karajan-code 4.51.1 → 4.53.0

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.

package/src/commands/hu.js

@@ -9,6 +9,8 @@ import { addHu, updateHuStatus } from "../plan/plan-hu-ops.js";
 import { generatePlanId } from "../plan/plan-id.js";
 import { savePlan, listPlans, loadPlan } from "../plan/plan-store.js";
 import { detectHostAgent } from "../utils/agent-detect.js";
+import { readIdentity } from "../identity/store.js";
+import { effectiveGitEmail } from "../identity/detect.js";
 
 // KJC-TSK-0661 (Jorge's friction): every HU records WHO created it — the
 // board must never show work nobody can trace. Host agent env → that agent;
@@ -58,7 +60,10 @@ export async function backlogPlan(projectDir) {
   return loadPlan(projectDir, planId);
 }
 
-export async function huCommand({ config = null, action, args = [], flags = {} }) {
+// KJC-TSK-1047 (TEAM-A): who works this clone, the one a started card is reserved to.
+const workerOf = (projectDir) => readIdentity(projectDir)?.gh_user || effectiveGitEmail(projectDir) || null;
+
+export async function huCommand({ config = null, action, args = [], flags = {}, deps = {} }) {
   const projectDir = config?.projectDir || process.cwd();
   const emit = (obj, human) => { console.log(flags.json ? JSON.stringify(obj) : human); return obj; };
 
@@ -79,12 +84,14 @@ export async function huCommand({ config = null, action, args = [], flags = {} }
           // the card. Older HUs predate the stamp: shown as "?".
           created_by: h.created_by || null, created_at: h.createdAt || null,
           external_ref: h.external_ref || null,
+          claimed_by: h.claimed_by || null, claimed_at: h.claimed_at || null,
         });
       }
     }
     if (flags.json) { console.log(JSON.stringify(rows)); return rows; }
     for (const r of rows) {
-      const suffixes = [r.created_at?.slice(0, 10), r.external_ref].filter(Boolean).map((s) => ` · ${s}`).join("");
+      const reserved = r.status === "running" && r.claimed_by ? `reserved by ${r.claimed_by}` : null;
+      const suffixes = [r.created_at?.slice(0, 10), r.external_ref, reserved].filter(Boolean).map((s) => ` · ${s}`).join("");
       const origin = `${r.plan} · by ${r.created_by || "?"}${suffixes}`;
       console.log(`${(r.short_id || r.id).padEnd(28)} ${r.status.padEnd(8)} ${r.title}  [${origin}]`);
     }
@@ -215,9 +222,23 @@ export async function huCommand({ config = null, action, args = [], flags = {} }
         + `a second concurrent task should live in its own lane: kj worktree start ${slug}`
       );
     }
+    // KJC-TSK-1047 (TEAM-A): a running card reserved by someone else moves only with --release.
+    const who = deps.who === undefined ? workerOf(projectDir) : deps.who;
+    const label = hu.short_id || hu.id;
+    // An unidentified caller is not the one who reserved it.
+    const takenOver = hu.status === "running" && hu.claimed_by && hu.claimed_by !== who;
+    if (takenOver && !flags.release) {
+      throw new Error(`${label} is reserved by ${hu.claimed_by} since ${hu.claimed_at} — releasing it is explicit: kj hu move ${ref} ${status} --release`);
+    }
+    const starting = status === "running" && hu.status !== "running";
+    // A running card nobody reserved is reserved by who moves it there again, once kj knows who.
+    const unclaimedRunning = status === "running" && !hu.claimed_by && who;
     updateHuStatus(plan, hu.id, status);
+    // Starting it, or releasing it to any status, rewrites the reservation: who did it, or nobody.
+    if (starting || takenOver || unclaimedRunning) Object.assign(hu, { claimed_by: who ?? null, claimed_at: who ? new Date().toISOString() : null });
+    if (starting && !who) console.warn(`⚠ ${label} is not reserved: kj cannot tell who works this clone — declare it with kj identity set`);
     await savePlan(projectDir, plan);
-    return emit({ id: hu.id, status }, `✓ ${hu.short_id || hu.id} → ${status}`);
+    return emit({ id: hu.id, status, claimed_by: hu.claimed_by ?? null }, `✓ ${label} → ${status}`);
   }
 
   throw new Error(`unknown action "${action}" — use: add | move | list`);

package/src/commands/identity.js

