karajan-code 4.28.1 → 4.28.2

package/README.md

@@ -41,7 +41,29 @@ This repo runs under its own environment: every commit to karajan-code carries a
 
 ## Install
 
-Tell your agent — in the directory where you want to work:
+Two ways in — pick your comfort level.
+
+### Maggle mode — you never touch the terminal
+
+Not a developer, or you just want it running? Paste this into your AI assistant (Claude Code, Codex, Cursor, VS Code):
+
+```text
+Set up Karajan in this project and start it for me: read
+https://karajancode.com/go.md and do everything it says. I'm not a developer —
+don't ask me technical questions, just get it running and tell me when it's ready.
+```
+
+It installs Karajan, prepares the project, and opens a single window with the board and your agent inside — stopping only if a step truly needs you (sudo or an account). Already installed? One command:
+
+```sh
+kj go            # or: kj go --window  (the agent's terminal embedded in the board)
+```
+
+`kj go` detects your agent (asks which only if you have several), prepares the project silently the first time, and drops you into a conversation that already follows the method. Your agent account and login stay yours — kj never touches credentials.
+
+### Developer mode — you stay in control
+
+Want your agent to walk each step and stop at every permission? Paste:
 
 ```text
 I want to use Karajan in this project: read https://karajancode.com/start.md
@@ -59,14 +81,6 @@ kj init && kj env install && kj harden && kj review --install-gate
 git config core.hooksPath .karajan/hooks
 ```
 
