@nurix/etna 0.15.1 → 0.15.3

package/data/harnesses/re/agents/wire-capture.md

@@ -0,0 +1,91 @@
+---
+name: wire-capture
+description: Dimension dumper for the GATED WIRE-CAPTURE dimension of the Product Recon Harness. Climbs the 3-rung lowest-privilege-first ladder (browser tap → HAR → user-run mitmproxy) to record what a non-browser/no-source client *actually* calls, redacting every body before disk. Dispatched during Ingestion (Mode 2) — not invoked directly by users.
+tools: Read, Write, Bash
+model: inherit
+---
+
+# wire-capture — the gated runtime wire dimension
+
+You dump what a target's client **actually puts on the wire** into
+`research/<target>/dimensions/wire-capture/`. Read `.claude/rules/re-ingestion.md` (repo root)
+first — especially **§7.1** (the 3-rung ladder), §6 (the shared api-path-catalog seam), and the
+redaction rules. You obey it absolutely. This is the **runtime complement** to
+`distribution-artifacts`: the binary says what hosts it *might* call; you record what it *does*.
+
+This dimension is **GATED**. Like `session`, the *live* capture is interactive and
+main-session-driven — the user routes their own client and you ingest exported flows. You apply
+the playbook, author the captures from what's already been collected, and **flag higher rungs for
+user authorization** rather than escalating on your own.
+
+## Inputs (from the dispatch prompt)
+- target slug + the output dir `research/<target>/dimensions/wire-capture/`,
+- the **authorized rung** (1 / 2 / 3) and, for rung 3, the explicit chat authorization + the
+  first-party client the user owns and has agreed to route,
+- any already-collected inputs: a Chrome tap log, an exported `*.har`, or a user-exported
+  mitmproxy flow dump (`.mitm`/JSON) — paths under `research/<target>/`.
+
+## Strategy — the 3-rung ladder, lowest privilege first
+
+Pick the **lowest rung that answers the question** and record it + the authorization in `_meta`.
+Never climb without explicit per-rung authorization in chat.
+
+1. **Rung 1 — browser network tap (default, unauth).** `method: wire-tap-browser`, confidence
+   **low** (shapes only). Chrome `read_network_requests` + an in-page fetch/XHR interceptor over
+   the **public** surface only — no login. Capture request/response *shapes* (method, path, status,
+   content-type, body skeleton), not values. This is the default when an unauth SPA makes
+   structured XHRs worth a tap.
+2. **Rung 2 — HAR export.** `method: wire-har`, confidence **medium**. Ingest a DevTools HAR the
+   user exported. Parse with `jq`: `jq '.log.entries[] | {method:.request.method, url:.request.url,
+   status:.response.status}' app.har`. Digest to an endpoint catalog; scrub `Authorization`,
+   `Cookie`, `Set-Cookie`, and every secret-shaped header/field before anything touches disk.
+3. **Rung 3 — mitmproxy (GATED · opt-in · USER-RUN · TOS-checked).** `method: wire-mitmproxy`,
+   confidence **medium**. **ONLY** first-party traffic the **user owns** (their own desktop/mobile/
+   CLI client), **ONLY** with explicit chat authorization, **ONLY** after the target's TOS is
+   checked. You **NEVER install a CA and NEVER intercept third-party traffic** — the *user* installs
+   the CA, routes *their* client, and exports flows; you only ingest the export
+   (`mitmdump -nr flows -w -` then digest, or read the user's JSON dump). Same explicit-authorization
+   loop as session Pass-2. If unauthorized, stop and flag it — do not proceed.
+
+**Wireshark / packet capture is explicitly NOT used** — for HTTPS it yields only TLS ciphertext,
+and a packet sweep of a third party is the bright line this harness will not cross.
+
+**Redact every body before disk.** Run the §7 + §7.1 redaction pass on each flow *before* writing:
+strip `Authorization`/`Cookie`/`Set-Cookie`, collapse credential-shaped fields to
+`<REDACTED:...>`, decode JWT *structure* only with identity claims removed, and log every redaction
+in the artifact `_meta.redactions`. Over-redact when unsure.
+
+## Output
+
+Write `research/<target>/dimensions/wire-capture/_summary.md` with the **provenance
+frontmatter** (`dimension: wire-capture`, `target`, `status`, `access_grade_used: runtime:reachable`,
+`method` = the rung actually used, `completeness_pct`, `confidence` per the rung mapping above,
+`captured_at`, `sources`, `gaps`). Body: **Method** (which rung, why that rung, what was skipped),
+**Findings** (the live endpoints, envelope shape, auth scheme, hosts contacted — as tables),
+**Inferences** (mark inference vs. fact — e.g. a host implies a vendor), **Open questions**,
+**Artifacts**.
+
+Then the captures + raw artifacts (per `re-discovery` Part C (wire-capture)):
+- `captures/wire-narrative.md` — the decoded story: what the client does on the wire, in order.
+- `raw/flows.json` — verbatim-but-**redacted and digested** flows, each with the `_meta` header
+  (incl. `kind`, `byte_length`, `redactions[]`, and the **chosen rung + authorization**), `body`,
+  `_decoded`. Digest large captures (schema + one redacted sample + counts), never paste megabytes.
+- `raw/api-path-catalog.md` — the **shared-surface artifact** (§6): every row carries
+  `source: wire`. Use this exact filename so evaluation can three-way diff it against `bundle` and
+  `session` rows.
+- `curls.md` — reproducer `curl` skeletons with all credentials replaced by placeholders.
+
+## Return value
+
+Return a **one-paragraph headline** of what the wire reveals — the real hosts contacted, the
+envelope/auth scheme, and the rung used (so the reader knows how much to trust it). Then a compact
+table of observed endpoints. **Flag the seam rule (§6):** every `api-path-catalog.md` row is
+`source: wire`, so evaluation can diff *actually-called* (wire) against *statically-declared*
+(`bundle` / `distribution-artifacts`) and *browser-observed* (`session`) — a host or path the
+binary declares but the wire never hits is a finding, not noise; the inverse (called but
+undeclared) is a stronger one. If only rung 1 was authorized, say so and name what rungs 2/3 would
+unlock so the main session can request authorization.
+
+**Discipline:** lowest privilege first; never self-escalate the ladder; never install a CA or tap
+third-party traffic; never run Wireshark; redact every body before disk and log it in `_meta`. An
+unauthorized higher rung is an Open question, not an excuse to guess what the wire would show.

package/data/harnesses/re/harness.json

@@ -0,0 +1,6 @@
+{
+  "name": "re",
+  "version": "0.1.0",
+  "epoch": null,
+  "digest": "04de463436b5"
+}

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

@@ -0,0 +1,266 @@
+# Discovery Reference — Scope Gate · Access Vector · Dimension Catalog
+
+The reference knowledge for **Discovery** (`re` harness, Mode 1). It carries all three of
+Discovery's steps in the order they run:
+
+- **Part A — Scope-feasibility gate** (Step 0): resolve the target's identity and emit a verdict
+  so the run never wastes effort on an infeasible target.
+- **Part B — Access vector** (Step 1): grade the four-axis capability vector that decides which
+  dimensions are reachable and which method each uses.
+- **Part C — Dimension catalog** (Step 2): the canonical list of dimensions, their detection
+  signals, dump strategy, and owning agent.
+
+`ingestion` also reads **Part C** to dispatch the right agent with the right method.
+
+---
+
+# Part A — Scope-feasibility gate (Step 0)
+
+Run this **before** any dimension probing. It resolves the target's identity and emits one of four
+verdicts. The rules are mechanical — execute them with cheap probes (`WebSearch`, `curl`,
+`git ls-remote`, `npm view`) in well under a minute.
+
+Output: `research/<target>/00-scope-verdict.md` + a `scope:` block in `00-recon-plan.md`. If the
+verdict is not `accept`, Discovery **halts** (presents the narrowing prompt, or refuses) and does
+not proceed to dimension probing.
+
+## Verdicts
+
+| Verdict | Meaning | Downstream |
+|---------|---------|-----------|
+| **accept** | bounded target with ≥1 real surface | continue to dimension probing |
+| **narrow** | too-broad-suite or ambiguous-name | present the narrowing prompt; halt for user reply |
+| **redirect** | a commodity primitive (behavior = its public spec) | offer a facet menu; halt for user reply |
+| **refuse** | ethically/legally out-of-bounds (hard stop only here) | stop; no run |
+
+A **no-reachable-surface** result is a **soft prompt** ("log in / give me a URL or repo"), not a
+hard refuse — only the ethics gate (Gate B) is a hard refuse.
+
+## The decision algorithm (priority-ordered; first match wins)
+
+**0a — Resolve identity.** If the user gave a concrete URL/repo/package, identity is fixed → skip
+ambiguity. Else `WebSearch "<target>"` + `"<target> software"`; collect canonical homepage, vendor,
+one-line category.
+
+**Gate A — ambiguity.** Top results map to ≥2 unrelated vendors/categories → `narrow` (disambiguate). STOP.
+
+**Gate B — ethics.** Resolved product is piracy/cracking/malware/CSAM/credential-harvesting/spyware,
+or the only way in is bypassing auth/paywall/TOS the user has no right to → `refuse` (ethics). STOP.
+*(Highest priority once identity is known — never proceed on an out-of-bounds target even if reachable.)*
+
+**Gate C — suite size.** Fetch homepage; count distinct independently-marketed products N (nav
+"Products" items each with their own `/pricing` or `/docs` tree; or a `WebSearch "<target> products"`
+grid). If N ≥ 4 **OR** the entity is on the umbrella seed list → `narrow` (pick-product). STOP.
+> Umbrella seed list: AWS, Azure, GCP, Salesforce, Microsoft 365, SAP, Oracle Cloud, Google
+> Workspace, Adobe Creative Cloud, Atlassian.
+> Guard against false positives: "one platform, many *modules* sharing one account/API/pricing page"
+> (Stripe: Payments/Billing/Connect) is **one product → accept**, not a suite. The N≥4 count alone
+> isn't enough — require separate pricing/docs trees, not just a broad nav.
+
+**Gate D — primitive.** Target is a single foundational building block whose behavior is a published
+spec with no hidden app surface (managed primitives like S3/EC2/Lambda; single-purpose util libs
+with <~5 exports; protocol/spec names; a raw DB engine) → `redirect` (pick-facet). STOP.
+> Bias: only `redirect` when behavior is fully a public spec. When a hosted SaaS wrapper exists
+> (Redis Cloud, MongoDB Atlas), prefer `accept` on the wrapper.
+
+**Gate E — reachability.** Run the cheapest probe per dimension as a boolean (does ANY surface
+exist?): `git ls-remote` OR npm/PyPI hit OR `llms.txt`/docs subdomain OR homepage-200-with-content
+OR user-has-session. If ZERO surfaces → **soft prompt** ("No reachable surface — log in, or give me
+a repo/docs/URL"). If exactly one thin non-session surface → `accept` (thin) with a shallow-coverage
+warning.
+
+**Fallthrough → `accept`.** Compute the access vector (Part B) and proceed to dimension probing.
+
+**Recursion:** a narrowed pick re-enters Step 0 (so "Salesforce → Marketing Cloud" is itself
+feasibility-checked and may narrow again). **Max narrow-depth = 2**, then accept-the-narrowest with
+a partial-coverage warning.
+
+## `00-scope-verdict.md` shape
+
+```markdown
+---
+target: <slug>
+scope_checked_at: <YYYY-MM-DD>
+verdict: accept | narrow | redirect | refuse
+verdict_reason: clean | too-broad-suite | primitive | ambiguous-name | no-surface | ethics | over-scoped
+resolved_identity: <canonical homepage / repo / package>
+suite_product_count: <N>
+surfaces_present: [codebase?, docs?, api?, website?, session?]
+awaiting_user: <true|false>
+---
+# <Target> — Scope Verdict: <VERDICT>
+## Resolution        (what the name resolved to + evidence)
+## Gate trace        (which gate fired A–E + the verbatim signal)
+## Verdict & reason
+## Narrowing prompt   (if narrow/redirect — the exact question + options)
+## If refused         (one-line reason + what would make it acceptable)
+```
+Mirror `verdict` into a `scope:` frontmatter block on `00-recon-plan.md` so ingestion reads one field.
+
+## Narrowing prompt templates
+
+**NARROW-SUITE (Gate C):** "I can recon a focused product, but **<Target>** is a suite of ~<N>
+independently-built products — a single run would be shallow across all of them. Which one should I
+tear down?" + a numbered list auto-built from the homepage product nav, each tagged with its likely
+access-grade. Always append "0. A specific feature within one of these (tell me which)."
+
+**NARROW-DISAMBIGUATE (Gate A):** "**<Target>** resolves to more than one product. Which did you
+mean?" + numbered candidates (vendor · one-line · URL) + "none of these — give me a URL."
+
+**REDIRECT-PRIMITIVE (Gate D):** "**<Target>** is a documented primitive, not a product with hidden
+internals — its behavior is the public spec. I can still recon a facet. Which angle?" + a facet menu
+(for a managed service: console/dashboard UX · public API surface · consistency/semantics model ·
+pricing & limits as a product · competitive positioning) + "Or point me at a real product that USES
+<Target> and I'll recon that instead."
+
+## Worked verdicts (regression fixtures)
+
+| Target | Gate | Verdict | Note |
+|--------|------|---------|------|
+| AWS S3 | D | redirect (primitive) | "behavior is the public API; pick a facet or a product built on S3" |
+| Salesforce | C | narrow (suite) | "pick a cloud: Sales / Service / Marketing / Flow Builder / Apex / …" |
+| Microsoft 365 | C | narrow (suite) | umbrella seed list; options Word/Excel/Teams/… each tagged |
+| Notion | fallthrough | accept | single product; docs+api+website+session, no public monorepo |
+| Liveblocks | fallthrough | accept (Case 1) | open monorepo + SDKs + docs + OpenAPI + site + session |
+| bare "Atlas" | A | narrow (ambiguous) | MongoDB Atlas vs Ory Atlas vs Palantir |
+| leftpad-class util | D | redirect (primitive) | "<5 exports; source IS the spec" |
+| coming-soon splash, no session | E | soft prompt | "no reachable surface — log in or give me a repo/URL" |
+| torrent/credential-stuffing service | B | refuse (ethics) | no prompt, no run |
+
+---
+
+# Part B — Access is a capability VECTOR (Step 1)
+
+A target's "access" is **four orthogonal axes**, each carrying `{value, confidence, evidence}`.
+The vector — not a single grade — decides which dimensions are reachable and which extraction
+*method* each uses.
+
+| Axis | Values | Unlocks dimensions | Anchors |
+|------|--------|--------------------|---------|
+| **source** | full · partial · none | codebase, packages | *Case 1* (full = OSS repo) |
+| **runtime** | reachable · gated · none | deployed-client-bundle, api, infra-backend-fingerprint, wire-capture | *Case 2* (reachable + source:none) |
+| **auth** | have-login · none | session | *Case 3* (have-login) |
+| **presence** | rich · thin · none | docs, website, community | (almost always rich) |
+
+The three named **cases** are presets over this vector — a target can light several at once
+(Liveblocks = source:full + runtime:reachable + auth:obtainable + presence:rich → nearly all
+dimensions). Rules:
+- **`auth:obtainable` is a hint, not actionable** — the harness never self-signs-up; it only counts as `have-login` if the *user* hands over a session.
+- **Dimension-level access overrides the target headline** for method selection (a Case-1 target can still have a Case-3 session dimension).
+- Method swaps on axis *value*: `source:full` ⇒ `clone-and-map`; `source:partial` ⇒ `source-map-reassembly`; `runtime:reachable + source:none` ⇒ `bundle-string-mine` + wire-capture.
+
+Discovery records the resolved vector in the `access_grade` frontmatter of `00-recon-plan.md`.
+
+---
+
+# Part C — The dimension catalog (Step 2)
+
+| # | Dimension | Agent | Unlocking axis | One-line strategy |
+|---|-----------|-------|----------------|-------------------|
+| 1 | **codebase** | `codebase` | source:full | clone → structural map → per-package fan-out |
+| 2 | **docs** | `docs` | presence | `llms.txt` → else crawl/clip → organize by section |
+| 3 | **packages** | `packages` | source/presence | registry metadata + exports + type defs |
+| 4 | **api** | `api` | runtime/presence | OpenAPI/GraphQL → endpoint catalog (+ **MCP/tool-catalog fold-in**) |
+| 5 | **website** | `website` | presence | crawl public pages → features, pricing, positioning |
+| 6 | **community** | `community` | presence | first-party changelog/issues/discord themes |
+| 7 | **session** | `session` | auth:have-login | delegate to the session playbook (§9 of `re-ingestion`: 3-pass, P0–P6) |
+| 8 | **deployed-client-bundle** | `deployed-client-bundle` | runtime:reachable | unauth SPA: route table, API-path catalog, flags, env, source maps |
+| 9 | **infra-backend-fingerprint** | `infra-backend-fingerprint` | runtime/presence | DNS, cert-transparency, CDN/cloud, headers (+ **sub-processor/trust fold-in**) |
+| 10 | **wire-capture** | `wire-capture` | runtime (source:none) | the 3-rung ladder for non-browser/no-source clients (gated) |
+| 11 | **distribution-artifacts** | `distribution-artifacts` | runtime (non-web client) | extension CRX / Electron `.asar` / mobile binary / CLI |
+
+> **Deferred (available on request, not built):** `external-reputation` (G2/Reddit/HN — the only
+> "what others say" surface) and `hiring-intel` (job posts leak the backend stack). Strong
+> candidates, declined for this iteration. Re-add via self-correction if a run needs them.
+
+An **absent** dimension is a finding — record it with its evidence; never silently drop it.
+
+## 1–7 — the core dimensions (strategy in brief)
+
+See git history / the source playbook for the full strategy text; in brief:
+- **codebase** — shallow-clone into `source/<target>/`, read orientation files + manifests, map
+  packages + internal dep hierarchy, return a per-package work-list for the main-session fan-out.
+- **docs** — prefer in-repo docs, then `llms.txt`/`llms-full.txt`, then crawl; organize by section.
+- **packages** — per public package: registry metadata, `exports` map + `.d.ts` type surface, health.
+- **api** — fetch the spec verbatim, build an endpoint catalog (auth, envelope, pagination, webhooks).
+  **NEW fold-in:** also probe MCP/tool surfaces — `/.well-known/mcp`, an MCP server manifest, a
+  function-calling tool schema, an LLM "actions" file — and write `raw/tool-catalog.md` (an MCP tool
+  list *is* an API catalog; it lives here, not in its own dimension).
+- **website** — crawl home/features/pricing/customers/integrations; extract positioning, pricing
+  matrix, target market.
+- **community** — *first-party only*: changelog cadence + direction, issue/discussion themes, blog.
+- **session** — the deepest, opt-in, user-gated dimension; delegates to the session playbook in
+  `re-ingestion` §9 (3-pass, P0–P6, captures/raw/curls).
+
+## 8 — deployed-client-bundle — `deployed-client-bundle`
+
+**Unlocked by:** `runtime:reachable`. The **unauthenticated app shell** — distinct from `website`
+(marketing) and `session` (authenticated). Works on closed SaaS with no repo and no login.
+
+**Detection:** an app subdomain (`app.<target>.*`) or SPA route serves a JS bundle;
+`sourceMappingURL` present; a `/assets/*.js` graph.
+
+**Strategy:** fetch the main bundle(s); string-mine the **route table**, the **API-path catalog**
+(→ shared `raw/api-path-catalog.md`, `source: bundle`), **feature flags** (→ shared
+`raw/feature-flags.md`), embedded **env config** (`VITE_*`, `NEXT_PUBLIC_*`, public keys —
+field-names only, redact values), and reassemble **source maps** if shipped (`method:
+source-map-reassembly`, confidence high). Digest huge bundles, don't paste.
+
+**Artifacts:** `_summary.md` + `raw/{route-table.md, api-path-catalog.md, feature-flags.md, env-config.md, bundle-map.md}`.
+
+## 9 — infra-backend-fingerprint — `infra-backend-fingerprint`
+
+**Unlocked by:** `runtime`/`presence`. Reconstructs the backend you can't see in the repo.
+
+**Detection:** always attemptable for any live domain.
+
+**Strategy:** DNS records; **cert-transparency subdomain enumeration** (crt.sh → staging/internal/
+api hosts); CDN/cloud fingerprint (CNAMEs, IP/ASN, response headers); security headers; tech
+fingerprint (framework/analytics tells). **Sub-processor fold-in:** fetch the `/legal`, `/trust`,
+`/security`, `/dpa` pages → `raw/sub-processors.md` — the sub-processor list **names the vendor
+stack** (cloud, payments, AI provider, email, telephony), which is exactly this dimension's job.
+
+**Artifacts:** `_summary.md` + `raw/{dns-and-subdomains.md, cloud-cdn-fingerprint.md, security-headers.md, sub-processors.md}`.
+
+## 10 — wire-capture — `wire-capture` (first-class, GATED)
+
+**Unlocked by:** `runtime` when the interesting client is **non-browser** or there's **no source**
+(your Case 2). The runtime-evidence complement to `distribution-artifacts` (static): the binary says
+what hosts it *might* call; the capture says what it *actually* calls.
+
+**Detection:** a non-browser client exists (from distribution-artifacts) OR an unauth SPA makes
+structured XHRs worth a tap, AND the appropriate ethics rung is authorized.
+
+**Strategy:** the **3-rung ladder** (lowest privilege first) — see `re-ingestion` §7.1:
+1. browser network tap (unauth, default) → `wire-tap-browser`;
+2. HAR export → `wire-har`;
+3. mitmproxy (**gated, opt-in, user-run, first-party traffic only**) → `wire-mitmproxy`.
+
+**Artifacts:** `_summary.md` + `captures/wire-narrative.md` + `raw/{flows.json (redacted/digested), api-path-catalog.md (source: wire)}` + `curls.md`. Record the chosen rung + authorization in `_meta`.
+
+## 11 — distribution-artifacts — `distribution-artifacts`
+
+**Unlocked by:** `runtime` (a downloadable non-web client). Often the closest thing to source for a
+closed product.
+
+**Detection:** a Chrome/Firefox web-store listing; a "Download for Mac/Windows" (Electron/Tauri)
+button; an App Store / Play Store listing; a published CLI (`npm i -g`, brew, GitHub releases).
+
+**Strategy:** **extension** — decode `manifest.json` (permissions/hosts/content-scripts = a
+capability map). **Electron** — `npx asar extract app.asar` → map JS modules + the shared
+route/API/flag catalog from the desktop client (often richer than web). **mobile** — `Info.plist`/
+`AndroidManifest` hosts, ATS exceptions, embedded-SDK list from strings (**redact any embedded
+keys**). **CLI** — help text/subcommands = an API catalog. Read the artifact's EULA first (see
+`re-ingestion` §7.2); never silently decompile a restrictively-licensed binary.
+
+**Artifacts:** `_summary.md` + `raw/{extension-manifest.md, electron-asar-map.md, mobile-strings.md, cli-catalog.md}` (whichever apply) + `raw/api-path-catalog.md` (source: distribution).
+
+---
+
+## How Discovery uses this reference
+
+Step 0 — run **Part A** (the gate); halt unless `accept`. Step 1 — grade the **Part B** vector with
+evidence. Step 2 — for each dimension in **Part C**, check its unlocking axis against the resolved
+vector, run the cheap detection probe, and record **available / partial / absent** with evidence
+into `00-recon-plan.md`. Gated dimensions (session, wire-capture rung 3) are flagged for user
+confirmation before ingestion dispatches them.

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

@@ -0,0 +1,100 @@
+# Evaluation Templates
+
+`evaluation` reads every `dimensions/<dim>/_summary.md` (its **provenance frontmatter** +
+Findings) and reconciles them into **cross-dimension** documents under
+`research/<target>/evaluation/`. The value is the reconciliation — cross-checking views into one
+coherent picture, **weighted by how each claim was obtained**, with disagreements flagged.
+
+**Three rules for every evaluation doc:**
+1. **Anchor + tag every claim** with its dimension *and provenance*: `(api: raw/endpoint-catalog.md
+   · openapi-verbatim · high)`. The method + confidence come verbatim from the source dimension's
+   `_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**.
+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.
+
+**Independence (for the promotion rule):** `codebase`, `api`, `session`, `wire-capture`,
+`distribution-artifacts` are mutually independent and independent of marketing. **`website` and
+`docs` are NOT independent** for *feature claims* (docs often restate marketing) — two of them
+agreeing is still one source. A bundle-declared route + a session-observed route ARE independent.
+
+**Presentation mapping:** high → stated as fact; low/single-source → hedged as tentative;
+conflicted → flagged. (This is the "lighter" form of the provenance-weighting — done inline in the
+prose, not via a separate `claims.yaml`.)
+
+---
+
+## 1. `evaluation/technology-architecture.md`
+```markdown
+# <Target> — Technology & Architecture
+## TL;DR                  (3–5 sentences; the single most distinctive choice)
+## Stack                  (languages/frameworks/build/runtime — table, each anchored+tagged)
+## Architecture           (client/server split, packages+deps, runtime/sync/data model, transport)
+## How it's built         (monorepo layout, public/private, codegen, CI, release cadence)
+## Notable design choices  (the 3–5 worth stealing + why)
+## Cross-dimension reconciliation  (agreements/disagreements + confidence per claim)
+## Open questions
+```
+
+## 2. `evaluation/product-features.md`
+```markdown
+# <Target> — Product Features & Capabilities
+## What it does           (one paragraph)
+## Feature map            (every capability · user · maturity GA/beta/docs-only — anchored+tagged)
+## User-facing surfaces   (dashboard/editor/components/CLI/widgets)
+## User journeys          (the 2–3 primary flows end-to-end)
+## Gaps & rough edges     (from community signal)
+## Cross-dimension reconciliation  (marketing claims vs. what code/docs actually support — flag over-claims)
+```
+
+## 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)
+## 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)
+## Cross-dimension reconciliation  (published surface [api/packages/docs] vs observed wire [session/
+                            wire-capture]; document drift — published=fact, observed-drift=tentative)
+## Open questions
+```
+
+## 4. `evaluation/competitive-positioning.md`
+```markdown
+# <Target> — Competitive Positioning
+## Positioning            (their pitch + market — website/blog)
+## Pricing & packaging    (plans, what gates what, unit economics — website pricing + platform/limits)
+## Differentiation        (claimed moat vs the teardown's read of the real moat — often infra/data)
+## Alternatives & comparison  (named competitors + how it differs)
+## Strategic read         (direction from changelog/blog)
+```
+
+---
+
+## 5. `research/<target>/README.md` — the run story
+```markdown
+# <Target> — Recon Run
+> One paragraph: what it is + why we ran recon.
+## Access grade           (the resolved vector — source/runtime/auth/presence — + matched case[s])
+## Dimensions covered     (table: dimension | status | method | confidence | headline finding)
+## Headline findings      (5–10, each anchored+tagged)
+## How to navigate         (00-scope-verdict.md, 00-recon-plan.md, dimensions/, evaluation/, 04-self-correction-proposal.md)
+## Lessons                 (candidate methodology learnings → feed self-correction)
+## Reproduction
+```
+
+---
+
+## Evaluation method
+1. Read every `dimensions/*/_summary.md` frontmatter first (the provenance index) — note method +
+   confidence + status + gaps per dimension.
+2. Read Findings; drop into specific `raw/` artifacts only when a claim needs a precise value.
+3. Draft the four rollups + the README — each rollup may be drafted by its own sub-agent dispatched
+   from the **main session** (overlapping reads, independent writes), then a single reconciliation
+   pass keeps them consistent.
+4. Tag every claim with provenance; weight per the rules above; flag every disagreement; record
+   every gap. A confident doc built on one low-confidence dimension is worse than an honest
+   "single-source, unverified."