@xhulz/nina 0.72.0 → 0.74.0

package/releases/0.74.0/surfaces/integrations/tree/.claude/graph.md

@@ -0,0 +1,10 @@
+<!-- nina:slot integrations.1 -->
+- `integration-tester` — gate: runs the real dependency when the diff touches what its spec lists
+
+<!-- nina:slot integrations.2 -->
+- `implementer` → `integration-tester` on `DIFF-READY` — the diff touches what its spec lists
+- `integration-tester` → `qa` on `APPROVED` — once the reviewer, and every other gate the diff went to, approved too
+- `integration-tester` → `architect` on `REJECTED` — a premise is wrong · max 2
+- `architect` → `integration-tester` on `BLOCKED` — a premise of a live service must be observed before the design can settle; the report goes back to the architect · max 2
+- `integration-tester` → `implementer` on `REJECTED` — the premise holds and the code does not honor it · max 2
+- `qa` → `integration-tester` on `FAIL` — the failure is the environment, not the code · max 2

package/releases/0.74.0/surfaces/integrations/tree/.claude/patterns.md

@@ -0,0 +1,38 @@
+<!-- nina:slot integrations.1 -->
+- **Queue** (`{{API_DIR}}/src/queues/<q>.ts`) / **Webhook** (`{{API_DIR}}/src/routes/<source>-webhook.ts`): same discipline — validate the input, build deps, call one service function.
+
+<!-- nina:slot integrations.2 -->
+- **Every integration is reached through its boundary module.** Services import the boundary's typed interface; they never construct an HTTP client, an SDK instance or a binding handle themselves.
+
+<!-- nina:slot integrations.3 -->
+
+---
+
+## Integrations (enforced by integration-tester + reviewer)
+
+An **integration** is a dependency whose behavior this project does not define. Each one is declared in `.nina/profile.json` with a `kind`, or a list of them, and a premise's kind decides what counts as evidence for it:
+
+| kind | what it is | a premise is settled by |
+|---|---|---|
+| `installed-library` | code on disk under `node_modules` | `<package dir>/node_modules/<lib>/<file>:<line>`, the version beside it; one no package links, through the one that depends on it: `<package dir>/node_modules/<parent> → <lib>@<version>/<file>:<line>` |
+| `live-api` | a third-party HTTP API | a contract-test case, or a response observed against the service and captured verbatim |
+| `platform-binding` | a runtime the host provides | behavior observed under the local emulator, plus the platform's installed types |
+
+- **One boundary per integration.** All access goes through the module named as its `boundary`. A service, route, queue consumer or scheduled handler that reaches the dependency directly is a hard reject: there is then no single place to mock it, retry it, log it, or fix it.
+- **A `live-api` gets two implementations behind one interface** — the real client, and a deterministic in-memory mock. One **contract-test suite** exercises the interface and **BOTH** must pass it. The mock passing alone proves nothing about production; when the two disagree, the mock is wrong, never the other way round.
+- **Validate responses at the boundary**, in both implementations, so drift in the dependency surfaces structurally instead of as a type error three layers downstream.
+- **Typed errors at the boundary.** It maps the dependency's failures to this project's own error types; callers never handle a raw HTTP status or a vendor error code.
+
+### Adding an integration
+
+Four things, and none of them is optional:
+
+1. **The doc** — `.claude/integrations/<slug>.md`, from `.claude/templates/integration.md`. It opens with a premise index, then one `## P<n>` section per premise: a one-sentence claim, and the evidence that settles it in the form its kind requires.
+2. **The boundary** — one module, named in the profile entry. For a `live-api`: the interface, both implementations, and the contract suite.
+3. **The profile entry** — `slug`, `name`, `kind`, `boundary` and `skill` in `.nina/profile.json`. This is what makes the integration visible to the gates; an integration that is not declared is not gated.
+4. **The skill binding, when one exists.** If an installed skill covers this dependency, name it in the entry's `skill` field and add its row to the *Skills you MUST consult* table of every agent that touches the surface. The table ends in a `skills` slot for exactly this: write the row in `.nina/project/tree/.claude/agents/<role>.md` under that slot's marker (`nina where .claude/agents/<role>.md` names it), with the skill in the first cell and the trigger in the second (where the section is a list or a paragraph, the skill in bold), then `nina compose`. `nina check` confirms the agent's `tools:` grants `Skill`, which is an allowlist, not a hint. **If no installed skill covers it, bind none:** an invented binding is worse than none, because it reads as retrieval while being recall.
+
+The **integration-tester** owns the doc: it creates it on first contact and appends a premise whenever it observes behavior the doc does not yet carry. The architect cites it, the implementer honors it, and the reviewer refuses a spec that touches the surface without it.
+
+<!-- nina:slot integrations.4 -->
+- **`live-api` integrations:** the contract-test suite for the boundary runs against BOTH implementations. Tests elsewhere inject the mock; the integration gate exercises the real service.

