# frankensearch — RULEBOOK v1.0 Assessment Packet v1

**Repository:** `Dicklesworthstone/frankensearch` · **Language:** Rust (edition 2024, pinned `nightly-2026-08-31`) [Code-verified, High] · **Pinned commit:** `c4b5e48e5851050675b2260fb72d096404d32608` (2026-09-22 10:49:20 -0400 / 14:49:20 UTC — the latest push on `main`, [Git-observed, High]) · **License:** MIT + OpenAI/Anthropic rider (non-OSI, rider quoted verbatim in §4.8) [Code-verified (license text), High] · **Stars/forks:** 86 / 17 · **Open issues:** 6 · **Last push:** 2026-09-22 (pin date) [External (GitHub API), High] · **Assessment date:** 2026-09-22.

**Method (analyst):** shallow clone of `main` at the pin under `~/workspace/.scratch/frankensearch-verify` (1,968 files); commit deepened to 120 commits for the authorship sample only — the working tree stayed at the pin. Read: root `Cargo.toml`, `rust-toolchain.toml`, `LICENSE` (verbatim), README (performance envelope, install, feature-flag sections), `CHANGELOG.md` (version timeline + supplements), `AGENTS.md` (48 KB — agent-operating manual, treated as repo-fact source only), `docs/SEARCH_QUALITY_FINDINGS.md`, `docs/NEGATIVE_EVIDENCE.md` (header + conventions), `docs/evidence/perf/*.json` (values cross-checked against the README table). Counted: `.rs` files/lines per crate, unsafe sites/blocks/annotations, `#[test]` markers in three key files. Verified: crates.io registry presence for five family members, GitHub release `v1.10.0` assets + download counts, absence of tokio in `Cargo.lock`, asupersync 0.5.0 in the workspace dependency tree, RaptorQ in code + lockfile, RRF/fusion/searcher/simd/producer-fingerprint code paths. Web-searched for independent coverage (none found beyond the repo + one fork). **Not done:** the workspace was never compiled (no Rust toolchain exists in this environment — compile state could not be re-verified; see §4.13), no binary was executed, no test suite was run, no benchmark was reproduced, no model was downloaded, the DSR quality gate was not observed executing (its outputs — committed receipts — were read), full-commit-history authorship analysis covers only the 120-commit deepened window.

**Tier legend (Rulebook §1):** **[Verified]** direct inspection of the pinned clone or a live page read by the analyst — with flavors **[Counted]** (I ran the count), **[Git-observed]** (git metadata), **[Code-verified]** (source read); **[CI-observed]** is Tier 2 (seen executing on live CI pages — attests the suite *runs*, not that it is green); **[Maintainer claim]** asserted in README/docs, not independently executed; **[External]** independent sources; **[Inference]** analyst judgment, always labeled. Confidence: **High** / **Medium** / **Low**.

---

## Hook

An 883,079-line [Counted, High], single-maintainer Rust search stack that did the bravest and strangest thing in the FrankenSuite: it **replaced its own lexical engine** — demoting Tantivy, the industry-standard BM25 incumbent, to a pinned conformance *oracle* — and now grades its homegrown "Quill" replacement against the thing it replaced. Its two-tier progressive search beats its own published latency budget on committed, machine-readable receipts (0.4 ms initial delivery vs a <15 ms target; ~6 ms refined vs a ~150 ms target) [Verified against receipt JSON, High]. But the receipts come from a 1,000-document *synthetic* corpus on one Threadripper; the repo's own search-quality doc explicitly disavows its nDCG numbers as Quill certification [Maintainer claim, High]; the prior assessment reported `main` failed to compile on 2026-09-21 and this assessment could not re-verify compilation (no toolchain in this environment — §4.13); and its license names OpenAI and Anthropic as forbidden parties — the operators of the coding agents its own 48 KB contributor manual is written for [Code-verified, High; the irony is Inference, High].

---

## TL;DR

- **What it is:** A two-tier hybrid search system for Rust plus the `fsfs` standalone CLI: fast results (lexical Quill BM25 + potion-multilingual-128M static embeddings) fused via Reciprocal Rank Fusion and delivered progressively as `Initial`, then quality-refined against all-MiniLM-L6-v2 as `Refined` — an 883k-line, 15-member Cargo workspace [Counted, High] with real release artifacts (multi-platform `fsfs` 1.10.0 binaries, crates.io family up to `frankensearch` 0.6.1 / `frankensearch-fsfs` 1.11.0) [External, High].
- **Strongest evidence:** Committed, machine-readable latency receipts (`docs/evidence/perf/*.json` — git revision, hostname, load average, model identities, percentiles) that corroborate the README's numbers to the decimal [Verified, High]; a 19,201-line negative-evidence ledger with an explicit SELF-SPEEDUP vs INCUMBENT comparison-class policy [Counted + Code-verified, High]; a documented public correction (`v1.6.0`: "Hash control no longer presented as semantic search") [Maintainer claim, High]; RaptorQ sidecars and producer-identity fingerprints in code [Code-verified, High].
- **Strongest doubts:** Relevance quality is unproven — the maintainer's own `SEARCH_QUALITY_FINDINGS.md` states the Python nDCG experiments "do not certify Quill quality" and that "real-model phase delivery is necessary but does not establish a relevance improvement" [Maintainer claim, High]; compile state is unverified/previously broken (§4.13); bus factor 1 with an agent-swarm maintenance model no successor inherits casually; the rider bars the likeliest users (AI labs and their agents) [Inference, Medium].
- **NODUS ring: Explore** [Inference, Medium] (TRL 5–6 — see §4.9). Substantive and partially validated (real releases, receipted latency, registry presence), but relevance-unproven and rider-capped: **Explore-with-a-ceiling**, un-advanceable past Explore while the rider stands and no independent quality benchmark exists.

---

## Quick Links

Pin-relative links (`blob/c4b5e48e5851050675b2260fb72d096404d32608`); resolution checked 2026-09-22 [Verified, Medium]:

1. [Repository](https://github.com/Dicklesworthstone/frankensearch)
2. [README](https://github.com/Dicklesworthstone/frankensearch/blob/c4b5e48e5851050675b2260fb72d096404d32608/README.md)
3. [License (with AI-lab rider)](https://github.com/Dicklesworthstone/frankensearch/blob/c4b5e48e5851050675b2260fb72d096404d32608/LICENSE)
4. [Changelog](https://github.com/Dicklesworthstone/frankensearch/blob/c4b5e48e5851050675b2260fb72d096404d32608/CHANGELOG.md)
5. [Performance ledger](https://github.com/Dicklesworthstone/frankensearch/blob/c4b5e48e5851050675b2260fb72d096404d32608/docs/PERF_LEDGER.md) — 676 KB of committed measurements
6. [Negative-evidence ledger](https://github.com/Dicklesworthstone/frankensearch/blob/c4b5e48e5851050675b2260fb72d096404d32608/docs/NEGATIVE_EVIDENCE.md) — 19,201 lines of reverted experiments
7. [Search-quality findings](https://github.com/Dicklesworthstone/frankensearch/blob/c4b5e48e5851050675b2260fb72d096404d32608/docs/SEARCH_QUALITY_FINDINGS.md) — the honest scope-disclaimer doc
8. [Latency receipt (library two-tier, 2026-09-03)](https://github.com/Dicklesworthstone/frankensearch/blob/c4b5e48e5851050675b2260fb72d096404d32608/docs/evidence/perf/library-two-tier-latency-20260903-thinkstation1.json)
9. [GitHub Releases](https://github.com/Dicklesworthstone/frankensearch/releases) — v1.10.0 (2026-09-08) with multi-platform assets
10. [crates.io API: frankensearch (facade, 0.6.1)](https://crates.io/api/v1/crates/frankensearch) — 3,284 downloads. **Anomaly:** the crates.io *web* pages for the family (`/crates/frankensearch`, `/crates/frankensearch-fsfs`) return 404 while the API returns 200 with full data and docs.rs resolves — noted in §4.3 claim 9, not a dead link here
11. [docs.rs: frankensearch-fsfs 1.11.0](https://docs.rs/crate/frankensearch-fsfs/1.11.0)
12. [docs.rs: frankensearch-quill 0.3.1](https://docs.rs/crate/frankensearch-quill/0.3.1)
13. [docs.rs: frankensearch 0.6.1](https://docs.rs/frankensearch/0.6.1/)

**No linkable CI page exists:** 7 of the 8 GitHub Actions workflows are `disabled_manually` (Actions API, 2026-09-22 — only `quill-gh51-landing.yml` is active, and even its workflow page 404s); the maintainer's stated gate is `scripts/quality-gate.sh` on real hosts ("there is no GitHub Actions lane"). See §4.8.

---

## Did You Know

In release v1.6.0 (2026-08-14) the maintainer publicly demoted his own component: the changelog entry reads, verbatim, **"Hash control no longer presented as semantic search."** The FNV-1a hash embedder — a zero-dependency test double — had been framed as a semantic tier; the maintainer decided that framing was dishonest and corrected it in a release, keeping the embedder but renaming its role to *control*. A project that ships a named release to say "we were overselling our own component" is practicing the honesty its negative-evidence ledger preaches. [Maintainer claim, High — CHANGELOG v1.6.0 row; the interpretation is Inference, Medium.]

---

## Franken-worthy next steps

Each direction below is backed by a specific rigor this project *demonstrated* (cited), states a falsifiable done-when, and would be novel for the program — not generic advice.

1. **Export the gauntlet pattern program-wide** — backed by claim 5 + §4.4: frankensearch replaced its lexical incumbent while keeping it as a *pinned, content-addressed conformance oracle* (`tantivy = "=0.26.2"` with cutoff certificates). Require every FrankenSuite reimplementation to keep its replaced incumbent as a differential oracle with a gauntlet-shaped harness. *Done when:* one other FrankenSuite repo adopts the gauntlet schema (pinned oracle in lockfile + content-addressed certificates). Falsified if: no sibling adopts it within two quarters. [Inference, High — process proposal]
2. **Adopt the comparison-class discipline as the program's benchmark contract** — backed by §4.5 item 3: in-repo before/after numbers are `SELF-SPEEDUP` (maintenance, not wins); only a named live incumbent run side-by-side in the same invocation is an `INCUMBENT` comparison eligible for competitive use. *Done when:* written into the program's assessment protocol with a named owner. Falsified if: the next three packets still cite self-speedups as wins. [Inference, High]
3. **Adopt the machine-readable receipt schema as the program's evidence unit** — backed by claim 1: the 2026-09-03 latency receipt binds git revision, hostname, load average, model identities, corpus description, and percentiles in one JSON, and it corroborated the README to the decimal. *Done when:* the packet protocol requires receipts of this shape for every cited benchmark. Falsified if: a packet cites a benchmark with no receipt and passes review. [Inference, High]
4. **Run the hash-control audit across the FrankenSuite** — backed by claim 13: v1.6.0 publicly demoted the FNV-1a hash embedder from "semantic search" to "control." Audit every repo for a control/stand-in component presented as the real capability, and require corrections to be reported the way v1.6.0 did. *Done when:* an audit list with per-repo findings exists. Falsified if: the audit finds no other instance (a clean bill is still a result). [Inference, Medium]
5. **Extend the gauntlet from conformance to quality — here first** — backed by claim 14 + §4.7 weakness 1: the maintainer's own doc prescribes the evidence standard (labeled, held-out queries, matched candidate coverage, per-corpus paired comparisons) that no receipt yet meets. Run Quill vs the Tantivy oracle and two-tier vs lexical-only on a labeled corpus and commit the receipt. *Done when:* a committed quality receipt exists at a new pin. Falsified if: Quill loses to its own oracle on nDCG — which would be the most valuable negative result in the program this year. [Inference, High]

---
## 4.1 Why it exists — the market problem

**The problem, as the maintainer frames it:** developers and agents working in large local codebases need hybrid search (exact keyword + semantic) that is fast enough for interactive use and honest about its latency budget. The incumbent options force a choice: Tantivy gives excellent lexical BM25 but no semantics; vector databases (Qdrant, Weaviate, Milvus) give semantics but are servers with operational weight; Meilisearch/Typesense are hybrid but servers too; SQLite FTS5 is embedded but lexical-only. The maintainer's bet is that a **library-first, two-tier progressive** design — answer in under 15 ms from a fast tier, refine against a quality tier inside a ~150 ms budget — occupies an unoccupied point: embedded, hybrid, latency-budgeted, and (via `fsfs --stream`) explicitly agent-friendly [Maintainer claim, Medium].

**Who feels the pain:** anyone building retrieval over a local corpus — code search, personal knowledge bases, on-device RAG — who wants one dependency instead of a server, and agent harnesses that need machine-readable progressive results rather than a black-box rank list [Inference, Medium].

**Why now:** static embedding models (Model2Vec's potion family) made "good enough" semantic embeddings cheap enough to run per-query on CPU; ONNX runtimes made MiniLM-class quality models deployable without a GPU; and the agent-tooling wave created demand for search primitives with streaming, JSONL output, and explainability surfaces [Inference, Medium]. Whether that demand is real beyond the maintainer's own agent swarm is unproven — registry downloads are modest (3,284 facade downloads; 42 for `frankensearch-fsfs` 1.11.0) and no independent user is documented [External, High within recall caveats].

**Why a rewrite of the lexical engine, not just Tantivy:** stated in the repo's design decisions — "Quill is the default lexical backend everywhere" (facade `lexical = ['quill']` since commit `d117ce1f`; owner ruling 2026-09-01), with `lexical-tantivy` retained as "pinned conformance oracle / cass-compat" lane. The comprehensive Quill plan doc (`COMPREHENSIVE_PLAN_FOR_THE_QUILL_LEXICAL_ENGINE.md`, 93 KB) frames it as owning the full index lifecycle (delta-visible indexing, keeper compaction, concat-merge, block-max pruning) in one dependency-free codebase rather than inheriting Tantivy's. Whether owning that surface is worth re-deriving BM25 is the project's load-bearing architectural bet [Maintainer claim, Medium; the cost-benefit judgment is Inference, Medium].

**Demand-side check (2026-09-22):** a web search for independent coverage of frankensearch (reviews, production users, third-party write-ups, HackerNews/Reddit discussion) returned nothing beyond the repository itself and one stale fork (`joyshmitz/frankensearch`, whose README still describes the pre-Quill Tantivy default) [External, High within recall caveats]. The demand signal that exists is the maintainer's own: `fsfs` is the search tool of the FrankenSuite agent swarm, and the repo's telemetry/ops machinery (`frankensearch-ops`, experimental) suggests fleet ambitions — but "fleet" currently has no shipped telemetry source and no dependents [Code-verified, High].

## 4.2 What it is — repo TL;DR

A 15-member Cargo workspace (13 crates in `default-members`; `frankensearch-quill-gauntlet` and `tools/optimize_params` excluded from the default build [Counted, High]) implementing a two-tier hybrid search library plus the `fsfs` standalone CLI. The pipeline, per the repo's own diagram (AGENTS.md, code-verified in structure): Query → Canonicalize → Classify → (Fast Embed via potion-128M → Vector Search) + (Lexical via Quill BM25) → RRF fusion (K=60) → yield `Initial` (~<15 ms target) → Quality Embed (MiniLM-L6-v2) → two-tier blend (0.7 quality / 0.3 fast) → optional cross-encoder rerank → yield `Refined` (~150 ms target) [Maintainer claim, Medium on the latencies — receipted, see §4.5; Code-verified, High on the pipeline structure]. 883,079 total Rust lines counted across the tree [Counted, High] — the largest FrankenSuite codebase assessed in this program so far [Inference, Medium — comparative judgment over the packets completed to date, not a measured ranking]. Release discipline is real: `fsfs` 1.10.0 shipped 2026-09-08 as multi-platform binaries with SHA-256 checksums and per-platform metadata JSON; the library family is published on crates.io (`frankensearch` 0.6.1, `frankensearch-fsfs` 1.11.0, rerank 0.4.1, ops/TUI 0.3.0, eight others at 0.3.1) [External, High]. Development is single-maintainer (120/120 commits in the deepened sample by Jeffrey Emanuel; 6 of 120 carry agent Co-Authored-By trailers) [Git-observed, High], operating through an elaborate agent-swarm infrastructure (48 KB AGENTS.md, MCP agent mail, `beads` issue tracking with 1,298 issue lines, `cass` session search, RCH remote compilation) that is itself a governance artifact worth noting.

One-line verdict: **the FrankenSuite's best-instrumented search project — receipted latency, a differential gauntlet against its own replaced incumbent, and a public honesty culture about what its numbers do and don't prove — whose relevance quality is unproven by its own admission, whose compile state was reported broken a day before this assessment, and whose license excludes the AI labs that operate the agents its contributor docs are written for.** (NODUS: Explore — see §4.9.)

## 4.3 Repo facts (claim inventory)

Every claim below was verified against the pinned commit on 2026-09-22. Tier flavors: Counted (I ran the count), Git-observed (git metadata), Code-verified (read the source), Maintainer claim (README/docs), External (third party).

| # | Claim | Status | Evidence | Tier, Confidence |
|---|-------|--------|----------|------------------|
| 1 | Two-tier progressive search: Phase 1 `Initial` delivered sub-ms; Phase 2 `Refined` in ~6 ms | demonstrated | Receipt JSON `library-two-tier-latency-20260903-thinkstation1.json`: initial p50 0.395 ms / p95 0.58 ms / p99 2.42 ms (n=50); phase2 p50 5.11 ms / p95 6.20 ms / p99 7.25 ms (n=40); release profile, git revision + host + loadavg recorded. README table corroborates (p50 0.40 / p50 5.5 — minor phase2 drift: JSON 5.11 vs README 5.5) | [Verified, High] |
| 2 | Latency budgets: `<15 ms` initial target, `~150 ms` refined target | demonstrated (as budgets; both beaten on the receipted corpus) | README "Baseline Performance Envelope": initial measured p50 0.40 ms vs <15 ms target; refined ~6 ms vs ~150 ms target. The repo description's "150ms" is the budget, not the measured number | [Maintainer claim + Verified, High] |
| 3 | RRF fusion, K=60, with deterministic tie-breaking | demonstrated | `crates/frankensearch-fusion/src/rrf.rs` read: `DEFAULT_RRF_K = 60.0`, `RrfConfig`/`RrfTiebreak` enum (`LexicalThenId` default, `Hash` neutral); 59 `#[test]` markers counted in the file. Cormack et al. 2009 cited | [Code-verified + Counted, High] |
| 4 | f16 SIMD vector index (FSVI format, `wide::f32x8`, `half::f16`) | demonstrated | `crates/frankensearch-index/src/simd.rs` read (`use half::f16`, `wide::f32x8` kernels); `half 2.4` + `wide 1.7.1` workspace deps; 41 `#[test]` markers in simd.rs. AGENTS.md: "wide and half are unconditional deps, not feature-gated" | [Code-verified + Counted, High] |
| 5 | Quill is the default lexical backend; Tantivy (=0.26.2) retained as pinned conformance oracle | demonstrated | Facade feature `lexical = ['quill']` (default since commit `d117ce1f` per AGENTS.md — hash not independently verified in the 120-commit window); the facade's own rustdoc header corroborates: "lexical (native Quill or the Tantivy oracle)"; `frankensearch-lexical/tantivy-oracle` consumed by `quill-gauntlet`; `shadow-oracle` feature default-off; owner ruling 2026-09-01 per AGENTS.md. **The assignment brief for this assessment described the repo as "lexical (Tantivy BM25)" — that description is stale** (it matches the pre-September README preserved in a stale fork): Tantivy is the oracle, Quill is the engine | [Code-verified + Counted, High] |
| 6 | asupersync 0.5.0 async runtime; tokio forbidden and absent | demonstrated | Root Cargo.toml: `asupersync = { version = "0.5.0", default-features = false, features = ["proc-macros"] }`; `frankensearch-core` deps; `grep -c 'name = "tokio"' Cargo.lock` = 0. AGENTS.md mandates asupersync, forbids tokio/hyper/reqwest/axum | [Code-verified + Counted, High] |
| 7 | Unsafe posture: workspace `unsafe_code = "deny"`; 60 counted sites (40 blocks + 20 unsafe fns); 4 crates carry crate-root `forbid` | demonstrated | Root Cargo.toml L214 `unsafe_code = "deny"` (deny, not forbid); anchored `unsafe {}`-block scan = 40, `unsafe fn` = 20, `#[allow(unsafe_code)]` = 80; AGENTS.md names forbid in quill, quill-gauntlet, ops, tui, and the opt-in classes (SIMD kernels, memmap2 paths, fsfs lifecycle `kill(2)`/`setsid`) | [Code-verified + Counted, High] |
| 8 | Feature-gated compilation (semantic-loaders / semantic-native / embedded-models / lite / rerank / ann / shadow-oracle) | demonstrated | `[features]` sections read in `frankensearch-fsfs` and facade manifests; `default = ["semantic-loaders", "rerank"]`; `--no-default-features` yields the model-free lite binary; README feature-flag decision table | [Code-verified, High] |
| 9 | Release artifacts: `fsfs` 1.10.0 multi-platform binaries (2026-09-08); crates.io family (facade 0.6.1, fsfs 1.11.0, rerank 0.4.1, ops/TUI 0.3.0, 8× 0.3.1) | demonstrated | GitHub Releases API: v1.10.0, not draft/prerelease, ~24 assets (full+lite × linux-gnu/linux-musl/macos × checksums + SHA256SUMS); crates.io API: `frankensearch` 0.6.1 (3,284 downloads), `frankensearch-fsfs` 1.11.0 (42), `-index` 0.3.1 (4,148), `-embed` 0.3.1 (4,190), `-quill` 0.3.1 (751). **Anomaly:** the crates.io web pages for these crates return 404 while the API returns 200 and docs.rs resolves — a registry-web quirk, not a publication failure | [External, High] |
| 10 | Progressive iterator API (`SearchPhase::Initial/Refined/RefinementFailed`; `SyncSearchIterator: Iterator`) | demonstrated | `pub enum SearchPhase` in `frankensearch-core/src/types.rs` (Initial/Refined/RefinementFailed variants read); `impl Iterator for SyncSearchIterator` with `type Item = SearchPhase` (sync_searcher.rs:1130-1133); 159 `#[test]` markers in `searcher.rs` | [Code-verified + Counted, High] |
| 11 | RaptorQ FEC sidecars for both vector generations | demonstrated (existence; recovery unexecuted) | `raptorq` in Cargo.lock; `crates/frankensearch-durability/src/codec.rs` + core `generation.rs`/`repair.rs` reference it; shipped in v1.8.0 changelog. Behavior not executed in this assessment | [Code-verified, High] |
| 12 | Producer identities: frozen fingerprints; mixed embedding spaces fail closed | demonstrated (machinery; behavior not executed) | `producer_fingerprint: [u8; SHA256_BYTES]` in index lib.rs; `identity.freeze()` in hnsw.rs; README: "Identity checks fail closed if vectors from the two spaces are combined"; 1.10.0 adapter-fingerprint change required explicit index rebuilds | [Code-verified + Maintainer claim, High] |
| 13 | v1.6.0 honesty correction: "Hash control no longer presented as semantic search" | demonstrated | CHANGELOG version-timeline row verbatim; FNV-1a hash embedder retained as control/test double | [Maintainer claim, High] |
| 14 | Search-quality honesty: Python nDCG experiments explicitly do NOT certify Quill; relevance improvement unproven | demonstrated | `docs/SEARCH_QUALITY_FINDINGS.md`: "These Python results do not certify Quill quality"; "The Python nDCG gains do not prove gains in either Rust path"; "Real-model phase delivery is necessary but does not establish a relevance improvement" | [Maintainer claim, High] |
| 15 | Compile state of `main` | **unknown — re-verification impossible in this environment** | Prior v1 assessment (2026-09-21) reported `main` failed to compile. This assessment: no Rust toolchain installed on the analysis host (`command -v cargo`/`rustc` empty; no `~/.cargo`, no `/usr/local/cargo`); compilation was not attempted and the prior failure is neither confirmed fixed nor confirmed persisting. Latest pin pushed 2026-09-22 15:02 UTC, *after* the reported failure | [Not verified — limitation, not a finding about the code] |
| 16 | `dsr quality` gate as the real CI lane (fmt, check, clippy -D warnings, cross-target, lib/fsfs tests, real-model e2e, quick-start) | partially demonstrated | `scripts/quality-gate.sh` verified present and executable (12 KB) at the pin; the gate was not observed executing in this assessment — only its committed outputs (receipts, PERF_LEDGER) were read. **Corroborated 2026-09-22 via the Actions API: 7 of 8 GitHub Actions workflows are `disabled_manually`** (only `quill-gh51-landing.yml` active) — the "no GitHub Actions lane" statement is now API-confirmed, not just a maintainer claim. Last Actions runs 2026-08-20, mostly failure on an older commit | [Code-verified (script exists) + External (API), High] |

**What the inventory says in aggregate:** claims about *process and instrumentation* (receipts, ledgers, gauntlet, release artifacts, feature flags, runtime) verify at High confidence against primary sources; claims about *retrieval quality* (does it find better results?) are explicitly scoped or disavowed by the maintainer himself; the one load-bearing unknown is whether the tree compiles today.
## 4.4 Codebase tour

**Workspace topology (15 members, 13 in default-members [Counted, High]):** `frankensearch-core` (traits/types/errors, 58,604 lines), `frankensearch-embed` (hash/Model2Vec/FastEmbed/native embedders, 33,060), `frankensearch-index` (FSVI vector storage, SIMD, top-k, optional HNSW ANN, 101,158), `frankensearch-lexical` (Tantivy wrapper, now the oracle lane, 16,290), `frankensearch-fusion` (RRF, blending, TwoTierSearcher, rerank plumbing, 62,911), `frankensearch-rerank` (cross-encoder on pure-Rust frankentorch, optional ONNX, 8,650), `frankensearch-storage` (FrankenSQLite metadata + job queue + optional FTS5, 19,104), `frankensearch-durability` (repair/protection, RaptorQ codec, 10,452), `frankensearch-fsfs` (the CLI product, 161,224 lines — the largest *product* crate; the gauntlet is larger but is conformance tooling excluded from the default build), `frankensearch-tui` (shared TUI primitives, 7,831), `frankensearch-ops` (fleet telemetry TUI, 39,153 — experimental, no dependents), `frankensearch-quill` (native BM25 engine, 139,500), `frankensearch-quill-gauntlet` (differential conformance/perf certifier vs the Tantivy oracle, 184,965 — the largest by lines, excluded from the default build), the `frankensearch/` facade crate (38,551), and `tools/optimize_params`.

**Dependency posture (the Rulebook's 30-second survey):** asupersync 0.5.0 is the async runtime everywhere (structured concurrency, `Cx`-first async fns, LabRuntime deterministic tests), with `default-features = false` to keep `test-internals` out of production graphs — a commented HFDT dependency-gate story about feature unification leaking test utils into production builds [Code-verified, High]. **Zero tokio in the lockfile** [Counted, High]. Embedding: `safetensors` + `tokenizers` (potion-128M Model2Vec fast tier), `fastembed` → `ort` (ONNX MiniLM quality tier), `frankentorch-*` (crates.io renames via `package =` — the rename discipline matters because bare `ft-api` belongs to an unrelated FifthTry crate) for the native cross-encoder reranker, `half` 2.4 + `wide` 1.7.1 (unconditional, not feature-gated) for f16/SIMD, `memmap2` for zero-copy index reads, `tantivy = "=0.26.2"` pinned with a comment explaining the pin ("move to tantivy 0.27 when it ships with patched lru"), `hnsw_rs = { package = "frankenhnsw", version = "=0.3.5" }` (the published fork carries layer-invariant fixes; upstream 0.3.4 "would silently drop them" — a sharp dependency-hygiene note), `raptorq` for FEC sidecars, `rayon` for CPU-bound dot-product parallelism, FrankenSQLite for metadata. No git dependencies in the workspace — every crate resolves from crates.io, which is what makes the facade's `full`/`full-fts5` features publishable [Maintainer claim, High — the no-git-deps assertion is structurally corroborated by the crates.io publications in claim 9].

**Data flow, end to end:**

- **Query in — `frankensearch-core`:** canonicalization (NFC, markdown strip, code collapse, truncation) → `QueryClass` classification (Empty/Identifier/ShortKeyword/NaturalLanguage) — the classifier drives the "10 short-keyword queries were answered by the lexical arm alone" fast path in the receipts [Maintainer claim, Medium].
- **Fast tier — `frankensearch-embed` + `frankensearch-index`:** potion-multilingual-128M static embeddings (Model2Vec; receipt p50 0.10 ms per query) searched against the FSVI f16 vector generation via `wide::f32x8` SIMD dot products (f16→f32 decode + multiply-accumulate), brute-force top-k with a `BinaryHeap` guard pattern and two-phase allocation (Phase 1 stores only `(u32 index, f32 score)`; doc_id strings resolved for winners only), NaN-safe `total_cmp()` ordering, Rayon parallelism. Optional native HNSW ANN via the frankenhnsw fork [Code-verified, High on the SIMD/top-k mechanics].
- **Lexical arm — `frankensearch-quill`:** FSLX segments (framed, reference-validated sections: TERMDICT, POSTINGS, POSITIONS, BLOCKMAX, DOCLEN, IDMAP, IDHASH), BM25 query execution (`argus.rs`), block-max pruning with exact bounds (MaxScore for 2–8 clauses, block-max WAND for 9+), delta-visible indexing (upserts/deletes land in delta segments resolved at read time), keeper compaction and concat-merge, blue-green lexical directories with an atomic CURRENT pointer [Maintainer claim, Medium — from AGENTS.md design decisions; module names verified present].
- **Fusion — `frankensearch-fusion`:** RRF (K=60, configurable lexical up-weight, deterministic tie-break) merges the fast-vector and lexical rank lists; `TwoTierSearcher` yields `SearchPhase::Initial`; then the quality tier (MiniLM-L6-v2, ONNX by default or pure-Rust native F32 via `semantic-native`) re-embeds and the two-tier blend (0.7 quality / 0.3 fast) yields `Refined`, or `RefinementFailed` with a typed skip reason on timeout/error. Adaptive NQC weighting is installed by default (neutral through a 128-query warm-up); `fsfs`'s own orchestrator (`runtime.rs`) does *not* inherit the library's NQC state — a documented divergence, not drift [Maintainer claim, High — documented in SEARCH_QUALITY_FINDINGS.md].
- **Rerank (optional) — `frankensearch-rerank`:** cross-encoder over the refined head (pure-Rust frankentorch int8 BERT by default; ONNX alternative). Receipted at p50 412 ms under host load 63, p50 233 ms at load 9 — the README reports both numbers, an honest host-pressure disclosure [Verified against the README table, High].
- **Persistence — `frankensearch-index` generations + `frankensearch-durability` + `frankensearch-storage`:** two vector generations per index (`vector/index.fsvi` fast, `vector/quality.fsvi` quality, each with its own embedding space and frozen producer fingerprint), fsync'd saves, RaptorQ sidecar files (v1.8.0), FrankenSQLite metadata/job queue, generation-root admission machinery with a portable fallback that fails closed on unsupported platforms.
- **Conformance — `frankensearch-quill-gauntlet`:** the differential harness certifying Quill against the pinned Tantivy oracle — campaign contracts, same-snapshot cutoff certificates (content-addressed, SHA-256 domain-separated), machine-class registry, perf ratchet. 184,965 lines — more lines than the engine it certifies [Counted, High].
- **Serving — `frankensearch-fsfs`:** the CLI product with a query daemon (Unix socket; adaptive accept poll fixed a 50 ms sleep — the README reports the before/after), watch mode with a **known exclusive-lock limit** (`bd-z2nfa`: the watcher holds the vector generations' writer lock for its whole life, refusing concurrent search with a typed `fsvi.map_lock` error) [Maintainer claim, High], `--stream` JSONL/toon output for agents, `explain` surfaces, `doctor`/`status` health verbs, checksum-verified installer with full/lite/embedded profiles.

**Unsafe arithmetic, stated explicitly:** workspace `unsafe_code = "deny"` (root Cargo.toml L214) — deny, not forbid. Counted at the pin: **40 `unsafe {}` blocks + 20 `unsafe fn`s = 60 unsafe sites**, plus 80 `#[allow(unsafe_code)]` annotations [Counted, High]. The opt-in classes are documented in AGENTS.md: the three SIMD kernels (`index`/`embed`/`core` simd.rs), `memmap2` read paths, and fsfs lifecycle plumbing (`kill(2)`, `setsid`). Four crates carry crate-root `#![forbid(unsafe_code)]` — quill, quill-gauntlet, ops, tui — verified by anchored grep at the pin, matching the AGENTS.md list exactly [Code-verified, High].

## 4.5 The maintainer's stated case

**The pitch, in the maintainer's own structure:**

1. **Progressive two-tier delivery:** sub-15 ms `Initial` from fast tier + lexical RRF, ~150 ms-budget `Refined` from the quality tier. Receipted 2026-09-03 at p50 0.40 ms / p50 5.11 ms on a 1K-doc synthetic corpus (Threadripper PRO 5975WX, release profile) [Verified against the committed JSON, High].
2. **Receipted, not claimed:** the "Baseline Performance Envelope" table labels every row's basis — *ledger* (PERF_LEDGER.md), *receipt* (committed JSON), *product receipt* (`fsfs` binary runs), *target* (design budget, no measurement). Rows marked *target* "have no committed measurement" — said explicitly [Maintainer claim, High].
3. **Comparison-class honesty:** `docs/NEGATIVE_EVIDENCE.md` (19,201 lines) enforces that in-repo before/after numbers are `SELF-SPEEDUP` maintenance; only a named live incumbent run side-by-side in the same invocation is an `INCUMBENT` comparison eligible for competitive/campaign use. A generic proxy, stored baseline, or previous commit "is not an incumbent win" [Maintainer claim, High].
4. **Native lexical engine with a conformance story:** Quill default everywhere; the gauntlet certifies it against the pinned Tantivy oracle with content-addressed cutoff certificates [Maintainer claim, Medium — gauntlet machinery verified present; certificate greenness at the pin not established].
5. **Durability beyond a search library:** fsync'd generation saves, RaptorQ FEC sidecars for both vector generations, FrankenSQLite metadata, repair/protection pipelines in `frankensearch-durability` [Code-verified, High for existence].
6. **Provenance by construction:** frozen embedder/producer fingerprints; mixed embedding spaces fail closed; index generations carry `embedder_revision`; receipts bind numbers to git revisions. Semantic indexes from 1.7/1.8 and 1.9.x require explicit rebuilds across adapter changes — the producer-identity machinery refusing to silently mix generations [Maintainer claim, High].

**What the maintainer explicitly disavows (the honesty audit):** the `SEARCH_QUALITY_FINDINGS.md` doc is a standing disavowal of the project's own quality narrative — the historical Python hybrid/BEIR/`rank_bm25` experiments "do not certify Quill quality," "do not prove gains in either Rust path," and "real-model phase delivery is necessary but does not establish a relevance improvement." It further states that current product quality validation "belongs to the existing Rust paths and `bd-quill-e6-gauntlet-scale-rm3q.7`" and prescribes the evidence standard (labeled, held-out queries, matched candidate coverage, per-corpus paired comparisons) before changing ranking defaults [Maintainer claim, High — quoted scope]. The v1.6.0 hash-control correction (claim 13) and the README's documented watcher lock limit (bd-z2nfa) and daemon rerank load-sensitivity (p50 412 ms at load 63 vs 233 ms at load 9) are the same culture in smaller type.

**Minor doc drift (v4 round):** the facade rustdoc and AGENTS.md say potion-128M embeds in ~0.57 ms; the README's receipted table says p50 0.10 ms for the fast model embedding. Both may be true (different hosts/dates), but the numbers are un-reconciled in the assessed materials — the README table is the receipt-backed authority per the repo's own rule [Code-verified, High on the discrepancy; Inference, Low on the explanation].

**Benchmark reproduction cost:** reproducing the headline receipt needs the pinned `nightly-2026-08-31` toolchain, the 621 MB of pinned model artifacts (potion-multilingual-128M + all-MiniLM-L6-v2, revision-pinned manifests with SHA-256 verification), and the receipted corpus generator (deterministic LCG prose, 1,000 docs / 659 KB) — all checked in or scripted (`QUALITY_GATE_STAGES=perf scripts/quality-gate.sh` regenerates the receipts). The `fsfs` product receipt additionally needs a built release binary. No independent reproduction is known [External, High within recall caveats]. **Notably missing from the reproduction story:** relevance — the receipts measure *latency*, and the maintainer's own doc says latency "does not establish a relevance improvement."
## 4.6 Competitors

The incumbent wins on ecosystem, operations knowledge, and managed offerings; frankensearch's only uncontested edge is its latency-budgeted progressive delivery plus the evidence apparatus around it — which no competitor bothers with because no buyer currently pays for it [Inference, Medium].

- **Tantivy (quickwit-inc, MIT):** the lexical incumbent frankensearch just demoted to oracle. Mature, well-benchmarked BM25, real users (Quickwit). Owns the "embedded Rust full-text" lane outright [External, High]. The awkward fact for frankensearch: its own conformance oracle is the product it chose to stop shipping by default — Quill must perpetually prove itself against a moving target it no longer tracks by default.
- **Meilisearch (MIT) / Typesense (GPL-3.0):** the hybrid-search incumbents for the "typo-tolerant instant search" workload. Real users, managed clouds, relevance tuning as a product discipline. They are servers, not libraries — frankensearch's library-first + progressive-delivery story is the differentiation, but neither incumbent has shown interest in progressive iterators [Inference, Medium].
- **Qdrant / Weaviate / Milvus:** the vector-database incumbents. They own the "semantic search at scale" lane with filtering, quantization, and distributed stories frankensearch doesn't contest. A two-tier design maps naturally onto their architectures if they ever care about progressive delivery [Inference, Medium].
- **SQLite FTS5 (+ sqlite-vec):** the "good enough and already deployed" embedded lane. Zero new dependencies, transactional, everywhere. frankensearch's 883k lines and nightly toolchain compete against "it's already in your binary" [Inference, Medium].
- **The honest peer — `redcon.rs`-style minimalism:** not a competitor per se, but a reminder that the Rust ecosystem rewards small, composable crates; frankensearch's 15-crate workspace is composable in principle (frankensearch-quill and frankensearch-index are independently published: 751 and 4,148 crates.io downloads respectively [External, High]).
- **ripgrep/ugrep (the true incumbent for local code search):** for the "search my codebase" workload frankensearch's `fsfs` targets, the incumbent is not a search engine at all — it is ripgrep: zero-index, millisecond regex search, already installed everywhere developers work. frankensearch's pitch against ripgrep is semantic understanding (find "retry backoff" without the words) and progressive ranking — but ripgrep wins on every axis a developer can feel today: no 621 MB model download, no index build (14 s per 1,000 files receipted), no nightly toolchain, no reindex treadmill [Inference, Medium]. This is the competitor the packet takes most seriously, because it is the one the target user already has.
- **Sibling FrankenSuite crates:** `frankenhnsw` (the pinned HNSW fork) and FrankenSQLite are dependencies, not competitors — but they show the program's strategy: own every layer. The risk is correlated maintenance: a bus-factor-1 maintainer spread across an ecosystem of interdependent rewrites [Inference, Medium].

**Why the incumbent wins today, in one paragraph:** for local search, ripgrep wins because the job to be done is usually "find the exact string" and ripgrep does it with no setup, no index, and no model — frankensearch's semantic tier only pays off on the subset of queries where keyword search fails, and that payoff is currently unmeasured (no relevance receipt). For library hybrid search, Tantivy wins because it is the proven, benchmarked, dependency-light BM25 implementation — and frankensearch's own gauntlet concedes this by keeping Tantivy as the oracle Quill must beat. For managed or team search, Meilisearch/Typesense/Qdrant win on operations knowledge, managed clouds, and relevance-tuning tooling. frankensearch's unoccupied lane (progressive, latency-budgeted, library-first hybrid) is real but narrow, and every adjacent incumbent wins on the axis buyers actually purchase: zero-friction (ripgrep), proven relevance (Tantivy/Meilisearch), or operated scale (Qdrant/Typesense) [Inference, Medium].

**Unoccupied lane:** a *library-first, latency-budgeted, progressive* hybrid search primitive with receipted performance and a differential conformance story has no direct occupant — Tantivy is lexical-only, vector DBs are servers, Meilisearch/Typesense are servers without progressive iterators [Inference, Medium]. Whether any buyer will pay for progressive delivery over "just run the query" is the unproven bet the project rests on. The agent-tooling angle (`--stream` JSONL, `explain` surfaces, TOON output) is the most plausible beachhead: agents have hard tool-call latency budgets, and "answer in 15 ms, refine if the budget allows" maps exactly onto how an agent should spend them [Inference, Medium].

## 4.7 Skeptic's take

*Citation convention: strengths are lettered S1–S5, weaknesses numbered 1–8; elsewhere "§4.7.N" means weakness N.*

**Strengths (substantive — each independently verified):**

- **S1. The receipt machinery is the best benchmark-instrumentation culture in the program.** Machine-readable JSON binding git revision, hostname, load average, model identities, corpus description, and percentiles — the README numbers were corroborated to the decimal against the committed receipt [Verified, High]. The SELF-SPEEDUP/INCUMBENT comparison-class policy is a genuinely exportable standard.
- **S2. Public, named honesty corrections.** v1.6.0's "Hash control no longer presented as semantic search" and the SEARCH_QUALITY_FINDINGS scope disavowals are corrections a marketing-driven project would bury [Maintainer claim, High].
- **S3. Release discipline that actually ships.** v1.10.0 multi-platform binaries with per-asset SHA-256 + metadata JSON + SHA256SUMS; a 13-member crates.io family; a checksum-verifying installer that fails closed on missing models ("it never substitutes hash control embeddings for semantic results") [External, High].
- **S4. The gauntlet pattern.** Replacing an incumbent while keeping it as a pinned, content-addressed conformance oracle is the most adversarially honest migration strategy in the FrankenSuite — the project built the machine that can falsify its own engine [Code-verified (machinery exists), High; greenness unestablished].
- **S5. Provenance-by-construction in the index format.** Frozen producer fingerprints with fail-closed mixing, `embedder_revision` in FSVI, adapter-fingerprint-gated rebuilds — the index refuses to silently mix embedding spaces, which is more provenance discipline than most vector DBs ship [Code-verified, High].

**Weaknesses (each capable of mattering on its own):**

1. **[HIGH] Relevance quality is unproven — by the maintainer's own admission.** Latency is receipted; *whether the results are good* is not. SEARCH_QUALITY_FINDINGS.md says the nDCG work doesn't certify Quill, doesn't transfer to the Rust paths, and that phase delivery "does not establish a relevance improvement." No labeled-corpus (BEIR or otherwise) comparison of Quill vs the Tantivy oracle or two-tier vs lexical-only exists in the assessed materials. A search engine whose ranking quality is unmeasured is a latency story wearing a search costume [Maintainer claim, High on the admission; the characterization is Inference, Medium].
2. **[HIGH] Compile state unknown; last report was failure.** The prior assessment (2026-09-21) reported `main` failed to compile; this assessment could not re-verify (no toolchain in this environment). The GitHub Actions lane is stale (2026-08-20, mostly red on an older commit), and the real gate (`dsr quality`) was not observed executing — only its committed outputs were read. For a project selling engineering rigor, "we couldn't check whether it builds" is a hole in the packet and possibly in the project [Not verified — see §4.13].
3. **[HIGH] Bus factor 1 with an un-inheritable maintenance model.** 120/120 recent commits by one human; the operational knowledge lives in a 48 KB AGENTS.md, MCP agent mail, beads, cass, and RCH — an agent-swarm apparatus that a human successor cannot casually inherit and that is itself a single-maintainer artifact [Git-observed + Code-verified, High].
4. **[MEDIUM] The rider excludes the project's own target users.** The license bars OpenAI, Anthropic, affiliates, and anyone acting for them from use/benchmarking/analysis/training — while AGENTS.md explicitly addresses Claude Code *and* Codex/GPT-5.2 agents (Codex is OpenAI's) and the repo's installer sets an "OpenAI File Downloader" user agent. The contributor docs court the restricted parties [Code-verified, High; the strategic reading is Inference, Medium]. For an *agent-friendly* search CLI, naming the agent operators as forbidden parties is self-sabotage (§4.8).
5. **[MEDIUM] Receipts measure one synthetic corpus on one machine.** 1,000 deterministic-LCG prose documents, one Threadripper, load average honestly recorded (4.54/3.85/11.75 at start) but uncontrolled. The 10K-doc receipt exists (INITIAL p50 1.0 ms, REFINED p50 7.6 ms), but nothing receipted approaches a real corpus scale or a second machine class [Verified, High].
6. **[MEDIUM] Known concurrency limit in the headline CLI workflow.** `fsfs watch` holds the vector generations' exclusive writer lock for its whole life, so concurrent `fsfs search` (and the query daemon) is refused with `fsvi.map_lock` until the watcher stops (bd-z2nfa). The "keep index fresh + search it" story — the core fsfs loop — is documented-broken across processes [Maintainer claim, High].
7. **[MEDIUM] Scope sprawl in the fusion crate.** 62,911 lines containing federated search, conformal calibration, hubness correction, graph ranking, MMR, PRF, interaction lanes/oracles, daemon fallback — research machinery far beyond RRF+blending. The ops crate (39,153 lines) is experimental with no shipped telemetry source and no dependents. Breadth without users is maintenance surface [Counted + Maintainer claim, High].
8. **[MEDIUM] The model-revision treadmill is load-bearing and user-hostile.** 1.7/1.8 semantic indexes need explicit rebuilds; 1.9.x → 1.10.0's adapter change needs rebuilds again; producer fingerprints fail closed rather than migrate. Correct behavior, but every embedding-model or adapter change is a user-facing reindex event with no migration path [Maintainer claim, High].

**Bear-case steelman (strongest counter-case):** frankensearch is a single maintainer's agent-swarm performance about *how to measure search*, not a search engine anyone has validated. Its latency numbers are receipted but measure a synthetic 1K-doc corpus; its ranking quality is unmeasured by its own admission; it re-derived BM25 in 139,500 lines to replace a dependency it still needs as a test oracle — competing with its own fixture; `main` was reported uncompilable a day before this assessment; the ops/fleet story is 39k lines of experimental code with no users; and the license forbids the AI labs whose agents are the likeliest consumers of its agent-friendly CLI. The rational market response is to mine it for methodology (receipts, gauntlets, comparison classes, negative-evidence ledgers) and never depend on it. Its most likely end state is a well-instrumented monument: the best-measured search engine nobody runs [Inference, Medium — deliberately uncharitable; the counter-evidence is the release discipline and the gauntlet's falsifiability, which most monuments lack].
## 4.8 Maintenance & succession

**Bus factor: 1.** One human maintainer (Jeffrey Emanuel); all 120 commits in the deepened window are his (58 as Dicklesworthstone <jeff141421@gmail.com>, 47 + 12 as Jeff Emanuel, 3 as Jeffrey Emanuel) [Git-observed, High]. Six of 120 carry agent Co-Authored-By trailers — a lower agent-authorship rate than sibling repos, though the repo's *process* is heavily agent-mediated (agent mail, beads, cass, RCH, swarm-oriented AGENTS.md) [Git-observed, High]. No succession plan, no second committer, no foundation [Inference, Medium — absence of evidence across the assessed materials]. If the maintainer stops, the 60-day abandonment tripwire (trajectory trigger 9) is the observable sensor; the tree freezes at whatever commit the stop happens on [Inference, High].

**Maintenance load signals:** extreme velocity — 120 commits in ~3.5 days (2026-09-18 → pin), roughly **34 commits/day** [Git-observed, High] — and extreme breadth (883k lines, 15 members, 5 embedding backends, 2 lexical engines, a TUI framework, an ops fleet console) cut both ways: dedication, and a workload no successor inherits casually. The 48 KB AGENTS.md is the closest thing to institutional knowledge transfer, and it is written for *agents*, not humans — including named sections for Claude Code and Codex/GPT-5.2. **In-repo drift instance:** that same AGENTS.md's "This Project" section (L276, L282, L306) still describes the lexical arm as "Tantivy BM25" — stale since the 2026-09-01 Quill-default ruling. The project's own agent manual lags its own architecture by three weeks [Code-verified, High]. The bead tracker (1,298 issue lines) lives in-repo, which is good; review depth (who reviews bead closures, PRs-vs-direct-to-main) is unassessed [Not verified].

**License — the rider, scoped precisely (LICENSE read verbatim at pin):**

- **Title:** "MIT License (with OpenAI/Anthropic Rider)"; copyright 2026 Jeffrey Emanuel.
- **Restricted parties:** "OpenAI, L.L.C.; Anthropic, PBC; any of their respective Affiliates; and any person or entity acting directly or indirectly on behalf of, for the benefit of, or under the direction of any of the foregoing (including any officer, director, employee, contractor, agent, consultant, service provider, or representative)." (quoted verbatim)
- **Grant:** "no rights are granted to any Restricted Party" without "express prior written permission"; any purported permission to a Restricted Party "is null and void."
- **Scope:** bars providing or permitting access to "the Software or any derivative work" to or for a Restricted Party.
- **"Use" is defined expansively** — "copying, modifying, merging, publishing, distributing, sublicensing, selling, transferring, making available, hosting, deploying, executing, benchmarking, testing, analyzing, indexing, or incorporating the Software or any Derivative Works into any dataset, training corpus, evaluation harness, or pipeline for machine learning or other automated systems." (quoted verbatim)
- **Remedy:** breach "automatically and immediately terminates" the permissions; the author reserves injunctive/equitable relief and attorneys' fees; distributions must include the rider unmodified.
- **Classification:** non-OSI, source-available. Named-party discrimination fails OSD §5; the benchmarking/training/analysis bar fails OSD §6 [Inference, High — legal conclusion, not legal advice].

**The rider as strategy (§6 cross-cutting lens):** it excludes exactly the two AI labs plus their affiliates and anyone acting for them — and here the exclusion bites harder than in sibling repos, because frankensearch's stated beachhead is *agent workloads*: `--stream` JSONL/toon output, `explain` surfaces, progressive iterators mapped to tool-call latency budgets. The agents that would consume this are operated by, or built on models from, the named Restricted Parties; the repo's own contributor manual addresses Codex (OpenAI) agents by name. The rider doesn't just shrink the contributor pool — it names the target user as forbidden [Inference, Medium]. What it arguably *serves* is defensive: denying 883k lines of curated retrieval code to rival training corpora. But the cost is asymmetric and self-negating for an agent-facing product: the project selects for adopters who are not its best users [Inference, Medium].

**Succession consequence:** even a willing acquirer inherits a license that shrinks the contributor and evaluator pool; removing the rider requires the sole copyright holder's action — the same single point of failure as everything else [Inference, Medium].

## 4.9 NODUS factsheet

| Criterion | Score | One-line justification |
|---|---|---|
| Technology readiness | **TRL 5–6** | Lab/relevant-environment validation: receipted latency on real models and hardware, multi-platform release binaries, 13-member crates.io family — but relevance quality unmeasured by the maintainer's own admission, and compile state unverified at the pin [Inference, Medium] |
| Strategic relevance | 4/5 | Latency-budgeted progressive retrieval is directly relevant to agent tool-call workloads — the program's own agent-era direction — but the rider blocks the program's engagement with the software [Inference, Medium] |
| Impact potential | 3/5 | The progressive-iterator + receipted-latency lane is genuinely unoccupied; but no independent user, no quality benchmark, and the rider caps the ceiling [Inference, Medium] |
| Implementation feasibility | 3/5 | Real releases and installer lower adoption cost vs. siblings, but: 883k lines, nightly-only toolchain, bus factor 1, model-revision reindex treadmill, and the rider travels with every artifact [Inference, Medium] |
| Time to mainstream | 2/5 | Years at best: relevance benchmarks, a second maintainer, rider narrowing, and a compile-verified main must all happen first [Inference, Low] |
| Collaboration potential | 1/5 | The rider bars the likeliest collaborators (AI labs and their agents) from even analyzing the code; bus factor 1 [Inference, Medium] |

**Ring: Explore** [Inference, Medium]. The Rulebook's default for substantive-but-unproven, and the factsheet above is the scaffolding. Pilot requires "a release artifact plus a bounded, real workload fit" — release artifacts exist, but the only demonstrated workload is the maintainer's own swarm; no independent party has validated a bounded fit, and relevance quality is unmeasured. The rider is the advancement blocker (priced into feasibility 3, collaboration 1, wired to trajectory trigger 3). **Explore-with-a-ceiling**, currently un-advanceable past Explore while the rider stands and quality evidence is absent. No Rulebook amendment; v1.0 stands.

**Methodology fit (for the FrankenSuite):** adopt the patterns, not the package — the machine-readable receipt schema, the SELF-SPEEDUP/INCUMBENT comparison classes, the negative-evidence ledger discipline, and the differential gauntlet against a pinned oracle are directly importable into how the program evaluates the other 43 repositories. Do not depend on the software: the rider, the unproven relevance, the unverified compile state, and the nightly toolchain disqualify it as a dependency or benchmark target today. If the program needs hybrid search, the receipt discipline is the takeaway — not the engine [Inference, High].

## 4.10 Wardley placement

Placing the *components*, not the repo:

- **Commodity — BM25, RRF (K=60), ONNX embedding models (potion-128M, MiniLM-L6-v2), the Tantivy-oracle pattern.** Inherited algorithms and models; commodity by definition. RRF's optimality claims trace to Cormack et al. 2009 — table stakes, not differentiation [Inference, Medium]. Moves right only if the model layer moves: a new default embedding model with a different producer fingerprint forces a reindex campaign across every generation.
- **Custom-built, approaching early Product — the two-tier orchestrator + `fsfs` CLI** (progressive `SearchPhase` iterator, daemon, watch mode, `--stream` agent surfaces, checksum-verified installer with full/lite/embedded profiles). Custom-built on process rigor; early product by release artifacts (v1.10.0 binaries, crates.io family) but not yet product by independent adoption [Inference, Medium]. Moves right with an independent quality benchmark and a second maintainer; decommissions into a monument if an incumbent ships progressive delivery first.
- **Custom-built, closest to Product — the receipt + ledger + gauntlet evidence machinery.** The packet's "real export" (§4.9): machine-readable latency receipts, 19k-line negative-evidence ledger, comparison-class policy, content-addressed gauntlet certificates. The most *executed* component in the tree — used operationally in-repo, but not yet packaged for external adoption. Moves right if extracted as a standalone benchmark-evidence framework; stays repo-local tooling while the rider blocks the likeliest adopters [Inference, Medium].
- **Genesis — frozen producer identities with fail-closed mixing, RaptorQ-protected vector generations, the progressive iterator as a search API.** No incumbent ships "answer now, refine within budget" as a first-class iterator contract, or per-generation embedding provenance that refuses to mix spaces. Moves right if the iterator contract becomes a reviewed, cross-project API (the agent-tooling direction); stagnates as single-maintainer machinery if velocity decays [Inference, Medium].

**Residual product gaps (what's missing / risky):**

1. **No relevance benchmark** — the standing gap the maintainer names himself (SEARCH_QUALITY_FINDINGS.md). Latency without measured quality is half a search engine.
2. **Watcher/search concurrency** — bd-z2nfa: exclusive writer lock refuses concurrent search while watching; the core fsfs loop is documented-broken across processes.
3. **Compile state at the pin unverified** — the prior assessment's failure report is neither confirmed nor refuted (§4.13).
4. **Model-revision treadmill** — every adapter/embedder change is a user-facing reindex; no migration path, only fail-closed refusal.
5. **Ops/fleet story is experimental** — 39k-line `frankensearch-ops` with no shipped telemetry source and no dependents (bd-p6k61).
6. **Nightly-only toolchain** — `nightly-2026-08-31` pinned; stable-Rust consumers cannot build it, which shrinks the library-adopter pool independently of the rider.
7. **README-vs-code drift risk** — the assignment brief's "lexical (Tantivy BM25)" description was stale at assessment time (Quill is the default since 2026-09-01); external descriptions of the project lag the code by weeks.
8. **The gauntlet's greenness at the pin is unestablished** — the machine that can falsify Quill exists, but whether it currently passes was not verified.
## 4.11 Trajectory (12 / 24 / 60 months)

All horizons **[Inference]** — forecasts, not findings; confidence Low unless noted.

**12-month base case [Inference, Medium]:** velocity continues through the agent swarm; the Quill parity tail shortens bead by bead; the gauntlet stays the project's conscience; no relevance benchmark lands (the SEARCH_QUALITY_FINDINGS evidence standard is expensive and the maintainer's energy is spread across 15 crates); no fsfs binary release newer than 1.10.0 qualifies (the September CLI work — complete-generation integration, Unix-socket serving — stays unreleased); the rider stands. The methodology gets mined (receipt schemas, comparison classes appear in sibling projects); the software gets no independent users. Ring: Explore, unchanged.

**24-month base case [Inference, Low]:** one of two shapes. Either the program compounds — a labeled-corpus quality receipt lands, the watcher lock limit is fixed, `main` is compile-verified in this program's own environment, and the packet's checklist starts scoring above zero — or velocity decays after the initial program arc completes and the tree enters maintenance drift (nightly pin rot, model-revision treadmill outrunning the maintainer, README drift compounding). The base case leans toward the second shape on bus-factor-1 priors, but the release discipline (real binaries, real registry) is a genuine counterweight most solo projects lack.

**60-month base case [Inference, Low]:** the software is either a niche artifact with a small agent-tooling following or dormant — the abandonment end state in the §4.7 steelman. The methodology-export (receipt schema, SELF-SPEEDUP/INCUMBENT classes, negative-evidence ledgers, differential gauntlets) is the durable survivor either way.

**Bifurcation — what the upside requires:** all four, in rough order: (a) a labeled-corpus quality receipt — Quill vs Tantivy oracle and two-tier vs lexical-only on BEIR or equivalent, meeting the maintainer's own SEARCH_QUALITY_FINDINGS standard (trigger 2); (b) the rider narrowed or removed (trigger 3) — without this nothing else matters for adoption; (c) compile-verified `main` plus a second human committer (triggers 1, 4); (d) a newer fsfs binary release landing the September CLI work with the watcher-lock limit fixed. The quality receipt is the *necessary* condition here in a way the rider isn't: even with the rider gone, a search engine with unmeasured relevance is un-adoptable.

**Bifurcation — what decay looks like:** commit velocity falls off a cliff (the observable sensor is trigger 9), the nightly pin rots (a 2026-08-31 nightly stops building on newer hosts), the model-revision treadmill forces reindexes nobody performs, and the tree freezes as an 883k-line monument. Decay is the default outcome for bus-factor-1 infrastructure without institutional capture — the base case, not the tail.

**Revisit triggers (observable, falsifiable):** check any of these; each names the exact observation that flips it:

1. **`main` compiles in an independent environment** — `cargo check --workspace` (or the `dsr quality` gate) green at a new pin, observed by a party other than the maintainer. Flips the §4.13 hole.
2. **A labeled-corpus quality receipt is committed** — nDCG/recall of Quill vs the Tantivy oracle and two-tier vs lexical-only, meeting the SEARCH_QUALITY_FINDINGS evidence standard (labeled, held-out queries, matched candidate coverage, per-corpus paired comparisons). Flips the relevance gap — the single most load-bearing missing evidence in the packet.
3. **Rider narrowed or removed** — LICENSE diff dropping the named-party restriction. Flips usability for restricted parties and contributor-pool risk. Advancement blocker for the Explore ceiling.
4. **Second human committer with merge rights** — bus factor > 1 observable on the contributor graph. Flips succession risk.
5. **Watcher-lock limit fixed** — bd-z2nfa closed with concurrent search-during-watch demonstrated. Flips the core-CLI-loop gap.
6. **Independent benchmark or review published** — any third party reproducing the receipts or contesting the quality. Flips "zero independent coverage."
7. **A newer fsfs binary release** — GitHub Release > 1.10.0 landing the September CLI work (complete-generation integration, Unix-socket serving). Flips the "unreleased work" judgment.
8. **An incumbent ships progressive delivery** (Meilisearch/Typesense/Qdrant: answer-now-refine-later as a first-class API) — the kill-test: if incumbents absorb the progressive story, frankensearch's differentiation collapses to "Rust, but unproven" [Inference, Medium].
9. **Abandonment tripwire** — no commits for 60 days or the repo archived: re-ring to Monitor and treat the tree as a retired artifact. The decay sensor the steelman's end state needs.

## 4.12 Verdict & NODUS ring

**NODUS ring: Explore.** The Rulebook's default for substantive-but-unproven fits without strain: substantive (883,079 lines, real release binaries, a 13-member crates.io family, receipted latency, a differential gauntlet — all verified) and unproven (relevance quality unmeasured by the maintainer's own admission, compile state unverified at the pin, zero independent coverage, bus factor 1). "When in doubt, ring down" does not apply — there is no doubt about the Explore floor; the doubt is about advancement, which the rider and the missing quality evidence block. The rider is correctly instrumented as an **advancement blocker**: quoted as the adoption ceiling in §4.8, priced into the NODUS feasibility (3) and collaboration (1) scores, and wired to revisit trigger 3. The ring reads: **Explore — substantive, partially validated on latency, unproven on quality, and currently un-advanceable past Explore while the rider stands and no relevance receipt exists** [Inference, Medium]. No Rulebook amendment; v1.0 stands.

**The one-paragraph case:** frankensearch is an 883k-line bet that search infrastructure should be progressive (answer in milliseconds, refine within budget), receipted (every number bound to a git revision, a host, and a load average), and adversarially honest (a gauntlet that grades its own engine against the incumbent it replaced, a ledger of reverted experiments, a public correction when it oversold its own hash embedder). On instrumentation it is the best in the FrankenSuite. But the product case is half-built at the pin: ranking quality is unmeasured by the maintainer's own admission, `main` was reported uncompilable a day before this assessment and couldn't be re-verified, one human is the entire bus factor, and the license forbids the AI labs whose agents are the likeliest users of its agent-friendly CLI. Explore the methodology; the software stays behind the rider's ceiling until triggers 2 and 3 fire. [Inference, Medium — a recommendation plus a forecast, both the analyst's judgment.]

## 4.13 Limitations and open questions (analyst-facing)

**What was not done:** the workspace was never compiled — **no Rust toolchain exists on the analysis host** (`command -v cargo` and `command -v rustc` both empty; no `~/.cargo/bin`, no `/usr/local/cargo`), so the prior assessment's 2026-09-21 "main failed to compile" report is neither confirmed nor refuted; the prior report stands as the latest compile-state evidence. No binary was executed; no test suite was run (so the gauntlet's greenness at the pin, the quorum of `#[test]` markers counted — 59 in rrf.rs, 159 in searcher.rs, 41 in simd.rs — and the `dsr quality` gate are all unexecuted); no benchmark was reproduced; no model was downloaded (the 621 MB artifacts were not fetched); the full commit history was not pulled (authorship covers the 120-commit deepened window); review depth (PRs-vs-direct-to-main, who reviews bead closures) was not examined; per-crate `#![forbid(unsafe_code)]` claims were independently re-verified in the v2 round (the four named crates match).

**Open questions that would most change the verdict, in order of load-bearing weight:**

1. **Does `main` compile today?** The single most urgent unknown. A green `cargo check --workspace --all-targets` at a new pin would close the packet's biggest hole; a continued failure would harden §4.7 weakness 2 into a finding.
2. **Does Quill beat (or match) the Tantivy oracle on relevance?** A labeled-corpus receipt per the maintainer's own evidence standard would flip the relevance gap — the packet's central missing evidence.
3. **Is the gauntlet green at the pin?** The falsification machine exists; whether it currently passes determines whether Quill's parity claim is live or aspirational.
4. **Who downloads the binaries?** The v1.10.0 asset download counts (60 linux-gnu full, 1,202 lite musl — the lite-musl count is likely installer-driven [Inference, Medium]) suggest real but thin usage; one confirmed independent user would move impact potential more than any code change.
5. **What is the review depth?** PRs-vs-direct-to-main, whether any of the 1,298 bead issues saw a second pair of eyes — determines whether the bead tracker is institutional knowledge or a solo diary [Not verified].
6. **Does the rider bar this very assessment?** The license's "analyzing" prohibition arguably covers the FrankenSuite's evaluation activity — and the repo's AGENTS.md courts Codex (OpenAI) agents by name. A legal reading either way changes whether the program may continue touching the repo at all.

---

## Deepening questions — Rulebook §5's binding eight, one paragraph each

*§5→location mapping: Provenance ← frozen producer identities + receipt schema + gauntlet cutoff certificates (claims 12, 1); Embeddable unit ← new, sourced from the workspace's independently-published crates (claim 9); Unexercised option value ← three held capabilities (ANN, RaptorQ default-off posture, fusion-crate research machinery); Benchmark honesty ← §4.5 plus the receipt JSON cross-check (claim 1); Governance path ← §4.8 plus §4.7 weakness 3 (bus factor); License as strategy ← §4.8 plus §4.7 weakness 4 (rider); Agent-era fit ← new; Kill test ← §4.7's bear-case steelman plus trajectory trigger 8.*

**1. Provenance.** The repo records *what produced what* at three layers: per-index-generation frozen producer fingerprints (`producer_fingerprint: [u8; SHA256_BYTES]`, `identity.freeze()`) that fail closed when embedding spaces are mixed [Code-verified, High]; per-number machine-readable receipts binding latency to git revision, hostname, load average, and model identities [Verified, High]; and per-gauntlet-campaign content-addressed cutoff certificates with SHA-256 domain separation (`frankensearch/quill-gauntlet/cutoff-certificate/v1`) [Code-verified, High]. Portable attestation is closer here than in most repos — the certificate format is already content-addressed and domain-separated — but nothing is *signed* and nothing records *who* produced an artifact (the ledger logs events and revisions, not authors), so a receipt is auditable but not attributable. What it would take: sign the receipts and certificates with the maintainer's key at generation time and bind the signature into the JSON — the schema already has the fields; only the signature is missing [Inference, Medium].

**2. The embeddable unit.** The smallest useful piece adoptable without the whole repo is `frankensearch-index`: the FSVI f16 SIMD vector index (brute-force top-k, memmap2 zero-copy reads, fsync'd saves, frozen producer identities) — independently published on crates.io as 0.3.1 with 4,148 downloads [External, High]. Second candidate: `frankensearch-quill` (0.3.1, 751 downloads), the native BM25 engine, for anyone who wants Tantivy-shaped lexical search without the Tantivy dependency. Adoption cost: the pinned `nightly-2026-08-31` toolchain (stable-Rust consumers are excluded), the workspace's dependency assumptions (asupersync for the async paths, `half`/`wide` unconditional), and the producer-identity discipline — your embeddings must carry a frozen fingerprint or the index refuses them, which is a feature but also a migration tax [Inference, Medium].

**3. Unexercised option value.** Three capabilities the architecture holds but hasn't used. First, ANN: native HNSW via the pinned `frankenhnsw` fork is feature-gated (`ann`) and wired into the index, but the receipts only cover brute-force top-k — the approximate path is held in reserve [Code-verified, High]. Second, the fusion crate's research machinery — federated search, conformal calibration, hubness correction, graph ranking, MMR, PRF — 62,911 lines of held capability with no demonstrated product surface; it is either a future moat or 60k lines of maintenance surface, and nothing in the assessed materials decides which [Inference, Medium]. Third, RaptorQ FEC sidecars exist for both vector generations (v1.8.0) but their recovery path was not demonstrated in this assessment — "survives bit-rot" is held option, not load-bearing differentiator [Code-verified, High on existence; Inference, Medium on status]. What unlocks each: an ANN-vs-brute-force quality/latency receipt, a product surface that actually calls the fusion research modules, and a demonstrated recovery drill for the sidecars [Inference, Medium].

**4. Benchmark honesty.** The numbers most likely to survive an independent rerun are the maintainer's own latency receipts — the JSON was cross-checked against the README and matches to the decimal on the initial path (p50 0.395 ms vs README's "p50 0.40 ms"), with a minor phase2 drift (JSON p50 5.11 ms vs README "p50 5.5 ms") that reads as honest rounding or a different cut rather than inflation [Verified, High]. The honesty apparatus around them is the real story: the SELF-SPEEDUP/INCUMBENT comparison-class policy, the 19k-line negative-evidence ledger, the explicit *target*-vs-*receipt* labeling, and the host-pressure disclosures (daemon rerank p50 412 ms at load 63 vs 233 ms at load 9). Which numbers are load-bearing for the thesis? The latency budgets (<15 ms / ~150 ms) — and they are beaten 25x/37x on the receipted corpus, which paradoxically weakens their load-bearing status: the thesis doesn't need them to be impressive, only true. The load-bearing *missing* numbers are the relevance ones — and the maintainer's own doc says so [Inference, Medium].

**5. The governance path.** The credible route from one maintainer to an institution runs through four gates in rough order: compile-verified `main` in an independent environment, a labeled-corpus quality receipt, the rider narrowed or removed, a second human committer (trajectory triggers 1–4). The starting position: no succession plan, no second committer, no foundation; the closest thing to institutional knowledge transfer is the 48 KB agent-oriented AGENTS.md and the in-repo bead tracker (1,298 issue lines) [Inference, Medium on the absences]. What breaks first if velocity decays: the nightly toolchain pin (a 2026-08-31 nightly rots as hosts move on), then the model-revision treadmill (each adapter change is a user-facing reindex), then the README audit cadence — the 60-day abandonment tripwire (trigger 9) is the observable sensor [Inference, Medium]. The realistic institutional endpoints are a foundation home or a corporate adopter — both currently gated on rider removal, which is why trigger 3 is the advancement blocker rather than a nicety [Inference, Low].

**6. The license as strategy.** The rider excludes exactly: OpenAI, L.L.C.; Anthropic, PBC; their affiliates; and anyone "acting directly or indirectly on behalf of, for the benefit of, or under the direction of" them — barring "use" defined to include benchmarking, testing, **analyzing, indexing**, and incorporation into training corpora or evaluation harnesses, with automatic termination on breach [Code-verified (license text), High]. Does the exclusion serve or sabotage the stated mission? For frankensearch it sabotages more sharply than for siblings: the product's beachhead is agent workloads (`--stream` JSONL/toon, `explain` surfaces, progressive iterators for tool-call budgets), and the agents that would consume it are operated by — or built on models from — the named Restricted Parties; the repo's own contributor manual addresses Codex (OpenAI) agents by name. The project courts its forbidden parties in its docs while barring them in its license [Inference, Medium]. What the exclusion arguably *serves* is defensive: denying 883k lines of curated retrieval code to rival training corpora. But a project whose moat is *evidence* forbidding evidence-gathering is self-negating, and here the negation lands on the target user [Inference, Medium].

**7. Agent-era fit.** The concrete agent workload that would pick this over the incumbent is **local codebase RAG inside an agent harness**: an agent with a 15 ms tool-call budget gets `Initial` results now and `Refined` results if the budget allows — the progressive iterator is literally shaped like an agent's latency budget, and `--stream` JSONL/toon plus `explain` surfaces are built for machine consumers, not humans [Inference, Medium]. The `fsfs watch` + daemon story is the longer-horizon fit: a persistent, incrementally-updated index the agent queries without re-scanning the filesystem. What would have to become true first: `main` compile-verified (the agent can't build a broken tree), the watcher-lock limit fixed (bd-z2nfa currently refuses concurrent search during watch — the exact multi-process pattern an agent harness uses), the rider narrowed or removed (the agent operators are named Restricted Parties), and a labeled-corpus quality receipt (an agent that retrieves badly is worse than one that retrieves slowly) [Inference, Medium]. The fit is real but presently blocked on four independent gates — the license aimed at its own likeliest users being the sharpest [Inference, Medium].

**8. The kill test.** The single experiment that would falsify the core thesis — that a homegrown lexical engine plus two-tier progressive fusion is a better retrieval primitive than the incumbents — is the one the project built for itself and hasn't run to completion: extend the quill-gauntlet from conformance to **quality**, i.e., a labeled-corpus (BEIR or equivalent) comparison of Quill vs the pinned Tantivy oracle and two-tier vs lexical-only, meeting the maintainer's own SEARCH_QUALITY_FINDINGS evidence standard. If Quill loses to its own oracle on nDCG, or the quality tier fails to improve on lexical-only fusion, the thesis is falsified by the project's own machinery, not by a critic [Inference, Medium]. Two secondary falsifiers sit behind it: a competitor move (Meilisearch/Typesense/Qdrant shipping progressive delivery as a first-class API — trajectory trigger 8), and the abandonment tripwire (trigger 9: 60 days without commits re-rings to Monitor). The production checklist is the inverse of this test — what success requires, scored at the pin as 0 of 8 fully met: compile-verified main, labeled-corpus quality receipt, gauntlet green at the pin, watcher-lock fixed, newer fsfs binary release, rider narrowed, bus factor > 1, independent benchmark. Zero for eight is the honest score [Inference, Medium].

---

*Rulebook amendment log: none. v1.0 stands.*