@deepseek-insight/dsi 0.6.13 → 0.6.14

package/.agents/skills/dsi-thin/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: "dsi-thin"
+description: "Meta skill: take the dsi-sloc over-threshold report as input and batch-refactor multiple files to the ADR-0019 thin-shell standard — one branch, one batch ADR, a rolling pool of TWO parallel sub-agents (next file starts the moment one finishes), dsi-spec + dsi-task per file, gates and registry amendments enforced. Reserved keyword: /dsi-thin."
+---
+
+# DSI Thin — Batch Refactor from the SLOC Report
+
+One trigger → batch thin-shell refactor. The `dsi-sloc` report is the input contract; the ADR-0019 standard is the authority; each file runs through dsi-spec → dsi-task as a sequential-commit wave unit, executed by a **rolling pool of two sub-agents**.
+
+## When to Use
+
+- User runs `/dsi-thin` or says "thin out the fat files" / "refactor the sloc report list"
+- A freshly-landed thin-shell standard (e.g. ADR-0019) needs applying to the remaining over-threshold files
+
+### Prerequisites ⛔
+
+- An **authority ADR** must exist that defines the thin-shell standard. If absent, STOP — draft it first via `dsi-adr`; this skill applies a standard, it does not invent one.
+- **Resolving the authority ADR — see `references/authority-adr.md`** for the full rules. Summary:
+  1. **Live first**: discover the newest thin-shell ADR in `dev/architectural-decission/` (grep for the standard's name, e.g. "Floor Registry" / "thin shell"). Pick the ADR that **DEFINES the standard**, not merely applies it: if a candidate's TL;DR says it applies/extends another ADR's method (e.g. ADR-0020 applies ADR-0019's move-whole method at component scale), climb to the one it cites. The defining ADR's path goes into the batch ADR citation; applying ADRs (e.g. ADR-0020) are cited as WORKED EXAMPLES, not authority.
+  2. **Snapshot fallback**: `references/ADR-0019-snapshot.md` is a dated copy of the standard at skill-freeze time — use it when the repo has no match (fresh clone, wrong repo, mirror-only context), and LABEL the run as snapshot-based.
+  3. **Drift check**: when both exist and the live ADR is newer than the snapshot, note "live ADR differs from snapshot" and follow the LIVE one; refresh the snapshot as part of batch close.
+- A fresh `dsi-sloc` report under `dev/sloc/` (run it if the latest is stale — files refactored since the report dropped below threshold and must not be re-picked).
+
+---
+
+## Step 0.5: Date Resolution ⛔ MANDATORY
+
+Resolve today's date via `date +%Y-%m-%d`. Store as `TODAY`. Never infer from context.
+
+## Step 1: Curate the Input List
+
+1. Read the latest `dev/sloc/{date} - SLOC Report - *.md` over-threshold table.
+2. **Re-verify each candidate live** — re-run the per-file SLOC count (`references/input-contract.md`); the report may be stale.
+3. Present the ranked list to the user with, per file: raw code, its touchpoints (which shared registries/servers it hits), and a suggested **lane assignment** (see Step 3).
+4. User picks, skips, and reorders. The confirmed list is the batch contract. Do NOT proceed without it.
+
+## Step 2: Branch + Batch ADR
+
+1. ⛔ **One branch per batch**: `refactor/thin-batch-{TODAY}`, created and activated BEFORE any artifact and BEFORE the first commit — no wave commit, spec commit, or ADR commit may land on any other branch. If the branch already exists (earlier run today), RESUME it: inspect its log and worktrees first, never create a same-day duplicate or commit to main while it exists.
+2. **One batch ADR** via `dsi-adr` — but the depth rule applies to what is actually DECIDED here:
+   - Cite the authority ADR (ADR-0019) as the standard being applied; do NOT re-argue it.
+   - Decide only batch-specific questions: the confirmed file list, per-file exclusions and why, which frozen registries amend, the two-lane concurrency contract, and accepted give-ups.
+   - Numbered decisions (D1…Dn), each naming its rejected alternative; diagram showing the two-lane pool and the merge gate.
+
+## Step 3: The Two-Lane Rolling Pool ⛔ THE CORE MECHANIC
+
+Run the batch through **two lanes, each a sub-agent, always two in flight**. The moment one lane's file fully completes (waves committed, gates green), immediately dispatch the next queued file into that lane. Never zero in-flight, never three.
+
+⛔ **All DEVELOPMENT is sub-agent work** (operator rule, batch R3 2026-10-10): every wave, extraction, and code commit is executed by a lane sub-agent — the orchestrator NEVER writes `src/` code. The orchestrator's job is verification and gates only: doc-gate checks, independent disk re-runs of reported gate outputs (commit hash, suite count, SLOC — a worker claim is never accepted as evidence), one-lane-at-a-time merge-backs, and adjudications. Serial milestones keep a lane sub-agent too (pool contracts to one in-flight, not zero-with-orchestrator-coding). If a sub-agent stalls (no commit across two orchestrator polls), re-dispatch a FRESH sub-agent with incremental commit phases (commit after each doc/wave so progress is observable) before ever considering takeover.
+
+### Concurrency safety — see `references/two-lane-contract.md` for the full contract
+
+- **Lane isolation by git worktree**: each lane gets its own worktree (`.worktrees/lane-a`, `.worktrees/lane-b`) branched from the batch branch, so two agents never share one working tree, one dev-server port, or one suite baseline. `.worktrees/` MUST be in `.gitignore` before the first worktree is created (untracked lane dirs would pollute every main-tree `git status`/`add`).
+- **Touchpoint disjointness**: when building the queue, pair files so the two in-flight files never mutate the same shared module (e.g. never floor-registry AND panel-registry together). If every pairing collides, fall back to strictly sequential for the colliding files — say so in the batch ADR.
+- **Merge gate**: lane worktree commits merge back to the batch branch ONE LANE AT A TIME; the other lane keeps working undisturbed. After each merge, the merging lane re-bases its next file on the updated batch branch.
+- **Suite baseline per lane**: each lane records the suite count from ITS starting commit; its gates compare against that. The merge gate re-runs the full suite on the batch branch after every merge.
+
+### Per-file unit (what each lane sub-agent does — the Composer session's proven chain)
+
+0. **Read the worked example first**: ADR-0020 + its spec folder + the wave completion notes (`dev/specs/2026-10/2026-10-10 - Composer Thin Shell/`) are the reference execution — and **check `references/proven-gates.md`** before writing any controller: paid-for lessons (`$effect.root` + `destroy()`, census assertion, live-getter props, focus fidelity) that fail quietly when skipped.
+1. `dsi-spec` for the file — visible checklist in progress; PRD + Tasks + Karpathy context + Tasks.json under `dev/specs/{YYYY-MM}/{TODAY} - {File} Thin Shell/`
+2. `dsi-task` for that file's waves — visible checklist in progress; behavior-neutral gates per wave: suites pass UNCHANGED (count + names), `svelte-autofixer` zero issues, `scripts/dep-graph.mjs --check` frozen crossings, **census assertion** (grep the shell for the moved declarations: zero hits)
+3. Commit per wave: `refactor(ADR-00XX Wn): {what moved whole} — suites pass unchanged (N), +M unit tests`
+4. If the file's floor registry must amend (the 500-line registry): stage the amendment in the lane, applied at merge time
+
+### Stop-the-line rule
+
+A file whose suites cannot stay green unchanged, or that reveals the standard doesn't fit it, falls OUT of the batch: record it in the batch ADR as a named rejected/excluded item with the reason, and continue the pool with the next file. One bad file never blocks the batch.
+
+## Step 4: Goal + Todo Discipline (every batch)
+
+- ONE batch goal at dispatch: objective = "Thin-shell refactor batch: {file list} per {authority ADR} on {branch}".
+- Todos per file-wave: `file → W1`, `file → W2`, ..., plus one per merge-back and one for the final registry sweep.
+- Update the todo the moment each unit completes; ALWAYS show the full todo list at every phase transition and after every lane completion. Never let the todo go stale between lane events.
+- ⛔ **Visible-checklist pattern** (see `docs/visible-checklist-pattern.md` — declare → execute → announce, same-turn): the pipeline checklist is output at the START, then **checked in progress** — at every phase transition, doc gate, and lane merge, re-output it with `[✅]/[🔄]/[❌]` and announce EACH item's result immediately after verifying it, with the disk evidence inline (commit hash, suite count, SLOC number, dep-graph line). Two layers per the pattern: the visible checklist (social) + objective disk verification (`git log`, vitest counts, verify-sloc2, dep-graph) — a worker's report is NEVER the evidence; the orchestrator re-runs the check and announces the result. A claim without a matching disk check stays `[🔄]`.
+
+## Step 5: Close the Batch
+
+1. All files merged, pool drained.
+2. Registry sweep: every refactored file that dropped below threshold is removed from the floor registry; `dep-graph --check` green.
+3. Re-run `dsi-sloc` — the "after" report. The delta (before → after raw SLOC per file) is appended to the batch ADR as its evidence section.
+4. Batch ADR → Implemented ONLY when every picked file is done or explicitly excluded with reason.
+5. Show the final visible checklist: ALL `[✅]` / `[❌]` with reasons. Commit and push on user command (or per batch contract).
+
+---
+
+## Pipeline Checklist — MANDATORY
+
+This is the ONLY checklist output to the user. Declared at the start. Verified at the end.
+
+```
+📋 dsi-thin: batch on {branch} — {n} files, two-lane pool
+
+   [ ]  0.5 ⛔ Resolve today's date via `date +%Y-%m-%d` (store as TODAY)
+
+   Step 1: Curate Input
+   [ ]  1.1  Latest dsi-sloc report read; candidates re-verified live
+   [ ]  1.2  Touchpoints identified per file; lane pairing plan built
+   [ ]  1.3  User confirmed the batch list
+
+   Step 2: Branch + Batch ADR
+   [ ]  2.1  Branch refactor/thin-batch-{TODAY} created AND activated
+   [ ]  2.2  Batch ADR drafted via dsi-adr (cites authority ADR, decides batch specifics only)
+   [ ]  2.3  Two-lane worktrees created from the batch branch
+
+   Step 3: Rolling Pool (per file, until queue empty)
+   [ ]  3.1  dsi-spec per file (visible checklist shown)
+   [ ]  3.2  dsi-task per file (visible checklist shown, behavior-neutral gates per wave)
+   [ ]  3.3  Lane merge-back one at a time, full suite green on batch branch after each
+   [ ]  3.4  Next file dispatched into the freed lane immediately (never 0 in-flight)
+   [ ]  3.5  Todos updated and SHOWN after every lane event
+
+   Step 4: Close
+   [ ]  4.1  Registry amendments applied; dep-graph --check green
+   [ ]  4.2  dsi-sloc re-run; before→after delta recorded in batch ADR
+   [ ]  4.3  Batch ADR marked Implemented (or exclusions recorded with reasons)
+   [ ]  4.4  Final checklist shown, all ✅/❌
+
+   ⛔ Behavioral Commitments:
+   [ ]  I will NOT make any commit before the batch branch exists and is activated
+   [ ]  I will NOT run three sub-agents or let the pool drop to zero while queue remains
+   [ ]  I will NOT let two in-flight files share a working tree or a shared-module mutation
+   [ ]  I will NOT merge both lanes simultaneously — one lane at a time, suite-gated
+   [ ]  I will NOT re-argue the authority ADR in the batch ADR
+   [ ]  I will NOT let one failing file block the batch — it gets excluded with a reason
+   [ ]  I will NOT go silent between lane events — todo + checklist always visible
+   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+### Check-Off Rules
+
+- Re-output the checklist at each phase transition and after every lane merge with `[✅]` / `[🔄]` / `[ ]`
+- At completion, output the final checklist: ALL `[✅]`, any `[❌]` for failures
+- Do NOT deliver without showing the final checklist
+
+---
+
+## Attention-Degradation Protection
+
+This skill stays SHORT. The input-contract mechanics live in `references/input-contract.md`; the full two-lane concurrency contract (worktrees, pairing, merge gate, failure recovery) lives in `references/two-lane-contract.md`; paid-for extraction lessons live in `references/proven-gates.md`. This file only orchestrates.

package/.agents/skills/dsi-thin/references/ADR-0019-snapshot.md

@@ -0,0 +1,363 @@
+# ADR-0019 — The Floor Registry: The Machine Moves Whole, the Shell Stays Thin
+
+| | |
+|---|---|
+| **ADR ID** | 0019 |
+| **Title** | The `+page.svelte` floor state machine (65 functions over one `panels` array) moves wholesale into an additive floor-registry service — one mutator delegation at a time behind a green e2e net — so the route collapses to wiring + markup and ADR-0018 D4's missed floor is met as a consequence, not by line-counting |
+| **Status** | Implemented (2026-10-09 — see the amendment below; D5's line number carries an honest miss, recorded) |
+| **Date** | 2026-10-09 |
+| **Project** | deepseek-insight |
+| **Companions** | [KB — Why the 500-Line Floor Missed](../../kb/component-graph/2026-10-09%20-%20Why%20the%20500-Line%20Floor%20Missed%20—%20Post-Implementation%20Measurement.md) (the facts section this ADR cites), [ADR-0018 — The Component Standard](2026-10-09%20-%20ADR-0018%20—%20The%20Component%20Standard%20—%20Thin%20Shells%2C%20Service%20State%2C%20Nine%20Crossings.md) (D2 state homes; D4 the failed promise this ADR re-plans), [ADR-0006 — The Panel Floor](../2026-08/2026-08-24%20—%20The%20Panel%20Floor%20—%20Many%20Conversations%2C%20One%20Page.md) (the leaf→root registry this generalizes to service scale) |
+| **Supersedes** | Nothing — it executes what ADR-0018's D4 amendment deferred; it re-opens ADR-0006's ownership question at service scale, with ADR-0006's control grammar preserved |
+| **Question this answers** | *The KB left open: schedule the floor-registry rewrite as its own ADR now, or leave it as documented debt until the e2e net is green?* |
+
+## TL;DR — for the reader in a hurry
+
+ADR-0018 promised the three god-files under 500 lines. Waves 1–3 drained the
+fuel (prefs, feeds, timers — now tested services) and the files barely moved
+(2,109 → 2,020), because what remains in `+page.svelte` is not a pile of
+independent logic but **one connected machine**: 65 functions that all read and
+write the same reactive `panels` array. This ADR decides that machine moves —
+**whole, additively, behind a green e2e net** — into a floor-registry service.
+This session's function census (§2) shows why the move is safe to stage: the
+machine's 65 functions already egress through exactly **two contracts** —
+markup prop-handlers and the two service registries — so delegating the
+mutators one-by-one to the service touches no third surface. The 500-line
+floor falls out at the end. Debt is not cheaper with age: every feature adds
+a 66th function to the machine.
+
+---
+
+## 1. The problem, in plain words
+
+An operator closes a skill-shelf panel and a half-dozen things happen: the
+shelf's tab memory dies, the selection falls to a neighbor, the loupe closes
+if it was louvered on that panel, the desk re-persists to localStorage. All
+of that logic lives in one 2,020-line file, in functions that share one
+mutable array. Nobody can unit-test "closing a shelf keeps the desk honest"
+without rendering the whole page — so nobody does, and the e2e suite (24
+specs failing before any of this work started) is the only net, and it has
+holes.
+
+The newcomer's question, and the operator's, is the same: *where does the
+floor live?* The written answer today is "in the route" — which is a
+location, not a design. ADR-0018's D2 said state like this belongs in a
+service. D4 promised the file would shrink and it did not, because the
+extractable-without-moving-the-machine part was already gone. What is left
+moves only as a machine. This ADR moves the machine.
+
+## 2. What the codebase gives us (the facts)
+
+Numbered; each inspected this session (2026-10-09, branch
+`component-standard-adr`, commit `dc51a8e`):
+
+1. **The census.** `src/routes/+page.svelte` declares **65 functions**
+   (script spans L44–L1,629; template L1,630–L2,020). Classified by where
+   their name appears:
+   - **29 markup-bound handlers** — no script caller, referenced only in the
+     template as prop/handler values into child components (e.g.
+     `setShelfTab` L226 → template L1733; `toggleExplorerPath` L336 →
+     L1771; `removePanel` L709 → seven template sites).
+   - **~27 script-internal machinery** — never appear in the template
+     (`make*Panel` factories, `insertPanel` L932, `insertionSlot` L955,
+     `pinnedSlotIndex` L967, the `doAdd`/`doReplace*` family,
+     `seedSessionId` L137, `fetchCold` L1462).
+   - **6 both-script-and-template functions** shared by both surfaces
+     (`openWorkspaceExplorer` L313, `openWorkspaceFile` L476,
+     `panelTitleFor` L828, `panelWorkspaceFor` L842, `selectPanel` L705,
+     `clearLoupeIfGone` L699).
+   - **2 dead functions** — `makeWorkspaceFilePanel` (L444) and
+     `parentOfSession` (L1197) have **zero references** in `src/` or
+     `tests/` (their caller moved to the `auto-open-slots` service in W3).
+2. **Two egress contracts, no third.** The machine's functions reach the rest
+   of the app only via: (a) template props/handlers into child components
+   (census group 1), and (b) the two registries wired in `onMount`
+   (L1592–L1611): `registerAddPanel(doAdd)`, `registerReplaceSelected`,
+   `registerReplacePanel`, `registerReplacePanelBySession`,
+   `registerSelectPanel(selectPanel)`,
+   `registerStartPanelResize(doStartPanelResize)`,
+   `registerMovePanel(doMovePanel)` — plus `setWorkspaceState({ select:
+   selectPanel, remove: removePanel, ... })` (R6 context). No function is
+   exported; no module outside the route can touch `panels`.
+3. **The service pattern is proven at small scale.** `page-feeds.svelte.ts`
+   already runs a module-scope reactive store with install/teardown
+   lifecycle, consumed reactively from the route (L818, L885); the KB calls
+   it "a miniature of" the registry move.
+4. **The wall and the floor are measured.** Template + styles = L1,630–L2,020
+   ≈ **391 lines** of identity-bound markup D2 forbids moving; wiring
+   (imports, two thin effects, registry mount) ≈ **100 lines**. 391 + 100 ≈
+   **490** — the <500 floor is physically reachable **only after** the
+   ~1,100-line script core moves.
+5. **The net is red.** 24 e2e specs fail pre-rewrite (KB §3; W2/W3
+   completion notes adjudicated them as pre-existing failures). Current
+   god-file sizes measured today: 2,020 / 1,269 / 1,126.
+6. **ADR-0018's gates are live.** The boundary rule (D1) and autofixer gate
+   (D3) run in the commit path — any extraction this ADR lands is already
+   lint-guarded, so this ADR adds no new gate.
+
+## 3. The principle, unfolded
+
+**Ownership is where the writes live, not where the markup renders.** The
+floor's state (`panels`, selection, loupe, resize gesture) has one legitimate
+writer — the floor itself — and every consumer is either a leaf rendering a
+piece of it or a leaf requesting a change. When the writer lives in a route
+component, every consumer must be able to *see the route*; when the writer
+lives in a service, leaves reach it through the two channels they already use
+(props down, registry up), and the route becomes one consumer among many —
+the thinnest one, holding only markup and identity-bound constructs (D2).
+
+And: **a machine moves whole, but it can be *carried* one bolt at a time** —
+provided that during the carry, exactly one component holds the write
+authority at any moment, and each bolt-transfer is behavior-neutral and
+verified.
+
+## 4. Decisions
+
+### D1 — Schedule the rewrite NOW, as this ADR's own plan — not as parked debt
+
+The KB's open question is answered: the floor-registry rewrite starts with
+this ADR's task run, before new features land on the floor.
+
+**REJECTED — leave as documented debt until "the net is green":** the net and
+the machine are coupled the other way round than the debt framing implies —
+several of the 24 failing specs are floor-behavior specs that a rewrite would
+exercise hardest; waiting means the next N features each add functions to the
+machine (making the eventual move bigger) while the net stays red for the
+same rewrite-sized reason. Debt here does not amortize; it compounds.
+
+**REJECTED — close D4 as "met in spirit" and move on:** ADR-0018's own
+amendment (the admission, commit `dc51a8e`) records that the plan misjudged.
+Re-deriving the target from measurement and executing it is the only
+correction that makes the record true; abandoning the number while keeping
+the standard's other gates would teach every future ADR that numbers in
+decisions are decorative.
+
+### D2 — Additive strangle: the service owns `panels` + mutators; the route delegates one function at a time; authority never splits
+
+A new `services/panels/floor-registry.svelte.ts` begins as a mirror: it owns
+`panels`, `selectedPanelId`, and the mutator family, but the route's
+functions delegate one-by-one (`function insertPanel(...) { return
+floorRegistry.insertPanel(...) }`). Each delegation is a separate,
+behavior-neutral commit, unit-testable as a plain module. The migration ends
+when the last mutator moves and the route's originals delete.
+
+**REJECTED — big-bang rewrite in one commit:** 65 functions and every
+template closure at once against any net converts a partial failure into a
+full-file bisect; the exact failure mode ADR-0018's amendment confessed to
+(promising wholesale outcomes without staged verification).
+
+**REJECTED — keep state in the route, export only the mutators:** that is the
+split-authority trap D2 of ADR-0018 warns against, at full scale — two homes
+for writes to `panels`, forever. The state and its writers move together;
+that is the entire point of "the machine moves whole."
+
+### D3 — The two egress contracts are preserved, not redesigned
+
+The census (fact 2) is the design: template prop-handlers stay
+prop-handlers — they become one-line closures delegating to the service —
+and the seven registry registrations (plus `setWorkspaceState`) re-point at
+service mutators directly. No leaf component changes its interface.
+
+**REJECTED — convert the 29 markup handlers into registry actions ("props
+are crossings too"):** it would churn ~24 template sites and every child
+component's contract for zero behavioral gain, and it deepens coupling: the
+registry's leaf→root channel exists for leaves that *cannot* see the owner,
+not for direct children the template already binds. The props are how a
+parent talks to its children; that is the tree working, not a violation.
+
+**REJECTED — rewrite the template's snippet ladders during the move:** the
+markup wall (fact 4) is identity-bound and out of scope (D2, ADR-0018);
+touching it during the migration makes every visual diff ambiguous — was it
+the move or the template?
+
+### D4 — The e2e net is greened as wave zero, and the net's own verdicts are recorded
+
+The 24 pre-existing failures are adjudicated first (fix, or
+stash-baseline-prove-and-record with owner sign-off), so every later
+delegation commit has a binary read: green means behavior preserved.
+
+**REJECTED — run net repair in parallel with mutator migration:** the point
+of the net is attribution; a red spec landing mid-migration is exactly the
+"maybe the rewrite did it" ambiguity the KB priced (§3). Waves serialize.
+
+### D5 — The dead weight drops first, and the target is re-derived from measurement
+
+`makeWorkspaceFilePanel` (L444) and `parentOfSession` (L1197) — zero
+references anywhere (fact 1) — delete before any move, so the census the
+migration stages against is honest. The completion target is the measured
+floor of fact 4: route = wiring (~100) + markup wall (~391) ≈ **490 lines**,
+met as a consequence of the last delegation, verified by `wc -l`, with
+every extracted mutator unit-tested as a plain module (ADR-0018 D4's
+original testability intent).
+
+**REJECTED — a new four-digit promise ("under 400!"):** the failure being
+corrected was a target set from optimism; the replacement is the measured
+sum of the parts that physically cannot move. The number is derived, not
+aspirated.
+
+## 5. Lifecycle — one mutator's migration
+
+```mermaid
+sequenceDiagram
+    participant R as +page.svelte (route shell)
+    participant S as floor-registry service
+    participant T as Unit tests
+    participant E as e2e net (green)
+
+    Note over S: wave 0 — net greened, dead functions deleted
+    R->>S: introduce service owning panels + mutators (mirror, unused)
+    loop per mutator (65 route originals down to 0)
+        R->>S: delegate — route fn becomes a one-line call
+        T->>S: unit-test the service mutator as a plain module
+        E->>R: full suite stays green (behavior-neutral proof)
+        R->>R: last consumer gone — delete the route original
+    end
+    Note over R: script collapses to wiring (~100) + markup (~391)
+    R->>R: wc -l near 490 — the floor, met as a consequence
+```
+
+## 6. State homes and control matrix
+
+```mermaid
+flowchart TD
+    subgraph Before["Today - authority in the route"]
+        P1["panels + selection + loupe<br/>STATE inside +page.svelte"] --> F1["65 functions<br/>write locally"]
+        F1 -->|template props| L1["Leaf components"]
+        F1 -->|registry onMount| G1["panel-registry + workspace-context"]
+    end
+    subgraph After["Target - authority in the service"]
+        S1["floor-registry service<br/>owns panels + mutators"] -->|registered mutators| G2["panel-registry + workspace-context"]
+        R2["+page.svelte shell<br/>wiring + markup only"] -->|one-line delegations| S1
+        L2["Leaf components<br/>same props as today"] --> R2
+    end
+    Before -->|per-mutator delegation waves| After
+```
+
+| Fact | Home today | Home after | Authority during migration |
+|---|---|---|---|
+| `panels` array | route `$state` | service `$state` | **single** — flips once per mutator transfer, never both |
+| Selection / loupe / resize gesture | route `$state` | service | single, as above |
+| Mutator implementations (65) | route functions | service functions | original deleted at its wave's end |
+| Leaf prop contracts | template bindings | **unchanged** | leaves never know the move happened |
+| Registry registrations | route `onMount` | route `onMount` re-pointed | one commit per registration |
+| Persistence (panel-prefs effect) | route effect | route effect reading service | flips with `panels` |
+
+## 7. Consequences
+
+**Gains**
+- The floor becomes unit-testable: "closing a shelf keeps the desk honest"
+  is a plain-module test, not a rendered page.
+- ADR-0018's D4 record becomes true on measurement, not amended again.
+- The route stops being the single point every floor feature edits; features
+  touch the service, and the shell stays thin.
+- The dead code (fact 1) leaves before it confuses the migration.
+
+**Accepted give-ups**
+- During the waves, `+page.svelte` is churn-heavy — merge contention on the
+  file every feature touches (ADR-0018 priced this; the waves concentrate it).
+- One more service with a mount lifecycle (`page-feeds`' pattern repeated).
+- The wave discipline serializes net repair before migration — slower start
+  than a parallel dash, chosen deliberately (D4).
+
+**What does NOT change**
+- Any leaf component's props, events, or markup — the census's two egress
+  contracts are preserved verbatim (D3).
+- ADR-0006's control grammar (leaf→root requests, state down through
+  context); the registry channel just gains a service on the root side.
+- The ADR-0018 gates (boundary rule, autofixer) — they keep guarding every
+  touched file during the waves.
+- The template's snippet ladders and styles — untouched (D3).
+
+## 8. File map (implementation footprint)
+
+| Artifact | Path | Pinned by |
+|---|---|---|
+| Dead-function deletion | `src/routes/+page.svelte` L444, L1197 | unit suite green; grep proves zero references |
+| The floor registry service | `src/lib/services/panels/floor-registry.svelte.ts` (name at PR) | new unit tests beside it, one per mutator family (add/replace/select/move/remove/explorer/shelf intent) |
+| e2e net repair | `tests/`, `playwright.config.ts` as needed | the 24 adjudicated specs — verdicts recorded per spec |
+| Route shell collapse | `src/routes/+page.svelte` (2,020 → ≈490) | existing floor e2e (greened in wave 0); `wc -l` check in the final wave's task |
+| Registry re-pointing | route `onMount` L1592–L1611 | A2A/panel registry live tests (`playwright.a2a.config.ts`) |
+| Facts source | KB — Why the 500-Line Floor Missed (2026-10-09) | — |
+
+## Glossary (for the layman)
+
+- **Floor** — the workspace page's row of panels; the thing that owns which
+  conversations are open, where they sit, and which is selected.
+- **The machine** — shorthand for the 65 functions in `+page.svelte` that all
+  read and write the same `panels` array; you cannot move half of it without
+  splitting who is allowed to change the array.
+- **Strangle / additive migration** — putting the new owner in place beside
+  the old one and moving responsibility one function at a time, so every
+  step can be verified and reversed.
+- **Split authority** — two places both allowed to write the same state; the
+  worst outcome of a half-finished extraction because it silently diverges.
+- **Egress contract** — the way the outside world reaches a function: here,
+  template props (parent→child) and the two registries (child→root).
+- **Net** — the automated test suite that would catch a behavior change; a
+  "red net" is one with pre-existing failures that drown any new signal.
+
+## Post-implementation amendments
+
+### 2026-10-09 — Implemented: the machine moved whole; the line floor needs one more honest correction
+
+**What landed** (branch `component-standard-adr`, commit `ec6c692` + the W3 commit):
+
+- **D1/D2/D3 as decided.** `src/lib/services/panels/floor-registry.svelte.ts` (1,081 lines) owns the WHOLE
+  machine — panels, selection, loupe, file-intent mailbox, gutter-drag + afterglow, every mutator family —
+  as module-scope `$state` + plain exported functions over ONE dep seam (`configureFloorRegistry`).
+  The route never writes floor state (grep-proven at every wave boundary); the registry and the template
+  bind service mutators directly. A second service, `floor-reads.svelte.ts` (181 lines), owns the READ side
+  (spine joins, lineage/row derivations, per-session lookups) behind plain getters the route's `$derived`
+  wrappers cache — module-scope `$derived` cannot be exported (Svelte compile gate `derived_invalid_export`,
+  probed this session), which is a fact the plan did not anticipate.
+- **D4 as decided, with the operator's attribution amendment honored:** wave 0 greened/adjudicated the net;
+  every delegation wave ran against the recorded failure set (net-verdicts.md) under the failure-set
+  attribution rule. Final sweep (W3, 2026-10-09): 175 passed / 35 failed — every failure attributed to the
+  recorded baseline, proven pre-existing, or a load flake that passes in isolation (prompt-tags 02: the one
+  new name this sweep, green in isolation at 1.9s). ZERO migration-attributable failures.
+- **Tests:** 60-test mutator suite (`tests/unit/floor-registry.test.ts`); unit suite 4,881 green; leaf
+  components byte-identical.
+
+**D5 — the line number, measured and MISSED, with the miss owned:** the target was wiring (~100) +
+markup (~391) ≈ **490**. Measured: `+page.svelte` = **603 lines** (script ≈212, markup 391) — down from
+1,993 (−70%), but 113 over the estimate. The ≈100-wiring estimate repeated the original D4 mistake at
+smaller scale: it did not measure the irreducible shell — ~57 lines of leaf/service imports (16 Svelte
+components), the dep-seam configure + seed/restore init, the persistence effect, the seed strip, the mount
+registrations, and 15 one-line derived wrappers the route must keep because template names bind them. The
+compile gate above also forbids the route from importing module deriveds directly. Cutting the remaining
+113 would require template restructuring (D3 forbids) or logic-free line tricks (the exact vanity this ADR
+was written to end). The measured, honest floor for this route under D1/D3 constraints is ~540–600;
+**490 is recorded as un-meetable without breaking a harder decision**, and D5's method — re-derive from
+measurement, never from optimism — is applied to its own number.
+
+**Rejected — flip D5 to "met" because 603 ≈ "roughly 500":** the D4 admission exists precisely because a
+four-digit promise was answered with rounding. 603 is reported as 603, the estimate as missed, and the
+constraint analysis as the closure evidence.
+
+
+(none yet — dated entries only, never edit the body in place)
+
+## Self-audit (dsi-adr §5)
+
+1. Alternatives enumerated per decision, not fused — **yes** (each D carries
+   its own REJECTED blocks).
+2. Every decision names what it rejected and why the rejection lost — **yes**
+   (D1×2, D2×2, D3×2, D4×1, D5×1).
+3. TL;DR + glossary stand alone — **yes** (the machine/net/egress story is
+   told without requiring the codebase).
+4. Every §2 fact inspected this session — **yes** (the 65-function census,
+   the registry block L1592–L1611, template span L1,630–L2,020, dead-function
+   grep across `src/` and `tests/`, `wc -l` 2020/1269/1126, commit
+   `dc51a8e`).
+5. Diagrams where state changes hands — **yes**: §5 sequence (a mutator's
+   migration), §6 flowchart + state-homes table; mermaid blocks contain no
+   `;` in message text.
+6. Shape copied from a recent ADR instead of matched to the trade — **no**;
+   depth follows the KB's measured alternative space, exemplars consulted
+   per the skill.
+7. Consequences include what does NOT change — **yes**.
+8. File map names the pinning tests — **yes**.
+
+## Post-implementation amendments
+
+**2026-10-09 — D4's green-net clause amended before W1 (operator-approved).** The 26 remaining e2e failures are conversation/attachments/prompt-streaming fixture specs: pre-existing on the stash baseline, unrelated to the floor surface, and each a dedicated repair effort. Attribution switches from "zero failures" to the **failure-set rule**: every delegation commit's failure set must equal the recorded baseline set in the W0 ledger; any new failure is the migration's. D4's intent (attribution) holds; strict green moves to post-migration.

package/.agents/skills/dsi-thin/references/authority-adr.md

@@ -0,0 +1,28 @@
+# Authority ADR — resolution rules
+
+The thin-shell standard lives in a repo ADR (currently ADR-0019, "The Floor Registry — The Machine Moves Whole, the Shell Stays Thin"). This skill must never INVENT the standard — only apply it. But a hard-coded path breaks: ADRs get amended, superseded, renumbered, and this skill also runs from the `~/.agents/skills` mirror where no repo may be present. So the authority is dual-sourced:
+
+## Source 1 — the live ADR (preferred)
+
+```bash
+# discover candidates
+grep -rln "thin shell\|Floor Registry\|Thin Shells" dev/architectural-decission/ | sort
+```
+
+Pick the newest ADR that defines the standard and is not marked superseded: highest ADR number, latest date, and its status line says Draft/Accepted/Implemented (NOT superseded/rejected). Its path is what the batch ADR must cite, and the per-wave commits reference its number (`refactor(ADR-00XX Wn): ...`).
+
+## Source 2 — the frozen snapshot (fallback)
+
+`references/ADR-0019-snapshot.md` is a verbatim copy of ADR-0019 at skill-freeze time (2026-10-10, commit 392054d^). Use it only when no live ADR is discoverable (fresh clone of the mirror, skill used outside the DSI repo). When used, the batch ADR must say: "authority = ADR-0019 via skill snapshot; live repo copy not found".
+
+## Drift check (both exist)
+
+If the live ADR and the snapshot differ (diff the two, or compare the live file's git log against the freeze date):
+
+- Follow the LIVE one — it is the standard of record.
+- Say so once: "live ADR differs from the skill snapshot; following live".
+- At batch close, refresh the snapshot: copy the live ADR over `references/ADR-0019-snapshot.md`, update this file's freeze stamp, and include the refresh in the batch commit.
+
+## Supersession
+
+If discovery finds a NEWER standard ADR that supersedes the thin-shell one (e.g. ADR-0030 replaces the floor model), STOP and ask the user: this skill's mechanics (per-file waves, registry amendments, unchanged-suite gates) assume the ADR-0019 shape. Adapting to a new standard is a skill revision, not a runtime decision.

package/.agents/skills/dsi-thin/references/input-contract.md

@@ -0,0 +1,42 @@
+# Input Contract — from dsi-sloc report to batch queue
+
+The `dsi-sloc` report is the input, but it is a SNAPSHOT. This reference defines how to turn it into a verified, lane-paired queue.
+
+## 1. Re-verify live
+
+The report was measured at its date; commits since then change the numbers. For every candidate in the report table, re-run the per-file raw-code count (method: `skills/dsi-sloc/references/measurement.md` — the `sloc` analyzer, not `wc -l`).
+
+- File now under threshold → drop silently (mention in one line: "already thin — fixed by commit X" if findable)
+- File gone/renamed → drop with a note
+- File grew → keep, use the new figure
+
+## 2. Identify touchpoints per file
+
+For each candidate, list the SHARED modules it will mutate or whose registry it will amend. Quick probes:
+
+```bash
+# who imports this file (its consumers)
+grep -rn "from.*{file-basename}" src --include='*.ts' --include='*.svelte' -l
+
+# which shared registries it touches
+grep -n "floor-registry|panel-registry|dsh-connection|prompt" {file} | head
+```
+
+Record per file: consumers, shared-module mutations, registry amendments, test files that pin it.
+
+## 3. Build the queue with lane pairing
+
+The pool runs TWO lanes. Queue order must satisfy: **the two in-flight files never mutate the same shared module**.
+
+- Sort by raw-code descending, then greedily pair A+B such that their touchpoint sets are disjoint; the pair ships to lanes a/b together, next pair waits.
+- If a file collides with EVERYTHING (e.g. a change to `floor-registry.svelte.ts` itself, which every panel file touches), it becomes a **serial milestone**: pause lane b, run it alone on the batch branch, resume the pool after. Record the pause in the ADR.
+- Present the pairing plan to the user with the curated list — the user may reorder by risk appetite instead.
+
+## 4. The delta ledger
+
+Every batch appends to the report file (or the batch ADR) a ledger:
+
+| File | Raw before | Raw after | Waves | Excluded? |
+|---|---|---|---|---|
+
+Convergence rule: a file that drops below threshold leaves all future queues. The batch is done when the ledger's "after" column has no entry over threshold (or every remaining one carries a recorded exclusion).

package/.agents/skills/dsi-thin/references/proven-gates.md

@@ -0,0 +1,61 @@
+# Proven Gates — lessons from executed thin-shell runs
+
+Each entry was paid for in a real run. Check every one during per-file
+dsi-task waves; skip only with a stated reason.
+
+## 1. `$effect` in `.svelte.ts` needs a root AND a teardown (Composer W1/W3)
+
+A class constructor in a `.svelte.ts` module cannot call `$effect` bare —
+outside component init it throws `effect_orphan`. Wrap the machine's
+effects in `$effect.root(() => { ... })`, keep the returned stop function,
+and expose `destroy()`; the shell calls it via `onDestroy`. Skip this and
+unmount-time reads warn `derived_inert` — the machine's effects outlive
+their component.
+
+## 2. Census assertion per wave (Composer W1–W4)
+
+Behavior-neutral extraction is proven by absence: after each wave, grep the
+shell for the moved declarations (`$state` names, machine functions) and
+assert **zero hits**. A grep hit on a prop KEY name (e.g. a gate key called
+`helpVisible:`) is a false positive — verify the line, don't blind-count.
+Record the count in the wave's completion notes.
+
+## 3. Tests pass UNCHANGED — and failure attribution
+
+If a pinned suite fails after an extraction, the FIRST suspect is the
+extraction, but audit before reverting: test-side assumptions (fake DOM
+elements missing methods, wrong type shapes vs the wire type, misread
+grammar) get corrected with a written reason; production code does not move
+to make a test green. This is dsi-task Step 3.5 applied.
+
+## 4. Props/callbacks: live getters, never initial capture
+
+When the shell passes a prop callback into a controller, pass a **getter**
+(`get onpickcommand() { return onpickcommand; }`) — a direct reference
+captures the initial value (svelte-check: `state_referenced_locally`) and
+freezes the controller to mount-time wiring. This also keeps the
+undefined-check semantics honest (BC-A3's no-callback early return).
+
+## 5. Focus/caret fidelity is behavior
+
+Re-focus paths are behavior, not plumbing: if the pre-move code queued a
+microtask to set caret-to-end, the controller callback must replicate that
+exactly (including the `== null` guard for a nulled `bind:this`); if it
+focused directly, direct focus. Two different re-focus semantics need two
+injected callbacks — do not unify them "while you're in there".
+
+## 6. Neutral router exception (D2 amendment, 2026-10-10)
+
+A keyboard/event ladder that arbitrates BETWEEN sibling machines may move
+into its own `.svelte.ts` router only if it owns no surface and no draft —
+constructed by the shell with the machines as deps. Never into a leaf
+component or one of the arbitrated machines. Worked example:
+`controller/keyboard-router.svelte.ts`.
+
+## Worked example — the reference execution
+
+ADR-0020 (dev/architectural-decission/2026-10/) + its spec folder
+(dev/specs/2026-10/2026-10-10 - Composer Thin Shell/) + commits 65a1027 →
+f4c1585 on `composer-thin-shell`: one file, four waves, suites unchanged at
+every commit, census 1,269 → 822 lines. Lane sub-agents should read the ADR
+and the wave completion notes before starting any file.