# franken-agent-detection — RULEBOOK v1.0 Assessment Packet v5

**Repository:** `Dicklesworthstone/franken_agent_detection` · **Language:** Rust [Code-verified, High] · **Pinned commit:** `026f60b28784ca77c5b8e47e3dba9b22d154b4d9` (2026-09-22 04:29:33 UTC, [Git-observed, High]) · **Last push:** 2026-09-22 (pin date) [Git-observed, High] · **Created:** 2026-02-16 [External, High] · **License:** MIT, 21 lines, **no rider** — read verbatim [Code-verified, High] · **Stars/forks:** 14 / 26 [External, High] · **Assessment date:** 2026-09-22 · **Scope:** the pinned commit (shallow clone; single commit visible locally, so commit velocity could not be measured from git history).

**Program-context correction (material):** program-level descriptions had characterized this repo as "spec + docs stage." That characterization is **stale and wrong at the pin** [Inference, High — the assessed tree is a 61,281-line published crate at v0.3.0 with 21,189 crates.io downloads and a real downstream consumer]. The packet assesses what is there, not what the description said. Per Rulebook §0.4, this staleness is reported as a finding, not a footnote: repo descriptions rot fast in this ecosystem.

**Method (analyst):** shallow clone at the pin under `~/workspace/.scratch/fad` (non-empty, verified); read `Cargo.toml`, `rust-toolchain.toml`, `LICENSE` (verbatim, 21 lines), `README.md` (full), `CHANGELOG.md` (timeline + release-vs-tag honesty block), `docs/planning/UPGRADE_LOG.md`, `.beads/issues.jsonl` (16 entries; *bead*: the repo's issue-tracker unit), all five GitHub workflow files, `src/lib.rs` (detection API + registry + canonical maps), `src/types.rs` (provenance types), `src/connectors/mod.rs` (trait + compiled constructor registry). Counted: `.rs` files/lines, `#[test]` annotations, `unsafe` occurrences, `KNOWN_CONNECTORS` slugs, constructor-registry entries, fixture files. Queried: GitHub REST (repo metadata, Actions runs + per-job conclusions for the pin), crates.io API (crate record, version/download counts, reverse dependencies — with a research user-agent; HTML page fetches were bot-filtered, noted below). **Not done:** the crate was never compiled, no test was executed by the analyst, no fixture was parsed, the ChatGPT decryption path was not exercised, download counts were not decomposed into users vs CI churn, the `release.yml` publish path was read but not end-to-end verified, CASS's runtime usage was not inspected beyond its docs and commit messages.

**Tier legend (Rulebook §1):** **[Verified]** direct inspection of the pinned clone or a live page read by the analyst — 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

A 61,281-line [Counted, High], single-maintainer Rust crate that knows where 34 coding agents [Counted, High] keep their session data on your machine — published to crates.io at v0.3.0 with 21,189 downloads [External, High], carrying the only plain-MIT license in the FrankenSuite — the maintainer's program of clean-room Rust reimplementations of infrastructure software — [Code-verified, High], documented in its README as "installation detection only" while its `connectors` feature quietly normalizes transcripts, decrypts ChatGPT's encrypted conversation store, and reads SQLite session databases behind a synchronous API the README never mentions [Code-verified, High on the code; the README omission is Verified, High]. The sharpest tension is saved for §4.7: the main CI job at the pin dies at `cargo fmt` before a single one of the 1,226 tests executes [CI-observed, High] — though a smaller exclusions job does run green (claim 20).

---

## TL;DR

- **What it is:** A Rust library that answers "which coding-agent tools are installed on this machine?" via filesystem probes over 34 registered slugs, and — behind the `connectors` cargo feature — normalizes 32 agents' session transcripts into one stable schema (`NormalizedConversation`) with per-artifact provenance (`Origin`, `SourceKind`, `PathMapping`) [Code-verified, High]. Zero `unsafe` under a crate-wide `#![forbid(unsafe_code)]` [Counted, High].
- **Strongest evidence:** Real distribution (crates.io 0.3.0, 21,189 downloads; GitHub Release v0.3.0, 2026-09-16) [External, High]; a real downstream workload — the maintainer's 1,127-star [External, High] CASS session-search tool discovers sessions from 26 agent harnesses *through this crate* [Maintainer claim, Medium — the maintainer's own planning doc]; 1,226 tests including registry-invariant tests that fail the build on slug drift, fixture-wired schema conformance validators, and historical prompt-extraction diffs kept as checked-in patch files for review [Counted/Code-verified, High]; a CHANGELOG that warns "do not invent" missing releases [Code-verified, High].
- **Strongest doubts:** The README documents only the zero-feature detection API while ~90% of the code (the connector zoo) goes unmentioned, and its "Limitations" line ("no session parsing or indexing") is flatly contradicted by the code [Code-verified, High]; the main CI job is red at the pin — the `Format` step fails, so clippy/tests/packaging never executed on the assessed commit (a 7-test exclusions job is green at the pin, which bounds but does not remove the doubt) [CI-observed, High]; bus factor 1 with an explicit no-outside-contributions policy [Maintainer claim, High]; the connector zoo is a treadmill — new agents (Muse Code, Aug 2026) appear monthly and each upstream format change is a silent breakage [Inference, Medium].
- **NODUS ring: Pilot** [Inference, Medium] (TRL 6 — see §4.9). Release artifacts exist (crates.io + GitHub Release) and a bounded, real workload fit is demonstrated (CASS's connector layer). The caveat is that the only evidenced consumer is the maintainer's own sibling project — independence is unproven, which caps the ring at Pilot rather than Invest.

---

## Quick Links

Pin-relative blob links verified resolving (HTTP 200) 2026-09-22 [Verified, High]; workflow/API checks as noted:

1. [Repository](https://github.com/Dicklesworthstone/franken_agent_detection)
2. [README](https://github.com/Dicklesworthstone/franken_agent_detection/blob/026f60b28784ca77c5b8e47e3dba9b22d154b4d9/README.md)
3. [License (plain MIT, 21 lines, no rider)](https://github.com/Dicklesworthstone/franken_agent_detection/blob/026f60b28784ca77c5b8e47e3dba9b22d154b4d9/LICENSE) — read verbatim
4. [Changelog (with release-vs-tag honesty block)](https://github.com/Dicklesworthstone/franken_agent_detection/blob/026f60b28784ca77c5b8e47e3dba9b22d154b4d9/CHANGELOG.md)
5. [GitHub Release v0.3.0 (2026-09-16)](https://github.com/Dicklesworthstone/franken_agent_detection/releases/tag/v0.3.0) — page returns 200
6. [Connector trait + compiled registry (`src/connectors/mod.rs`)](https://github.com/Dicklesworthstone/franken_agent_detection/blob/026f60b28784ca77c5b8e47e3dba9b22d154b4d9/src/connectors/mod.rs)
7. [Provenance types (`src/types.rs`: `Origin`, `SourceKind`, `PathMapping`, `LOCAL_SOURCE_ID`)](https://github.com/Dicklesworthstone/franken_agent_detection/blob/026f60b28784ca77c5b8e47e3dba9b22d154b4d9/src/types.rs)
8. [CI workflow](https://github.com/Dicklesworthstone/franken_agent_detection/actions/workflows/ci.yml) — main job red at pin (Format step); see claim 10
9. [Codex exclusions workflow (green at pin, ubuntu + windows)](https://github.com/Dicklesworthstone/franken_agent_detection/actions/workflows/codex-exclusions.yml) — see claim 20
10. [docs.rs](https://docs.rs/crate/franken-agent-detection/latest) — returns 200
11. [crates.io API record](https://crates.io/api/v1/crates/franken-agent-detection) — confirms listing, 21,189 downloads, max 0.3.0 [External, High]. Note: the HTML page `https://crates.io/crates/franken-agent-detection` (the README badge target) returned 404 to scripted fetches — bot filtering, not a missing listing; the API record is the verified evidence and the badge URL is the canonical form.

---

## Did You Know

The README's "Limitations" section says "Installation detection only; no session parsing or indexing" — but the `chatgpt` cargo feature decrypts ChatGPT Desktop's **AES-256-GCM-encrypted** v2/v3 conversation stores (`aes-gcm 0.11`, `blake3`, `base64` in the feature's dependency set, 1,967-line `chatgpt.rs`) [Code-verified, High]. A crate documented as a filesystem-existence probe ships a decryption path for an encrypted chat database. The README's limitation line is not a simplification; it is contradicted by the dependency tree [Inference, High].

---

## Franken-worthy next steps

1. **Export the registry-invariant test pattern program-wide.** `registry_tables_agree_exactly` (lib.rs L2070) fails the build if the connector registry, tilde-expansion table, canonical-slug map, and factory registry disagree by even one slug — the crate's mechanical answer to the drift its own README exhibits. *Done when:* the pattern is extracted as a template and adopted by one sibling repo, where it must catch at least one real drift within 90 days or the export is declared a failure. [Inference, Medium]
2. **Prototype portable provenance on the existing `Origin`/`SourceKind` substrate.** Every scanned artifact already carries `source_id`, `SourceKind`, and `PathMapping`; add a signed envelope (content hash + producer attestation) and test portability by round-tripping a normalized corpus between two CASS instances with signature verification. This makes concrete the program's memory-capsule thesis — the idea, developed in the FrankenRedis deep-dive, that agents will carry portable provenance-attested memory while stores become interchangeable — on the one FrankenSuite component that already models artifact provenance. *Done when:* a corpus exported on machine A verifies on machine B with no shared state, or the attempt documents exactly which provenance field fails to survive. [Inference, Medium]
3. **Productize the upstream-drift canary.** The checked-in transcript fixtures (16 files: antigravity/codex/openhands), the fixture-wired schema conformance validators (bead `wlb`, closed), and the codex prompt/read-integrity regression tests are an early-warning system for upstream CLI format changes — the connector zoo's existential risk. *Done when:* the canary is extracted as a reusable template and fires on the next upstream format break *before* a user-reported issue, or it misses one and the miss is ledgered. [Inference, Medium]
4. **Write down the scan-budget discipline.** The 100 MB scan cap, bounded workspace caches, per-connector root scoping, and discover-before-parse (`discover_source_files`, so CASS can mirror artifacts before parser failures hide them) are a coherent methodology for touching users' data directories safely. *Done when:* the discipline is documented as the program's standard and applied to one currently uncapped sibling tool, with peak-RSS measured before/after on a large archive. [Inference, Medium]
5. **Treat the rider-free license as a natural experiment.** This is the only FrankenSuite repo with a plain-MIT, no-rider license; it is also the only one with a documented downstream integration (CASS) and 21k downloads. *Done when:* at the 6-month revisit, downstream integration counts and fork counts are compared against rider-bearing siblings, testing whether the rider correlates with adoption cost — publish the comparison either way. [Inference, Medium]

---

## 4.1 Why it exists — the market problem

**The problem, as the maintainer frames it:** many tools need to answer "which coding-agent connectors are available on this machine?" — and every project answers it ad hoc: `which codex` here, a `~/.codex` existence check there, inconsistent outputs, repeated bugs [Maintainer claim, Medium — the README's comparison table names "ad-hoc per-project checks" as the incumbent approach with "drift, inconsistent outputs, repeated bugs" as the cons]. The crate offers one consistent report shape, one probe flow, and test-friendly root overrides so downstream tooling (and snapshot tests) get deterministic answers [Maintainer claim, Medium].

**Who feels the pain:** builders of agent-adjacent tooling — session search/indexing (CASS), usage dashboards, multi-agent orchestrators — anything that must discover and then *read* the heterogeneous stores (JSONL rollouts, SQLite session DBs, encrypted chat archives) that 30+ agent CLIs scatter across a machine [Inference, Medium].

**Why now:** the agent-CLI zoo exploded in 2026 — the registry names 34 slugs, and Meta's Muse Code (new as of August 2026 per its module docs) already has a connector at the September pin, i.e. coverage within weeks of appearing [Code-verified, High on the module doc and the pin; the "within weeks" timing is Inference, Medium] — while each vendor ships its own undocumented, version-drifting store format. A normalization layer is valuable precisely because the formats are unstable and nobody else is maintaining the mapping [Inference, Medium].

**Demand-side check:** the demand is not hypothetical. The maintainer's own CASS tool (1,127 GitHub stars [External, High]; Homebrew/Scoop distribution [Maintainer claim, Medium — the maintainer's own planning doc]) discovers sessions from 26 agent harnesses *through this crate* [Maintainer claim, Medium] — its AGENTS.md pins `franken-agent-detection =0.2.3` on crates.io with a per-version capability changelog, and its commit history shows connector-by-connector integration (`feat(connectors): integrate Crush connector from franken_agent_detection`, 2026-03-25) [Maintainer claim, High]. crates.io reports 21,189 total downloads with 0.3.0 published 2026-09-16 [External, High]. Caveat: download counts are not users (CI churn, mirrors), and crates.io reverse-dependencies list no *external* dependents — the only evidenced consumer is the maintainer's sibling project [External, High on the API result; the interpretation is Inference, Medium].

**Why a library, not a tool:** stated implicitly by the shape — the zero-feature API (`detect_installed_agents`) is 4 always-on dependencies (`serde`, `thiserror`, `chrono`, `dirs`), synchronous, runtime-neutral, no network; the heavy connector machinery is opt-in cargo features [Code-verified, High]. The design says: be cheap to depend on, expensive only if you opt in [Inference, Medium].

**Adjacent context:** one entry in the FrankenSuite. Unlike its siblings, it carries **no AI-lab rider** — the license is 21 lines of plain MIT [Code-verified, High]. The README's contribution policy is blunt: no outside contributions accepted ("I do not accept outside contributions for any of my projects… it's my name on the thing"), though PRs may be *reviewed by Claude or Codex* via `gh` and then independently reimplemented — an irony the packet returns to in §4.8, muted here because the license itself excludes nobody [Maintainer claim, High].

## 4.2 What it is — repo TL;DR

A single-crate Cargo package (`franken-agent-detection 0.3.0`, edition 2024, rust-version 1.85, pinned `nightly-2026-08-31` toolchain [Code-verified, High]) in two layers: (1) a zero-feature detection API — `detect_installed_agents(&AgentDetectOptions)` walks 34 registered connector slugs, checks filesystem probe roots (with per-connector `root_overrides` for deterministic tests), and returns a versioned JSON-serializable `InstalledAgentDetectionReport` [Code-verified, High]; (2) an opt-in `connectors` feature with 32 scan-connector modules implementing the `Connector` trait (`detect` + `scan` → `Vec<NormalizedConversation>` + `discover_source_files` + optional streaming), shared `PathTrie`/workspace-cache/scan-budget infrastructure, token-usage extraction, and SQLite bridging for session databases [Code-verified, High]. 51 `.rs` files, 61,281 lines (src + tests) [Counted, High]; 1,226 `#[test]` annotations [Counted, High]; zero `unsafe` under crate-wide `#![forbid(unsafe_code)]` [Counted, High].

One-line verdict: **the FrankenSuite's only genuinely distributed library — a published, downloaded, downstream-consumed crate whose evidence discipline (registry-invariant tests, fixture-wired conformance, scan budgets, historical patches kept as review artifacts) is among the strongest in the program, documented by a README that describes a tenth of it and contradicted by its own Limitations section.** (NODUS: Pilot — see §4.9.)

## 4.3 Repo facts (claim inventory)

| # | Claim | Status | Evidence | Tier, Confidence |
|---|-------|--------|----------|------------------|
| 1 | Published on crates.io at 0.3.0 (2026-09-16); 21,189 total downloads | demonstrated | crates.io API record (name, max_version, per-version downloads) | [External, High] |
| 2 | GitHub Release v0.3.0; earlier Releases back to v0.1.4; CHANGELOG warns which tags lack Release pages ("do not invent them") — but its "There is no `v0.1.8` tag or Release" line has a blind spot: crates.io lists 0.1.8 (published 2026-05-20, not yanked, 3,949 downloads, the second-highest of any version) | demonstrated (with the blind-spot qualification) | CHANGELOG release-vs-tag block [Code-verified, High]; release page HTTP 200 [Verified, High]; the 2026-09-16 date is [Maintainer claim, Medium]; 0.1.8's registry existence is [External, High] |
| 3 | 51 `.rs` files, 61,281 lines across `src/` + `tests/` | demonstrated | `find … -name '*.rs' \| wc -l`; line count over both trees | [Counted, High] |
| 4 | Zero `unsafe` code; crate-wide `#![forbid(unsafe_code)]` in `lib.rs` | demonstrated | grep over `src/` + `tests/`: only `unsafe` hits are comments/doc references to `std::env::set_var` being `unsafe` in Rust 2024 | [Counted, High] |
| 5 | 34 known connector slugs in `KNOWN_CONNECTORS`; registry-invariant test fails the build on table disagreement | demonstrated | `src/lib.rs` L128–163 counted; `registry_tables_agree_exactly` test read | [Code-verified, High] |
| 6 | `detect_installed_agents` is synchronous, runtime-neutral, local-filesystem-only, no network; versioned report schema (`format_version: 1`) | demonstrated | Function + `AgentDetectOptions` read; always-on deps are only serde/thiserror/chrono/dirs | [Code-verified, High] |
| 7 | `Connector::scan()` normalizes transcripts to `NormalizedConversation` (messages, snippets, tool/skill invocations, token usage) — i.e., session ingestion, not just detection | demonstrated | Trait definition + `token_extraction` + per-connector `scan` impls (codex 2,837 lines, cursor 3,269, opencode 4,104) | [Code-verified, High] |
| 8 | ChatGPT connector decrypts AES-256-GCM v2/v3 encrypted conversation stores (`decrypt_file` constructs `Aes256Gcm` from a loaded key) | demonstrated | `chatgpt` feature deps (`aes-gcm 0.11`, `blake3`, `base64`) + `decrypt_file` in `chatgpt.rs` read | [Code-verified, High] |
| 9 | 1,226 tests; fixture-based conformance and read-integrity tests exist | demonstrated (count); partially demonstrated (conformance wiring) | `grep -c '#[test]'` summed over `src/` + `tests/` [Counted, High]; fixture dirs + `tests/codex_read_integrity.rs` read [Code-verified, Medium — tests counted and read, none executed] |
| 10 | Main CI job at the pin is red: `CI` run 35687081573 (head = pin) failed at the `Format` (`cargo fmt --check`) step; clippy/tests/packaging never executed | demonstrated | Actions REST `runs/{id}/jobs`: single job "Lint, Test, and Package" → conclusion failure, failing step "Format" | [CI-observed, High] |
| 11 | `Codex prompt integrity` workflow (file: `validate-codex-prompt-patch.yml`) failed 2026-09-20 | demonstrated | Actions runs list | [CI-observed, High] |
| 12 | License is plain 21-line MIT; **no AI-lab rider** | demonstrated | `LICENSE` read verbatim (full 21 lines) | [Code-verified, High] |
| 13 | CASS (1,127 stars [External, High]) consumes the crate: discovers sessions from 26 agent harnesses via it; pins `=0.2.3` in its AGENTS.md | demonstrated | CASS AGENTS.md dependency table; integration commit messages (all maintainer-authored docs) | [Maintainer claim, High] |
| 14 | Single maintainer; README contribution policy: "I do not accept outside contributions for any of my projects" (PRs may be reviewed by Claude/Codex but not merged) | demonstrated | README "About Contributions" section, quoted verbatim | [Maintainer claim, High] |
| 15 | README/mod.rs say "15 connectors"; the tree has 34 registry slugs and 32 scan connectors | stale (docs) | Doc comment `src/connectors/mod.rs` L3 vs `KNOWN_CONNECTORS` count vs constructor-registry count | [Code-verified, High] |
| 16 | README "Limitations: Installation detection only; no session parsing or indexing" | disproven (by the code) | `Connector::scan`, `NormalizedConversation`, SQLite bridging, ChatGPT decryption | [Code-verified, High] |
| 17 | frankensqlite (fsqlite) 0.4.1 + asupersync 0.5.0 as paired optional deps; sync bridge in `sqlite_sync.rs`; lockstep comment in Cargo.toml | demonstrated | `Cargo.toml` feature table + comments; bead `yh4` (migrate to Asupersync 0.5.0) closed | [Code-verified, High] |
| 18 | Open bead `8np`: registry slug `claude` vs connector module file `claude_code.rs` — canonical-slug alignment undecided since 2026-08-25 | demonstrated (open issue) | `.beads/issues.jsonl`; constructor registry uses `"claude"` while the module file is `claude_code.rs` | [Code-verified, High] |
| 19 | `.github/patches/` keeps 2 historical landed diffs (e.g. codex prompt-dedup refactor, "verified in 33/61 sampled files") as review artifacts; the workflow states they are "not applied by this job" | demonstrated | Patch files + `validate-codex-prompt-patch.yml` header comment, read | [Code-verified, High] |
| 20 | `Codex exclusions` workflow green at the pin: 7 tests (`cargo test --features connectors --test codex_exclusions`) on ubuntu + windows | demonstrated | Actions run 35687081588 (head = pin), conclusion success | [CI-observed, High] |

**What the inventory says in aggregate:** claims about *distribution and mechanism* verify at High confidence; the README is the weakest artifact in the repo — stale counts, an undescribed feature surface, and a Limitations line the code disproves. The test suite is large and well-designed, and a 7-test slice of it is green at the pin — but the main suite's greenness at the pin is unestablished (CI died at formatting before tests ran).

## 4.4 Codebase tour

**Package topology (single crate, [Code-verified, High]):** 42 files in `src/connectors/` = `mod.rs` + 7 infra modules (`scan`, `utils`, `path_trie`, `sqlite_sync`, `token_extraction`, `workspace_cache`, `conformance_tests`) + 2 special (`pi_wire`: shared pi-family wire parser; `copilot_vscode`: `pub(crate)` helper) + **32 agent connector modules** [Counted, High]; plus `src/lib.rs` (2,185 lines — detection API, registry, canonical-slug maps, tilde-expansion tables, tests), `src/types.rs` (provenance + normalized schema), `src/connectors/codex/{reader,user_prompts}` submodules.

**Slug accounting (the reconciliation):** 34 `KNOWN_CONNECTORS` slugs = 32 scan connectors (the compiled constructor registry in `mod.rs` has exactly 32 entries, [Counted, High]) + 2 detection-only slugs — `continue` and `windsurf` have filesystem probe roots in `lib.rs` but no scan connector [Code-verified, High]. Naming seams: the constructor registry registers the claude_code module's connector under slug `"claude"` (the `8np` bead tracks the filename-vs-slug decision), and `copilot::CopilotConnector` serves the `"github-copilot"` slug via the canonical map [Code-verified, High].

**Dependency posture:** 4 always-on deps (`serde`, `thiserror`, `chrono`, `dirs`) [Counted, High]; 14 cargo features gate everything else (`connectors`, `chatgpt`, `cursor`, `opencode`, `goose`, `hermes`, `crush`, `devin`, `codebuff`, `grok-bot`, `shelley`, `openclaw-sqlite`, `copilot-vscdb`, `all-connectors`) [Counted, High]. **No tokio, no async runtime anywhere** — the README's "Async runtime required: No" verifies [Code-verified, High]. Notable: `bloomfilter 3` and `once_cell` in the base `connectors` feature (scale machinery for large scans), `walkdir`, `tracing`, `dotenvy`. There is **no Cargo.lock in the git tree** (normal for a library; `cargo package` includes one for the published artifact per the `include` list) and **no `benches/` directory** [Code-verified, High].

**Data flow, end to end:**

- **Detection — `lib.rs`:** `detect_installed_agents(opts)` → normalize slugs via `canonical_connector_slug` (alias map: `codex-cli`→`codex`, `manicode`/`freebuff`→`codebuff`, …) → reject unknown slugs (`UnknownConnectors` error) → per slug, probe default filesystem roots or `root_overrides` → `InstalledAgentDetectionReport { format_version: 1, generated_at, installed_agents, summary { detected_count, total_count } }`, entries sorted by slug [Code-verified, High].
- **Registry governance — `lib.rs` tests:** `registry_tables_agree_exactly` asserts `KNOWN_CONNECTORS`, the tilde-expansion table, the canonical map, and the factory registry agree *exactly* — a new connector that forgets one table fails the build [Code-verified, High]. This is the crate's answer to drift, and it is why bead `8np` (the `claude`/`claude_code` misalignment) is tracked as an open task rather than silent rot.
- **Scan — `Connector` trait:** `detect()` → `DetectionResult`; `scan(ctx)` → `Vec<NormalizedConversation>`; `discover_source_files(ctx)` (pre-parse file inventory so callers like CASS can mirror artifacts before parser failures); `scan_with_callback` (streaming for connectors that support it — `supports_streaming_scan()`) [Code-verified, High]. `ScanContext` carries `ScanRoot`s with `source_id` provenance; `LOCAL_SOURCE_ID = "local"` marks on-machine sources [Code-verified, High].
- **Provenance — `types.rs`:** `NormalizedConversation { agent_slug, external_id, title, workspace, source_path, started_at, ended_at, metadata, messages }`; `NormalizedMessage` adds `invocations: Vec<NormalizedInvocation>` (structured tool/skill calls) and `snippets`; `Origin { source_id, kind: SourceKind }`, `Platform`, `PathMapping` [Code-verified, High]. Every artifact knows where it came from — the substrate §4.11's memory-capsule direction builds on.
- **SQLite bridging — `sqlite_sync.rs`:** fsqlite's async (`!Send`) engine is driven to completion behind the connectors' synchronous API; Cargo.toml comments state fsqlite 0.4 "names asupersync 0.5.x types in its public API, so the two must move in lockstep" — the asupersync relationship is **present and load-bearing** (optional, feature-gated), not assumed or rejected [Code-verified, High]. Used by cursor/opencode/goose/hermes/crush/devin/shelley/openclaw-sqlite/copilot-vscdb features.
- **Token accounting — `token_extraction.rs`:** per-agent token usage extraction (`extract_codex_tokens`, `extract_claude_code_tokens`, `extract_tokens_for_agent`, model normalization) — the unexercised metering option (Q3) [Code-verified, High].
- **The zoo (selected):** `codex.rs` (2,837 lines — rollout JSONL reader + prompt-integrity handling), `cursor.rs` (3,269 — `state.vscdb` SQLite + workspace attribution), `opencode.rs` (4,104 — largest connector), `claude_code.rs` (2,529), `chatgpt.rs` (1,967 — AES-GCM decryption), `shelley.rs` (3,032 — one-WAL-DB-many-conversations + FTS5), `muse.rs` (Meta's terminal agent, "new as of August 2026" per its own docs — the treadmill made visible), `vibe.rs` (Mistral), `prime_agent.rs` (1,912), `antigravity.rs` (Google's IDE store + CLI store dual probing), `devin.rs` (detection-only without the `devin` feature; bead `rqa` tracks enabling SQLite scans in `all-connectors` builds) [all Code-verified, High on existence/size].
- **Historical patches as method:** `.github/patches/` keeps 2 landed diffs (e.g. the codex dual-stream prompt-dedup refactor, whose comments cite "verified in 33/61 sampled files" — empirical sampling of real rollouts) as review artifacts; the validating workflow (file `validate-codex-prompt-patch.yml`, job name "Codex prompt integrity") states explicitly they are "not applied by this job" [Code-verified, High]. This is a proof-bundle analog: the reasoning behind a parser change is preserved next to the code.

**Drift ledger (README-vs-code):** (a) `mod.rs` L3: "used by all 15 connectors" — 34 slugs at the pin; (b) README documents only the zero-feature API — the `connectors` feature (the bulk of 61k lines) is never mentioned, no feature table, no `Connector` trait docs; (c) README "Limitations: …no session parsing or indexing" — disproven (claim 16); (d) README "Design goals" and comparison table describe only detection. The README is accurate for what it covers and silent-to-wrong about the rest — a structural liability for a crate whose pitch is *stable machine-consumable output* [Code-verified, High].

## 4.5 The maintainer's stated case

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

1. **One report shape:** stable, JSON-serializable `InstalledAgentDetectionReport` for downstream tooling and snapshot tests [Maintainer claim, Medium — the shape is code-verified; "stable" is a promise, and `format_version: 1` is the mechanism].
2. **Explicit behavior:** connector normalization, unknown-connector errors, no env-var configuration [Code-verified, High].
3. **Local-only:** filesystem probes, no network [Code-verified, High — no network deps in the tree].
4. **Runtime-neutral:** synchronous API, no tokio [Code-verified, High].

**Benchmark and conformance audit:** there are no maintainer performance numbers — no `benches/`, no benchmark table in the README, no throughput claims anywhere in the repo [Code-verified, High]. The quantitative claims that exist are: 21,189 crates.io downloads (registry-counted, not users — per-version data shows a long tail on 0.1.x versions accounting for 17,753 of the 21,189 total, consistent with CI systems pinning old versions rather than users upgrading; treat as distribution evidence, not adoption [External, High on the numbers; the churn reading is Inference, Medium]), 1,226 tests (counted; main-suite greenness at pin unestablished — claim 10), and "34 connectors" (counted). **Nothing here needs a re-baseline because nothing here is a benchmark.** The honest reproduction cost: `cargo test --all-targets --all-features` on the pinned `nightly-2026-08-31` toolchain [Code-verified, High on the toolchain pin]. The conformance story is qualitative but unusually concrete: 16 checked-in transcript fixture files (antigravity/codex/openhands) + 1 test fixture [Counted, High], fixture-wired schema validators (bead `wlb`, closed), codex read-integrity tests asserting failed reads never deliver partial conversations, per-connector regression tests, and historical prompt-extraction diffs preserved as patch files (claim 19) [Code-verified, High].

## 4.6 Competitors

The incumbent wins on distribution breadth; franken-agent-detection's only uncontested edge is depth — 34 probed agents plus transcript normalization behind one schema, where everyone else answers a narrower question [Inference, Medium].

- **The real incumbent: ad-hoc per-project checks.** The README names it honestly: every agent-adjacent tool rolls its own `which codex` / `~/.codex`-exists probes — zero distribution cost to start, unbounded drift over time [Maintainer claim, Medium on the framing; the cost characterization is Inference, Medium]. This crate's pitch is to be the shared library that kills that code [Maintainer claim, Medium].
- **Caller-detection crates (adjacent lane, different question):** `detect-coding-agent` (21,545 downloads — "detect if your application is being invoked by an AI coding agent"), `is-ai-agent` (11,558), `ai_env` (9,805 — "detect AI coding agent information from the environment"), `agent-detector` (3,743), `mise-agent-env` (454) [External, High — crates.io search]. These answer "am I being run *by* an agent?" via environment variables. FAD answers "which agents are *installed*?" via filesystem probes. Related but not substitutes — a tool could use both [Inference, Medium].
- **`car-external-agents` (1,640 downloads, 0.55.0, updated 2026-09-21): the nearest neighbor.** "Detection of installed agentic CLIs (Claude Code, Codex, Gemini) for the Common Agent Runtime" [External, High]. Same question as FAD's detection layer, but 3 agents vs 34, no transcript normalization, no provenance schema, no fixture-conformance machinery. It is also *fresher* (updated the day before the assessment) — the lane is contested, not empty [Inference, Medium]. ("Common Agent Runtime" is the consuming project's name per the crate description; its provenance was not investigated further [External, Medium].)
- **Upstream vendors' own formats:** every connector's store format is owned by its vendor (OpenAI, Anthropic, Google, Meta, Cursor, …). They are not competitors; they are the weather. Any of them can break any connector with a dot release — the structural risk no competitor solves either [Inference, High].
- **Unoccupied lane:** a *provenance-carrying, schema-stable transcript normalization layer* across 30+ agents has no direct occupant — `car-external-agents` stops at detection, caller-detection crates stop at env vars, and CASS (the consumer) builds its index on top of FAD rather than competing with it [Inference, Medium — based on crate descriptions and FAD's code; no competitor's source was audited]. Whether anyone besides the maintainer's own tooling will pay the dependency cost for that normalization is the unproven bet.

## 4.7 Skeptic's take

Weaknesses, threat-classed (each substantive — capable of killing the project on its own):

1. **[HIGH] The README is a tenth of the crate, and wrong about the rest.** It documents only the zero-feature detection API; the `connectors` feature — the bulk of 61k lines, the `Connector` trait, the provenance schema, all 14 cargo features — is never mentioned. Worse, "Limitations: Installation detection only; no session parsing or indexing" is disproven by the code it ships beside. For a crate whose pitch is *stable machine-consumable output for downstream tooling*, the human-consumable front door misdescribing the product is a structural liability, not a typo [Code-verified, High].
2. **[HIGH] 1,226 tests, and the main suite has never been observed green at the pin.** CI run 35687081573 (head = pin) failed at the `Format` step — `cargo fmt --all --check` — so clippy, the full test suite, and packaging never executed on the assessed commit [CI-observed, High]. The `Codex prompt integrity` workflow also failed on 2026-09-20 [CI-observed, High]. Bounding the doubt: the `Codex exclusions` workflow (7 tests on ubuntu + windows) is green at the pin [CI-observed, High] — so *some* tests execute green, but the suite that matters (the 1,226) is unobserved. A test suite that cannot be observed passing at the assessed commit is a claim about process, not evidence of correctness.
3. **[MEDIUM] The connector zoo is a treadmill with no finish line.** 34 slugs today; Meta's Muse Code appeared August 2026 and had a connector by the September pin (its module doc dates it; the speed is Inference, Medium). Each new agent is a new store format to reverse-engineer; each vendor dot-release is a silent breakage. The fixture-conformance canary (next-step #3) mitigates but cannot eliminate this: the maintainer is permanently behind 30+ vendors' release notes. Five beads are `in_progress` right now (Prime watch roots, Cursor attribution, Copilot CLI workspacePath, Devin SQLite, SQLite unwind rollback) [Code-verified, High] — the backlog is the treadmill made visible.
4. **[MEDIUM] Bus factor 1, by policy.** The README's contribution section: "I do not accept outside contributions for any of my projects… I simply don't have the mental bandwidth to review anything, and it's my name on the thing, so I'm responsible for any problems it causes" [Maintainer claim, High — quoted verbatim]. One human, no succession, no second reviewer — and the connector treadmill above means the workload grows while the workforce is fixed at one.
5. **[MEDIUM] The only evidenced consumer is the maintainer's own project.** CASS is real (1,127 stars [External, High]; Homebrew/Scoop distribution [Maintainer claim, Medium]) but it is the same author's tool; crates.io reverse-dependencies show no external dependents [External, High]. 21,189 downloads are distribution, not adoption — per-version data shows 17,753 of the 21,189 total sitting on old 0.1.x releases (0.3.0 itself has only 239), the signature of CI systems pinning versions rather than a user base upgrading [External, High on the numbers; the churn reading is Inference, Medium].
6. **[LOW] Forks (26) exceed stars (14)** — an unusual ratio [External, High]. Unexplained: possibly the maintainer's agent-review flow forking per task, possibly mirrors. It is not evidence of adoption, and its cause is unknown — reported as an observation, not a finding [Inference, Low].
7. **[LOW] The `claude`/`claude_code` slug seam is open.** Bead `8np` (open since 2026-08-25): the constructor registry canonicalizes to `claude` while the module file is `claude_code.rs`. The registry-invariant tests enforce *table agreement*, not *naming correctness* — the one seam the machinery cannot close by itself is the naming decision, and it is still undecided [Code-verified, High].

**Bear-case steelman (strongest counter-case):** franken-agent-detection is a one-maintainer compatibility treadmill dressed as a library. The README cannot describe its own product; the main test suite has never been observed green at a pin; the 34-connector registry is a liability that compounds monthly as vendors ship new agents and silently change formats — and the one time a vendor ships a stable, signed session-export API (or the OS grows an agent registry), the entire filesystem-probe approach becomes legacy overnight. Adoption beyond the maintainer's own CASS is unproven — 21k downloads with no external reverse-dependencies is distribution without users. The rational market response is to vendor the three connectors you need and ignore the zoo. Its most likely end state is not deprecation but quiet stagnation: the registry slowly rotting as the maintainer's attention moves to the next FrankenSuite entry, with the README's "detection only" line becoming retroactively true as the connectors bit-rot. [Inference, Medium — deliberately uncharitable; the counter-evidence is the fixture-conformance machinery and the 0.2.x→0.3.0 release cadence, which show the treadmill is currently being run, not abandoned.]

## 4.8 License and governance (material, not boilerplate)

**License: plain MIT, 21 lines, read verbatim — there is no rider.** The full operative grant: "Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software…" [Code-verified (license text), High]. No named parties, no exclusions, no benchmarking/analysis/training bars, no termination clause beyond the standard warranty disclaimer. **OSI status: clean MIT** — this is the only FrankenSuite repo assessed to date without the OpenAI/Anthropic rider, and the difference is load-bearing: CASS (which indexes sessions *produced by* those labs' tools) could not sanely depend on a crate whose license barred the labs, and the maintainer's own contribution policy ("I'll have Claude or Codex review submissions via `gh`") would be incoherent under a rider naming them as restricted parties [Inference, High].

**Governance:** bus factor 1 (Jeff Emanuel). The README contribution policy is explicit and unusual enough to quote: "Please don't take this the wrong way, but I do not accept outside contributions for any of my projects. I simply don't have the mental bandwidth to review anything, and it's my name on the thing, so I'm responsible for any problems it causes; thus, the risk-reward is highly asymmetric from my perspective." Issues and illustrative PRs are welcome, with the stated flow that Claude or Codex reviews submissions via `gh` and the maintainer independently decides whether and how to address them [Maintainer claim, High]. No succession plan, no second committer, no foundation [Inference, Medium — absence of evidence across assessed materials]. Release discipline is real: GitHub Releases for v0.1.4+ (with explicit warnings about which tags lack releases — "do not invent them"), a `release.yml` workflow (tag → verify → publish), and a CHANGELOG that reconstructs each version wave [Code-verified, High]. Commit velocity could not be measured from the shallow clone (single commit visible); the CHANGELOG shows ~monthly minor releases 2026-05 → 2026-09 [Maintainer claim, Medium].

**The rider question (Rulebook §6):** the exact scope of the rider is *nothing* — it does not exist here. Who is excluded: nobody. Does that serve the mission: yes — the mission is downstream adoption by agent tooling, and a named-party exclusion would have been fatal to the one real consumer (CASS), whose entire purpose is indexing sessions from agents built by the named labs [Inference, High]. The natural-experiment next step (§"Franken-worthy next steps" #5) follows directly.

## 4.9 NODUS factsheet

| Criterion | Score | Justification (one line) |
|---|---|---|
| Technology readiness | TRL 6 | Published, versioned, downloadable, and integrated into a shipped tool (CASS) — demonstrated in an operational environment, but independent production use is unproven and main CI is red at the pin. [Inference, Medium] |
| Strategic relevance | 3/5 | Agent-session provenance is strategically adjacent to the program's memory-capsule thesis; the crate is the only component that already models artifact provenance. [Inference, Medium] |
| Impact potential | 3/5 | If the normalized schema becomes the interchange format for agent transcripts, impact is high; today it is a single-consumer library. [Inference, Medium] |
| Implementation feasibility | 4/5 | It is already implemented and published; the risk is maintenance (the treadmill), not construction. [Inference, Medium] |
| Time to mainstream | 2/5 | Requires a second independent consumer and README honesty first; the lane has a fresher rival (`car-external-agents`, updated 2026-09-21). [Inference, Medium] |
| Collaboration potential | 2/5 | Bus factor 1 with an explicit no-contributions policy caps collaboration regardless of license cleanliness. [Inference, Medium] |

**Ring: Pilot** [Inference, Medium]. The Rulebook's Pilot bar is "a release artifact plus a bounded, real workload fit": crates.io 0.3.0 + GitHub Release v0.3.0 (2026-09-16) satisfy the first [External, High]; CASS discovering sessions from 26 agent harnesses through this crate satisfies the second [Maintainer claim, Medium]. Ring-down pressure was weighed explicitly — the only evidenced consumer is the maintainer's sibling project, main CI is red at the pin, and the README misdescribes the product — but those are advancement blockers toward Invest, not Pilot disqualifiers: the Rulebook's Pilot criteria do not require independence or governance. Explore would understate a published, downloaded, downstream-integrated library.

## 4.10 Wardley placement

- **Commodity surface (evolved → utility):** filesystem existence probing, JSONL/SQLite parsing, semver'd JSON reports — solved problems; the zero-feature detection API competes here and wins only on consolidation [Inference, Medium].
- **Custom-built (product stage):** the 34-slug registry + `NormalizedConversation` schema + registry-invariant tests + fixture canary — nobody else maintains this mapping; `car-external-agents` (3 agents, detection only) is the closest product-stage rival [Inference, Medium].
- **Genesis (novel):** provenance-attested transcript normalization (`Origin`/`SourceKind`/`PathMapping` per artifact) as a substrate for portable agent memory — unoccupied and unproven [Inference, Medium].
- **What moves each:** the commodity surface moves on documentation honesty (README describing the real product); the custom layer moves on surviving the vendor-format treadmill (the drift canary firing before users do); the genesis layer moves on the signed-envelope prototype in next-step #2 — a verified cross-machine round-trip would pull it into custom-built [Inference, Medium].

## 4.11 Trajectory (12 / 24 / 60 months) [Inference]

**Base case:** the treadmill continues. The maintainer adds 1–2 connectors per quarter, vendors break 2–3 existing ones per year, the fixture canary catches most of it, CASS keeps consuming new versions, downloads accumulate without a second independent consumer. The README stays detection-focused; the `claude`/`claude_code` seam stays open. In 60 months the registry covers 50+ agents and the crate is the de facto transcript-normalization layer for exactly one tool.

**Upside bifurcation:** requires (a) a second independent consumer (a usage-dashboard or orchestrator outside the FrankenSuite) that validates the schema as an interchange format, and (b) the README rewritten to document the connectors feature, which is the precondition for (a). If both happen, the crate becomes the quiet interchange layer for agent transcripts — small, boring, everywhere — and the provenance substrate (next-step #2) gets built because someone needs portable session memory.

**Decay:** requires only inattention. The treadmill is the decay function: each unhandled vendor format change silently converts a connector into a liar (it detects the install but misparses the sessions). Decay looks like CASS pinning an old version "because the new one broke cursor parsing" — observable in CASS's AGENTS.md pin table, which today documents per-version connector behavior in unusual detail.

**Revisit triggers (concrete, observable):** (1) a crates.io reverse-dependency outside the FrankenSuite appears; (2) main CI goes green at a pin (Format gate passing, 1,226 tests executing); (3) the README documents the `connectors` feature; (4) bead `8np` closes (the slug seam resolved); (5) a second maintainer or any merged outside contribution appears; (6) a vendor ships a stable signed session-export API (the kill-test event — see Q8).

## 4.12 Limitations and open questions (mandatory)

**Not done:** the crate was never compiled; no test was executed by the analyst (1,226 counted, none run); no transcript fixture was parsed; the ChatGPT decryption path was not exercised; download counts were not decomposed into users vs CI churn; the `release.yml` publish path was read but not end-to-end verified; CASS's actual runtime usage was not inspected beyond its docs and commit messages; the shallow clone exposed a single commit, so commit velocity and authorship distribution could not be measured from git history; web demand-signal search beyond crates.io/GitHub was not performed (absence of coverage reported with that recall caveat); no competitor's source was audited (competitor claims rest on registry descriptions).

**Open questions that would most change the verdict:** (1) Do the 1,226 tests pass at a green pin — i.e., is the suite real or aspirational? (2) Who or what generates the 21,189 downloads — is there a silent user base (e.g., vendored into tools not on crates.io)? (3) How many of the 32 scan connectors' `scan()` paths are exercised against *current* vendor formats vs rotting against 2026-Q1 formats? (4) Would the maintainer accept the README rewrite that the packet's own §4.7 demands — the cheapest high-leverage fix available? (5) Is "no outside contributions" absolute in practice, or has the Claude/Codex review flow ever produced a merged change?

---

## The eight deepening questions

**1. Provenance.** Every scanned artifact carries `Origin { source_id, kind: SourceKind }`, `PathMapping`, and `source_path` — the crate knows which machine-local store each conversation came from, and `LOCAL_SOURCE_ID = "local"` explicitly marks on-machine provenance so downstream tools can distinguish it from synced sources [Code-verified, High]. What it does *not* record is attestation: no content hash, no producer signature, no chain of custody beyond the path. Making it portable would require a signed envelope (artifact hash + producer key + the existing `Origin`) that survives export — the schema has the fields to hang it on, but the cryptography is entirely unbuilt [Inference, Medium].

**2. The embeddable unit.** The zero-feature detection API: `detect_installed_agents(&AgentDetectOptions::default())` with 4 always-on dependencies (`serde`, `thiserror`, `chrono`, `dirs`), no async runtime, no network, one function call returning a versioned JSON report [Code-verified, High]. Adoption cost is a 4-dependency addition and a synchronous call — but the *valuable* unit (the connector normalization) costs the `connectors` feature and its tree (`anyhow`, `serde_json`, `walkdir`, `tracing`, `dotenvy`, `bloomfilter`, `once_cell`, plus per-connector SQLite/crypto deps), and is undocumented in the README, so the real adoption cost includes reading the source [Code-verified, High on the deps; the "real cost" judgment is Inference, Medium].

**3. Unexercised option value.** Three clear holdings: (a) `token_extraction` — per-agent token-usage accounting with model normalization is a metering/billing substrate no consumer currently uses; (b) the `Connector` trait's streaming half (`supports_streaming_scan`, `scan_with_callback`, `discover_source_files`) — built for corpora larger than memory, with a 100 MB scan cap and bloomfilter-backed dedupe already in the base feature; (c) the registry-invariant test pattern itself, which is process technology applicable to any slug-governed system [Code-verified, High on existence; the "unexercised" judgment is Inference, Medium]. What unlocks (a) is a usage-dashboard consumer; (b) is already half-unlocked by CASS-scale archives.

**4. Benchmark honesty.** There are no maintainer benchmarks to audit — no benchmark table, no throughput claims, no `benches/` [Code-verified, High]. The quantitative claims are downloads (registry-counted; not users — the 0.2.3 spike of 1,990 vs 0.3.0's 239 reads as CI/mirror churn [External, High on the numbers; the churn reading is Inference, Medium]), test counts (1,226 counted; main-suite greenness unestablished at the pin [CI-observed, High]), and connector counts (34 slugs / 32 scan connectors, counted [Counted, High]). Nothing here is load-bearing for a performance thesis because no performance thesis is advanced — the honesty finding is that the crate makes no claims it needs to disavow, which is rarer in this program than it should be [Inference, Medium].

**5. The governance path.** There is no credible route from one maintainer to an institution today: the README explicitly refuses outside contributions, there is no second committer, and the connector treadmill's workload grows while the workforce is fixed [Maintainer claim, High]. If velocity decays, what breaks first is format currency — vendors ship new agents and change store formats monthly, and each unhandled change converts a connector from an asset into a liar (detects the install, misparses the sessions), with decay observable in CASS's version pin table [Inference, Medium]. The credible path, if one were wanted, starts with documenting the connectors feature (the precondition for any outside contributor to be useful) — which is also next-step #3's canary extraction.

**6. The license as strategy.** There is no rider; the license is 21 lines of plain MIT granting "any person" the rights to "use, copy, modify, merge, publish, distribute, sublicense, and/or sell" without restriction [Code-verified, High]. The exclusion set is empty — OpenAI, Anthropic, their affiliates, and agents acting for them are all permitted, which is precisely what the mission (downstream adoption by agent tooling, including tooling that indexes those labs' agents' sessions) requires [Inference, High]. The strategy question answers itself by contrast with the siblings: this is the only FrankenSuite repo with a documented downstream integration, and it is the only one without a rider — correlation is not causation, but the natural experiment (next-step #5) is worth running [Inference, Medium].

**7. Agent-era fit.** The concrete workload is CASS: a session-search tool that must discover and normalize transcripts from 26+ agent harnesses without writing 26 bespoke parsers — it delegates exactly that to this crate, pinned per-version in its AGENTS.md with per-release connector notes [External, High]. What would have to become true for a *second* workload to pick it over ad-hoc checks: the README must document the connectors feature (discoverability), main CI must go green at a pin (trust), and ideally a usage-metering dashboard or multi-agent orchestrator adopts the schema — the `token_extraction` substrate is waiting for the former [Inference, Medium].

**8. The kill test.** Ship a stable, signed, vendor-supported session-export API — or an OS-level agent registry — for any two of the top five agents (Claude Code, Codex, Cursor, Gemini, Copilot). If vendors own a stable export contract, the filesystem-probe-and-reverse-engineer approach loses its reason to exist overnight: detection becomes a registry read and normalization becomes a schema mapping against documented formats [Inference, Medium]. The weaker, nearer-term kill signal: CASS pins an old `franken-agent-detection` version "because the new one broke parsing" — observable in its AGENTS.md pin table — which would falsify the thesis that the treadmill is being run successfully [Inference, Medium].

---

## Cross-cutting lenses

- **The decoupling lens.** This project decouples *detection/normalization logic from vendor store formats*: vendors own the formats (the weather), the crate owns the `Connector` trait + registry + `NormalizedConversation` schema. It is the same decoupling move as the memory-capsule thesis from the FrankenRedis deep-dive — portable, provenance-carrying artifacts separated from the stores that produced them — except here it is already partially built rather than proposed [Inference, Medium].
- **The methodology-export lens.** If the crate fails, what survives: the registry-invariant test pattern (mechanical drift governance), the fixture-wired schema conformance harness (upstream-drift canary), the scan-budget discipline (100 MB caps, root scoping, discover-before-parse), and the historical-patch review artifacts — four process artifacts, three of them extracted as next steps above [Inference, Medium].
- **The asupersync question.** Verified present, not assumed: `asupersync 0.5.0` (optional, `default-features = false`) paired with `frankensqlite` (fsqlite) `0.4.1`, bridged behind the synchronous connector API in `sqlite_sync.rs`; the Cargo.toml comments document the lockstep requirement (fsqlite 0.4 names asupersync 0.5.x types in its public API), and bead `yh4` records the 0.5.0 migration as closed [Code-verified, High]. Nine features depend on the pair.
- **The rider question.** Quoted scope: none — 21-line plain MIT, "to any person… without restriction," no named parties, no benchmarking/analysis/training bars [Code-verified, High]. The exclusion serves the mission precisely by not existing: the crate's purpose is indexing sessions from agents built by the labs the sibling riders exclude [Inference, High].