Neuron inherits

What happens when someone changes a shared piece of the fleet

The picture is the index — each node jumps to where that step is decided. Follow one shared-package change from edit to per-site verdict.

Reference strip: Decisions · The one idea · Risks · Your calls · How we’ll know · Kill criterion · The machinery (Layer 2)

The story — what this earns us

Plato has proven, on itself, that it can tell an agent the truth about a codebase cheaply: what’s here, what’s wired to what, and a receipt that proves the answer is still current. W6 carries that machinery onto the business — the 14-site Neuron fleet Digital Empathy actually runs.

The payoff is one specific, expensive thing made cheap. Today, when someone changes a shared piece of the fleet — a component every site renders, a build step every site runs through — the honest answer to “which of our 14 client sites did that just change?” is nobody’s. So the whole fleet gets re-QA’d by hand, or worse, nobody checks and a site breaks silently. W6 replaces that with a computed answer that carries its own proof.

1. A shared-package edit lands. Someone changes a file in packages/* — a component, a build step. That’s “a change” (one commit’s worth of touched files).
2. Plato reads the Neuron repo the way it reads its own. A thin Neuron adapter teaches Plato the map of what’s there and a currency proof for each piece — reusing the proven code engine, because Neuron is TypeScript and the engine already reads that correctly.
   ↘ go deeper — what the adapter actually supplies

   NeuronAdapter(repoPath) composes the code adapter over packages/**+scripts/** and adds three Neuron pieces: groundTruth (delegates), currency via buildVerifiedSnapshot → hashCommittedBlob (never hash genome.json — authority-deprecated), and graph() with the site-wiring layer kept as a separate, fenced relation. Fleet universe = the 14 enabled sites in sites-manifest.json. Full: L2.1.
3. Which sites does the change reach? This is the whole spec. Our client sites are not code — they’re content. The shared code gets rendered over that content by a build step; sites don’t “import” the code. So Plato’s normal import-following map cannot by itself see “this component reaches this site.” That path runs through the build pipeline — so the adapter models the pipeline path explicitly, and fences honestly anywhere it can’t fully resolve it.
   ↘ go deeper — the blind spot, and the fence

   The site↔package edge is a build-pipeline relation (scripts/assembly-line.ts iterates siteIds and renders package code over site content), NOT an import edge. The pipeline-reach model over-approximates toward AFFECTED. Where it hits an .astro component Plato can’t parse (38 of them), or a site whose per-site config selects code dynamically — the answer is CANNOT-CERTIFY, never “untouched.” Full completeness audit (8 blind axes): L2.2.
4. Each site gets a verdict, and the verdict is a receipt. Per site: affected, untouched, or can’t-certify — each carrying a {basis, receipt, currency} proof in the exact shape W1’s gate already banks. We’re not inventing a proof format; we’re pointing the proven one at the fleet.
5. An untouched site is a site you can skip — with proof. Re-run the receipt to confirm nothing reached it. That’s the fleet-scale version of what W1 proved on Plato’s own gate: skip-with-proof, not skip-on-faith.

“Untouched, with proof” — and what it refuses to say

So the bar is deliberately lopsided: cheap to say “affected,” expensive (proof-gated) to say “untouched.” Over-approximation is safe (extra QA); under-approximation is the nightmare.

The decisions, in consequences

The hard problems, and what catches each

What I need from you

Three measured numbers — all recomputed from raw by the lead

For the builder — you never need to read past here

The full build contract lives in the canonical Markdown (docs/ai/SPEC-w6-internal.md, Layer 2): the ground-truth re-derived from the pinned clone at b68a4b1; the adapter interface reuse; the 8-axis completeness audit; the pipeline-reach model with its frontier-brief prerequisite; the per-site deposit shape; the G1–G6 gates with named deliberate-breaks; rollback and dependencies. Drill into the key pieces: