@xhulz/nina 0.34.0 → 0.36.0

package/bin/nina.mjs

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
 /**
- * NINA — harness orchestration CLI.
- *
- * Today it captures and reports how the agent pipeline behaves. The composition
- * commands (`init`, `compose`, `check`, `upgrade`) land once the core has been
- * extracted from its first real project.
+ * NINA — composes an agent harness into a project, keeps it wired and current, and measures what the
+ * pipeline it composed does. Each command lives in `src/commands/`; this file is the table of them, and
+ * the one place an argument is checked before any command runs.
  */
 
 import { readFile } from 'node:fs/promises';
@@ -34,55 +32,224 @@ import { status } from '../src/commands/status.mjs';
 /** The NINA install directory (the parent of `bin/`). */
 const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
 
-/** Commands wired today, in the order `help` lists them. */
+/** Where a command acts, which most of them take. */
+const PROJECT = { '--project <dir>': 'the project to act on (default: the working directory)' };
+
+/**
+ * Commands wired today, in the order `help` lists them, each with what it takes: `options`, keyed by the
+ * option and the name of its value when it takes one, and `args`, what it takes that is not an option.
+ * Checked before the command runs, and printed by `nina <command> --help`.
+ */
 const COMMANDS = {
-  init: { run: init, help: 'start a harness for a project: profile, surfaces, and what to fill' },
-  status: { run: status, help: "one screen: the pin, the install and the newest release, the hooks, the gate, check, what the week cost, the learning" },
-  snapshot: { run: snapshot, help: 'capture pipeline history from the Claude Code transcripts' },
-  stats: { run: stats, help: 'report loop-back rate per stage from the snapshots' },
-  runs: { run: runs, help: 'what each piece of work cost: its cycles, their stages and rounds, what was sent back, time and cost' },
-  check: { run: check, help: "validate a project's profile, vocabulary and integrations" },
-  compose: { run: compose, help: 'rebuild a project\'s .claude/ from core + its surfaces' },
-  where: { run: where, help: 'say which layer owns a path, and where a change to it goes' },
-  pipeline: { run: pipeline, help: "draw the project's agent chain: the line, its gates, what goes back, each stage's model and skills" },
-  pills: { run: pills, help: 'validate the corrections the pipeline wrote about itself' },
-  learn: { run: learn, help: 'is the pipeline learning from its own runs? observe, capture, apply, graduate, verify; --deep reads why' },
-  requests: { run: requests, help: "the lessons projects have graduated to the harness — this repo's inbox" },
-  wire: { run: wire, help: "merge the hooks and npm scripts a project's harness needs to run" },
-  gate: { run: gate, help: 'the loop gate: is it wired, and would it still hold a loop past its cap?' },
-  upgrade: { run: upgrade, help: 'move a project to a newer core, reporting what it costs' },
-  eval: { run: evalCommand, help: "does a release's reviewer catch more planted defects than another's? runs on the login" },
-  export: { run: exportCommand, help: 'send the measured history to Langfuse by hand: each run once' },
-  langfuse: { run: langfuse, help: 'keep the Langfuse keys, and turn on the projects that send their runs after every turn' },
-  release: { run: release, help: 'freeze the working core + surfaces as a pinnable version' },
+  init: {
+    run: init,
+    help: 'start a harness for a project: profile, surfaces, and what to fill',
+    options: {
+      ...PROJECT,
+      '--surfaces <list>': 'declare the surfaces, comma-separated, instead of detecting them',
+      '--core <version>': 'the release to pin (default: the newest this install carries)',
+      '--force': 'start over, keeping the pin, the vocabulary and the integrations the profile declares',
+      '--ask': 'ask about the surfaces even when not on a terminal',
+      '--no-ask': 'take the detected surfaces without asking',
+    },
+  },
+  status: {
+    run: status,
+    help: "one screen: the pin, the install and the newest release, the hooks, the gate, check, what the week cost, the learning",
+    options: { ...PROJECT, '--offline': 'do not ask the registry for the newest release' },
+  },
+  snapshot: {
+    run: snapshot,
+    help: 'capture pipeline history from the Claude Code transcripts',
+    options: {
+      '--project <name>': 'only the projects whose name contains this',
+      '--exact': 'only the project named exactly so',
+      '--out <dir>': 'where to write (default: ~/.nina/snapshots)',
+      '--rebuild': 'read every transcript again from the start, keeping a copy of what it replaces',
+    },
+  },
+  stats: {
+    run: stats,
+    help: 'report loop-back rate per stage from the snapshots',
+    options: {
+      '--project <name>': 'the project whose history to read (default: the one here)',
+      '--all': 'every project on this machine',
+      '--since <date>': 'from this day on, YYYY-MM-DD',
+      '--snapshots <dir>': 'read the history from somewhere else',
+    },
+  },
+  runs: {
+    run: runs,
+    help: 'what each piece of work cost: its cycles, their stages and rounds, what was sent back, time and cost',
+    options: { ...PROJECT, '--since <date>': 'from this day on, YYYY-MM-DD', '--last <n>': 'how many cycles (default: 10)' },
+  },
+  check: {
+    run: check,
+    help: "validate a project's profile, vocabulary and integrations",
+    options: {
+      ...PROJECT,
+      '--detector': 'as the project\'s harness:check runs it',
+      '--expect-unfilled <slots>': 'slots, comma-separated, a move is known to leave unfilled',
+    },
+  },
+  compose: {
+    run: compose,
+    help: "rebuild a project's harness files from the core, its surfaces and its own layer",
+    options: {
+      ...PROJECT,
+      '--check': 'report drift instead of writing',
+      '--drift': 'with --check: only whether the files on disk are what the layers compose',
+      '--expect-unfilled <slots>': 'slots, comma-separated, a move is known to leave unfilled',
+    },
+  },
+  where: { run: where, help: 'say which layer owns a path, and where a change to it goes', args: '<path>', options: PROJECT },
+  pipeline: {
+    run: pipeline,
+    help: "draw the project's agent chain: the line, its gates, what goes back, each stage's model and skills",
+    options: { ...PROJECT, '--for <shape>': 'the chain for one task shape, by number or words', '--since <date>': 'history from this day on, YYYY-MM-DD' },
+  },
+  pills: { run: pills, help: 'validate the corrections the pipeline wrote about itself', options: { ...PROJECT, '--tidy': 'move retired pills to .claude/pills/retired/' } },
+  learn: {
+    run: learn,
+    help: 'is the pipeline learning from its own runs? observe, capture, apply, graduate, verify; --deep reads why',
+    options: {
+      ...PROJECT,
+      '--check': 'as a detector: say only what is owed',
+      '--days <n>': 'how far back to look',
+      '--graduate <pill>': 'send a lesson to the harness as a request',
+      '--close <request>': 'close a request whose rule reached this project some other way',
+      '--deep': 'have a model read why the pipeline sent work back',
+      '--dry-run': 'with --deep: say what would be read, and read nothing',
+      '--model <id>': 'with --deep: the model that reads',
+      '--api': 'with --deep: bill the API instead of the Claude Code login',
+    },
+  },
+  requests: {
+    run: requests,
+    help: "the lessons projects have graduated to the harness — this repo's inbox",
+    options: {
+      '--check': 'as a detector: say only what is waiting',
+      '--answer <id>': 'record the rule a request became',
+      '--in <file>': 'with --answer: the layer file that now carries it',
+      '--decline <id>': 'record that a request does not become a rule',
+      '--why <reason>': 'with --decline: why',
+    },
+  },
+  wire: {
+    run: wire,
+    help: "merge the hooks and npm scripts a project's harness needs to run",
+    options: { ...PROJECT, '--to <version>': 'wire for this release instead of the pinned one', '--apply': 'write them, instead of printing them' },
+  },
+  gate: {
+    run: gate,
+    help: 'the loop gate: is it wired, and would it still hold a loop past its cap?',
+    options: { ...PROJECT, '--selftest': 'hold a synthetic loop past its cap, and compare the ledger with the history', '--hook': 'answer one hook event on stdin' },
+  },
+  upgrade: {
+    run: upgrade,
+    help: 'move a project to a newer core, reporting what it costs',
+    options: {
+      ...PROJECT,
+      '--to <version>': 'the core to move to',
+      '--apply': 'make the move, once it is safe, and verify it',
+      '--force': 'move although something would lose meaning',
+      '--abort': 'undo a move that was stopped before it finished',
+    },
+  },
+  eval: {
+    run: evalCommand,
+    help: "does a release's reviewer catch more planted defects than another's? runs on the login",
+    options: {
+      '--release <version>': 'a release to measure; give two to compare them',
+      '--repeat <n>': 'runs per release',
+      '--model <id>': 'the model the reviewer runs on',
+      '--judge': 'have a model grade each finding against the planted defects',
+      '--api': 'bill the API instead of the Claude Code login',
+      '--dry-run': 'say what would run, and run nothing',
+      '--keep': 'keep the scratch projects',
+      '--reports <dir>': 'keep each report here',
+      '--regrade <dir>': 'grade reports kept earlier instead of running',
+    },
+  },
+  export: {
+    run: exportCommand,
+    help: 'send the measured history to Langfuse by hand: each run once',
+    options: {
+      '--langfuse': 'the destination — the only one there is',
+      '--project <name>': 'one project, by its snapshot name',
+      '--dry-run': 'say what would be sent, and send nothing',
+      '--auto': 'as the hook runs it after a turn',
+    },
+  },
+  langfuse: {
+    run: langfuse,
+    help: 'keep the Langfuse keys, and turn on the projects that send their runs after every turn',
+    args: '<login|on|off|status>',
+    options: {
+      ...PROJECT,
+      '--host <url>': 'with login: the Langfuse host',
+      '--content': 'with on: send what each stage read, wrote and called',
+      '--prompts': 'with on: send only what passed between the agents',
+    },
+  },
+  release: { run: release, help: 'freeze the working core + surfaces as a pinnable version', args: '<version>', options: {} },
 };
 
