karajan-code 4.24.0 → 4.26.0

package/packages/hu-board/src/sync.js

@@ -1,6 +1,7 @@
 import { watch } from 'chokidar';
+import { execFileSync } from 'node:child_process';
 import { readFileSync, readdirSync, existsSync, rmSync } from 'node:fs';
-import { dirname, join, basename } from 'node:path';
+import { dirname, join, basename, isAbsolute, resolve as resolvePath } from 'node:path';
 import { homedir } from 'node:os';
 import {
   getKjHome,
@@ -93,7 +94,7 @@ function deriveProjectName(data, fallbackId) {
  * @param {string} projectDir
  * @returns {string}
  */
-function deriveProjectIdFromDir(projectDir) {
+export function deriveProjectIdFromDir(projectDir) {
   if (!projectDir || typeof projectDir !== 'string') return 'unknown';
   // Same slug rule the plan-store uses, so identifiers match if we ever
   // cross-reference `~/.kj/plans/<slug>/` with this project_id.
@@ -104,6 +105,42 @@ function deriveProjectIdFromDir(projectDir) {
     .slice(0, 120);
 }
 
+/** git-common-dir del directorio, con el stderr silenciado (no-git = throw). */
+const defaultGitCommonDir = (dir) =>
+  execFileSync('git', ['-C', dir, 'rev-parse', '--git-common-dir'], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+  }).trim();
+
+const canonicalDirCache = new Map();
+
+/**
+ * Resolve a projectDir to the REPO's identity (KJC-BUG-0160): a linked
+ * worktree (`.claude/worktrees/*`, kj lanes) used to register the same
+ * repo as a brand-new project — 13+ same-named entries in a real picker.
+ * `git rev-parse --git-common-dir` points every worktree at the main
+ * tree's `.git`; its parent is the canonical root. A non-git directory
+ * keeps its own path as identity, as always.
+ *
+ * @param {string} projectDir
+ * @param {(dir: string) => string} [gitCommonDir] Inyectable en tests.
+ * @returns {string}
+ */
+export function canonicalProjectDir(projectDir, gitCommonDir = defaultGitCommonDir) {
+  if (!projectDir || typeof projectDir !== 'string') return projectDir;
+  if (canonicalDirCache.has(projectDir)) return canonicalDirCache.get(projectDir);
+  let canonical = projectDir;
+  try {
+    const common = gitCommonDir(projectDir);
+    const absCommon = isAbsolute(common) ? common : resolvePath(projectDir, common);
+    canonical = dirname(absCommon);
+  } catch {
+    // Sin git no hay más identidad que la ruta — comportamiento de siempre.
+  }
+  canonicalDirCache.set(projectDir, canonical);
+  return canonical;
+}
+
 /**
  * Turn a directory basename into a human-friendly Title Case string,
  * preserving every meaningful word. Unlike `slugToTitle`, this one does
@@ -379,9 +416,10 @@ export function syncPlanFile(filePath) {
     // under a single board entry. Legacy plans without `projectDir` still
     // fall back to `planId` (conservative — they at least continue to show
     // up, just each on its own card).
-    const projectId = data.projectDir
-      ? deriveProjectIdFromDir(data.projectDir)
-      : data.planId;
+    // KJC-BUG-0160: la identidad es el ROOT del repo — un plan creado desde
+    // un worktree/carril agrupa bajo el mismo proyecto que el árbol principal.
+    const canonicalDir = data.projectDir ? canonicalProjectDir(data.projectDir) : null;
+    const projectId = canonicalDir ? deriveProjectIdFromDir(canonicalDir) : data.planId;
 
     if (skipIfTombstoned('plan', data.planId, filePath)) return;
     // KJC-BUG-0055 (supersedes KJC-BUG-0050): gating por timestamp.
@@ -418,8 +456,13 @@ export function syncPlanFile(filePath) {
     //      with a SPEC about "Linux Assistant", the basename here would
     //      misleadingly say "Hu Board" — that's why plan.name wins.
     //   3. slugToTitle of the task / projectId as a last resort.
-    const projectName = data.name
-      || (data.projectDir ? titleCaseBasename(basename(data.projectDir)) : null)
+    // KJC-BUG-0162: the default backlog plan is named "brain-backlog" — a
+    // DEFAULT, not a user choice. Every project synced through it ended up
+    // named "brain-backlog", indistinguishable in the picker. Only a real,
+    // user-given plan name may override the repo-derived name.
+    const userGivenName = data.name && data.name !== 'brain-backlog' ? data.name : null;
+    const projectName = userGivenName
+      || (canonicalDir ? titleCaseBasename(basename(canonicalDir)) : null)
       || slugToTitle(data.task || '')
       || projectId;
 

package/packages/hu-board/src/terminal-wire.js

@@ -0,0 +1,96 @@
+// KJC-TSK-0816 — pegamento fino de la terminal embebida: rutas REST para
+// arrancar/parar la sesión y el upgrade WebSocket que puentea el pty.
+// La LÓGICA (tokens, catálogo, ciclo de vida) vive en terminal.js y está
+// testeada con dobles; esto es cableado deliberadamente delgado.
+//
+// El token NO viaja en la URL: el cliente lo manda como subprotocolo
+// WebSocket (['kj-terminal', token]) — las URLs acaban en logs; los
+// subprotocolos, no.
+import { Router } from 'express';
+import { WebSocket, WebSocketServer } from 'ws';
+
+const LOOPBACK = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1']);
+const WS_PATH = '/api/terminal/ws';
+
+/**
+ * Monta las rutas REST de la terminal sobre un Router de express.
+ * @param {ReturnType<import('./terminal.js').createTerminalManager>} manager
+ */
+export function terminalRouter(manager, { defaultAgent = 'claude' } = {}) {
+  const router = Router();
+  router.post('/start', (req, res) => {
+    try {
+      res.json(manager.start({ agent: req.body?.agent ?? defaultAgent }));
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+  router.get('/alive', (_req, res) => res.json({ alive: manager.alive() }));
+  router.post('/stop', (req, res) => {
+    try {
+      manager.stop({ termId: req.body?.termId, token: req.body?.token });
+      res.json({ stopped: true });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+  return router;
+}
+
+/**
+ * Registra el upgrade WS en el servidor http. Entrada del cliente: bytes
+ * crudos = teclado; un mensaje que empiece por \x00 es control JSON
+ * ({type:'resize', cols, rows}) — el prefijo evita confundir un '{'
+ * tecleado con un mensaje de control.
+ *
+ * @param {import('node:http').Server} server
+ * @param {ReturnType<import('./terminal.js').createTerminalManager>} manager
+ */
+export function attachTerminalWs(server, manager) {
+  const wss = new WebSocketServer({ noServer: true });
+  server.on('upgrade', (req, socket, head) => {
+    const url = new URL(req.url, 'http://localhost');
+    if (url.pathname !== WS_PATH) return;
+    if (!LOOPBACK.has(req.socket.remoteAddress)) {
+      socket.destroy();
+      return;
+    }
+    const termId = url.searchParams.get('termId');
+    const protocols = String(req.headers['sec-websocket-protocol'] ?? '')
+      .split(',')
+      .map((p) => p.trim());
+    const token = protocols[1] ?? '';
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      let detach;
+      try {
+        detach = manager.attach({
+          termId,
+          token,
+          send: (data) => {
+            if (ws.readyState === WebSocket.OPEN) ws.send(data);
+          },
+        });
+      } catch (err) {
+        ws.close(1008, err.message);
+        return;
+      }
+      ws.on('message', (raw) => {
+        const text = raw.toString('utf8');
+        try {
+          if (text.charCodeAt(0) === 0) {
+            const msg = JSON.parse(text.slice(1));
+            if (msg.type === 'resize') {
+              manager.resize({ termId, token, cols: msg.cols, rows: msg.rows });
+            }
+            return;
+          }
+          manager.write({ termId, token, data: text });
+        } catch {
+          // Una trama malformada no tumba la sesión: se ignora y se sigue.
+        }
+      });
+      ws.on('close', () => detach());
+    });
+  });
+  return wss;
+}

package/packages/hu-board/src/terminal.js

@@ -0,0 +1,122 @@
+// KJC-TSK-0816 (MGL-E, ADR 0008) — la ventana única: la terminal REAL del
+// agente embebida en el board; el proceso es el agente interactivo de
+// siempre, con los hooks del Sentinel intactos. Seguridad de la superficie:
+// server solo en loopback, token aleatorio de 128 bits entregado tras el
+// auth del board y comparado en tiempo constante, y catálogo de agentes
+// CERRADO — por la red viaja qué agente, jamás un comando arbitrario.
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+
+/** Catálogo cerrado: los mismos agentes que kj go sabe lanzar. */
+export const TERMINAL_AGENTS = Object.freeze({
+  claude: { command: 'claude', args: [] },
+  codex: { command: 'codex', args: [] },
+});
+
+const tokenMatches = (expected, given) => {
+  const a = Buffer.from(String(expected));
+  const b = Buffer.from(String(given ?? ''));
+  return a.length === b.length && timingSafeEqual(a, b);
+};
+
+/**
+ * Gestor de LA sesión de terminal del board (singleton por diseño: una
+ * conversación por board acota la superficie; multi-terminal queda fuera
+ * del alcance del ADR).
+ *
+ * @param {Object} deps
+ * @param {(command: string, args: string[], opts: object) => object} deps.spawnPty
+ *   Factoría del pty (node-pty.spawn en producción; fake en tests).
+ * @param {string} deps.cwd Directorio del proyecto donde vive el agente.
+ * @param {Record<string, string|undefined>} [deps.env]
+ * @param {string} [deps.promptArg] Prompt inicial del agente (kj go --window
+ *   lo pasa por env al daemon) — SIEMPRE del lado servidor, jamás de la red.
+ */
+export function createTerminalManager({ spawnPty, cwd, env = process.env, promptArg }) {
+  /** @type {{termId: string, token: string, pty: object, subscribers: Set<Function>, buffer: string[]} | null} */
+  let session = null;
+
+  const requireSession = (termId, token) => {
+    if (!session || session.termId !== termId) {
+      throw new Error('terminal: no hay sesión viva con ese id.');
+    }
+    if (!tokenMatches(session.token, token)) {
+      throw new Error('terminal: token inválido.');
+    }
+    return session;
+  };
+
+  return {
+    /** Arranca (o devuelve) LA sesión — reutilizar la viva evita que cada
+     *  recarga multiplique agentes. @param {{agent: string}} params */
+    start({ agent }) {
+      if (session) return { termId: session.termId, token: session.token, reused: true };
+      // hasOwn: sin él, "constructor"/"__proto__" indexarían el prototipo.
+      const spec = Object.hasOwn(TERMINAL_AGENTS, agent) ? TERMINAL_AGENTS[agent] : null;
+      if (!spec) {
+        throw new Error(
+          `terminal: agente "${agent}" fuera del catálogo (${Object.keys(TERMINAL_AGENTS).join(', ')}).`,
+        );
+      }
+      // CLAUDECODE fuera: un Claude anidado se niega a arrancar con ella
+      // (la misma peculiaridad que ya maneja kj go).
+      const { CLAUDECODE: _omit, ...cleanEnv } = env;
+      const args = promptArg ? [...spec.args, promptArg] : spec.args;
+      const pty = spawnPty(spec.command, args, {
+        name: 'xterm-256color',
+        cols: 120,
+        rows: 32,
+        cwd,
+        env: cleanEnv,
+      });
+      const current = {
+        termId: `term-${randomBytes(8).toString('hex')}`,
+        token: randomBytes(16).toString('hex'),
+        pty,
+        subscribers: new Set(),
+        buffer: [],
+      };
+      pty.onData((data) => {
+        // Búfer corto para que una reconexión no arranque en negro.
+        current.buffer.push(data);
+        if (current.buffer.length > 200) current.buffer.shift();
+        for (const send of current.subscribers) send(data);
+      });
+      pty.onExit(() => {
+        for (const send of current.subscribers) send('\r\n[la sesión del agente terminó]\r\n');
+        // El exit tardío de un pty viejo no debe anular una sesión nueva.
+        if (session === current) session = null;
+      });
+      session = current;
+      return { termId: current.termId, token: current.token, reused: false };
+    },
+
+    /**
+     * Conecta un receptor de salida. Devuelve el detach; soltar la
+     * conexión NO mata el pty — el agente sigue y se puede volver.
+     */
+    attach({ termId, token, send }) {
+      const s = requireSession(termId, token);
+      for (const chunk of s.buffer) send(chunk);
+      s.subscribers.add(send);
+      return () => s.subscribers.delete(send);
+    },
+
+    write({ termId, token, data }) {
+      requireSession(termId, token).pty.write(data);
+    },
+
+    resize({ termId, token, cols, rows }) {
+      requireSession(termId, token).pty.resize(cols, rows);
+    },
+
+    stop({ termId, token }) {
+      const s = requireSession(termId, token);
+      s.pty.kill();
+      session = null;
+    },
+
+    alive() {
+      return session ? { termId: session.termId } : null;
+    },
+  };
+}

package/src/cli/register-meta.js

@@ -154,6 +154,7 @@ export function registerMeta(program, { pkgVersion }) {
   program
     .command("go")
     .description("Arranca Karajan sin saber nada: detecta tu agente, prepara el proyecto, abre el tablero y te deja en la conversación")
+    .option("--window", "La ventana única (ADR 0008): la conversación vive DENTRO del tablero del navegador")
     .action(async (flags) => {
       await withConfig(pkgVersion, "go", flags, async ({ config, logger }) => {
         await goCommand({ config, logger, flags });
@@ -371,6 +372,7 @@ export function registerMeta(program, { pkgVersion }) {
     .option("--rule <rule_id>", "Regla exacta (p.ej. roles.coder.write.deny)")
     .option("--until <iso>", "Caducidad ISO-8601 (p.ej. 2026-09-01T00:00:00Z)")
     .option("--reason <text>", "Justificación escrita en el momento")
+    .option("--global", "Ámbito global (~/.karajan): vale para todos tus proyectos de esta máquina — KJC-TSK-0813")
     .action(async (flags) => {
       await withConfig(pkgVersion, "policy-grant", flags, async ({ config }) => {
         process.exitCode = await policyCommand({ action: "grant", config, flags });

package/src/commands/go.js

@@ -46,12 +46,13 @@ export function buildGoPrompt() {
 async function defaultPrepare({ config, logger }) {
   await envInstallCommand({ config, logger, flags: { yes: true } });
 }
-export async function defaultBoard({ config, logger, runBoard = boardCommand }) {
+export async function defaultBoard({ config, logger, runBoard = boardCommand, openPath = "/?maggle=1" }) {
   const port = config.hu_board?.port || 4000;
   await runBoard({ action: "start", port, bind: "127.0.0.1", logger });
   // /?maggle=1 switches the frontend to plain language (KJC-TSK-0810) —
-  // the muggle's window opens already speaking their language.
-  await runBoard({ action: "open", port, bind: "127.0.0.1", path: "/?maggle=1", logger });
+  // the muggle's window opens already speaking their language. With
+  // &window=1 (KJC-TSK-0816) the conversation itself lives IN the board.
+  await runBoard({ action: "open", port, bind: "127.0.0.1", path: openPath, logger });
 }
 function defaultLaunch(agent, prompt) {
   // Interactive session: the muggle LIVES here. CLAUDECODE is stripped so a
@@ -96,13 +97,41 @@ export async function goCommand({ config = {}, logger = console, flags = {}, dep
     logger.info?.("Preparando tu proyecto (solo la primera vez)…");
     await (deps.prepare ?? defaultPrepare)({ config, logger });
   }
+  const prompt = (deps.prompt ?? buildGoPrompt)();
+  // --window (MGL-E, ADR 0008): la conversación vive DENTRO del board — el
+  // daemon hereda por env (HU_BOARD_TERMINAL_CWD/AGENT/PROMPT) el cwd, el
+  // agente elegido y el prompt inicial, y el pty arranca el agente REAL
+  // (harness intacto). La fase 1 sigue siendo el default: sin el flag,
+  // nada cambia.
+  const windowMode = Boolean(flags.window);
+  if (windowMode) {
+    process.env.HU_BOARD_TERMINAL_CWD = projectDir;
+    process.env.HU_BOARD_TERMINAL_AGENT = chosen.name;
+    process.env.HU_BOARD_TERMINAL_PROMPT = prompt;
+  }
   // The board is the muggle's window — unless the project turned it off
   // (hu_board.enabled false is respected: KJC-BUG-0152). A board failure is
   // said and never stops the conversation from starting.
+  let boardOpened = false;
   if (config.hu_board?.enabled !== false) {
-    try { await (deps.board ?? defaultBoard)({ config, logger }); } catch (err) { logger.warn?.(`El tablero no pudo abrirse (${err.message}) — la conversación arranca igual.`); }
+    const openPath = windowMode ? "/?maggle=1&window=1" : "/?maggle=1";
+    try {
+      await (deps.board ?? defaultBoard)({ config, logger, openPath });
+      boardOpened = true;
+    } catch (err) {
+      logger.warn?.(`El tablero no pudo abrirse (${err.message}) — la conversación arranca igual.`);
+    }
+  }
+  if (windowMode && boardOpened) {
+    logger.info?.("Tu conversación vive en la ventana del navegador que se acaba de abrir. Si el tablero ya estaba arrancado de antes, reinícialo con kj board stop && kj go --window para que recoja este proyecto.");
+    process.exitCode = 0;
+    return 0;
+  }
+  if (windowMode) {
+    // Sin board no hay ventana: se dice y la conversación arranca en la
+    // terminal — el maggle nunca se queda sin sesión (catch de codex).
+    logger.warn?.("Sin tablero no hay ventana única: abro la conversación aquí mismo.");
   }
-  const prompt = (deps.prompt ?? buildGoPrompt)();
   logger.info?.("Abriendo tu conversación… (escribe ahí lo que necesites, en tu idioma)");
   const code = await (deps.launch ?? defaultLaunch)(chosen, prompt);
   process.exitCode = code;

package/src/commands/policy.js

@@ -12,7 +12,7 @@ import { createHash } from "node:crypto";
 import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { checkStagedDiff, evalToolCall, loadPolicy } from "../policy/engine.js";
-import { loadExceptionRecords, loadStandingExceptions, recordPolicyException } from "../policy/exceptions.js";
+import { loadExceptionRecords, loadGlobalExceptionRecords, loadStandingExceptions, recordPolicyException } from "../policy/exceptions.js";
 import { buildPolicyReport } from "../policy/report.js";
 import { policyFileHash, recordGateDecision } from "../policy/decisions.js";
 import { readIdentity } from "../identity/store.js";
@@ -110,12 +110,16 @@ export async function policyCommand({ action, config = {}, flags = {}, logger =
       // regla re-concedida N veces es la política real pidiendo que la
       // cambien por su cauce. Se cuenta contra TODAS las permanentes previas
       // (vencidas incluidas: precisamente esas son la sedimentación).
-      const previous = loadStandingExceptions(projectDir).standing.filter((e) => e.rule_id === rule).length;
+      // KJC-TSK-0813: --global escribe en ~/.karajan (todos los proyectos de
+      // la máquina). El contador de renovaciones cuenta sobre la FUSIÓN.
+      const scope = flags.global ? "global" : "project";
+      const previous = loadStandingExceptions(projectDir, { home: deps.home }).standing.filter((e) => e.rule_id === rule).length;
       const rec = recordPolicyException({
-        projectDir,
+        projectDir, scope, deps: { home: deps.home },
         entry: { rule_id: rule, justification: reason.trim(), scopeKind: "permanente", expiresAt: until },
       });
-      logger.info?.(`✓ excepción permanente registrada: [${rec.rule_id}] hasta ${rec.expiresAt} — concedida por ${rec.who?.git ?? "?"} (${rec.who?.grade ?? "?"})`);
+      const ambit = scope === "global" ? " [ámbito global — todos tus proyectos de esta máquina]" : "";
+      logger.info?.(`✓ excepción permanente registrada${ambit}: [${rec.rule_id}] hasta ${rec.expiresAt} — concedida por ${rec.who?.git ?? "?"} (${rec.who?.grade ?? "?"})`);
       if (previous >= 1) {
         logger.warn?.(`⚠ ${previous + 1}ª concesión sobre esta regla — una excepción que se renueva ya no es una excepción: considera cambiar la política por su cauce (PR a .karajan/policy.yml)`);
       }
@@ -134,7 +138,11 @@ export async function policyCommand({ action, config = {}, flags = {}, logger =
     try {
       decisionLines = readFileSync(join(projectDir, ".karajan", "policy-decisions.jsonl"), "utf8").split("\n").filter((l) => l.trim());
     } catch { /* sin decisiones aún: el informe lo dice con ceros */ }
-    const exc = loadExceptionRecords(projectDir);
+    // KJC-TSK-0813 (AC3): el informe cubre TAMBIÉN el almacén global — cada
+    // registro llega con su origin FÍSICO estampado por la carga.
+    const proj = loadExceptionRecords(projectDir);
+    const glob = loadGlobalExceptionRecords({ home: deps.home });
+    const exc = { records: [...proj.records, ...glob.records], discarded: proj.discarded + glob.discarded };
     const soonDays = Number(flags.soon ?? 7);
     const report = buildPolicyReport({ decisionLines, exceptionRecords: exc.records, policy, soonDays: Number.isFinite(soonDays) ? soonDays : 7 });
     if (flags.json) {
@@ -152,8 +160,10 @@ export async function policyCommand({ action, config = {}, flags = {}, logger =
       const meta = [r.enforcement && `enforcement=${r.enforcement}`, r.class && `class=${r.class}`].filter(Boolean).join(" ");
       logger.info?.(`  [${r.rule_id}] ${meta} — warn ${r.warns} · deny ${r.denies} · exempt ${r.exempts} · abiertas ${r.open}`);
     }
-    logger.info?.(`concesiones: vivas ${g.alive.length} (próximas a vencer ${g.soon.length}) · vencidas ${g.expired.length} · puntuales ${g.point}`);
-    for (const e of g.alive) logger.info?.(`  [${e.rule_id}] hasta ${e.expiresAt} — ${e.who?.git ?? "?"}: ${e.justification ?? "sin justificación"}`);
+    // Con 0 globales el resumen queda EXACTAMENTE como siempre (hay consumidores de texto).
+    const globals = g.alive.filter((e) => e.origin === "global").length;
+    logger.info?.(`concesiones: vivas ${g.alive.length} (${globals > 0 ? `${globals} globales, ` : ""}próximas a vencer ${g.soon.length}) · vencidas ${g.expired.length} · puntuales ${g.point}`);
+    for (const e of g.alive) logger.info?.(`  [${e.rule_id}] hasta ${e.expiresAt}${e.origin === "global" ? " [global]" : ""} — ${e.who?.git ?? "?"}: ${e.justification ?? "sin justificación"}`);
     logger.info?.(report.signals.length > 0 ? "señales:" : "señales: ninguna");
     for (const s of report.signals) logger.warn?.(`  ⚠ ${s}`);
     return chain.ok ? 0 : 1;

package/src/commands/review-gate.js

@@ -52,6 +52,13 @@ async function rawDiff(range, extraArgs = []) {
   return res.stdout;
 }
 
+// KJC-TSK-0813 (AC3): la exención dice su PROCEDENCIA — un standing global
+// (concedido para toda la máquina) no pasa por uno del proyecto. El texto
+// de las de proyecto queda EXACTAMENTE como estaba.
+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) {
   if (record.verdict === "approved") {
     const ws = record.workspace ? ` [${record.workspace}]` : "";
@@ -257,11 +264,7 @@ export async function reviewGateCommand({ config, logger = null, flags = {} }) {
   });
   const at = (v) => (v.file ? ` (${v.file})` : "");
   for (const w of gate.warns) console.log(`⚠ policy [${w.rule_id}] ${w.reason}${at(w)}`);
-  for (const e of gate.exempted) {
-    console.log(e.standing
-      ? `⚠ policy standing [${e.rule_id}] — excepción permanente 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})`);
-  }
+  for (const e of gate.exempted) console.log(formatExempted(e));
   // GOV-C (KJC-TSK-0747): las decisiones de chokepoint dejan rastro
   // hash-encadenado — cada deny, cada excepción, y el allow del commit.
   const chokepoint = flags.check ? "commit" : "review";