@xhulz/nina 0.53.2 → 0.53.3

package/releases/0.53.3/surfaces/money/tree/.claude/patterns.md

@@ -0,0 +1,49 @@
+<!-- nina:slot money.1 -->
+
+---
+
+## Monetary values & percentages
+
+- **Money is an integer of the currency's minor unit**, end to end — {{MINOR_UNIT}}, never a float, never a type that can hold a fraction of one. Source of precision: `{{MONEY_MODULE}}`.
+- **Percentages are basis points** (`40% → 4000`, `100% → 10000`) so a distribution is exact without floating point.
+- **Parsing, formatting and percentage arithmetic live in one module and nowhere else.** A second place that turns a string into money is a second rounding rule, and the two will disagree on a value somebody is owed.
+- **Never** convert to a floating-point type before formatting, and never let a display format round a stored value.
+- Monetary database columns are integer. JSON responses serialize them as **strings**, not numbers, so no client parses them into a float. The service owns the conversion.
+
+<!-- nina:slot money.2 -->
+
+---
+
+## Distribution invariants (enforced by reviewer + unit tests)
+
+The distribution engine lives in `{{CORE_PKG}}`. It is pure and total over integer {{MINOR_UNIT}}:
+
+- A destination is either a percentage (basis points of the amount) or a fixed value.
+- `total = Σ destinations`, computed in {{MINOR_UNIT}}.
+- `total > amount` → **reject.** Never clamp, never distribute what is not there.
+- `total < amount` → **allow**, surface the shortfall, and leave the remainder **parked**. Silence is the defect here: an unexplained remainder is indistinguishable from a bug.
+- `total = amount` → OK.
+- A retention is just another destination — the same arithmetic applies to it, with no special case.
+
+<!-- nina:slot money.3 -->
+
+---
+
+## State machines & idempotency (enforced by reviewer)
+
+- **Every money-moving entity is a state machine.** Its states and legal transitions are declared in `.claude/architecture.md`; the code follows the declaration, not the other way round. Illegal transitions throw; they are never silently coerced.
+- **Every transition writes an audit row** (entity type, entity id, from, to, actor). No transition without a trail — the trail is what makes a money bug diagnosable after the money has moved.
+- **Outbound transfers are idempotent.** Each carries a unique key, and dedupe happens before the side effect, at the serialization point.
+- **One serialization point per balance.** Whatever computes and dispatches against a single balance never runs concurrently with itself. Two concurrent runs over one balance is how a double send happens even when every individual write is correct.
+
+<!-- nina:slot money.4 -->
+- **Money computation and dispatch go through the serialization point.** Routes, queue consumers and tools never run a distribution or a transfer synchronously in the request path.
+
+<!-- nina:slot money.5 -->
+- **The distribution engine lives in `{{CORE_PKG}}`.** Services call it as a pure function; they do not embed money logic inline.
+
+<!-- nina:slot money.6 -->
+- Idempotency on money-moving writes: the record carries an idempotency key, and the serialization point refuses the second attempt *before* the side effect.
+
+<!-- nina:slot money.7 -->
+- `{{CORE_PKG}}` is the most-tested package — pure functions over fixtures. Cover the distribution invariants exhaustively: over, under, exact, mixed percentage and fixed, and rounding.

package/releases/0.53.3/surfaces/money/tree/.claude/pipeline.md

@@ -0,0 +1,2 @@
+<!-- nina:slot money.1 -->
+  - **Money invariants respected** — a distribution never exceeds the amount; a shortfall is parked, not distributed; transfers idempotent; every transition audited.

package/releases/0.53.3/surfaces/money/tree/.claude/retrieval.md

@@ -0,0 +1,2 @@
+<!-- nina:slot money.1 -->
+| New distribution / transfer logic | `.claude/architecture.md` § *Money*, `.claude/patterns.md` § *Distribution invariants*, `{{CORE_PKG}}/` | architect → implementer → reviewer → qa |

package/releases/0.53.3/surfaces/money/tree/CLAUDE.md

@@ -0,0 +1,11 @@
+<!-- nina:slot money.1 -->
+3. **An outbound transfer is idempotent — it is NEVER sent twice.** Every transfer carries an idempotency key, and deduplication happens at a single serialization point **before** the side effect, never after it. A retry, a re-delivered queue message, a double-click and a replayed webhook must all collapse to one transfer. This is the highest-blast-radius invariant in the system: almost everything else can be corrected afterwards, and a duplicated transfer cannot.
+
+<!-- nina:slot money.2 -->
+4. **Conservation — what comes in equals what goes out plus what is retained.** A distribution may NEVER exceed the amount it distributes → **block**. If it is **less**, **alert** and leave the remainder **parked** and visible — never silently distributed, never silently absorbed. All arithmetic is integer {{MINOR_UNIT}}; percentages are basis points. The LLM never computes a monetary value.
+
+<!-- nina:slot money.3 -->
+5. **State-machine integrity.** Every money-moving entity has an explicit set of states and legal transitions, declared in `.claude/architecture.md` § *State machines* — not inferred from whatever code happens to exist. Only declared transitions are legal; an illegal one throws and is never silently coerced. **Every transition writes an audit row** (entity, id, from → to, actor, when). Skipping a state, inventing one, or landing a transition with no audit row is a hard reject.
+
+<!-- nina:slot money.4 -->
+- **money movement**: anything that creates, moves, settles or records a balance

