simt-dev 0.3.0 → 0.4.0

package/src/commands/index.mjs

@@ -25,6 +25,7 @@ import {
   whyCommand as skillsWhy,
   evalCommand as skillsEval,
 } from './skills.mjs';
+import { briefCommand } from './brief.mjs';
 import { syncCommand, checkCommand } from './sync.mjs';
 import { initCommand } from './init.mjs';
 import { ciCommand } from './ci.mjs';
@@ -34,6 +35,7 @@ import { compareCommand } from './compare.mjs';
 import { upgradeCommand } from './upgrade.mjs';
 import { mcpCommand } from './mcp.mjs';
 import { installCommand } from './skillsinstall.mjs';
+import { compileCommand } from './skillscompile.mjs';
 import { listCommand as rulesList, showCommand as rulesShow, whyCommand as rulesWhy } from './rules.mjs';
 import { tokensCommand } from './tokens.mjs';
 import { harnessCommand, harnessLoadersCommand } from './harness.mjs';
@@ -43,9 +45,22 @@ import {
   benchReportCommand,
   benchAblateCommand,
   benchProbesCommand,
+  benchVariantsCommand,
 } from './bench.mjs';
 import { planCommand } from './plan.mjs';
+import { sharedPlanCommand, sharedInstallCommand, sharedWarning } from './shared.mjs';
+import { evidenceCommand } from './evidence.mjs';
+import { indexCommand } from './repoindex.mjs';
+import { mapCommand } from './map.mjs';
+import { testsCommand } from './tests.mjs';
+import { whyCommand } from './why.mjs';
+import { gateCommand } from './gate.mjs';
+import { impactCommand } from './impact.mjs';
+import { lessonsListCommand, lessonsReviewCommand } from './lessons.mjs';
+import { decideCommand } from './decide.mjs';
+import { localDoctorCommand } from './local.mjs';
 import { parse } from '../argv.mjs';
+import { CLI } from '../name.mjs';
 import { fingerprint } from '../resolve/fingerprint.mjs';
 import { resolveWorkspace } from '../workspace.mjs';
 
