docs(site,skills): promote BYOD + cross-reference older skills

Two follow-ups to the substrate-complete state.

Site: add a "Bring Your Own Data" section between Query+Policy and
Capabilities.  The differentiator story now reads coherently from
the homepage: structural baseline -> queryable through Rayfall ->
extensible through CSV import + vector primitives -> enforceable
through .rfl policy packs.  Four feature cards explain external
signals as tables, vector search as policy, the shared sym-table
join semantics, and the live progress on stderr.  Code block shows
the canonical "join coverage.csv with temporal_hotspots" recipe with
inline highlight spans matching the rest of the site palette.
Section alternation rebalanced: BYOD slots in as section-alt, with
capabilities flipping to plain and languages flipping to alt to
keep the pattern.

llms.txt mirrors the new content for crawlers: a "Bring your own
data" section covering CSV import + cos-dist / knn / hnsw-build /
ann, plus a "Live progress" section noting the stderr-only
throttled feedback channel for long Rayfall queries.

Skills: the four phase-scoped skills (bootstrap / impact / verify /
audit) predate Lanes A/G/H so an agent reading any of them today
gets no signal that baseline_query / policy_check / import_csv even
exist.  Add a "See also" section to each with the cross-references
relevant to that phase:

  bootstrap  -> raysense-query, policy_check, import_csv
                (everything the bootstrap baseline now unlocks)
  impact     -> Datalog reaches, .graph.shortest-path, ad-hoc
                joins for author-weighted blast radius
  verify     -> policy_check (alongside check_rules)
  audit      -> .graph.pagerank / louvain / betweenness for
                centrality audits, import_csv for external audit
                data

Each cross-reference is one short paragraph -- enough to plant the
seed for the SkillRouter, not enough to bloat the host skill.  No
behavior changes; pure documentation surface.

Author: singaraiona

claude-plugin/skills/raysense-audit/SKILL.md

@@ -42,4 +42,19 @@ land better.
 - The user asked a narrow question. Use `raysense-impact` or a
   single targeted MCP call instead.
 - The repo is tiny (under ~50 files). The audit will produce mostly
-  noise — just call `raysense_health` and read out the grade.
+  noise -- just call `raysense_health` and read out the grade.
+
+## See also
+
+The audit's typed tools surface what raysense already knows.  When
+the user asks an audit-shaped question that doesn't fit a typed
+tool, the **raysense-query** skill exposes Rayfall directly via
+`raysense_baseline_query`:
+
+- Custom architectural breakdowns -- group calls by caller module,
+  count cross-layer imports, find ownership-by-language splits.
+- `.graph.pagerank` / `.graph.louvain` / `.graph.betweenness` over
+  call_edges or module_edges for centrality-based audits.
+- `raysense_baseline_import_csv` to bring external audit data
+  (coverage, lint counts, test runtime) into the same query
+  substrate as the structural baseline.

claude-plugin/skills/raysense-bootstrap/SKILL.md

@@ -40,10 +40,24 @@ After bootstrap, the agent should remember (briefly):
 
 ## When to skip
 