-/** Commands named in the plan but not built yet, shown so the roadmap stays visible. */
-const PLANNED = {};
+/** Options every command takes: the banner reads it, and the commands that print say less. */
+const EVERYWHERE = { '--quiet': 'say nothing unless something is wrong, and print no banner' };
 
-/** Prints usage. */
+/** Prints the commands. */
 function help() {
-  console.log('  usage: nina <command> [options]');
+  console.log('  usage: nina <command> [options]        nina <command> --help for its options');
   console.log('         nina              on a terminal: the banner once, then type commands under it\n');
   for (const [name, c] of Object.entries(COMMANDS)) {
     console.log(`    ${name.padEnd(12)} ${c.help}`);
   }
-  if (Object.keys(PLANNED).length > 0) {
-    console.log('\n  planned:');
-    for (const [name, desc] of Object.entries(PLANNED)) {
-      console.log(`    ${name.padEnd(12)} ${desc}`);
+  console.log('');
+}
+
+/** Prints one command's usage and options. */
+function commandHelp(name) {
+  const c = COMMANDS[name];
+  const options = { ...c.options, ...EVERYWHERE };
+  console.log(`  usage: nina ${name}${c.args ? ` ${c.args}` : ''} [options]\n`);
+  console.log(`  ${c.help}\n`);
+  const width = Math.max(...Object.keys(options).map((k) => k.length));
+  for (const [option, what] of Object.entries(options)) console.log(`    ${option.padEnd(width)}  ${what}`);
+  console.log('');
+}
+
+/**
+ * What is wrong with a command's arguments, or null. An option the command does not take was ignored, so
+ * `compose --chek` composed over the tree it was meant to check; an option's value was taken on trust, so
+ * `--project --quiet` named a directory called `--quiet`, and a `--project` with nothing after it crashed.
+ *
+ * @param {string} name - The command.
+ * @param {string[]} argv - Its arguments.
+ * @returns {string|null}
+ */
+function refusal(name, argv) {
+  const c = COMMANDS[name];
+  // Each option, and the name of the value it takes, if any: `--since <date>` takes a date.
+  const takes = new Map(Object.keys({ ...c.options, ...EVERYWHERE }).map((k) => [k.split(' ')[0], k.split(' ')[1] ?? null]));
+  const positional = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (!a.startsWith('-')) {
+      positional.push(a);
+      continue;
+    }
+    if (!takes.has(a)) return `${name} takes no option ${a}`;
+    if (takes.get(a)) {
+      if (i + 1 >= argv.length || argv[i + 1].startsWith('--')) return `${a} needs a value`;
+      // Compared as text against the days of the store, anything else — `7d` — matched nothing, or everything.
+      if (takes.get(a) === '<date>' && !/^\d{4}-\d{2}-\d{2}$/.test(argv[i + 1])) return `${a} takes a day as YYYY-MM-DD, and was given ${argv[i + 1]}`;
+      i += 1;
     }
   }
-  console.log('\n  options:');
-  console.log('    --project <dir>    the project to act on (default: the working directory)');
-  console.log('    --surfaces <list>  init: declare surfaces instead of detecting them');
-  console.log('    --to <version>     upgrade: the core to move to');
-  console.log('    --check            compose: report drift instead of writing');
-  console.log('    --quiet            compose/pills: say nothing unless something is wrong');
-  console.log('    --apply            upgrade: write the new version, once it is safe');
-  console.log('    --since <date>     stats: YYYY-MM-DD');
-  console.log('    --snapshots <dir>  stats: read the history from somewhere else');
-  console.log('    --out <dir>        snapshot: where to write\n');
+  const allowed = c.args ? 1 : 0;
+  if (positional.length > allowed) return `${name} takes ${allowed === 0 ? 'no argument' : `one argument, ${c.args}`}, and was given ${positional.slice(allowed).join(' ')}`;
+  return null;
 }
 
 /** Entry point. */
@@ -100,18 +267,25 @@ async function main() {
   if (!argv.includes('--quiet') && !argv.includes('--hook') && !process.env.NINA_SHELL) printBanner(pkg.version);
 
   if (!name || name === 'help' || name === '--help' || name === '-h') {
-    help();
+    if (name === 'help' && COMMANDS[argv[0]]) commandHelp(argv[0]);
+    else help();
     return 0;
   }
   const command = COMMANDS[name];
   if (!command) {
-    if (PLANNED[name]) {
-      console.error(`  "${name}" is planned, not built yet — see \`nina help\`.\n`);
-      return 2;
-    }
     console.error(`  unknown command "${name}" — see \`nina help\`.\n`);
     return 2;
   }
+  // Before anything runs: `nina init --help` used to initialise the working directory.
+  if (argv.includes('--help') || argv.includes('-h')) {
+    commandHelp(name);
+    return 0;
+  }
+  const wrong = refusal(name, argv);
+  if (wrong) {
+    console.error(`  ${wrong} — \`nina ${name} --help\` lists what it takes. Nothing was run.\n`);
+    return 2;
+  }
   return command.run(argv, { root: ROOT });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xhulz/nina",
-  "version": "0.34.0",
+  "version": "0.36.0",
   "description": "Composes an agent harness into a project from a versioned core, its surfaces, and the project's own layer.",
   "license": "SEE LICENSE IN LICENSE",
   "author": "Marcos Schulz",

package/releases/0.35.0/core/GAPS.md

@@ -0,0 +1,125 @@
+# Known gaps
+
+The harness was extracted by slicing one live project, and a slice cannot be cleaner than the
+thing it was cut from. This file tracks what is still shaped by that origin.
+
+## Closed
+
+**Domain examples in the core.** The extraction had to leave money and PII nouns in otherwise
+invariant rules, because byte-exact recomposition was the proof that nothing was lost and
+rewriting a line broke it. Once projects started pinning a release, that constraint lifted:
+the core no longer names payouts, escrow, KYC, PIX, CPF or a single provider, and the
+`db` surface no longer assumes the write it protects is a money movement. `fixtures/acme`
+holds the line — it declares no `money` and no `pii` surface, and the test fails on any of
+those words reappearing.
+
+**The single-provider assumption.** `external-api` became `integrations`, plural, cut by how
+a premise is settled (`installed-library` / `live-api` / `platform-binding`) rather than by
+one project's payment provider.
+
+**The `money` surface was one project's money path.** It shipped that project's state machine
+(`DETECTADA → CASADA | DIVERGENTE | SEM_REGRA`) as a harness rule, named its models, its
+currency and its escrow vocabulary, and assumed one payment provider. It now states the
+invariants and nothing else: conservation, idempotency of an irreversible send, one
+serialization point per balance, integer minor units, and a state machine the **project**
+declares in its own `.claude/architecture.md`. `fixtures/ledger` holds that line — a money
+project whose minor unit is `cents`, whose engine is `packages/settlement`, and whose deny
+list fails on `escrow`, `centavos`, `Payout`, `DETECTADA` or any of the rest reappearing.
+
+**The `pii` surface was one country's regime.** It named CPF/CNPJ, PIX keys, KYC documents, LGPD,
+R2 and Postgres as if they were universal categories. It now says that sensitive categories are
+**declared by the project** in its own `.claude/architecture.md`, and states what is invariant:
+classified, encrypted at rest, never in a log, an error, a URL, an analytics event or an agent
+transcript, and document bytes only in the object store. `fixtures/ledger` declares `pii` with a
+`GDPR` regime and fails on any of the old words returning.
+
+**Incident dates that read as false history.** Five places told a rule through a date it happened
+on — a wiped database on 2026-09-16, a blocked deploy on 2026-09-21, specs split across two
+directories before 2026-09-04. In the project where it happened that is provenance; in a new one it
+is a claim about a past it does not have, and an agent will go looking for it. The rules keep their
+force without the date: *"the command completes with a reassuring 'empty migration' result and no
+error, having already destroyed everything in the database it was pointed at."*
+
+**A rule cross-reference that pointed at nothing.** The hard rules are one numbered list assembled
+from several layers, so a project that declares no `integrations` surface has no rule 12 — while the
+core still said "the premise rule (#12 below)". `compose-test` now checks every `Hard Rule #N`
+against the rules the project actually composed, and `fixtures/plain` declares no surface at all, so
+the most reduced case is exercised on every run.
+
+**Invariant rules that landed in the project layer.** Four rules were generically valuable but were
+stated through an incident or an inventory belonging to one project, so the project layer swallowed
+them and a new project got nothing. Each was restated in the layer that actually owns it:
+
+| Spec | What it got back |
+|---|---|
+| secops | the **AuthN / session** dimension is now core: credential issuance and consumption, cookie flags, fixation across a privilege change, origin allowlist, and any dev bypass that could reach production. The project slot survives for the auth library and the bypasses that project actually has. |
+| qa | the *"pre-existing failure"* traps moved to `surfaces/frontend` — they are facts about a jsdom + vitest harness, not about one feature. The project slot held only the provenance, so it was dropped. |
+| architect, implementer | both specs now state the Route → Service → Data rule themselves instead of only `patterns.md` stating it. The project slot survives for the package names. |
+| patterns | *"when correcting a document, delete what you are correcting"* is now a core section. |
+
+**The threat model was numbered, and the numbers came from slots.** Dimensions 1–8 lived in surface
+fragments and 9–10 in the core, so a project declaring every surface got 1–10 and everyone else got
+a list with holes: `acme` read `2, 3, 6, 8, 9, 10`, and a surfaceless project began at **9**. The
+list is bullets now, valid under any combination. The core's rate-limiting dimension also named one
+project's auth strategy (`magic-link request, dev routes`); it says `issues a credential` instead.
+
+**A surface's technology was named in files nothing gated.** The item above used to bundle two
+different things under "stack-specific", and only one of them was a choice. `Prisma` appeared in 7
+ungated core files and Cloudflare's runtime in 10 — technologies that already *have* surfaces, named
+in text every project composes. A frontend-only project read a `CLAUDE.md` that discussed Prisma, a
+`patterns.md` headed *API (Cloudflare Worker / Hono) conventions*, and a qa spec telling it to kill
+stray `workerd` processes that could not exist. The reviewer even pointed at `CLAUDE.md` §
+*Cloudflare plugin skills*, a section that lives in the edge-cf surface — a dangling cross-reference
+of exactly the kind already closed once here.
+
+42 sites were fixed by saying what the rule means rather than which product implements it: "if the
+database was touched" instead of "if Prisma touched", "deploy config" instead of "wrangler config",
+"the local emulator" instead of "Miniflare". None of it lost precision, because the instruction was
+never about the product. Where a genuine specific was worth keeping it moved into `surfaces/edge-cf`
+behind a slot.
+
+The deny lists never caught this, and could not: they guard one fixture's output against *domain*
+leaks, and a substring match makes a word like `Hono` unusable because it fires on `Honor`. The
+guard is now a layer audit in `compose:test` — for every core file, a surface's technology may be
+named only if the file is gated on that surface. It asks the question once, of everything, instead
+of only of what a fixture happens to compose.
+
+**Money in the core, and the heavy-gate list that carried it.** The extraction closed money's nouns
+(payout, escrow, the state machine) but not the word itself: ten places in the core listed "money, the
+database, auth, an integration" as the changes that are always gated in full, so a project with no
+money was told that under-gating a money movement was a protocol violation, and its devops that a
+production deploy "moves real money". The audit now holds `money` like a technology, and found 19 of
+them. The list is one definition of **critical paths** in `CLAUDE.md` — auth in the core, and the
+database, an integration boundary, money movement, personal data and contract code each added by its
+own surface — and the ten places say "a critical path". Two copies of money's own rules had also
+landed in `surfaces/db` (`BigInt` columns, a money-integrity check in the dba's report), contradicting
+the money surface's integer minor unit; they are gone, since the money surface already says it better.
+The same pass found Cloudflare's `Pages`, `Worker` and a capitalised `Wrangler` in the core and in
+two surfaces, and the leftovers no audit could name: a model called `DestinationAccount` and a spec
+set called `retention-spec1..8` in the router's examples, "all nine stages" where a profile composes
+seven to eleven, `userId` as the name of owner scoping, and "the harness's first three months" told
+as the history of whichever project was reading it.
+
+## Open
+
+**The core is domain-agnostic, not stack-agnostic — deliberately.** The stack's own commands are
+vocabulary now, with the release's defaults (`core/vocabulary.json`): the typecheck, lint and build
+commands a spec tells a stage to run, and the test command every stage but qa is told not to run. qa's
+own targeted `vitest run` stays literal. What remains is the stack's substance, not its commands:
+`vitest` and its memory discipline, `TSDoc`, `TypeScript`, `turbo`, and `pnpm` wherever a sentence
+describes the workspace rather than a command to run. That is the single track
+this harness is for, and most of it is load-bearing: the qa spec's memory discipline is a fact about
+vitest, not about testing. Unlike the surface leak above, this is not a defect — there is no
+`pnpm` surface a project could decline. It becomes a gap only when a project on another stack
+appears. The `.js`-extension and barrel-export rules are the sharpest case — they assume a
+TypeScript monorepo that emits `dist/`, and `fixtures/plain` needs `PKG_SCOPE` and `EMITTING_PKGS`
+in its vocabulary to compose at all. If a second stack ever arrives, those are a `ts-monorepo`
+surface, not core.
+
+**A composed project is not a finished project — by design.** With no project layer, `CLAUDE.md`
+still opens with blank lines and no title, mission or stack. That is not a defect to fix in the
+core: the missing text is the part only this project can say. `init` conducts the interview and
+writes it to `.nina/TODO.md`, and it deliberately writes **no stub fragments**, because a stub is
+a filled slot as far as every tool is concerned — a tree of TODOs would compose and check clean
+while saying nothing. So `compose` keeps naming the unfilled slots until a person fills them, and
+the blank opening is that list being honest rather than the core being incomplete.

package/releases/0.35.0/core/answered.json

@@ -0,0 +1,29 @@
+{
+  "2026-09-22-integration-tester__regenerate-the-premise-index-after-editing-an-integration-doc": {
+    "in": "core/tree/.claude/agents/integration-tester.md"
+  },
+  "2026-09-22-qa__exit-code-is-the-verdict": {
+    "in": "core/tree/.claude/agents/qa.md"
+  },
+  "2026-09-22-shared__test-must-name-the-mutation-that-fails-it": {
+    "in": "core/tree/.claude/agents/reviewer.md"
+  },
+  "2026-09-25-shared__docs-match-final-code": {
+    "in": "core/tree/.claude/agents/implementer.md"
+  },
+  "2026-09-25-shared__fail-closed-on-every-branch": {
+    "in": "core/tree/.claude/agents/implementer.md"
+  },
+  "2026-09-25-shared__test-must-fail-under-its-mutation": {
+    "in": "core/tree/.claude/agents/implementer.md"
+  },
+  "2026-09-25-shared__tsdoc-covers-members": {
+    "in": "core/tree/CLAUDE.md"
+  },
+  "2026-09-26-architect__revision-sweeps-contradicted-text": {
+    "in": "core/tree/.claude/agents/architect.md"
+  },
+  "2026-09-26-shared__validate-patterns-against-real-samples": {
+    "in": "core/tree/.claude/agents/implementer.md"
+  }
+}

package/releases/0.35.0/core/defaults/tree/.claude/agents/architect.md

@@ -0,0 +1 @@
+<!-- nina:slot project.7 -->

package/releases/0.35.0/core/defaults/tree/.claude/agents/dba.md

@@ -0,0 +1,3 @@
+<!-- nina:slot project.1 -->
+description: Use when a diff touches the schema, a migration or a query, in the same message as the reviewer. Architect and implementer may also ask it while designing one. Checks migration safety, query cost and indexes, cache and freshness rules, and data integrity, and returns APPROVED or REJECTED. The reviewer does not approve without its sign-off. Never writes application code.
+<!-- nina:slot project.4 -->

package/releases/0.35.0/core/defaults/tree/.claude/agents/devops.md

@@ -0,0 +1 @@
+<!-- nina:slot project.4 -->

package/releases/0.35.0/core/defaults/tree/.claude/agents/implementer.md

@@ -0,0 +1 @@
+<!-- nina:slot project.4 -->

package/releases/0.35.0/core/defaults/tree/.claude/agents/integration-tester.md

@@ -0,0 +1,3 @@
+<!-- nina:slot project.1 -->
+description: Use when a diff touches an integration boundary, meaning a service, library or platform binding whose behavior this project does not define. Verifies each premise against the real dependency rather than the mock, and returns APPROVED or REJECTED. A wrong premise goes back to the architect, code that does not honor a premise to the implementer.
+<!-- nina:slot project.5 -->

package/releases/0.35.0/core/defaults/tree/.claude/agents/qa.md

@@ -0,0 +1,2 @@
+<!-- nina:slot project.1 -->
+description: Use after the reviewer approves. Runs the tests of the packages the diff touched, once and never beside another test run, and returns PASS or FAIL with the exit code as the verdict. A failure loops back to the implementer, or to the architect when the test is right and the spec was wrong. Never writes code.

package/releases/0.35.0/core/defaults/tree/.claude/agents/reviewer.md

@@ -0,0 +1,3 @@
+<!-- nina:slot project.1 -->
+description: Use after the implementer produces a diff, in the same message as every gate the diff triggered. Audits the diff against the architect's spec, runs typecheck, lint and build (never the tests, which qa runs after approval), and names every gate the diff triggers, which run beside it; qa waits for all of them. Returns APPROVED or REJECTED. Read-only, never fixes.
+<!-- nina:slot project.3 -->

package/releases/0.35.0/core/defaults/tree/.claude/agents/secops.md

@@ -0,0 +1,3 @@
+<!-- nina:slot project.1 -->
+description: Use after the last step of a milestone passes qa, or when the owner asks for a security pass. Audits the assembled system as an attacker and as a privacy and compliance auditor, scoped to the milestone's diff, and returns SECURE or BLOCKED with each finding's severity. Not a substitute for the reviewer. Writes nothing to the repo.
+<!-- nina:slot project.7 -->

package/releases/0.35.0/core/defaults/tree/.claude/agents/solidity-auditor.md

@@ -0,0 +1,3 @@
+<!-- nina:slot project.1 -->
+description: Use on any diff that touches a contract, a deploy script, or a library version the contracts import, wherever the pipeline is. Audits the diff as an attacker before anything deploys, and returns APPROVED or REJECTED with the path and call sequence of each finding. The reviewer does not approve, and devops does not deploy, without its sign-off.
+<!-- nina:slot project.5 -->

package/releases/0.35.0/core/defaults/tree/.claude/agents/solidity-dev.md

@@ -0,0 +1,3 @@
+<!-- nina:slot project.1 -->
+description: Use when the architect's spec changes contract code. Writes the contract change and its adversarial tests, treating deployed code as immutable, so work that cannot be made safe as specified is BLOCKED rather than merged with a follow-up. Hands its diff to the solidity-auditor.
+<!-- nina:slot project.5 -->