package/releases/0.53.3/surfaces/pii/tree/.claude/agents/dba.md

@@ -0,0 +1,2 @@
+<!-- nina:slot pii.1 -->
+- **Privacy.** No sensitive value in clear text where it must not be. The categories are declared in `.claude/architecture.md` § *Privacy* — they are not decided per query, and not decided by you. **Document bytes live only in the object store, referenced by key: the column holds the key, never the bytes.** Any column the architect's spec flagged for masking must be encrypted at rest. Reject a schema that widens what is stored in the clear.

package/releases/0.53.3/surfaces/pii/tree/.claude/agents/devops.md

@@ -0,0 +1,8 @@
+<!-- nina:slot pii.1 -->
+
+**Point it at an UNAUTHENTICATED route — a sign-in page is the right one.** Never sign in, and never
+screenshot a signed-in page. Accounts on deployed environments hold real personal data, and a
+screenshot or a console dump pulls it into agent transcripts and logs, where it persists and nobody
+ever looks for it again. That is a privacy leak with no upside here: the sign-in page proves
+everything this check is for. It renders from the same bundle, it exercises the same build-time env
+inlining (a missing variable blanks it identically), and it needs no session.

package/releases/0.53.3/surfaces/pii/tree/.claude/agents/reviewer.md

@@ -0,0 +1,8 @@
+<!-- nina:slot pii.1 -->
+- Check for privacy regressions: **no sensitive value in a log, an error message — a library's own included — a URL or a test fixture**, per the categories in `.claude/architecture.md` § *Privacy*; document bytes only in the object store, never plaintext in the database; no leaked secret.
+
+<!-- nina:slot pii.2 -->
+- **privacy** — the privacy check above, in full: no sensitive value in a log, an error message, a
+  URL or a test fixture; document bytes only in the object store; no leaked secret. Where
+  **tenant-and-privacy** is dispatched, its reviewer owns this too and there is no separate one; where
+  it is not, this is a dimension of its own. Either way it is never nobody's.

package/releases/0.53.3/surfaces/pii/tree/.claude/agents/secops.md