-Already installed and just want to work — even with no computing background? One command:
-
-```sh
-kj go
-```
-
-It detects your agent (Claude Code or Codex; asks which one only if you have both), prepares the project silently the first time, opens the board in your browser, and drops you into a conversation that already follows the method. Your agent account and login stay yours — kj never touches credentials. Prefer everything in ONE browser window? `kj go --window` embeds the agent's real terminal inside the board (loopback-only, single-session token).
-
 Requires git and at least one AI agent CLI — two enables cross-AI review; three enables arbitration. The npm route is `npm install -g @karajan-family/code` (published as `karajan-code` before joining the scope; the legacy name still installs the same versions). All install routes (npm, binaries, brew, Python wrapper) in the [install docs](https://karajancode.com/docs/v4/install/).
 
 ## The daily loop

package/package.json

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

package/scripts/verify-pack.mjs

@@ -33,8 +33,25 @@ const pkgName = pkg.name;
 
 // Subprocess env: strip CLAUDECODE (Claude Code blocks nested non-interactive
 // runs otherwise) and force a non-interactive, quiet npm.
+// KJC-BUG-0171: the tarball's postinstall registers karajan-mcp in
+// ~/.claude.json / ~/.codex / ~/.karajan pointing at THIS install's path. Every
+// verify install lives in a throwaway prefix, so those paths go stale the moment
+// the temp dir is cleaned — a CONNECTION_CLOSED MCP left in the real user config.
+// Redirect HOME so every global-config write lands in an isolated dir removed
+// with the rest; seed a git identity so any commit still works without ~/.gitconfig.
+const homeTmp = fs.mkdtempSync(path.join(os.tmpdir(), "kj-verify-home-"));
 const { CLAUDECODE: _omit, ...cleanEnv } = process.env;
-const childEnv = { ...cleanEnv, npm_config_yes: "true", CI: "1" };
+const childEnv = {
+  ...cleanEnv,
+  npm_config_yes: "true",
+  CI: "1",
+  HOME: homeTmp,
+  USERPROFILE: homeTmp,
+  GIT_AUTHOR_NAME: "kj verify",
+  GIT_AUTHOR_EMAIL: "verify@kj.local",
+  GIT_COMMITTER_NAME: "kj verify",
+  GIT_COMMITTER_EMAIL: "verify@kj.local",
+};
 
 function run(cmd, args, opts = {}) {
   return execFileSync(cmd, args, {
@@ -271,6 +288,7 @@ try {
   console.log(`\n✓ verify-pack: ${pkgName}@${expectedVersion} installs clean and runs.`);
 } finally {
   if (tgzPath && fs.existsSync(tgzPath)) fs.rmSync(tgzPath, { force: true });
+  if (homeTmp && fs.existsSync(homeTmp)) fs.rmSync(homeTmp, { recursive: true, force: true });
   if (tmpDir && fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true, force: true });
   if (gTmp && fs.existsSync(gTmp)) fs.rmSync(gTmp, { recursive: true, force: true });
   if (pnpmTmp && fs.existsSync(pnpmTmp)) fs.rmSync(pnpmTmp, { recursive: true, force: true });

package/src/checks/config-files.js

@@ -8,9 +8,11 @@
  *     ~/.karajan/kj.config.yml (strategy: manual — structural fixes needed)
  */
 
+import { existsSync } from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { exists } from "../utils/fs.js";
 import { getConfigPath } from "../config.js";
 import { resolveRoleMdPath, loadFirstExisting } from "../roles/base-role.js";
@@ -132,6 +134,89 @@ function createClaudeConfigCheck() {
   };
 }
 
+/**
+ * KJC-BUG-0171: the karajan-mcp server path registered in ~/.claude.json.
+ * Returns the args entry that points at the MCP server (…/mcp/server.js), or
+ * null when karajan-mcp is not registered.
+ */
+export function karajanMcpServerPath(config) {
+  const server = config?.mcpServers?.["karajan-mcp"];
+  const args = Array.isArray(server?.args) ? server.args : [];
+  return args.find((a) => typeof a === "string" && /[\\/]mcp[\\/]server\.js$/.test(a)) ?? null;
+}
+
+/**
+ * Repair a stale karajan-mcp registration in place: re-point it to this
+ * install's server when that server exists, or drop the dead entry when this
+ * install has no bundled server (the standalone binary). `serverExists` is
+ * injectable for tests. Mutates `config`; returns "repointed" | "removed" | null.
+ */
+export function repairKarajanMcpPath(config, correctServerPath, serverExists) {
+  const server = config?.mcpServers?.["karajan-mcp"];
+  if (!server) return null;
+  if (correctServerPath && serverExists(correctServerPath)) {
+    server.args = [correctServerPath];
+    server.cwd = path.resolve(path.dirname(correctServerPath), "..", "..");
+    return "repointed";
+  }
+  delete config.mcpServers["karajan-mcp"];
+  return "removed";
+}
+
+/**
+ * karajan-mcp registration path validity (~/.claude.json) — KJC-BUG-0171.
+ * A verify/temp install used to register the MCP at a throwaway prefix; once
+ * cleaned, the path 404s and every session's MCP fails with CONNECTION_CLOSED,
+ * and the health check never caught it (it spawns its OWN bundled server).
+ */
+function createStaleMcpPathCheck() {
+  return {
+    name: "agent-config:karajan-mcp-path",
+    label: "MCP registration path (~/.claude.json)",
+    // KJC-BUG-0172: AUTO, not PROMPT — the runner never remediates a WARN
+    // check whose strategy is PROMPT, so the repair was inert under `kj doctor
+    // -y`. Re-pointing a dead entry to the current server (or dropping it) is
+    // deterministic and reversible on an already-broken entry; `--check-only`
+    // stays available to detect without touching the config.
+    strategy: STRATEGY.AUTO,
+    describe: "Re-point karajan-mcp in ~/.claude.json to this install's server (or drop a dead entry)",
+    async detect() {
+      const claudeJsonPath = path.join(os.homedir(), ".claude.json");
+      let config;
+      try {
+        config = JSON.parse(await fs.readFile(claudeJsonPath, "utf8"));
+      } catch {
+        return { ok: true, severity: "info", detail: "Not present or unparseable (skipped)" };
+      }
+      const registered = karajanMcpServerPath(config);
+      if (!registered) return { ok: true, severity: "info", detail: "karajan-mcp not registered (skipped)" };
+      if (await exists(registered)) return { ok: true, severity: "info", detail: "karajan-mcp path valid" };
+      const correct = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "mcp", "server.js");
+      return {
+        ok: false,
+        severity: "warn",
+        detail: `karajan-mcp points at a path that no longer exists: ${registered} — this is the CONNECTION_CLOSED cause`,
+        fix: `Re-point karajan-mcp to ${correct} (or remove the entry) in ~/.claude.json`,
+        extra: { claudeJsonPath, correct },
+      };
+    },
+    async remediate({ extra }) {
+      try {
+        const config = JSON.parse(await fs.readFile(extra.claudeJsonPath, "utf8"));
+        const action = repairKarajanMcpPath(config, extra.correct, existsSync);
+        if (!action) return { fixed: false, detail: "karajan-mcp entry vanished before repair" };
+        await fs.writeFile(extra.claudeJsonPath, `${JSON.stringify(config, null, 2)}\n`);
+        return {
+          fixed: true,
+          detail: action === "repointed" ? `Re-pointed karajan-mcp to ${extra.correct}` : "Removed the dead karajan-mcp entry",
+        };
+      } catch (err) {
+        return { fixed: false, detail: `Failed to repair ~/.claude.json: ${err.message}` };
+      }
+    },
+  };
+}
+
 /**
  * Codex config (~/.codex/config.toml) validity.
  */
@@ -211,6 +296,7 @@ export function getConfigFileChecks() {
     createReviewRulesCheck(),
     createCoderRulesCheck(),
     createClaudeConfigCheck(),
+    createStaleMcpPathCheck(),
     createCodexConfigCheck(),
     createKjConfigYamlCheck(),
   ];

package/src/cli/register-pipeline.js

@@ -234,12 +234,15 @@ export function registerPipeline(program, { pkgVersion }) {
     .option("--check", "Verify the recorded verdict matches the staged diff (exit 0/1, hook-friendly)")
     .option("--range <range>", "Review a git range (e.g. main..HEAD) instead of the staged diff")
     .option("--install-gate", "Enable the pre-commit review gate for this project (creates .karajan/review-gate)")
+    .option("--prune", "Garbage-collect verdicts in .karajan/reviews older than the TTL (they age out as diffs change)")
+    .option("--prune-days <n>", "TTL in days for --prune (default: 14)")
+    .option("--dry-run", "With --prune: report what would be removed without deleting")
     .option("--no-sonar", "Skip the deterministic Sonar pre-gate that runs before the cross-AI verdict")
     .action(async (task, flags) => {
       await withConfig(pkgVersion, "review", flags, async ({ config, logger }) => {
         // 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) {
+        if (flags.staged || flags.check || flags.range || flags.installGate || flags.prune) {
           await reviewGateCommand({ config, logger, flags: { ...flags, task } });
           return;
         }

package/src/commands/identity.js

@@ -8,7 +8,7 @@
  *           no session and no flags → exit 1.
  */
 
-import { enrollPhone } from "../harden/phone-sign.js";
+import { addSigner, enrollPhone } from "../harden/phone-sign.js";
 import { readIdentity, writeIdentity } from "../identity/store.js";
 import { activeGhUser, effectiveGitEmail } from "../identity/detect.js";
 import { compareIdentity } from "../identity/compare.js";
@@ -27,12 +27,15 @@ export async function identityCommand({ action = "show", config, flags = {}, dep
   // KJC-TSK-0822: enrola la clave PÚBLICA del móvil (la privada nunca toca esta máquina).
   if (action === "enroll-phone") {
     try {
+      // KJC-TSK-0831 (ADR 0010): añade al PADRÓN versionado del repo (compartible,
+      // base para la verificación en CI) y mantiene la clave legacy en ~/.karajan.
+      addSigner(flags.publicKeyBase64, { projectDir, label: flags.label });
       enrollPhone(flags.publicKeyBase64, { home: deps.home });
     } catch (err) {
       log(`kj identity enroll-phone: ${err.message}`);
       return 1;
     }
-    log("Móvil enrolado: la clave pública quedó en ~/.karajan/supervisor-phone.json. A partir de ahora, sellar el supervisor pedirá la firma de tu móvil.");
+    log("Móvil enrolado: la clave pública se añadió al padrón .karajan/supervisor-signers.json (commítealo) y a ~/.karajan/supervisor-phone.json. Sellar el supervisor pedirá la firma de un móvil del padrón.");
     return 0;
   }
 

package/src/commands/review-gate.js

@@ -8,7 +8,7 @@
 import { existsSync } from "node:fs";
 import { isAbsolute, join } from "node:path";
 import { runCommand } from "../utils/process.js";
-import { checkVerdict, diffHash } from "../review/verdict-store.js";
+import { checkVerdict, diffHash, pruneVerdicts } from "../review/verdict-store.js";
 import { runOneShotReview } from "../review/one-shot-review.js";
 import { runSolomonArbitration } from "../review/solomon-arbitration.js";
 import { ensureGateTrackable } from "../review/gate-gitignore.js";
@@ -144,6 +144,21 @@ export async function reviewGateCommand({ config, logger = null, flags = {} }) {
     return { installed: true };
   }
 
+  // KJC-BUG-0173: manual GC of the verdict store. Opportunistic pruning runs
+  // on every saved verdict; this lets a human sweep on demand, with --dry-run
+  // to see what would go without deleting.
+  if (flags.prune) {
+    const dryRun = Boolean(flags.dryRun || flags.checkOnly);
+    const days = Number(flags.pruneDays);
+    const res = await pruneVerdicts({ projectDir, dryRun, ...(Number.isFinite(days) && days > 0 ? { maxAgeDays: days } : {}) });
+    console.log(
+      dryRun
+        ? `kj review --prune (dry run): ${res.expired.length} of ${res.scanned} verdict(s) older than ${res.maxAgeDays}d would be removed`
+        : `kj review --prune: removed ${res.removed} verdict(s) older than ${res.maxAgeDays}d (${res.scanned - res.removed} kept)`,
+    );
+    return { pruned: res.removed, dryRun };
+  }
+
   const diff = await rawDiff(flags.range);
 
   const card = await enforceCardFirst({ config, projectDir });

package/src/harden/harden-engine.js

@@ -12,7 +12,7 @@ import { join } from "node:path";
 
 import { upsertManagedBlock } from "../utils/managed-markers.js";
 import { runCommand } from "../utils/process.js";
-import { hookBody, PROFILE_HOOKS, SHEBANG } from "./hook-templates.js";
+import { hookBody, PROFILE_HOOKS, SHEBANG, toPortableHooksDir } from "./hook-templates.js";
 
 const BLOCK_VERSION = 1;
 const HOOKS_DIR = join(".karajan", "hooks");
@@ -67,7 +67,10 @@ export async function installHooks({
   const globalCfg = await runCommand("git", ["config", "--global", "core.hooksPath"], { cwd: projectDir });
   const rawGlobal = globalCfg.exitCode === 0 ? globalCfg.stdout.trim() : "";
   if (rawGlobal && rawGlobal !== HOOKS_DIR) {
-    globalHooksDir = rawGlobal.startsWith("~") ? `$HOME${rawGlobal.slice(1)}` : rawGlobal;
+    // KJC-BUG-0169: normalize to a machine-independent form HERE (generation,
+    // on the human's machine) so the provenance stores the portable dir and CI
+    // recomputes the SAME bytes — an absolute home path is not verifiable there.
+    globalHooksDir = toPortableHooksDir(rawGlobal);
   }
 
   const absHooksDir = join(projectDir, HOOKS_DIR);

package/src/harden/hook-templates.js

@@ -27,16 +27,24 @@ export const PROFILE_HOOKS = {
 // hooks dir, silently disabling personal guards. When a previous global dir
 // is known, every generated hook ends by chaining its namesake there —
 // guarded, so machines without it are unaffected.
+// KJC-BUG-0161 / 0169 (ADR 0009): a committed hook must not bake a machine's
+// absolute home path — a dir under the home resolves through $HOME so the same
+// generated content is valid on every machine and its provenance stays
+// verifiable IN CI (a different home), with no local filesystem layout leaking
+// into a public repo. Normalization happens ONCE, at generation, on the human's
+// machine; the stored/rendered value is already portable, so a render on any
+// other home (CI) reproduces identical bytes. `home` is injectable for tests.
+export function toPortableHooksDir(dir, home = homedir()) {
+  if (!dir) return dir;
+  if (dir.startsWith("$HOME")) return dir;
+  if (dir.startsWith("~")) return `$HOME${dir.slice(1)}`;
+  if (dir === home || dir.startsWith(`${home}/`)) return `$HOME${dir.slice(home.length)}`;
+  return dir;
+}
+
 function chainToGlobal(hook, globalHooksDir) {
   if (!globalHooksDir) return [];
-  // KJC-BUG-0161 (ADR 0009): a committed hook must not bake a machine's
-  // absolute home path — resolve through $HOME at runtime so the same
-  // generated content is valid on every machine and its provenance stays
-  // verifiable (and no local filesystem layout leaks into a public repo).
-  const home = homedir();
-  const dir = globalHooksDir === home || globalHooksDir.startsWith(`${home}/`)
-    ? `$HOME${globalHooksDir.slice(home.length)}`
-    : globalHooksDir;
+  const dir = toPortableHooksDir(globalHooksDir);
   return [
     "# Chain the machine's previous global hook (kj harden keeps it active).",
     `if [ -x "${dir}/${hook}" ]; then`,
@@ -114,12 +122,19 @@ export function hookBody(hook, cmds = {}, { globalHooksDir = null, baseBranch =
         "# the same precise pattern (tool MENTIONS stay legal; attribution not).",
         "# The guard's own definition files are excluded by literal path — they",
         "# CONTAIN the pattern; excluding a path that does not exist is harmless.",
-        `if git diff --cached -- . ':(exclude).github/workflows/kj-no-ai-attribution.yml' ':(exclude)src/harden/hook-templates.js' ':(exclude)src/harden/workflow-templates.js' ':(exclude)src/harden/sentinel-hooks.js' ':(exclude)scripts/ai-attribution-guard.yml' ':(exclude)tests/harden/attribution-guard.test.js' ':(exclude)tests/harden/sentinel-hooks.test.js' | grep '^+' | grep -qiE '${AI_ATTRIBUTION}|generated with \\[?claude'; then`,
+        "# KJC-BUG-0170: the generated supervisor hooks (.karajan/hooks/pre-commit,",
+        "# commit-msg) also CONTAIN the pattern by design — the bootstrap commit",
+        "# that versions them must not self-detect in the consumer repo.",
+        `if git diff --cached -- . ':(exclude).github/workflows/kj-no-ai-attribution.yml' ':(exclude)src/harden/hook-templates.js' ':(exclude)src/harden/workflow-templates.js' ':(exclude)src/harden/sentinel-hooks.js' ':(exclude)scripts/ai-attribution-guard.yml' ':(exclude)tests/harden/attribution-guard.test.js' ':(exclude)tests/harden/sentinel-hooks.test.js' ':(exclude).karajan/hooks/pre-commit' ':(exclude).karajan/hooks/commit-msg' | grep '^+' | grep -qiE '${AI_ATTRIBUTION}|generated with \\[?claude'; then`,
         "  echo 'kj harden: AI attribution is not allowed in committed content'; exit 1",
         "fi",
         "# v4 review gate (ENV-C1, opt-in via `kj review --install-gate`):",
         "# a staged diff only enters with a recorded cross-AI approved verdict.",
-        "if [ -f .karajan/review-gate ]; then",
+        "# KJC-BUG-0165: the gate is active once the marker is COMMITTED (HEAD),",
+        "# not merely present — so the bootstrap commit that INTRODUCES it is",
+        "# exempt (no gate can exist before it does), and it cannot be bypassed",
+        "# by deleting the working-tree file.",
+        "if git cat-file -e HEAD:.karajan/review-gate 2>/dev/null; then",
         "  if ! command -v kj >/dev/null 2>&1; then",
         "    echo 'kj: review gate is enabled but kj is not installed — see karajancode.com/docs/getting-started/installation'; exit 1",
         "  fi",

package/src/harden/phone-sign.js

@@ -32,21 +32,78 @@ async function relayConfig(fetchFn) {
 }
 const SIGN_PAGE = "https://karajancode.com/sign";
 const POLL_INTERVAL_MS = 2000;
-const TTL_MS = 120000;
+const TTL_MS = 60000;
+
+/** Spinner en su sitio (una línea, con \r) solo en TTY; no-op fuera de TTY o en tests. */
+function makeSpinner() {
+  if (!process.stdout?.isTTY) return { tick() {}, stop() {} };
+  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  let i = 0;
+  return {
+    tick() { process.stdout.write(`\r${frames[i++ % frames.length]} esperando la firma del móvil…`); },
+    stop() { process.stdout.write("\r\x1b[K"); },
+  };
+}
 
 const phoneKeyPath = (home) => join(home ?? homedir(), ".karajan", "supervisor-phone.json");
 
+// KJC-TSK-0831 (ADR 0010): el padrón de firmantes vive VERSIONADO en el repo,
+// no una única clave local — así un equipo comparte la confianza y el CI puede
+// verificar (0823) contra el mismo conjunto. La legacy ~/.karajan sigue valiendo.
+const signersPath = (projectDir) => join(projectDir ?? process.cwd(), ".karajan", "supervisor-signers.json");
+
+/** Valida una clave pública ed25519 raw en base64 canónico (32 bytes). */
+export function validatePhonePublicKey(publicKeyBase64) {
+  const raw = Buffer.from(publicKeyBase64 ?? "", "base64");
+  if (raw.length !== 32 || raw.toString("base64") !== publicKeyBase64) {
+    throw new Error("la clave debe ser base64 canónico de EXACTAMENTE 32 bytes (ed25519 raw)");
+  }
+  return publicKeyBase64;
+}
+
 export const isPhoneEnrolled = ({ home } = {}) => existsSync(phoneKeyPath(home));
 
 export const readEnrolledKey = ({ home } = {}) =>
   JSON.parse(readFileSync(phoneKeyPath(home), "utf8")).publicKey;
 
-/** Valida y persiste la clave pública del móvil (base64 del raw de 32 bytes). */
-export function enrollPhone(publicKeyBase64, { home } = {}) {
-  const raw = Buffer.from(publicKeyBase64 ?? "", "base64");
-  if (raw.length !== 32 || raw.toString("base64") !== publicKeyBase64) {
-    throw new Error("la clave debe ser base64 canónico de EXACTAMENTE 32 bytes (ed25519 raw)");
+/** Claves públicas del padrón versionado del repo (o [] si no hay). */
+export function readSigners({ projectDir } = {}) {
+  try {
+    const doc = JSON.parse(readFileSync(signersPath(projectDir), "utf8"));
+    return Array.isArray(doc?.signers) ? doc.signers.map((s) => s.publicKey).filter(Boolean) : [];
+  } catch {
+    return [];
   }
+}
+
+/**
+ * Conjunto de claves AUTORIZADAS a sellar: el padrón del repo ∪ la clave legacy
+ * de ~/.karajan (compat). Sin fallbacks silenciosos: si no hay ninguna, el Set
+ * está vacío y la verificación fallará ruidosamente.
+ */
+export function readEnrolledKeys({ projectDir, home } = {}) {
+  const keys = new Set(readSigners({ projectDir }));
+  if (isPhoneEnrolled({ home })) keys.add(readEnrolledKey({ home }));
+  return keys;
+}
+
+/** Añade una clave pública al padrón versionado del repo (dedup). Acto humano. */
+export function addSigner(publicKeyBase64, { projectDir, label } = {}) {
+  validatePhonePublicKey(publicKeyBase64);
+  const path = signersPath(projectDir);
+  let doc = { signers: [] };
+  try { doc = JSON.parse(readFileSync(path, "utf8")); } catch { /* new file */ }
+  if (!Array.isArray(doc.signers)) doc.signers = [];
+  if (doc.signers.some((s) => s.publicKey === publicKeyBase64)) return doc;
+  doc.signers.push({ publicKey: publicKeyBase64, label: label ?? null, enrolledAt: new Date().toISOString() });
+  mkdirSync(join(path, ".."), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+  return doc;
+}
+
+/** Valida y persiste la clave pública del móvil (legacy: clave única ~/.karajan). */
+export function enrollPhone(publicKeyBase64, { home } = {}) {
+  validatePhonePublicKey(publicKeyBase64);
   mkdirSync(join(phoneKeyPath(home), ".."), { recursive: true });
   const record = { publicKey: publicKeyBase64, enrolledAt: new Date().toISOString() };
   writeFileSync(phoneKeyPath(home), `${JSON.stringify(record, null, 2)}\n`, "utf8");
@@ -98,22 +155,34 @@ export async function requestPhoneSignature({ project, files, kjVersion, logger
   const signUrl = `${SIGN_PAGE}?c=${cid}`;
   drawQr(signUrl);
   logger.info?.(`phone-sign: escanea el QR o abre ${signUrl} y firma en el móvil (caduca en ${TTL_MS / 1000}s)`);
+  logger.info?.("phone-sign: esperando la firma del móvil…");
+  const spinner = deps.spinner ?? makeSpinner();
   const deadline = now() + TTL_MS;
   while (now() < deadline) {
     const res = await fetchFn(`${relay.url}/${cid}?key=${relay.apiKey}`);
-    if (!res.ok) throw new Error(`phone-sign: fallo consultando la petición de firma (HTTP ${res.status})`);
+    if (!res.ok) { spinner.stop(); throw new Error(`phone-sign: fallo consultando la petición de firma (HTTP ${res.status})`); }
     const fields = (await res.json()).fields ?? {};
     if (fields.state?.stringValue === "signed") {
-      const enrolled = readEnrolledKey({ home: deps.home });
-      if (fields.publicKey?.stringValue !== enrolled) {
-        return { ok: false, reason: "la publicKey del doc no coincide con la enrolada — el doc es transporte, la verdad es la enrolada" };
+      spinner.stop();
+      // KJC-TSK-0831 (ADR 0010): la clave que firma debe estar en el PADRÓN
+      // autorizado (repo ∪ legacy). El doc es transporte; la verdad es el padrón.
+      const authorized = readEnrolledKeys({ projectDir: deps.projectDir, home: deps.home });
+      const signerKey = fields.publicKey?.stringValue;
+      if (!signerKey || !authorized.has(signerKey)) {
+        return { ok: false, reason: "la publicKey que firma no está en el padrón autorizado — el doc es transporte, la verdad es el padrón" };
       }
       const payload = canonicalPayload({ cid, nonce, project, files });
-      const good = verifyPhoneSignature({ payload, signature: fields.signature?.stringValue ?? "", publicKey: enrolled });
-      return good ? { ok: true } : { ok: false, reason: "firma ed25519 inválida para el payload canónico" };
+      const signature = fields.signature?.stringValue ?? "";
+      const good = verifyPhoneSignature({ payload, signature, publicKey: signerKey });
+      if (!good) return { ok: false, reason: "firma ed25519 inválida para el payload canónico" };
+      // KJC-TSK-0823: devuelve el desafío + firma para que el sello los GRABE en
+      // la provenance y CI pueda re-verificar server-side (clave del padrón).
+      const filesHash = createHash("sha256").update(JSON.stringify(files)).digest("hex");
+      return { ok: true, signer: signerKey, signature, challenge: { cid, nonce, project, filesHash } };
     }
-    logger.info?.("phone-sign: esperando la firma del móvil…");
+    spinner.tick();
     await sleep(POLL_INTERVAL_MS);
   }
+  spinner.stop();
   return { ok: false, reason: "caducado" };
 }

package/src/harden/supervisor-commit.js

@@ -123,6 +123,7 @@ export async function commitSupervisorRegeneration({
   // es OBLIGATORIA — jamás se degrada a solo-nonce. Firma los MISMOS
   // files/hashes de la provenance (normalizados al par {file, sha256}).
   const phone = deps.phone ?? { enrolled: isPhoneEnrolled, request: requestPhoneSignature };
+  let signatureBlock = null;
   if (phone.enrolled({})) {
     const signed = await phone.request({
       project: basename(projectDir),
@@ -133,6 +134,11 @@ export async function commitSupervisorRegeneration({
     if (!signed.ok) {
       throw new Error(`capa 5: firma del móvil rechazada (${signed.reason}) — con móvil enrolado el sello exige su firma (PRP-0023)`);
     }
+    // KJC-TSK-0823: graba el desafío + firma en la provenance para que CI
+    // re-verifique server-side que un humano (clave del padrón) aprobó.
+    if (signed.challenge && signed.signature) {
+      signatureBlock = { ...signed.challenge, signer: signed.signer, signature: signed.signature };
+    }
   }
   const who = readIdentity(projectDir);
   const provenance = {
@@ -141,6 +147,7 @@ export async function commitSupervisorRegeneration({
     generation,
     who: who ? { gh: who.gh_user ?? null, git: who.git_email ?? null, grade: "declarada" } : null,
     files: hashed,
+    ...(signatureBlock ? { signature: signatureBlock } : {}),
   };
   writeFileSync(join(projectDir, PROVENANCE_FILE), `${JSON.stringify(provenance, null, 2)}\n`, "utf8");
   recordGateDecision(projectDir, {

package/src/review/verdict-store.js

@@ -16,6 +16,11 @@ import { runCommand } from "../utils/process.js";
 
 const STORE_DIR = path.join(".karajan", "reviews");
 
+// KJC-BUG-0173: a verdict is keyed by one exact diff hash, so once that diff is
+// committed or changed its hash is never looked up again — anything older than
+// this TTL is dead weight and safe to shed. Nothing live stays staged for weeks.
+export const VERDICT_TTL_DAYS = 14;
+
 export function diffHash(diff) {
   // trimEnd: runners differ on the final newline (execa strips it, raw
   // git keeps it) — trailing whitespace must not void a verdict.
@@ -36,9 +41,44 @@ export async function saveVerdict(projectDir, diff, verdict) {
   const file = verdictPath(projectDir, hash);
   await fs.mkdir(path.dirname(file), { recursive: true });
   await fs.writeFile(file, `${JSON.stringify(record, null, 2)}\n`);
+  // KJC-BUG-0173: a review is the natural moment to shed dead verdicts.
+  // Best-effort — hygiene must never break a save.
+  try { await pruneVerdicts({ projectDir }); } catch { /* hygiene, not correctness */ }
   return record;
 }
 
+/**
+ * Opportunistic GC for the verdict store: removes verdict files whose mtime is
+ * older than `maxAgeDays`. A verdict only counts for a byte-identical diff, so
+ * an aged one can never be re-checked. `now`/`dryRun` injectable for tests.
+ * @returns {Promise<{scanned:number, removed:number, expired:string[], dryRun:boolean, maxAgeDays:number}>}
+ */
+export async function pruneVerdicts({ projectDir, maxAgeDays = VERDICT_TTL_DAYS, now = Date.now, dryRun = false } = {}) {
+  const dir = path.join(projectDir || process.cwd(), STORE_DIR);
+  const cutoff = now() - maxAgeDays * 86400000;
+  let names;
+  try {
+    names = await fs.readdir(dir);
+  } catch {
+    return { scanned: 0, removed: 0, expired: [], dryRun, maxAgeDays };
+  }
+  const jsons = names.filter((n) => n.endsWith(".json"));
+  const expired = [];
+  for (const name of jsons) {
+    try {
+      const st = await fs.stat(path.join(dir, name));
+      if (st.mtimeMs < cutoff) expired.push(name);
+    } catch { /* vanished mid-scan */ }
+  }
+  let removed = 0;
+  if (!dryRun) {
+    for (const name of expired) {
+      try { await fs.unlink(path.join(dir, name)); removed += 1; } catch { /* already gone */ }
+    }
+  }
+  return { scanned: jsons.length, removed, expired, dryRun, maxAgeDays };
+}
+
 export async function loadVerdict(projectDir, hash) {
   try {
     return JSON.parse(await fs.readFile(verdictPath(projectDir, hash), "utf8"));