package/releases/0.74.0/surfaces/integrations/tree/.claude/pipeline.md

@@ -0,0 +1,16 @@
+<!-- nina:slot integrations.1 -->
+
+### Integration-tester (mandatory for integration boundaries)
+
+- **Trigger:** any diff touching the boundary module of a declared integration, or adding a call into one.
+- **Input:** architect spec (with its **Integration premises** section) + implementer diff + repo state.
+- **Output:** approve or reject. Approve includes a verified-premise table (premise → verdict → citation). Reject identifies which premise or contract case failed, and whether the fix is upstream (respec) or in code.
+- **Tools:** Read, Write, Edit, Glob, Grep, Bash. Edits scoped to integration/contract test dirs and `.claude/integrations/**`.
+- **Checks:**
+  - **`installed-library` / `platform-binding`:** run the real flow against the real dependency. Read `.claude/integrations/<slug>.md` and probe each premise it lists.
+  - **`live-api`:** run the **contract-test suite** for that boundary against **both** implementations. A mock that is green while the real client is not is a lie. Confirm nothing reaches the service outside its boundary module.
+  - Update `.claude/integrations/<slug>.md` when new behavior is observed.
+- **Position:** after implementer, in parallel with any other gate the diff triggered. Reviewer verifies both gates ran.
+
+<!-- nina:slot integrations.2 -->
+  - **If an integration boundary was touched → integration-tester approved.**

package/releases/0.74.0/surfaces/integrations/tree/.claude/retrieval.md

@@ -0,0 +1,16 @@
+<!-- nina:slot integrations.1 -->
+
+## Integration docs (load whenever an integration is touched)
+
+`.claude/integrations/<slug>.md` holds the verified premises for one integration. The architect MUST cite premises from it — or add new ones, carrying the evidence the integration's kind requires — in any spec that touches the boundary. The integration-tester probes each cited premise before `qa` goes out.
+
+This project's integrations:
+
+<!-- nina:slot integrations.2 -->
+
+The integration-tester owns these docs. It creates one on first contact with a dependency and appends a premise whenever it observes behavior the doc does not yet carry, written against the version actually installed here or the response actually observed — never against the vendor's documentation.
+
+Read the doc's index and the premise sections your task cites. **Not the whole file:** an integration doc for a large dependency runs to thousands of lines, and reading it end to end is one of the biggest time sinks in this pipeline.
+
+<!-- nina:slot integrations.3 -->
+| Integration boundary change | `.claude/integrations/<slug>.md`, and the boundary module named in the profile | architect (cites premises) → implementer → reviewer + **integration-tester** → qa |

package/releases/0.74.0/surfaces/integrations/tree/.claude/router.md

@@ -0,0 +1,6 @@
+<!-- nina:slot integrations.1 -->
+
+### Integration-tester is a guardrail for integration boundaries
+Invoke **integration-tester** any time the diff touches the boundary module of a declared integration, or adds a call into one. It runs the real dependency, never a mock of it; for a `live-api` it runs the **contract-test suite against BOTH implementations**, so the mock can never pass while the live path is broken. No such change merges without its approval.
+
+The architect's spec MUST carry an **Integration premises** section: every behavior the implementation relies on, each with the evidence its kind requires — `<package dir>/node_modules/<lib>/<file>:<line>` with its version for an installed library, a contract case or an observed response for a live API, the local emulator for a platform binding. Never by inference. An architect `BLOCKED` on a live service's premise gets it observed by the integration-tester, then resumes with its report.

