# FrankenTerm (`ft`) — Technical Due-Diligence Assessment

**The hook:** A 3.4M-line, 83-crate WezTerm fork reborn as a terminal hypervisor for fleets of AI coding agents — 21 signed releases, 70,809 tests, and an honesty apparatus that publishes the benchmarks it loses and refuses to qualify its own "200-pane" headline until a target-class hardware gate signs it.

**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**.

## TL;DR

FrankenTerm is a genuinely substantive, installable, single-author terminal platform: a WezTerm-derived terminal runtime (absorbed in-tree, September 2026) plus an agent-swarm control plane — Robot Mode JSON/TOON API (TOON: a token-efficient JSON-compatible encoding used for agent-facing output), MCP surface, policy-gated actions, transactional multi-pane missions with prepare/commit/compensate and an idempotency ledger, BOCPD Bayesian change-point detection over pane deltas, FTS5 (SQLite full-text search) + Tantivy hybrid search, flight recorder/replay forensics — wrapped in a claim-governance apparatus with no peer in this program: content-addressed, sigstore-signed release attestation bundles, per-category producing-bead provenance (a "bead" is the maintainer's work-item unit in the `.beads` issue tracker), negative-results ledgers, an auto-stamping count script that documents its own drift, and explicit `skipped_not_proven` qualification gates the maintainer refuses to sign off prematurely. **TRL 7. NODUS ring: Explore.** Strongest strength: the attestation and reality-check machinery — the maintainer publishes held-out runs that *fail* (e.g., RC53) and the exact sentences where claims aren't yet qualified. Strongest ceiling: bus factor 1 by **explicit, deliberate policy** (no outside contributions accepted), a custom MIT+OpenAI/Anthropic-rider license that denies all rights to the two leading AI labs — the precise demographic an agent-orchestration tool needs — no public CI (verification runs on maintainer-controlled RCH hosts that are not independently inspectable), a pinned nightly toolchain, and zero independent benchmarks, reviews, or production deployments found.

## Quick Links

- Repository: https://github.com/dicklesworthstone/frankenterm
- README: https://github.com/dicklesworthstone/frankenterm/blob/HEAD/README.md
- CHANGELOG: https://github.com/dicklesworthstone/frankenterm/blob/HEAD/CHANGELOG.md
- AGENTS.md (build/verification commands, RCH proof lanes): https://github.com/dicklesworthstone/frankenterm/blob/HEAD/AGENTS.md
- License (MIT + OpenAI/Anthropic rider, read verbatim): https://github.com/dicklesworthstone/frankenterm/blob/HEAD/LICENSE
- Releases (21 GitHub releases, detailed notes): https://github.com/dicklesworthstone/frankenterm/releases
- Release attestation bundles (README + claim registry): https://github.com/dicklesworthstone/frankenterm/blob/HEAD/docs/attestations/README.md
- Performance ledgers (keep + negative-results ledgers, rounds 4–9): https://github.com/dicklesworthstone/frankenterm/blob/HEAD/docs/perf-ledger/round6-negative-results.md
- Vendored-WezTerm design doc: https://github.com/dicklesworthstone/frankenterm/blob/HEAD/docs/vendored-wezterm-design.md
- Count-stamp machinery (auto-stamps README counts, documents drift): https://github.com/dicklesworthstone/frankenterm/blob/HEAD/scripts/stamp-readme-counts.sh
- rust-toolchain.toml (pinned nightly + rustc-ICE forensics comment): https://github.com/dicklesworthstone/frankenterm/blob/HEAD/rust-toolchain.toml
- Install script (curl|bash, DSR minisign verification): https://github.com/dicklesworthstone/frankenterm/blob/HEAD/install.sh
- Sibling term-capability spec (frankentui): https://github.com/dicklesworthstone/frankentui/blob/HEAD/docs/spec/frankenterm-term-capability-profile.md

## Did you know?

`rust-toolchain.toml` pins `nightly-2026-08-31` — and carries a ~35-line comment documenting that on 2026-08-22/23 `cargo clippy --fix` aborted with a rustc ICE ("delayed bug: unexpected rigid alias in layout_of after normalization") which was diagnosed as a *toolchain* bug, not a project bug, because the identical signature appeared the same day in two unrelated repositories (`toon_rust`, `charmed_rust`) [Verified in the clone, High]. Forensic compiler triage, embedded in a config file.

## Franken-worthy next steps

These are research directions, not engineering tickets: each is novel, specific, falsifiable, and backed by rigor this project has already demonstrated.

1. **Port the attestation-bundle schema to an unrelated single-maintainer project.** ft's release apparatus (content-addressed, sigstore-signed bundles; `docs/attestations/claim-registry.json`; per-category producing-bead pointers; negative-evidence slots; a claim → signed-slot attestation graph) is the most honest release-trust system found in the 44-repo program. **Falsification:** port the schema to a second solo-maintainer project and have a third party verify a release *cold*, offline, with no maintainer involvement (`ft attestation verify <bundle>` is the claimed one-command flow); if the verifier needs the maintainer's help, the schema is governance theater, not a portable artifact.
2. **Generalize the `skipped_not_proven` scale gate into a qualification-ladder protocol.** The 200-pane headline is held behind an explicit target-class hardware gate whose current signed state is `skipped_not_proven` — refusal-to-claim as a machine-readable state. **Falsification:** formalize the ladder (fixture → benchmark-lane → native → target-class) and assign a gate state to each of ft's nine perf-ledger rounds (4–9, keep + negative) from their recorded artifacts *alone*; any round that cannot be assigned a state without new runs falsifies the protocol's retro-applicability — and retro-applicability is the difference between a protocol and post-hoc labeling.
3. **Test the Robot envelope contract against a foreign backend.** The `RobotResponse` envelope (`ok/data/elapsed_ms/version/now/schema_version`) with golden matrices (`proofs/robot-contracts`) is the closest thing in the wild to an agent-to-terminal control contract. **Falsification:** implement the envelope against a non-ft backend (e.g., tmux control mode) and run ft's golden matrix against it; contract-parity above threshold means the envelope is a genuine cross-terminal standard candidate; failure to decouple means it is product scaffolding.
4. **Upgrade the mission idempotency ledger toward write-time origin binding.** Transactional missions already log prepare/commit/compensate with an idempotency ledger — but the ledger records *what* happened, not *who authorized* it, and per arXiv 2606.24322 (June 2026) content/lineage defenses are malleable via origin laundering, making write-time origin binding necessary. ft's fail-closed policy engine plus its negative-evidence discipline make it the best-placed codebase in the program to attempt this honestly. **Falsification:** bind every mission mutation to (origin identity, policy version, input hash) in a hash-chained ledger, then red-team origin laundering (forged provenance, replayed transactions, ledger truncation); any undetected laundering kills the thesis.
5. **Quantify the asupersync concentration risk as a coupled-bus-factor study.** ft is the flagship production consumer of asupersync (pinned `=0.5.0`, tokio banned at four layers — dependency, sealed `RuntimeProof` trait with a Lean soundness model, tests, and release gates), and asupersync carries the *same* OpenAI/Anthropic rider. The coupling is now measured, not asserted: **74 distinct `runtime_async::` APIs across 259 files / 2,378 usage sites** at HEAD [Verified, High]. **Falsification:** set the threshold in advance — e.g., if a migration-seam analysis shows fewer than half of those 74 APIs are covered by any abstraction boundary, the "async abstraction" claim fails and the project is a single-runtime artifact; either outcome is publishable evidence about ecosystem correlated-failure risk.

---

## 4.1 Header

| Field | Value |
|---|---|
| Repository | https://github.com/dicklesworthstone/frankenterm |
| Pinned revision | `ce183cd1f7dd074ce187e279f6b99442256040d8` — 2026-09-22 02:31:53 -0400 [Verified, High] |
| Assessment date | 2026-09-22 |
| Language / toolchain | Rust, edition 2024, pinned `nightly-2026-08-31` (`rust-toolchain.toml`, with rustc-ICE forensics comment) [Verified, High] |
| License | MIT License **with OpenAI/Anthropic Rider** — NOT OSI open source; full text read verbatim, rider scope quoted in §4.8 [Verified, High] |
| Scale | 83 workspace members (33 first-party crates + 2 custom lint crates + 1 fuzz crate + 47 WezTerm-derived `frankenterm/` members) [Verified, High]; 3,411,020 Rust lines / 2,666 files [Verified, High]; 70,809 `#[test]` annotations in 2,209 files [Verified, High — simple `#\[test\]` grep; the maintainer's stamp recipe also counts `tokio::test`/`asupersync_test::test` attributes, so the numbers are methodologically adjacent, not identical]; 758 files under `docs/` [Verified, High] |
| Stars / forks | 118 stars / 19 forks [Verified via live GitHub read, High] |
| Commits | 16,269 on default branch; repo created 2026-01-18 [Verified via live GitHub read, High] |
| Releases / tags | 21 GitHub releases; 24 tags; workspace version 0.15.8 (unreleased) [Verified via live GitHub read + `git ls-remote`, High] |
| Last push | HEAD 2026-09-22; GitHub "Current commit: ce183cd1f7dd074ce187e279f6b99442256040d8" [Verified, High] |
| Maintainer | Single: Dicklesworthstone (Jeffrey Emanuel, per LICENSE copyright) — bus factor 1 **by explicit stated policy** [Verified, High] |
| Inception | 2026-01-18 (GitHub created date) [Verified, High] |

**Analyst method.** Fresh shallow clone of HEAD to `~/workspace/.scratch/frankenterm-fresh/` (HEAD `ce183cd`, 2026-09-22; a stale `/tmp`-era clone directory was present and ignored). Read: README (full), LICENSE (verbatim), CHANGELOG (targeted greps), `rust-toolchain.toml` (verbatim), AGENTS.md (targeted greps), root `Cargo.toml` workspace member list, `deny.toml` (targeted greps), `install.sh` (targeted greps), `scripts/stamp-readme-counts.sh` (recipe). Grep-verified: workspace member composition, Rust line/file counts, `#[test]` counts, docs file count, `forbid(unsafe_code)` in CLI + core, unsafe site counts in GUI (36 code sites) and mux-server daemonize, asupersync pin `=0.5.0` and tokio-ban layers, MCP crate size, `main.rs` size, BOCPD/bayesian presence, robot envelope shape, negative-evidence ledgers, count-stamp placeholders in README. Fetched and confirmed resolution of every Quick Link (repo page, releases page). Web-searched for independent coverage (benchmarks, reviews, production use). **Not done:** did not compile (3.4M LOC, pinned nightly toolchain), run tests, install the binary, execute Robot Mode, or verify release artifact contents; did not inspect RCH (remote proof) hosts; did not recount GUI unsafe semantics per site; did not verify the frankentui sibling spec from a fresh frankentui clone (carried as [External] from the prior draft with a re-check noted as open).

## 4.2 Executive verdict

FrankenTerm is a **genuinely substantive, installable, single-author terminal platform** [Inference, High] — a WezTerm-derived terminal runtime plus an agent-swarm control plane with real tagged releases and the most rigorous claim-governance apparatus in the FrankenSuite. The shallow-clone audit confirms: 83 workspace members [Verified], 3,411,020 lines of Rust [Verified], 70,809 test annotations in 2,209 files [Verified], 16,269 commits since 2026-01-18 [Verified via live GitHub], 21 GitHub releases with detailed engineering notes [Verified], an installer with DSR-minisign verification [Verified file exists], crate-root `#![forbid(unsafe_code)]` on the CLI and core [Verified], asupersync pinned `=0.5.0` with tokio banned at four layers including a sealed `RuntimeProof` trait whose soundness argument is modeled in Lean [Verified], and a September 2026 in-tree absorption of the WezTerm fork (47 workspace members) [Verified]. The control plane is real machinery — Robot Mode JSON/TOON envelope with golden matrices, a 586-line MCP crate [Verified, High], transactional missions (prepare/commit/compensate + idempotency ledger), BOCPD Bayesian change-point detection, FTS5+Tantivy hybrid search, flight recorder/replay — though behavioral claims rest on maintainer evidence since nothing was executed. The governance layer is the standout: content-addressed, sigstore-signed attestation bundles with per-bead provenance, negative-results ledgers through round 9, a count-auto-stamper that documents its own drift, a CHANGELOG that publishes failed held-out runs (RC53), and a refusal to qualify the "200-pane" headline behind a `skipped_not_proven` gate [Verified]. **But:** bus factor 1 is an explicit, deliberate policy — "I do not accept outside contributions for any of my projects" — which caps collaboration permanently [Verified verbatim]; the MIT+OpenAI/Anthropic-rider license denies all rights (including benchmarking and analysis) to the two leading AI labs — the exact demographic for an agent-orchestration tool [Verified verbatim]; there is no public CI (`.github/` holds only `dependabot.yml`) — verification runs on maintainer-controlled RCH hosts that are not independently inspectable [Verified]; the toolchain is pinned to a dated nightly; and zero independent benchmarks, reviews, or production deployments were found [External, High within recall]. **NODUS: Explore. Wardley: control plane Custom-built → early Product; attestation machinery Genesis → Custom-built.** The durable value is the *control-plane methodology* (policy-gated agent actions, attested release bundles, negative-evidence ledgers, refusal-to-claim gates) more than the terminal fork [Inference, Medium].

## 4.3 Claim inventory: demonstrated vs aspirational

Status values: *demonstrated* / *partially demonstrated* / *aspirational* / *disproven* / *stale*.

| # | Claim | Status | Evidence |
|---|---|---|---|
| 1 | Installable CLI `ft` via `install.sh` (curl\|bash) with DSR-minisign verification (DSR: the maintainer's release-signing identity, minisign key `69B3955C8D2E62A8`) and `ft doctor` self-check | **Partially demonstrated** (machinery exists; installer not executed) | [Verified, High] — `install.sh` present with checksum + minisign verification code paths; `ft doctor` referenced 32× in README; 21 GitHub releases ship platform binaries [Verified releases page] |
| 2 | Robot Mode JSON API with stable envelope (`ok/data/elapsed_ms/version/now/schema_version`) and TOON encoding | **Partially demonstrated** (exists; behavior not executed) | [Verified, High] — envelope shape documented in README with examples; golden matrices at `proofs/robot-contracts`; CLI + core code in tree |
| 3 | MCP control surface | **Partially demonstrated** (exists; thin) | [Verified, High] — `crates/frankenterm-core-mcp/src/lib.rs` is 586 lines; release notes mention FT-MCP error taxonomy (`FT-MCP-0011`); depth is modest relative to "Machine API for agents" framing |
| 4 | "Fleets of 200+ concurrent AI coding agents" | **Aspirational headline; explicitly gated** | [Verified, High] — README hero: "The retained 200-pane figures are synthetic benchmark-lane results, not a qualified native or target-class operating envelope"; high-scale wording "held back until the target-class hardware gate signs a non-skipped artifact (**currently `skipped_not_proven`**)" |
| 5 | `unsafe` forbidden in CLI and core | **Demonstrated — TRUE** | [Verified at HEAD `ce183cd`, High] — `#![forbid(unsafe_code)]` at `crates/frankenterm/src/main.rs` and `crates/frankenterm-core/src/lib.rs:45`; workspace `unsafe_code = "forbid"` lint; the only actual `unsafe` code-site in core is `render_call_graph_populator.rs:774` — an `unsafe fn` inside a raw string literal in a test fixture (`pub_async_unsafe_const_fns_recognized`), i.e. rendered text, not code; zero `#[allow(unsafe_code)]` in core |
| 6 | GUI/mux-server FFI exceptions audited | **Partially demonstrated** | [Verified exists, High] — 36 `unsafe` fn/block sites in `crates/frankenterm-gui/src`; mux-server `daemonize.rs` enumerates `#[allow(unsafe_code)]` libc calls; "audited" is a maintainer assertion, not an independent review |
| 7 | Transactional multi-pane missions (prepare/commit/compensate + idempotency ledger + kill switches + failure injection) | **Partially demonstrated** (exists; not executed) | [Verified, High] — README deep dives ("Transactional Mission Execution", "Sample Mission and Tx Contracts"), `MissionJournal` code; v0.13.0 release notes describe tx-engine hardening found by the recovered test suite |
| 8 | Full-text search over output (FTS5 — SQLite's full-text-search extension — + Tantivy + semantic fastembed + RRF hybrid; RRF = reciprocal rank fusion) | **Partially demonstrated** (exists; not executed) | [Verified, High] — `frankenterm-core-tantivy` crate; README "Search Modes" deep dive; "Future-query recall caveat" disclosed |
| 9 | Bayesian change-point detection (BOCPD) for state transitions | **Partially demonstrated** (exists; not executed) | [Verified, High] — `bayesian_ledger.rs`, README "Bayesian Regime Detection (BOCPD)" deep dive; production efficacy not independently measured |
| 10 | asupersync-exclusive runtime; tokio banned at four layers | **Demonstrated** | [Verified, High] — asupersync `=0.5.0` pinned; `deny.toml` `[bans]` tokio; sealed `RuntimeProof` trait + Lean soundness model (`docs/proofs/runtime-proof-soundness.lean`) + check script; `asupersync_test!` macro and test-layer guards |
| 11 | README count stamps kept honest by `scripts/stamp-readme-counts.sh` | **Partially demonstrated** (machinery exists; stamps lag) | [Verified, High] — script exists with documented recipe, `--check` advisory gate; measured worktree (70,809 tests, 2,019,309 core LOC) exceeds committed stamps (60,535+ tests, 1,346,112+ core LOC); the script's own README caveat says "drift fast" |
| 12 | Sigstore-signed release attestation bundles, verifiable offline (`ft attestation verify`) | **Partially demonstrated** (machinery exists; bundles not re-verified) | [Verified exists, High] — `docs/attestations/` schema + manifest + claim-registry; per-category producing-bead pointers; bundle greenness not re-checked by analyst |
| 13 | Perf evidence vs ghostty/rio/zellij; 5-round optimization campaign "fully converged" | **Partially demonstrated** (corpus exists; in-repo only) | [Verified exists, High] — `evidence/{ghostty,rio,zellij}/` dirs, `docs/perf-ledger/` keep + negative ledgers rounds 4–9, round-9 notes claim +35–43% per-delta detection; all maintainer-produced |
| 14 | In-tree WezTerm absorption (Sept 2026), "owned" fork | **Demonstrated** | [Verified, High] — 47 `frankenterm/` workspace members, ~600K-line-class import, `docs/vendored-wezterm-design.md` |
| 15 | Weekly upstream WezTerm backport workflow keeps the fork current | **Aspirational** (process claim) | [Maintainer claim, Medium] — README "Why a WezTerm Fork" documents the decision and the intended cadence; no independently observable backport history was audited |
| 16 | Event-driven (never time-based) capture and automation — no polling loops | **Partially demonstrated** (design + code-consistent; behavior not executed) | [Verified, High] — README design principle §2 "Event-Driven, Not Time-Based"; watcher capture loop is per-tick staged with tick-budget bands; workflows trigger on detected patterns, "never on `sleep` loops" |
| 17 | Four-platform binary matrix (Linux x86_64+arm64, macOS arm64 CLI + FrankenTerm.app, Windows x86_64) with per-asset SHA256 + SHA256SUMS | **Partially demonstrated** (releases exist; binaries not downloaded) | [Verified, High] — v0.13.0 release notes: "this release restores the full binary matrix"; releases page lists the assets; `install.sh` verifies checksums + minisign (DSR key) |
| 18 | Native GUI `FrankenTerm.app` on macOS | **Partially demonstrated** (shipped in releases; not run) | [Verified, High] — `frankenterm-gui` crate exists; release notes document real GUI bug archaeology (v0.10.3 glyph-atlas lifetime fix, v0.10.4 render-loop CPU fix) with measured numbers; "working terminal window" not independently observed |
| 19 | Native GUI is production-quality / qualified | **Aspirational** | [Maintainer claim, Medium] — CHANGELOG repeatedly caveats "native qualification remains pending"; macOS bundle is ad-hoc signed, not notarized [Verified releases page] |

## 4.4 Architecture (reconstructed, not summarized)

**Crate topology (83 workspace members, root `Cargo.toml`)** [Verified, High]: 33 first-party `crates/` (the CLI `frankenterm` — a single 139,682-line `main.rs` [Verified, High] — plus `frankenterm-core` and 19+ satellite sub-crates: mux-server (+impl), pty-guardian, gui, flight-recorder, core-replay, core-fleet, core-mcp, core-tantivy, redactor, telemetry, connectors, topo, alloc, sigpipe, plus 12 zero-first-party-dep leaf `*-types` crates), 2 custom lint crates (`lints/cx_propagation`, `lints/cache_gpu_handle`), 1 fuzz crate, and 47 WezTerm-derived `frankenterm/` members (44 top-level dirs measured in the worktree vs 42 stamped — minor drift) including vendored C-library crates (`deps-freetype`, `deps-harfbuzz`, `deps-fontconfig`).

**Data flow (reconstructed from README deep dives + code)** [Verified code-consistent, Medium]: PTY output → PTY guardian (single-writer owner of process lifecycles) → watcher capture loop (per-tick stages with tick-budget bands; throttles under pressure) → bounded delta extraction with explicit gap records when continuity can't be established → pattern engine (`patterns::detect_with_context`: multi-pattern matching → BOCPD change-point → Bayesian regime ledger) → policy engine (decision pipeline, approval tokens, secret redaction) → workflow engine / transactional missions (prepare → commit → compensate, idempotency ledger, kill switches) → durable storage (SQLite via single-writer integrity, three-tier scrollback hot/warm/cold, recorder AppendLog) → Robot Mode/MCP/web surfaces with the typed envelope. Event-driven throughout; no polling by design [Maintainer claim, code-consistent].

**Async story** [Verified, High]: asupersync `=0.5.0` exclusively; the ban is enforced at four layers — (1) dependency: `deny.toml` `[bans]` tokio, wired into `scripts/release-gates.sh`; (2) type: sealed `RuntimeProof` trait makes `tokio::sync::*` types fail to compile in bounded surfaces, soundness modeled in `docs/proofs/runtime-proof-soundness.lean` with `scripts/check-runtime-proof-soundness.sh`; (3) test: `tests/wa_22x4r_no_tokio_test_in_supported_paths.rs` plus `scripts/check_asupersync_test_only.sh`; (4) custom lints (`lints/cx_propagation` enforces Cx-first cancellation contracts). `runtime_async` is the project-owned wrapper (Mutex, RwLock, Semaphore, mpsc/watch/broadcast/oneshot, `sleep_with_cx`, `timeout_with_cx`, `RuntimeBuilder`). The `tokio` entry still present in `crates/frankenterm-core/Cargo.toml` is a **dev-dependency only** (`features = ["test-util"]`, for legacy criterion `async_tokio` benches; the production dep was removed per the in-file comment `ft-i2eni.3`), and the only `use tokio::` hits in core `src/` are the self-policing eradication/guard modules — the production ban holds end to end [Verified, High].

**Memory-safety posture** [Verified, High]: CLI + core `#![forbid(unsafe_code)]`; workspace lint `unsafe_code = "forbid"` inherited by most crates; exceptions are fenced and labeled (GUI: 36 unsafe fn/block sites [Verified, High] for native/macOS APIs; mux-server `daemonize.rs`: enumerated `#[allow(unsafe_code)]` libc calls; vendored WezTerm code carries its own history; macOS Blocks binding and vendored SSH/OpenSSL linkage documented in CHANGELOG). The README's hero badge says "unsafe-forbidden" but the Engineering Discipline section states plainly: "the entire workspace is not unsafe-free" — badge simplification up top, honest framing in the body [Verified].

**Storage:** SQLite (single-writer integrity, schema migrations, GC/VACUUM discipline); recorder uses AppendLog + rusqlite with truthful identity reporting (v0.14.0 fixed identity misreporting) [Verified docs/claims, Medium].

**Asupersync relationship** [Verified, High]: pinned runtime dependency, not optional — ft is the flagship production consumer of asupersync in the FrankenSuite, and asupersync itself carries the same OpenAI/Anthropic rider, so the runtime-dependency and license-exclusion risks are *correlated* (see next step 5). Measured coupling at HEAD: **74 distinct `runtime_async::` APIs used across 259 files / 2,378 usage sites** [Verified, High] — Mutex/RwLock/Semaphore, mpsc/broadcast/watch/oneshot channels, `sleep_with_cx`/`timeout_with_cx`, `RuntimeBuilder`, `ScopedRuntimeHandle`, shutdown tokens, plus quarantine machinery (`RAW_TOKIO_RUNTIME_BUILDER_QUARANTINE_V` — a versioned quarantine symbol for the tokio runtime builder, suggesting the eradication is institutionalized rather than ad-hoc [Inference, Medium]). A runtime swap would be rewrite-scale, not a dependency bump. The sibling coupling is real: v0.12.0 notes asupersync 0.3.5 → 0.5.0 progression and the CHANGELOG shows runtime-level fixes (blocking-pool fix, fd-close-lag contention handling).

**README-vs-code drift (governance signal):** the auto-stamper *documents* its own drift — README: "Counts are auto-stamped… and drift fast." Measured at HEAD: 83 workspace members (stamp: 83 — current), 538 core top-level modules (stamp: 536 — current), 2,019,309 core LOC (stamp: 1,346,112+ — **~50% behind**; stamp recipe confirmed identical method, so this is velocity, not methodology), 70,809 test annotations (stamp: 60,535+ — ~17% behind), 44 vendored top-level dirs (README says 42 — ~5% behind). The drift direction is uniformly *growth outpacing stamps*, and the `--check` advisory gate exists but is not strict. Signal: honest machinery, maintained at a speed that defeats even its own automation.

## 4.5 Benchmark and conformance audit

### Maintainer-produced numbers

The negative-evidence discipline deserves texture, because it is the packet's load-bearing claim about methodology: the round-9 ledger opens with "**Load-bearing:** every round-9 item that is *rejected*, *carried-over*, *deferred*, or *caught-as-false-open* gets an entry here, closed with exactly one of the 8 grep-able **retry-condition predicate** forms. Negative evidence is a *win*." It defines 10 keep-gate rules, a forbidden anti-vocabulary, and declares after five rounds that "the per-op CPU micro-space is **exhausted**; both round-9 wins were *removals/parked-levers*, not new mining" — including the removal of a dead 4,260-line `scan_pipeline` module with zero production callers [Verified quotes, High].

| Claim | Number | Method controls | Would it survive independent rerun? [Inference] |
|---|---|---|---|
| Per-delta pattern detection (round 9) | +35–43% faster per delta after removing `quick_reject` Bloom prefilter; 22.76% of fleet detection self-time eliminated | 256 deltas, RCH-remote, cv≤5% local Mac timing; byte-equivalence argued (Bloom has no false negatives) [Maintainer claim] | Plausible shape [Inference, Medium]; host/toolchain-sensitive; needs independent rerun |
| Dirty-WAL startup | +74% (~2 ms saved per restart) from WAL skip-startup-checkpoint default-on | Durability preserved, regression-checked [Maintainer claim] | Small absolute number; methodologically sound but trivial impact [Inference, Medium] |
| macOS GUI render-loop CPU (v0.10.4) | ~31% lower render-loop CPU, ~56% fewer HarfBuzz calls per atlas rebuild; byte-identical re-resolve | Throttled repro, shape tests green [Maintainer claim] | Internally consistent; the bug archaeology is the strongest part [Inference, Medium] |
| 29.6k-test frankenterm-core suite (ft-nam3s) | 85 known deterministic failures → 0; "never-terminating → zero" | Verified on two independent build hosts at pinned parallelism; nine failures turned out to be real production bugs [Maintainer claim] | This is the most credible class of claim — failures-becoming-fixes is checkable in principle [Inference, Medium] |
| RC53 held-out run | **FAILED** its capture and storage service-envelope checks; "fitted rates do not establish saturated throughput or a passing performance gate" | Published in CHANGELOG verbatim [Verified quote] | The anti-benchmark: survives because it *refuses* the claim [Inference, High] |

**The honesty apparatus, quoted:** "The RC53 held-out run **failed** its capture and storage service-envelope checks; fitted rates do not establish saturated throughput or a passing performance gate." (CHANGELOG). And on scale: "The retained 200-pane figures are synthetic benchmark-lane results, not a qualified native or target-class operating envelope" (README). A packet must never cite the 200-pane figure without this sentence attached.

**Reproduction cost (honest):** 3.4M-line checkout (~469 MB working tree), pinned `nightly-2026-08-31`, heavy lanes require the maintainer's RCH (remote command host) proof workers (`RCH_REQUIRE_REMOTE=1 … rch exec`), which are not publicly inspectable. Independent rerun is effectively infeasible without maintainer cooperation — this is the single largest evidence caveat on the whole packet.

### Independent numbers

**None found.** Web search returns only the repository itself, its own docs pages (README, CHANGELOG, AGENTS.md), four verbatim mirror forks (`donaldkundert`, `rstkit`, `joyshmitz`, `mycosavant`), and one sibling-repo spec (`frankentui/docs/spec/frankenterm-term-capability-profile.md`) [External, High within recall caveats]. No third-party benchmark, code review, production deployment report, or press coverage found. **Independent validation: zero.**

**A note on evidence tiers:** the Rulebook's **[CI-observed]** tier is unused in this packet — `.github/` contains only `dependabot.yml`; there are no GitHub Actions workflows to observe. All execution evidence is maintainer-hosted (RCH proof workers) and therefore tiered as Maintainer claim, never as CI-observed.

## 4.6 Comparison: who owns the lane

**The incumbent lane — terminal multiplexing/emulation:** **WezTerm** (upstream, MIT) owns the runtime's ancestry; **tmux** owns scriptable session multiplexing with decades of operator trust; **Zellij** owns the modern-Rust multiplexer niche with a plugin system and real community; **Ghostty** owns the fast-native-terminal lane. **Why the incumbents win today, in one paragraph:** terminal choice is dominated by stability, upstream security maintenance, and ecosystem (terminfo, shell integration, editor support) — WezTerm upstream ships CVE fixes from a maintainer team, tmux is in every distro's base install, Zellij and Ghostty have independent users filing real bug reports; FrankenTerm has a solo maintainer, no independent users found, a pinned nightly toolchain, and a license that bars the two AI labs most likely to evaluate an agent terminal. Nobody migrates a daily-driver terminal to a 0.15.x single-maintainer fork on perf-ledger promises, and nobody runs a 200-pane fleet on a headline the README itself declines to qualify.

**The control-plane lane:** genuinely thin. tmux/Zellij scripting is glue, not a control plane; commercial agent harnesses (OpenAI Codex, Claude Code, Gemini CLI multi-pane setups) are ad-hoc; no open-source project offers policy-gated, transactional, attested AI-to-AI terminal control as a first-class surface. The buy-vs-build calculus for a fleet operator: tmux plus scripts can *observe* panes and *send* input, but cannot give you approval-gated sends, transactional rollback across panes, or a forensic record of which agent did what — that is the gap ft prices itself into, and it is real, if narrow [Inference, Medium]. **The genuinely unoccupied lane [Inference, Medium]:** *self-hosted, attestable, policy-gated fleet control for coding-agent swarms* — Robot Mode's typed envelope + approval tokens + transaction idempotency + signed attestation bundles is a combination no incumbent ships, because incumbents are built for humans. The lane is real but narrow: it requires the buyer to be an agent-fleet operator, which today mostly means the labs the license excludes.

## 4.7 Technical merit and adversarial review

**Strengths:**
1. **Claim-governance machinery without peer in this program.** Content-addressed, sigstore-signed attestation bundles with per-category producing-bead provenance, a claim registry, an attestation graph (headline claim → signed slot), negative-results ledgers through round 9, a count-stamper that documents its own drift, a CHANGELOG that publishes failed held-out runs, and machine-readable refusal-to-claim (`skipped_not_proven`). This is the methodology-export lens made concrete [Verified, High].
2. **Real implementation volume with release discipline.** 16,269 commits, 21 GitHub releases with detailed engineering notes (real bug archaeology: glyph-atlas lifetime decoupling, render-loop CPU fix with measured numbers, tx-engine hardening), a four-platform binary matrix restored at v0.13.0, installer with minisign verification — this is a shipped product, not a demo [Verified, High].
3. **The control plane is differentiated, not decorative.** Robot Mode's typed envelope with golden matrices, transactional missions (prepare/commit/compensate, idempotency ledger, kill switches, failure injection), policy engine with approval tokens and secret redaction, BOCPD change-point detection, hybrid search — a coherent agent-first design philosophy (passive-first, event-driven, delta extraction, single-writer integrity, fail-closed on missing telemetry) that no incumbent offers [Verified exists, High; behavioral efficacy Maintainer claim, Medium].
4. **Memory-safety and async discipline are enforced by the build, not the README.** `forbid(unsafe_code)` on CLI/core with the badge-simplification corrected in the body text; tokio banned at four layers including a Lean-modeled sealed trait; custom lints (`cx_propagation`, `cache_gpu_handle` — the latter a build failure for any process-global cache transitively owning a GPU handle, born from a real leak) [Verified, High].
5. **The WezTerm absorption is strategically coherent.** Owning the fork in-tree (Sept 2026) with a documented design rationale and weekly backport workflow means ft can patch runtime assumptions (asupersync Cx-first) that upstream would never accept — "we can (and do) patch them when their runtime assumptions don't fit ours" [Verified, High].

**Weaknesses:**
1. **Bus factor 1 by explicit, permanent policy.** "I do not accept outside contributions for any of my projects… I won't merge them directly… the only way I can move at this velocity and keep my sanity." No CODEOWNERS, no CONTRIBUTING, no governance path — this is a deliberate ceiling, not a gap to be fixed [Verified verbatim, High].
2. **The rider excludes the addressable market.** The OpenAI/Anthropic rider denies all rights — including benchmarking and analysis — to the two companies building the dominant coding agents (Claude Code, Codex) that ft is *designed to orchestrate*. The irony is total and material: the product's users are its license's excluded parties [Verified, High].
3. **No public CI; verification is maintainer-hosted.** `.github/` contains only `dependabot.yml`. All heavy verification runs on RCH proof workers that are not independently inspectable; attestation bundles are maintainer-signed. The evidence is rigorous but entirely self-certified [Verified, High].
4. **Scale claims are disavowed by their own author.** The 200-pane headline sits one screen above its qualification; native qualification "remains pending" across releases; the GUI bundle is ad-hoc signed (not notarized). The honest summary is "rich single-host machinery, fleet scale unproven" [Verified, High].
5. **Structural weight.** 3.4M lines (139,682-line single-file CLI), pinned nightly, 47 in-tree WezTerm crates to backport against solo, vendored C libraries (freetype/harfbuzz/fontconfig) — if velocity decays, bit-rot sets in within quarters, and the WezTerm fork becomes a security-maintenance liability [Verified + Inference, High].
6. **Correlated concentration risk.** Flagship consumer of asupersync (bus factor 1, same rider) — the runtime, the product, and the license exclusion are a single correlated failure domain [Inference, High].

**Steelman of the bear case:** FrankenTerm is a 3.4M-line monument to a market of one: its maintainer. The "agent swarm" framing targets coding-agent fleets, but the two labs that build the dominant coding agents are legally barred from even *benchmarking* it, and independent fleet operators don't exist yet in numbers that matter — so the control plane's most sophisticated machinery (transactional missions, BOCPD detection, attestation bundles) has no second user and no path to one. The terminal itself competes with WezTerm upstream, which has a team, CVE processes, and no nightly pin; the in-tree fork means every upstream security fix must now be backported by hand, solo, forever. The attestation apparatus is admirable, but it attests claims nobody independent asked about, signed by the person making the claims, verified on hosts nobody else can see. At bus factor 1 with an explicit no-contributions policy, the terminal state is a 3.4M-line artifact only its author can maintain — and the methodology, however honest, doesn't get a second maintainer either. The most likely terminal state: a personal tool of extraordinary quality, and a research record of how rigorous a solo developer can be.

**Hook audit (the packet grades its own hook):** "A 3.4M-line, 83-crate WezTerm fork reborn as a terminal hypervisor for fleets of AI coding agents — 21 signed releases, 70,809 tests, and an honesty apparatus that publishes the benchmarks it loses and refuses to qualify its own '200-pane' headline until a target-class hardware gate signs it." Line count (3,411,020), member count (83), release count (21), test count (70,809) verified; WezTerm-fork origin and agent-hypervisor purpose verified; "publishes the benchmarks it loses" verified (RC53 failure quote, round-9 negative ledgers, "Where it's behind"-style candor in release notes); "refuses to qualify its own 200-pane headline" verified (`skipped_not_proven` gate language). "Reborn" is stylistic but defended by the Sept 2026 fork absorption. The hook survives.

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

**License text, read verbatim** [Verified, High]: `LICENSE` is the MIT License **with an "ADDITIONAL RIDER / RESTRICTION (OpenAI / Anthropic)"** that is "part of the 'conditions' of this License" and "controls" in any conflict. Quoted scope: *"Restricted Parties" means 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).* *"Notwithstanding any other provision of this License, no rights are granted to any Restricted Party. Any purported license, sublicense, assignment, transfer, or other permission to any Restricted Party is null and void absent the express prior written permission of Jeffrey Emanuel."* Distribution/hosting/access to Restricted Parties is forbidden. *"use" includes, without limitation: 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.* Breach terminates all permissions automatically; injunctive relief and attorneys' fees reserved to Jeffrey Emanuel (copyright holder, 2026). **Classification: NOT OSI open source** — named-party discrimination with a use-restriction covering even benchmarking and analysis. Source-available with a targeted exclusion.

**The rider as strategy:** defensively coherent (prevents the two best-positioned labs from absorbing the work into training corpora or evaluation harnesses without permission); offensively self-sabotaging (the excluded parties *are* the agent-infrastructure builders, and any enterprise downstream of them inherits the legal risk; the rider also chills the independent validation the project most needs — no third party can publish a benchmark without lawyering the rider first, which helps explain why independent validation is zero). README disclosure is a single line — "MIT License (with OpenAI/Anthropic Rider). See LICENSE for details" — accurate but easy to skim past [Inference, Medium].

**Governance:** owner-directed single maintainer; no external contributors by *explicit stated policy* (quoted in §4.7); PRs are reviewed by Claude/Codex via `gh` at the maintainer's discretion, never merged directly. The `.beads` issue tracker is the planning surface. Bus factor 1, deliberately. **What breaks first if velocity decays:** upstream WezTerm security backports (47 in-tree crates, weekly workflow, solo) — the fork becomes a CVE liability; then the pinned nightly ages; then the 3.4M-line tree becomes unmaintainable. Bit-rot within quarters, not years [Inference, High].

## 4.9 NODUS factsheet

| Criterion | Score | One-line justification |
|---|---|---|
| Technology readiness (TRL 1–9) | **7** | Installable, 21 releases, maintainer-operated in production-like use; headline 200-pane scale unqualified, native GUI qualification pending |
| Strategic relevance (1–5) | **4** | Attestable agent-fleet control is a genuinely strategic emerging category; rider + solo maintenance cap it |
| Impact potential (1–5) | **3** (4 if the attestation methodology is exported) | Narrow operator niche today; the methodology's transfer value exceeds the product's |
| Implementation feasibility (1–5) | **2** | Shipped and installable, but rider excludes the AI-lab market, nightly pin, fork weight, zero external review |
| Time to mainstream (1–5) | **2** | No independent adoption signal; scale qualification pending; years minimum |
| Collaboration potential (1–5) | **1** | No outside contributions accepted, by explicit stated policy — the floor of the scale |

**Ring: Explore.** The ring rules are decisive: *Pilot* requires a release artifact plus a bounded, real workload fit — releases exist, but the headline workload (fleet scale) is explicitly unqualified and there is no independent operator; *Invest* requires independent validation plus governance — neither exists. Explore is the default for substantive-but-unproven, and FrankenTerm is its most rigorous example. Revisit triggers: target-class 200-pane gate passing (non-skipped), a second maintainer or a policy reversal, rider removal, an independent benchmark or production deployment.

## 4.10 Wardley placement

- **Terminal emulation / PTY multiplexing:** Commodity — WezTerm, tmux, Zellij, Ghostty own it; ft adds no leverage here [Inference, High].
- **WezTerm-derived terminal runtime (owned fork):** Product — v0.15.x, installable, four-platform binaries; custom-maintained solo with a weekly backport obligation. Moves toward Commodity only if the fork tracks upstream indefinitely (unlikely solo); moves left if backports lapse [Inference, Medium].
- **Agent-swarm control plane** (Robot Mode, policy gates, transactional missions, BOCPD detection, forensic replay): Custom-built → early Product — works in the maintainer's hands, unvalidated by third parties; moves to Product with the target-class scale gate passing + one independent operator [Inference, Medium].
- **Attestation machinery** (sigstore bundles, claim registry, per-bead provenance, negative-evidence ledgers, `skipped_not_proven` gates): Genesis → early Custom-built — no equivalent in any incumbent; moves right the moment a second project adopts the schema (see next step 1) [Inference, Medium].
- **Qualified 200+-pane fleet orchestration:** Genesis — explicitly gated, not yet demonstrated [Inference, High].

**The decoupling lens:** FrankenTerm represents *control-plane-from-terminal* — the orchestration logic decoupled from the emulator it observes. It advances *evidence-from-maintainer* (claims decoupled from the claimant via signed slots). And it gestures at the next decoupling: *agent-action attestation from the agent* — the mission idempotency ledger is a proto-mechanism for portable, origin-bound records of what AI agents did, a prerequisite for the memory-capsule thesis where stores become interchangeable executors.

**The methodology-export lens:** if the product fails, what survives is the claim-governance apparatus — the attestation bundle schema, the negative-evidence ledger discipline, the `skipped_not_proven` refusal-to-claim gate, the count-stamper that documents its own drift. It is the most transferable artifact in the FrankenSuite.

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

- **12 months:** continued high-velocity solo work; v0.16+; either the target-class 200-pane gate passes (lifting the provisional wording — the single highest-leverage event for the packet's verdict) or the qualification debt grows; the WezTerm backport treadmill continues. Stays in Explore. Medium confidence.
- **24 months:** bifurcation. **Upside:** an independent fleet operator validates Robot Mode on a real workload → niche Pilot for self-hosted agent-fleet operators; the attestation schema gets a second adopter → methodology moves to Custom-built/Product. **Decay:** velocity slows; upstream CVE backports lapse; the pinned nightly ages; the 3.4M-line tree becomes a solo-maintained liability → drifts to Monitor as a research artifact whose methodology outlives its product. Low–Medium confidence.
- **60 months:** binary. Either a niche-but-real artifact (the attestable control plane embedded in agent infrastructure — the "Kubernetes for terminal agents" lane, unbuilt by anyone else), or superseded: tmux/Zellij add policy-gated agent control, the labs ship their own fleet harnesses, and the terminal fork is abandoned — with the rider acting as a decay *accelerator*, since it deters exactly the acquirers or adopters who could fund a succession. The attestation methodology is the more likely survivor either way.

**Revisit triggers (concrete, observable):** target-class 200-pane gate signing a non-skipped artifact; a second human maintainer or a contributions-policy reversal; any change to the license rider; any independent benchmark, code review, or production deployment; native GUI qualification completing; upstream WezTerm backports lapsing (a negative trigger).

## 4.12 Limitations and open questions (mandatory)

**Not done:** did not compile the workspace (3.4M LOC, pinned nightly), run any test, install the binary, execute Robot Mode, or verify release artifact contents — all behavioral and performance claims rest on maintainer evidence plus source-level inspection. Shallow clone only (no history beyond HEAD). RCH remote-proof hosts are not publicly inspectable; attestation-bundle signatures were not re-verified. GUI unsafe sites were counted (36), not semantically audited. The tokio-in-`frankenterm-core/Cargo.toml` scoping was not fully audited. The frankentui sibling spec was not re-verified from a fresh frankentui clone. Web search for independent coverage carries the usual recall caveats.

**Open questions that would most change the verdict:** actual held-out performance numbers at HEAD; whether the 200-pane gate ever passes; whether any enterprise has evaluated the rider's legal exposure; funding and succession intentions (the no-contributions policy is stated, not explained); whether the WezTerm backport workflow survives a CVE crunch; what the `v0.15.8` unreleased tree becomes; whether the attestation schema gets a second adopter.

## The eight deepening questions (one paragraph each)

1. **Provenance.** FrankenTerm records more about *who did what* than any sibling repo: release attestation bundles are content-addressed and sigstore-signed with per-category producing-bead pointers, so a release is traceable to the exact work items that produced each claim; the mission subsystem keeps an idempotency ledger of prepare/commit/compensate decisions; the flight recorder captures pane output with explicit gap records when continuity can't be established [Verified machinery exists, High; end-to-end verification Maintainer claim, Medium]. Making attestation *portable* would require the bundle schema to be decoupled from ft's bead tracker (a second project adopting it — next step 1) and the mission ledger to become tamper-evident and origin-bound: today it records what happened, not who authorized it, so a hostile operator could rewrite agent-action history; hash-chaining entries and binding (origin identity, policy version, input hash) at write time — the arXiv 2606.24322 necessity result — is the missing step [Inference, Medium].

2. **The embeddable unit.** The smallest useful adoptable piece is the **Robot envelope contract** — the `RobotResponse` shape (`ok/data/elapsed_ms/version/now/schema_version`) plus its golden matrices — because it is a *specification*, not code: an operator could implement it against tmux today without touching ft's 3.4M lines, and the golden matrix gives a conformance target [Inference, Medium]. The next-smallest is the 12 zero-first-party-dependency `*-types` leaf crates (typed errors, audit, policy, config), adoptable as libraries with only the license rider as baggage. Adopting the *runtime* pieces (watcher capture loop, pattern engine, mission transactions) costs the whole asupersync-pinned, nightly-only core — vendoring hundreds of thousands of lines of rider-encumbered code — which is why the envelope-as-spec is the only genuinely cheap unit [Verified structure, High; adoption-cost judgment Inference, High].

3. **Unexercised option value.** The architecture holds at least four unused capabilities: the `xterm-frankenterm` terminfo entry plus the `FRANKENTERM=1` session-detection protocol, defined in a real cross-project spec (`frankenterm-term-capability-profile.md` in the frankentui repo — verified resolving 2026-09-22) that is explicitly marked DRAFT and where the custom entry is "NOT the default" — a terminal-identity coordination point no program yet consumes [Verified, High]; the WASM extension surface ships types with the runtime "not yet wired" (README deep dive) — an extension ecosystem waiting on a loader [Verified, High]; the recorder/replay forensics plus the idempotency ledger are a time-travel debugging substrate currently used only for post-hoc forensics, not for *predictive* fleet management [Verified exists, High]; and the owned WezTerm fork means ft can ship terminal-protocol extensions (custom escape sequences for agent signaling) that upstream would never accept — a private protocol lane nobody has exercised [Inference, Medium]. What unlocks them is, respectively, one consumer of the terminfo entry (or of `FRANKENTERM=1` detection), the WASM runtime wiring, a replay-driven anomaly predictor, and the decision to mint a private escape-sequence namespace — all product decisions, none blocked on research [Inference, Medium].

4. **Benchmark honesty.** The numbers most likely to survive an independent rerun are the *adverse and negative* ones — the RC53 held-out failure, the round-9 negative ledgers, the v0.10.3/v0.10.4 bug-archaeology measurements (which are checkable against the fixed code) — because they are published losses and failure modes with documented methodology, and nobody publishes a failure they can't defend [Inference, Medium]. The positive perf numbers (+35–43% detection, +74% WAL startup) have documented methods (RCH-remote, cv≤5%) but are load-bearing for the "optimization campaign converged" narrative and have never been independently reproduced; the 200-pane figure is explicitly disavowed as a qualification by its own README. The thesis that rests on the *safest* numbers is not "fast" but "honest": the evidence discipline, not the deltas, is what an independent rerun would confirm [Inference, Medium].

5. **The governance path.** There is no credible route from one maintainer to an institution that doesn't start with a policy reversal: the README states plainly that outside contributions are not accepted, PRs are never merged directly, and the arrangement exists to protect the maintainer's velocity and sanity — a deliberate, reasoned choice, not an oversight [Verified verbatim, High]. A second maintainer can only emerge if the policy changes; an institutional adopter can only appear if the rider changes (no lab or enterprise will build on a codebase whose license can terminate their rights over a benchmarking dispute). What breaks first if velocity decays is the WezTerm backport treadmill — 47 in-tree crates against upstream CVE fixes, solo — which turns the fork from an asset into a security liability within quarters; the pinned nightly and the 3.4M-line tree follow [Inference, High].

6. **The license as strategy.** The rider excludes exactly OpenAI, L.L.C., Anthropic, PBC, their affiliates, and anyone acting for, benefiting from, or under the direction of them — and defines "use" to include benchmarking, testing, analyzing, indexing, and training-data incorporation, with automatic termination and injunctive relief reserved to Jeffrey Emanuel [Verified verbatim, High]. As strategy it is coherent defensively (it prevents the two labs best positioned to absorb the work from doing so without permission, and the maintainer's stated motive is protecting work he gives away for free) and self-sabotaging offensively: the project's stated mission is orchestrating *AI coding agents*, the excluded parties build the dominant coding agents (Claude Code, Codex), and the rider's breadth (even *analyzing* is forbidden) chills exactly the independent validation the project needs — the zero-independent-coverage finding and the rider are not independent facts [Inference, Medium].

7. **Agent-era fit.** The concrete workload that would pick FrankenTerm over tmux/Zellij plus scripts is a self-hosted operator running 20–200 coding agents who needs *one AI to safely drive others*: approval-gated sends, transactional multi-pane missions with rollback, a forensic record of what every agent did, and a machine-readable envelope for meta-agent orchestration — the "Scenario 5: Drive one AI by another, safely" use case no incumbent serves [Inference, Medium]. What would have to become true first: the target-class 200-pane gate passing (the workload is literally the headline), one independent operator validating Robot Mode on a real fleet, and — unavoidably — a license the operator's lawyers can sign, since the current rider excludes the labs most likely to *be* that operator [Inference, Medium].

8. **The kill test.** The single event that would falsify the core thesis — "agent swarms need a dedicated, attestable terminal control plane" — is an incumbent absorbing the control plane: Zellij or tmux shipping policy-gated, transactional, audited agent control as a first-class surface, or the labs shipping fleet orchestration inside their own harnesses (making the terminal a dumb substrate), would commoditize FrankenTerm's only unoccupied lane and leave it competing as a terminal, a fight it cannot win solo against WezTerm upstream [Inference, Medium]. The experimental falsifications are nearly as decisive: an independent rerun of the round-9 perf claims on quiet hardware showing they don't reproduce outside the maintainer's RCH workers, or the 200-pane target-class gate failing repeatedly — either would collapse the two pillars (measured performance, qualified scale) the product thesis stands on, leaving only the methodology [Inference, Medium].

---

**Working notes:** fresh shallow clone at `~/workspace/.scratch/frankenterm-fresh/` (HEAD `ce183cd`, 2026-09-22 02:31:53 -0400). A stale clone directory from earlier work was present and ignored; all numbers above come from the fresh clone. Web search for independent coverage (2026-09-22) returned only the repo's own pages and four verbatim mirror forks. No durable user-facing files created besides this assessment and its versioned intermediates.