chore: sanitize internal hostnames + cargo fmt + gitignore markdown-explorer

Replaces internal Gitea URLs (gitea.neuralempowerment.xyz,
git-ssh.neuralempowerment.xyz) with the public GitHub URLs.
Removes personal email from Cargo.toml authors. Applies cargo fmt
across the codebase. Adds markdown-explorer/ to .gitignore.

A follow-up filter-repo pass scrubs PII from past commit blobs.

Author: NeuralEmpowerment

.gitignore

@@ -19,3 +19,4 @@ experiments/
 /eval.jsonl
 /hard_negatives.jsonl
 /router.toml
+markdown-explorer/

CLAUDE.md

@@ -21,7 +21,7 @@ cargo test --test integration           # one integration file
 cargo test --test routing_test
 cargo test <name>                       # filter by test name
 
-# Run the CLI (mock embedder by default — no network/model download)
+# Run the CLI (mock embedder by default: no network/model download)
 cargo run -- route "Help me debug this Python error"
 cargo run -- routes
 cargo run -- info
@@ -43,14 +43,14 @@ Single binary + library crate. `src/lib.rs` exposes `SemanticRouter`; `src/main.
 1. `storage::load_examples` reads `routes.jsonl`; `embed_examples` produces `EmbeddedExample`s. Same for `hard_negatives.jsonl` → `EmbeddedHardNegative`.
 2. `embedding::EmbeddingProvider` (trait) embeds the input; `normalize` makes cosine = dot product.
 3. `scoring::score_routes` groups example similarities by route, averages the top-K, then subtracts a penalty for nearby hard negatives (`hard_negative_penalty` × max sim to any hard-negative).
-4. `decision::make_decision` applies `minimum_score` and `minimum_margin` from config and emits a `RouteDecision` with status (`accepted` / `ambiguous` / `below_threshold` / `needs_review`) and candidate scores. semrouter is a pure classifier — risk assessment and confirmation gating belong in the consumer's plugin layer, not here.
+4. `decision::make_decision` applies `minimum_score` and `minimum_margin` from config and emits a `RouteDecision` with status (`accepted` / `ambiguous` / `below_threshold` / `needs_review`) and candidate scores. semrouter is a pure classifier: risk assessment and confirmation gating belong in the consumer's plugin layer, not here.
 
 **Embedders** (`src/embedding.rs`):
-- `MockEmbedder` — 64-dim keyword-bag, deterministic, no network. Used by tests and as CLI default. Score range ~0.25–0.60.
-- `FastEmbedEmbedder` — local ONNX `AllMiniLML6V2` via `fastembed` crate, 384-dim. Caches model under `.fastembed_cache/`. Score range ~0.22–0.62.
-- `HttpEmbedder` — OpenAI-compatible `/v1/embeddings`. Endpoint from `[embedding].endpoint` in `router.toml` or `OPENAI_BASE_URL` env var.
+- `MockEmbedder`: 64-dim keyword-bag, deterministic, no network. Used by tests and as CLI default. Score range ~0.25–0.60.
+- `FastEmbedEmbedder`: local ONNX `AllMiniLML6V2` via `fastembed` crate, 384-dim. Caches model under `.fastembed_cache/`. Score range ~0.22–0.62.
+- `HttpEmbedder`: OpenAI-compatible `/v1/embeddings`. Endpoint from `[embedding].endpoint` in `router.toml` or `OPENAI_BASE_URL` env var.
 
-Thresholds in `router.toml` are tuned **per embedder**. The committed values target `fastembed` (`minimum_score = 0.22`, `minimum_margin = 0.005`); for `mock` use ~0.25 / 0.04. Changing embedder usually means re-tuning thresholds and re-running `eval`.
+Thresholds in `router.toml` are tuned **per embedder**. The committed values target `fastembed` (`minimum_score = 0.22`, `minimum_margin = 0.005`). For `mock`, use ~0.25 / 0.04. Changing embedder usually means re-tuning thresholds and re-running `eval`.
 
 **Eval / experiments** (`src/eval.rs`, `src/experiment.rs`): `eval` command computes accuracy, top-2 accuracy, per-route precision/recall/F1, and confusion pairs against `eval.jsonl`. `--save-experiment` writes a timestamped JSON snapshot (config + metrics + embedder label) into `experiments/` for cross-run comparison.
 
@@ -60,12 +60,12 @@ Thresholds in `router.toml` are tuned **per embedder**. The committed values tar
 |---|---|
 | `router.toml` | Thresholds, embedder config, storage paths |
 | `routes.jsonl` | Labeled examples (source of truth for routing) |
-| `hard_negatives.jsonl` | Counter-examples — penalize routes that match these |
+| `hard_negatives.jsonl` | Counter-examples that penalize routes which match them |
 | `eval.jsonl` | Held-out `{text, expected_route}` pairs for `cargo run -- eval` |
 | `experiments/` | Saved eval runs (gitted) |
 | `pocs/POC-NNN/` | Phase-by-phase proof-of-concept writeups |
 
-There is no `feedback.jsonl` / `decisions.jsonl` / `index/` yet — those are reserved for later phases (see README "Implementation Phases").
+There is no `feedback.jsonl` / `decisions.jsonl` / `index/` yet; those are reserved for later phases (see README "Implementation Phases").
 
 ## Testing principles
 
@@ -76,4 +76,8 @@ There is no `feedback.jsonl` / `decisions.jsonl` / `index/` yet — those are re
 
 - Errors flow through `RouterError` (`src/error.rs`); `main.rs` prints and `exit(1)`s on each command boundary.
 - All vectors are unit-normalized before scoring. If you add a new embedder, normalize in the provider or rely on the `normalize()` call in `SemanticRouter::route`.
-- `storage::load_examples` skips blank lines and surfaces parse errors with line numbers — keep that behavior when extending JSONL formats.
+- `storage::load_examples` skips blank lines and surfaces parse errors with line numbers; keep that behavior when extending JSONL formats.
+
+## Writing style
+
+**No em dashes (—) anywhere in source, docs, or commit messages.** Restructure the sentence instead: use a colon for an explanation, a comma for a brief aside, parentheses for a parenthetical, or split into two sentences. This applies to all Markdown, Rust doc comments, code comments, README, CHANGELOG, ADRs, and PR descriptions. En dashes (–) in numeric ranges like `0.25–0.60` are fine.

Cargo.toml

@@ -2,7 +2,7 @@
 name = "semrouter"
 version = "0.1.1"
 edition = "2021"
-authors = ["AgentParadise <***REDACTED***>"]
+authors = ["AgentParadise"]
 description = "File-based semantic vector router for agent/model/workflow dispatch. Zero default deps."
 license = "MIT"
 repository = "https://github.com/AgentParadise/semrouter"

README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="https://raw.githubusercontent.com/AgentParadise/semrouter/main/assets/banner-v1.png" alt="semrouter — Semantic Routing Engine" />
+  <img src="https://raw.githubusercontent.com/AgentParadise/semrouter/main/assets/banner-v1.png" alt="semrouter: Semantic Routing Engine" />
 </p>
 
 # semrouter
@@ -8,28 +8,28 @@
 [![crates.io](https://img.shields.io/crates/v/semrouter.svg)](https://crates.io/crates/semrouter)
 [![docs.rs](https://docs.rs/semrouter/badge.svg)](https://docs.rs/semrouter)
 
-A lightweight, file-based semantic router for agent / model / workflow dispatch. Routes input text to a labeled route by comparing embeddings against a curated set of examples. **Zero default dependencies beyond `serde`, `serde_json`, `toml`, and `thiserror`** — bundle a local embedder via the `fastembed` feature, or bring your own. No LLM in the hot path. Sub-millisecond routing.
+A lightweight, file-based semantic router for agent / model / workflow dispatch. Routes input text to a labeled route by comparing embeddings against a curated set of examples. **Zero default dependencies beyond `serde`, `serde_json`, `toml`, and `thiserror`.** Bundle a local embedder via the `fastembed` feature, or bring your own. No LLM in the hot path. Sub-millisecond routing.
 
 <p align="center">
   <img src="https://raw.githubusercontent.com/AgentParadise/semrouter/main/assets/flow-diagram.svg" alt="semrouter routing pipeline: input text → embed → cosine vs. examples → top-K per route → threshold + margin → decision" />
 </p>
 
 ## Why
 
-If you're building an AI agent, voice assistant, or workflow system, you need to dispatch user input to one of N specialized handlers. The naive options — keyword matching (brittle), LLM classifier (slow, expensive, cloud round-trip) — both have real costs. semrouter splits the difference: a tiny local embedding model gives you semantic understanding, and a flat file of labeled examples gives you a router you can edit and version-control.
+If you're building an AI agent, voice assistant, or workflow system, you need to dispatch user input to one of N specialized handlers. The naive options, keyword matching (brittle) and LLM classifier (slow, expensive, cloud round-trip), both have real costs. semrouter splits the difference: a tiny local embedding model gives you semantic understanding, and a flat file of labeled examples gives you a router you can edit and version-control.
 
-semrouter is a **pure classifier**. Risk classification, confirmation prompts, and dispatch live in your application — they don't belong in the router. This separation keeps risk policies next to the code that actually runs the dangerous thing.
+semrouter is a **pure classifier**. Risk classification, confirmation prompts, and dispatch live in your application; they don't belong in the router. This separation keeps risk policies next to the code that actually runs the dangerous thing.
 
 ## Install
 
-**Batteries-included (default — bundles fastembed local embedder):**
+**Batteries-included (default, bundles fastembed local embedder):**
 
 ```toml
 [dependencies]
 semrouter = "0.1"
 ```
 
-**Lean (lib only — bring your own `EmbeddingProvider`):**
+**Lean (lib only, bring your own `EmbeddingProvider`):**
 
 ```toml
 [dependencies]