@@ -66,6 +81,13 @@ const GROUPS = new Map([
   ['agent-hooks', 'status'],
   ['harness', 'detect'],
   ['bench', 'mine'],
+  // ADR-084. `shared` is the one group whose default writes nothing, and it is `plan` for
+  // the same reason `skills`'s is `index`: the read answers "what would this do, and
+  // where", and `install` — the subcommand that touches a reader's home directory — is the
+  // one that needs `--yes` before it does anything.
+  ['shared', 'plan'],
+  ['lessons', 'list'],
+  ['local', 'doctor'],
 ]);
 
 /**
@@ -82,6 +104,7 @@ const GROUPS = new Map([
  * just correct: nothing in the map depends on the call.
  */
 export const IMPLEMENTED = {
+  brief: briefCommand,
   doctor: runDoctor,
   'graph lint': lintCommand,
   'skills index': skillsIndex,
@@ -91,6 +114,7 @@ export const IMPLEMENTED = {
   'skills why': skillsWhy,
   'skills eval': skillsEval,
   'skills install': installCommand,
+  'skills compile': compileCommand,
   'rules list': rulesList,
   'rules show': rulesShow,
   'rules why': rulesWhy,
@@ -99,6 +123,20 @@ export const IMPLEMENTED = {
   'plan status': (args, flags) => planCommand('status', args, flags),
   'plan next': (args, flags) => planCommand('next', args, flags),
   'plan done': (args, flags) => planCommand('done', args, flags),
+  'shared plan': sharedPlanCommand,
+  'shared install': sharedInstallCommand,
+  evidence: evidenceCommand,
+  index: indexCommand,
+  map: mapCommand,
+  tests: testsCommand,
+  why: (args, flags) => whyCommand(args, flags, COMMANDS),
+  gate: gateCommand,
+  impact: (args, flags) => impactCommand(args, flags, COMMANDS),
+  'lessons list': lessonsListCommand,
+  'lessons review': lessonsReviewCommand,
+  decide: decideCommand,
+  'local doctor': localDoctorCommand,
+  'evidence check': (args, flags) => evidenceCommand(['check', ...args], flags),
   init: initCommand,
   ci: ciCommand,
   'hooks install': (args, flags) => hooksCommand('install', args, flags),
@@ -116,6 +154,7 @@ export const IMPLEMENTED = {
   'bench report': benchReportCommand,
   'bench ablate': benchAblateCommand,
   'bench probes': benchProbesCommand,
+  'bench variants': benchVariantsCommand,
   upgrade: upgradeCommand,
   mcp: mcpCommand,
 };
@@ -163,7 +202,7 @@ export async function dispatch(argv) {
     // simt-dev: they run this tool, not its source tree. The step number is the
     // stable handle; the file that documents it is an implementation detail.
     return fail(
-      `\`simt-dev ${path}\` is declared but not implemented`,
+      `\`${CLI} ${path}\` is declared but not implemented`,
       EXIT.UNSUPPORTED,
       `implementation step ${step} is not built yet`,
     );
@@ -220,6 +259,13 @@ async function runDoctor(positional, flags) {
   // answer confidently wrong, so the answer is reported rather than inferred
   // (ADR-014).
   const ws = await resolveWorkspace(flags);
+  // The shared file this repository hands rules to (ADR-084). Asked here and nowhere else
+  // because it is the one thing about a repository that is true of the reader's machine
+  // rather than of the tree: `check` must not read `$HOME`, so `doctor` is the only command
+  // that can notice a region that dropped rules into a file nobody has. Reported, never
+  // blocking — a stale copy costs a reader some of their rules, which is worth knowing and
+  // is not this repository's gate failing.
+  const shared = await sharedWarning(root, result.manifest ?? null, flags);
 
   // Under `--json` the document is the whole report, so it has to carry both
   // failures the text path reports AND the workspace answer the text path prints.
@@ -254,6 +300,7 @@ async function runDoctor(positional, flags) {
         detail: ws.detail,
         error: ws.error ?? null,
       },
+      shared,
       ...(failure ?? {}),
     });
     return code;
@@ -276,6 +323,10 @@ async function runDoctor(positional, flags) {
       }`,
       `manifest ${result.manifest ? (result.manifest.error ?? result.manifest.id ?? 'present') : '(absent)'}`,
       `workspace ${ws.root ?? '(none)'}  (${ws.source}: ${ws.detail})`,
+      // Printed only when this repository handed rules to a workspace copy: a line in
+      // every `doctor` is a line in every reader's terminal, and the reader who has
+      // nothing to install is not served by one (ADR-084).
+      ...(shared.declared ? [`shared    ${shared.state}  ${shared.detail}`] : []),
     ].join('\n'),
     { maxBytes: flags.maxBytes ?? 0 },
   );

package/src/commands/lessons.mjs

@@ -0,0 +1,127 @@
+// `simt lessons [list|review]` — deterministic lesson candidates and promotion to
+// `docs/lessons/NNNN-<slug>.md` (plan 0003 R32).
+
+import { resolve } from 'node:path';
+
+import { EXIT, emit, emitJson, fail, isJson, note, writeMode } from '../output/index.mjs';
+import { CLI } from '../name.mjs';
+import { parsePathList } from '../argv.mjs';
+import {
+  LESSONS_DIR,
+  LESSONS_FILE,
+  captureFromLedger,
+  captureRevertedCommits,
+  listPromotedLessons,
+  promoteLesson,
+  readLessonCandidates,
+} from '../memory/lessons.mjs';
+
+export async function lessonsListCommand(args, flags) {
+  if (args.length > 0) {
+    return fail(`unknown lessons argument ${args[0]}`, EXIT.USAGE, `run: ${CLI} lessons`);
+  }
+  const root = resolve(flags.root ?? process.cwd());
+  await captureFromLedger(root);
+  await captureRevertedCommits(root);
+
+  const [{ candidates, errors }, promoted] = await Promise.all([
+    readLessonCandidates(root),
+    listPromotedLessons(root),
+  ]);
+
+  const payload = {
+    ok: errors.length === 0,
+    command: 'lessons list',
+    root,
+    ledgerFile: LESSONS_FILE,
+    lessonsDir: LESSONS_DIR,
+    candidateCount: candidates.length,
+    promotedCount: promoted.length,
+    candidates,
+    promoted,
+    errors,
+  };
+
+  if (isJson(flags)) {
+    emitJson(payload, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
+    return errors.length === 0 ? EXIT.OK : EXIT.FAIL;
+  }
+
+  const lines = [
+    `candidates  ${candidates.length} (${LESSONS_FILE})`,
+    `promoted    ${promoted.length} (${LESSONS_DIR})`,
+  ];
+
+  if (candidates.length > 0) {
+    lines.push('', 'CANDIDATES');
+    for (const c of candidates) {
+      const sigShort = c.signature.slice(0, 19);
+      const state = c.status === 'promoted' ? `promoted -> ${c.promotedTo}` : 'candidate';
+      lines.push(`  ${c.id}  ${c.kind.padEnd(14)}  ${sigShort}  ${state}  ${c.summary}`);
+    }
+  }
+
+  if (promoted.length > 0) {
+    lines.push('', 'LESSONS');
+    for (const l of promoted) {
+      lines.push(`  ${l.id.padEnd(28)}  ${(l.signature ?? 'no-signature').slice(0, 19)}  ${l.title}`);
+    }
+  }
+
+  for (const err of errors) lines.push(`error       ${err}`);
+
+  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  return errors.length === 0 ? EXIT.OK : EXIT.FAIL;
+}
+
+export async function lessonsReviewCommand(args, flags) {
+  if (args.length > 1) {
+    return fail(`unknown lessons review argument ${args[1]}`, EXIT.USAGE, `run: ${CLI} lessons review [<id>] [--yes]`);
+  }
+  const root = resolve(flags.root ?? process.cwd());
+  const mode = writeMode(flags);
+  const parsedPaths = parsePathList(flags.paths);
+  const paths = parsedPaths.length > 0 ? parsedPaths : undefined;
+  const title = flags.task ? String(flags.task) : undefined;
+
+  const result = await promoteLesson(root, {
+    id: args[0],
+    apply: mode.apply,
+    paths,
+    title,
+  });
+
+  if (!result.ok) {
+    return fail(result.error, EXIT.FAIL, `record a session failure-then-fix or run: ${CLI} lessons`);
+  }
+
+  const payload = {
+    ok: true,
+    command: 'lessons review',
+    root,
+    dryRun: mode.dryRun,
+    written: result.written,
+    path: result.path,
+    candidate: result.candidate,
+    markdown: result.markdown,
+  };
+
+  if (isJson(flags)) {
+    emitJson(payload, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
+    return EXIT.OK;
+  }
+
+  const lines = [
+    `promote     ${result.candidate.id} (${result.candidate.kind}) -> ${result.path}`,
+    `signature   ${result.candidate.signature}`,
+    `mode        ${mode.apply ? 'applied' : mode.dryRun ? 'dry-run (writes nothing)' : `preview (pass --yes to write ${result.path})`}`,
+    '',
+    result.markdown.trimEnd(),
+  ];
+
+  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  if (!mode.apply) {
+    note(`note    dry-run  nothing written; apply with: ${CLI} lessons review --yes`);
+  }
+  return EXIT.OK;
+}

package/src/commands/local.mjs

@@ -0,0 +1,97 @@
+// `simt local doctor` — probe configured local model endpoints (plan 0003 R37).
+//
+// Reads `local: { chat: { url, model }, embed: { url, model } }` from `simt.json`.
+// When `local` is unset, opens no socket and exits 0. Refuses non-loopback URLs
+// without `--allow-remote` (ADR-075).
+
+import { resolve } from 'node:path';
+import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
+import { CLI, MANIFEST_FILE } from '../name.mjs';
+import { probeLocal } from '../local/client.mjs';
+
+function formatRoleLine(role, report) {
+  if (!report) return `${role.padEnd(8)} (unset)`;
+  if (report.status === 'refused-remote') {
+    return `${role.padEnd(8)} refused-remote  ${report.model} @ ${report.url}`;
+  }
+  if (!report.ok) {
+    return `${role.padEnd(8)} ${report.status}  ${report.model} @ ${report.url} (${report.error})`;
+  }
+  const extra =
+    role === 'embed' && Number.isInteger(report.dimensions)
+      ? `  dimensions=${report.dimensions}`
+      : '';
+  const listed =
+    report.modelListed === true
+      ? '  listed=yes'
+      : report.modelListed === false
+        ? '  listed=no'
+        : '';
+  return `${role.padEnd(8)} ok  ${report.model} @ ${report.url}${extra}${listed}`;
+}
+
+function remedyFor(result) {
+  if (result.status === 'refused-remote') {
+    return `set a loopback URL (http://127.0.0.1:<port>/v1) in ${MANIFEST_FILE}, or run: ${CLI} local doctor --allow-remote`;
+  }
+  if (result.status === 'invalid-config' || result.status === 'invalid-manifest') {
+    return `fix the \`local\` configuration in ${MANIFEST_FILE}`;
+  }
+  if (result.status === 'unreachable') {
+    return `start the local model server at the URL in ${MANIFEST_FILE}, then rerun: ${CLI} local doctor`;
+  }
+  return null;
+}
+
+export async function localDoctorCommand(args, flags) {
+  const root = resolve(flags.root ?? args[0] ?? process.cwd());
+  const allowRemote = flags.allowRemote === true;
+  const result = await probeLocal(root, { allowRemote });
+
+  const code = result.ok
+    ? EXIT.OK
+    : result.status === 'refused-remote' ||
+        result.status === 'invalid-config' ||
+        result.status === 'invalid-manifest'
+      ? EXIT.CONFIG
+      : EXIT.FAIL;
+
+  const error = result.ok ? null : result.findings[0] ?? `local model probe failed (${result.status})`;
+  const remedy = result.ok ? null : remedyFor(result);
+
+  if (isJson(flags)) {
+    emitJson(
+      {
+        ok: code === EXIT.OK,
+        command: 'local doctor',
+        root,
+        configured: result.configured,
+        status: result.status,
+        allowRemote: result.allowRemote,
+        remoteBlocked: result.remoteBlocked,
+        socketsOpened: result.socketsOpened,
+        chat: result.chat,
+        embed: result.embed,
+        findings: result.findings,
+        ...(error ? { error, remedy, exitCode: code } : {}),
+      },
+      { maxBytes: flags.maxBytes ?? 0 },
+    );
+    return code;
+  }
+
+  const lines = [
+    `root     ${root}`,
+    `local    ${result.configured ? result.status : '(unset)  optional adapter is off; no socket opened'}`,
+    formatRoleLine('chat', result.chat),
+    formatRoleLine('embed', result.embed),
+    `sockets  ${result.socketsOpened}`,
+  ];
+
+  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+
+  if (!result.ok) {
+    return fail(error, code, remedy);
+  }
+  return EXIT.OK;
+}

package/src/commands/map.mjs

@@ -0,0 +1,126 @@
+// `simt map` ranks the files a task is most likely to touch (R22, ADR-091).
+// The cache is read, and rebuilt once when it is empty, because a map of no
+// files is not an answer. The rebuild writes the gitignored index, which is
+// the same cache `simt index` writes.
+
+import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
+import { CLI } from '../name.mjs';
+import { readEdges, readEmbeddings, readFiles, readFts, readSymbols, reindex, searchFtsBm25 } from '../index/store.mjs';
+import {
+  DEFAULT_BUDGET,
+  embedTaskQuery,
+  formatRecall,
+  measureRecall,
+  rankFiles,
+  renderMap,
+} from '../index/map.mjs';
+
+const LEVELS = new Set(['outline', 'names', 'signatures']);
+
+export async function mapCommand(args, flags) {
+  if (args.length > 0) return fail(`unknown map argument ${args[0]}`, EXIT.USAGE, `run: ${CLI} map`);
+  const root = flags.root ?? process.cwd();
+  if (flags.recall === true) return recall(root, flags);
+  const level = flags.level ?? 'outline';
+  if (!LEVELS.has(level)) {
+    return fail(`unknown level ${level}`, EXIT.USAGE, 'use outline, names or signatures');
+  }
+  const budget = flags.budget === undefined ? DEFAULT_BUDGET : Number(flags.budget);
+  if (!Number.isInteger(budget) || budget < 0) {
+    return fail(`budget must be a non-negative integer`, EXIT.USAGE, `run: ${CLI} map --budget 2048`);
+  }
+  const loaded = await loadGraph(root);
+  if (loaded.error) return loaded.error;
+  const task = typeof flags.task === 'string' ? flags.task : '';
+  const bm25 = task.trim().length > 0 ? await searchFtsBm25(root, task, { fts: loaded.fts }) : [];
+  const queryVector =
+    flags.embed === true && loaded.embeddings.length > 0
+      ? await embedTaskQuery(root, task, {
+          embed: true,
+          allowRemote: flags.allowRemote === true,
+        })
+      : null;
+  const ranked = rankFiles({ ...loaded, bm25, queryVector, task });
+  const rendered = renderMap(ranked, loaded.symbols, { level, budget });
+  const payload = {
+    ok: true,
+    command: 'map',
+    root,
+    level,
+    budget,
+    shown: rendered.shown,
+    total: rendered.total,
+    truncated: rendered.truncated,
+    files: rendered.files,
+    text: rendered.text,
+  };
+  if (isJson(flags)) {
+    emitJson(payload, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
+    return EXIT.OK;
+  }
+  const lines = [
+    `level    ${level}`,
+    `shown    ${rendered.shown}`,
+    `total    ${rendered.total}`,
+    `budget   ${budget}`,
+  ];
+  if (rendered.text) lines.push(rendered.text);
+  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  return EXIT.OK;
+}
+
+async function recall(root, flags) {
+  let result;
+  try {
+    result = await measureRecall(root, {
+      embed: flags.embed === true,
+      allowRemote: flags.allowRemote === true,
+    });
+  } catch (error) {
+    return fail(`could not measure recall (${error.message})`, EXIT.UNSUPPORTED, `run ${CLI} index in a git repository`);
+  }
+  const payload = { ok: true, command: 'map', root, recall: result };
+  if (isJson(flags)) {
+    emitJson(payload, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
+    return EXIT.OK;
+  }
+  emit(formatRecall(result), { maxBytes: flags.maxBytes ?? 0 });
+  return EXIT.OK;
+}
+
+/**
+ * The files, symbols, edges, FTS rows and stored vector embeddings the index holds,
+ * building the index once when it is empty.
+ *
+ * `build: false` refuses that rebuild and answers with `cold: true` instead. The one
+ * caller that passes it is the prompt-submit hook (R29), and the reason is the bar that
+ * hook has to meet: a delivered packet that built an index would make a person's first
+ * prompt in a fresh clone wait on a walk of the whole repository, and a prompt that takes
+ * a minute to appear is how a hook gets uninstalled. The next prompt gets the packet, and
+ * a command a person typed at a terminal always builds what it needs.
+ */
+export async function loadGraph(root, { build = true } = {}) {
+  let files = await readFiles(root);
+  if (files.length === 0) {
+    if (!build) return { files: [], symbols: [], edges: [], fts: [], embeddings: [], cold: true };
+    try {
+      await reindex(root);
+    } catch (error) {
+      return {
+        error: fail(
+          `could not map this repository (${error.message})`,
+          EXIT.UNSUPPORTED,
+          'run this inside a git repository',
+        ),
+      };
+    }
+    files = await readFiles(root);
+  }
+  const [symbols, edges, fts, embeddings] = await Promise.all([
+    readSymbols(root),
+    readEdges(root),
+    readFts(root),
+    readEmbeddings(root),
+  ]);
+  return { files, symbols, edges, fts, embeddings };
+}

package/src/commands/repoindex.mjs

@@ -0,0 +1,55 @@
+// `simt index` rebuilds the local cache from git. The cache is not repository
+// content: it is gitignored, and a second run with the same blobs writes the same
+// rows (ADR-089).
+
+import { execFile } from 'node:child_process';
+
+import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
+import { CLI } from '../name.mjs';
+import { JSONL_FILE, SQLITE_FILE, reindex } from '../index/store.mjs';
+
+export async function indexCommand(args, flags) {
+  if (args.length > 0) return fail(`unknown index argument ${args[0]}`, EXIT.USAGE, `run: ${CLI} index`);
+  const root = flags.root ?? process.cwd();
+  let result;
+  try {
+    result = await reindex(root, {
+      embed: flags.embed === true,
+      allowRemote: flags.allowRemote === true,
+    });
+  } catch (error) {
+    return fail(
+      `could not index this repository (${error.message})`,
+      EXIT.UNSUPPORTED,
+      'run this inside a git repository',
+    );
+  }
+  const file = result.backend === 'sqlite' ? SQLITE_FILE : JSONL_FILE;
+  const ignored = await isIgnored(root, file);
+  const payload = { ok: true, command: 'index', root, file, ignored, ...result };
+  if (isJson(flags)) {
+    emitJson(payload, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
+    return EXIT.OK;
+  }
+  const lines = [
+    `index    ${result.backend}`,
+    `files    ${result.files}`,
+    `updated  ${result.updated}`,
+    `removed  ${result.removed}`,
+    `symbols  ${result.symbols}`,
+    `edges    ${result.edges}`,
+    `ms       ${result.ms}`,
+  ];
+  if (result.parsers === 'missing') lines.push('note     index.parsers did not load, so the built-in extractors ran');
+  if (!ignored) lines.push(`note     ${file} is not gitignored, and the cache is not meant to be committed`);
+  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  return EXIT.OK;
+}
+
+function isIgnored(root, file) {
+  return new Promise((resolve) => {
+    execFile('git', ['check-ignore', '-q', '--', file], { cwd: root }, (error) => {
+      resolve(!error);
+    });
+  });
+}

package/src/commands/rules.mjs

@@ -14,6 +14,8 @@
 // one, because "this rule has no decision behind it" is exactly the fact a
 // reviewer needs and exactly the fact an empty output would hide.
 
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
 import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
 import { loadRules, select } from '../projection/project.mjs';
 import { loadMdcRules } from '../projection/mdc.mjs';
@@ -217,10 +219,17 @@ export async function whyCommand(args, flags) {
   if (!what) return fail('rules why needs a rule id or an ADR id', EXIT.USAGE, `usage: ${CLI} rules why <rule-id|ADR-NNN>`);
 
   const { rules, broken } = await load(flags.root ?? null);
-  const { ok, decisions, errors } = await loadDecisions({ all: flags.all === true });
+  const localDir = flags.root ? join(flags.root, 'docs', 'decisions') : null;
+  const hasLocal = localDir
+    ? (await readdir(localDir).catch(() => [])).some((n) => /^ADR-\d{3,}-.*\.md$/i.test(n))
+    : false;
+  const { ok, decisions, errors } = await loadDecisions({
+    all: flags.all === true,
+    ...(hasLocal ? { dir: localDir } : {}),
+  });
   if (!ok) return fail(errors[0], EXIT.CONFIG, 'the decision records must be readable for provenance to work');
 
-  return what.match(/^ADR-\d{3}$/i)
+  return what.match(/^ADR-\d{3,}$/i)
     ? adrDirection(what.toUpperCase(), rules, decisions, flags)
     : ruleDirection(what, rules, decisions, flags, broken);
 }
@@ -326,6 +335,12 @@ async function adrDirection(adr, rules, decisions, flags) {
   ];
   if (d.supersededBy) lines.push(`SUPERSEDED by ${d.supersededBy} - this record is retained as evidence, not as policy.`);
   if (d.supersedes.length > 0) lines.push(`supersedes  ${d.supersedes.join(', ')}`);
+  const partialForward = (d.supersedesRulings ?? []).filter((s) => s.ruling !== null);
+  if (partialForward.length > 0) {
+    lines.push(
+      `supersedes  ${partialForward.map((s) => `${s.adr} ruling ${s.ruling} (${s.kind})`).join('; ')}`,
+    );
+  }
   // A partial supersession is named here as well as on the ruling it moved, because the
   // two print different sets: this prints every ruling the record lost, and the
   // annotation prints the ones inside the excerpt below. A ruling past the excerpt