@nurix/etna 0.19.4 → 0.19.6

package/data/harness-index.json

@@ -1,5 +1,5 @@
 {
-    "fingerprint": "21e76b5126aa",
+    "fingerprint": "a14542f490ff",
     "harnesses": {
         "code": {
             "plugin": "code",
@@ -9,6 +9,10 @@
             "plugin": "discover",
             "description": "Product Discovery harness"
         },
+        "discussion": {
+            "plugin": "discussion",
+            "description": "deliberation-workspace harness"
+        },
         "etna": {
             "plugin": "etna",
             "description": "the master store's own harness"

package/data/harnesses/code/harness.json

@@ -1,11 +1,11 @@
 {
   "harness": "code",
   "name": "code",
-  "version": "3.1.10",
+  "version": "3.1.11",
   "files": [
     ".prettierrc.json",
     ".prettierignore",
     ".vscode/settings.json"
   ],
-  "digest": "a1bef972ab42"
+  "digest": "dd5ee7b4d838"
 }

package/data/harnesses/code/skills/design/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: design
-description: Design, build, review, polish, redesign, judge, or introspect internal operator UIs — CRMs, ticket queues, admin panels, analytics dashboards, log viewers, command centers, and any internal/back-office tool an operator, agent, or analyst works in all day. Resolves the project's brand from its design-tokens artifact (design.tokens.json), derives structure from the domain objects, emits a working React + Tailwind UI against @nurix/components or shadcn/ui, and holds it to operator-grade quality across a full sixteen-dimension taxonomy. Triggers on "build a dashboard", "design an admin panel", "review this CRM UI", "polish this queue", "redesign this internal tool", "judge this UI", "does this look right", "screenshot review", "why does this table feel off", "why does this feel off visually" (introspect keeps the causal why; judge owns the rendered whether), "make it feel like Linear", or any create/improve/introspect request for an internal operator interface. Coverage is the operator pack: marketing sites, landing pages, storefronts, homepages, and mobile-native apps are out of scope — no carried pack covers them, so refuse cleanly and redirect. The machinery is not the limit; the packs are.
+description: 'Design, build, review, polish, judge, or introspect internal operator UIs — CRMs, ticket queues, admin panels, dashboards, log viewers, command centers — as React + Tailwind from design.tokens.json. Also "does this look right" and "why does this feel off". Not marketing or mobile-native.'
 ---
 
 # design

package/data/harnesses/code/skills/design/references/personality.md

@@ -266,7 +266,7 @@ radius scale. Two cascade contracts keep the personality in charge; both are har
 emitted in-CSS comments below, enforced by the code-and-token rules (`cod-*`) in
 [hard-rules.md](./hard-rules.md), and verified **rendered** by the render rung's per-theme drift
 check (cod-15). Measured at `@nurix/components@0.14.0`, the library directly consumes 15 of the 17
-v1 semantic color roles but only one personality primitive (`--radius`) — everything else reaches
+shadcn-standard semantic color roles but only one personality primitive (`--radius`) — everything else reaches
 it through the consumer Tailwind build this file feeds (shadows, weights, tracking, and the density
 remap below).
 
@@ -288,12 +288,12 @@ remap below).
 *The exact loss mode:* a bare `:root { --background: … }` is specificity `(0,1,0)` — the library's
 own `:root { --background: … }` is also `(0,1,0)` and imported *later*, so it wins by source order
 and every surface silently reverts to shadcn gray. A lone `[data-theme="dark"]` attribute selector
-is the same `(0,1,0)` and loses the same way — the historical dark defect was exactly that
-unarmored selector, shipped while every static gate stayed green. The `:root[data-theme="…"]` arm
+is the same `(0,1,0)` and loses the same way — and it ships while every static gate stays green,
+because no static check sees the cascade. The `:root[data-theme="…"]` arm
 is `(0,2,0)` and out-wins — but only if `<html>` actually carries the attribute; scaffold writes it
 from the payload's `theme-default`, and the render rung's cod-15 measures the rendered
 `--background`/`--foreground`/`--primary` per declared theme context against the authored values,
-so a cascade-dead theme block can no longer pass.
+so a cascade-dead theme block cannot pass.
 
 **CASCADE CONTRACT 2 — the five-step import order.** The emitted `globals.css` opens:
 
@@ -419,7 +419,7 @@ on upgrades). This is user-owned upstream work — never patched with brittle pe
   color props: scaffold's `src/lib/chart-colors.ts` wires `var(--chart-1..5)` through the series
   props and the status roles (`--success`/`--warning`/`--destructive` + the accent/muted homes for
   info/empty) through the BarGraph map, so charts inherit the theme today. Chart *chrome*
-  (gridlines, axis labels) stays hardcoded — a substrate limit, filed, never a v3 bug.
+  (gridlines, axis labels) stays hardcoded — a substrate limit, filed, never a skill defect.
 - **Motion & icon stroke** — JS motion durations and icon `strokeWidth` numbers; `--duration-*` and
   `--icon-stroke` reach consumer-emitted markup but not library internals. The density dial also
   no-ops inside library tables (`h-8` row height).

package/data/harnesses/discussion/.prettierignore

@@ -0,0 +1,12 @@
+# Dependencies & build output
+node_modules
+dist
+build
+
+# Lockfiles
+pnpm-lock.yaml
+package-lock.json
+yarn.lock
+
+# Harness-managed agent/skill definitions (installed under .claude/)
+.claude

package/data/harnesses/discussion/.prettierrc.json

@@ -0,0 +1,3 @@
+{
+  "proseWrap": "never"
+}

package/data/harnesses/discussion/.vscode/settings.json

@@ -0,0 +1,10 @@
+{
+  // Markdown: Prettier unwraps prose to one logical line per paragraph
+  // (see .prettierrc → proseWrap:never) on save; the editor soft-wraps for
+  // reading, so no hard line breaks get baked into the source.
+  "[markdown]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+    "editor.formatOnSave": true,
+    "editor.wordWrap": "on"
+  }
+}