@@ -0,0 +1,2 @@
+<!-- nina:slot pii.1 -->
+- **Privacy (Hard Rule #8)** — the categories declared in `.claude/architecture.md` § *Privacy* must never appear in logs, in responses that do not need them, in error paths, or in the database in clear text. Check every endpoint that returns a person's record for fields it includes by accident: a `select` that quietly grew a column is the usual way this leaks. Check the error paths too — they are written last and reviewed least — and what the libraries on them print or carry in their own errors, bound values included.

package/releases/0.53.3/surfaces/pii/tree/.claude/agents/solidity-auditor.md

@@ -0,0 +1,5 @@
+<!-- nina:slot pii.1 -->
+- **Nothing personal reaches the chain.** What is written on-chain is public, permanent, and beyond
+  deletion by anyone — including by you, and including after a subject asks. A hash of a personal
+  identifier is not a protection: it is a lookup table for whoever holds the input set. Reject a
+  personal datum stored in state, emitted in an event, or passed as calldata.

package/releases/0.53.3/surfaces/pii/tree/CLAUDE.md

@@ -0,0 +1,5 @@
+<!-- nina:slot pii.1 -->
+8. **Sensitive personal data is classified, and the classification is enforced.** What counts as sensitive here — identity documents, financial identifiers, anything a person would not expect to be readable by whoever can read a log — is declared in `.claude/architecture.md` § *Privacy*, along with the regime that governs it ({{PRIVACY_REGIME}}). Encrypted at rest. **No sensitive value in a log, an error message, a URL, an analytics event, or an agent transcript** — the places nobody thinks about are exactly the ones that persist. That includes what a library puts in its own errors and prints itself: a database client's error can carry the query and every bound value, and a framework can log a whole error past the logger it was given. A database error is mapped at the data layer to a typed error from a closed list before anything logs or returns it, and a test proves that a bound value it writes reaches no thrown error. Document bytes live only in the object store, referenced by key, never in the database in clear text.
+
+<!-- nina:slot pii.2 -->
+- **personal data**: where it is collected, stored, logged or sent

package/releases/0.53.3/surfaces/prisma/tree/.claude/agents/architect.md

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

package/releases/0.53.3/surfaces/prisma/tree/.claude/agents/dba.md

@@ -0,0 +1,42 @@
+<!-- nina:slot prisma.1 -->
+| `prisma-cli` | **before ANY `prisma` CLI command** — `validate`, `format`, `migrate dev`, `migrate diff`, `migrate deploy`. Flags differ between versions, and one of them (`migrate diff --shadow-database-url` against a live database) destroys the database it points at |
+| `prisma-client-api` | auditing a new or changed query — filters, operators, `$transaction` semantics. Through a driver adapter, cite the adapter's installed source for what a transaction does: the skill describes the default engine, and an adapter can roll back less |
+
+<!-- nina:slot prisma.2 -->
+Neither skill covers a **caching or edge layer sitting on top of the client** — cache strategy,
+edge-client behaviour and the rule about never caching a read that authorizes a write belong to that
+layer's own integration doc, declared like any other integration. A skill does not replace it.
+
+<!-- nina:slot prisma.3 -->
+- **With Prisma, both offline.** Run `pnpm --filter {{DB_PKG_NAME}} exec prisma validate`; it must pass. Then run `prisma migrate diff` in its **offline, file-only form** and read the generated SQL, not just the Prisma delta. Its flags changed in Prisma 7, so read the installed major (`prisma --version`) before writing the command:
+
+   ```
+   # Prisma 6. Compare the PREVIOUS schema against the working one — pure file-to-file, no database.
+   git show HEAD:{{DB_PKG}}/prisma/schema.prisma > /tmp/schema-head.prisma
+   pnpm --filter {{DB_PKG_NAME}} exec prisma migrate diff \
+     --from-schema-datamodel /tmp/schema-head.prisma \
+     --to-schema-datamodel prisma/schema.prisma \
+     --script
+   ```
+
+   From Prisma 7 the two flags are `--from-schema` and `--to-schema`, and the schema engine starts from the
+   datasource in `prisma.config.ts` even for this diff: with none there, it prints nothing and exits 0. For
+   SQLite a placeholder the diff never opens is enough, a `file:` URL under a gitignored directory; for any
+   other provider, find out what the diff opens before you give it one. Never a real database's URL. A first schema has nothing at `HEAD`: diff it `--from-empty`. Compare the output against the
+   hand-written `migration.sql` to confirm the declarative parts match.
+
+   ⚠️ **Do NOT reach for `--from-migrations`.** It looks like the natural choice and it is a trap:
+   Prisma refuses it without a shadow database (`--shadow-database-url`, or from Prisma 7 a
+   `shadowDatabaseUrl` in `prisma.config.ts`), which pushes you toward supplying a database URL — the exact move that destroys databases (below). The file-to-file form above answers the
+   same question with no database involved.
+
+   ⛔ **NEVER point `--shadow-database-url`, `--from-url`, `--to-url`, `--from-schema-datasource` — or, from Prisma 7, a `shadowDatabaseUrl` or the config datasource behind `--from-config-datasource` — at a real database, most of all not the one `{{SECRETS_LOCAL}}` names.** Prisma **executes** the entire migration history against whatever database those flags name, which **DESTROYS ALL DATA** in it. A shadow database must be a disposable, empty database and nothing else. It does not announce itself: the command completes with a reassuring "empty migration" result and no error, having already destroyed everything in the database it was pointed at. If the offline form above cannot answer your question, **STOP and report that to the orchestrator** instead of reaching for a database URL.
+
+<!-- nina:slot prisma.4 -->
+- **Where reads are cached through Prisma Accelerate,** every `findUnique` / `findMany` on a hot read path names its `cacheStrategy` (`ttl` / `swr`), and one that feeds a correctness-critical write names none.
+
+<!-- nina:slot prisma.5 -->
+- **On an edge runtime,** new Prisma code paths use the edge client of the installed major: `@prisma/client/edge` up to Prisma 6; from 7, the client the `prisma-client` generator writes with the platform's `runtime` set, imported from where it is generated — `@prisma/client/edge` fails there with `MODULE_NOT_FOUND`.
+
+<!-- nina:slot prisma.6 -->
+- Run a Prisma command that writes to a real database — `prisma migrate dev`, `migrate deploy`, `migrate reset`, `migrate resolve`, `db push`, `db execute`, `$executeRaw*` — or **any `prisma migrate diff` variant carrying a database URL**, which silently wipes the database it points at.

package/releases/0.53.3/surfaces/prisma/tree/.claude/agents/devops.md

@@ -0,0 +1,11 @@
+<!-- nina:slot prisma.1 -->
+- **`prisma-cli`** — before `migrate deploy` or any other Prisma CLI command against a real database.
+
+<!-- nina:slot prisma.2 -->
+- **Prisma migrations go out with `prisma migrate deploy`**, and nothing else changes a shared database's schema.
+
+<!-- nina:slot prisma.3 -->
+- Run `prisma migrate diff --shadow-database-url <url>` against any live database. It **executes** the migration history against that database, destroying everything in it, and reports success. Use a disposable shadow database or don't run it.
+
+<!-- nina:slot prisma.4 -->
+- Run `prisma migrate reset` against a shared database, ever.

package/releases/0.53.3/surfaces/prisma/tree/.claude/agents/implementer.md

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

package/releases/0.53.3/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.53.3/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.53.3/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.53.3/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/learn.mjs

@@ -39,7 +39,7 @@ import { autoExport } from './export.mjs';
 import { beforeModel } from '../detectors.mjs';
 
 /** Loop-backs from one role, since its newest lesson, that make a lesson overdue. */
-const CAPTURE_AT = 3;
+export const CAPTURE_AT = 3;
 
 /**
  * How far back a loop-back still counts. Older ones are history nobody remembers well enough to
@@ -115,7 +115,8 @@ const SENT_BACK_HOURS = 24;
  *
  * @param {object[]} records - Recorded dispatches.
  * @param {Map<string, Map<string, Map<string, number>>>|null} loops - The graph's capped loop-back edges.
- * @returns {Map<object, string>} Loop-back record → the stage it sent work back to, where one can be told.
+ * @returns {Map<object, {to: string, fix: object|null}>} Loop-back record → the stage it sent work back to, where
+ *   one can be told, and the dispatch of that stage that took the work back, where one was found.
  */
 export function sentBackTo(records, loops) {
   const out = new Map();
@@ -133,7 +134,7 @@ export function sentBackTo(records, loops) {
     const within = (x) => Date.parse(x.ts) - Date.parse(back) <= SENT_BACK_HOURS * 3_600_000;
     const next = (bySession.get(r.session) ?? []).find((x) => String(x.ts) > back && within(x) && targets.has(x.role));
     const to = next?.role ?? (targets.size === 1 ? [...targets.keys()][0] : null);
-    if (to) out.set(r, to);
+    if (to) out.set(r, { to, fix: next ?? null });
   }
   return out;
 }
@@ -155,7 +156,7 @@ export function overdue(records, known, now = new Date(), days = CAPTURE_DAYS, o
   // A loop-back is the lesson of the stage it sent work back to, where that is known (`sentBackTo`): charged
   // to the stage that gave the verdict, the reviewer owed the implementer's lessons, and only a pill naming
   // every checker in its applies_to ever settled the count.
-  const ownerOf = (r) => owners.get(r) ?? r.role;
+  const ownerOf = (r) => owners.get(r)?.to ?? r.role;
   const roles = [...new Set(records.map(ownerOf).filter(Boolean))];
   const out = [];
   for (const role of roles) {
@@ -214,7 +215,7 @@ export function applied(records, known) {
 }
 
 /** How many days either side of a lesson's date its role is measured over: the same on both sides. */
-const VERIFY_DAYS = 14;
+export const VERIFY_DAYS = 14;
 
 /** A day as `YYYY-MM-DD`, moved by some days. */
 const shift = (date, days) => new Date(Date.parse(`${date}T12:00:00Z`) + days * 86_400_000).toISOString().slice(0, 10);
@@ -248,18 +249,30 @@ function wilson(k, n) {
  * graph sends work back to. A change is called only where the two intervals do not overlap. Not proof — the
  * work changes too — but a number where one can be had, and the reason where it cannot.
  *
+ * A round is counted sent back once, however many loop-backs sent it: the checkers that run beside each other
+ * each reject the same work, and one project's architect had 14 loop-backs on a day it ran 7 rounds, which the
+ * share read as 100% sent back where 5 of the 7 were. Loop-backs that the same dispatch took back are one.
+ *
  * @param {object[]} records - Recorded dispatches.
  * @param {Awaited<ReturnType<typeof lessons>>} known - The project's pills.
- * @param {{owners?: Map<object, string>, targets?: Set<string>|null}} [graph] - Who each loop-back sent work
- *   back to, and the stages the graph sends work back to at all.
+ * @param {{owners?: ReturnType<typeof sentBackTo>, targets?: Set<string>|null}} [graph] - Who each loop-back sent
+ *   work back to, and the stages the graph sends work back to at all.
  * @returns {{rel: string, date: string, role: string, comparable: boolean, why?: string, on?: string|null,
- *   was?: string, before?: {n: number, loops: number}, after?: {n: number, loops: number},
- *   change?: 'lower'|'higher'|'unclear', control?: {before: {n: number, loops: number}, after: {n: number, loops: number}}}[]}
+ *   was?: string, before?: Side, after?: Side, change?: 'lower'|'higher'|'unclear', control?: {before: Side, after: Side}}[]}
+ *   A `Side` is `{n, loops, span}`: the stage's rounds, how many were sent back, and the first and last day a round
+ *   of it was recorded on, since a project younger than the window has fewer days than fourteen to show.
  */
 export function verified(records, known, { owners = new Map(), targets = null } = {}) {
   const out = [];
-  const ownerOf = (r) => owners.get(r) ?? r.role;
+  const ownerOf = (r) => owners.get(r)?.to ?? r.role;
   const sentBack = records.filter((r) => readable(r.verdict) && isLoopBack(r.verdict));
+  // The rounds these loop-backs sent back: those one dispatch took back are one. One no dispatch took back counts on
+  // its own, since nothing then says which work it rejected.
+  const sendings = (backs) => new Set(backs.map((r) => owners.get(r)?.fix ?? r)).size;
+  const sideOf = (these, backs) => {
+    const days = these.map((r) => day(r.ts)).sort();
+    return { n: these.length, loops: Math.min(these.length, sendings(backs)), span: [days[0] ?? null, days.at(-1) ?? null] };
+  };
   const ranOn = (r) => (r.usage_model ? `${r.usage_model}${r.effort ? ` · ${r.effort}` : ''}` : null);
   for (const lesson of known.filter((l) => l.date)) {
     const from = shift(lesson.date, -VERIFY_DAYS);
@@ -274,10 +287,7 @@ export function verified(records, known, { owners = new Map(), targets = null }
       }
       const rounds = records.filter((r) => r.role === role && readable(r.verdict));
       const backs = sentBack.filter((r) => ownerOf(r) === role);
-      const side = (pick, mine) => {
-        const n = mine.filter(pick).length;
-        return { n, loops: Math.min(n, backs.filter(pick).length) };
-      };
+      const side = (pick, mine) => sideOf(mine.filter(pick), backs.filter(pick));
       if (side(pre, rounds).n < VERIFY_MIN || side(post, rounds).n < VERIFY_MIN) {
         const [b, a] = [side(pre, rounds).n, side(post, rounds).n];
         out.push({ ...base, comparable: false, why: `too few rounds of ${role} either side (${b} before, ${a} after, in ${VERIFY_DAYS} days each)` });
@@ -302,7 +312,7 @@ export function verified(records, known, { owners = new Map(), targets = null }
       const others = [...(targets ?? new Set(sentBack.map(ownerOf)))].filter((x) => x !== role);
       const theirs = records.filter((r) => others.includes(r.role) && readable(r.verdict));
       const otherBacks = sentBack.filter((r) => others.includes(ownerOf(r)));
-      const control = (pick) => ({ n: theirs.filter(pick).length, loops: Math.min(theirs.filter(pick).length, otherBacks.filter(pick).length) });
+      const control = (pick) => sideOf(theirs.filter(pick), otherBacks.filter(pick));
       out.push({ ...base, comparable: true, on, before, after, change, control: { before: control(pre), after: control(post) } });
     }
   }

package/src/dashboard.html

@@ -61,7 +61,21 @@
   .stage { display: grid; grid-template-columns: 170px 1fr; gap: 4px 14px; padding: 12px 0; border-bottom: 1px solid #2a2838; }
   .empty { color: var(--faint); padding: 30px 0; text-align: center; }
   .note { margin: 4px 0; font-size: 13px; }
-  @media (max-width: 640px) { .stage { grid-template-columns: 1fr; } nav { margin-left: 0; } }
+  .answer { background: var(--panel); border: 1px solid var(--line); border-left: 4px solid var(--faint); border-radius: 6px; padding: 12px 16px; margin: 0 0 14px; }
+  .answer[data-tone="ok"] { border-left-color: var(--green); } .answer[data-tone="bad"] { border-left-color: var(--red); } .answer[data-tone="warn"] { border-left-color: var(--amber); }
+  .answer .q { color: var(--faint); font-size: 12px; }
+  .answer .head { font: 600 18px var(--sans); margin: 2px 0 4px; }
+  .answer p { margin: 2px 0; color: var(--soft); font-size: 13px; }
+  .cmp { background: var(--panel); border: 1px solid var(--line); border-radius: 6px; padding: 12px 14px; margin: 0 0 10px; }
+  .cmp .top { display: flex; flex-wrap: wrap; align-items: baseline; gap: 4px 12px; margin-bottom: 8px; }
+  .cmp .verdict { margin-left: auto; font: 600 13px var(--mono); }
+  .chip.wraps { white-space: normal; overflow-wrap: anywhere; }
+  .meter { display: grid; grid-template-columns: 48px minmax(60px, 1fr) 44px minmax(0, 230px); align-items: center; gap: 2px 10px; margin: 4px 0; font-size: 13px; }
+  .meter .pctv { text-align: right; }
+  @media (max-width: 640px) {
+    .stage { grid-template-columns: 1fr; } nav { margin-left: 0; }
+    .meter { grid-template-columns: 48px minmax(60px, 1fr) 44px; } .meter .detail { grid-column: 2 / -1; }
+  }
 </style>
 </head>
 <body>
@@ -210,34 +224,105 @@ const RENDER = {
 
   learning(d) {
     if (!d) return el('p', { class: 'empty' }, 'No profile here to read the learning cycle of.');
-    const measured = d.checks.filter((c) => c.before);
+    const name = (rel) => rel.replace(/^\.claude\/pills\//, '').replace(/^retired\//, '').replace(/\.md$/, '');
+    const graduated = (rel) => rel.startsWith('.claude/pills/retired/');
+    const dayOf = (iso) => new Date(`${iso}T12:00:00`).toLocaleDateString(undefined, { month: 'short', day: 'numeric' });
+    const daysIn = ([a, b]) => Math.round((Date.parse(`${b}T12:00:00Z`) - Date.parse(`${a}T12:00:00Z`)) / 86_400_000) + 1;
+    const lessonChip = (rel) => el('span', { class: 'chip wraps', title: rel }, name(rel), graduated(rel) ? el('span', { class: 'faint' }, ' · graduated') : null);
+    // Lessons written the same day for the same stage are read over the same rounds, so they are one comparison, not
+    // a row each repeating its numbers.
+    const groups = [];
+    for (const c of d.checks.filter((x) => x.before)) {
+      const same = groups.find((g) => g.role === c.role && g.date === c.date && g.on === c.on);
+      if (same) same.lessons.push(c.rel);
+      else groups.push({ ...c, lessons: [c.rel] });
+    }
+    const rank = { higher: 0, lower: 1, unclear: 2 };
+    groups.sort((a, b) => rank[a.change] - rank[b.change] || b.date.localeCompare(a.date) || a.role.localeCompare(b.role));
     const unmeasured = d.checks.filter((c) => !c.before);
+    const [less, more, unclear] = ['lower', 'higher', 'unclear'].map((k) => groups.filter((g) => g.change === k).length);
+    const lessonsRead = new Set(groups.flatMap((g) => g.lessons)).size;
+    const history = d.span ? daysIn(d.span) : 0;
+    const shortest = Math.min(...groups.flatMap((g) => [g.before, g.after]).map((side) => (side.span[0] ? daysIn(side.span) : 0)));
+    // The share is of work sent back, so up is worse. A move the rounds are too few to tell from chance still says
+    // which way it went: "could be chance" alone read, beside 33% → 67%, as if the larger number were the better one.
+    const share = (side) => (side.n ? Math.round((100 * side.loops) / side.n) : 0);
+    const verdict = (g) =>
+      g.change === 'lower' ? ['ok', '▼ better: sent back less']
+      : g.change === 'higher' ? ['bad', '▲ worse: sent back more']
+      : share(g.after) > share(g.before) ? ['faint', '▲ sent back more, but could be chance']
+      : share(g.after) < share(g.before) ? ['faint', '▼ sent back less, but could be chance']
+      : ['faint', '≈ no change'];
+
+    const answer = !groups.length
+      ? { tone: 'faint', head: 'Not measurable yet', body: unmeasured.length ? `None of the ${unmeasured.length} lesson-and-stage pairs has enough rounds of its stage on both sides of its date — the reasons are at the bottom.` : 'No lesson has been written yet.' }
+      : less && more
+        ? { tone: 'warn', head: 'Mixed', body: `${less} comparison(s) sent back less since their lessons, ${more} sent back more, ${unclear} with no clear change.` }
+        : more
+          ? { tone: 'bad', head: 'Sent back more since', body: `In ${more} of ${groups.length} comparison(s) the stage had more of its work sent back after its lessons than before; ${unclear ? `the other ${unclear} show no clear change` : 'none shows less'}.` }
+          : less
+            ? { tone: 'ok', head: 'Sent back less since', body: `In ${less} of ${groups.length} comparison(s) the stage had less of its work sent back after its lessons than before${unclear ? `; the other ${unclear} show no clear change` : ''}.` }
+            : { tone: 'faint', head: 'No clear change yet', body: `None of the ${groups.length} comparison(s) moved by more than chance moves a share at that many rounds.` };
+
+    const meter = (label, side) => el('div', { class: 'meter' },
+      el('span', { class: 'faint' }, label),
+      bar([[side.n ? side.loops / side.n : 0, 'var(--amber)']]),
+      el('span', { class: 'mono pctv' }, pct(side.loops, side.n)),
+      el('span', { class: 'faint detail' }, `${side.loops} of ${side.n} rounds · ${side.span[0] ? `${dayOf(side.span[0])}${side.span[1] !== side.span[0] ? ` – ${dayOf(side.span[1])}` : ''}` : 'no day'}`),
+    );
+    const comparison = (g) => el('div', { class: 'cmp' },
+      el('div', { class: 'top' },
+        el('span', { class: 'role' }, g.role),
+        el('span', { class: 'soft' }, `${g.lessons.length} lesson${g.lessons.length > 1 ? 's' : ''} written ${dayOf(g.date)}`),
+        g.on ? el('span', { class: 'faint mono' }, g.on) : null,
+        el('span', { class: `verdict ${verdict(g)[0]}` }, verdict(g)[1]),
+      ),
+      el('div', { class: 'faint', style: 'font-size:12px;margin:0 0 2px' }, `share of the ${g.role}'s rounds sent back to it · lower is better`),
+      meter('before', g.before),
+      meter('after', g.after),
+      el('div', { class: 'faint', style: 'margin:6px 0 8px' }, `for reference, the other stages over the same days: ${pct(g.control.before.loops, g.control.before.n)} → ${pct(g.control.after.loops, g.control.after.n)}`),
+      el('div', { class: 'chips' }, g.lessons.map(lessonChip)),
+    );
+    // What could not be measured, by its reason: the same reason, word for word, is one line.
+    const reasons = new Map();
+    for (const c of unmeasured) reasons.set(c.why, [...(reasons.get(c.why) ?? []), c.rel]);
+
     return el('div', {},
       el('h2', {}, 'Learning'),
       el('p', { class: 'sub' }, said('Whether the pipeline learns from its own runs, link by link, as `nina learn` reads it.')),
+      el('div', { class: 'answer', 'data-tone': answer.tone },
+        el('div', { class: 'q' }, 'Did the lessons help?'),
+        el('div', { class: 'head' }, answer.head),
+        el('p', {}, answer.body),
+        groups.length && history < 2 * d.window + 1
+          ? el('p', {}, `This project has ${history} day(s) of history, so a lesson is compared over fewer than the ${d.window} days either side the measure asks for: read it as an early sign.`)
+          : groups.length && shortest < d.window
+            ? el('p', {}, `The shortest comparison has rounds on ${shortest} day(s) of one side, of the ${d.window} the measure reads: read it as an early sign.`)
+            : null,
+      ),
       el('div', { class: 'cards' },
-        card('observe', d.rounds ? `${d.runs} runs` : '—', d.rounds ? `${d.rounds} rounds, ${d.span[0]} → ${d.span[1]}` : 'nothing recorded'),
-        card('capture', d.late.length ? `${d.late.length} owed` : '✓', d.late.length ? 'stages sent back with nothing written down' : `no stage sent back 3+ times without a lesson in ${d.days} days`),
-        card('apply', d.use.measured ? pct(d.use.read, d.use.measured) : '—', d.use.measured ? `of ${d.use.measured} runs read a lesson` : 'not measured yet'),
-        card('graduate', `${d.open.length} open`, `${d.ready.length} at 3+ · ${d.madeHere} made a rule here`),
+        card('observe · what ran', d.rounds ? `${d.runs} runs` : '—', d.rounds ? `${d.rounds} rounds, ${d.span[0]} → ${d.span[1]}` : 'nothing recorded'),
+        card('capture · written down?', d.late.length ? `${d.late.length} owed` : '✓', d.late.length ? 'stages sent back with nothing written down' : `no stage sent back ${d.at}+ times without a lesson in ${d.days} days`),
+        card('apply · read?', d.use.measured ? pct(d.use.read, d.use.measured) : '—', d.use.measured ? `of ${d.use.measured} runs read a lesson` : 'not measured yet'),
+        card('verify · helped?', !groups.length ? '—' : less && more ? 'mixed' : more ? '▲ more' : less ? '▼ less' : '≈ unclear', groups.length ? `${groups.length} comparison(s) of ${lessonsRead} lesson(s): ${less} sent back less, ${more} more` : 'nothing measurable yet'),
+        card('graduate · made rules?', `${d.open.length} open`, `${d.ready.length} at ${d.at}+ · ${d.madeHere} made a rule here${d.relapses.length ? ` · ${d.relapses.length} watched` : ''}`),
         card('loops', d.gated ? (d.activity ? String(d.activity.rounds) : '—') : 'no gate', d.activity ? `rounds on capped edges · ${d.activity.held} sent to you` : d.gated ? 'no ledger yet' : 'caps are instructions'),
       ),
       d.late.length ? [el('h3', {}, 'capture · sent back with nothing written down'), d.late.map((o) => el('div', { class: 'note' }, el('span', { class: 'role' }, o.role), ` ${o.count} loop-back(s) ${o.since ? `since its newest lesson (${o.since})` : 'and no lesson at all'}`, el('ul', { class: 'list soft' }, o.recent.map((r) => el('li', {}, `${when(r.ts)} · ${r.desc ?? '(no description)'}`)))))] : null,
+      el('h3', {}, 'verify · is each stage sent back less since its lessons?'),
+      el('p', { class: 'note soft', style: 'margin-bottom:12px' }, `For each lesson, the share of its stage's rounds that a later stage sent back, in the ${d.window} days before it was written and the ${d.window} after — lower is better. A change is called only when it is larger than chance moves a share at that many rounds. The other stages, over the same days, say whether everything moved at once: then it was the work that changed, not the lesson.`),
+      groups.length ? groups.map(comparison) : el('p', { class: 'note faint' }, 'No lesson could be measured yet.'),
       d.owed.length ? [el('h3', {}, 'to graduate · here or in the harness'), d.owed.map((o) => el('p', { class: 'note' }, el('span', { class: 'mono' }, o.rel), o.declined ? el('span', { class: 'soft' }, ` — declined by the harness${o.declined.in ? ` in ${o.declined.in}` : ''}: ${o.declined.why}`) : el('span', { class: 'soft' }, ` — recurred ${o.occurrences} times`)))] : null,
       d.open.length ? [el('h3', {}, 'requests open in the harness'), table(['since', 'pill', 'proposed for'], d.open.map((r) => [el('span', { class: 'mono soft' }, r.date), el('span', { class: 'mono' }, r.pill), r.target]))] : null,
-      d.relapses.length ? [el('h3', {}, 'came back after graduating'), d.relapses.map((r) => el('p', { class: `note ${r.due ? 'bad' : 'soft'}` }, `${r.due ? '✗' : '·'} ${r.rel} came back ${r.recurred} time(s) after ${r.target === 'project' ? `it became a rule here in ${r.rule_in}` : `its rule shipped in ${r.answered_in || 'a release'}`}${r.due ? ' — the rule did not hold' : ' — watched'}`))] : null,
-      el('h3', {}, 'verify · is each lesson sent back less since?'),
-      measured.length
-        ? table(['lesson', 'stage', 'before → after', 'n', 'change', 'other stages'], measured.map((c) => [
-            el('span', { class: 'mono' }, c.rel.replace(/^\.claude\/pills\//, '')),
-            el('span', { class: 'role' }, c.role),
-            `${pct(c.before.loops, c.before.n)} → ${pct(c.after.loops, c.after.n)}`,
-            `${c.before.n} → ${c.after.n}`,
-            el('span', { class: c.change === 'lower' ? 'ok' : c.change === 'higher' ? 'bad' : 'faint' }, { lower: 'sent back less', higher: 'sent back more', unclear: 'no clear change' }[c.change]),
-            el('span', { class: 'soft' }, `${pct(c.control.before.loops, c.control.before.n)} → ${pct(c.control.after.loops, c.control.after.n)}`),
-          ]), [3])
-        : el('p', { class: 'note faint' }, 'No lesson could be measured yet.'),
-      unmeasured.length ? el('p', { class: 'note faint' }, `${unmeasured.length} more could not be measured.`) : null,
+      d.relapses.length ? [el('h3', {}, 'graduated, then seen again'),
+        d.relapses.map((r) => el('p', { class: 'note' },
+          el('span', { class: r.due ? 'bad' : 'faint' }, r.due ? '✗ ' : '· '),
+          el('span', { class: 'mono', title: r.rel }, name(r.rel)),
+          el('span', { class: 'soft' }, ` — seen ${r.recurred} time(s) since its rule ${r.target === 'project' ? `was made here in ${r.rule_in}` : `shipped in ${r.answered_in || 'a release'}`}`),
+          r.due ? el('span', { class: 'bad' }, ': the rule did not hold') : el('span', { class: 'faint' }, `; watched, it reopens at ${d.at}`)))] : null,
+      unmeasured.length ? el('details', { style: 'margin-top:24px' },
+        el('summary', { class: 'soft', style: 'cursor:pointer' }, `${unmeasured.length} lesson-and-stage pair(s) could not be measured, and why`),
+        [...reasons].map(([why, rels]) => el('div', { class: 'note', style: 'margin:10px 0' }, el('div', { class: 'soft' }, why), el('div', { class: 'chips', style: 'margin-top:4px' }, rels.map(lessonChip))))) : null,
     );
   },
 

package/src/dashboard.mjs

@@ -21,7 +21,7 @@ import { layerRootFor } from './commands/compose.mjs';
 import { taskList } from './commands/runs.mjs';
 import { pipelineData } from './commands/pipeline.mjs';
 import { pillsData } from './commands/pills.mjs';
-import { learningData } from './commands/learn.mjs';
+import { CAPTURE_AT, VERIFY_DAYS, learningData } from './commands/learn.mjs';
 import { statsData } from './commands/stats.mjs';
 
 /** The page: one self-contained file, nothing fetched from anywhere else. */
@@ -72,6 +72,10 @@ export function dashboardTabs(target, ctx) {
       const d = await learningData(target, layers.dir, profile, { records: roundsOf(target) });
       return {
         days: d.days,
+        // How many times makes an event: a stage sent back, a lesson recurring, a rule that came back. And the days
+        // either side of a lesson that verify reads, which a project younger than them cannot fill.
+        at: CAPTURE_AT,
+        window: VERIFY_DAYS,
         runs: d.runs,
         rounds: d.rounds,
         span: d.span,