@@ -125,7 +125,7 @@ impl EmbeddingProvider for OpenAIEmbedder {
 }
 ```
 
-That's the full HTTP-embedder surface. semrouter doesn't ship one because every consumer wants different things from their HTTP client (retry, batching, observability) — pick yours.
+That's the full HTTP-embedder surface. semrouter doesn't ship one because every consumer wants different things from their HTTP client (retry, batching, observability); pick yours.
 
 ## Decision shape
 
@@ -200,16 +200,16 @@ The 9.1% "incorrect" cases are correctly routed to the `direct_llm` fallback int
 
 ## Status
 
-semrouter is **pre-1.0**. The public API surface is unstable — minor version bumps may include breaking changes. Pin to a specific version (`semrouter = "=0.1.1"`) for exact reproducibility.
+semrouter is **pre-1.0**. The public API surface is unstable; minor version bumps may include breaking changes. Pin to a specific version (`semrouter = "=0.1.1"`) for exact reproducibility.
 
 `v1.0.0` will freeze the API.
 
 ## Roadmap
 
-- **v0.2.0** — Configurable embedder. Pick any fastembed-supported model from `router.toml` (`fastembed/AllMiniLML6V2`, `fastembed/BGESmallENV15`, `fastembed/MiniLML12V2`, etc.) with a tradeoff guide in docs.
-- **v0.3.0** — Closed-loop learning. `semrouter tag` (interactive CLI to mark recent decisions correct/wrong) + `semrouter promote` (ingest tagged feedback as new routing examples + run `EvalSuite` to gate regression). The router gets better the more you use it.
-- **v1.0.0** — API freeze + crates.io 1.0.
+- **v0.2.0**: Configurable embedder. Pick any fastembed-supported model from `router.toml` (`fastembed/AllMiniLML6V2`, `fastembed/BGESmallENV15`, `fastembed/MiniLML12V2`, etc.) with a tradeoff guide in docs.
+- **v0.3.0**: Closed-loop learning. `semrouter tag` (interactive CLI to mark recent decisions correct/wrong) + `semrouter promote` (ingest tagged feedback as new routing examples + run `EvalSuite` to gate regression). The router gets better the more you use it.
+- **v1.0.0**: API freeze + crates.io 1.0.
 
 ## License
 
-MIT — see [LICENSE](LICENSE).
+MIT. See [LICENSE](LICENSE).

docs/ADRs/0001-zero-dependencies-goal.md

@@ -4,9 +4,9 @@
 
 ## Context
 
-Rust crates that target the AI/agent ecosystem often pull in 200+ transitive dependencies — async runtimes, HTTP clients, JSON/YAML/TOML parsers, ML frameworks, etc. Each transitive dep is a build-time cost (cold builds, CI minutes), a security surface (supply-chain attacks, CVEs to track), and a friction point for downstream consumers (especially those targeting embedded, WASM, or constrained CI environments).
+Rust crates that target the AI/agent ecosystem often pull in 200+ transitive dependencies: async runtimes, HTTP clients, JSON/YAML/TOML parsers, ML frameworks, etc. Each transitive dep is a build-time cost (cold builds, CI minutes), a security surface (supply-chain attacks, CVEs to track), and a friction point for downstream consumers (especially those targeting embedded, WASM, or constrained CI environments).
 
-semrouter is a small library — at its core, it does:
+semrouter is a small library. At its core, it does:
 1. Read JSONL + TOML files
 2. Compute cosine similarity between embedding vectors
 3. Apply thresholds and emit a decision struct
@@ -17,7 +17,7 @@ The pre-v0.1.1 dep tree was 254 transitive crates, dominated by fastembed (190),
 
 ## Decision
 
-**The default dep tree must stay minimal — under 25 transitive crates for `default-features = false` builds.** Every dependency must justify its existence:
+**The default dep tree must stay minimal: under 25 transitive crates for `default-features = false` builds.** Every dependency must justify its existence:
 
 1. **Mandatory deps** (`serde`, `serde_json`, `toml`, `thiserror`): the data model is JSONL + TOML, and consumers need typed errors. ~12 transitive crates total.
 2. **Optional deps behind feature flags** (`fastembed`, `clap`): batteries-included for users who want them, opt-out for users who don't.
@@ -29,7 +29,7 @@ CI enforces this with a regression guard: the `lean-build` job runs `cargo tree
 
 - **`anyhow`** in the library. Public APIs deserve typed errors (`thiserror::Error` enums). `anyhow` is fine in binaries; not in library code.
 - **`chrono`** for timestamps. `std::time::SystemTime` plus a 60-line `civil_from_days` helper covers our needs (ISO-8601 + compact filename formats).
