@nurix/etna 0.15.4 → 0.15.6

package/bin/etna.js

@@ -186,32 +186,45 @@ async function main(args) {
     const targetDir = process.cwd();
     const claudeMdDest = join(targetDir, 'CLAUDE.md');
 
-    console.log(`\nInstalling ${pluginName} into ${targetDir}`);
+    // Read the bundled epoch marker up front so the install banner can name the
+    // harness version; the file itself is copied into the project further down.
+    const bundledHarnessJson = join(bundledHarnessDir, 'harness.json');
+    const harnessMeta = existsSync(bundledHarnessJson) ? readJson(bundledHarnessJson) : {};
+    const versionTag = harnessMeta.version ? ` v${harnessMeta.version}` : '';
+
+    console.log(`\nInstalling ${pluginName}${versionTag} into ${targetDir}`);
 
     const claudeBackup = backupIfExists(claudeMdDest);
     if (claudeBackup) console.log(`  backed up existing CLAUDE.md → ${claudeBackup}`);
 
     // CLAUDE.md ships frontmatter-free (the harness's metadata lives in its index.md and the
     // plugin's definition.md), so it installs as a verbatim copy — no stripping.
+    // Tracks the categories actually present in this harness, for the closing
+    // summary — so a harness that ships no skills or hooks reads as an explicit,
+    // honest list rather than a silently missing line.
+    const installed = [];
+
     cpSync(bundledClaudeMd, claudeMdDest, { force: true });
     console.log(`  installed CLAUDE.md → ${claudeMdDest}`);
+    installed.push('CLAUDE.md');
 
     for (const sub of PLUGIN_SUBDIRS) {
         const count = copyHarnessSubdir(
             join(bundledHarnessDir, sub),
             join(targetDir, '.claude', sub),
         );
-        if (count > 0) console.log(`  copied ${count} ${sub} → ${targetDir}/.claude/${sub}/`);
+        if (count > 0) {
+            console.log(`  copied ${count} ${sub} → ${targetDir}/.claude/${sub}/`);
+            installed.push(`${count} ${sub}`);
+        }
     }
 
     // Copy the epoch marker so harness-manager can resolve the installed epoch.
-    const bundledHarnessJson = join(bundledHarnessDir, 'harness.json');
     if (existsSync(bundledHarnessJson)) {
         const harnessJsonDest = join(targetDir, '.claude', 'harness.json');
         mkdirSync(dirname(harnessJsonDest), { recursive: true });
         cpSync(bundledHarnessJson, harnessJsonDest, { force: true });
-        const meta = readJson(harnessJsonDest);
-        const tag = [meta.version && `v${meta.version}`, meta.epoch && `epoch ${meta.epoch}`]
+        const tag = [harnessMeta.version && `v${harnessMeta.version}`, harnessMeta.epoch && `epoch ${harnessMeta.epoch}`]
             .filter(Boolean)
             .join(', ');
         console.log(`  installed harness.json → ${harnessJsonDest}${tag ? ` (${tag})` : ''}`);
@@ -226,8 +239,10 @@ async function main(args) {
     const migrated = migrateFromPluginInstall(targetDir, pluginName);
     for (const entry of migrated) console.log(`  removed stale ${entry}`);
 
-    console.log(`\nDone. Open Claude Code in ${targetDir}.`);
-    console.log(`Re-run \`npx @nurix/etna ${pluginName}\` anytime to refresh harness content.\n`);
+    console.log(`\nDone — ${pluginName}${versionTag} installed: ${installed.join(', ')}.`);
+    console.log(
+        `Open Claude Code in ${targetDir}. Re-run \`npx @nurix/etna ${pluginName}\` anytime to refresh harness content.\n`,
+    );
 }
 
 main(process.argv.slice(2)).catch((e) => {

package/data/harness-index.json

@@ -1,5 +1,5 @@
 {
-    "fingerprint": "be67d356d0f6",
+    "fingerprint": "ef554a39d069",
     "plugins": {
         "code": "code",
         "kb-agi": "kb-agi",

package/data/harnesses/re/CLAUDE.md

@@ -69,11 +69,18 @@ method · confidence · completeness · gaps) + `raw/`, obeying `.claude/rules/r
 
 - **Run independents in parallel** — dispatch `docs`, `packages`, `api`, `website`, `community`,
   `deployed-client-bundle`, `infra-backend-fingerprint`, `distribution-artifacts` together
-  (`subagent_type='<dimension>'`, one message, multiple Agent calls).
+  (`subagent_type='<dimension>'`, one message, multiple Agent calls). Seed each dumper with **warm
+  entry points (URLs / repos / hosts), not claimed facts** — any fact carried from Discovery (a price,
+  a tier name, a version) is tagged `verify:may-be-stale` so the dumper re-derives it instead of
+  anchoring on a possibly-stale value. Only one dimension may drive the browser at a time (see
+  `re-ingestion` §7 rule 9): the parallel dumpers use WebFetch/curl, leaving Chrome to `session`.
 - **Codebase fan-out** — dispatch `codebase`; it clones + maps + returns a per-package work-list;
   then the main session fans out one reader per substantial package.
 - **Gated dimensions** — `session` and `wire-capture` (rung ≥2) need explicit user authorization
-  first (see `re-ingestion` §7). `session` follows `.claude/rules/re-ingestion.md` §9.
+  first (see `re-ingestion` §7). `session` follows `.claude/rules/re-ingestion.md` §9. When `session`
+  is authorized, **dispatch the non-browser dumpers in the background (`run_in_background`) and drive
+  the gated browser session in the main session concurrently** — they don't contend (Chrome belongs to
+  the main session; the dumpers use WebFetch/curl), so the whole of Ingestion runs in parallel.
 - **Shared seam** — bundle/session/wire each contribute to the canonical `raw/api-path-catalog.md`
   with a `source:` column; don't triplicate.
 

package/data/harnesses/re/agents/deployed-client-bundle.md

@@ -27,6 +27,12 @@ the endpoints it will call, and the flags it gates behind.
    pull every `<script src>` and `<link rel=modulepreload>`. Vite/Next ship hashed
    `/assets/*.js` and `/_next/static/chunks/*.js`. Grab the entry chunk + the largest vendor
    chunk; `curl -s <chunk-url> -o raw/.work/<name>.js`. Note `Content-Length` per chunk.
+   **Bound this — do NOT exhaustively fetch every lazy chunk.** The route table and the GraphQL/op
+   registry live in the entry + `_app` + a registry chunk; grab those plus the largest few vendor
+   chunks (cap ~40 chunks / ~5 MB / 90 s), and record the rest as a `gap`. Fetching all lazy chunks
+   (often 90+, multi-MB) can run 3–4× a sibling dumper and read as hung. **Per §8, write a
+   `status: partial` `_summary.md` from the entry/manifest chunks BEFORE the wider fetch loop**, then
+   enrich and flip to `complete`.
 2. **Check for source maps FIRST.** Grep each chunk for `//# sourceMappingURL=`. If present,
    fetch the `.map` and reassemble original sources (`npx source-map-explorer` or unpack
    `sourcesContent` from the JSON map). A live map flips you to `method: source-map-reassembly,

package/data/harnesses/re/agents/infra-backend-fingerprint.md

@@ -95,3 +95,12 @@ any CT-leaked host worth a `wire-capture` or `deployed-client-bundle` follow-up.
 crt.sh/WHOIS rate limits and back off; redact any credential-shaped value before writing (contract
 §7 rule 3 — DSNs, verification tokens, embedded keys surfaced in headers/TXT). An unresolvable host or a
 missing sub-processor page is an Open question, not a guess.
+
+**Verify an absence before asserting it (contract §7 rule 10).** Before reporting any host as
+**NXDOMAIN / absent** — especially `api.<target>` or any host a sibling dimension (bundle / session /
+wire) reports actually hitting — re-resolve via a **second resolver** (`dig @1.1.1.1 <host>`,
+`dig @8.8.8.8 <host>`) **and** a direct `curl -sI https://<host>`. An HTTP 4xx/5xx response means the
+host **resolves** → report it **present**, not absent. A single negative resolver result is recorded as
+*tentative*, never stated as fact and never used to instruct sibling dimensions. Likewise, an *inferred*
+backend engine (e.g. "looks like Hasura/Supabase from the CNAME") is phrased as an inference and yields to
+a runtime-observing dimension (`session`/`deployed-client-bundle`) that names the engine directly.

package/data/harnesses/re/harness.json

@@ -2,5 +2,5 @@
   "name": "re",
   "version": "0.1.2",
   "epoch": null,
-  "digest": "f5dda6cb5667"
+  "digest": "29a864bc5245"
 }

package/data/harnesses/re/rules/re-evaluation.md

@@ -11,7 +11,11 @@ coherent picture, **weighted by how each claim was obtained**, with disagreement
    `_summary.md` frontmatter.
 2. **Weight, don't average.** A claim's confidence = the **max** of its sources' confidence,
    **promoted one band only if corroborated by ≥2 *independent* dimensions**, capped at source
-   confidence when single-source. Conflicts are **flagged, never averaged**.
+   confidence when single-source. Conflicts are **flagged, never averaged**. **Tiebreaker — direct
+   observation outranks inference.** When two sources conflict on the *same* fact, a directly-observed
+   value beats an inferred one regardless of dimension or stated confidence (a session-observed backend
+   engine beats a DNS-inferred one; a live HTTP probe beats a single NXDOMAIN result). The inferred
+   side is rendered tentative and never used to override the observation or to issue cross-dimension directives.
 3. **Cross-check, don't concatenate.** Agree → state as fact. Disagree / single-source / low-conf →
    render hedged ("observed but unverified…") and flag in the doc's reconciliation section.
 
@@ -52,8 +56,10 @@ prose, not via a separate `claims.yaml`.)
 ## 3. `evaluation/data-model-api-surface.md`
 ```markdown
 # <Target> — Data Model & API / SDK Surface
-## Core entities          (domain objects + relations; ER-style)
-## Integration surface    (SDK/packages public API · REST/HTTP catalog · realtime/wire protocol)
+## Core entities          (domain objects + relations; ER-style — when the runtime exposes an RBAC verb
+                           taxonomy, derive the entity set from it: `X_CREATE/VIEW/EDIT/DELETE` ⇒ entity X)
+## Integration surface    (SDK/packages public API · REST/HTTP catalog · realtime/wire protocol — flag
+                           where the app's OWN API differs from the published/developer API; that split is common)
 ## Auth & tenancy model   (token type, where it lives, scope expression)
 ## Three-way API-path diff (the seam rule: bundle-declared vs session-observed vs wire-observed —
                             dormant/unshipped routes are findings)

package/data/harnesses/re/rules/re-ingestion.md

@@ -123,6 +123,12 @@ flags**. To keep them consumable instead of triplicated:
   in `data-model-api-surface.md`. A path that appears in `bundle` but never in `session`/`wire` is a
   dormant/unshipped route — a finding, not noise.
 
+> **Published API ≠ the app's own API.** A product's developer/REST/MCP surface (`api`/`docs`/`packages`
+> dims) is frequently *not* the API its own app runs on (`session`/`bundle` dims) — different protocol,
+> host, and operation set. Always diff the two: operations the app uses but the public API omits, **and**
+> public operations the app never calls, are both findings. The published surface is the integration
+> story; the runtime surface is the real architecture.
+
 ---
 
 ## 7. Ethics & redaction (non-negotiable — binds EVERY dimension)
@@ -137,6 +143,9 @@ Carried from the source playbook (`setup.md` §6). Violating them voids the work
 6. **No bypassing safety harnesses** — redact, never evade.
 7. **No exfiltration.** Captures stay local under `research/<target>/`.
 8. **Respect TOS & robots.** For spec-writing / integration / competitive analysis — not credential theft, rate-limit bypass, or scraping.
+9. **One browser-driving dimension at a time.** Chrome MCP is a shared singleton. Only the gated `session`/`wire-capture` dimensions drive the browser; parallel non-browser dumpers use WebFetch/curl, or — if a page genuinely needs a real browser — create their **own** tab and never touch the session tab. Never run two browser-driving dumpers concurrently.
+10. **Verify an absence before asserting it.** A "host is NXDOMAIN / dimension is absent / endpoint 404s everywhere" claim that would *contradict another dimension* must be re-checked by a **second method** (alternate resolver, direct HTTP probe, second source) before it is written as fact. A single-resolver/single-probe negative is recorded as *tentative*, never as a cross-dimension directive. (An HTTP 4xx/5xx means the host **resolves** — present, not absent.)
+11. **Bounded live-token use (read-only, in-page only).** To fill a Pass-1 capture gap you MAY read the live token from its store and replay a **read-only** request with it — *only* if the token is used **in-page / in-process only**, is **never written to `raw/`, never returned, never logged**, and the replay changes no state. This is the single permitted touch of a live credential; rules 2–3 (shape-not-values, never-save-secrets) still bind everything written to disk.
 
 ### 7.1 wire-capture & active-interception ethics (the strictest tier)
 
@@ -170,6 +179,15 @@ A dump is complete when: `_summary.md` exists with full provenance frontmatter +
 every Finding is backed by a `raw/` artifact or inline value; `raw/` artifacts have `_meta` +
 decoding (large ones digested); redaction pass run; `gaps` recorded (never fabricated).
 
+**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 dumper 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.
+
 ---
 
 ## 9. The session dimension — logged-in browser-session playbook
@@ -201,7 +219,11 @@ project, conversation, account, order), mine it first. Hit every list/state/hist
 the existing token; capture verbatim bodies. This yields ~70% of the spec for free. Mine, by role:
 identity (`/me`, `/account`, `/workspaces`), list (the canonical taxonomy), single-resource state
 (server-injected vs client-sent fields), history/event-log (a whole trajectory in one call),
-runtime/preview state, per-resource billing, account billing, feature flags/cohort, integration
+runtime/preview state, per-resource billing, account billing, feature flags/cohort, **the account's
+`entitlements`/`permissions` arrays** (the single richest data-model artifact — `entitlements`/`features`
+enumerate every gated feature *including ones your plan hides*; `permissions` are CRUD-verbs-per-entity,
+so the verb set enumerates the domain entity set — `X_CREATE/VIEW/EDIT/DELETE` ⇒ entity `X`; mine these
+first), integration
 catalog (`/mcp/`, `/integrations/`), and schema/capabilities (`/openapi.json`, `/.well-known/*`,
 `/page-metadata`).
 
@@ -222,24 +244,59 @@ The same phases apply whether the target is an AI builder, analytics dashboard,
 
 | Phase | Focus |
 |-------|-------|
-| **P0 Surface** | routes, bundles, storage shape, the API host(s), the auth tell |
-| **P1 Auth** | token type + issuer + storage location + refresh path; tenancy model |
+| **P0 Surface** | routes, bundles, storage shape, the API host(s), the auth tell; build the **coverage checklist** from any route/op catalog a sibling declared (§9.4) |
+| **P1 Auth** | token type + issuer + storage location + refresh path; tenancy model; **disambiguate the transport by omission** (replay one authed read with each credential mechanism dropped) — and never test auth with a schema-only field |
 | **P2 Core action** | the primary write — the submit/create body and its server resolution |
-| **P3 Streaming** | the realtime transport (WS / SSE / WebChannel / Pusher / none) + event catalog |
+| **P3 Streaming** | the realtime transport (WS / SSE / WebChannel / Pusher / none) + event catalog; **fingerprint binary frames by signature, never log them as opaque** (§9.4) |
 | **P4 Runtime/state** | sandbox/preview/build/deploy state; the live result surface |
 | **P5 Iteration** | the follow-up/edit endpoint (often surprisingly named) + any auto-iteration loop |
 | **P6 Synthesis** | reconcile into the dimension's `_summary.md` + `captures/` + `curls.md` |
 
 ### 9.4 Runtime taps (Pass-1 instrumentation, run in-page)
 
+> **Install the in-page interceptor FIRST, then move section-to-section WITHOUT a full reload.**
+> CDP `read_network_requests` is unreliable for an already-loaded single-page app: it starts tracking
+> only when first called and silently misses requests already in flight or served from cache (seen on a
+> real run where only a third-party analytics beacon was captured while the app's own API calls went
+> unseen). Treat it as a *supplement*; the in-page interceptor is the primary capture. A full-page
+> `navigate` wipes the interceptor, so traverse the app using whatever it exposes — **clicking in-app
+> nav works on any stack**; or call the client router if one is reachable (`history.pushState`+`popstate`,
+> React Router / Vue Router / Angular Router, or a globally-exposed router such as `window.next.router`
+> on Next.js). The principle is framework-agnostic; the specific call is just whatever that app ships.
+
 - **WebSocket / EventSource / fetch+XHR interceptors** — wrap the constructors/methods to log
   URLs, frames, and bodies (shapes, not secrets — redact in the wrapper before anything reaches
   disk). Add a `SCRUB(value)` step inside the fetch wrapper so credentials never reach the harness.
+  **Never log a binary frame as opaque `<binary>`.** Any realtime/streaming/collab layer (token
+  streams, CRDT/OT edits, presence, telemetry, game or market state) may ship `ArrayBuffer`/`Blob`
+  frames; for each *distinct* frame capture its **byte-length + a hex dump of the first ~16 bytes** —
+  enough to fingerprint the wire format (protobuf, MessagePack, CBOR, Yjs/CRDT, gRPC-web, or a
+  text/topic-prefixed channel protocol) without recording content. **Decode the signature as ASCII
+  first** — many "binary" protocols are framed text (STOMP, Phoenix, Centrifugo, a `+topic` channel
+  prefix), so a legible prefix names the protocol in one step before a binary-codec guess. The frame
+  *signature* is the finding; the payload is not.
 - **Storage shape inspector** — enumerate localStorage / sessionStorage / cookies / IndexedDB
   **key names + lengths**, never raw values.
 - **JWT decoder** — decode the token *structure* (alg, claim names, exp) with identity claims
   (`sub`, `email`, `phone`, `user_id`, `uid`, `sid`) redacted.
-- If a Pusher/realtime SDK is loaded, bind a global listener to capture the event catalog.
+- **Auth-channel disambiguation.** Token *location* is itself a tell: not in localStorage ⇒ an httpOnly
+  cookie **or** an SDK store (IndexedDB — Firebase/Auth0/Supabase/Cognito keep tokens there, which is why
+  a "no JWT in localStorage" result is a finding, not a dead end). Determine the *required* transport by
+  **omission**: replay one harmless authed read — using a field that needs the authed context (`viewer`/
+  `me`), **never** a schema-only field (GraphQL `__typename`, a health route) that resolves
+  unauthenticated — with each candidate credential dropped (cookie-only, then header-only); whichever
+  response comes back unauthorized names the channel the app actually requires.
+- If a realtime SDK is loaded (Pusher, Ably, Socket.IO, Centrifugo, Phoenix, …), bind a global listener
+  to capture the event/channel catalog.
+- **Third-party-SDK fingerprint** (cross-checks `infra-backend-fingerprint`). Storage key names + the
+  network host list name the embedded vendor stack — auth (Firebase/Auth0), flags (LaunchDarkly/Statsig),
+  support (Intercom/Zendesk/Ada), analytics (Segment/Amplitude/Datadog), payments (Stripe). Record them;
+  they corroborate the sub-processor list *independently* (a different dimension → promotes confidence).
+- **Drive op coverage from any catalog a sibling declared.** If `deployed-client-bundle` (or `api`/`docs`)
+  recovered a declared **route / endpoint / operation catalog** — a REST path table, a GraphQL operation
+  set, an RPC/tool method list — consume it as a **coverage checklist**: walk the routes/actions that
+  trigger the un-observed entries so the declared-vs-observed diff (§6) reflects a real walk, not just the
+  landing page.
 
 ### 9.5 The capture contract (richer than a standard dimension dump)
 
@@ -254,6 +311,10 @@ Under `research/<target>/dimensions/session/`:
   redacted) + `_decoded_fields`. Digest bodies > 50 KB into a structured summary.
 - **`curls.md`** — reproducible curl per endpoint, the auth model documented, a variables block,
   and an endpoint-catalog table.
+- **`captures/screens/`** (recommended) — one annotated screenshot per primary surface (each major nav
+  section), plus a short tour recording if useful. The fastest "what does it actually do" artifact for a
+  human reader, complementing the wire teardown — and the place the visual product map lives. Redact any
+  visible PII before saving.
 - **`_summary.md`** — the standard dimension bridge file (provenance frontmatter per §2) pointing
   into the above, so Evaluation treats session like any other dimension. `method: session-playbook`,
   `confidence: low` for Pass-1-only/inferred.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nurix/etna",
-    "version": "0.15.4",
+    "version": "0.15.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": {