package/data/harnesses/discussion/CLAUDE.md

@@ -0,0 +1,19 @@
+# The deliberation workspace
+
+Not a code repo — a **thinking workspace**: each subfolder is one long-running discussion topic, deliberated across many sessions. Chat is ephemeral; **the folders are the record**. Anything of value lands in files inside the topic's folder, never only in conversation.
+
+## Baseline
+
+Invoke the `discussion-baseline` agent whenever the workspace looks unreconciled — no `metadata/TOPICS.md` (fresh install: baseline before anything below), no git repository, or a `harness-version` stamp behind the installed `.claude/harness.json` version. **Never reconcile these by hand** — the agent auto-selects its mode (bootstrap when the sentinel is missing, reconcile when the version is behind) and hands back. The workspace **must** be a git repository — baseline initializes one; the session-end hook batches each session's changes into one commit.
+
+## The three layers
+
+Strictly separated — never mix them:
+
+| Layer | Lives in |
+| --- | --- |
+| **Method** (timeless) | this file + `.claude/rules/method.md` (how sessions run) + `.claude/rules/artifacts.md` (what gets written) |
+| **State** (current) | `metadata/` — `TOPICS.md` (topic index) + `SESSIONS.md` (session ledger) |
+| **Record** (append-only) | each topic's `README.md` + artifacts |
+
+The rules are the method — portable, abstract, generic examples; nothing depends on any local topic. Live exemplars are reached through `metadata/TOPICS.md`. Workspace-local method notes go to `metadata/method-changelog.md`; the harness itself is versioned by `.claude/harness.json` and documented in the etna forge (`docs/architecture/harness/discussion/`).

package/data/harnesses/discussion/agents/discussion-baseline.md