-- Session is read-only (the user just asked a question — no edits
+- Session is read-only (the user just asked a question -- no edits
   planned). Skip bootstrap; reach for `raysense-audit` instead if
   structural context is needed.
 - A baseline already exists from a recent session and no commits have
   landed since (`git log -1 --since='1 hour ago'` shows nothing).
   Re-using the previous baseline is fine; just call `raysense_health`
   for a fresh grade and skip the rest.
+
+## See also
+
+The baseline this skill produces is queryable, not just a dump.
+After bootstrap, the agent has access to:
+
+- `raysense_baseline_query` -- run any Rayfall expression against a
+  saved table.  Syntax and worked examples in the **raysense-query**
+  skill (select / `.graph.*` / Datalog / vector search).
+- `raysense_policy_check` -- evaluate `.rfl` policy packs in
+  `<repo>/.raysense/policies/`; ships its own exit-code semantics for
+  CI gating.
+- `raysense_baseline_import_csv` -- bring external CSVs (coverage,
+  lint counts, embeddings) into the baseline as queryable tables.

claude-plugin/skills/raysense-impact/SKILL.md

@@ -46,3 +46,18 @@ the target file path relative to that root.
 - Local-only edit inside one file with no signature changes (typo
   fix, comment, internal rename). No downstream effect, no need.
 - Brand-new file. Nothing depends on it yet.
+
+## See also
+
+For cases the typed tools above don't cover, the **raysense-query**
+skill exposes Rayfall directly via `raysense_baseline_query`:
+
+- Custom reachability rules through Datalog -- declarative
+  `(reaches ?a ?b)` plus a recursive arm gives the same shape as
+  `raysense_blast_radius` but with a rule the agent picks at query
+  time.
+- `.graph.shortest-path` / `.graph.k-shortest` for path-aware impact
+  ("which call paths reach this entry point") that go beyond the
+  blast-radius set.
+- Ad-hoc joins between `call_edges` and `change_coupling` /
+  `file_ownership` to weight blast radius by author / commit history.

claude-plugin/skills/raysense-verify/SKILL.md

@@ -45,3 +45,18 @@ report is:
   affect imports.
 - The session bootstrapped less than a minute ago and the working
   tree shows trivial changes (`git diff --stat` is one or two lines).
+
+## See also
+
+For verify checks the typed tools don't cover natively:
+
+- `raysense_policy_check` -- evaluates `.rfl` files in
+  `<repo>/.raysense/policies/`.  Use this when the team has shipped
+  custom architectural rules; they fire alongside the built-in
+  `raysense_check_rules` but are code-reviewable in the repo.  Exit
+  code 1 = a policy itself failed to evaluate, 2 = at least one
+  error-severity finding.
+- `raysense_baseline_query` -- the **raysense-query** skill covers
+  the syntax.  Useful when a verify-time question is shaped like "did
+  any new file land that violates X" and X needs a custom Rayfall
+  expression.

site/index.html

@@ -313,7 +313,49 @@ <h3>Composable across history</h3>
   </div>
 </section>
 
-<section class="section section-alt">
+<section id="byod" class="section section-alt">
+  <div class="container">
+    <div class="section-eyebrow">BRING YOUR OWN DATA</div>
+    <h2>Coverage. Lint counts. Embeddings. Same query language.</h2>
+    <p class="section-lead">
+      Drop a CSV; it joins the baseline.  First row is headers, column types are inferred, and the shared symbol table means cross-table predicates like <code>(in path (at coverage 'path))</code> work without ETL.  Vector primitives - <code>cos-dist</code>, <code>l2-dist</code>, <code>knn</code>, <code>hnsw-build</code>, <code>ann</code> - are built into Rayfall, so embeddings imported alongside the structural baseline serve semantic similarity from the same query expression that drives policy gates.
+    </p>
+
+    <div class="code-block code-block-wide">
+      <div class="code-block-head">join coverage.csv with raysense's own temporal hotspots</div>
+<pre><code><span class="hl-cmt">$</span> <span class="hl-kw">raysense</span> baseline import-csv coverage <span class="hl-str">./coverage.csv</span>
+<span class="hl-cmt">  imported ./coverage.csv -&gt; .raysense/baseline/tables/coverage</span>
+
+<span class="hl-cmt">$</span> <span class="hl-kw">raysense</span> baseline query temporal_hotspots \
+    <span class="hl-str">'(select {from: t
+              where: (in path
+                         (at (select {from: coverage where: (&lt; covered_pct 50)})
+                             (quote path)))
+              desc: risk_score})'</span></code></pre>
+    </div>
+
+    <div class="feature-grid">
+      <div class="feature-card">
+        <h3>External signals as tables</h3>
+        <p>Coverage, lint counts, error budgets, runtime traces, ownership-from-elsewhere - any CSV becomes addressable from <code>baseline query</code>, <code>policy check</code>, and the MCP tools.  Subsequent re-imports overwrite cleanly; the schema-version stamp keeps stale baselines from silently mis-rendering.</p>
+      </div>
+      <div class="feature-card">
+        <h3>Vector search as policy</h3>
+        <p>Pair CSV import with embeddings: <code>cos-dist</code> for direct similarity, <code>knn</code> for brute-force scans on small sets, <code>hnsw-build</code> + <code>ann</code> for sub-linear queries on &gt;10k vectors.  An <code>.rfl</code> policy that flags near-duplicate functions is six lines.</p>
+      </div>
+      <div class="feature-card">
+        <h3>One sym table, one schema</h3>
+        <p>Imported tables share the baseline's interned-string space, so <code>path</code> in <code>coverage</code> and <code>path</code> in <code>files</code> point to the same sym ID.  Joins are predicate equality, not ETL plumbing - and the schema-version stamp catches imports against an out-of-date baseline directory.</p>
+      </div>
+      <div class="feature-card">
+        <h3>Live progress on stderr</h3>
+        <p>Long Rayfall queries print throttled progress lines to stderr - <code>op_name</code>, <code>phase</code>, <code>rows_done / rows_total</code>, elapsed seconds, memory used.  JSON callers stay byte-clean; humans on a TTY get the live signal.  Quick queries (under 200ms) stay silent by design.</p>
+      </div>
+    </div>
+  </div>
+</section>
+
+<section class="section">
   <div class="container">
     <div class="section-eyebrow">CAPABILITIES</div>
     <h2>Beyond the score.</h2>
@@ -359,7 +401,7 @@ <h3>69 languages out of the box</h3>
   </div>
 </section>
 
-<section id="languages" class="section">
+<section id="languages" class="section section-alt">
   <div class="container">
     <div class="section-eyebrow">LANGUAGE COVERAGE</div>
     <h2>69 languages, three tiers of analysis depth.</h2>

site/llms.txt

@@ -57,6 +57,21 @@ Every saved baseline is a queryable columnar database. Two surfaces share one su
 
 A policy is just a Rayfall expression that returns a table with columns severity, code, path, message. Empty result table = policy passed.
 
+## Bring your own data
+
+Drop a CSV; it joins the baseline.  `raysense baseline import-csv <name> <path>` (CLI) or `raysense_baseline_import_csv` (MCP) reads the CSV with first-row headers, infers column types, and writes it as a splayed table alongside the built-in ones.  Subsequent queries can join across imported and built-in tables because they share the baseline's interned-string sym table - `path` in an imported coverage CSV points to the same sym ID as `path` in the structural `files` table.
+
+Vector primitives are built into Rayfall:
+- `cos-dist` / `l2-dist` / `inner-prod` / `norm` for direct similarity.
+- `knn` for brute-force nearest-neighbor over a list of candidate vectors; returns a (_rowid, _dist) table sorted ascending.
+- `hnsw-build` / `ann` / `hnsw-save` / `hnsw-load` / `hnsw-info` for sub-linear approximate-nearest-neighbor on >10k vector spaces.
+
+Pair the two: import an embeddings CSV (file_id + e0..eN columns), build an HNSW index, and ship a `.rfl` policy that flags near-duplicate functions or finds the most-similar files to a target.  Vector search becomes a CI gate without a separate service.
+
+## Live progress
+
+Long Rayfall queries (group-by aggregations, pivots) emit throttled progress lines on stderr from the CLI surfaces - `[rayfall] op / phase  rows_done / rows_total  elapsed=Xs  mem=YMB`.  JSON callers (--json, MCP, pipes) stay byte-clean.  Quick queries under 200ms emit nothing.
+
 ## Capabilities beyond the score
 
 - Live treemap dashboard. Every file, every metric, every cycle, refreshed on save.