package/releases/0.74.0/surfaces/integrations/tree/CLAUDE.md

@@ -0,0 +1,17 @@
+<!-- nina:slot integrations.1 -->
+| **ANY integration surface** (the boundary module of a declared integration, or a new call into one) | architect cites a premise, with the evidence its kind requires, for every dependency behavior the code relies on; **+ integration-tester beside the reviewer** |
+
+<!-- nina:slot integrations.3 -->
+- **integration-tester** → mandatory gate on any integration boundary; runs the real dependency rather than a mock of it, and for a `live-api` runs the contract-test suite against both implementations so they cannot diverge; verifies every cited premise; keeps `.claude/integrations/<slug>.md` current
+
+<!-- nina:slot integrations.4 -->
+11. **Every integration has one boundary and one doc.** A dependency whose behavior you do not define — an installed library, a live third-party API, a platform binding — is reached through exactly ONE module, and nothing else speaks to it: no raw HTTP, SDK instance or binding handle in a route, service, queue consumer or scheduled handler. Each is declared in `.nina/profile.json` with its `kind` — a list, where it is more than one — and `boundary`, and documented at `.claude/integrations/<slug>.md`. A `live-api` carries two implementations behind one interface — the real client and a deterministic mock — and one contract-test suite that BOTH must pass; a mock that is green while the real client is not is a lie, and a hard reject.
+
+<!-- nina:slot integrations.5 -->
+12. **A premise about an integration requires a citation, and the form depends on the kind.** The architect MAY NOT state a dependency's behavior as fact without evidence: for an `installed-library`, `<package dir>/node_modules/<lib>/<file>:<line>` with the version installed here beside it — the package's own link, not the store directory a peer change renames, and for a dependency of a dependency, which no package links, its parent's: `<package dir>/node_modules/<parent> → <lib>@<version>/<file>:<line>`; for a `live-api`, a contract-test case or a response observed against the service and captured verbatim — observed by the integration-tester, before the spec when the design depends on it; for a `platform-binding`, behavior observed under the local emulator. An integration of two kinds — a client library over a platform binding — cites each premise by the kind it is about: the library's own behavior from its source, the binding's from the emulator. Vendor docs, a README, a changelog and recall are NOT citations. An uncited premise is an assumption, and the spec is rejected by the reviewer.
+
+<!-- nina:slot integrations.6 -->
+13. **Integration boundaries require the integration-tester gate before qa.** Any diff touching a boundary module, or adding a call into one, MUST pass the integration-tester, which runs beside the reviewer, before `qa` goes out. Unit-test mocks honor the spec, not the dependency — a mock is green because we wrote it that way. Only a run against the real thing, or a contract suite both implementations pass, catches drift.
+
+<!-- nina:slot integrations.7 -->
+- **an integration boundary**: a call to an external service, or a webhook or callback from one

package/releases/0.74.0/surfaces/money/tree/.claude/agents/architect.md

@@ -0,0 +1,12 @@
+<!-- nina:slot money.1 -->
+- **Money invariants** — if the spec touches distribution, transfer generation, or a send to the payment integration, explicitly confirm the design honors:
+    - Money is integer {{MINOR_UNIT}} end to end; percentages are basis points. Never a floating-point type.
+    - A distribution may NEVER exceed the amount → **block** (reject the operation, do not clamp it).
+    - A distribution **less** than the amount → **allow**, surface the shortfall, leave the remainder **parked** — never silently distributed.
+    - Transfers are **idempotent** — never sent twice. Dedupe happens at the serialization point, via the key, before the side effect.
+    - Every legal state transition writes an audit row (who / when / from → to). Illegal transitions throw.
+
+    If the design cannot satisfy all of these, redesign before submitting the spec.
+
+<!-- nina:slot money.2 -->
+- Design a money movement that can exceed the amount it distributes, silently absorb a shortfall, or send a transfer twice. If the design needs monetary computation, that computation lives in `{{CORE_PKG}}` as a pure function — never inline in a service or route.

package/releases/0.74.0/surfaces/money/tree/.claude/agents/dba.md

