@xhulz/nina 0.47.0 → 0.49.0

package/releases/0.49.0/surfaces/prisma/tree/.claude/agents/integration-tester.md

@@ -0,0 +1,2 @@
+<!-- nina:slot prisma.1 -->
+| `prisma-cli` | a Prisma CLI command |

package/releases/0.49.0/surfaces/prisma/tree/.claude/agents/reviewer.md

@@ -0,0 +1,2 @@
+<!-- nina:slot prisma.1 -->
+| `prisma-client-api` | a new or changed Prisma query |

package/releases/0.49.0/surfaces/prisma/tree/.claude/patterns.md

@@ -0,0 +1,15 @@
+<!-- nina:slot prisma.1 -->
+- **Database table/column names** (Prisma `@map` / `@@map`): `snake_case` in SQL, `camelCase` in TS.
+
+<!-- nina:slot prisma.2 -->
+- Where Prisma reads are cached through Accelerate, `cacheStrategy` lives in `{{DB_PKG}}`: services do not add, strip, or override cache policies.
+
+<!-- nina:slot prisma.3 -->
+
+### Prisma
+
+- Schema lives in `{{DB_PKG}}/prisma/schema.prisma`. Nowhere else.
+- **Never write raw SQL** unless justified in a code comment with perf data.
+- N+1 is solved with `include` / `select`, chosen deliberately.
+- Where reads are cached through Accelerate, every `findUnique` / `findMany` on a hot path defines its `cacheStrategy`, and no direct connection string is embedded in code.
+- Tests run a real Prisma client against a real database; the client is never mocked.

package/releases/0.49.0/surfaces/prisma/tree/CLAUDE.md

@@ -0,0 +1,5 @@
+<!-- nina:slot prisma.1 -->
+| Run any `prisma` CLI command (the database gate, devops, and the integration gate where there is one) | `prisma-cli` | flags differ between versions; `migrate diff --shadow-database-url` against a live DB wiped dev/staging once |
+
+<!-- nina:slot prisma.2 -->
+| Write or audit a Prisma query (architect, implementer, the database gate, reviewer) | `prisma-client-api` | filters, operators, `$transaction` semantics. a caching or edge layer on top of the client is **NOT covered** — its cache strategy belongs to that layer's own integration doc |

package/src/commands/check.mjs

@@ -297,6 +297,16 @@ export async function check(argv, ctx) {
       notes.push(`${label} names boundary "${entry.boundary}", which does not exist yet`);
     }
   }
+  // The other direction: a doc no integration declares is retired, waits for its boundary, or lost its
+  // declaration, and nothing told a reader which. Said as a note, and as a deferral once the profile says why.
+  const declaredSlugs = new Set(integrations.map((entry) => entry?.slug));
+  const docs = await readdir(join(target, '.claude', 'integrations')).catch(() => []);
+  for (const doc of docs.filter((name) => name.endsWith('.md') && !declaredSlugs.has(name.slice(0, -'.md'.length))).sort()) {
+    const key = `.claude/integrations/${doc}`;
+    const why = deferredWhy(profile, key);
+    if (why) deferredUsed.add(key);
+    notes.push(why ? `deferred: ${key} — ${why}` : `${key} documents no declared integration — declare it, or say under "deferred" why not: retired, or waiting for its boundary`);
+  }
 
   const slots = await projectSlots(resolved.dir, surfaces);
   const filled = await filledSlots(target);

package/src/commands/gate.mjs

@@ -2,6 +2,7 @@
  * `nina gate` — the loop gate's own check, and a way to run it by hand.
  *
  *   nina gate --selftest   is the gate wired, has it failed, would it still hold a loop past its cap?
+ *   nina gate --status     the loops a session holds open, and what would close each
  *   nina gate --hook       handle one hook event from stdin, the way the composed script does
  *
  * The gate lets every call through when anything goes wrong, which is right for a hook and makes a
