@nurix/etna 0.20.4 → 0.20.5

package/data/harness-index.json

@@ -1,5 +1,5 @@
 {
-    "fingerprint": "dfcdee7d275f",
+    "fingerprint": "e8ec199f3a00",
     "harnesses": {
         "code": {
             "plugin": "code",

package/data/harnesses/discover/harness.json

@@ -1,7 +1,7 @@
 {
   "harness": "discover",
   "name": "discover",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "files": [
     ".prettierignore",
     ".prettierrc.json",
@@ -10,5 +10,5 @@
   "seeds": [],
   "tools": [],
   "docsRoot": "docs",
-  "digest": "0bf7a6a6f479"
+  "digest": "15abe8b51cd9"
 }

package/data/harnesses/discover/rules/ingestion.md

@@ -292,6 +292,50 @@ the elements needing redaction change as you navigate.
 > redaction was real; the *frame* was never examined. **Never write a zero-PII assertion you did not verify
 > by looking at the image** — and prefer "redacted: <what>" over a blanket claim.)
 
+### 5.6 Reconstructing an ALGORITHM — differential testing, in separated layers
+
+§5.4 says what a *catalog* capture must dump. This is the extra bar for the harder case: a dimension
+that reconstructs **behaviour** — a scoring formula, a ranking function, a pricing calculation, a
+matcher, a state machine. A word list can be checked by reading it. An algorithm cannot: it is only
+`complete` once it has been **run against the live product on inputs chosen to break it**.
+
+**The rule.** A reconstructed algorithm is `partial` until:
+
+1. It is **executable** and committed to the corpus, not merely described in prose.
+2. It has been **differentially tested against the live product** on a real corpus plus deliberately
+   adversarial inputs — not only on the examples it was derived from.
+3. The test **separates the estimator from the feature extraction**, and the per-layer pass rates are
+   recorded separately. One aggregate number is not enough.
+4. The inputs and the product's own observed outputs are frozen in `raw/` (or beside the
+   implementation) as **re-runnable fixtures**, so a later run can repeat the comparison.
+
+**Why the layer split is the load-bearing part.** Almost every reconstruction has two independent
+places to be wrong — the *computation* and the *inputs fed to it*. Tested together they are
+indistinguishable, and the aggregate score points at whichever one you already suspect:
+
+- **Layer A — the estimator.** Feed the algorithm **the product's own reported feature values** and
+  check it reproduces the product's own output. This tests the mathematics alone.
+- **Layer B — the feature extraction.** Compare **your** computed features against the product's
+  reported features. This tests tokenisation / parsing / counting alone.
+- **Layer C — end-to-end.** Both together. C failing while A passes localises the fault to B in one
+  step, with no re-derivation of a formula that was already right.
+
+**A residual that survives a correct layer B is a finding about the TARGET, not an error in the
+reconstruction** — and it is often the most valuable thing the dimension produces. Chase it; do not
+tune it away. And when the target's behaviour is a defect, **do not silently replicate it** to make
+the numbers match: implement the correct behaviour by default and put bug-parity behind an explicit,
+documented flag. A reconstruction that quietly reproduces a bug teaches the next reader the bug.
+
+> (Origin: hemingway — the run shipped a "validated" reference implementation of the app's readability
+> scorer whose **formula was exactly right** and whose **tokenizer agreed with the target on only 41 of
+> 62 real inputs**. A single end-to-end comparison read as *"the model is wrong"* and would have sent
+> the run back to re-derive a correct formula. Splitting the test localised it immediately: layer A was
+> **62/62** from the first run, and `Δletters = 0` in 20 of the 21 layer-B divergences pinned the fault
+> to word/sentence segmentation, which was then reverse-engineered to **61/62**. The one residual that
+> survived a correct tokenizer was **a defect in the product** — a literal `...` silently deletes the
+> preceding text from every statistic — which no static lane could have found and which only appeared
+> because adversarial inputs were included.)
+
 ---
 
 ## 6. The shared-surface seam rule (bundle ↔ session ↔ wire-capture)
@@ -509,6 +553,11 @@ Downloading a public binary (CRX/`.asar`/`.ipa`/`.apk`) and reading its manifest
 
 A capture is complete when: `_summary.md` exists with full provenance frontmatter + honest `status`; **every Finding is backed by a `raw/` artifact — an inline value is NOT sufficient (§5.3)**; the dimension's **§5.4 dump manifest is satisfied verbatim**; `raw/` artifacts carry `_meta` (with `verbatim:` and, if bounded, `sampling:`); redaction pass run; `gaps` recorded (never fabricated).
 
+> **Algorithm reconstructions have an extra bar (§5.6):** if the dimension reconstructed *behaviour*
+> rather than a catalog, it is `partial` until the implementation is executable, differentially tested
+> against the live product with the **estimator and feature extraction scored as separate layers**, and
+> the inputs + observed outputs are frozen as re-runnable fixtures. Record the per-layer pass rates.
+
 > **Self-check before writing `status: complete`:** count the verbatim artifacts in `raw/`. If that count is **zero**, the dimension is `partial` no matter how good the prose is — you have written an essay, not a capture. If a Finding names a number, a path, a version, or a field, open the file that contains it; if no such file exists, write it now (§5.3).
 
 **Summary-first + bounded, visible fan-out (never go silent long enough to look dead).** Write a `status: partial` `_summary.md` with whatever is mined so far **before** any long-tail fetch loop (downloading many chunks, crawling many pages, deep pagination), then enrich it in place and flip to `complete`. **Bound** every fan-out — cap it by count / total bytes / wall-time (e.g. ≤40 items or ≤90 s) and record the remainder as a `gap` rather than fetching exhaustively; emit a progress note per batch. A collector that fetches everything before writing anything can run many times longer than its siblings and read as hung to the orchestrator, forcing a needless salvage. Partial-but-finalized beats complete-but-silent.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nurix/etna",
-  "version": "0.20.4",
+  "version": "0.20.5",
   "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": "dfcdee7d275f"
+  "etnaFingerprint": "e8ec199f3a00"
 }