-- **`reqwest` / `tokio`** for HTTP embedding. semrouter is not async; its hot path is dot-product math. A user wanting an HTTP-backed embedder implements the public `EmbeddingProvider` trait themselves — the surface is one method, easy to roll with `ureq` (~5 deps) or whatever client they prefer.
+- **`reqwest` / `tokio`** for HTTP embedding. semrouter is not async; its hot path is dot-product math. A user wanting an HTTP-backed embedder implements the public `EmbeddingProvider` trait themselves: the surface is one method, easy to roll with `ureq` (~5 deps) or whatever client they prefer.
 - **`async_trait`** (entire ecosystem). `EmbeddingProvider::embed` is sync. Async-in-sync via `tokio::runtime::Runtime::new().block_on(...)` is a smell; we removed it.
 
 ## Consequences
@@ -49,7 +49,7 @@ CI enforces this with a regression guard: the `lean-build` job runs `cargo tree
 
 ### Neutral
 
-- `fastembed` (default-on, ~190 transitive deps) is the elephant in the room. It's there because most users want batteries-included local embeddings, but consumers who bring their own embedder pay zero cost for it via `default-features = false`. This is the only acceptable form of "fat" dep — opt-out, never opt-in-required.
+- `fastembed` (default-on, ~190 transitive deps) is the elephant in the room. It's there because most users want batteries-included local embeddings, but consumers who bring their own embedder pay zero cost for it via `default-features = false`. This is the only acceptable form of "fat" dep: opt-out, never opt-in-required.
 
 ## References
 

docs/ADRs/0002-pure-classifier-architecture.md

@@ -4,7 +4,7 @@
 
 ## Context
 
-Earlier semrouter prototypes tracked a "risk policy" — the router would emit a `policy` block on `RouteDecision` indicating whether a route required user confirmation, was high-risk, etc. The classification was driven by hardcoded substring matching against route names (`"execute_shell_command"` → high-risk, `"send_email"` → requires_confirmation, etc.).
+Earlier semrouter prototypes tracked a "risk policy": the router would emit a `policy` block on `RouteDecision` indicating whether a route required user confirmation, was high-risk, etc. The classification was driven by hardcoded substring matching against route names (`"execute_shell_command"` → high-risk, `"send_email"` → requires_confirmation, etc.).
 
 Two problems with this:
 
@@ -38,9 +38,9 @@ The risk logic sits **next to the dangerous code**, where the author cannot forg
 
 ### What semrouter still tracks
 
-- Score thresholds (`minimum_score`, `minimum_margin` from `router.toml`) — these are about **classification confidence**, not policy.
-- Hard negatives (counter-examples that penalize specific routes for specific inputs) — also classification, not policy.
-- Latency metrics — observability of the classifier itself.
+- Score thresholds (`minimum_score`, `minimum_margin` from `router.toml`): these are about **classification confidence**, not policy.
+- Hard negatives (counter-examples that penalize specific routes for specific inputs): also classification, not policy.
+- Latency metrics: observability of the classifier itself.
 
 These all sit on the classification side of the line.
 
@@ -64,5 +64,5 @@ These all sit on the classification side of the line.
 ## References
 
 - CHANGELOG.md v0.1.0 (the risk-policy removal, before public release)
-- `src/decision.rs` — the `DecisionStatus` enum and `RouteDecision` struct (no `policy` field)
-- `docs/integration-example.md` — the Plugin / Dispatcher pattern for consumers
+- `src/decision.rs`: the `DecisionStatus` enum and `RouteDecision` struct (no `policy` field)
+- `docs/integration-example.md`: the Plugin / Dispatcher pattern for consumers

docs/ADRs/0003-byo-embedder-trait.md

@@ -6,9 +6,9 @@
 
 Pre-v0.1.1, semrouter shipped three embedder backends:
 
-1. `MockEmbedder` — 64-dim keyword-bag, deterministic, zero deps. For testing.
-2. `FastEmbedEmbedder` — local ONNX MiniLM via the `fastembed` crate. The recommended production embedder.
-3. `HttpEmbedder` — OpenAI-compatible `/v1/embeddings` HTTP client built on `reqwest` + `tokio`.
+1. `MockEmbedder`: 64-dim keyword-bag, deterministic, zero deps. For testing.
+2. `FastEmbedEmbedder`: local ONNX MiniLM via the `fastembed` crate. The recommended production embedder.
+3. `HttpEmbedder`: OpenAI-compatible `/v1/embeddings` HTTP client built on `reqwest` + `tokio`.
 
 The HTTP embedder pulled in ~85 transitive crates (the entire async stack) for what is, in its core form, a 30-line HTTP request. Worse, it shipped a half-baked implementation: no connection pooling, no retry/backoff, no rate limiting, no observability hooks. Real HTTP-embedding consumers replace that on day one with their own implementation tuned for their service.
 
@@ -19,7 +19,7 @@ The HTTP embedder pulled in ~85 transitive crates (the entire async stack) for w
 - `MockEmbedder` (always available)
 - `FastEmbedEmbedder` (behind `fastembed` feature, default-on)
 
-For any other backend — HTTP API, custom local model, candle-based embedder, GPU-accelerated ort directly — consumers implement the public `EmbeddingProvider` trait:
+For any other backend (HTTP API, custom local model, candle-based embedder, GPU-accelerated ort directly) consumers implement the public `EmbeddingProvider` trait:
 
 ```rust
 pub trait EmbeddingProvider: Send + Sync {
@@ -54,7 +54,7 @@ The full README has this example.
 
 - semrouter's default dep tree drops by ~85 crates (no `reqwest`, no `tokio`).
 - Consumers pick their own HTTP client (`ureq` for ~5 deps; `reqwest` for full bells and whistles; `hyper` for fanatics; `tokio` if they're already async).
-- Consumers control retry, backoff, batching, observability — all the details that vary per service.
+- Consumers control retry, backoff, batching, observability: all the details that vary per service.
 - The `EmbeddingProvider` trait is sync, which keeps the library sync. Async creep is contained.
 
 ### Negative
@@ -69,5 +69,5 @@ The full README has this example.
 ## References
 
 - CHANGELOG.md v0.1.1 (HttpEmbedder removal)
-- `src/embedding.rs` — `EmbeddingProvider` trait definition
+- `src/embedding.rs`: `EmbeddingProvider` trait definition
 - README.md "Bring your own embedder" section