@@ -0,0 +1,93 @@
+---
+name: discussion-baseline
+description: Baselines a deliberation workspace against the installed discussion harness — bootstraps a fresh folder (git init, metadata/ seeding, version stamp) or reconciles an existing one when the harness-version stamp is missing or behind. Mode is auto-selected from the sentinel. Use on a fresh install, when metadata/TOPICS.md or the git repo is missing, or after a harness upgrade. Triggers on "baseline this workspace", "initialize the workspace", "reconcile the harness", "is this workspace on the current harness", "/baseline".
+tools: Read, Glob, Grep, Bash, Write, Edit
+model: inherit
+---
+
+You are the **discussion-baseline** agent. One job: converge a workspace to the installed discussion-harness shape, then get out of the way. You are idempotent — a second run is a verification pass. Every file you seed is carried inline below; you need no external templates.
+
+## Mode selection
+
+Decide once, up front, from two reads:
+
+- **Installed version** — `version` in `.claude/harness.json`, shipped by the CLI at install. If `harness.json` is absent, stop and instruct the user to run `npx @nurix/etna --name=discussion`, then retry.
+- **Workspace version** — the `harness-version:` field in the YAML frontmatter of `metadata/TOPICS.md`.
+
+| Workspace version | Mode |
+| --- | --- |
+| `metadata/TOPICS.md` absent | **bootstrap** — fresh workspace, scaffold everything |
+| present, behind on **major** | **reconcile** — converge to the current shape, then re-stamp |
+| present, behind on minor/patch | re-stamp only; report, change nothing else |
+| equal | verify-only — report what's present, stop |
+
+**Precondition:** a root `CLAUDE.md` must exist — if it doesn't, the harness wasn't installed; stop and say so.
+
+**Write boundary:** you write only `metadata/`, per-topic `metadata.md` maps, `.gitignore`, and git commits. You **never** write or modify `CLAUDE.md`, anything under `.claude/` (the CLI ships those), or any topic's content files (READMEs, dumps, syntheses, canon — those are the record, not yours).
+
+## Bootstrap mode
+
+1. **Git.** If `.git/` is absent: `git init`. Ensure the root `.gitignore` exists with the minimal set (below). The workspace **must** end this run as a git repository — the session-close auto-commit depends on it.
+2. **Seed `metadata/`.** Create `metadata/TOPICS.md`, `metadata/SESSIONS.md`, and `metadata/method-changelog.md` from the templates below — create only what's missing; **never overwrite an existing file**. Stamp `harness-version:` in `TOPICS.md` frontmatter from `.claude/harness.json`.
+3. **Adopt existing content.** If topic-shaped folders already exist (a folder with a `README.md` that isn't harness machinery), fold them forward: add a `TOPICS.md` entry per topic (state phrase from its README's TL;DR/open threads), and create a `metadata.md` map for any topic lacking one (one line per file — name + what it is, from each file's H1/banner; bulk directories one line total). Adoption is registration, not rewriting — READMEs stay untouched.
+4. **Commit.** One commit: `🔧 baseline: discussion harness v<version>`.
+5. **Hand off.** Report created vs skipped vs adopted, then point at the next actions: start the first topic (say what you're thinking about), or resume via `metadata/TOPICS.md`.
+
+## Reconcile mode
+
+Declarative, not a migration ladder — converge to the **current** shape; detect old-shape artifacts to know what to *move* versus *create*; never replay version steps. Known old shapes to fold forward:
+
+| Old-shape artifact | Current home |
+| --- | --- |
+| `TOPICS.md` at workspace root | `metadata/TOPICS.md` (preserve content; add frontmatter) |
+| Folder map section inside a topic README | per-topic `metadata.md` (move the map; leave a `Folder map: [metadata.md](metadata.md)` pointer line) |
+| Method changelog inside `CLAUDE.md` | `metadata/method-changelog.md` (copy the entries out; the CLI owns `CLAUDE.md` — flag, don't edit it) |
+| Instrument folders at the root | flag for the user to relocate outside the workspace (never move data yourself) |
+
+Only fold what is present. Then re-stamp `harness-version:`, commit `🔧 baseline: reconciled to discussion harness v<version>`, and report every move.
+
+## Rules
+
+- **Idempotent** — create-only for seeds; a clean report is valid, do not invent work.
+- **Registration, not authorship** — you index topics; you never write their content.
+- **One sentinel** — `harness-version:` in `metadata/TOPICS.md` frontmatter; no second marker.
+- **Every write lands in the baseline commit** — reviewable and reversible in git.
+
+## Templates
+
+`metadata/TOPICS.md`:
+
+````markdown
+---
+harness-version: <version from .claude/harness.json>
+---
+
+# TOPICS — topic state
+
+> The workspace's record of what each topic is about, its current state, and its open threads. Method lives in `CLAUDE.md` and `.claude/rules/`; state lives in `metadata/` — this file (the topic index) and [`SESSIONS.md`](SESSIONS.md) (the session ledger). Update this file whenever a topic is added or its state changes materially (a `SessionEnd` hook reconciles it automatically; it fails silently, so check `../.claude/topics-sync.log` if this file looks stale). Each topic's `README.md` remains the authoritative deep record — this file is the session-start index.
+````
+
+`metadata/SESSIONS.md`:
+
+````markdown
+# SESSIONS — the session ledger
+
+> One entry per session, appended at the bottom. An entry is the session's **summary** — goal, what was touched, what was filed, where it stopped — rewritten in place when the session resumes (a summary, never a resume-log). Entries point into topics; content never lives here. Grammar in `.claude/rules/method.md`.
+````
+
+`metadata/method-changelog.md`:
+
+````markdown
+# Method changelog — workspace-local
+
+> Dated one-line entries for method decisions made in this workspace. Harness-level method changes arrive by version (`.claude/harness.json`) and are logged in the harness source, not here.
+````
+
+Root `.gitignore` (create if missing; append missing lines, never remove existing ones):
+
+````
+node_modules/
+dist/
+.DS_Store
+.claude/*.log
+````

package/data/harnesses/discussion/harness.json

@@ -0,0 +1,11 @@
+{
+  "harness": "discussion",
+  "name": "discussion",
+  "version": "0.1.1",
+  "files": [
+    ".prettierrc.json",
+    ".prettierignore",
+    ".vscode/settings.json"
+  ],
+  "digest": "8c85979c28c4"
+}

package/data/harnesses/discussion/hooks/hooks.json

@@ -0,0 +1,16 @@
+{
+  "hooks": {
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/update-topics.sh",
+            "timeout": 15,
+            "statusMessage": "Syncing workspace metadata"
+          }
+        ]
+      }
+    ]
+  }
+}

package/data/harnesses/discussion/hooks/update-topics.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+# SessionEnd hook — reconcile workspace metadata, then auto-commit the session as one batch.
+# Spawns a headless claude sub-agent that updates metadata/TOPICS.md and metadata/SESSIONS.md
+# from the ended session's transcript, then commits everything the session changed
+# (one commit per session close, never per file).
+set -uo pipefail
+
+# Recursion guard: the spawned sub-agent's own SessionEnd fires this hook too.
+if [ -n "${TOPICS_SYNC_RUNNING:-}" ]; then
+  exit 0
+fi
+
+workspace="${CLAUDE_PROJECT_DIR:-$(cd "$(dirname "$0")/../.." && pwd)}"
+log="$workspace/.claude/topics-sync.log"
+cd "$workspace" || exit 0
+
+# Missing prerequisites must be visible in the log, not a silent dead end.
+sync_ok=1
+for bin in jq claude; do
+  if ! command -v "$bin" >/dev/null 2>&1; then
+    echo "=== $(date '+%Y-%m-%d %H:%M:%S') SessionEnd — $bin not on PATH; metadata sync skipped" >> "$log"
+    sync_ok=0
+  fi
+done
+
+transcript=""
+if [ "$sync_ok" = 1 ]; then
+  input=$(cat)
+  transcript=$(printf '%s' "$input" | jq -r '.transcript_path // empty')
+fi
+
+prompt="You are a maintenance sub-agent for the deliberation workspace at $workspace.
+A session there just ended. Its transcript (JSONL) is at: $transcript
+
+1. Read the transcript to determine which topic folders (subdirectories of the workspace) were discussed, created, closed, or materially changed — and what the session's goal was. If the transcript is large, read it in chunks starting from the end.
+2. Read $workspace/.claude/rules/method.md — its 'metadata/ — the state layer' section defines the grammars for both state files and is the single source of format truth.
+3. Read $workspace/metadata/TOPICS.md, $workspace/metadata/SESSIONS.md, and the README.md of each touched topic.
+4. If any topic's description, state, or open threads changed during the session — or a topic folder was added or wrapped up — update TOPICS.md to match, preserving the entry grammar and the file's YAML frontmatter.
+5. Ensure SESSIONS.md carries a summary entry for the ended session (goal, touched, filed, close state): update the entry if the session already wrote one; append at the bottom otherwise. A resumed session updates its existing entry — never log resumes.
+6. If nothing needs changing, reply 'no change'.
+
+Only edit files inside $workspace/metadata/. Do not modify any other file."
+
+echo "=== $(date '+%Y-%m-%d %H:%M:%S') SessionEnd — transcript: ${transcript:-none}" >> "$log"
+
+# Backgrounded so it outlives the hook timeout; sync runs first, then one batched commit.
+TOPICS_SYNC_RUNNING=1 nohup bash -c '
+  cd "$1" || exit 0
+  if [ -n "$3" ] && [ -f "$3" ]; then
+    claude -p "$4" \
+      --allowedTools "Read,Glob,Grep,Edit(metadata/TOPICS.md),Write(metadata/TOPICS.md),Edit(metadata/SESSIONS.md),Write(metadata/SESSIONS.md)" \
+      >> "$2" 2>&1
+  fi
+  if [ -d .git ] && [ -n "$(git status --porcelain 2>/dev/null)" ]; then
+    git add -A >> "$2" 2>&1
+    git commit -m "📝 session close $(date "+%Y-%m-%d %H:%M")" >> "$2" 2>&1
+  fi
+' _ "$workspace" "$log" "$transcript" "$prompt" >/dev/null 2>&1 &
+disown
+
+exit 0

package/data/harnesses/discussion/rules/artifacts.md

@@ -0,0 +1,75 @@
+# Artifact formats
+
+What gets written in a topic folder. How sessions run is [method.md](method.md). Every file belongs to a named class; never let one masquerade as another.
+
+| Class | What |
+| --- | --- |
+| 1 — raw dumps | lossless sweep output, one file per lane + critic |
+| 2 — synthesis | opinionated analysis over the raw; filed, never chat-only |
+| 3 — goal track | what we're trying to achieve; from user intent, not sweeps |
+| canon | the ratified deliverable, own subfolder + `00-INDEX.md` |
+| spine / clips / auxiliaries | README, `references/`, bibliographies-matrices-built-artifacts |
+
+A ratified class-3 doc **is** the goal-track canon — never double-book it under canon.
+
+**Banner**: class 1/2/3 artifacts and auxiliaries open with an H1 + `>` blockquote banner: **class · derivation (links + scale) · method · ISO date · ratification status**. Status applies to 2/3/auxiliaries only — raw dumps are immutable, never ratified. Exempt: canon (its own `**Status:**` line / orientation paragraph) and clips (two-line header).
+
+**Status vocabulary**: `**DRAFT — not yet ratified**` / `Not yet user-ratified` · `(ratified YYYY-MM-DD)` — at doc, section, or extract granularity · `**Superseded note (YYYY-MM-DD):** … kept as record` · `deferred — blocked on <gate>` vs the exclusion grades.
+
+**Immutability**: raw dumps immutable once filed (corrections land in critic or synthesis) · unratified syntheses may be rewritten in place as v2, recorded in provenance · ratified material changes by dated append or supersession only · nothing valuable is deleted — superseded → banner + keep; broken → flagged; closed threads → struck through. Every lifecycle event carries an ISO date.
+
+## The topic README
+
+Routes and records, never duplicates the research. Sections in order (first and last invariant):
+
+1. `# <folder-slug> — <subtitle>`
+2. **Topic definition** — subject, driving question (user's words verbatim), standing scope decisions (dated). If canon exists, a bold pointer line at the very top.
+3. `## TL;DR of current understanding` — present-tense verdict, **rewritten in place** (the one non-append-only section); ratification status inline per claim; closes with `Full argument: [00-synthesis.md]` when a lead synthesis exists.
+4. `## Provenance chain` — numbered, **append-only**. Entry: `N. **YYYY-MM-DD — <3–8 word headline>.** <body>` — one entry per **event**, not per session. Body: trigger (user quoted verbatim for rulings) · what ran (telemetry) · what was filed (links) · dispositions · adjudications (counts + reasons) · closing status. Never edited into a new story — a break gets a new entry.
+5. `Folder map: [metadata.md](metadata.md)` — a pointer line only. The map itself is **`metadata.md`**, beside the README: one line per file (name + what it is + class/status; breakage flagged there, file kept; bulk directories one line total). Rewritten in place — the map is state, not record.
+6. `## Open threads` — every item **deferred** (with its blocker; point at the synthesis's numbered questions when awaiting the user) or **excluded** (graded). Retired threads struck through: `~~<thread>~~ **Excluded by decision** (YYYY-MM-DD, provenance entry N).`
+
+Seed at creation: title, definition, empty Open threads, and the `metadata.md` map. Every state-changing session: append provenance, rewrite TL;DR, reconcile the map and threads. Pre-codification topics grow the missing spine when next touched — one dated catch-up entry, not invented history.
+
+## Raw dumps — filing sweeps
+
+The lossless appendix of record; everything downstream cites into it. Never distill-and-discard.
+
+- One sweep = one folder: `research-<slug>/` (web) or `surveys/` (codebase). Only lane files + critic inside. Files `01-<lane>.md` … `NN-completeness-critic.md`, critic always last; gap-fill files continue the sequence. Script filing: word-boundary filename truncation; check briefs for leaked placeholders.
+- **Lane file**: banner (same template across the sweep) · charter incl. what it deliberately does **not** cover (a sibling owns it) · **verdict first** · shared dissection template across lanes · **stable item IDs** (`A1`, `H3`) so downstream cites precisely · sourcing (web: every figure dated; conflicts → both numbers with dates; secondary sources flagged; closing `## Sources` with URL + access date; codebase: file paths) · exclusion notes, so absence ≠ oversight.
+- **The critic**: reads all lanes in full, then coverage audit (severity-ordered, naming the sweep-design bias behind each hole) · cross-lane contradictions (adjudicated or flagged) · verification spot-checks of load-bearing claims · convergence vs tension (2+ lanes agree → settled input; tensions → user decisions) · prioritized follow-up briefs. Critic fetches are clipped to `references/`.
+- **Gap-fills**: one lane per critic finding worth closing now, same folder, numbering continued, banner naming the finding it answers.
+- Provenance is split: file banner = method + date; README entry = agents + model + results (model lives only there). Citation grammar downstream: lane / item ID / `file:line` — a claim that can't be cited this way means the raw layer failed.
+
+## Synthesis
+
+Discussion material, not canon: a verdict the user can react to, every claim traceable to the raw record. The lead working doc takes the `00-` slot at topic root; it may grow chapters `00-`…`NN-` in production order, each banner stating which distinct question it answers vs the earlier ones.
+
+Skeleton: `## The verdict` first (1–3 sentences, load-bearing clause bolded) · **what holds / what breaks** · evidence spine (numbered bold-led findings citing lanes/IDs/`file:line`, weighted by convergence counts) · **pushback register** — the user's own framing adjudicated item by item: vindicated / broken / reframed; filed, not softened · stable IDs on disposable units (T1…, H1…, B1…) · epistemics (confidence flags, data hygiene before canon, sweep-quality note) · judgment record (overrules with citations; "undecidable — user to ratify or commission") · `## Open questions for reaction` **always last** — numbered, each disposable (accept / reframe / exclude / defer), recommendation attached where you have one. These become the README's Open threads by reference.
+
+Lifecycle: filed "Not yet user-ratified" → broken pre-ratification: rewritten **in place** as v2 (versioned title, break in provenance) → broken by a sibling: the newer file declares "what this breaks", the older stays but gets flagged in the folder map → superseded by canon: dated superseded banner, **kept**. Partial ratification is stamped at the granularity it happens. Synthesis argues from evidence and ends in questions; canon states settled method and ends in exclusions.
+
+## The goal track
+
+When a topic has a **goal**, not just a subject: a parallel doc recording what we are trying to achieve — from the user's intent, never from sweeps. Draft it as soon as the goal appears (late drafting is a repair). Only the user ratifies.
+
+- Two shapes: **vision narrative** (the goal state as a story, as if it already exists: thesis → numbered journey sections → closing "why it compounds") or **intent charter** (`What we are trying to achieve` → `Overarching goals` → `The questions this topic must answer` → `What done looks like` → `Excluded by decision`, dated → `Open intent — only the user can fill these`).
+- Placement: single doc at topic root (`mental-model.md`) or a subfolder (`vision/`) if it will grow. The README states the split in one line — "sweeps describe what *is*; this track describes what we're *building*".
+- Voice: present-tense declarative about the future, in the user's vocabulary; no hedging, no evidence citations. **Divergence flags are mandatory** wherever reality differs, kept out of the body: `## Grounding notes` at the bottom (ratified narrative kept clean) or inline `⚑ *Divergence flag:*` (draft whose divergence is under deliberation).
+- Ratified, it **is** the goal-track canon. Updated, not superseded: a resolved flag becomes changed intent (edit the body + dated provenance entry — the one sanctioned edit into ratified material) or changed plan (keep the flag, date the disposition).
+
+## Canon
+
+The user-ratified deliverable — settled, never exploratory. Own subfolder (`<topic>/playbook/`), zero-padded numbered chapters, `00` reserved for the index.
+
+`00-INDEX.md`, in order: H1 · `**Status:**` (state + ISO date · one-line distillation provenance · source-of-truth declaration: "this directory, not the sweeps") · `## Scope and exclusions` (excluded-by-decision vs deferred, distinguished; a later-canonized deferral gets its bullet rewritten) · `## The axioms` (numbered; bold one-sentence lead + a line of elaboration; **append-only** under dated introducers — never renumber) · chapter table (`# | chapter | concern`, linked) · `## Conventions`.
+
+Chapters: H1 = short noun title, no number (the number lives in the filename) · bold orientation first paragraph ("**Pass N of the method.** Input: … Output: …"; post-ratification additions carry the date + a link to the grounding sweep) · self-contained, declarative present tense, cross-linked to siblings, axioms cited by number · named patterns: **bold name** + `**Definition:**` / `**When to use:**` / consequence + real product examples — the user's coined word is the canonical name; credit external frameworks, claim originals explicitly · deliberate closer: `## Anti-patterns` (commonest), "Output of this pass" (pipelines), or "Known whitespace" (catalogs).
+
+Canonization checklist (only on explicit ratification): survivors in the user's reframed language → axioms appended under a dated introducer; chapter table updated → stale "deferred" stubs rewired → dated superseded banner on the outdated synthesis, kept → README reconciled (provenance entry, canon pointer line up top, Open threads) + `TOPICS.md`.
+
+## References and auxiliaries
+
+- **`references/` clips** — sources surfaced in discussion, clipped losslessly: one file per source, kebab-case title slug, header first (`Source URL: <url>` / `Retrieved: YYYY-MM-DD`), faithful markdown, quotes verbatim; optional curator's blockquote stating the clip's role. Clips only — sweep output stays in its sweep folder.
+- **Auxiliaries** (bibliographies, matrices, built artifacts) fit no class — don't force one; self-describe via banner with an explicit class disclaimer ("not sweep output") + ratification status. Bibliography: thread-grouped H2s, `**Author, *Title* (year)** — why it matters here`, `★` priority reads, closing "Suggested reading order". Matrix: banner (source, validation, acceptance), glyph legend (`■ solid · ▫ partial · † dead · blank`), column key linking the source doc, "Reading notes" closer, unratified membership rules flagged. Built artifact: its own buildable subfolder inside the topic — a deliverable, not a record; any embedded re-cut of a canon/vision doc names its source-of-truth and is regenerated, never edited into a fork.
+- The README folder map annotates every auxiliary; the provenance chain records its creation and validation.

package/data/harnesses/discussion/rules/method.md

@@ -0,0 +1,81 @@
+# The deliberation method
+
+How sessions run in this workspace. What gets written is [artifacts.md](artifacts.md).
+
+## Workspace layout
+
+- **Topic folders** — one folder = one long-running topic. Kebab-case noun phrase naming the **inquiry, not the deliverable** (`pricing-research`, not `pricing-report`). Every topic has a `README.md` (the record), a `metadata.md` (the map), and a `TOPICS.md` entry.
+- **`metadata/`** — all workspace state: `TOPICS.md` (topic index), `SESSIONS.md` (session ledger), `method-changelog.md` (workspace-local method notes; the harness itself versions via `.claude/harness.json`). State lives here and nowhere else.
+- **External instruments** — code/data a topic depends on (scraper, corpus, pipeline) lives **outside the workspace**, never at the root: this folder holds only topics and the harness. Record the dependency on the depending topic's README (external path + ratification status); exclusions are recorded on the excluder's side.
+- **Git** — the workspace **is a git repository** (the `discussion-baseline` agent initializes one). The SessionEnd hook auto-commits each session's changes as one `📝 session close` batch — never per-file commits. Milestone commits by hand are still welcome: `✨` content, `🔧` workspace/method. Root `.gitignore` stays minimal.
+- **Grandfathering** — when the method changes, never reshuffle existing artifacts to match. New artifacts follow current rules; old layouts stay, flagged where confusing.
+
+## Session protocol
+
+A session is one sitting; the durable unit is the topic. Route before substantive work:
+
+1. Read `metadata/TOPICS.md` and the last entry of `metadata/SESSIONS.md` (fallback: list folders, read the first ~15 lines of each README).
+2. Match the opening message against the topics. Likely continuation → recommend **that topic only** ("sounds like `<topic>/` — pick it up there?"). Unambiguous → skip the ask, just confirm the folder.
+3. No plausible match → ask: continue an existing topic or start new (one-line summaries + open threads).
+4. Existing topic → read its `metadata.md`, then its README **fully** before anything substantive. Never re-litigate settled decisions.
+5. New topic → create the folder, seed a README (definition + empty Open threads) and a `metadata.md`, add its `TOPICS.md` entry (missing `metadata/` files or git repo → run the `discussion-baseline` agent, don't hand-seed).
+
+Stale index? The README wins — reconcile. Check `.claude/topics-sync.log`; the hook fails silently.
+
+Update the topic README, its `metadata.md`, and `metadata/` **inline, the moment a material change happens** — the hook is the safety net, not the mechanism. At close: provenance entry appended, TL;DR rewritten, Open threads reconciled, `TOPICS.md` matched, the session's `SESSIONS.md` entry updated, touched folders' maps reconciled.
+
+## Context doctrine
+
+Claude thinks best with an empty context and a good map.
+
+- **Map first** — read `metadata.md` before (usually instead of) the files it describes; never load what the map answers.
+- **Delegate bulk reading** — sub-agents read the heavy material and return summaries; the main line holds conclusions, not corpora.
+- **File early** — disk gets everything valuable the moment it exists; context is never the only copy.
+- **Maps stay small** — one line per file; bulk directories get one line total.
+
+## The discussion loop
+
+1. **Dump** — the user lectures, brain-dumps, or asks. Their framing is the raw material.
+2. **Sweep** — fan out sub-agents for breadth (expert panels, web research, codebase surveys). Every fan-out sweep **ends with a completeness critic**.
+3. **File the raw** — losslessly, per [artifacts.md](artifacts.md); web finds clipped to `references/`.
+4. **Synthesize** — verdict first, in chat **and filed**, ending in numbered open questions.
+5. **The user narrows** — dispositions are exactly: **accepted / reframed / excluded / deferred**. Reframings override everything prior, including sweep conclusions and your own arguments; concede precisely, not wholesale. Record every disposition in provenance, quoting the ruling verbatim.
+6. **Canonize** — only after explicit ratification ("agree / hit it / put it in the document"); run the canonization checklist. Discussion turns get discussion answers, not canon files.
+
+Exclusion grades:
+
+| Label | Strength |
+| --- | --- |
+| **Excluded by decision** | user ruling, dated — never re-litigate |
+| **Excluded by framing** | definitional consequence of a ratified framing |
+| **Excluded pending objection** | agent-proposed, stands until the user objects |
+
+## `metadata/` — the state layer
+
+Method lives in the rules (timeless); state lives in `metadata/` (current); topic READMEs stay the deep record.
+
+### `TOPICS.md` — topic index
+
+- YAML frontmatter carries `harness-version:` — the baseline sentinel; **always preserve it**.
+- H1 + blockquote preamble (division of responsibility, update triggers).
+- Per topic: `` ## `topic-folder/` — <state phrase> `` — the suffix encodes **who it's waiting on** ("synthesis filed, awaiting user reaction").
+- One dense routing paragraph: what it is, which artifacts exist (files, dates), headline findings — enough to route without opening the folder.
+- Bullets: `**Open:**` (typically "user disposition on the N questions closing `<file>`") · exclusion grades, dated when user rulings · `**Note:**` caveats.
+
+### `SESSIONS.md` — session ledger
+
+One entry per session, appended at the bottom. An entry is the session's **summary**, rewritten in place when the session resumes — never a resume-log. Format: `## YYYY-MM-DD — <goal headline>` + bullets: `**Goal:**` (the user's stated aim; update it if it shifts mid-session) · `**Touched:**` · `**Filed:**` (linked) · `**Close state:**` (where it stopped, what it awaits). Entries point into topics; content never lives here.
+
+### The SessionEnd hook
+
+Safety net only: `settings.json` → script in `.claude/hooks/`, `$CLAUDE_PROJECT_DIR`-relative. Script: recursion-guard env sentinel · stdin JSON → `transcript_path`, silent exit-0 on anything missing · headless `claude -p`, tool-allowlisted to write **only the two `metadata/` state files**, told to read this rule for the grammars · then **one batched auto-commit** of the session's changes · `nohup … & disown` to outlive the timeout · appends `.claude/topics-sync.log`. Needs `jq` + `claude` on PATH (missing → logged). Failures are logged, never surfaced: stale index → check the log, reconcile by hand.
+
+## Working with this user
+
+- Developer; thinks **data-model-first** and in systems (storage / flow / view). Meet them there.
+- *"Throw a lot at me — I'll tell you what's relevant."* Exhaustive named-pattern catalogs over cautious summaries.
+- **Push back explicitly** — dedicated pushback sections on their claims, not watered-down hedging. When they push back on you, find the precise boundary of what was wrong; don't abandon everything.
+- They coin patterns mid-discussion: name them crisply, credit the framing, build canon in their vocabulary.
+- Scale effort to the ask: sweeps for capture/research; direct opinionated prose for "what's your view".
+
+**Sub-agents validate, the main agent judges** (standing rule): agents gather, cross-check, attack; the main agent assembles the deliverable and adjudicates every finding itself. Every validation round is adjudicated on the record — N findings → accepted (reason each) / **rejected as intentional** (reason each); never auto-apply. Overrules carry citations into the raw corpus. Record sweep telemetry in provenance: agents, model, lanes, sources.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nurix/etna",
-    "version": "0.19.4",
+    "version": "0.19.6",
     "description": "Bootstrap a project with a Nurix harness — copies the harness's CLAUDE.md, skills, agents, rules, and hooks directly into the project from a bundled payload (no marketplace fetch, no network).",
     "type": "module",
     "bin": {