@@ -0,0 +1,14 @@
+<!-- nina:slot money.1 -->
+- **No cache on a read that feeds a money write.** Anything that loads an amount or a balance before computing, approving or dispatching a transfer MUST NOT be cached. A stale amount contaminates a real money movement, and that damage is not undone by fixing the cache afterwards. **Hard reject if violated.**
+
+<!-- nina:slot money.2 -->
+- **Monetary columns are integer.** Money is stored as an integer of the currency's minor unit ({{MINOR_UNIT}}); percentages are basis points. Reject `Decimal`, `Float`, or any type that can hold a fraction of the minor unit.
+
+<!-- nina:slot money.3 -->
+- **Money-integrity constraints.** When the change touches the record of an outbound transfer, verify the **unique constraint on its idempotency key** exists (`@unique` in the schema → `UNIQUE` in the migration SQL). That constraint is what still holds when the application-level guard fails; a missing or dropped one is a **hard reject**. Verify likewise any uniqueness the ownership model depends on. Report it in its own *Money-integrity* section, before the final verdict.
+
+<!-- nina:slot money.4 -->
+- Approve a cache policy on a query that feeds a money write.
+
+<!-- nina:slot money.5 -->
+- Approve a change to an outbound-transfer record that lacks the unique constraint on its idempotency key.

package/releases/0.74.0/surfaces/money/tree/.claude/agents/implementer.md

@@ -0,0 +1,11 @@
+<!-- nina:slot money.1 -->
+
+## Money invariants you MUST honor
+- **A distribution may NEVER exceed the amount** → block. Implement the reject; never clamp and continue.
+- **A shortfall is parked, not distributed.** Surface it and leave the remainder where it is — never auto-distribute it, never absorb it quietly.
+- **Transfers are idempotent — never sent twice.** Dedupe at the serialization point via the key, *before* the side effect. A retry, a re-delivered message or a double-click must not produce a second transfer.
+- **Every state transition writes an audit row** (entity, from → to, actor). No transition without a trail.
+- The deterministic money logic lives in `{{CORE_PKG}}` — call it as a pure function; never embed the arithmetic in a service.
+
+<!-- nina:slot money.2 -->
+- Embed money arithmetic (sums, deltas, value comparisons, distribution math) inline in a service. Computation lives in `{{CORE_PKG}}`.

package/releases/0.74.0/surfaces/money/tree/.claude/agents/integration-tester.md

@@ -0,0 +1,3 @@
+<!-- nina:slot money.1 -->
+- **Confirm idempotency holds end to end.** Two sends with the same key → one logical transfer, no double send, and the serialization point refuses the second. This is the highest-blast-radius invariant in the system — drive it explicitly against the real service; do not infer it from reading the code.
+- **Confirm money crosses the boundary as an integer of the minor unit**, and that conversion happens only in the module that owns it — never in a service, never through a floating-point type.

package/releases/0.74.0/surfaces/money/tree/.claude/agents/reviewer.md

@@ -0,0 +1,23 @@
+<!-- nina:slot money.1 -->
+- **Enforce the money invariants. Each violation is a HARD REJECT → loop back to architect:**
+  - **A distribution may NEVER exceed the amount.** It is blocked, not clamped. A retention is just another destination — same arithmetic, in integer {{MINOR_UNIT}}.
+  - **A shortfall must be parked, not silently distributed.** The remainder stays where it is, and the shortfall is surfaced to whoever is owed it.
+  - **Transfers must be idempotent — never sent twice.** Every transfer carries a key, and dedupe happens at the serialization point before the side effect. A retry, a re-delivered message or a double-click must never produce a second transfer.
+  - **Every state transition writes an audit row** (entity type, id, from, to, actor) and follows the transitions declared in `.claude/architecture.md`. An undeclared transition, or one missing its audit row, is a hard reject.
+
+<!-- nina:slot money.2 -->
+- **money-invariants** — a distribution never exceeds the amount; a shortfall is parked, never
+  distributed; transfers idempotent at the serialization point; an audit row on every transition;
+  integer {{MINOR_UNIT}} and basis points; no arithmetic outside `{{CORE_PKG}}`.
+
+<!-- nina:slot money.3 -->
+- `{{CORE_PKG}}` money logic touched (distribution and transfer generation are high-blast-radius)
+
+<!-- nina:slot money.4 -->
+- Approve a change that lets a distribution exceed the amount, silently distributes a shortfall, sends a transfer without idempotent dedupe, or skips an audit row — those are hard rejects, loop back to architect.
+
+<!-- nina:slot money.5 -->
+- **If APPROVED:** ≤300 words. Sections: Verification commands run (typecheck/lint/build only — NEVER vitest), Spec-match (✅/❌ per item), Hard-rule checks (tenant scoping ✅, integer {{MINOR_UNIT}} / bps ✅, each gate the diff triggered ✅ (`.claude/graph.md`), money invariants ✅ — distribution ≤ amount, shortfall parked, idempotent transfer, audit row on transition), QA-attention flags (list any condition from the "stricter audit" list so QA knows what to focus on), Final verdict.
+
+<!-- nina:slot money.6 -->
+- Money invariant violated (distribution exceeds the amount, shortfall silently distributed, non-idempotent transfer, missing audit row) → back to **architect** for redesign.

