# Franken Surveillance System — RULEBOOK v1.0 Assessment Packet

**Repository:** `Dicklesworthstone/franken_surveillance_system` · **Language:** Rust 2024 (pinned `nightly-2026-08-31`), zero third-party dependencies [Code-verified, High] · **Pinned commit:** `3dcc111c67979a0225edbc8f5ff30343aec33388` (2026-09-22 09:15:33 −0400, [Git-observed, High]) — `feat(capture): record native HTTP cameras through durable original custody` · **Last push:** 2026-09-22T13:35:31Z [External, High] · **Scope:** the pinned commit only, not HEAD. **No tag points at the pin; zero GitHub Releases exist for this repository** [External, High]. *Cold-reader note: "v5" = fifth draft of this packet (rewrite-loop round 5).*

**Method (analyst):** shallow clone checked out at the pin under `~/workspace/.scratch/fss-verify` (verified non-empty, 833 `.rs` files); history deepened to 60 commits for the authorship/velocity sample only — the working tree stayed at the pin. Read: README (all 562 lines), `IMPLEMENTATION_STATUS.md`, `AGENTS.md`, `LICENSE` (verbatim), `DEPENDENCY_CONSTITUTION.md` (asupersync sections), `LOCAL_QUALIFICATION_AND_RELEASE.md` (release-authority thesis), `COMPREHENSIVE_PLAN_FOR_FRANKEN_SURVEILLANCE_SYSTEM.md` (document-control + evidence labels), `DEVICE_ADAPTER_MATRIX.md` (tiers + state column), `architecture/franken_imports.json` (47 rows), `docs/deep-dives/INDEX.md`, `docs/PERF_LEDGER.md`, `docs/NATIVE_HTTP_RECORDING.md` (new at the pin), `docs/NEGATIVE_EVIDENCE.md`, `docs/ATP_AND_DISTRIBUTED_EVIDENCE.md` (thesis section), `CHANGELOG.md` (Unreleased section), root and crate `Cargo.toml` files, `Cargo.lock`, `.github/workflows/ci.yml`, pin-commit diff stat, `crates/fss-twin/src/lib.rs` header, `crates/fss-reference/src/agent_session/` listing, `crates/fss-reference/src/ingest/{http_camera.rs, inference/mod.rs, rgb_detections.rs}` headers, `crates/fss-cli/src/bin/fss-infer.rs` header. Counted: `.rs` files/lines per crate, unsafe constructs (blocks, `fn`/`trait`/`impl`/`extern` — comment-excluding), `forbid(unsafe_code)` attributes, `#[test]` attributes, `async fn` occurrences (zero), Cargo.lock package entries, `.beads/issues.jsonl` status distribution, README target-crate names (83). Fetched: GitHub repo API (stars/forks/push date), releases API (empty), Actions API (run counts, conclusions, queued jobs). **Not done:** the workspace was never compiled, no test was executed, no toolchain was installed in this environment, no benchmark was reproduced (there are no maintainer benchmark numbers to reproduce), no camera hardware or drone was touched, no independent deployment was attempted, the 133-doc corpus was sampled by index and key files rather than read exhaustively.

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

---

## Hook

A 437,249-line [Counted, High], zero-third-party-dependency [Counted, High], unsafe-free [Counted, High] Rust workspace that wants to be the evidence-native operating system for owner-authorized cameras — whose own README says it is not yet a surveillance product [Maintainer claim, High], whose declared async runtime appears nowhere in the dependency tree [Code-verified, High], whose CI history is 622 runs with zero successes on the current qualification workflow (570 cancelled, 47 failed; the only 4 successes, on 2026-09-03/04, belong to retired snapshot workflows absent from the pin) and the pin's own run still queued [CI-observed, High], and whose latest commit ships native HTTP camera recording while honestly recording that it was never compiled or tested [Git-observed, High]. The architecture documents are the product; the code is the most honest draft of them. [Inference, High]

## TL;DR

- **What it is:** A from-scratch, pure-Rust "sensor fabric and semantic control plane" for owner-authorized cameras and manually piloted capture drones: 13 workspace crates, 833 files, ~437k first-party lines, zero external crates, zero unsafe constructs, 5,379 test attributes — all building on `std` alone at the pin [all Counted, High]. Single human maintainer (Jeffrey Emanuel), extreme velocity (~20 commits across 2026-09-21/22 [Git-observed, High]), 26 stars [External, High].
- **Strongest evidence:** The honesty infrastructure. The README's IMPORTANT box disclaims the product does not yet exist as a product; `docs/PERF_LEDGER.md` states verbatim "No runtime exists yet, so this ledger contains no performance wins"; the pinned commit message itself records "Rust compilation, tests, rustfmt, Clippy and native qualification NOT RUN: no Rust toolchain available"; the dependency constitution and qualification docs explicitly demote GitHub CI to "portable supplementary specification." A project that documents its own incompleteness at this resolution is rare [all Maintainer claim, High — the honesty is the maintainer's; the code facts are Counted/Code-verified, High].
- **Strongest doubts:** Nothing at the pin has been shown to run end-to-end on real hardware: no release artifact, zero GitHub Releases, and CI history across all 622 recorded runs shows zero successes on the current "portable qualification specification" workflow (570 cancelled, 47 failed; the only 4 successes, dated 2026-09-03/04, belong to retired agent-source-snapshot workflows no longer in the tree), with the pin's run sitting "queued" against self-hosted runners [CI-observed, High]; 25 of the last 40 commits carry "NOT RUN" disclaimers (~63% of the recent window [Git-observed, High]); the declared sole async runtime (asupersync) is absent from `Cargo.lock` and the tree contains zero `async fn` [Code-verified, High]; the MIT license carries the FrankenSuite rider naming OpenAI and Anthropic as forbidden parties for use including *analysis* [Code-verified (license text), High].
- **NODUS ring: Explore** [Inference, Medium] (TRL 3 — see §4.9). Substantive-but-unproven is the textbook Explore case: the reference implementation is large and internally coherent, but no operational-environment demonstration exists at the pin. The rider is an advancement blocker, not a ring qualifier.

## Quick Links

Pin-relative links (`blob/3dcc111c67979a0225edbc8f5ff30343aec33388`); all verified HTTP 200 on 2026-09-22 [Verified, High]:

1. [Repository](https://github.com/Dicklesworthstone/franken_surveillance_system) — 26 stars, 3 forks
2. [Pinned commit page](https://github.com/Dicklesworthstone/franken_surveillance_system/commit/3dcc111c67979a0225edbc8f5ff30343aec33388) — the native-HTTP-recording commit with its NOT RUN trailer
3. [README](https://github.com/Dicklesworthstone/franken_surveillance_system/blob/3dcc111c67979a0225edbc8f5ff30343aec33388/README.md) — thesis, device tiers, target crate families
4. [License (with AI-lab rider)](https://github.com/Dicklesworthstone/franken_surveillance_system/blob/3dcc111c67979a0225edbc8f5ff30343aec33388/LICENSE)
5. [Implementation status](https://github.com/Dicklesworthstone/franken_surveillance_system/blob/3dcc111c67979a0225edbc8f5ff30343aec33388/IMPLEMENTATION_STATUS.md) — dated 2026-09-03; "pre-release deterministic reference implementation; not production-qualified"
6. [Native HTTP recording (new at the pin)](https://github.com/Dicklesworthstone/franken_surveillance_system/blob/3dcc111c67979a0225edbc8f5ff30343aec33388/docs/NATIVE_HTTP_RECORDING.md)
7. [Dependency constitution](https://github.com/Dicklesworthstone/franken_surveillance_system/blob/3dcc111c67979a0225edbc8f5ff30343aec33388/DEPENDENCY_CONSTITUTION.md) — the asupersync-only runtime rule
8. [Local qualification & DSR-first release architecture](https://github.com/Dicklesworthstone/franken_surveillance_system/blob/3dcc111c67979a0225edbc8f5ff30343aec33388/LOCAL_QUALIFICATION_AND_RELEASE.md)
9. [FrankenStack deep dive](https://github.com/Dicklesworthstone/franken_surveillance_system/blob/3dcc111c67979a0225edbc8f5ff30343aec33388/FRANKENSTACK_DEEP_DIVE.md) — the sibling-project audit
10. [Deep-dive index](https://github.com/Dicklesworthstone/franken_surveillance_system/blob/3dcc111c67979a0225edbc8f5ff30343aec33388/docs/deep-dives/INDEX.md) — 14 sibling audits
11. [Performance ledger](https://github.com/Dicklesworthstone/franken_surveillance_system/blob/3dcc111c67979a0225edbc8f5ff30343aec33388/docs/PERF_LEDGER.md) — "No runtime exists yet, so this ledger contains no performance wins"
12. [Changelog](https://github.com/Dicklesworthstone/franken_surveillance_system/blob/3dcc111c67979a0225edbc8f5ff30343aec33388/CHANGELOG.md)
13. [CI workflow (portable qualification specification)](https://github.com/Dicklesworthstone/franken_surveillance_system/actions/workflows/ci.yml) — 622 runs; self-hosted runners required

## Did You Know

`Cargo.lock` at the pin contains exactly **13 packages — the 13 `fss-*` workspace crates themselves**. A 437,249-line Rust workspace with zero third-party dependencies: no serde, no tokio, no libc, no image crate — the MJPEG decoder, the tensor types, the HTTP camera client, the content-addressed object graphs, and the agent situation machinery are all first-party code on `std` alone [Counted, High]. The dependency constitution's "tiny DEP-recorded foundational exception set" (serde/serde_json as candidates) has not been exercised — the exception list is currently empty [Code-verified, High]. Whether that is heroic discipline or an enormous reinvention surface is the central engineering bet of the project [Inference, Medium].

## Franken-worthy next steps

1. **Adopt the "NOT RUN" receipt norm as program-wide evidence policy:** this repo's commits already carry machine-greppable qualification disclaimers ("Rust compilation, tests, rustfmt, Clippy and native qualification NOT RUN: no Rust toolchain available"). Require every FrankenSuite assessment and every future packet to record a structured qualification receipt per pinned commit — compiled? tests run? by whom, on what toolchain? *Done when:* the Rulebook's method section mandates the receipt and one packet backfills it. [Inference, High — process proposal]
2. **Import silence certificates into the assessment program:** FSS's `MeaningfulDelta` machinery can *prove no decision-relevant change* across successor commits — a "silence certificate." Our own rewrite loop needs exactly this: when a packet is re-pinned, the coordinator should publish which prior findings the new pin invalidates versus leaves silent, instead of re-verifying everything or asserting nothing changed. *Done when:* one packet ships a machine-readable silence/invalidation delta against its previous pin. [Inference, High — process proposal, project-distinctive]
3. **Extract the CoverageWitness discipline into agent evaluation:** the repo's rule — a missing detection during a coverage gap is not evidence of absence; negative reads require a `CoverageWitness` — ports directly to agent benchmarks, where a non-answer caused by tool-coverage gaps is routinely mis-scored as model failure. *Done when:* an agent benchmark variant scores with and without coverage witnesses and the ranking delta is published. [Inference, Medium]
4. **Carve out the embeddable unit and prove second-consumer adoption:** `fss-packet` (12,563 lines) or `fss-container` (1,736 lines) as a standalone crate with no workspace siblings, adopted by one unrelated tool (e.g., a pcap-evidence or media-forensics utility). The dependency-free posture makes this unusually cheap to attempt [Inference, Medium on the cheapness claim]. *Done when:* the crate builds standalone and a second consumer exists. [Inference, Medium]
5. **Price the rider with a real experiment:** the rider bars OpenAI/Anthropic from even *analyzing* the code. Commission the first permitted-party independent review of the privacy/threat model (PRIVACY.md, SECURITY.md) and record whether any qualified reviewer will engage under these terms. *Done when:* a review is published, or three qualified reviewers decline on license grounds. [Inference, Medium]

## 4.1 Why it exists — the market problem

**The problem, as the maintainer frames it:** consumer security hardware is cheap and capable but every product is an island — a battery camera exposes only a proprietary app, a USB camera is standards-compliant but tethered, a drone gives a superb moving view with no supported control SDK. Conventional NVRs record streams but do not build a calibrated, provenance-carrying world model that an autonomous agent can query and operate safely. The gap FSS targets is not "another NVR" but the substrate beneath models: packet truth vs. decoded frames vs. model scores vs. verified effects, kept type-distinct so an agent never mistakes one for another [Maintainer claim, Medium].

**Who feels the pain:** owner-operators of heterogeneous camera fleets who want local-first (no cloud), plus — prospectively — agents that need a legible, uncertainty-preserving interface to the physical world rather than a pile of subsystem replies [Inference, Medium]. The "agent cognitive operating system" framing assumes agents will be the primary consumers of surveillance infrastructure — a bet on the agent era, not on today's NVR buyer [Inference, Medium].

**Why now:** the repo states the "what" far more than the "why now" — no triggering motivation is given a date or event in the materials read [Code-verified, Medium — absence across README, plan, and status docs]. The plan's document-control section gives the closest thing to a stated motivation, and it is about failure modes, not timing: "A home-security system observes a partially visible physical world through lossy sensors and fallible models. A stream may be accepted without producing frames; frames may exist without trustworthy time; a detector may fire without a real event; an event may be real but unobservable from a failed camera…" — the design exists because "a design that collapses these states will look good in a demo and fail exactly when an operator needs to know what happened" [Maintainer claim, High]. The implicit timing argument is that consumer cameras, local accelerators, and Rust's maturity make a from-scratch, dependency-free, memory-safe sensor fabric buildable by a small team, while the agent wave creates demand for exactly the legibility layer (situation capsules, affordance frontiers, proof-carrying operations) that current NVRs lack [Inference, Low].

**Demand-side check:** the lane FSS would enter already has a dominant open-source occupant. Frigate (MIT, Blake Blackshear) is, per an independent NVR comparison, "the most popular self-hosted NVR for homelab and Home Assistant users, with mature hardware-accelerated detection (Coral, OpenVINO, TensorRT, Hailo)" plus face recognition, license-plate recognition, CLIP semantic search, and GenAI descriptions landing in-tree [External, Medium — the comparison is a third-party homelab project, not a neutral benchmark]. FSS's honest position is that it does not compete with Frigate yet: its own README says it does not acquire feeds, decode video (at the README's writing), run models, or deliver alerts [Maintainer claim, High]. The unoccupied part of the lane is the *epistemic* substrate — provenance-attested, abstention-aware, agent-legible sensor fusion — which no incumbent bothers with because no buyer currently pays for it [Inference, Medium].

**Why a rewrite, not an extension:** the architecture docs argue that bolting provenance, version-universe semantics, and agent legibility onto an existing NVR (Frigate/ZoneMinder/Shinobi) would inherit their foreign runtimes (Python, Node, FFmpeg) and ambient-authority designs; only a clean room lets every plane be type-distinct from the start [Maintainer claim, Medium]. Whether the clean-room premium is worth paying before a single camera works is the open question §4.7 takes up.

## 4.2 What it is — repo TL;DR

A 13-crate Cargo workspace (root `Cargo.toml` verified at the pin [Counted, High]) implementing a *deterministic reference* — not a product — for an evidence-native surveillance system: packet capture truth, content-addressed object graphs, an ordered `EvidenceDeltaBatch` authority history, child-first/root-last publication, a native MJPEG codec, tensor/model IR types, a digital-twin crate, and an agent cognition membrane (`SituationCapsule`, `WorldEnvelope`, affordance frontiers, handoffs). The newest edge is native HTTP camera recording (`http_recording.rs`, 401 lines [Counted, High]) with loopback/filesystem test contracts, landed at the pin — uncompiled and untested by its own commit message's admission [Git-observed, High].

Development velocity is extreme and agent-shaped [Inference, Medium — the shape evidence: highly structured commit bodies with bead-ID trailers like [FSS-140]/[fss-ziv3z], machine-checkable honesty trailers, and a ~10-commit/day cadence no human sustains alone; direct agent-attribution trailers are rare (1 Grok trailer in 60 commits), so the "shaped" is stylistic, not proven]: ~20 commits across 2026-09-21/22 alone [Git-observed, High], 1,581 beads (issue units) in `.beads/issues.jsonl` — 1,262 open, 300 closed, 16 in progress, 2 blocked, 1 tombstoned [Counted, High]. The honest comparison the packet keeps returning to: the *documentation* corpus (133 docs files, 1.9 MB; registries 284 KB; schemas 492 KB; architecture 432 KB [Counted, High]) rivals the code in mass, and the README's own IMPORTANT box still describes the repo as "normative architecture, deep Franken-suite audits, registries, schemas, and a dependency-free Rust contract skeleton" that "does not yet acquire camera feeds, decode video, run models, reconstruct a property, upload archives, or deliver alerts" — a description the pin's HTTP-recording commit has already partially outgrown [Maintainer claim, High on the box's text; the outgrowing is Code-verified, High].

One-line verdict: **the most elaborately self-documenting pre-product codebase in the FrankenSuite [Inference, Medium — comparative over the packets completed so far, not a measured ranking] — a 437k-line, zero-dependency, unsafe-free reference implementation of a surveillance philosophy, with the epistemic honesty to disclaim its own verification status commit by commit, and no demonstrated end-to-end run on real hardware.** (NODUS: Explore — see §4.9.)

## 4.3 Repo facts (claim inventory)

Every claim below was verified against the pinned commit on 2026-09-22. **Status** is the Rulebook's required audit verdict per claim.

| # | Claim | Status | Evidence | Tier, Confidence |
|---|-------|--------|----------|------------------|
| 1 | 13 workspace crates, 833 `.rs` files, ~437,249 first-party lines | demonstrated | Fresh clone at pin; per-crate `find`/`wc` counts (largest: fss-reference 184,727; fss-core 124,083; fss-publication 22,004; fss-twin 20,277; fss-object 18,529; fss-cli 17,518) | [Counted, High] |
| 2 | Zero unsafe constructs in the tree; 695 of 833 files carry `#![forbid(unsafe_code)]`; the remaining 138 files were scanned for `unsafe` blocks and `unsafe fn/trait/impl/extern` declarations — zero hits | demonstrated | Comment-excluding scans over all `.rs` files. (Caveat: crates do not inherit `[lints] workspace = true` — the forbid rides on per-crate-root attributes, which are present in all 13 lib/bin roots checked) | [Counted + Code-verified, High] |
| 3 | Zero third-party dependencies: `Cargo.lock` contains exactly 13 packages (the workspace crates) | demonstrated | `grep -c 'name = '` on Cargo.lock = 13; no serde, tokio, libc, or anything else | [Counted, High] |
| 4 | The README badge claims "runtime-Asupersync"; asupersync is absent from `Cargo.lock` and the tree contains zero `async fn` | stale as a present-tense code claim | `grep -ri asupersync` over manifests+lockfile: only root `Cargo.toml` `[workspace.metadata.fss]`; `grep -rl 'async fn'` over crates = 0. (Fairness note: the import ledger's asupersync rows are a target-state *design* census, honestly dated asOf 2026-08-31 with "after admission" modes — the drift is the badge's present tense, not the ledger) | [Code-verified, High] |
| 5 | Native HTTP camera recording through durable original custody (pin commit: `http_recording.rs` 401 lines, 310 lines of loopback/filesystem tests, `docs/NATIVE_HTTP_RECORDING.md`) | partially demonstrated (code exists; qualification explicitly disclaimed) | Commit diff stat at pin; the commit message itself states "Rust compilation, tests, rustfmt, Clippy and native qualification NOT RUN: no Rust toolchain available. No Bead, gate or production-readiness claim advanced." | [Code-verified, High] on existence; [Maintainer claim, High] on the disclaimed qualification |
| 6 | 5,379 `#[test]` attributes across 436 files | demonstrated (existence); greenness unestablished | Counted via grep; no public test report exists, and the current CI workflow has never succeeded (claim 7) | [Counted, High] on existence |
| 7 | CI executes a portable qualification spec (622 runs) | partially demonstrated (the spec exists and runs are attempted; the current workflow has never succeeded) | Actions API 2026-09-22, full history: 622 runs — 570 `cancelled` (concurrency cancel-in-progress), 47 `failure`, 4 `success`, 1 `queued`. The 4 successes (2026-09-03/04) belong to retired `agent-source-snapshot*.yml` workflows absent from the pin's tree (which has only `ci.yml` and `release.yml`); the current "portable qualification specification" workflow has zero successes. The run against the pin is `queued` behind `runs-on: [self-hosted, fss-linux-amd64]`. The repo's own docs demote hosted runs to "supplementary" — consistent with the observed record, but greenness of the current spec is nowhere established | [CI-observed, High] |
| 8 | `docs/PERF_LEDGER.md`: "No runtime exists yet, so this ledger contains no performance wins" | demonstrated | File read at pin; no benchmark numbers exist anywhere in the tree (no criterion/hyperfine, no ops/s figures — grep-clean) | [Code-verified (file text), High] |
| 9 | README IMPORTANT box: repo is "normative architecture … and a dependency-free Rust contract skeleton" that "does not yet acquire camera feeds, decode video, run models, reconstruct a property, upload archives, or deliver alerts"; README "Current status" section: project "remains at **GATE-000**: architecture constitution" with "Not implemented now" listing codecs, containers, model inference, detection/tracking/association, and the agent/CLI layer | stale (code has moved past both statements; the two README statements also sit uneasily with each other and with IMPLEMENTATION_STATUS.md) | Box text and status section at pin vs. the pin's own HTTP-recording feature, the 6,145-line MJPEG codec, `ingest/inference/`, `rgb_detections.rs`, and the six fss-cli binaries; IMPLEMENTATION_STATUS.md (2026-09-03) already said the repo was "no longer merely an architecture corpus or crate skeleton". Nuance the packet keeps: the GATE-000 label applies the plan's strict 7-criteria definition of "implemented" (nothing is qualified, so nothing counts), while the status doc uses "deterministic reference implementation" — the terms differ, but the status section is also factually stale (it counts "twelve project-specific deep dives"; the tree has 14) | [Maintainer claim, High] on the text; [Code-verified, High] on the drift |
| 10 | IMPLEMENTATION_STATUS.md (2026-09-03): "pre-release deterministic reference implementation; not production-qualified" | stale (dated 19 days before the pin; the native-capture work landed after) | File date vs. pin date; the native HTTP recording, RGB neural trajectories, and global-assignment tracker commits are all 2026-09-21/22 | [Maintainer claim, High] on the text; [Git-observed, High] on the staleness |
| 11 | FrankenSuite deep-dive inheritance: 14 sibling audits + `FRANKENSTACK_DEEP_DIVE.md` (86,792 bytes) + machine ledger `architecture/franken_imports.json` (47 rows, asOf 2026-08-31) mapping mechanisms to owning crates | demonstrated (as documents); the "load-bearing inheritance" into named crates is aspirational where the crates don't exist | Files counted and ledger parsed; most `owner` fields (fss-transfer, fss-runtime, fss-search, fss-graph-*, fss-mcp, fss-memory…) name crates absent from the 13-member workspace. The README counts 83 named target crates/families against 13 checked in | [Counted, High] on the documents; [Inference, Medium] on the mapping gap |
| 12 | Device posture tiers 0–4 with owner-authorized-only policy; lab candidates Wyze Cam v4, AOSU P1 Max (interoperability lab), DJI Flip (manual capture/import, no autonomous flight authority) | partially demonstrated (policy docs + adapter matrix exist; only the native HTTP/MJPEG path has code) | README device section; DEVICE_ADAPTER_MATRIX.md — whose header states its "Meaning…: research and admission plan, **not a list of working integrations**" (evidence snapshot 2026-08-31), with a "Current FSS state" column reading "specified", "research complete; unimplemented", or "research target only" — the maintainer's own matrix confirms no working integration; INTEROPERABILITY_LAB.md, AGENTS.md security boundary; the `fss-device-*` and `fss-drone-capture` crates from the target family list do not exist in the workspace | [Maintainer claim, High] on policy; [Code-verified, High] on the missing crates |
| 13 | Extreme recent velocity with honest non-qualification: ~20 commits 2026-09-21/22; 25 of the last 40 commits carry "NOT RUN" disclaimers | demonstrated | `git log` window (deepened to 60); per-commit body grep for "NOT RUN" (25 of 40 commits, not lines) | [Git-observed, High] |
| 14 | Single human maintainer; no releases; no release artifact at the pin despite the "release-local DSR authority" badge | demonstrated | GitHub API: 26 stars, 3 forks, 0 releases; all sampled commits authored by Dicklesworthstone/Jeffrey Emanuel; `scripts/qualify.sh` and DSR docs exist but no signed assets are checked in and no DSR receipt is published in the repo [Code-verified, High on the absence] | [External, High] on stars/forks/releases; [Git-observed, High] on authorship |
| 15 | License rider bars OpenAI, Anthropic, affiliates, and anyone acting for them from any use — explicitly including "benchmarking, testing, analyzing, indexing" — with automatic termination on breach | demonstrated | LICENSE read verbatim at pin | [Code-verified (license text), High] |
| 16 | `docs/NEGATIVE_EVIDENCE.md` (48 lines) records failed hypotheses with a required schema (ID, date/commit, hypothesis, setup, result, decision, revival condition) | partially demonstrated (the discipline exists as schema + 3 design-level entries; zero implementation experiments) | File header states "No implementation experiments have been run"; entries NEG-001 (DJI Flip SDK not an architectural dependency), NEG-002 (proprietary app access not a stable standard), NEG-003 (no single frontier VLM as the whole stack) are architecture-research constraints, not experimental results | [Code-verified (file text), High] |

**What the inventory says in aggregate:** claims about *discipline* (zero unsafe, zero deps, forbid-attributes, test counts, documentation mass) verify at High confidence; claims about *capability* (async runtime, camera acquisition, release authority, inherited mechanisms) are either stale documents, aspirational target-state, or explicitly disclaimed by the maintainer's own commit messages. The repo's honesty about the second category is its most verified property.

## 4.4 Codebase tour

**Workspace topology (13 members, [Counted, High]):** `fss-cli`, `fss-codec-mjpeg`, `fss-container`, `fss-core`, `fss-geometry`, `fss-ledger`, `fss-model-ir`, `fss-object`, `fss-packet`, `fss-publication`, `fss-reference`, `fss-tensor`, `fss-twin`.

**Dependency posture:** the union of external dependencies across all 13 manifests and `Cargo.lock` is the empty set — the production closure is `std` plus the workspace itself [Counted, High]. The dependency constitution's "tiny DEP-recorded foundational exception set" names serde/serde_json as *candidates* for bounded control/report data-shape roles; at the pin the exception list is unexercised [Code-verified, High]. Reproduction requires the pinned `nightly-2026-08-31` toolchain (`rust-toolchain.toml`) — `rust-version = "1.100"` is declared in the workspace manifest [Code-verified, High].

**Data flow, end to end (reconstructed from the code, not the diagrams):**

- **Acquisition — `fss-reference` (184,727 lines, 381 files [Counted, High]):** the giant. Deterministic *virtual* acquisition: synthetic/consented fixtures generate source truth before transport truth; delivery loss, duplication, reordering, and corruption are explicit derived observations that can never rewrite retained source bytes. The native path has two layers worth distinguishing: `ingest/http_camera.rs` — an actual owner-authorized native HTTP MJPEG acquisition client over `std::net::TcpStream` ("No DNS, redirects, credentials, reconnect, worker, clock reads or invented camera timestamps") [Code-verified, High] — and the pin's `ingest/http_recording.rs` (401 lines), which composes the camera client, wire archive, native JPEG decoder, and terminal publisher into `HttpRecording` with ten single-thread loopback/filesystem contracts covering three HTTP framings, cold recovery, frame limits, publication cut points, lost acknowledgements, stale keys, denied access, and retained decoded work. The module docstring is explicit that this is single-threaded — consistent with the zero-`async fn` finding [Code-verified, High]. The same crate hosts the reference agent membrane (`src/agent_session/` — checkpoint, context hydration), i.e., the SituationCapsule machinery lives here as reference code, not in the unbuilt `fss-agent-*` target crates [Code-verified, High].
- **Model execution — `ingest/inference/` + `ingest/rgb_detections.rs`:** retained source-to-model execution exists as reference code — "using the existing pure-Rust scalar executor," with outputs that are "uncalibrated model tensors, never detections, corroboration, certified absence or external-effect authority" [Code-verified, High]. One layer up, `rgb_detections.rs` turns RGB tensor heads into "source-space, privacy-screened detector proposals" with class-aware NMS — but the file's own boundary is explicit: "These are uncalibrated model proposals, never identity, coverage or effect authority" [Code-verified, High]. So the honest stack is: model graphs execute → tensors come out → proposals are generated → nothing is calibrated, nothing carries authority, and nothing has been qualified. The packet's §4.7.1 is refined accordingly: it is not that no model code exists, but that the model story stops exactly where a product's would start.
- **Packet truth — `fss-packet` (12,563 lines [Counted, High]):** exact transport/source bytes, protocol sequence, compressed access units, time and continuity evidence. The narrow waist everything downstream cites.
- **Media — `fss-codec-mjpeg` (6,145 lines), `fss-container` (1,736 lines):** first-party MJPEG decode and container handling — the "no FFmpeg" bet made concrete, at least for MJPEG. No H.264/H.265/AV1 codec crates exist at the pin [Code-verified, High].
- **Authority — `fss-ledger` (11,074 lines), `fss-object` (18,529 lines), `fss-publication` (22,004 lines), `fss-core` (124,083 lines):** stable typed identities, content digests, root-closed manifests, ordered `EvidenceDeltaBatch` history, `LedgerAnchor` succession, child-first/root-last publication, semantic handles with H0–H4 hydration ladders, capability/privacy enforcement [Code-verified, High on the module structure; behavior unexecuted].
- **Cognition substrate — `fss-tensor` (2,569 lines), `fss-model-ir` (9,940 lines):** typed tensors and a frozen operator IR for model execution; the pin-window `2d6f695` commit ("execute deep graphs within explicit peak-memory bounds [FSS-140]") is the newest edge [Git-observed, High]. No model weights ship (`models/` contains only `lab/` fixtures) and runtime weight download is constitutionally forbidden [Code-verified, High].
- **Geometry/twin — `fss-geometry` (6,084 lines), `fss-twin` (20,277 lines):** calibration, coverage witnesses, and property-geometry import — `fss-twin`'s root docs describe importing "evaluated property geometry without executing authoring software" (the Blender-twin integration plan made reference code), with local right-handed Z-up source units that "scale evidence never silently rescales" [Code-verified, High].
- **Operator surface — `fss-cli` (17,518 lines):** binaries `fss-archive`, `fss-event`, `fss-file`, `fss-infer`, `fss-lab`, `fss-hydration-rehearsal`. `fss-infer` is the "local operator bridge from retained recordings to exact model execution and replay" [Code-verified, High] — the closest thing to an executable demo, and notably it operates on *retained recordings*, not live cameras, consistent with the tier-0/tier-4-first device posture.

**Machine-readable governance mass:** alongside the prose docs sit `registries/` (284 KB: agent contracts, capabilities, effects, device adapters, digest domains), `schemas/` (492 KB: versioned JSON schemas including operation/provider receipts), and `architecture/` (432 KB: the import ledger, dependency allowlist) [Counted, High]. And the comprehensive plan carries its own claim taxonomy that mirrors this packet's evidence tiers: every statement is meant to be labeled **FACT** (established by a checked source), **DESIGN** (proposed normative choice), **HYPOTHESIS** (requires measurement), **TARGET** (acceptance objective, not a current result), or **OPEN** (unresolved, with an owner and decision gate) — with the explicit rule that "unlabeled normative prose specifies desired behavior; it does not claim current implementation" [Maintainer claim, High]. A requirement counts as "implemented" only when seven criteria hold jointly — typed contract, explicit authority/inputs/outputs/failure semantics, compatibility behavior, deterministic reference tests, adversarial/fault tests, retained reproducible acceptance evidence, and documentation/schemas/registries/status/implementation in agreement [Maintainer claim, High]. This is the "truth hierarchy" (AGENTS.md: machine registries > plan > tests > implementation > prose) made concrete — and it is why the packet treats the registry layer and the plan's taxonomy as first-class artifacts, not documentation. The methodology-export lens (§6) starts here.

**The asupersync question (Rulebook §6, answered):** asupersync is **evaluated-and-adopted-as-doctrine, not integrated**. It appears in the README badge ("runtime-Asupersync"), the workspace metadata (`sole_async_runtime = "asupersync"`), the dependency constitution (Class F1, admission gate `INT-AS-001`), and 4 rows of the import ledger (mode "direct dependency", status "censused", asOf 2026-08-31) — but in zero manifests, zero lockfile entries, and zero lines of code [Code-verified, High]. Precision on the ledger: several of its `owner` fields (e.g., `fss-transfer`) name crates that do not exist in the workspace, which bounds the "direct dependency" reading — the ledger is fairly read as a *target-state design census* of sibling mechanisms, honestly dated, not as a build-graph description. The executed code is synchronous and single-threaded. The drift that matters is the badge's present tense against the build graph. This remains the single largest README-vs-code gap in the repo [Inference, High].

**Test posture:** 5,379 `#[test]` attributes in 436 files [Counted, High] — unit, integration, adversarial, durability, replay, effect-fault, situation-projection, meaningful-delta, continuation, compression, and hydration tests per IMPLEMENTATION_STATUS.md [Maintainer claim, Medium]. Greenness: unestablished everywhere (see claims 6–7).

## 4.5 The maintainer's stated case

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

1. **Evidence-native substrate:** four type-distinct planes (packet, authority, cognition, effect); one ordered `EvidenceDeltaBatch` version universe with exact high-water marks; semantic MVCC with positive/negative witnesses. The claim is that this substrate is what makes agent operation *safe*, not just possible [Maintainer claim, Medium].
2. **Agent cognitive operating system:** the agent receives an anchor-pinned `SituationCapsule` (SituationFrame, WorldEnvelope, MeaningfulDelta, ContextPack + SemanticCompressionReceipt, categorized affordance frontier) instead of subsystem replies; no mission-critical fact may live only in conversational context [Maintainer claim, Medium].
3. **Pure-Rust production:** packet protocols, codecs, containers, model execution, graph algorithms, archive protocols, and orchestration in first-party safe Rust; FFmpeg/PyTorch/ONNX/NetworkX/C SQLite/Tantivy/browsers/vendor apps are "pinned laboratory oracles only" [Maintainer claim, Medium — verified as *intent*; the zero-dependency lockfile corroborates the current extent, Code-verified, High].
4. **Proof-carrying operations:** child-first/root-last publication; prepare → revalidate → commit → observe → verify for effects; repair as doctor → sealed plan → apply; claims derive from retained proof roots [Maintainer claim, Medium].
5. **Local release authority:** Doodlestein Self-Releaser (DSR) executes clean-snapshot qualification on controlled local machines; GitHub workflows are portable specifications, not a trust root [Maintainer claim, Medium — the thesis is documented at length; no DSR receipt is published in the repo, Code-verified, High].

**The conformance case (the maintainer's own):** the comprehensive plan defines "implemented" as a seven-way conjunction — stable typed contract; explicit authority, inputs, outputs, success, failure, cancellation, and indeterminacy; explicit compatibility/migration behavior; deterministic reference tests; adversarial/fault tests; retained reproducible acceptance evidence; and documentation, schemas, registries, status, and implementation in agreement — under a FACT/DESIGN/HYPOTHESIS/TARGET/OPEN labeling discipline where unlabeled prose "does not claim current implementation" [Maintainer claim, High]. By the maintainer's own definition, most of FSS is therefore DESIGN and TARGET, not FACT — the packet's claim inventory is, in effect, the plan's taxonomy applied back to the repo. This is the strongest version of the maintainer's case: not that the system works, but that the project knows exactly what "working" would have to mean [Inference, High].

**Benchmark and conformance audit:**

| Source | Numbers | Methodology doc | Verdict |
|---|---|---|---|
| Maintainer | none | `docs/PERF_LEDGER.md` (states "No runtime exists yet, so this ledger contains no performance wins"); `docs/PERFORMANCE_AND_MECHANICAL_SYMPATHY.md` (normative doctrine, no measurements) | **No numbers to gate.** The ledger's schema for future entries (commit, device/model/platform generations, corpus digest, distributions, variance, retained artifacts) is stricter than most projects' actual practice — as a *template* it is exemplary [Maintainer claim, High on the text] |
| Independent | none | n/a | No independent coverage found [External, High within recall caveats] |

**Reproduction cost:** the checkout at the pin plus the pinned `nightly-2026-08-31` toolchain (`rust-toolchain.toml`) and whatever self-hosted hardware the maintainer's DSR lanes assume; `scripts/qualify.sh` is the entrypoint [Code-verified, High]. The honest statement: reproduction of the *test suite* is cheap in principle (cargo test on a pinned nightly); reproduction of any *system* claim is impossible in principle — there is no system to run yet, only a reference [Inference, High].

**The disavowal pattern:** unlike FrankenRedis's benchmark disavowal, FSS disavows *existence*: the README IMPORTANT box, the PERF_LEDGER's first line, the pin commit's NOT RUN trailer, the "A passing skeleton build does **not** qualify any camera, codec, model, graph algorithm, archive provider, or alert path" line, and the qualification docs' "hosted runs are supplementary" stance form a coherent honesty protocol — every layer states what it has not earned [Inference, High]. The negative-evidence ledger (claim 16) extends the pattern to hypotheses: its schema demands revival conditions, and its honest "no implementation experiments have been run" bounds what the three entries are. The packet credits this while noting it is not a substitute for the missing verification (§4.7.3).

**The quality doctrine (the maintainer's most load-bearing future claim):** "Never miss a true intruder" is called "the right motivating aspiration and the wrong unqualified claim," and is converted into event-level AUPRC over a declared threat distribution, recall lower bounds at a declared false-alerts-per-property-day budget, time-to-detect/deliver distributions, calibration and selective-risk curves, slices for darkness/occlusion/crawling/dark clothing/weather/wildlife/residents/delivery workers/children/tampering, explicit `not_observable` accounting, property-separated held-out evaluation, and retained misses/near-misses/false-alarms/contradictions — with the rule that "a missing or degraded sensor is not a negative observation" [Maintainer claim, High]. No threat distribution, budget, or measurement exists yet — the doctrine is TARGET, not FACT, in the plan's own taxonomy — but as a *specification of what would count as good*, it is the most serious quality bar in the lane [Inference, High].

## 4.6 Competitors

The incumbent wins on cameras, users, and ecosystems; FSS's only uncontested edge is its epistemic apparatus (provenance, coverage witnesses, abstention discipline, proof-carrying operations) — which no competitor bothers with because no buyer currently pays for it [Inference, Medium].

- **Frigate (MIT, Blake Blackshear):** the lane owner. An independent NVR comparison describes it as "the most popular self-hosted NVR for homelab and Home Assistant users, with mature hardware-accelerated detection (Coral, OpenVINO, TensorRT, Hailo)" and notes recently expanded AI capabilities — face recognition, license-plate recognition, CLIP semantic search, GenAI descriptions — landing in-tree under MIT [External, Medium — the comparison is a third-party homelab project (open-nvr), not a neutral benchmark]. Owns the "local AI NVR" lane by every observable measure: working software, community, integrations, hardware-acceleration story [Inference, Medium].
- **ZoneMinder (GPLv2):** "the twenty-year-old legacy choice — broad camera compatibility, deeply documented… designed before the modern AI-surveillance era" [External, Medium — same comparison]. Owns the commodity "it just records" floor [Inference, Medium].
- **Shinobi (Node.js; GPLv3/AGPLv3 community + commercial Pro):** "the prosumer-SMB option with a polished UI, narrower plugin AI surface, and a dual-licence model" [External, Medium — same comparison]. The developer-friendly alternative lane [Inference, Low].
- **Viseron:** "the closest architectural peer — a small Python-native NVR with a clean detector abstraction, MIT-licensed, Home-Assistant-aligned" [External, Medium — same comparison]. Relevant as the nearest *architectural* neighbor to FSS's ambitions, and it already runs [Inference, Medium].
- **Commercial cloud (Verkada et al.):** "proprietary, SaaS, vendor-managed AI, no operator-side infrastructure" [External, Medium — same comparison]. The actual mass market — convenience over locality; FSS's local-first thesis is a bet *against* this default [Inference, Medium].
- **Unoccupied lane:** a memory-safe, provenance-attested, abstention-aware *agent substrate* for physical sensors — deterministic replay, coverage witnesses, semantic versioning of beliefs, proof-carrying effects — has no direct occupant. The demand-signal asymmetry is stark: Frigate is shipping face recognition, license-plate recognition, CLIP semantic search, and GenAI descriptions in-tree under MIT [External, Medium], while FSS's model story stops at uncalibrated tensors and detector proposals that the code itself says carry no authority [Code-verified, High]. Frigate detects objects; nothing in the lane certifies what the system *doesn't* know. Whether any buyer (or agent framework) will pay for epistemology over detection accuracy is the unproven bet the whole project rests on [Inference, Medium].

## 4.7 Skeptic's take

Weaknesses, ordered by lethality (each is substantive — capable of killing the project on its own):

1. **[FATAL] There is no system, only a reference to a system.** At the pin, nothing acquires a real camera feed end-to-end in a qualified run: the native HTTP acquisition client and recording composition landed hours before assessment with compilation and tests explicitly not run; the MJPEG codec has no qualified decode demonstration; model graphs execute only as reference code over retained/virtual inputs, and their outputs stop at uncalibrated tensors and detector proposals that the code itself says carry no authority (see §4.4); no alert has ever been delivered. The README says so itself [Maintainer claim, High]. A 437k-line codebase whose own documentation's first substantive sentence is a disclaimer is an architecture corpus with a test suite, not a surveillance system [Inference, High — built from Counted/Code-verified facts].
2. **[FATAL] The declared runtime is a fiction in the build graph.** Asupersync — "the sole runtime," badged, constitutionally mandated (Class F1, admission gate INT-AS-001), ledgered as "direct dependency" — is absent from every manifest and the lockfile, and the tree contains zero `async fn` [Code-verified, High]. Either the entire async orchestration story is unbuilt (likely) or the ledger is fiction (worse). For a project whose pitch includes "structured concurrency, region ownership, request→drain→finalize cancellation," having none of it in the tree is not a gap — it is a missing foundation [Inference, High].
3. **[HIGH] The qualification vacuum.** 25 of the last 40 commits (~63%) admit tests were not run [Git-observed, High]; the pin's headline feature was merged uncompiled; across all 622 recorded CI runs the current qualification workflow has zero successes (570 cancelled, 47 failed; the 4 successes belong to retired snapshot workflows), with the pin's run `queued` against self-hosted runners that may not exist [CI-observed, High]; zero GitHub Releases; no DSR receipt is published in the repo despite the "release-local DSR authority" badge [Code-verified, High]. The honesty protocol documents the vacuum precisely — but a documented vacuum is still a vacuum. 5,379 tests of unknown greenness are 5,379 unfalsified assertions [Inference, High].
4. **[HIGH] Bus factor 1 with no artifact to fork.** One human author, no second committer, no foundation, no release artifact — if the maintainer stops, the project freezes mid-sprint with no qualified cut for anyone to continue from [Inference, High]. The bead tracker (1,581 issues: 1,262 open, 300 closed, 16 in progress [Counted, High]) records intent, not continuity.
5. **[MEDIUM] The license rider sabotages the agent thesis.** The project's stated consumer is the coming agent ecosystem; the rider bars OpenAI and Anthropic — the two labs whose models would most plausibly operate the "agent cognitive operating system" — from *using, benchmarking, testing, analyzing, or indexing* the code [Code-verified (license text), High]. An agent substrate that the leading agent builders may not analyze is a contradiction in terms, and the "acting for the benefit of" prong chills contributors across the AI supply chain [Inference, Medium].
6. **[MEDIUM] Documentation mass exceeds implementation mass in the dimensions that matter.** 133 docs files (1.9 MB), registries, schemas, and 14 sibling deep-dives describe 83 named target crates/families; 13 exist — a ≈6.4:1 promised-to-built ratio [Counted, High]. Design-ahead-of-proof is a legitimate strategy, but most architecture prose has no code to be wrong about yet — it is unfalsifiable by construction [Inference, Medium].
7. **[MEDIUM] Drift is structural, not incidental.** The README's IMPORTANT box ("does not yet acquire camera feeds, decode video…") is contradicted by the pin's HTTP-recording commit; the README's own "Current status" section says GATE-000 "architecture constitution" with a "Not implemented now" list (codecs, containers, model inference, detection/tracking, agent/CLI layer) that the tree's reference implementations have outgrown — while IMPLEMENTATION_STATUS.md (2026-09-03) says the repo is "no longer merely an architecture corpus or crate skeleton" [all Code-verified, High]. The packet keeps the nuance: GATE-000 applies the plan's strict 7-criteria "implemented" bar (nothing qualified = nothing implemented), so the tension is partly terminological — but the status section is also factually stale (counts twelve deep dives; the tree has fourteen). Each instance is honestly dated — which is why the packet can see them — but a project whose pitch is *version-universe coherence* cannot keep its own headline documents coherent across a three-week sprint [Inference, Medium].
8. **[MEDIUM] The dual-use surface is real and the governance is one person.** This is surveillance infrastructure: multi-camera tracking, person trajectories, zones, alerting [Code-verified, High — the pin-window commits name RGB neural trajectories, zones, global track assignment]. The owner-authorized framing is explicit: the README's non-goals list disavows "a way to access devices, accounts, or footage without the owner's authorization," "a credential-bypass, exploit-distribution, or covert-monitoring toolkit," "a public face-recognition or cross-property identity network," and "an autonomous armed, confrontational, pursuit, or drone-flight system" [Maintainer claim, High], and the AGENTS.md security boundary is genuinely restrictive (no credential bypass, no broad scanning, owner devices only) [Code-verified, High]. But the privacy/threat posture ultimately rests on one maintainer's judgment, and the rider's exclusions do nothing about misuse by *permitted* parties. The packet notes this as a governance ceiling, not a moral verdict [Inference, Medium].

**Bear-case steelman (strongest counter-case):** Franken Surveillance System is a 437,000-line design document that compiles (maybe — the pin's feature was merged uncompiled) into a test suite nobody has watched go green, describing an 83-crate agent-operated surveillance fabric whose async runtime doesn't exist in its own dependency tree, whose CI has never completed, whose README disclaims the product, and whose license forbids the AI labs most likely to build the agent layer from even reading it. Meanwhile Frigate — MIT-licensed, working, accelerated, integrated — already owns the lane with real cameras and real users. The rational market response is to read the docs for the epistemic patterns (coverage witnesses, proof-carrying operations, silence certificates, the NOT-RUN honesty norm) and never run the code. Its most likely end state is abandonment at the maintainer's next context switch, leaving the most elaborately specified unexecuted surveillance architecture on GitHub. [Inference, Medium — deliberately uncharitable; the counter-evidence is the reference implementation's genuine depth (zero-dep MJPEG, 5,379 tests, the ledger discipline) and the repair velocity of the September sprint — though velocity without verification is motion, not progress.]

## 4.8 Maintenance & succession

**Bus factor: 1.** One human maintainer (Jeffrey Emanuel); all sampled commits in the 60-commit window are authored by Dicklesworthstone/Jeffrey Emanuel [Git-observed, High]. One agent co-authorship trailer found in the window (Grok <noreply@x.ai>) [Git-observed, Medium — trailer conventions may undercount agent involvement]. No succession plan, no second committer, no foundation, no release artifact to fork from cleanly [Inference, Medium — absence of evidence across the assessed materials].

**Contribution & work tracking:** `CONTRIBUTING.md` exists; the bead tracker (`.beads/issues.jsonl`) holds 1,581 issue units — 1,262 open, 300 closed, 16 in progress, 2 blocked, 1 tombstoned — the work ledger is real and machine-readable [Counted, High]. Commit velocity is extreme (~20 commits across two days at the pin window) with the honesty-norm trailers [Git-observed, High].

**License and governance (material):** `LICENSE` reads "MIT License (with OpenAI/Anthropic Rider)" [Code-verified, High]. The rider's scope, quoted exactly:

> "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. … For purposes of this rider, '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." (emphasis added)

> "Any breach of this rider automatically and immediately terminates the permissions granted by this License."

**OSI status: non-OSI** — the rider discriminates against named persons/groups (violating OSD §5) and against fields of endeavor (benchmarking/analysis/training prohibitions, violating OSD §6) [Inference, High — the classification follows directly from the quoted text]. The README badge advertises "License: MIT+OpenAI/Anthropic Rider" — the rider is disclosed, not hidden [Code-verified, High].

**The license as strategy (Rulebook §6):** the rider excludes exactly the two AI labs (plus affiliates and anyone acting for them) whose models are the most plausible operators of the "agent cognitive operating system" the project is built for. As strategy it reads as defensive (preventing training-data incorporation of a clean-room codebase) — but it sabotages the stated mission: an agent substrate the leading agent builders may not analyze, benchmark, or deploy has no path to its own thesis. The exclusion serves the *author's* interest (control) at the direct expense of the *mission's* interest (adoption by the agent ecosystem) [Inference, Medium].

## 4.9 NODUS factsheet

| Criterion | Score | Justification (one line) |
|---|---|---|
| Technology readiness | TRL 3 | Analytical/experimental: large deterministic reference implementation exists, but no operational-environment (real camera, qualified run) demonstration at the pin [Inference, Medium] |
| Strategic relevance | 3/5 | Provenance-attested, agent-legible sensing is strategically interesting for the agent era; today it has no buyer [Inference, Medium] |
| Impact potential | 3/5 | If the epistemic substrate works, it reframes how agents consume physical sensors; the methodology-export value is real even if the product fails [Inference, Medium] |
| Implementation feasibility | 2/5 | Zero-dep, unsafe-free discipline is proven in-tree; but the async runtime, most device adapters, and ~70 of 83 named crates are unbuilt, and qualification is undemonstrated [Inference, Medium] |
| Time to mainstream | 2/5 | Pre-product with no release artifact; the lane is occupied by working incumbents — mainstream is a multi-year proposition at best [Inference, Medium] |
| Collaboration potential | 2/5 | Bus factor 1, extreme velocity, honest docs — but the rider bars the most relevant collaborators and there is no release to build against [Inference, Medium] |

**Ring: Explore** [Inference, Medium]. Substantive-but-unproven is the textbook Explore case per the Rulebook's assignment rules: the reference implementation is large, internally coherent, and unusually honest, but nothing is independently validated and no release artifact exists. TRL 3 vs 4 was considered — the loopback/filesystem contracts are lab-like (arguing 4), but they were never executed (arguing 3); unexecuted lab work does not clear the lab-validation bar, so 3. The rider is an advancement blocker (Explore-with-a-ceiling), not a ring qualifier — even a fully qualified FSS could not advance while the named-party exclusion stands. Ring down, not up: Monitor was considered (the docs have a plan-stage flavor), but 437k lines of unsafe-free reference code with 5,379 tests is substantive, not plan-stage.

## 4.10 Wardley placement

- **Commodity/product surface:** NVR recording, MJPEG decode, HTTP camera ingestion, alert webhooks — solved problems; Frigate/ZoneMinder own them. FSS re-derives them (necessarily, for the zero-dep bet) but they are not the point [Inference, Medium]. *Users here:* homelab owners who want a working camera today — they buy Frigate, not FSS.
- **Custom-built:** the evidence-native substrate — `EvidenceDeltaBatch` universe, child-first/root-last publication, content-addressed object graphs, deterministic virtual acquisition/replay. Built, unproven in operation; would move toward product with a qualified real-camera loop [Inference, Medium]. *Users here:* the rare operator who needs court-grade provenance more than they need a working UI — almost nobody yet.
- **Genesis:** the agent cognitive operating membrane — `SituationCapsule`, `WorldEnvelope` with protected high-loss possible worlds, nondominated affordance frontiers, proof-bearing semantic compression, coverage-witnessed negative reads. No occupant in the surveillance lane; would move toward custom if an agent framework adopted the envelope contracts [Inference, Medium]. *Users here:* future agent frameworks operating physical sensors — a user class that barely exists.

## 4.11 Trajectory (12 / 24 / 60 months)

**[Inference — all of this section is analyst judgment, Low to Medium confidence.]**

**Base case:** the sprint continues, the reference implementation accretes toward the 83-crate target, and the repo remains a pre-product architecture corpus with an ever-more-honest ledger of its own incompleteness. Without a qualification event (a green test run anyone can see, a DSR receipt, a real camera loop), external adoption stays at zero and the project becomes a methodology mine for the FrankenSuite rather than a system.

**Bifurcation — upside:** a published DSR receipt plus a qualified real-camera demonstration (even one HTTP camera, 24 hours, with the coverage-witnessed event log to show for it) would move FSS from "honest corpus" to "the only provenance-native NVR" — a genuine differentiator against Frigate in the agent-builder niche. Admission of asupersync into the actual build graph would close the largest drift. A second maintainer or a permitted-party independent review would crack the bus-factor/rider ceiling.

**Bifurcation — decay:** velocity without verification compounds: each uncompiled commit raises the cost of the first real qualification run, the bead backlog (1,262 open) grows faster than it closes, the docs drift further from the code, and the maintainer's context switches to the next FrankenSuite repo — freezing FSS mid-sprint with no qualified cut.

**Revisit triggers (concrete, observable):** (1) first published DSR/local-qualification receipt naming the pin and toolchain; (2) a CI run concluding `success` (hosted or self-hosted) with public logs; (3) asupersync appearing in `Cargo.lock`; (4) a qualified real-camera recording run with retained evidence; (5) a second human committer; (6) an independent (permitted-party) deployment or review. Any one of these would change the ring assessment.

## 4.12 Limitations and open questions

**Not done:** the workspace was never compiled; no test was executed; no benchmark was reproduced (none exist); no camera hardware, drone, or accelerator was touched; the history sample was 60 commits (shallow + deepen), not full history; the 133-doc corpus was sampled by index and key files, not read exhaustively; no contact with the maintainer; no license-lawyer review of the rider (the non-OSI classification is the analyst's reading of the quoted text against OSD §§5–6).

**Open questions that would most change the verdict:**
1. Do the 5,379 tests pass on the pinned nightly? (Cheapest falsifier; see §8.)
2. Is there a self-hosted runner behind the `queued` CI jobs, and has any DSR receipt ever been produced?
3. What is the actual plan and timeline for asupersync admission (gate INT-AS-001)?
4. Which single real-camera demonstration is the maintainer targeting first, and what would qualify it?
5. Has any permitted party evaluated the code under the rider, and what did they conclude?

---

## The eight deepening questions

**1. Provenance.** The system records content digests, root-closed manifests, immutable sensor capsules with capture-time uncertainty intervals, ordered `EvidenceDeltaBatch` history with `LedgerAnchor` succession, and model/calibration/policy generations on every derived artifact — provenance is the product, not a feature [Code-verified, High on the contracts' existence as code]. Making it portable would require exactly what the architecture already sketches: content-addressed, self-describing evidence bundles moved by ATP — the immutable object-graph transfer (manifest/chunk/repair, root-last commit) the architecture ascribes to asupersync's doctrine (doctrinal only at the pin: absent from manifests, lockfile, and code; the docs never expand the acronym, so the packet defines it functionally [Code-verified, Medium]) — whose soundness would depend only on the digest algorithm and schema registry, not on FSS itself. The missing piece is a published, versioned bundle format with a second implementation [Inference, Medium].

**2. The embeddable unit.** The smallest useful piece is `fss-packet` (packet truth: exact bytes, sequence, time/continuity evidence, 12,563 lines [Counted, High]) or `fss-container` (1,736 lines) — both small, dependency-free, and carrying no agent-membrane concepts. Adoption cost is near-zero technically (add one path dependency; no async runtime, no unsafe, no build scripts) and high socially (the rider travels with the code, and there is no release to depend on — only git pins) [Inference, Medium].

**3. Unexercised option value.** The architecture holds three large unexercised options: the asupersync admission (structured concurrency, region ownership, cancellation — all specified in the dependency constitution, none built [Code-verified, High]); the WASM/sandboxed-model story (the frozen operator IR and bounded execution plans in `fss-model-ir` are designed for isolated execution; the pin-window commit on bounded deep-graph execution is preparation, not delivery [Code-verified, Medium]); and the evidence machinery itself as an export (the ledger, coverage witnesses, and proof-bundle conventions port to any agent system [Inference, Medium]). What unlocks them is the same event: a first qualified release that forces the specified-but-unbuilt to become specified-and-built [Inference, Medium].

**4. Benchmark honesty.** There are no benchmark numbers, so there is nothing to launder — the PERF_LEDGER's "No runtime exists yet, so this ledger contains no performance wins" is the strongest benchmark-honesty statement in the FrankenSuite precisely because it refuses the category [Maintainer claim, High]. The load-bearing thesis numbers do not exist yet; when they do, the ledger's entry schema (commit, device generations, corpus digest, distributions, variance, retained artifacts) is the gate they must pass [Inference, High].

**5. The governance path.** The credible route is: publish the first DSR receipt → cut the first signed release → admit asupersync for real → land one qualified camera integration → attract a second maintainer from the permitted-party pool [Inference, Medium]. What breaks first if velocity decays is the docs-code coherence the project already struggles with: at 1,262 open beads and 19-day doc staleness *during* a sprint, a slowdown freezes the drift in place rather than healing it [Inference, Medium].

**6. The license as strategy.** The rider excludes OpenAI, Anthropic, their affiliates, and anyone acting for their benefit — from use, benchmarking, testing, analyzing, and indexing, with automatic termination on breach [Code-verified (license text), High]. It serves the author's control interest (no training-data incorporation, no lab benchmarking on his terms) and sabotages the mission interest: the "agent cognitive operating system" is built for operators who are forbidden from touching it. For a surveillance project, the rider also fails as a safety instrument — it constrains *who may analyze*, not *how the system may be used* by permitted parties [Inference, Medium].

**7. Agent-era fit.** The concrete workload is an agent operating a heterogeneous owner-camera fleet under uncertainty: "which camera should I ask for a view from, what don't I know, what would change my decision, and what is the cheapest safe next action" — the SituationCapsule/affordance-frontier machinery answers exactly this, and no incumbent NVR offers it [Inference, Medium]. What must become true first: a qualified real-sensor loop (the membrane currently wraps virtual acquisition [Code-verified, High]), a release artifact an agent framework can depend on, and license terms the agent builders can accept — all three are missing at the pin [Inference, High on the conjunction].

**8. The kill test.** Execute the test suite on the pinned nightly and publish the result: if a large fraction of the 5,379 tests fail — or if the tree does not compile at the pin — the "deterministic reference implementation" claim, the load-bearing premise of the entire architecture corpus, is falsified in one run. Conversely, a green run would be the single strongest validation event available to the project. A competitor move that kills the thesis differently: Frigate (or Viseron) shipping provenance-attested, coverage-witnessed event logs would occupy the one unoccupied lane without the 83-crate rebuild [Inference, Medium].

---

*Assessment date 2026-09-22. All "verified resolving" link checks and counts were performed on 2026-09-22 against the pinned commit. The runtime never compiled the tree; every behavioral claim about the code is a claim about the source as read, not as executed.*