karajan-code 4.21.0 → 4.22.0

package/src/harden/sentinel-hooks.js

@@ -29,7 +29,7 @@ const LIB_BODY = `// kj sentinel shared lib (KJC-TSK-0714) — managed by \`kj h
 // Single source for every sentinel script: state, branch, classification,
 // violations, and escape recording.
 import { readFileSync, writeFileSync } from "node:fs";
-import { execSync } from "node:child_process";
+import { execSync, spawnSync } from "node:child_process";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 const here = dirname(fileURLToPath(import.meta.url));
@@ -85,6 +85,18 @@ export const recordEscape = (sid, escape, tool) => {
   if (!s.escapes.includes(escape)) s.escapes.push(escape);
   (state.escape_events ||= []).push({ escape, tool, sid, ts: Date.now() });
   save(state);
+  // GOV-F (KJC-TSK-0768): el escape es una excepcion consciente — entra en el
+  // decision log hash-encadenado (kj policy seal), no solo en este estado.
+  // Best-effort CON aviso: fail-closed aqui encerraria la sesion justo cuando
+  // kj no carga, que es cuando mas se usa el escape (restaurar con git).
+  try {
+    const args = ["policy", "seal", "--escape", escape];
+    if (tool) args.push("--tool", String(tool));
+    const r = spawnSync("kj", args, { cwd: ROOT, encoding: "utf8" });
+    if (r.error || r.status !== 0) console.error("kj sentinel: escape " + escape + " usado pero NO sellado en el decision log (kj policy seal " + (r.error ? r.error.message : "exit " + r.status) + ") — revisa kj; el escape queda solo en sentinel-state.json");
+  } catch (e) {
+    console.error("kj sentinel: escape " + escape + " usado pero NO sellado en el decision log: " + e.message);
+  }
 };
 `;
 