@@ -20,7 +21,7 @@ import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { readProfile, slugFor } from '../paths.mjs';
 import { GATE, hookCommand, missingWiring, shippedScripts } from '../wiring.mjs';
-import { LEDGER_TAIL, ledgerPath, loadProject, projectGateDir, readLedger, runGate } from '../gate.mjs';
+import { LEDGER_TAIL, ledgerPath, loadProject, loopState, projectGateDir, readLedger, runGate, sessionLedgers } from '../gate.mjs';
 import { projectRecords } from '../store.mjs';
 import { layerRootFor } from './compose.mjs';
 import { handsToModel } from '../detectors.mjs';
@@ -271,13 +272,57 @@ function dryRun(target) {
 }
 
 /**
- * @param {string[]} argv - `[--selftest | --hook] [--project <dir>]`.
+ * What the gate holds of one session: its loops, what would close each, and the loop-backs waiting on a fix —
+ * the same lines a compaction hands the orchestrator, at any time. The session is the one whose ledger was
+ * written last, which is the running one while it dispatches, or the one `--session` names by the start of its id.
+ *
+ * @param {string} target - The project directory.
+ * @param {string|undefined} wanted - The start of a session id, or nothing for the latest.
+ * @returns {number} Process exit code.
+ */
+function loopStatus(target, wanted) {
+  const project = loadProject(target);
+  if (!project) {
+    console.error('  .claude/graph.md is not composed, so the gate has no loops to hold — run `nina compose`\n');
+    return 2;
+  }
+  const { dir, ledgers, picked, why } = sessionLedgers(target, wanted);
+  if (ledgers.length === 0 && !wanted) {
+    console.log(`  the gate has no ledger here yet: no session has dispatched a stage since it was wired (${dir})`);
+    console.log('gate: no open loop');
+    return 0;
+  }
+  if (!picked) {
+    console.error(`  ${why} (${dir})\n`);
+    return 2;
+  }
+  const { session, written, path } = picked;
+  const state = loopState(project, readLedger(path));
+  const others = ledgers.length > 1 ? `; ${ledgers.length - 1} other session(s) kept here, --session <id> for one` : '';
+  console.log(`  session ${session}, its ledger last written ${written.toISOString().slice(0, 16).replace('T', ' ')} UTC${others}`);
+  for (const line of state.lines) console.log(`  ${line}`);
+  const counts = [
+    state.open ? `${state.open} open loop(s)` : 'no open loop',
+    state.closing ? `${state.closing} settled, dropped at the next dispatch` : '',
+    state.waiting ? `${state.waiting} loop-back(s) waiting on a fix` : '',
+  ];
+  console.log(`gate: ${counts.filter(Boolean).join(', ')}`);
+  return 0;
+}
+
+/**
+ * @param {string[]} argv - `[--selftest | --status [--session <id>] | --hook] [--project <dir>]`.
  * @param {{root: string}} ctx - CLI context; `root` is the NINA install directory.
  * @returns {Promise<number>} Process exit code.
  */
 export async function gate(argv, ctx) {
   const target = resolve(argv.includes('--project') ? argv[argv.indexOf('--project') + 1] : '.');
   if (argv.includes('--hook')) return runGate({ root: target });
+  if (argv.includes('--status')) return loopStatus(target, argv.includes('--session') ? argv[argv.indexOf('--session') + 1] : undefined);
+  if (argv.includes('--session')) {
+    console.error('  --session names the session --status reads, and means nothing without it\n');
+    return 2;
+  }
 
   const { profile, error } = readProfile(target);
   if (error) {

package/src/commands/init.mjs

@@ -218,14 +218,21 @@ async function interview(available, matched, impacts) {
     const scope = lines.join(' ');
 
     const order = available;
-    console.log(`\n  ${strong('Surfaces')} — ${order.length} yes-or-no questions, one per surface.`);
+    console.log(`\n  ${strong('Surfaces')} — up to ${order.length} yes-or-no questions, one per surface; a stack comes only after a yes to what it needs.`);
     console.log('  A surface is a part of the harness only some projects need: its rules, its checks, sometimes a');
     console.log('  whole role. Answer for what the project does today; one can be added later in .nina/profile.json.\n');
     const surfaces = [];
+    let asked = 0;
     for (const [n, s] of order.entries()) {
       // A stack is asked about only where its concern was answered yes: asked whether data it does not
       // own goes through Prisma, a project has nothing true to answer.
       if (missingNeeds(s, surfaces).length > 0) continue;
+      // Counted by what is asked, not by place in the list: numbered by place, a no to the database read
+      // 1/10 then 4/10, and the header promised ten questions to someone asked seven. The total is what is
+      // asked so far plus what can still be, so a no shrinks it; the last question is n/n while the order
+      // ends with a surface that needs nothing, as it does.
+      asked += 1;
+      const total = asked + order.slice(n + 1).filter((t) => missingNeeds(t, [...surfaces, ...order.slice(n)]).length === 0).length;
       const i = impacts[s];
       const reason = matched.find((d) => d.surface === s)?.why;
       // What a yes brings, in what a person would recognise: roles, rules, agents. The count of
@@ -235,7 +242,7 @@ async function interview(available, matched, impacts) {
         ...(i.rules ? [`${i.rules} hard rule${i.rules > 1 ? 's' : ''}`] : []),
         ...(i.agents.length ? [`changes to ${i.agents.length} agent${i.agents.length > 1 ? 's' : ''}`] : []),
       ];
-      console.log(`  ${faint(`${n + 1}/${order.length}`)}  ${strong(s)}`);
+      console.log(`  ${faint(`${asked}/${total}`)}  ${strong(s)}`);
       console.log(`       ${questionFor(s)}`);
       console.log(faint(`       if yes: ${brings.length ? brings.join(' · ') : `guidance in ${i.fragments} places`}`));
       if (reason) console.log(found(`       already here: ${reason}`));

package/src/commands/pipeline.mjs

@@ -168,7 +168,8 @@ export function historyOf(records, since) {
 /**
  * Runs the command.
  *
- * @param {string[]} argv - `[--project <dir>] [--for <number or words>] [--since <YYYY-MM-DD>]`.
+ * @param {string[]} argv - `[--project <dir>] [--for <number or words>] [--since <YYYY-MM-DD>]`, or `--view [--session <id>]
+ *   [--replay] [--port <n>] [--open]` for the office.
  * @returns {Promise<number>} Process exit code.
  */
 export async function pipeline(argv) {
@@ -179,6 +180,26 @@ export async function pipeline(argv) {
     console.error(`  no .claude/graph.md in ${dir} — this draws a composed pipeline: \`nina compose\` writes one`);
     return 1;
   }
+  // The office: the same graph as a room, its agents at their desks, live or replayed (src/office.mjs).
+  const viewOnly = ['--session', '--replay', '--port', '--open'].filter((flag) => argv.includes(flag));
+  if (viewOnly.length > 0 && !argv.includes('--view')) {
+    console.error(`  ${viewOnly.join(', ')} ${viewOnly.length > 1 ? 'belong' : 'belongs'} to the office, and mean${viewOnly.length > 1 ? '' : 's'} nothing without --view`);
+    return 2;
+  }
+  if (argv.includes('--view')) {
+    const drawingOnly = ['--for', '--since'].filter((flag) => argv.includes(flag));
+    if (drawingOnly.length > 0) {
+      console.error(`  ${drawingOnly.join(', ')} ${drawingOnly.length > 1 ? 'are' : 'is'} for the drawing, not the office`);
+      return 2;
+    }
+    const { viewOffice } = await import('../office.mjs');
+    const port = arg('--port');
+    if (port !== null && !(/^\d+$/.test(port) && Number(port) <= 65535)) {
+      console.error(`  --port takes a port number, 0 to 65535, and was given ${port}`);
+      return 2;
+    }
+    return viewOffice({ target: dir, wanted: arg('--session') || undefined, replay: argv.includes('--replay'), port: port === null ? undefined : Number(port), open: argv.includes('--open') });
+  }
   const graphText = readFileSync(graphPath, 'utf8');
   const graph = parseGraph(graphText);
   const words = stageWords(graphText);

package/src/commands/upgrade.mjs

@@ -364,6 +364,14 @@ export async function upgrade(argv, ctx) {
   const scriptsBefore = await shippedScripts(from.dir, surfaces);
   const newScripts = new Set([...(await shippedScripts(onto.dir, kept))].filter((s) => !scriptsBefore.has(s)));
   const unwired = newScripts.size > 0 ? await missingWiring(target, newScripts) : [];
+  // A script already run whose hooks this NINA needs more of — a matcher that grew — holds what it held, so it does
+  // not stop the move; it is said, with what fixes it.
+  const stillRun = new Set([...(await shippedScripts(onto.dir, kept))].filter((s) => scriptsBefore.has(s)));
+  const widened = stillRun.size > 0 ? (await missingWiring(target, stillRun)).filter((w) => / hook running `[^`]+` does not match /.test(w)) : [];
+  if (widened.length > 0) {
+    for (const w of widened) console.log(`  · ${w}`);
+    console.log('');
+  }
   if (unwired.length > 0) {
     console.log(`  ✗ ${unwired.length} hook(s) or script(s) that ${to}'s new ${[...newScripts].join(', ')} need(s) are not wired:`);
     for (const w of unwired) console.log(`      ${w}`);

package/src/gate.mjs

@@ -18,6 +18,8 @@
  *   PreToolUse / PostToolUse on Agent, Task, SendMessage
  *                                     a dispatch launched, and the agent it launched
  *   UserPromptSubmit (human text only) the owner spoke, and every open loop gets one round more
+ *   PreToolUse / PostToolUse on AskUserQuestion
+ *                                     the orchestrator asked the owner, and was answered: when, for the office
  *   PreToolUse on Agent, Task, SendMessage
  *                                     the decision: let it through, or send the round past the cap to
  *                                     the owner to confirm
@@ -280,11 +282,13 @@ function append(path, entry) {
  * @param {object[]} entries - The ledger, oldest first.
  * @param {ReturnType<typeof loopEdges>} loops - The capped loop-back edges.
  * @param {Map<string, Set<string>>} [forward] - Stage → the sources that hand passing work on to it.
- * @returns {{effect: (to: string) => {rounds: object[]}, rounds: object[]}}
+ * @returns {{effect: (to: string) => {rounds: object[]}, rounds: object[], open: object[], waiting: object[]}}
  *   A round is `{source, target, token, round, max, edgeRound, ceiling, agents}`, plus `issue` (the id
  *   that decides it) and `issues` (every id with its count) when it was counted by issue.
  *   `effect` says what a dispatch to a stage would make now, without making it; `rounds` is every round
- *   the recorded dispatches made.
+ *   the recorded dispatches made; `open` each loop still counted, with whether a pass already closes it
+ *   (`closing`), the stages a dispatch to which would (`targets`) and the stages whose pass would (`onward`);
+ *   `waiting` each loop-back no fix has acted on yet.
  */
 export function replay(entries, loops, forward = new Map()) {
   // When each dispatch went out. A foreground dispatch's `dispatch` entry is written after the agent
@@ -329,15 +333,23 @@ export function replay(entries, loops, forward = new Map()) {
     for (const map of [streak, grace]) for (const key of [...map.keys()]) if (key.startsWith(`${source}|`)) map.delete(key);
   };
 
+  /**
+   * A source's waiting verdicts, settled: the rejections no later review of a fix cancelled, and whether a pass
+   * closes its loops — one that began after the latest fix, with no rejection running beside it.
+   */
+  const settle = (source, batch) => {
+    const passes = batch.filter((v) => !isLoopBack(v.verdict));
+    const live = batch.filter((v) => isLoopBack(v.verdict) && !passes.some((p) => p.launch > v.at && fixBetween(source, v.at, p.launch)));
+    return { live, closes: passes.some((p) => p.launch > (lastFix.get(source) ?? -1) && !live.some((v) => v.launch < p.at)) };
+  };
+
   const effect = (to, at) => {
     const rounds = [];
     const outcome = [];
     for (const [source, batch] of pending) {
       const byToken = loops.get(source);
       if (!byToken || batch.length === 0 || !targetsOf(source).has(to)) continue;
-      const passes = batch.filter((v) => !isLoopBack(v.verdict));
-      const live = batch.filter((v) => isLoopBack(v.verdict) && !passes.some((p) => p.launch > v.at && fixBetween(source, v.at, p.launch)));
-      const closes = passes.some((p) => p.launch > (lastFix.get(source) ?? -1) && !live.some((v) => v.launch < p.at));
+      const { live, closes } = settle(source, batch);
       const routed = live.filter((v) => byToken.get(v.verdict)?.has(to));
       const fresh = routed.filter((v) => {
         const last = streak.get(`${source}|${v.verdict}`);
@@ -434,13 +446,18 @@ export function replay(entries, loops, forward = new Map()) {
   });
   // What is open when the replay ends: each loop with its rounds, the rounds the owner's replies gave it and the
   // issues it counted by, and each loop-back no fix has acted on yet — what a compaction takes from the orchestrator.
+  // A loop whose source passed after the latest fix is closed by the next dispatch it could act on, and until then
+  // is still in the count; it says so, and what would close each of the others. Listed as open, three loops
+  // approved the evening before a compaction were handed back as capped, and the orchestrator went looking for why.
   const open = [...streak.entries()]
     .filter(([key]) => key.split('|').length === 2)
     .map(([key, s]) => {
       const [source, token] = key.split('|');
       const cap = Math.max(0, ...(loops.get(source)?.get(token)?.values() ?? []));
       const issues = [...streak.keys()].filter((k) => k.startsWith(`${key}|`)).map((k) => k.slice(key.length + 1));
-      return { source, token, rounds: s.n, cap, given: grace.get(key) ?? 0, issues };
+      const closing = settle(source, pending.get(source) ?? []).closes;
+      const onward = [...forward].filter(([, sources]) => sources.has(source)).map(([stage]) => stage);
+      return { source, token, rounds: s.n, cap, given: grace.get(key) ?? 0, issues, closing, targets: [...targetsOf(source)], onward };
     });
   const waiting = [...pending.entries()].flatMap(([source, batch]) => batch.filter((v) => isLoopBack(v.verdict)).map((v) => ({ source, verdict: v.verdict, issues: v.issues ?? [] })));
   return { effect: (to) => effect(to, entries.length), rounds: made, open, waiting };
@@ -591,6 +608,10 @@ function onPost(input, project, path, at) {
   }
   // A dispatch made inside a subagent is not the pipeline's: its stages are dispatched by the orchestrator.
   if (input.agent_id) return null;
+  if (tool === 'AskUserQuestion') {
+    append(path, { k: 'answered', at });
+    return null;
+  }
   if (!DISPATCH.has(tool)) return null;
   const response = input.tool_response && typeof input.tool_response === 'object' ? input.tool_response : {};
   let role;
@@ -644,13 +665,23 @@ function confirmation(r) {
 
 /** A dispatch is about to go out: note when, and send the round past its edge's cap to the owner to confirm. */
 function onPre(input, project, path, at) {
+  // The orchestrator asking the owner, as it asks: when it was, and nothing it said. Nothing counts it; the office
+  // (`nina pipeline --view`) draws the question over its head until the answer, which `onPost` records.
+  if (!input.agent_id && input.tool_name === 'AskUserQuestion') {
+    append(path, { k: 'question', at });
+    return null;
+  }
   if (input.agent_id || !DISPATCH.has(input.tool_name)) return null;
   const entries = readLedger(path);
-  const role = input.tool_name === 'SendMessage' ? recipient(entries, project, input.tool_input?.to).role : input.tool_input?.subagent_type;
+  const to = input.tool_name === 'SendMessage' ? recipient(entries, project, input.tool_input?.to) : null;
+  const role = to ? to.role : input.tool_input?.subagent_type;
   if (!role || !project.graph.stages.has(role)) return null;
   // When it went out, whatever the owner decides: joined to its `dispatch` entry by the tool_use id,
-  // it is the moment the fixer was sent — which is what a later review has to begin after.
-  append(path, { k: 'pre', at, role, id: input.tool_use_id ?? null });
+  // it is the moment the fixer was sent — which is what a later review has to begin after. A message says so, and
+  // names its agent when the ledger already knows it — never a name the model wrote that nothing launched — so the
+  // office can tell a message to a running agent from a resume before the `dispatch` entry is written.
+  const known = to?.agent && entries.some((e) => e.k === 'dispatch' && e.agent === to.agent);
+  append(path, { k: 'pre', at, role, id: input.tool_use_id ?? null, ...(to ? { via: 'SendMessage', ...(known ? { agent: to.agent } : {}) } : {}) });
   const over = roundsFor(entries, role, project.loops, project.forward)
     .filter((r) => excess(r) > 0)
     .sort((a, b) => excess(b) - excess(a));
@@ -672,31 +703,84 @@ function onPre(input, project, path, at) {
 }
 
 /**
- * What the gate hands the orchestrator after its conversation was compacted: the loops still open and the
- * loop-backs waiting on a fix, the latest dispatches, where the checkout stands, and the two documents to read
- * again. The graph and the router are read once, at a session's start, and a compaction drops them with every
- * report; the router told the orchestrator to write "round 2 of max 2" in a dispatch so "you after a
- * compaction" could see it, and after a compaction it sees only a summary.
+ * A project's session ledgers, the newest first, and the one asked for: the latest, or the one whose id starts
+ * with `wanted`. `nina gate --status` and the office (`nina pipeline --view`) pick a session through this, so
+ * the two never show different ones.
+ *
+ * @param {string} root - The project directory.
+ * @param {string} [wanted] - The start of a session id; absent, the session whose ledger was written last.
+ * @returns {{dir: string, ledgers: {session: string, written: Date, path: string}[], picked: {session: string, written: Date, path: string}|null, why: string|null}}
+ *   `why` says why nothing was picked, and is null when there is simply no ledger yet.
+ */
+export function sessionLedgers(root, wanted) {
+  const dir = projectGateDir(root);
+  const ledgers = (existsSync(dir) ? readdirSync(dir) : [])
+    .filter((f) => f.endsWith('.jsonl') && f !== 'errors.jsonl')
+    .flatMap((f) => {
+      // Pruned between the listing and here, by another session: gone, and not a failure.
+      try {
+        return [{ session: f.slice(0, -'.jsonl'.length), written: statSync(join(dir, f)).mtime, path: join(dir, f) }];
+      } catch {
+        return [];
+      }
+    })
+    .sort((a, b) => b.written - a.written);
+  const matching = wanted ? ledgers.filter((l) => l.session.startsWith(wanted)) : ledgers.slice(0, 1);
+  if (matching.length === 1) return { dir, ledgers, picked: matching[0], why: null };
+  const why = !wanted ? null : matching.length === 0 ? `no session starts with "${wanted}"` : `${matching.length} sessions start with "${wanted}" — give more of the id`;
+  return { dir, ledgers, picked: null, why };
+}
+
+/** Stages as a sentence lists them: `qa`, `implementer or architect`, `a, b or c`. */
+const either = (stages) => (stages.length < 2 ? stages.join('') : `${stages.slice(0, -1).join(', ')} or ${stages.at(-1)}`);
+
+/**
+ * What a session's ledger says of its loops, a line each: every loop still counted, and what would close it;
+ * the loop-backs no fix has acted on yet; and the latest dispatches. It is what a compaction hands the
+ * orchestrator and what `nina gate --status` prints, so the two cannot disagree.
  *
  * @param {object} project - `loadProject`'s.
- * @param {string} path - The session's ledger.
- * @param {string} root - The project.
- * @returns {object}
+ * @param {object[]} entries - The session's ledger, oldest first.
+ * @returns {{lines: string[], open: number, closing: number, waiting: number}} The lines; the loops open, the
+ *   loops a pass already settled, whose count the next dispatch drops, and the loop-backs waiting on a fix.
  */
-function afterCompaction(project, path, root) {
-  const entries = readLedger(path);
+export function loopState(project, entries) {
   const { open, waiting } = replay(entries, project.loops, project.forward);
-  const lines = ['The conversation was compacted. What the NINA loop gate kept of this session:'];
+  const lines = [];
   for (const l of open) {
+    const count =
+      `${l.source} ${l.token} — ${l.rounds} round(s), capped at ${l.cap}${l.given ? ` and ${l.given} more from the owner's replies` : ''}` +
+      (l.issues.length ? `, issues ${l.issues.join(', ')}` : '');
+    const fix = waiting.some((w) => w.source === l.source) ? 'the fix it waits on' : 'the latest fix';
     lines.push(
-      `- open loop: ${l.source} ${l.token} — ${l.rounds} round(s), capped at ${l.cap}${l.given ? ` and ${l.given} more from the owner's replies` : ''}` +
-        (l.issues.length ? `, issues ${l.issues.join(', ')}` : ''),
+      l.closing
+        ? `- passed after its latest fix: ${count}. Those rounds are settled, and the gate drops them at the next dispatch to ${either(l.targets)}`
+        : `- open loop: ${count}. It closes when a ${l.source} launched after ${fix} passes with no rejection beside it` +
+            (l.onward.length ? `, or when ${either(l.onward)} passes, sent out after the ${l.source} last reported` : ''),
     );
   }
   for (const w of waiting) lines.push(`- waiting on a fix: ${w.source} ${w.verdict}${w.issues.length ? `, issues ${w.issues.join(', ')}` : ''}`);
   if (open.length === 0 && waiting.length === 0) lines.push('- no loop is open');
   const dispatched = entries.filter((e) => e.k === 'dispatch' && e.role).slice(-4);
   if (dispatched.length) lines.push(`- the latest dispatches: ${dispatched.map((e) => e.role).join(', ')}, the newest at ${String(dispatched.at(-1).at ?? '').slice(11, 16)} UTC`);
+  const closing = open.filter((l) => l.closing).length;
+  return { lines, open: open.length - closing, closing, waiting: waiting.length };
+}
+
+/**
+ * What the gate hands the orchestrator after its conversation was compacted: the loops still open and the
+ * loop-backs waiting on a fix, the latest dispatches, where the checkout stands, and the two documents to read
+ * again. The graph and the router are read once, at a session's start, and a compaction drops them with every
+ * report; the router told the orchestrator to write "round 2 of max 2" in a dispatch so "you after a
+ * compaction" could see it, and after a compaction it sees only a summary.
+ *
+ * @param {object} project - `loadProject`'s.
+ * @param {string} path - The session's ledger.
+ * @param {string} root - The project.
+ * @returns {object}
+ */
+function afterCompaction(project, path, root) {
+  const lines = ['The conversation was compacted. What the NINA loop gate kept of this session:', ...loopState(project, readLedger(path)).lines];
   const git = (...args) => spawnSync('git', ['-C', root, ...args], { encoding: 'utf8', timeout: 2000 }).stdout?.trim() ?? '';
   const branch = git('rev-parse', '--abbrev-ref', 'HEAD');
   const last = git('log', '-1', '--format=%h %s');