@nurix/etna 0.19.78 → 0.19.80

package/data/harness-index.json

@@ -1,5 +1,5 @@
 {
-    "fingerprint": "728af89f1e8e",
+    "fingerprint": "f0d6766a263f",
     "harnesses": {
         "code": {
             "plugin": "code",

package/data/harnesses/code/harness.json

@@ -1,7 +1,7 @@
 {
   "harness": "code",
   "name": "code",
-  "version": "3.10.4",
+  "version": "3.10.6",
   "files": [
     ".prettierignore",
     ".prettierrc.json",
@@ -15,5 +15,5 @@
     "docs/memory/main.md",
     ".mcp.json"
   ],
-  "digest": "4b1ec8d430ab"
+  "digest": "9198a225596a"
 }

package/data/harnesses/code/hooks/awareness.mjs

@@ -31,7 +31,7 @@ import {
   recordTouched,
 } from "./lib/state.mjs";
 import { frozenStatus } from "./lib/frozen.mjs";
-import { approvedPackages } from "./lib/approved.mjs";
+import { approvedPackages, rejectedPackages } from "./lib/approved.mjs";
 import {
   recordSession,
   liveSiblings,
@@ -484,15 +484,24 @@ function detectOutcomes(projectDir, meta, rows) {
       } catch (e) {
         continue;
       }
+      // A row is raised for a *rejected* package only — a decision already taken and violated.
+      // A package with no decision either way is not a defect: it is a dimension nobody has ruled
+      // on, harvested centrally by the fleet package census. Raising rows on absence turned the
+      // commit wall into a tax on every unlisted dependency and produced waivers, not decisions.
+      const rejected = rejectedPackages(projectDir);
       const names = [...Object.keys(manifest.dependencies || {}), ...Object.keys(manifest.devDependencies || {})];
       for (const name of names) {
-        if (approved.has(name) || raised(`\`${name}\` (package-off-catalog`)) continue;
+        if (approved.has(name) || raised(`\`${name}\` (package-rejected`)) continue;
+        const no = rejected.get(name);
+        if (!no) continue;
         rows.push(
           formatAutoRow({
             ...meta,
-            kind: "package-off-catalog",
-            description: `${rel} declares \`${name}\` (package-off-catalog), absent from the approved table`,
-            action: "remove the dependency, or add it to .claude/hooks/approved-packages.md by explicit user decision",
+            kind: "package-rejected",
+            description: `${rel} declares \`${name}\` (package-rejected), which the approved table rejects`,
+            action: no.use
+              ? `replace it with \`${no.use}\`, or change the decision in .claude/hooks/approved-packages.md`
+              : `use the choice ${no.rule} prescribes for this stack, or change the decision`,
           })
         );
       }

package/data/harnesses/code/hooks/compliance.mjs

@@ -13,7 +13,7 @@ import { readQueue, countRows, askedThisSession, recordAsked } from "./lib/state
 import { frozenStatus } from "./lib/frozen.mjs";
 import { undischargedRows } from "./lib/ledger.mjs";
 import { appendEvent, unresolvedDenials, sessionLogPath, malformedEventLines } from "./lib/session-log.mjs";
-import { approvedPackages } from "./lib/approved.mjs";
+import { approvedPackages, rejectedPackages } from "./lib/approved.mjs";
 import { claimActivity, releaseActivity, recentForeignTouches } from "./lib/claims.mjs";
 
 function readSafe(file) {
@@ -277,6 +277,7 @@ function packageGate(projectDir, command, sessionId) {
   if (!m) return null;
   const approved = approvedPackages(projectDir);
   if (approved.size === 0) return null; // no rules file installed — nothing to enforce
+  const rejected = rejectedPackages(projectDir);
   const raw = m[1] || "";
   // Test packages install at `latest`, outside the table's pin set (.claude/rules/testing.md).
   // Two dev-only installs are a decision already taken rather than a new one: a companion in an
@@ -291,16 +292,25 @@ function packageGate(projectDir, command, sessionId) {
   const args = raw.split(/\s+/).filter((a) => a && !a.startsWith("-") && PKG_SPEC.test(a));
   for (const arg of args) {
     const pkg = arg.startsWith("@") ? arg.split("@").slice(0, 2).join("@") : arg.split("@")[0];
+    if (approved.has(pkg)) continue;
     if (isDev && pkg.startsWith("@") && approvedScopes.has(pkg.split("/")[0])) continue;
-    if (!approved.has(pkg)) {
+    // Approved wins over rejected: `jest` is banned for web and Express and prescribed for Expo,
+    // so a name in both is a prescription somewhere and must not be denied.
+    const no = rejected.get(pkg);
+    if (no) {
+      const instead = no.use
+        ? `Use \`${no.use}\`${no.version ? ` ${no.version}` : ""}${no.purpose ? ` — ${no.purpose}` : ""}.`
+        : `The prescribed choice for your stack is in ${no.rule}.`;
       return deny(
         projectDir,
         sessionId,
         "package-table",
         pkg,
-        `BLOCKED — package table. \`${pkg}\` is not in the approved table (.claude/hooks/approved-packages.md; test packages: .claude/rules/testing.md). The table changes only by explicit user decision.`
+        `BLOCKED — \`${pkg}\` is rejected here. ${instead} Rejections are recorded in .claude/hooks/approved-packages.md; changing one is an explicit user decision.`
       );
     }
+    // No decision exists for this package — not approved, not rejected. Allowed, and harvested
+    // centrally by the fleet package census rather than blocked here.
   }
   // Every named package is approved — a package-table denial for one of them is a successful retry.
   for (const arg of args) {

package/data/harnesses/code/hooks/lib/approved.mjs

@@ -56,3 +56,35 @@ export function approvedPackages(projectDir) {
   }
   return names;
 }
+
+// A rejection is a decision already taken, and it names its replacement: the approved table's rows
+// are `| package | version | use | don't use |`, so every name in a Don't-use cell points at that
+// row's package. testing.md's framework table bans by stack without a single substitute, so those
+// rejections carry the rule reference instead. Absence from both maps is not a rejection — it is a
+// dimension nobody has ruled on, and the gate lets it through (the census harvests it centrally).
+export function rejectedPackages(projectDir) {
+  const rejected = new Map();
+  const table = path.join(projectDir, ".claude", "hooks", "approved-packages.md");
+  for (const line of readSafe(table).split("\n")) {
+    const cells = line.split("|");
+    if (cells.length < 6) continue;
+    const pkg = /`([^`]+)`/.exec(cells[1] || "");
+    if (!pkg || pkg[1] === "Package" || pkg[1] === "---") continue;
+    const version = (/`?([^`|]+)`?/.exec((cells[2] || "").trim()) || [])[1] || "";
+    for (const m of (cells[4] || "").matchAll(/`(@?[a-z0-9][\w./-]*)`/g)) {
+      if (m[1] === pkg[1]) continue; // "`mermaid` via CDN" bans a delivery, not the row's own package
+      rejected.set(m[1], { use: pkg[1], version: version.trim(), purpose: (cells[3] || "").trim() });
+    }
+  }
+  const testing = path.join(projectDir, ".claude", "rules", "testing.md");
+  let banColumn = -1;
+  for (const line of readSafe(testing).split("\n")) {
+    banColumn = banColumnOf(line, banColumn);
+    if (banColumn < 0 || !line.trimStart().startsWith("|")) continue;
+    const cell = line.split("|")[banColumn] || "";
+    for (const m of cell.matchAll(/`(@?[a-z0-9][\w./-]*)`/g)) {
+      if (!rejected.has(m[1])) rejected.set(m[1], { rule: "testing.md § Frameworks by stack" });
+    }
+  }
+  return rejected;
+}

package/data/harnesses/code/rules/frontend.md

@@ -11,6 +11,16 @@ Tailwind v4 + shadcn-based UI conventions for **web** apps — styling, the `@nu
 - Tokens: CSS vars in `:root, :root[data-theme="light"]` and `:root[data-theme="dark"]` (both specificity 0,2,0 — armor a later bare `:root` can't defeat), consumed as semantic Tailwind tokens (`bg-card`, `text-foreground`). `globals.css` carries the active `@custom-variant dark` line; the theme attribute is `data-theme`. The library bundles `class-variance-authority`, `clsx`, `tailwind-merge` — don't re-add them.
 - Spacing in 2/4/6/8; `object-cover`; `truncate`; color through tokens — **never** hardcoded hex in components.
 
+## Component Search Order
+
+**A component already exists until the search proves otherwise** — building one is the last step, never the first instinct, and a primitive the library ships is never re-implemented. Search in order: **`@nurix/components`** (its `exports` keys are the available subpaths) → **the app's own `src/components/`**, which in a monorepo is the consuming package's pool → **the route folders**, where a near-match is a misfiled generic to promote rather than duplicate.
+
+**A new component lands in `src/components/` on first use, not on second.** Waiting for reuse to promote it fails in practice: nobody notices the second use, so the promotion never happens and the component sits where the next session will not look. Findability is the point of the pool, so one consumer earns a place in it.
+
+**The exception is mechanical — a component importing from a specific route folder belongs to that route folder.** That import is what domain-coupled means, and it is decidable the moment the file is written, where consumer count cannot classify anything until a second use exists. A pool component that starts importing a route has drifted and moves down.
+
+**Pay the pollution as you go, never as scheduled cleanup:** re-read the pool before adding — something differing from an existing component by one prop is a prop, not a component — and group the pool by kind once it passes roughly fifteen flat files.
+
 ## TypeScript
 
 Every package compiles under `strict: true` and `noUncheckedIndexedAccess: true`.

package/data/harnesses/code/rules/general.md

@@ -1,6 +1,29 @@
 # General Standards
 
-Runtime versions, package policy, the API response envelope, and GitHub Actions pins — the workspace baseline.
+Runtime versions, package policy, source layout, the API response envelope, and GitHub Actions pins — the workspace baseline.
+
+## Source Layout
+
+How a package's `src/` is laid out. A single-runtime package drops `server/` and `shared/`.
+
+| Folder | Intent — what it protects | Belongs here when |
+| --- | --- | --- |
+| `app/` | The frame that survives navigation — one router, one auth gate, one shell. The property is **instance count, not importance**; without it every route reinvents the chrome, and the shell becomes where "general" code hides. | Mounted once, present on every page |
+| `surfaces/` | An address maps to one deletable folder holding its page, panels, client and private `lib/`. **One folder per route outranks file count** — a one-file route keeps its folder, because the value is that the folder list *is* the route list. | A routable destination |
+| `components/` | UI shared across the app, **and the known place anyone looks before building** — the second job is the load-bearing one, because a component nobody finds gets rebuilt and the app grows three of it that disagree. | A component importing no route folder |
+| `lib/` | The client's non-visual work — API client, session state, ids, timestamps, hooks. | Non-React logic only the client uses |
+| `shared/` | The contracts and domain logic both runtimes read, so the halves cannot drift; without it the contract is stated twice and diverges on the first change nobody propagates. | Client **and** server both import it |
+| `server/` | The other runtime as a peer in the same package — what lets a contract be a file both sides import instead of a shape both sides guess. | Runs on the server runtime |
+
+**Split by role, not by feature** — a flat `src/leads/ src/accounts/…` trades one level of depth for unbounded root breadth, and the top-level scan is what keeps a repo legible. The container **bounds** rather than classifies, so `routes/` is an equally valid name for `surfaces/` — use the word the codebase already speaks.
+
+**Never `core/`** — its membership test collapses to "is it important?", making it the queue for files nobody could place; a bare `lib/` holding everything non-visual fails the same way, which is what `shared/` prevents. A route's own nested `lib/` is private and is **never** hoisted, and **dependencies point down** — a shared folder importing one route folder is a defect.
+
+**A folder earns its place at ~4+ files, or by being a boundary somebody could delete whole.** Below that, inline it: a folder around one file is a longer filename, and a folder holding only another folder is cascade with nothing at it. Density — not depth, not root breadth — is what makes a tree read as sprawling. The boundary clause splits the one-file cases: a one-file route folder stays, a one-file component folder goes.
+
+**Never judge dead code by a name grep** — a relative import never contains its own parent's path, so `grep "x/brand"` cannot see `from "./brand/Detail"`, and every folder imported only by its parent reads as dead. Test by transitive reachability from the real entry points, resolving specifiers as the bundler does (`.ts`, `.tsx`, `.css`, `/index.ts`; strip `?raw`/`?url`; map a `.js` specifier onto its `.ts` source), running the test tree as a **second, separate** entry set — reachable from tests alone means a suite pinning code nothing ships, and both go together. Ambient `.d.ts` files enter through tsconfig `include`, so a sweep always reports them dead. A retired mechanism spans more than source — grep the build config for the same concept before calling a removal complete. **Unreachable ≠ unwanted**: a routed surface rendering dummy data is reachable and still not product, and retiring it removes a route, which is a product decision.
+
+**Reshape an existing tree largest-lever-first**, verifying typecheck plus the full suite between steps: purge unreachable files → collapse single-occupancy and pass-through folders → push domain-coupled components down → name the shared layer (the only step that adds a top-level name) → optionally add a path alias, which makes depth invisible at the import site and dissolves most "flatten it" instincts. **Delete and promote before you move** — a folder whose name misdescribes its contents just relocates the lie.
 
 ## Runtime Versions
 
@@ -10,7 +33,17 @@ Runtime versions, package policy, the API response envelope, and GitHub Actions
 
 ## Packages
 
-**Only packages in the approved table** — `.claude/hooks/approved-packages.md`, enforced by the PreToolUse install gate, which names the file on a block. The table changes only by explicit user decision.
+**The approved table is `.claude/hooks/approved-packages.md`**, enforced by the PreToolUse install gate. It records three states, and the gate treats them differently:
+
+| The package is… | What happens |
+| --- | --- |
+| in the **Package** column | installs |
+| in a **Don't use** column | **blocked**, and the block names that row's replacement — `moment` answers "use `date-fns`" |
+| in neither | **installs.** No decision exists, so there is nothing to enforce |
+
+A rejection is a decision and binds; an absence is not one and never blocks work. Unlisted packages are harvested across the fleet by the package census, and become rows — or bans — by explicit user decision. **Never edit the table to unblock yourself**; a rejection changes only on the user's say-so.
+
+Two **dev-only** installs are exempt even from the rejection check being reached: a scoped companion of an approved package (`@testing-library/react` is on the table, so `-D @testing-library/user-event` needs no row of its own) and `@types/*`.
 
 ## API Response Envelope
 

package/data/harnesses/etna/harness.json

@@ -1,12 +1,12 @@
 {
   "harness": "etna",
   "name": "etna",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "files": [
     ".prettierignore",
     ".prettierrc.json",
     ".vscode/settings.json"
   ],
   "seeds": [],
-  "digest": "615e0382294b"
+  "digest": "b76f5c26d6a9"
 }

package/data/harnesses/etna/rules/general.md

@@ -1,6 +1,29 @@
 # General Standards
 
-Runtime versions, package policy, the API response envelope, and GitHub Actions pins — the workspace baseline.
+Runtime versions, package policy, source layout, the API response envelope, and GitHub Actions pins — the workspace baseline.
+
+## Source Layout
+
+How a package's `src/` is laid out. A single-runtime package drops `server/` and `shared/`.
+
+| Folder | Intent — what it protects | Belongs here when |
+| --- | --- | --- |
+| `app/` | The frame that survives navigation — one router, one auth gate, one shell. The property is **instance count, not importance**; without it every route reinvents the chrome, and the shell becomes where "general" code hides. | Mounted once, present on every page |
+| `surfaces/` | An address maps to one deletable folder holding its page, panels, client and private `lib/`. **One folder per route outranks file count** — a one-file route keeps its folder, because the value is that the folder list *is* the route list. | A routable destination |
+| `components/` | UI shared across the app, **and the known place anyone looks before building** — the second job is the load-bearing one, because a component nobody finds gets rebuilt and the app grows three of it that disagree. | A component importing no route folder |
+| `lib/` | The client's non-visual work — API client, session state, ids, timestamps, hooks. | Non-React logic only the client uses |
+| `shared/` | The contracts and domain logic both runtimes read, so the halves cannot drift; without it the contract is stated twice and diverges on the first change nobody propagates. | Client **and** server both import it |
+| `server/` | The other runtime as a peer in the same package — what lets a contract be a file both sides import instead of a shape both sides guess. | Runs on the server runtime |
+
+**Split by role, not by feature** — a flat `src/leads/ src/accounts/…` trades one level of depth for unbounded root breadth, and the top-level scan is what keeps a repo legible. The container **bounds** rather than classifies, so `routes/` is an equally valid name for `surfaces/` — use the word the codebase already speaks.
+
+**Never `core/`** — its membership test collapses to "is it important?", making it the queue for files nobody could place; a bare `lib/` holding everything non-visual fails the same way, which is what `shared/` prevents. A route's own nested `lib/` is private and is **never** hoisted, and **dependencies point down** — a shared folder importing one route folder is a defect.
+
+**A folder earns its place at ~4+ files, or by being a boundary somebody could delete whole.** Below that, inline it: a folder around one file is a longer filename, and a folder holding only another folder is cascade with nothing at it. Density — not depth, not root breadth — is what makes a tree read as sprawling. The boundary clause splits the one-file cases: a one-file route folder stays, a one-file component folder goes.
+
+**Never judge dead code by a name grep** — a relative import never contains its own parent's path, so `grep "x/brand"` cannot see `from "./brand/Detail"`, and every folder imported only by its parent reads as dead. Test by transitive reachability from the real entry points, resolving specifiers as the bundler does (`.ts`, `.tsx`, `.css`, `/index.ts`; strip `?raw`/`?url`; map a `.js` specifier onto its `.ts` source), running the test tree as a **second, separate** entry set — reachable from tests alone means a suite pinning code nothing ships, and both go together. Ambient `.d.ts` files enter through tsconfig `include`, so a sweep always reports them dead. A retired mechanism spans more than source — grep the build config for the same concept before calling a removal complete. **Unreachable ≠ unwanted**: a routed surface rendering dummy data is reachable and still not product, and retiring it removes a route, which is a product decision.
+
+**Reshape an existing tree largest-lever-first**, verifying typecheck plus the full suite between steps: purge unreachable files → collapse single-occupancy and pass-through folders → push domain-coupled components down → name the shared layer (the only step that adds a top-level name) → optionally add a path alias, which makes depth invisible at the import site and dissolves most "flatten it" instincts. **Delete and promote before you move** — a folder whose name misdescribes its contents just relocates the lie.
 
 ## Runtime Versions
 
@@ -10,7 +33,17 @@ Runtime versions, package policy, the API response envelope, and GitHub Actions
 
 ## Packages
 
-**Only packages in the approved table** — `.claude/hooks/approved-packages.md`, enforced by the PreToolUse install gate, which names the file on a block. The table changes only by explicit user decision.
+**The approved table is `.claude/hooks/approved-packages.md`**, enforced by the PreToolUse install gate. It records three states, and the gate treats them differently:
+
+| The package is… | What happens |
+| --- | --- |
+| in the **Package** column | installs |
+| in a **Don't use** column | **blocked**, and the block names that row's replacement — `moment` answers "use `date-fns`" |
+| in neither | **installs.** No decision exists, so there is nothing to enforce |
+
+A rejection is a decision and binds; an absence is not one and never blocks work. Unlisted packages are harvested across the fleet by the package census, and become rows — or bans — by explicit user decision. **Never edit the table to unblock yourself**; a rejection changes only on the user's say-so.
+
+Two **dev-only** installs are exempt even from the rejection check being reached: a scoped companion of an approved package (`@testing-library/react` is on the table, so `-D @testing-library/user-event` needs no row of its own) and `@types/*`.
 
 ## API Response Envelope
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nurix/etna",
-    "version": "0.19.78",
+    "version": "0.19.80",
     "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": {
@@ -42,5 +42,5 @@
         "agent",
         "plugin"
     ],
-    "etnaFingerprint": "728af89f1e8e"
+    "etnaFingerprint": "f0d6766a263f"
 }