@@ -112,9 +124,11 @@ process.stdin.on("end", () => {
     const clearPending = (cardId) => {
       const state = load();
       const s = session(state, sid);
-      const before = (s.pending_moves || []).length;
       s.pending_moves = (s.pending_moves || []).filter((p) => p.card !== null && p.card !== cardId);
-      if (s.pending_moves.length !== before) save(state);
+      // KJC-TSK-0774: a card closed this turn is what the Stop hook points the
+      // user at when the focus comes back (the board is where to look).
+      if (cardId && !(s.closed_cards ||= []).includes(cardId)) s.closed_cards.push(cardId);
+      save(state);
     };
     if (/__update_card$/.test(String(tool)) && /^mcp__/.test(String(tool))) {
       // The MCP response reaches the hook as {content:[{text:"<json>"}]}: once
@@ -133,20 +147,30 @@ process.stdin.on("end", () => {
       const mergeCmd = /\\bgh\\s+pr\\s+merge(\\s+(\\d+))?/.exec(cmdText);
       const said = /merged pull request #(\\d+)/i.exec(text);
       let mergedPr = said ? Number(said[1]) : null;
-      if (mergedPr === null && mergeCmd) {
-        const args = ["pr", "view", ...(mergeCmd[2] ? [mergeCmd[2]] : []), "--json", "number,state"];
+      // KJC-BUG-0148: the card belongs to the PR's HEAD branch, not to whatever
+      // branch the working tree happens to be on (found live: a merge issued
+      // from another card's lane pinned the pending move on the wrong card).
+      let headRef = null;
+      if (mergeCmd || said) {
+        const n = said ? said[1] : mergeCmd[2];
+        const args = ["pr", "view", ...(n ? [n] : []), "--json", "number,state,headRefName"];
         const r = spawnSync("gh", args, { cwd: ROOT, encoding: "utf8" });
-        try { const v = JSON.parse(r.status === 0 ? r.stdout : "null"); if (v && v.state === "MERGED") mergedPr = Number(v.number); } catch { /* unknown = not confirmed */ }
+        try {
+          const v = JSON.parse(r.status === 0 ? r.stdout : "null");
+          if (v && v.state === "MERGED") { mergedPr = Number(v.number); headRef = v.headRefName || null; }
+        } catch { /* unknown = not confirmed (or confirmed only by the printed line) */ }
       }
       if (mergedPr !== null) {
         const state = load();
         const s = session(state, sid);
-        const ref = CARD.exec(branchOf() || "");
-        (s.pending_moves ||= []).push({ card: ref ? ref[0].toUpperCase() : null, pr: mergedPr, at: Date.now() });
+        const ref = CARD.exec(headRef || branchOf() || "");
+        (s.pending_moves ||= []).push({ card: ref ? ref[0].toUpperCase() : null, pr: mergedPr, at: Date.now(), ...(headRef ? {} : { head: "unknown" }) });
         save(state);
       }
       const moved = /kj\\s+hu\\s+move\\s+([A-Za-z0-9-]+)\\s+([a-z&-]+)/i.exec(String(input.command || ""));
-      if (moved && CLOSING.includes(moved[2].toLowerCase()) && !/error|fail/i.test(text)) clearPending(moved[1].toUpperCase());
+      // "not found" counts as failure (KJC-BUG-0154): a move that moved nothing must not
+      // clear a pending — that would discard a LEGITIMATE one without touching the tracker.
+      if (moved && CLOSING.includes(moved[2].toLowerCase()) && !/error|fail|not found/i.test(text)) clearPending(moved[1].toUpperCase());
       process.exit(0);
     }
     const file = input.file_path || input.notebook_path;
@@ -177,7 +201,19 @@ const STOP_BODY = `#!/usr/bin/env node
 // after 3 unresolved blocks — a sentinel bug never bricks the session — and
 // the fail-open is recorded in the state. \`--status\` prints, never blocks.
 import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 import { load, save, branchOf, violations, ROOT } from "./sentinel-lib.mjs";
+// KJC-TSK-0774: when the turn ends green with cards closed, remind the user
+// where to look — the board URL if it runs (pid file alive), else how to start it.
+const boardHint = () => {
+  const home = process.env.KARAJAN_HOME || process.env.KJ_HOME || join(homedir(), ".karajan");
+  try {
+    process.kill(Number(readFileSync(join(home, "hu-board.pid"), "utf8").trim()), 0);
+    return "http://localhost:" + (process.env.KJ_BOARD_PORT || "4000") + "/#governance";
+  } catch { return "no esta arrancado: kj board start (luego http://localhost:4000/#governance)"; }
+};
 if (process.argv.includes("--status")) {
   const st = load();
   const branch = branchOf();
@@ -221,9 +257,14 @@ process.stdin.on("end", () => {
     const v = violations(s, branchOf());
     if (!v.length) {
       s.blocks = 0;
+      const notes = [];
+      if ((s.escapes || []).length) notes.push("kj sentinel: esta sesion uso " + s.escapes.length + " escape(s): " + s.escapes.join(", ") + " — decision registrada; detalle en kj sentinel status.");
+      if ((s.closed_cards || []).length) {
+        notes.push("kj sentinel: card(s) cerrada(s) en este turno: " + s.closed_cards.join(", ") + " — el board las muestra: " + boardHint());
+        s.closed_cards = [];
+      }
       save(state);
-      if ((s.escapes || []).length)
-        console.log(JSON.stringify({ systemMessage: "kj sentinel: esta sesion uso " + s.escapes.length + " escape(s): " + s.escapes.join(", ") + " — decision registrada; detalle en kj sentinel status." }));
+      if (notes.length) console.log(JSON.stringify({ systemMessage: notes.join("\\n") }));
       process.exit(0);
     }
     s.blocks = (s.blocks || 0) + 1;
@@ -313,11 +354,36 @@ process.stdin.on("end", () => {
         if (tok === name + "=1") found = true;
       }
       if (!found) return false;
-      for (const c of CMD_TEXT) {
-        if (c === ";" || c === "|" || c === "&" || c === ESC_NL || c === ESC_BT) return false;
-        if (c === "$" || c === "(" || c === ")") return false;
+      // KJC-BUG-0147: lo que va ENTRE COMILLAS no encadena comandos — un
+      // mensaje "fix(x): ... (KJC-TSK-1)" es un comando simple. Dentro de
+      // comillas dobles $ y backtick siguen expandiendo (se rechazan); en
+      // comillas simples todo es literal. Y si el escape esta pero se ignora,
+      // SE DICE: un escape ignorado en silencio era el bug.
+      const bad = escSimple();
+      if (bad === null) return true;
+      if (!escNoted.has(name)) {
+        escNoted.add(name);
+        console.error("kj sentinel: " + name + "=1 presente pero IGNORADO — el escape solo vale en un comando simple y este contiene " + JSON.stringify(bad) + " fuera de comillas simples (sin ; | & $ ( ) backtick ni salto de linea: parte el comando o usa -F fichero)");
       }
-      return true;
+      return false;
+    };
+    const escNoted = new Set();
+    const escSimple = () => {
+      let q = null;
+      for (let i = 0; i < CMD_TEXT.length; i += 1) {
+        const c = CMD_TEXT[i];
+        if (q === "'") { if (c === "'") q = null; continue; }
+        if (q === '"') {
+          if (c === '"') q = null;
+          else if (c === "$" || c === ESC_BT) return c;
+          else if (c === "\\\\") i += 1;
+          continue;
+        }
+        if (c === "\\\\") { i += 1; continue; }
+        if (c === "'" || c === '"') { q = c; continue; }
+        if (c === ";" || c === "|" || c === "&" || c === ESC_NL || c === ESC_BT || c === "$" || c === "(" || c === ")") return c;
+      }
+      return q === null ? null : "comilla sin cerrar";
     };
     // IDN-B (KJC-TSK-0763, ADR 0005): identity lock — gh and mutating git never
     // run under an account other than the one THIS CLONE declared (the incident:
@@ -659,7 +725,15 @@ process.stdin.on("end", () => {
           process.exit(2);
         }
       } else if (PUSH.test(cmd)) {
-        const v = violations(load().sessions?.[sid], branchOf());
+        // KJC-BUG-0147: the board escape covers the push too — a pending move
+        // blocks the push like it blocks the commit, and the SAME conscious,
+        // recorded escape opens both (multi-PR cards are a legitimate plan).
+        const sess = load().sessions?.[sid];
+        let v = violations(sess, branchOf());
+        if (v.length && pendingMoves(sess).length && escOn("KJ_ALLOW_BOARD")) {
+          recordEscape(sid, "KJ_ALLOW_BOARD", tool);
+          v = violations({ ...sess, pending_moves: [] }, branchOf());
+        }
         if (v.length) {
           console.error("kj sentinel: git push con el metodo en rojo:\\n" + v.map((x) => "- " + x).join("\\n") + "\\nResuelve antes de empujar. Estado: kj sentinel status");
           process.exit(2);

package/src/policy/exceptions.js

@@ -24,13 +24,23 @@ function defaultIdentity(projectDir) {
  * @returns {{standing: object[], discarded: number}}
  */
 export function loadStandingExceptions(projectDir) {
+  const { records, discarded } = loadExceptionRecords(projectDir);
+  return { standing: records.filter((rec) => rec.scopeKind === "permanente"), discarded };
+}
+
+/**
+ * TODOS los registros del jsonl (permanentes y puntuales) con el mismo parse
+ * tolerante — el informe (PL-E) cuenta también las puntuales.
+ * @returns {{records: object[], discarded: number}}
+ */
+export function loadExceptionRecords(projectDir) {
   let raw;
   try {
     raw = readFileSync(join(projectDir, ".karajan", "policy-exceptions.jsonl"), "utf8");
   } catch {
-    return { standing: [], discarded: 0 };
+    return { records: [], discarded: 0 };
   }
-  const standing = [];
+  const records = [];
   let discarded = 0;
   for (const line of raw.split("\n")) {
     if (!line.trim()) continue;
@@ -39,12 +49,12 @@ export function loadStandingExceptions(projectDir) {
       // JSON válido pero no-objeto (null, número…) es tan corrupto como el
       // que no parsea: se descarta contando (catch de codex, explícito).
       if (typeof rec !== "object" || rec === null) discarded += 1;
-      else if (rec.scopeKind === "permanente") standing.push(rec);
+      else records.push(rec);
     } catch {
       discarded += 1;
     }
   }
-  return { standing, discarded };
+  return { records, discarded };
 }
 
 function defaultAppend(projectDir, line) {

package/src/policy/report.js

@@ -0,0 +1,99 @@
+/**
+ * PL-E (KJC-TSK-0767) — el informe de policy, PURO (líneas del decision log +
+ * excepciones + policy + reloj ⇒ objeto determinista; cero I/O, cero LLM).
+ * Responde: ¿qué reglas avisan y cuánto (gana dientes con datos)?, ¿qué
+ * denegaciones siguen abiertas (la renuncia deja rastro)?, ¿qué concesiones
+ * viven, vencen o se renuevan (la renovación es señal)?
+ */
+import { verifyDecisionChain } from "@karajan-family/governance";
+
+const DAY_MS = 86_400_000;
+const WARN_SIGNAL_MIN = 5;
+
+/** enforcement/class de una regla según la policy cargada (null si no se sabe). */
+function ruleMeta(policy, ruleId) {
+  if (!policy) return {};
+  if (ruleId.startsWith("defaults.")) return { enforcement: "deny", class: "security" };
+  const m = /^roles\.([^.]+)\.([^.]+)/.exec(ruleId);
+  const spec = m ? policy.roles?.[m[1]]?.[m[2]] : policy.invariants?.find((i) => i.id === ruleId);
+  if (!spec) return {};
+  return { enforcement: spec.enforcement || "warn", ...(spec.class ? { class: spec.class } : {}) };
+}
+
+function parseDecisions(lines) {
+  const records = [];
+  let discarded = 0;
+  for (const line of lines) {
+    try {
+      const rec = JSON.parse(line);
+      if (typeof rec === "object" && rec !== null) records.push(rec);
+      else discarded += 1;
+    } catch {
+      discarded += 1;
+    }
+  }
+  return { records, discarded };
+}
+
+// Abiertas = denies posteriores al último allow/exempt: el log acaba en
+// rechazo sin que nada haya pasado después. Heurística declarada — el log
+// no lleva rama ni autor, así que no distingue "arreglado" de "abandonado".
+const lastResolvedIndex = (records) => records.findLastIndex((r) => r.decision === "allow" || r.decision === "exempt");
+
+function tallyRules(records, policy, lastResolved) {
+  const rules = new Map();
+  const row = (id) => {
+    if (!rules.has(id)) rules.set(id, { rule_id: id, ...ruleMeta(policy, id), warns: 0, denies: 0, exempts: 0, open: 0 });
+    return rules.get(id);
+  };
+  // Un sello lleva un rule_id por FICHERO violador: se cuentan decisiones
+  // por regla, no ficheros — de ahí el Set por entrada.
+  const ids = (list) => new Set(list ?? []);
+  records.forEach((rec, i) => {
+    for (const id of ids(rec.warn_rule_ids)) row(id).warns += 1;
+    if (rec.decision === "deny") for (const id of ids(rec.rule_ids)) { row(id).denies += 1; if (i > lastResolved) row(id).open += 1; }
+    if (rec.decision === "exempt") for (const id of ids(rec.rule_ids)) row(id).exempts += 1;
+  });
+  return [...rules.values()].toSorted((a, b) => (b.denies + b.warns) - (a.denies + a.warns));
+}
+
+function tallyGrants(exceptionRecords, now, soonDays) {
+  const perm = exceptionRecords.filter((e) => e?.scopeKind === "permanente");
+  // Una caducidad ilegible (NaN) NO está viva: la excepción falla cerrada.
+  const alive = [];
+  const expired = [];
+  for (const e of perm) (Date.parse(e.expiresAt) > now.getTime() ? alive : expired).push(e);
+  const soon = alive.filter((e) => Date.parse(e.expiresAt) - now.getTime() <= soonDays * DAY_MS);
+  const counts = Map.groupBy(perm, (e) => e.rule_id);
+  const renewals = [...counts].filter(([, v]) => v.length >= 2).map(([rule_id, v]) => ({ rule_id, count: v.length }));
+  return { alive, expired, soon, renewals, point: exceptionRecords.length - perm.length };
+}
+
+function signalsFor(rules, grants) {
+  const out = [];
+  for (const g of grants.renewals) out.push(`[${g.rule_id}] concedida ${g.count} veces — una excepción que se renueva ya no es una excepción: es la política pidiendo cambio (PR a .karajan/policy.yml)`);
+  for (const r of rules) {
+    if (r.warns >= WARN_SIGNAL_MIN && r.denies === 0 && r.enforcement !== "deny") out.push(`[${r.rule_id}] ha avisado ${r.warns} veces y nunca ha bloqueado — decide: promover a enforcement=deny o retirarla; un aviso perpetuo es ruido`);
+    if (r.open > 0) out.push(`[${r.rule_id}] ${r.open} denegación(es) abierta(s) — el log acaba en rechazo: ¿arreglo pendiente, excepción por pedir, o renuncia?`);
+  }
+  for (const g of grants.soon) out.push(`[${g.rule_id}] vence ${g.expiresAt} — al vencer vuelve a bloquear sola; renueva por su cauce o deja que caduque`);
+  return out;
+}
+
+/**
+ * @returns {{chain: object, decisions: object, rules: object[], grants: object, signals: string[]}}
+ */
+export function buildPolicyReport({ decisionLines = [], exceptionRecords = [], policy = null, now = new Date(), soonDays = 7 } = {}) {
+  const chain = decisionLines.length ? verifyDecisionChain(decisionLines) : { ok: true, length: 0 };
+  const { records, discarded } = parseDecisions(decisionLines);
+  const count = (d) => records.filter((r) => r.decision === d).length;
+  const chokepoints = Object.fromEntries([...Map.groupBy(records, (r) => r.chokepoint ?? "unknown")].map(([k, v]) => [k, v.length]));
+  const lastResolved = lastResolvedIndex(records);
+  const rules = tallyRules(records, policy, lastResolved);
+  const grants = tallyGrants(exceptionRecords, now, soonDays);
+  const decisions = {
+    total: records.length, discarded, allow: count("allow"), deny: count("deny"), exempt: count("exempt"),
+    open: records.filter((r, i) => r.decision === "deny" && i > lastResolved).length, chokepoints,
+  };
+  return { chain, decisions, rules, grants, signals: signalsFor(rules, grants) };
+}

package/src/review/card-first.js

@@ -14,7 +14,10 @@ const LIVE_STATUSES = new Set(["pending", "running", "failed"]);
 // Card-shaped reference: LIN-123, bb-002 and multi-segment ids like
 // KJC-TSK-0684 (optional middle segments) — tight enough to skip slugs.
 // Shared with the method report (MG-D): one pattern, one truth.
-export const CARD_REF_RE = /\b[a-z][a-z0-9]{1,9}(?:-[a-z][a-z0-9]{1,9})*-\d{1,6}\b/i;
+// The lookahead keeps a version tail from reading as a card (KJC-BUG-0154):
+// `chore/release-4.22.0` matched "release-4" at the dot's word boundary, and
+// the board-sync gate then demanded moving a card that exists nowhere.
+export const CARD_REF_RE = /\b[a-z][a-z0-9]{1,9}(?:-[a-z][a-z0-9]{1,9})*-\d{1,6}\b(?!\.\d)/i;
 const DEFAULT_EXEMPT_PREFIXES = ["chore/release-"];
 
 // Token-boundary match: BB-002 must not satisfy a branch that actually

package/src/review/one-shot-review.js

@@ -12,9 +12,10 @@ import { createAgent } from "../agents/index.js";
 import { resolveRole } from "../config/role-resolver.js";
 import { buildReviewerPrompt } from "../prompts/reviewer.js";
 import { resolveReviewProfile } from "./profiles.js";
-import { parseMaybeJsonString } from "./parser.js";
+import { parseMaybeJsonString, normalizeReviewPayload } from "./parser.js";
 import { detectAvailableAgents, detectHostAgent } from "../utils/agent-detect.js";
-import { saveVerdict } from "./verdict-store.js";
+import { saveVerdict, diffHash } from "./verdict-store.js";
+import { reportUnparseableVerdict } from "./unparseable-verdict.js";
 import { detectWorkspace } from "./workspace.js";
 import { isQuotaExhausted, candidateStatus, pickQuotaFallback, formatCandidateMenu } from "./reviewer-fallback.js";
 
@@ -103,9 +104,14 @@ export async function runOneShotReview({
     throw new Error(`reviewer ${activeReviewer} failed: ${result?.error || "no output"}`);
   }
 
-  const parsed = parseMaybeJsonString(result.output);
+  // KJC-BUG-0146, second half: parseMaybeJsonString only PARSES — it returns whatever JSON came
+  // back, wrapper and all. Yesterday's fix taught normalizeReviewPayload to unwrap {ok, result},
+  // but this path never called it, so the bug survived with a green test on the wrong function.
+  // A test can only prove the code it actually exercises.
+  const parsed = normalizeReviewPayload(parseMaybeJsonString(result.output));
   if (!parsed || typeof parsed.approved !== "boolean") {
-    throw new Error(`reviewer ${activeReviewer} returned no parseable verdict`);
+    // KJC-BUG-0146: keep the answer. Throwing it away is what left eight occurrences undiagnosed.
+    throw new Error(await reportUnparseableVerdict({ projectDir, reviewer: activeReviewer, output: result.output, hash: diffHash(diff) }));
   }
 
   return saveVerdict(projectDir, diff, {

package/src/review/parser.js

@@ -33,10 +33,19 @@ export function normalizeReviewPayload(payload) {
   if (isReviewPayload(payload)) return payload;
   if (Array.isArray(payload)) return findReviewInArray(payload);
 
+  // KJC-BUG-0146 — the verdict often arrives WRAPPED by the CLI that produced it:
+  // {"ok":true,"result":{approved,...}}. Only the string form was unwrapped, so a
+  // perfectly good approval from codex was thrown away as "no parseable verdict"
+  // eight times in three days. The evidence came from the raw answer this bug's
+  // first fix started saving.
   if (typeof payload.result === "string") {
     const parsedResult = parseMaybeJsonString(payload.result);
     if (parsedResult?.approved !== undefined) return parsedResult;
   }
+  if (payload.result && typeof payload.result === "object") {
+    const inner = normalizeReviewPayload(payload.result);
+    if (inner) return inner;
+  }
 
   return null;
 }

package/src/review/unparseable-verdict.js

@@ -0,0 +1,50 @@
+/**
+ * KJC-BUG-0146 — when a reviewer answers something the parser cannot read.
+ *
+ * Until now that answer was thrown away: the error said "no parseable verdict"
+ * and not one byte of what the reviewer actually replied survived. Eight
+ * occurrences produced zero evidence, which is why the bug stayed undiagnosed
+ * for two days. A failure nobody can inspect is a failure nobody can fix.
+ *
+ * So the raw answer is written next to the verdicts and an excerpt travels in
+ * the error. Nothing else changes: an unreadable answer is still a refusal,
+ * never a pass — it COULD be a rejection in the wrong shape, and switching to
+ * another reviewer would turn it into an approval.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const DIR = path.join(".karajan", "reviews");
+const EXCERPT = 400;
+
+/** One line about what came back, so the shape is visible without opening anything. */
+export function describeOutput(output) {
+  if (output === undefined || output === null) return "no output at all";
+  if (typeof output !== "string") return `${typeof output}, not a string`;
+  if (output.trim() === "") return "empty output";
+  return `${output.length} chars, starts with ${JSON.stringify(output.slice(0, 60))}`;
+}
+
+/**
+ * Writes the raw answer for inspection and returns the error message to raise.
+ * A failure to write is never allowed to hide the original problem.
+ * @param {{projectDir?: string, reviewer: string, output: unknown, hash: string, writeFile?: Function}} args
+ */
+export async function reportUnparseableVerdict({ projectDir = process.cwd(), reviewer, output, hash, writeFile = fs.writeFile }) {
+  const file = path.join(projectDir, DIR, `${hash}.unparseable.txt`);
+  const body = typeof output === "string" ? output : JSON.stringify(output ?? null, null, 2);
+  let saved = null;
+  try {
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, `reviewer: ${reviewer}\n\n${body}\n`, "utf8");
+    saved = file;
+  } catch {
+    // Could not save it — the excerpt below still travels, and the message says so.
+  }
+  const excerpt = typeof output === "string" && output.trim() ? `\n--- what ${reviewer} answered (first ${EXCERPT} chars) ---\n${output.slice(0, EXCERPT)}\n---` : "";
+  return [
+    `reviewer ${reviewer} returned no parseable verdict (${describeOutput(output)})`,
+    saved ? `full answer saved to ${path.relative(projectDir, saved)}` : "the full answer could NOT be saved to disk",
+    "an unreadable answer is a refusal, not a pass: it may be a rejection in the wrong shape (KJC-BUG-0146)",
+  ].join("\n") + excerpt;
+}