@@ -14,6 +14,7 @@ import { signAct } from "../harden/act-sign.js";
 import { enrollPhone, isPhoneEnrolled, readEnrolledKey, readEnrolledKeys, validatePhonePublicKey } from "../harden/phone-sign.js";
 import { admitSigner, redeemRecoveryCode } from "../harden/roster.js";
 import { phoneInvite } from "../harden/phone-invite.js";
+import { readSecurityLevel } from "../harden/security-level.js";
 import { humanAct } from "../harden/human-act.js";
 import { readIdentity, writeIdentity } from "../identity/store.js";
 import { activeGhUser, effectiveGitEmail } from "../identity/detect.js";
@@ -75,7 +76,9 @@ export async function identityCommand({ action = "show", config, kjVersion = "un
   // KJC-TSK-0986 (HUM-F): the once-per-version invitation to enroll the phone,
   // printed for the SessionStart hook (which cannot import kj) and for scripts.
   if (action === "phone-invite") {
-    const text = phoneInvite({ home: deps.home, version: flags.version });
+    // KJC-BUG-0360: the text depends on the level; at max (the default) the acts are refused.
+    const { level } = readSecurityLevel({ projectDir: deps.projectDir ?? process.cwd(), home: deps.home });
+    const text = phoneInvite({ home: deps.home, version: flags.version, level });
     if (text) log(text);
     return 0;
   }

package/src/commands/init.js

@@ -26,6 +26,7 @@ import { installQmd } from "../utils/qmd-install.js";
 import { registerQmdCollections } from "../utils/qmd-collection.js";
 import { isGitRepo } from "../harden/harden-engine.js";
 import { isPhoneEnrolled } from "../harden/phone-sign.js";
+import { identityCommand } from "./identity.js";
 import { hardenCommand } from "./harden.js";
 import { contractChanges } from "../environment/contract-commit.js";
 import { detectProjectStack } from "../utils/stack-detect.js";
@@ -300,7 +301,36 @@ export function tellPhoneStep(logger, { enrolled = isPhoneEnrolled() } = {}) {
   logger.info("  1. Open https://karajancode.com/sign on the phone: it creates a key pair and shows the PUBLIC key (the private one never leaves it).");
   logger.info("  2. From YOUR terminal, never from an agent session: kj identity enroll-phone <public key> --label <name>");
   logger.info("  3. Keep the recovery code it prints, off this machine: it replaces a lost phone (--recovery <code>).");
-  logger.info("  Prefer the four layers alone? kj security normal lowers the level, signed from the phone too (ADR 0018).");
+  logger.info("  Prefer the four layers alone? kj security normal lowers the level from your own terminal while no phone is enrolled (ADR 0020).");
+}
+
+/**
+ * KJC-TSK-1046 (ADR 0020): with a person at the terminal and no phone, init
+ * offers to enroll it now. The wizard only collects the public key: enrolling
+ * reads a typed code from /dev/tty, so it runs once the wizard is closed.
+ */
+export async function offerPhoneEnrollment(wizard, logger, { enrolled = isPhoneEnrolled() } = {}) {
+  if (enrolled) return null;
+  const now = await wizard.confirm("Enroll your phone now? (at the max level, seals and approvals are refused without it)", true);
+  const key = now ? String(await wizard.input("  Open https://karajancode.com/sign on the phone and paste the PUBLIC key it shows:", "")).trim() : "";
+  if (key) return key;
+  logger.info("  -> Phone: not now. Enroll it later from your own terminal: kj identity enroll-phone <public key> --label <name>");
+  return null;
+}
+
+const enrollThroughIdentity = (key) => identityCommand({ action: "enroll-phone", config: { projectDir: process.cwd() }, flags: { publicKeyBase64: key, label: os.hostname() } });
+
+/** Enrolls the key the wizard collected, with every check of the identity command; a failure is said and init goes on. */
+export async function enrollPendingPhone(key, { enroll = enrollThroughIdentity, logger }) {
+  if (!key) return false;
+  let reason = "see the message above";
+  try {
+    if ((await enroll(key)) === 0) return true;
+  } catch (err) {
+    reason = err.message;
+  }
+  logger.info(`  -> Phone not enrolled (${reason}). Try again from your own terminal: kj identity enroll-phone <public key>`);
+  return false;
 }
 
 /**
@@ -355,6 +385,7 @@ async function runWizard(config, logger) {
   logger.info("");
 
   const wizard = createWizard();
+  let pendingPhoneKey;
   try {
     const { coder, reviewer } = await askAgents(wizard, available, config, logger);
 
@@ -418,10 +449,12 @@ async function runWizard(config, logger) {
 
     logger.info("");
     tellPhoneStep(logger);
+    pendingPhoneKey = await offerPhoneEnrollment(wizard, logger);
     logger.info("");
   } finally {
     wizard.close();
   }
+  await enrollPendingPhone(pendingPhoneKey, { logger });
 
   return config;
 }

package/src/commands/plan/generate.js

@@ -232,6 +232,11 @@ async function planGenerateImpl({ task, config, logger, json, context, runLog, f
     // KJC-TSK-0661: provenance stamp (addHu builds its object explicitly,
     // so this goes on the returned reference, not in huData).
     hu.created_by = "planner";
+    // KJC-TSK-1061: the classification travels to the HU; validatePlan judges it (KJC-TSK-0717).
+    for (const key of ["change_class", "change_criterion", "hardens"]) {
+      const value = typeof step === "object" ? step[key] : null;
+      if (typeof value === "string" && value.trim()) hu[key] = value.trim();
+    }
     if (symbolicId) symbolicToHuId.set(symbolicId, hu.id);
     const deps = typeof step === "object" && Array.isArray(step.dependencies) ? step.dependencies : [];
     stepDeps.push(deps);

package/src/commands/plan/license.js

@@ -0,0 +1,35 @@
+/**
+ * kj plan license <planId> <huId> --module <path> (KJC-TSK-0717, SPD-A): scores
+ * the module with kj mutate and records the REWORK licence on the HU, with the
+ * threshold in force. validatePlan judges it again from the score.
+ */
+import { loadPlan, savePlan } from "../../plan/plan-store.js";
+import { licenseFor, DEFAULT_REWORK_MIN } from "../../plan/rework-license.js";
+import { mutateCommand } from "../mutate.js";
+
+/** The module's mutation score in percent, or null when kj mutate gives none. */
+async function scoreModule(projectDir, module) {
+  let report = null;
+  const logger = { info: (line) => { try { report = JSON.parse(line); } catch { /* a progress line */ } } };
+  await mutateCommand({ projectDir, path: module, json: true, maxSurvivors: Number.POSITIVE_INFINITY, logger });
+  return Number.isFinite(report?.score) ? report.score : null;
+}
+
+export async function planLicenseCommand({ config, planId, huId, module, deps = {} }) {
+  const say = deps.say ?? console.log;
+  const projectDir = config.projectDir || process.cwd();
+  if (!module) { say("kj plan license: --module <path> is required (the module the REWORK regenerates)"); return 1; }
+  const plan = await (deps.loadPlan ?? loadPlan)(projectDir, planId);
+  if (!plan) { say(`Plan not found: ${planId}`); return 1; }
+  const hu = plan.hus?.find((h) => h.id === huId);
+  if (!hu) { say(`HU not found: ${huId}`); return 1; }
+  const score = await (deps.scoreModule ?? scoreModule)(projectDir, module);
+  if (score === null) { say(`kj mutate could not score ${module}: no licence recorded (run kj mutate ${module} to see why)`); return 1; }
+  const threshold = config?.method_gates?.rework_mutation_min ?? DEFAULT_REWORK_MIN;
+  hu.rework_license = licenseFor({ module, score, threshold });
+  await (deps.savePlan ?? savePlan)(projectDir, plan);
+  const pct = `${Math.round(threshold * 100)}%`;
+  if (hu.rework_license.granted) { say(`✓ REWORK licence granted for ${module} on ${huId}: mutation score ${score}% at or over ${pct}`); return 0; }
+  say(`✗ REWORK licence denied for ${module} on ${huId}: mutation score ${score}% under ${pct}. Plan two phases: add an HU with hardens: ${module} (kill the survivors first) and put it in ${huId}'s blocked_by`);
+  return 1;
+}

package/src/commands/plan/ready.js

@@ -10,7 +10,7 @@ export async function planReadyCommand({ config, planId }) {
   const plan = await loadPlan(projectDir, planId);
   if (!plan) { console.error(`Plan not found: ${planId}`); process.exitCode = 1; return; }
 
-  const validation = validatePlan(plan);
+  const validation = validatePlan(plan, { reworkMin: config?.method_gates?.rework_mutation_min });
   if (!validation.valid) {
     console.error("Plan validation failed:");
     for (const err of validation.errors) console.error(`  - ${err}`);

package/src/commands/plan/validate.js

@@ -9,7 +9,7 @@ export async function planValidateCommand({ config, planId }) {
   const plan = await loadPlan(projectDir, planId);
   if (!plan) { console.error(`Plan not found: ${planId}`); process.exitCode = 1; return; }
 
-  const result = validatePlan(plan);
+  const result = validatePlan(plan, { reworkMin: config?.method_gates?.rework_mutation_min });
   if (result.valid) {
     console.log(`✅ Plan ${planId} is valid (${plan.hus.length} HUs, status: ${plan.status})`);
   } else {

package/src/commands/report.js

@@ -4,6 +4,8 @@ import { exists } from "../utils/fs.js";
 import { getSessionRoot } from "../utils/paths.js";
 import { loadConfig } from "../config.js";
 import { DEFAULTS } from "../config/defaults.js";
+import { listPlans, loadPlan } from "../plan/plan-store.js";
+import { formatModelTally, modelTally } from "../report/model-tally.js";
 
 function parseBudgetFromActivityLog(logText) {
   if (!logText) {
@@ -269,6 +271,18 @@ async function printSentinelEscapes({ projectDir = process.cwd(), format } = {})
       console.log(tally);
     }
   } catch { /* no decision log — no panel to tally */ }
+  // KJC-TSK-1057 (MR-E2): what each coder model cost and how often it failed first time.
+  try {
+    const hus = [];
+    for (const meta of await listPlans(projectDir)) hus.push(...((await loadPlan(projectDir, meta.planId))?.hus ?? []));
+    const tally = formatModelTally(modelTally(hus));
+    if (tally) {
+      console.log("");
+      console.log(tally);
+    }
+  } catch (err) {
+    console.log(`\nCoder models: the plans could not be read (${err.message})`);
+  }
 }
 
 function formatDuration(ms) {

package/src/commands/review-gate.js

@@ -29,6 +29,9 @@ import { checkStagedDiff, loadPolicy } from "../policy/engine.js";
 import { loadStandingExceptions, recordPolicyException } from "../policy/exceptions.js";
 import { policyFileHash, recordGateDecision } from "../policy/decisions.js";
 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";
 
 // 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
@@ -111,11 +114,12 @@ export const formatExempted = (e) => (e.standing
   ? `⚠ policy standing [${e.rule_id}] — excepción permanente${e.standing.origin === "global" ? " GLOBAL" : ""} viva hasta ${e.standing.expiresAt} (${e.standing.justification || "sin justificación"})`
   : `⚠ policy exempt [${e.rule_id}] — excepción registrada en .karajan/policy-exceptions.jsonl (${e.justification})`);
 
-function printVerdict(record) {
+function printVerdict(record, rounds = 0) {
   if (record.verdict === "approved") {
     const ws = record.workspace ? ` [${record.workspace}]` : "";
     console.log(`✓ APPROVED by ${record.reviewer} (diff ${record.diffHash.slice(0, 12)})${ws}`);
     if (record.summary) console.log(`  ${record.summary}`);
+    if (rounds > 0) console.log(`  ${correctionNote(rounds)}`);
     return;
   }
   console.log(`✗ REJECTED by ${record.reviewer} — ${record.issues.length} blocking issue(s):`);
@@ -576,8 +580,28 @@ export async function reviewGateCommand({ config, logger = null, flags = {} }) {
     }
   }
 
+  // KJC-TSK-1052 (TEAM-F): another branch in progress touching the same files is said, never blocks.
+  if (flags.staged && !flags.range) {
+    for (const line of formatOverlaps(await branchOverlaps({ projectDir, stagedFiles: changedFiles, base: config?.base_branch || "main" }))) console.log(line);
+  }
+
+  // KJC-TSK-0722: a dependency published under the cooldown is said, and weighed by the reviewer.
+  const cooldownHours = config?.supply_chain?.cooldown_hours ?? DEFAULT_COOLDOWN_HOURS;
+  const cooldownResult = await cooldownAdvisories(diff, { thresholdHours: cooldownHours });
+  const cooldown = formatCooldown(cooldownResult, cooldownHours);
+  for (const line of cooldown.lines) console.log(line);
+  // KJC-TSK-1056: method_gates.dep_cooldown: block stops it here, before any reviewer token.
+  const cooldownStop = cooldownGate({ result: cooldownResult, mode: config?.method_gates?.dep_cooldown, standingExceptions: std.standing });
+  if (cooldownStop.grant) console.log(`⚠ dep_cooldown lifted by a HUMAN grant [method.dep_cooldown] until ${cooldownStop.grant.expiresAt}`);
+  if (cooldownStop.block) {
+    console.log(`✗ ${cooldownStop.reason}`);
+    process.exitCode = 1;
+    return { verdict: "rejected", reviewer: "dep-cooldown", issues: cooldownResult.young.map((p) => ({ severity: "high", description: `${p.name}@${p.version} published ${p.hours} h ago` })) };
+  }
+  if (cooldown.note) task = `${task || "Review the following diff for correctness, security and maintainability."}\n\n${cooldown.note}`;
+
   const record = await runOneShotReview({ diff, task, config, logger, projectDir, sonar: sonarRecord, rag: ragRecord, ui: uiRecord });
-  printVerdict(record);
+  printVerdict(record, record.verdict === "approved" ? await reviewCorrectionRounds(projectDir, record) : 0);
   process.exitCode = record.verdict === "approved" ? 0 : 1;
   return record;
 }

package/src/commands/worktree.js

@@ -11,13 +11,15 @@ import path from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { bootstrapWorktree } from "../hu/worktree-bootstrap.js";
+import { classifyLanes, liveProcesses, looseLaneBranches, resolveBase } from "../hu/lane-prune.js";
+import { recordGateDecision } from "../policy/decisions.js";
 
 const execFileAsync = promisify(execFile);
 const WORKTREE_DIR = ".kj/worktrees"; // shared with the headless lanes
 
 const SLUG_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 
-export async function worktreeCommand({ config = null, action, args = [], flags = {} }) {
+export async function worktreeCommand({ config = null, action, args = [], flags = {}, deps = {} }) {
   const projectDir = config?.projectDir || process.cwd();
   const git = (gitArgs, cwd = projectDir) => execFileAsync("git", gitArgs, { cwd });
   const lanePath = (slug) => path.join(projectDir, WORKTREE_DIR, slug);
@@ -72,5 +74,36 @@ export async function worktreeCommand({ config = null, action, args = [], flags
     return { removed: true, slug };
   }
 
-  throw new Error(`unknown action "${action}" — use: start | list | done`);
+  if (action === "prune") {
+    const { processes = liveProcesses() } = deps;
+    const base = await resolveBase({ git, base: config?.base_branch || "main" });
+    const lanes = await classifyLanes({ git, laneRoot: path.join(projectDir, WORKTREE_DIR), base, processes, now: deps.now });
+    const abandoned = lanes.filter((l) => l.reasons.length === 0);
+    const kept = lanes.filter((l) => l.reasons.length > 0);
+    for (const l of kept) console.log(`kept    ${l.slug.padEnd(24)} ${l.reasons.join("; ")}`);
+    if (lanes.length === 0) console.log("no kj lanes");
+    // KJC-TSK-1037: loose kj-hu-* branches of old runs, measured against the same base.
+    const { empty: branches, withWork } = await looseLaneBranches({ git, base });
+    for (const b of withWork) console.log(`kept    branch ${b.branch.padEnd(17)} ${b.reason}`);
+    if (flags.dryRun) {
+      for (const l of abandoned) console.log(`would retire ${l.slug} (${l.branch ?? "detached"})`);
+      for (const b of branches) console.log(`would delete branch ${b}`);
+      return { wouldRemove: abandoned, kept, wouldRemoveBranches: branches, branchesKept: withWork };
+    }
+    for (const b of branches) {
+      await git(["branch", "-D", b]);
+      console.log(`✓ deleted branch ${b}`);
+    }
+    for (const l of abandoned) {
+      await git(["worktree", "remove", l.path]);
+      if (l.branch) await git(["branch", "-D", l.branch]);
+      console.log(`✓ retired ${l.slug} (${l.branch ?? "detached"})`);
+    }
+    if (abandoned.length > 0 || branches.length > 0) {
+      recordGateDecision(projectDir, { decision: "allow", chokepoint: "tool", kind: "worktree-prune", lanes: abandoned.map((l) => l.slug), branches });
+    }
+    return { removed: abandoned, kept, branchesRemoved: branches, branchesKept: withWork };
+  }
+
+  throw new Error(`unknown action "${action}" — use: start | list | done | prune`);
 }

package/src/config/defaults.js

@@ -90,8 +90,17 @@ const DEFAULTS = {
     // the turn's final message against that turn's tool outputs. "off" (adoption
     // is explicit) | "warn" (report only) | "block" (a datum DENIED by its own
     // source refuses to end the turn; unbacked data is still only reported).
-    claims: "off"
+    claims: "off",
+    // KJC-TSK-0717 (SPD-A): the module mutation score a REWORK needs (0.8 = 80 %).
+    rework_mutation_min: 0.8,
+    // KJC-TSK-1056: a dependency published under supply_chain.cooldown_hours
+    // ago: "warn" (said in kj review) | "block" (stops the review; a human
+    // grant on method.dep_cooldown lifts it). Unverifiable ones never block.
+    dep_cooldown: "warn"
   },
+  // KJC-TSK-0719 (SPD-C): kj check says the audit is due after this many
+  // distinct cards or work commits since the last scored audit.
+  audit_cycle: { every_cards: 10, every_commits: 60 },
   review_rules: "./.karajan/review-rules.md",
   coder_rules: "./.karajan/coder-rules.md",
   base_branch: "main",

package/src/config/overrides.js

@@ -17,6 +17,7 @@
 import { mergeDeep } from "./loader.js";
 import { DEFAULTS } from "./defaults.js";
 import { safeParseConfig, formatConfigIssues } from "./schema.js";
+import { applyModelProfile } from "../utils/model-selector.js";
 
 const ROLE_PROVIDER_FLAGS = [
   ["planner", "planner"], ["coder", "coder"], ["reviewer", "reviewer"],
@@ -99,6 +100,13 @@ function applyRoleOverrides(out, flags) {
   }
   // reviewerModel also updates reviewer_options
   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;
+  if (profile) {
+    applyModelProfile(out, String(profile));
+    out.model_profile = String(profile);
+  }
 }
 
 function applyPipelineOverrides(out, flags) {

package/src/config/schema.js

@@ -242,6 +242,8 @@ export const ConfigSchema = v.looseObject({
   ))),
   // ENV-D1 (KJC-TSK-0642): where work items live — the integrated HU Board
   // or the user's Planning Game. The v4 playbook renders per backend.
+  // KJC-TSK-0699 (MR-B): the default model profile; kj run --profile overrides it.
+  model_profile: v.optional(v.picklist(["frugal", "standard", "deep"], "model_profile must be frugal, standard or deep")),
   state_backend: v.optional(v.picklist(
     // KJC-TSK-0709 caught the drift: "external" shipped in v4.5.0 (any
     // board via the agent's own MCP/tools) but this picklist never learned it.
@@ -249,6 +251,11 @@ export const ConfigSchema = v.looseObject({
     "state_backend must be \"hu-board\", \"planning-game\" or \"external\""
   )),
   review_rules: v.optional(v.string()),
+  // KJC-TSK-0719 (SPD-C): kj check says the audit is due past these counts.
+  audit_cycle: v.optional(v.looseObject({
+    every_cards: v.optional(PositiveInt),
+    every_commits: v.optional(PositiveInt),
+  })),
   coder_rules: v.optional(v.string()),
   base_branch: v.optional(v.string()),
   coder_options: CoderOptions,

package/src/environment/playbook.js

@@ -70,6 +70,8 @@ Invariants (the git gates enforce these — they are not suggestions):
 - Every diff is reviewed by a DIFFERENT AI before it is committed
   (\`kj review --staged\`): verdicts bind to the exact diff — change the code
   and it must be reviewed again. Disagree with a rejection? \`kj solomon\`.
+  A correction from the other AI is the method working: apply it and move
+  on, no apology, and never report it as your mistake.
 ${panel ? `${panel}\n` : ""}- Security findings are never overridable — not even by arbitration. You
   absorb the security role: \`kj brief security\` states what must be true.
   Task touches auth, user input, secrets, network or deps? Run

package/src/harden/act-sign.js

@@ -10,7 +10,7 @@
 import { basename } from "node:path";
 
 import { humanActOf } from "./human-act.js";
-import { PHONE_INVITE } from "./phone-invite.js";
+import { PHONE_ENROLL, PHONE_INVITE } from "./phone-texts.js";
 import { isPhoneEnrolled, requestPhoneSignature } from "./phone-sign.js";
 import { readSecurityLevel } from "./security-level.js";
 
@@ -53,7 +53,7 @@ export async function signAct(id, { projectDir, home, kjVersion, files, changes
   const phone = deps.phone ?? { enrolled: isPhoneEnrolled, request: requestPhoneSignature };
   if (!phone.enrolled({ home })) {
     if (level.level === "max" && !bootstrap) {
-      throw new Error(`${act.label}: con seguridad máxima este acto se firma con el móvil y no hay ninguno enrolado. ${PHONE_INVITE}`);
+      throw new Error(`${act.label}: con seguridad máxima este acto se firma con el móvil y no hay ninguno enrolado. ${PHONE_ENROLL}`);
     }
     logger.warn?.(`${act.label}: sin móvil enrolado solo valen las cuatro capas y la garantía es menor (ADR 0018). ${PHONE_INVITE}`);
     return { level, signature: null };

package/src/harden/branch-protection.js

@@ -0,0 +1,97 @@
+/**
+ * KJC-TSK-0928 (M15-B): the method's CI checks become required on the base
+ * branch, where no agent reaches. Branch protection needs admin rights, so kj
+ * never applies it: it reads what is there and says the exact command.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { parse as parseYaml } from "yaml";
+import { runCommand } from "../utils/process.js";
+
+// Scheduled or advisory kj workflows: they never block a PR, so they are never required.
+const NOT_REQUIRED = new Set(["kj-mutation.yml", "kj-steward.yml"]);
+
+/** The GitHub check name of each job: its `name:` when it has one, its id otherwise. */
+function jobChecks(text) {
+  const jobs = parseYaml(text)?.jobs ?? {};
+  return Object.entries(jobs).map(([id, job]) => (typeof job?.name === "string" ? job.name : id));
+}
+
+/** The checks kj harden's own workflows publish, from the files installed in the repo. */
+export function requiredChecksFrom(projectDir) {
+  const dir = path.join(projectDir, ".github", "workflows");
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir)
+    .filter((f) => /^kj-.*\.ya?ml$/.test(f) && !NOT_REQUIRED.has(f))
+    .toSorted()
+    .flatMap((f) => jobChecks(fs.readFileSync(path.join(dir, f), "utf8")));
+}
+
+const shellQuote = (value) => `'${String(value).replaceAll("'", "'\\''")}'`;
+
+// A base branch such as release/1.0 is one path segment of the REST endpoint.
+const protectionPath = ({ owner, repo, branch }) => `repos/${owner}/${repo}/branches/${encodeURIComponent(branch)}/protection`;
+
+function protectCommand({ checks, ...target }) {
+  const contexts = checks.map((c) => `-f ${shellQuote(`required_status_checks[contexts][]=${c}`)}`).join(" ");
+  return `gh api -X PUT ${protectionPath(target)} -F 'required_status_checks[strict]=false' ${contexts} -F enforce_admins=false -F required_pull_request_reviews=null -F restrictions=null -F allow_force_pushes=false`;
+}
+
+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`;
+
+/**
+ * What the base branch needs for the checks to be required, and how. A command
+ * is given only when it cannot undo anything: the full PUT for a branch with no
+ * protection at all, the additive contexts call otherwise. Protection without
+ * status checks, or unreadable, gets the settings page: a PUT there would wipe
+ * the reviews and restrictions already set. Never applies anything, never throws.
+ * @returns {Promise<{status: "ok"|"missing"|"unprotected"|"no-checks"|"unverified", command?: string, settings?: string, missing?: string[], reason?: string}>}
+ */
+export async function protectionAdvice({ owner, repo, branch, checks, run = runCommand }) {
+  const target = { owner, repo, branch };
+  let res;
+  try {
+    res = await run("gh", ["api", protectionPath(target)]);
+  } catch (err) {
+    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 }) };
+    return { status: "unverified", reason: (res.stderr || res.stdout || "gh failed").trim(), settings: settingsUrl(target), missing: checks };
+  }
+  const statusChecks = JSON.parse(res.stdout || "{}").required_status_checks;
+  if (!statusChecks) return { status: "no-checks", settings: settingsUrl(target), missing: checks };
+  const existing = new Set(statusChecks.contexts ?? []);
+  const missing = checks.filter((c) => !existing.has(c));
+  return missing.length === 0 ? { status: "ok" } : { status: "missing", missing, command: addCommand({ ...target, missing }) };
+}
+
+// Owner and repo go into a command an admin copies: only the characters GitHub allows in them.
+const GITHUB_REMOTE = /github\.com[^:/]*[:/]([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?$/;
+
+/** kj harden's last step: on a GitHub remote, what the base branch needs and who runs it. */
+export async function adviseBranchProtection({ projectDir, branch, logger, run = runCommand }) {
+  const checks = requiredChecksFrom(projectDir);
+  if (checks.length === 0) return null;
+  const remote = await run("git", ["-C", projectDir, "remote", "get-url", "origin"]).catch(() => null);
+  const match = remote?.exitCode === 0 ? GITHUB_REMOTE.exec(remote.stdout.trim()) : null;
+  if (!match) return null;
+  const advice = await protectionAdvice({ owner: match[1], repo: match[2], branch, checks, run });
+  if (advice.status === "ok") {
+    logger.info?.(`  • branch protection: ${branch} requires the ${checks.length} kj check(s)`);
+    return advice;
+  }
+  const list = advice.missing?.join(", ");
+  const why = {
+    unprotected: `${branch} is not protected: the method's checks do not stop a merge. An admin runs (kj never does):`,
+    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:`,
+  }[advice.status];
+  logger.warn?.(`  ⚠ branch protection: ${why}`);
+  logger.warn?.(`      ${advice.command ?? advice.settings}`);
+  return advice;
+}

package/src/harden/phone-invite.js

@@ -10,10 +10,11 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 
 import { isPhoneEnrolled } from "./phone-sign.js";
+import { phoneTextFor } from "./phone-texts.js";
+import { readSecurityLevel } from "./security-level.js";
 import { STRATEGY } from "../checks/types.js";
 
-export const PHONE_INVITE =
-  "El móvil no está enrolado: los sellos (kj harden --commit), las aprobaciones y los comandos del catálogo se firman hoy con un código tecleado, con menos garantía. Enrólalo con kj identity enroll-phone <clave pública de la app>: cada acto queda atado a tu clave privada, que nunca sale del móvil (ADR 0018).";
+export { PHONE_ENROLL, PHONE_INVITE, PHONE_REFUSED_AT_MAX } from "./phone-texts.js";
 
 const markerPath = (home) => join(home ?? homedir(), ".karajan", "phone-invite.json");
 
@@ -21,10 +22,10 @@ const markerPath = (home) => join(home ?? homedir(), ".karajan", "phone-invite.j
  * The invitation, once per kj version, or null (phone enrolled, or already said
  * for this version). Saying it records it; a marker that cannot be written
  * never silences the invitation.
- * @param {{home?: string, version?: string}} [opts]
+ * @param {{home?: string, version?: string, level?: "max"|"normal"}} [opts]
  * @returns {string|null}
  */
-export function phoneInvite({ home, version = "unknown" } = {}) {
+export function phoneInvite({ home, version = "unknown", level = "max" } = {}) {
   if (isPhoneEnrolled({ home })) return null;
   let seen = null;
   try { seen = JSON.parse(readFileSync(markerPath(home), "utf8")).version; } catch { /* never invited */ }
@@ -33,11 +34,16 @@ export function phoneInvite({ home, version = "unknown" } = {}) {
     mkdirSync(dirname(markerPath(home)), { recursive: true });
     writeFileSync(markerPath(home), `${JSON.stringify({ version, at: new Date().toISOString() })}\n`, "utf8");
   } catch { /* the invitation still goes out */ }
-  return PHONE_INVITE;
+  return phoneTextFor(level);
 }
 
-/** `kj doctor`: WARN while the phone is not enrolled, with the same text. */
-export function createPhoneCheck({ home } = {}) {
+const projectLevel = (projectDir, home) => readSecurityLevel({ projectDir, home }).level;
+
+/**
+ * `kj doctor`: without a phone, a FAILURE at the max level (the default, where
+ * the acts are refused) and a warning at the normal level (KJC-BUG-0360).
+ */
+export function createPhoneCheck({ home, projectDir = process.cwd(), readLevel = () => projectLevel(projectDir, home) } = {}) {
   return {
     name: "phone-enrolled",
     label: "móvil enrolado (firma de sellos y aprobaciones)",
@@ -45,7 +51,8 @@ export function createPhoneCheck({ home } = {}) {
     describe: "Whether a phone's public key is enrolled for the supervisor seal and approvals (ADR 0018)",
     async detect() {
       if (isPhoneEnrolled({ home })) return { ok: true, severity: "info", detail: "clave pública en ~/.karajan/supervisor-phone.json" };
-      return { ok: false, severity: "warn", detail: PHONE_INVITE, fix: "kj identity enroll-phone <clave pública de la app>" };
+      const level = await readLevel();
+      return { ok: false, severity: level === "normal" ? "warn" : "fail", detail: phoneTextFor(level), fix: "kj identity enroll-phone <clave pública de la app>" };
     },
   };
 }