package/releases/0.74.0/surfaces/money/tree/.claude/agents/secops.md

@@ -0,0 +1,5 @@
+<!-- nina:slot money.1 -->
+- **Money-movement abuse (Hard Rules #3, #4, #5)** — **the money path reaches a real service; this is not a stub audit.** Is the idempotency contract actually enforced at the seam — the unique key, the serialization point, and the dedupe happening *before* the side effect? Can a replay, a double-click, a queue redelivery, or a manual reset of processed state cause a double send? Can a distribution exceed the amount, or a shortfall be silently distributed? Is whatever authorizes money OUT forgeable — a webhook without a verified signature, a callback trusted on its word? Is every state transition forced through an audit write? Flag any seam that is structurally unable to enforce its invariant, even where nothing has exploited it yet.
+
+<!-- nina:slot money.2 -->
+- **Idempotency-key & replay surface** — keys unguessable and collision-resistant where it matters; dedup enforced before the side effect, not after.

package/releases/0.74.0/surfaces/money/tree/.claude/agents/solidity-auditor.md

@@ -0,0 +1,4 @@
+<!-- nina:slot money.1 -->
+- **The conservation property, asserted rather than argued.** Find the test that proves in equals
+  out plus retained, and check it holds on the adversarial paths too, not only the intended one.
+  Rounding that always favours the same party is a finding; so is a fee path with no upper bound.

package/releases/0.74.0/surfaces/money/tree/.claude/agents/solidity-dev.md

@@ -0,0 +1,4 @@
+<!-- nina:slot money.1 -->
+- **State the conservation property and assert it in the suite.** A contract that holds or routes an
+  amount has one — what goes in equals what goes out plus what is retained — and it belongs in a
+  test, not in a comment. Rounding is part of it: say which way it goes and who it favours.

package/releases/0.74.0/surfaces/money/tree/.claude/graph.md

@@ -0,0 +1,2 @@
+<!-- nina:slot money.1 -->
+- `reviewer` → `architect` on `REJECTED` — a money invariant is broken (a distribution over the amount, a shortfall distributed, a transfer that is not idempotent, a transition with no audit row): a design question before it is a code one · max 2

package/releases/0.74.0/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.74.0/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.74.0/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.74.0/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.74.0/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.74.0/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.74.0/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.74.0/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.74.0/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.74.0/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. **A test that proves a value stays out matches by containment** (`String(v).includes(value)`), never by equality: a leak arrives inside an id, a message or a key. It gives each log call in the source a run, asserts the silent channels silent, and reads every property of each entry and each error the runs produce, the non-enumerable ones too (`Object.getOwnPropertyNames`). Its forbidden values are the run's own that § *Privacy* keeps out — where it lists what may be logged, every other value the run carries — each with a control that embeds it in a longer string under an allowed key and must fail the check, and no fixture value inside another's.<!-- nina:why --> In one project an allowlist check that refused only equal values passed a mutant logging `${id}:${amount}`; the next read `Object.keys` and missed an amount on a non-enumerable property and an info log no row inspected; the one after left out a class and four log paths.<!-- /nina:why --> 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.74.0/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.74.0/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.74.0/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.74.0/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.74.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.74.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.74.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.74.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/cost.mjs

@@ -23,7 +23,7 @@
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { projectGateDir } from './gate.mjs';
-import { CLIP_MARK } from './transcripts.mjs';
+import { CLIP_MARK, contextSize } from './transcripts.mjs';
 
 /** Where a run's counts are kept between calls, one file per agent. */
 const stateDir = (root) => join(projectGateDir(root), 'cost');
@@ -38,7 +38,7 @@ const KEEP_MS = 7 * 86_400_000;
  * @param {number} from - The offset already read.
  * @returns {{text: string, to: number}}
  */
-function gained(path, from) {
+export function gained(path, from) {
   const size = statSync(path).size;
   if (size <= from) return { text: '', to: size < from ? 0 : from };
   const buffer = Buffer.alloc(size - from);
@@ -238,7 +238,7 @@ function count(input, { root, warnAt, now }) {
         state.read[message.id] = read;
         last = read;
         // The whole context that turn held, which a turn after an expired cache writes again.
-        state.context = read + n(message.usage.cache_creation_input_tokens) + n(message.usage.input_tokens);
+        state.context = contextSize(message.usage);
       }
     } catch {
       // A torn line loses one message's count.

package/src/office.html

@@ -31,8 +31,15 @@
   #tasks .who { margin-top: 3px; color: #c9cde0; font-size: 12px; overflow-wrap: anywhere; }
   #tasks .now { margin-top: 2px; color: #ffd34d; font-size: 12px; }
   #tasks .now.quiet { color: #8a8fa8; }
+  #tasks ul.agents { list-style: none; margin: 8px 0 0; padding: 0; }
+  #tasks ul.agents li { margin: 0 0 7px; padding: 0 0 0 14px; }
+  #tasks ul.agents li::before { left: 1px; top: 4px; width: 7px; height: 7px; border: 0; background: #ffd34d; animation: beat 1.2s ease-in-out infinite; }
+  #tasks .agent { overflow-wrap: anywhere; font-size: 12px; color: #c9cde0; }
+  #tasks .role { font: 600 12px ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; color: #fff8e8; margin-right: 6px; }
+  #tasks .desc { margin-top: 1px; color: #8a8fa8; font-size: 11px; overflow-wrap: anywhere; }
+  #tasks .took { margin-top: 1px; color: #a9adbf; font: 11px ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }
   @keyframes beat { 50% { opacity: 0.35; } }
-  @media (prefers-reduced-motion: reduce) { #tasks li.running::before { animation: none; } }
+  @media (prefers-reduced-motion: reduce) { #tasks li.running::before, #tasks ul.agents li::before { animation: none; } }
 </style>
 </head>
 <body>
@@ -805,6 +812,14 @@ function onBeat(b) {
     }
     return;
   }
+  if (b.type === 'home') {
+    // Reported, and nobody came for the work in time: it goes home, unless it was sent back to work meanwhile.
+    const p = b.agent ? people.get(b.agent) : null;
+    if (!p || !(p.reported || p.reporting) || p.leaving) return;
+    if (b.instant) leave(p, true);
+    else act(p, () => p.reported && !p.typing && !p.leaving && leave(p));
+    return;
+  }
   if (b.type === 'refused' || b.type === 'stale') {
     // A dispatch the owner refused never ran; a run that never reported has stopped. Either way, whoever sat down
     // for it gets up — and a refusal answers the gate's call.
@@ -975,14 +990,16 @@ function syncButtons() {
  * The session's work, task by task, as the server cuts it — the way `nina runs` does: each named by the words the
  * orchestrator gave its first dispatch, with the stages that worked on it, from when that went out to the verdict
  * that closed it. The server sends the whole list whenever it changes, and it replaces what is here. A task still
- * open counts up while anyone is at work on it, and stops at the last thing that happened while nobody is.
+ * open counts up while anyone is at work on it, and stops at the last of its runs to start or end while nobody is;
+ * under it, each of its agents at work, as Claude Code lists its own: the stage, what it is doing now, the words of
+ * its dispatch, how long it has been at work and the context it holds.
  */
 const SIDE = 300;
 /** Narrower than this, the timeline is drawn over the room, and starts hidden. */
 const NARROW = 760;
 const TASKS_KEY = 'nina-office-tasks';
 let tasks = [];
-/** The newest dispatch or verdict: a replay's clock, and where an idle task's count stops. */
+/** The newest dispatch or verdict: a replay's clock. */
 let lastActivity = 0;
 let tasksOpen = (() => {
   try {
@@ -998,6 +1015,15 @@ let tasksOpen = (() => {
 const atWork = () => [...new Set([...people.values()].filter((p) => p.work && !p.reported && !p.leaving).map((p) => p.role))];
 
 const two = (n) => String(n).padStart(2, '0');
+/** How long an agent has been at work, as Claude Code says it: 28s, 7m 19s, 1h 4m. */
+function took(ms) {
+  const s = Math.max(0, Math.floor(ms / 1000));
+  if (s < 60) return `${s}s`;
+  if (s < 3600) return `${Math.floor(s / 60)}m ${s % 60}s`;
+  return `${Math.floor(s / 3600)}h ${Math.floor((s % 3600) / 60)}m`;
+}
+/** A count of tokens: 850, 49.8k, 1.2M — a count that rounds to a thousand thousands is a million. */
+const tokens = (n) => (n >= 999_950 ? `${(n / 1e6).toFixed(1)}M` : n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n));
 /** A moment as the hour, with the day when it is not the day of `beside` — now, or the moment it follows. */
 function stamp(at, beside) {
   const t = new Date(at);
@@ -1021,26 +1047,43 @@ function counter(ms) {
 function drawTasks() {
   if (!tasksOpen) return;
   const clock = status.startsWith('replay') ? lastActivity : Date.now();
-  const working = atWork();
-  const line = (cls, text) => {
-    const el = document.createElement('div');
+  const line = (cls, text, tag = 'div') => {
+    const el = document.createElement(tag);
     el.className = cls;
     el.textContent = text;
     return el;
   };
+  // What it is doing now, as Claude Code's list leads with, and under it the words its dispatch was given.
+  const agentRow = (a) => {
+    const li = document.createElement('li');
+    const what = line('agent', '');
+    what.append(line('role', a.role, 'span'), a.doing ?? a.desc ?? '');
+    li.append(what);
+    if (a.doing && a.desc) li.append(line('desc', a.desc));
+    li.append(line('took', a.tokens === null ? took(clock - a.start) : `${took(clock - a.start)} · ${tokens(a.tokens)} tokens`));
+    return li;
+  };
   const shown = [...tasks].sort((a, b) => b.start - a.start);
   document.getElementById('task-list').replaceChildren(
     ...shown.map((t) => {
       const li = document.createElement('li');
       const running = t.end === null;
-      const idle = running && working.length === 0;
+      const agents = t.agents ?? [];
+      const idle = running && agents.length === 0;
       li.className = running ? (idle ? 'idle' : 'running') : t.how === 'closed' ? 'done' : 'ended';
       li.append(line('name', t.name || '(no description)'));
       if (t.who?.length > 0) li.append(line('who', t.who.map(([role, n]) => (n > 1 ? `${role} ×${n}` : role)).join(' · ')));
       if (running) {
-        const upTo = idle ? Math.max(t.start, lastActivity) : Math.max(t.start, clock);
+        // Idle, it stops at the last of its own runs to start or end, whatever another task is doing.
+        const upTo = idle ? Math.max(t.start, t.last ?? t.start) : Math.max(t.start, clock);
         li.append(line('when', `${stamp(t.start, clock)} → now · ${counter(upTo - t.start)}`));
-        li.append(line('now', idle ? `idle since ${stamp(lastActivity, clock)}` : `at work: ${working.join(', ')}`));
+        if (idle) li.append(line('now', `idle since ${stamp(t.last ?? t.start, clock)}`));
+        else {
+          const list = document.createElement('ul');
+          list.className = 'agents';
+          list.append(...agents.map(agentRow));
+          li.append(list);
+        }
       } else {
         li.append(line('when', `${stamp(t.start, clock)} → ${stamp(t.end, t.start)} · ${span(t.end - t.start)}`));
         // A task that waited — overnight, on the owner — says how much of it anyone was at work.