Redesign: continuous discovery / dynamic transfer / per-connection governance

P2P Downloader v2.3: core architecture and connection governance

Keep source information flowing to every valid target; run a trial when evidence is available, and retain it in the pool when it delivers value. The download count is not a fixed cap, and idle connections are not an achievement.

New Connection ManagerSQLite stores facts and evidence122 Tracker + 12 eD2k candidatesUntested endpoint ≠ safe endpoint

Substantive changes in this revision: Independent discovery and transfer loops, elastic trial/active pools, PoolSupervisor, connection analysis, and revocable policies. Retains split Config files, React source tabs, incremental files/hash bucketing, and the dead-file journal; adds no VPN, login, or User system.

Article contents

Search article sections

Date: 2026-10-03. This is a design specification, not a deployed product or one that has passed live-network acceptance. This revision fully redesigns discovery and transfer in Scheduler/Component, adds connection governance, and provides traceable tracker/eD2k default sources. Latencies, ratios, and capacities in these files are adjustable initial policies, not measured optimal values.

Markdown, JSON Schema, SQL, and TOML are implementation contracts; HTML is a review view of the same content. reference/model.py It is only an executable offline decision reference, not a P2P Engine. It does not modify the original repository, open peer connections, send announces, measure network speed, or delete data.

01 | What changes in this revision

The previous version kept most jobs in Store and admitted only a small number for discovery. This version immediately adds every valid target to the discovery and analysis working set. Source information flows back continuously; whichever target is ready enters trial first. The active download pool is sized by sustainable resource headroom. Do not wait until all 1,000 probes finish, and do not let a fixed 5, 8, or 32 transfer slots prevent the remaining targets from obtaining source information.

Decision	v2.3 requirement
Discovery eligibility	All valid targets may participate simultaneously, independently of transfer-pool capacity. Importing 1,000 at once does not create 1,000 Engines or pre-create payload files.
Half-connection	Interpret the user's intent as short-lived source probing: after the protocol handshake/necessary metadata completes, save the evidence and release connections that can be released. Do not deliberately leave TCP SYN connections half-open.
Connection concurrency	Remove the fixed task-count cap; `connection_window=auto`. FD, memory, system pressure, and remote protocol rate limits still create dynamic backpressure; sockets cannot truly be unlimited.
Trial and active transfer	Both are elastic resource sets, not fixed numbers of slots. Useful data, stability, and cost determine promotion and demotion.
Dedicated supervision	Scheduler contains a `PoolSupervisor`, which continuously observes downloads, rotations, and the observation area; connection governance is separately handled by `P2P Connection Manager` .
Blocking	Separate narrowly scoped disconnects, temporary avoidance, revocable quarantine, and manual persistent blocks. Zero traffic or country alone cannot establish malicious intent.
Default sources	Include traceable candidates and an update policy. Candidates may be validated first; that does not mean all endpoints are used simultaneously or confirmed safe.

This revision replaces v2.2's fixed probe/transfer slots, dominance by a single scheduling score, and conclusion that no new connection component is needed. Retained Split Config files, source tabs, Component.Downloader + Engine, SQLite-backed Store, centralized Metrics storage, incremental writes, hash bucketing, completed-file moves, and dead-file cleanup. VPN Manager and product User/login systems remain outside this core scope.

02 | Overview: nine logical components, not nine microservices

Design illustration, not a running system view. Scroll horizontally within the diagram in narrow windows.

A ninth logical component is recommended: P2P Connection Manager. Previously, Scheduler only needed resource summaries. Now it must also track individual connections across Components, analyze evidence, avoid false blocks, execute disconnects, and review policies. This responsibility has its own state and contracts; it should neither be buried in Metrics nor require Scheduler to operate protocol sockets directly.

Component	Owned decisions and state	Boundary
P2P Web View	Download pool, source tabs, connection table, evidence details, and operation status	React + Vite + Tailwind, Traditional Chinese, dark-only; no direct Engine connection.
P2P Manager	API, Component Registry, entry points for intents, Operations, and domain events	Does not replace Scheduler's scheduling or Connection Manager's maliciousness judgments.
P2P Config	Split-file defaults, source feeds, schema, effective snapshots, configuration versions	Remote candidate lists cannot change configuration directly; Components read the same snapshot version.
P2P Search	Keyword search, exact resolve, per-source discovery scheduling	Continuously supplies sources for every registered target; does not own trial or active transfer.
P2P Scheduler	Trials, active pool, observation area, resource optimization, and fair rotation	Owns a Task's download intent, not wire/piece operations; receives availability and cost summaries from Connection Manager.
P2P Component	Protocol adaptation and execution capabilities	Contains Search Provider, Downloader, Engine, Connection Agent, Resource Reporter, and Metrics Publisher; not one process per Task.
P2P Store	SQLite tasks, content identities, snapshots, policy evidence, command and file journals	A single write owner; stores neither every peer's per-second time series nor payloads.
P2P Metrics	All observation samples, time series, distributions, monitoring retention	Components only push; they do not write to the monitoring DB or monitoring disk spool. Metrics failure does not mean download failure.
P2P Connection Manager	Connection index, service eligibility, anomaly evidence, source avoidance, and blocking decisions	Adds no firewall or VPN; only Connection Agent can execute concrete actions inside Engine.

For the first version, a single Rust p2pd containing control/analysis modules is recommended, with multiple Component hosts arranged according to native engine processes. Connection Manager is a logically independent, testable module; split it into a process only if CPU/latency measurements justify it.

03 | 1,000 at once: two paths running together

Design illustration, not a running system view. Scroll horizontally within the diagram in narrow windows.

Path A runs continuously: Batch validation and deduplication → register all valid targets → Store history/metadata → shared source queries → lightweight handshake/available ranges → save SourceSnapshot → release temporary connections → update candidate ranking.

Path B does not wait for all of A to finish: Targets with fresh evidence → trial set → active download pool → PoolSupervisor → maintain / expand / rotate / observe → return to trial on expiry or new-source events.

All 1,000 discovery jobs can enter the runnable set at the outset. Asynchronous I/O does not require sockets for 1,000 × all peers to open in the same millisecond. Share tracker transports, eD2k server sessions, Kad routing tables, and identical metadata already being fetched. Coalesce source queries for the same content + realm + configuration version, and reuse results across multiple selected ranges.

Source protocols' reask/announce intervals must be respected. BT tracker responses include the interval before the next normal request; choked also means the remote side is not currently sending data. These are normal protocol semantics, not intervals Scheduler may arbitrarily shorten. S2

There is no whole-batch barrier. If target 900 replies first, it enters the rankable set first; a timeout on target 1 does not block others. Reject only the item with invalid input. Every successfully persisted item must have its own task_id, result, and recoverable import operation.

04 | A precise implementation of unlimited half-connections

libtorrent calls connecting half-open; handshake is an established connection waiting for the protocol handshake. Obtaining peer bitfields/queue information usually requires more than a TCP connect. S5

This specification uses probe_session for short-lived probes, avoiding the mistaken description of information gathering as TCP half-open. UDP trackers/DHT may not have a dedicated TCP connection; the connection table must distinguish logical sessions from actual socket counts.

ProbeGovernor builds elastic windows solely from cost, without a fixed max_probing_tasks=32:

window_headroom [count] = floor(min(FD headroom, available memory / p95 bytes per probe) × pressure reduction factor)
new_dials_this_tick [count] = min(window_headroom, global dial tokens available this tick, per-source tokens)
tokens_added [count] = adaptive_rate [attempts/second] × elapsed [seconds]

The window limits simultaneous live probes, while the token bucket limits new attempts per second; multiplying them would be a unit error. FD headroom subtracts current usage and control-channel reserves; count each physical transport once. NAT state, ephemeral port exhaustion, event-loop lag, and surges in DNS/dial timeouts must feed back to Governor. If NAT state is unobservable, do not claim to know its capacity; use failure rates and conservative growth instead. Completed probes immediately return resources and have explicit termination deadlines to prevent half-open connections from exhausting FDs.

When releasing a connection, save: target content and selection digest, source endpoint/identity strength, advertised coverage, service/queue status, TTFB or its absence, report sequence, observation time, expiry time, and error classification. Speed can only be measured by payload trials; a fast handshake does not imply fast downloads.

Exceptions include shared eD2k server/Hub sessions, DHT that must remain resident, and native protocols where disconnecting loses a valid queue ticket. Release only task-local probing resources; a disconnect-after-probe rule must not break source discovery for an entire Component. Track ticket-maintenance costs separately and never silently start unbudgeted transfers.

05 | State model: separate jobs, connections, and source quality

Design illustration, not a running system view. Scroll horizontally within the diagram in narrow windows.

Task main phase	Entry condition	Exit condition
`collecting` Collecting	Valid intent submitted	Sufficient fresh source evidence allows `rank_ready`; unfinished targets do not affect it.
`rank_ready` Awaiting trial	Content/service path is discoverable; trial is allowed	Receive elastic trial resources; return to collection when evidence expires.
`trial` Trial	Downloader confirms native service startup or bounded waiting	Available and stable → `active`; insufficient samples / remote queue / failure → `observing`.
`active` Active pool	Useful data proven and resources available	On completion, verify; on local pressure, enter `held`; when remote is unavailable, enter `observing`; retain checkpoints during fair rotation.
`observing` Observation area	Currently not worth holding expensive resources for long	Review/retry when new sources arrive, cooldown expires, or a queue ticket becomes serviceable.
`held` Retained	User pause, local disk/engine failure, unknown command outcome	Recovery must match the specific cause; do not record source failure.
`finished` Transfer phase finished	All required data acquired and native verification completed	Moves/sharing are managed separately by placement state.

observing.reason Must be specific: NO_SOURCE, MISSING_SEGMENTS, REMOTE_QUEUE, SERVICE_TIMEOUT, LOW_MARGINAL_YIELD, STALE_EVIDENCE.dead_candidate belongs to the later long-term file lifecycle; it is not a synonym for observation.

Source quality is an orthogonal field: high / available / unknown / incomplete / low; safety evidence is unknown / observed_anomaly / attributed_invalid / manual_deny. The UI can correctly show incomplete · actively downloading · safety unknown; high speed does not clear a safety quarantine.

06 | Source completeness and priorities

Evaluate against the same native content, layout, and selection. The locally verified set V, the missing set M, and the set advertised by fresh sources A_j:

M = selected_units − V
observed_coverage = bytes((V ∪ union(A_j)) ∩ selected_units) / bytes(selected_units)
missing_supply = bytes(union(A_j) ∩ M) / bytes(M)

When no units are missing, enter completion verification and stop searching for seeds. Sources with complementary partial data can still complete the download. If all sources lack the tail pieces, even numerous sources still yield incomplete. Protocols without native bitfields retain unknown; do not prohibit useful downloads because a field is absent.

Priority 0..999, with lower values taking precedence; first pass checks for user intent, policy, deduplication, native retry floors, and resource eligibility. Ranking features include fresh supply coverage, rare-piece value, useful-speed quantiles, stability, TTFB, connection/I/O cost, historical success when eligible to serve, waiting deficits, near-completion benefit, and requeue cost. Do not score speed or safety using country or the numeric magnitude of peer IDs.

Ranking cannot replace service guarantees. Unknown jobs receive a discovery deficit; slow sources holding the only copy of rare pieces receive a rescue budget. Manual weights cannot bypass blocks, full disks, or unknown execution state.

07 | Trial Controller: connecting alone does not earn promotion

Trials fetch only data actually needed, retaining samples for later use rather than downloading junk for speed tests. Initial bytes/time limits are resource windows only; before a verification unit is fully fetched, do not describe verification_pending as a hash failure.

trial time is divided into wall-clock and qualified-service-clock. Remote queues/chokes, local rate limits, disk blockage, and report gaps do not count as time when the peer promised service but failed to send data. Evaluate TTFB, consecutive windows, and unique payload only after native service is obtained.

Requirements for promotion into the active pool: At least three valid observation windows; an actual increase in missing unique bytes; acceptable error/duplicate ratios; no current safety quarantine; and incremental benefit exceeding trial cost relative to the effective capacity of that protocol and host. min_qualified_ms=15000, 5 seconds per window, and CV ≤ 0.75 are starting points for tuning, not universal guarantees of success.

Do not discard large, slow files or long-RTT transfers solely for missing a fixed MiB/s threshold. Slow but stable protocol service may qualify through fair/rescue promotion. Small files completed during trial go straight to verification without forcing three windows. If a verifiable unit exceeds the window, extend the issued byte budget or return to inconclusive; never exceed the budget.

08 | Elastic download pool: task count is an outcome, not a target

Design illustration, not a running system view. Scroll horizontally within the diagram in narrow windows.

PoolSupervisor collects live resource summaries, CapacityController performs global adjustments, and FairRotator chooses specific candidates and yielding tasks. All three are internal Scheduler modules, not another piece scheduler competing with Engine for control.

The goal is to maximize sustainable useful throughput, while retaining headroom for control, verification, disk writes, and interaction. A 94% target is adjustable, not a promise to run network, CPU, and disk all at 100%. One resource will bottleneck first; spare capacity elsewhere is a reasonable result.

Observation	Control action	Prohibited behavior
Five downloads use only half the known bandwidth; I/O and CPU are healthy, with candidates available	First check whether active sources can accept more requests/peers; if insufficient, automatically add trials, with the pool naturally growing after promotion	Stop adding because the maximum is five.
Network has headroom, but disk backlog and write latency keep rising	Reduce new transfer grants, drain low-benefit jobs, and maintain verification and flush	Blame sources for zero speed and blacklist them.
Network approaches its target and backlog is stable	Keep high-benefit incumbents; reserve a small share for discovery and challenger candidates	Disrupt stability to accumulate more connections.
Adding jobs brings no useful-speed improvement while increasing cost	Roll back the latest expansion and use challengers to replace jobs with low marginal benefit	Add indefinitely or pause and restart the entire pool together.
Unknown network capacity	Probe gradually using useful data and cost; show estimated/unknown in the UI	Claim available Internet bandwidth from a 1 Gbit/s NIC.
Stale reports	Stop aggressive expansion, retain native safe resource controls, and resynchronize	Treat missing samples as 0 B/s or idle resources.
No more useful sources	Record `SOURCE_LIMITED`, and maintain observation/retry	Guarantee saturation or send unrelated traffic to fill bandwidth.

net_utilization Use counters from the same bottleneck domain and byte layer; unique_goodput is the benefit after removing duplicate/useless data and cannot share a denominator directly with NIC wire speed. Account separately for downloads, uploads, control/DNS overhead, traffic from other processes, and shared-device I/O.

Each disk/filesystem has its own pressure domain. A slow HDD should constrain only jobs writing to it, without freezing another idle SSD. Linux PSI can signal CPU, memory, and I/O stalls, but does not fully measure network capacity or disk throughput. S14

09 | Control algorithms, oscillation, and fairness

Raw samples are about 1 second apart, decisions about 10 seconds apart. After a change, wait at least 30 seconds or the native startup cost, whichever is longer, before judging success. Fast protection events need not wait. Use robust EWMA/medians over the past 10–30 seconds for throughput, and p95 for latency and memory cost.

If local_pressure >= 1: drain yielding jobs with low marginal benefit and stop aggressive expansion
Else if data is stale or the last expansion has not stabilized: hold
Else if network < 90% of target and local_pressure < 0.70: increase the trial resource budget
Else if additions show no positive marginal benefit for two consecutive windows: roll back / rotate candidates
Else: maintain the active pool, with a small ongoing share for discovery, deficit repayment, and rare-piece rescue

Start with an expansion step estimated at 25% of the currently affordable population, and a reduction step of 15%. Actual admission still checks the resource-vector ledger item by item. Change at most one main factor at a time (task population / per-job peer credit / request window) so bottlenecks remain identifiable. Do not treat ceil(active×1.25) as the permanently correct download count.

Use incumbent/challenger rotation: under equal conditions, the candidate's estimated utility must be at least 15% higher, or its deficit must be due. Typical minimum residence is 120 seconds, with at most about 5% of the population rotated per round. These may be relaxed for Component startup/queue costs; clearly useless behavior, protocol violations, or user cancellation can be handled immediately.

Retain effective service debt: sleeping/rate-limited time is not service. Remote queue tickets do not confer download eligibility but have retention value. Sharing/uploads also consume resources and must enter upload, disk-read, and concurrency ledgers rather than protecting download RX alone.

10 | Connection Manager: explain every connection

Design illustration, not a running system view. Scroll horizontally within the diagram in narrow windows.

Internal modules: ConnectionRegistry → ProtocolStateNormalizer → ServiceEligibility → EvidenceAnalyzer → PolicyResolver → CommandOutbox. Also includes ReputationLedger and expiry reviews. Accept reports only from registered Components/Collectors; peer-claimed statistics are not local measurements.

Field group	Required data	Semantics
Unique identity	connection_id、component_id、run_id、native_connection_key、transport_handle_id	Reconnecting to the same endpoint creates a new connection_id; restarting a process creates a new run_id, preventing late disconnect commands from harming new connections.
Associations	realm、protocol、roles、task_ids、source／tracker／server provenance	One transport may be associated with multiple logical jobs; count its physical FD only once.
Endpoint / identity	IP + port or overlay Destination, peer_id/user_hash, strength of identity proof	BT peer IDs and eD2k user hashes do not automatically establish trusted human/device identities.
Service eligibility conditions	handshake、remote_choked、interest、remote_queue_rank、slot_granted、outstanding requests、recv credit	`can_serve_now` Must follow the native protocol; unknown is not false.
Data quality	payload／unique／duplicate／discarded／verified bytes、hash failure attribution	Keepalive carries bytes but is not file progress; unfinished hash verification is not corrupt data.
Performance	TTFB, request latency p50/p95, RTT method, goodput window, qualified stall duration	Specify each measurement method/window explicitly; do not confuse connect RTT with ongoing RTT.
Local interference	local throttle、disk backlog、hash queue、memory／event loop、report gaps	Used to exclude false judgments; network headroom does not disprove disk congestion.
Geography / network	country、ASN、database version、observation age、unknown reason	Query locally offline; do not send all peer IPs to third parties. Country adds no risk score.

libtorrent peer_info native APIs include pieces, payload speeds, pending disk-write bytes, request timeouts, choke/snubbed status, and more; Whether qBittorrent WebAPI exposes the same details requires separate testing; underlying fields do not prove adapter access. S5

10.1 Connection ID levels must be separated into three dimensions

connection_id is the local tracking key; peer_id／user_hash is the remote protocol identity; High ID／Low ID is eD2k reachability information. These are not the same type of level. Official eMule documentation explains that High ID/Low ID comes from the server's judgment of inbound reachability; a larger ID number does not mean a better level. S18

The design stores reachability_class=direct/callback_needed/unknown, observing server/time, callback results, and native ID type. Sources requiring callbacks may cost more, but cannot be classified as incomplete or malicious on that basis; scheduling depends on whether needed data can actually be obtained. Country/ASN are only for distribution and diagnostics, not country allowlists/denylists or safety percentages.

11 | Zero traffic: count faults only when eligible for service

Classify connection roles first: payload_peer / tracker / ed2k_server / dht_session / hub / metadata / provider / upload_only. Trackers and eD2k servers provide information/indexes, not file payloads; download-traffic thresholds do not apply. Official eMule documentation also defines servers as entry points to file and source indexes. S11

Qualified no-response timer qualified_idle_ms Accumulate only while all of the following hold:

payload role + a range we lack that the peer advertises as available
+ handshake complete + native remote state permits service (not choked/queued)
+ an actual outstanding request has been sent + recv/write credit issued
+ no known local bottleneck + no shared network-domain failure + fresh reports

Reset the timer on each valid unique-progress event; protocol keepalives do not reset it. Do not count wall-clock time while qualified time is paused. Apply bounded cancellation/retry to overdue requests; repeated failures lead to disconnect + temporary avoid, preserving evidence. If no request exists, the peer is legitimately queued, or missing ranges do not intersect, release unused connections at most; do not add maliciousness strikes.

Set the deadline using max(protocol floor, 8×RTT, request size / expected lower-bound rate + margin), then constrain it to an adjustable range. RTT alone cannot judge large requests. The base reference uses 30 seconds as a test threshold; production Engines must use their native request deadlines and be no more aggressive than the protocol permits.

Traffic without progress needs separate classification: duplicate endgame blocks, already-verified ranges, useless messages, buffered but unverified data, or wrong ranges sent by the peer. Small amounts of late unsolicited data for which no local request is outstanding should not always count as attacks; evidence must account for cancellation races and protocol-permitted behavior. S2

12 | A blacklist is not a single permanent IP list

Name	Trigger	Scope / expiry	Recovery
`disconnect` Disconnect this connection	Unused connection / qualified timeout / confirmed malformed data	Exact run + connection, without requiring a permanent penalty	May reconnect based on new evidence.
`avoid` Temporarily avoid	Eligible but returns no useful data; local interference ruled out	Default: realm + content + source; starts at 60 seconds, doubles for independent repeat offenses, up to 1 hour	Permit only one trial at expiry; success clears/decays the penalty.
`quarantine` Quarantine	Attributable corrupt data, protocol violations, malicious metadata behavior	Narrowest provable scope; default 1–24 hours, with evidence retained	Reconcile / retry trial / manually revoke.
`manual_deny` Manual block	Explicitly specified by the user	May be permanent; must show scope and side effects	Manual unblock.

Replaying the same evidence_id must not add another strike. Policies include config_revision, expires, original reason, and actual enforcement; requested, enforced, unsupported, unknown are shown separately. Source A failing to serve file X must not automatically block file Y, other peers behind the same NAT, an entire ASN, or a whole country.

When multiple peers contribute to one corrupt piece, do not label every peer malicious. First isolate the verification unit and local write/RAM faults, then retest with attributable single-source data or use verified native attribution. Native libtorrent also uses a parole mechanism for hash-failure contributors instead of immediately banning all of them permanently. S5

Unblocking cannot be a UI-only change. Revoke the native policy and reconcile it. An adapter supporting only permanent IP bans must not pretend to offer revocable single-connection avoidance.

13 | Capability limits in judging phishing, entrapment, monitoring, and safety

The system can detect observable behavior, not the peer's true intent. It can analyze path traversal, dangerous URLs/control characters, invalid wire lengths, compression bombs, attributable hash failures, discrepancies between source claims and behavior, repeated unusable sources, and metadata asking users to open external pages or enter credentials. The UI renders such content only as plain text and warnings; it never automatically executes it, previews scripts, or opens links.

It cannot guarantee detection of honeypots, copyright monitors, or passive loggers. An endpoint that follows the protocol perfectly and serves correct data may still record your IP, hash, and timestamps. Normal transfers, HTTPS, peer IDs, country, cloud ASN, or listings on many websites do not prove that it is not a trap. surveillance_intent=unknown Do not package this as falsely precise percentage scores.

Keep risk classification separate from performance evaluation: availability_evidence, integrity_evidence, protocol_behavior, provenance_confidence; only concretely verifiable evidence rules may automatically impose narrow restrictions. AI may later help explain or cluster evidence, but LLM speculation alone must never trigger a global ban.

For anomalies such as provider responses injecting internal-network/management ports, floods of broadly similar sources, DNS redirects, or metadata changes, first retain provenance and quarantine the affected candidate/source. A short network outage must not blacklist all sources.

14 | Capability interfaces: precise governance needs more than coarse adapters

ComponentCapabilities Separate reporting from enforcement by version. Required entries: per_connection_identity, service_eligibility, per_peer_piece_map, request_progress, disconnect_connection, avoid_content_source, reversible_ban, metadata_without_payload, retain_queue_without_autostart. Values are native / observed / unsupported, with the tested fixture version attached.

The inspected qBittorrent banPeersAction() parses endpoints and then calls banIP(), so it cannot implement a command that closes only one connection.S6

Backend	Requirements in this version
Custom REMULE	Engine provides per-connection IDs, request/part progress, queues, precise disconnect, content-source avoid, and revocable policies. These must be implemented, not merely shown in the UI.
Stock qBittorrent WebAPI	Keep available torrent/peer summaries; do not enable speculative automatic bans when per-connection service eligibility is unknown. Precise actions return `unsupported_scope`.
qBittorrent full-governance mode	Requires a maintainable Engine bridge, controlled extension, or explicitly reviewed patch connected to underlying connection handles; define separate tasks and acceptance criteria. Do not claim that libtorrent's public API already guarantees all per-connection closing capabilities.
slskd／DC／Kubo／I2P	Retain each one's queue/Hub/provider/Destination; implement only tested capabilities, with null + reason for unavailable fields. Do not force country fields onto overlay identities.

Thus, full-precision automatic connection governance is BLOCKED for adapters lacking the required capabilities, but source discovery, coarse job scheduling, and honest reporting can be implemented first. This is capability tiering, not silently reducing the user's requirements.

15 | Tracker and eD2k: collect broadly, use in tiers

Design illustration, not a running system view. Scroll horizontally within the diagram in narrow windows.

This package includes 122 deduplicated tracker endpoints and 12 current eD2k server candidates. Trackers combine ngosang's 75 entries and XIU2's 122; the former is entirely contained in the latter in this snapshot. Deduplication is at URI level, not proof of 122 independent operators: DNS aliases, shared IPs, or common teams can still overlap.

Source	Retrieved in this revision	Purpose of the default	Safety / integrity limitations
ngosang/trackerslist	Snapshot updated 2026-10-02, 75 entries; original Git blob hash checked	Versioned candidates, conditional daily updates	Maintainer health checks, not certification against maliciousness or monitoring.
XIU2/TrackersListCollection	2026-10-02 README; all.txt has 122 entries, Git blob hash checked	Expand candidates without duplicate injection into Engine	Includes HTTP/HTTPS/UDP/WSS; overlaps with other aggregators.
eMule-Security.org	Official page listed 12 entries at 2026-10-02 16:02 UTC	Include IP + explicitly stated TCP port in candidate defaults	No server connections were made this time; no guessing UDP/obfuscation ports.
newTrackon	Official page and stable-list documentation	Supporting health and uptime reference	`/list` Dynamically loaded; machine API not verified, so none invented `/api/...`.
Historical gruk / peerates lists	Historical official/community records are traceable	Not directly included in enabled defaults	Old URLs, HTTP, and unconfirmed current maintenance status; do not relax validation merely to increase the count.

S7 S8 S9 S10

The latest page has one fewer entry than the previous 13-entry snapshot. sources/ed2k-previous-snapshot.json and catalog/ed2k-source-diff.json retain this difference; removed sources are no longer selected automatically, but delisting alone does not label them malicious.

The HTTPS server.met raw binary was not obtained this time, so the feed is configured but disabled by default; 12 page-derived candidates are available for startup validation. A tool read failure does not prove the HTTPS URL is unusable; automatic fallback to HTTP is prohibited. Fixing this requires a real HTTPS fetch, bounded parser fixtures, and source-update tests; enable the feed only after these complete.

WSS endpoints are candidates for WebTorrent-specific capabilities, not unsupported standard BT Engines. Sensitive ports such as UDP/25 require manual review; being in a public list does not authorize automatic protocol traffic. Even trackers on common low ports need exact role/scheme allowances, never a blanket allowance for general peers.

16 | Config defaults and automatic update governance

config/source-feeds.toml Defines feed URLs, authorized scope, update timing, limits, source lineage, and validation policies. catalog/trackers.json, catalog/ed2k-servers.json is traceable bootstrap data. Every Component still obtains published effective snapshots through ConfigReader rather than embedding scattered servers/ports independently.

Use this transactional path: the Component's shared CatalogFetcher downloads only allowed sources → parser returns typed candidates → Store stages candidates/provenance → Connection Manager applies endpoint/behavior policies → Config publishes a new immutable catalog revision. Raw feeds cannot carry shell commands, extra headers, credentials, arbitrary include paths, or overrides of local policy.

Automatic updates run after the user enables the corresponding Component, not upon opening HTML or installing the spec. Use conditional requests every 24 hours plus jitter; only the two tracker text feeds actually retrieved are enabled by default. New endpoints begin as validated/probing; failed updates retain the last known-good configuration. Manual pin/deny always overrides feeds.

Large additions/removals, domain ownership or DNS/certificate anomalies, many non-public addresses, and source-format changes enter a quarantine diff for review. HTTPS and Git blob digests protect source/transport and snapshot consistency; they do not prove endpoints are benign, and unverified signatures must not be called verified.

17 | Automatic safety awareness and source-benefit analysis

Stage	Checks	Result
Fetch	HTTPS, fixed sources, valid TLS, at most 2 same-origin redirects, no downgrade, timeout/encoded-byte limits	On failure, retain last-good and emit a feed event.
Parse	Raw/decoded byte limits, entry limits, strict ports/URLs, MET tag/count bounds, compression bombs	Reject anomalous data; parsing must never execute or connect.
Address	Literals, all A/AAAA/CNAME final addresses, IPv4-mapped IPv6; reject loopback/private/link-local/multicast/reserved	Revalidate on every dial and after every redirect; pin the IP validated for that attempt to the actual connection, preserving TLS hostname/SNI.
Protocol	Valid handshake/transaction/request correlation, response limits, source-address checks	`usable_observed` Proves usability only for this attempt; temporarily quarantine malformed responses.
Semantics	Public/private/I2P realms; content hash/scope; eD2k index versus peer	No cross-realm injection or sending private hashes outside.
Continuous observation	Qualified queries, incremental unique sources, connection success, actual service rate, time to first byte, bad-result ratio	Rotate sources by marginal benefit rather than accumulating traffic according to list length.

These SSRF defenses must be enforced on actual fetch/connect paths; a one-time string-parser check cannot handle DNS rebinding. OWASP guidance on validation and redirect/DNS risks serves as the implementation reference. S12

Metric denominators must be qualified: new_usable_sources / qualified_lookup, payload_served_sources / qualified_connected_sources. Duplicate sources do not count as new results; zero queries means unknown, not 0% or 100% success. Shared network-failure windows must not penalize every source. Track claimed completeness, candidate domain/IP counts, and actual useful pieces received separately; a 100% claim does not automatically mean completion is possible.

A tracker's UDP connect does not mean valid announce peers were received. BEP 15 defines connect/announce/scrape; store each stage's result separately. Do not send extra test announces for all the user's hashes. S15

Private torrent： When metadata explicitly states private=1 , do not add public trackers/DHT/PEX. For magnets without metadata, follow the original source information and selected privacy policy first; unknown does not authorize public defaults. Inject according to policy only after public evidence is obtained. BEP 27 requires private torrents to use only sources from their private trackers. S3

18 | Downloader and Engine inputs, outputs, and commands

Interface	Input	Output / required effect
`Discover`	task／content／realm／Config revision／deadline	Metadata + source snapshots, coverage quality, expiry; no transfer grant required.
`ProbeSources`	Candidate source set, dynamic resource window, desired scope	Report and retainable tickets; release task-local connections when probing finishes and report the release result.
`StartTrial`	Task revision、source snapshot、byte／I/O／network lease	Run-bound operation + qualified progress; stale sources cannot directly establish high availability.
`SetDownloadBudget`	Task / run / generation + multidimensional resource vector	Requested/effective budget, enforcement strength; return unsupported if unavailable.
`PauseOrObserve`	Reason and intent to retain checkpoint/ticket	Observed paused / retained queue / unknown; release all accounting only after stopping is confirmed.
`ConnectionCommand`	run＋connection＋policy_revision＋scope＋action＋evidence	applied／already_closed／unsupported_scope／stale_target／unknown／failed。
`ResourceReport`	Engine measurements	Local pressure and source/job/connection summaries go directly to Scheduler/Connection Manager, not through polling historical Metrics DB data.
`MetricsPush`	Raw observation batch + run / sequence / lost_count	P2P Metrics centralizes persistence; publisher memory queues are bounded and may drop data with recorded gaps.

For internal App interface JSON contracts, see contracts/control.schema.json; for new Web APIs, see contracts/control.openapi.json. Example requests contain no provider credentials and accept no arbitrary native API paths.

Actual socket creation, piece selection, normal protocol timeouts, and immediate parser rejection belong to Engine. Scheduler adjusts download budgets; Connection Manager imposes narrower source/connection restrictions. The effective allowed set is their intersection. Connection Manager cannot bypass user pauses or exceed Scheduler budgets.

18.1 Types and default semantics

run_id, connection_id and native keys are opaque identifiers, not decoded trust scores. Report sequence is a canonical decimal string, limited in SQLite to 0..9223372036854775807; start a new run at the limit rather than wrapping. Other API counts/times are constrained to JS safe integers; long-lived byte counters use decimal strings checked against the uint64 maximum. null always means unknown/unsupported, accompanied by missing_reason, not zero.

SourceSnapshot is bound to selection_digest. TTL expiry only reduces confidence in availability, not file completeness; callbacks must match component/run/seq. ConnectionReport 's service_expected is the Component-normalized result of handshake, interest, queue, request eligibility, and credit; include raw details too when available. qualified_idle_ms must accumulate valid observations from a monotonic clock within the same service generation; never fill sampling gaps with zero.

For multiplexed transports, content-source avoid restricts only the specified work. If the engine can only close the whole transport while other Tasks are receiving useful service, do not present this as closing only that job; automatic governance returns unsupported_scope, preserving narrow deny-new-request rules. A manual close-this-physical-connection action must show all affected Tasks.

If-Match: "rN" corresponds to expected_policy_revision/expected_revision on the command; reject mismatched body and header values. N for creating a manual policy is the current effective Config revision (returned as config_revision/ETag by the policy list); revocation uses that policy row's revision; connection commands use the reconciled policy version. Do not mix these. Persistent manual policies may have no current connection: policy_commands stores each Component's publication/revocation result without inventing a connection_id. request_id is at most 128 characters and deduplicated within that management instance; resending the same body returns only the original operation. Browser mutations accept only same-origin JSON; CLI may use private UDS. There is no product authentication, and this origin check is not claimed to resist malicious same-UID processes.

19 | Recoverable commands and races

Every command contains request_id, payload_digest, expected_run_id, connection_id or task_id, and expected_revision/policy_revision. Store operation + outbox first, then send to Engine. The same request_id with a different body returns 409; stale run/connection returns stale_target, and must not affect the new socket created by a reconnect.

No ack means unknown, not disconnected or unblocked. Reconcile actual connections or native command results read-only; never blindly resend with a new request_id. A purely local close of an already-missing handle may return already_closed, but only after checking the same run and identity.

Resource accounting retains pending / active / draining / unknown / released. Reduced/paused grants still count as potential transfer load until confirmed. A remote queue that may start automatically still consumes credit available for automatic use; changing its label to observing must not create fictitious free resources.

If Store cannot write, stop new dispatches and policy expansion. Engine may still immediately reject parse errors or disconnect under published policies; self-protection events go to bounded memory and are marked unpersisted. If Metrics fails, retain the live ResourceReport path, mark historical observation gaps, and do not stop healthy downloads.

Use monotonic time for report freshness and service timing. Persist expiries in UTC, retaining original observation and local receive times. After restart, clock rollback, unclear expiry ranges, or sequence jumps require new observations: never extend blocks or count unobserved service time. Component re-registration changes run; old IDs cannot carry violation counts onto other connections.

20 | SQLite and data ownership

Data	Owner / storage	Persistence method
Tasks, download success/failure, native hashes, deduplication claims, file journal	P2P Store／SQLite	Keep the core tables; transactions must not split.
Discovery targets and recent schedulable snapshots	P2P Store	`discovery_targets`, `source_snapshots`; include expiry / selection / report seq.
Connection open/close indexes and evidence affecting policies	P2P Store	`connection_identities`, `connection_tasks`, `connection_evidence`; not every 1-second sample.
Temporary avoidance, quarantines, commands, and results	P2P Store	`connection_policies`, `connection_commands`／`policy_commands`; target-scope indexes and expiry reviews.
Source candidates and publication lineage	P2P Store＋Config	Store stages facts/revisions; Config alone publishes the effective catalog.
Per-connection speed / RTT / country history	P2P Metrics' own storage	Locally redacted detail + aggregates; not a second system for deciding Task success.
Payload / native resume / range journal	Engine-managed working directory	No payload BLOBs in SQLite; avoid dual writers.

tasks.execution_state still represents Engine execution reality; discovery_targets.phase is Scheduler's scheduling phase, not another copy of the same state. Handle transitions involving both in one transaction: desired paused → phase held; keep lease draining until native pause is confirmed; completed verification → phase finished. New migrations first put existing running Tasks without run evidence into held/RECONCILE_REQUIRED, never assuming active; return to trial only after native reconciliation.

store-base.sql is the original v2.2 reference, while store-v23.sql is the additive schema. The migration runner first checks baseline hash/version, backs up, takes exclusive schema-migration access, and uses a transaction. Commit the version only after foreign_key_check/integrity_check pass; never run directly against an arbitrary unknown DB.

Store uses SQLite WAL, one writer, short transactions, read snapshots, and bounded batches. The same coordinator schedules checkpoints to avoid long reads blocking reclamation. Production WAL deployments must include the SQLite WAL-reset fix; this spec retains the policy of at least 3.51.3 or a verified backport. A local schema smoke test is not production-version acceptance. S13

21 | Pool rotation must not disrupt the file lifecycle

Do not preallocate whole-file payloads or reserve full capacity for all targets. Account separately for actual allocated blocks, native buffers, the next write window, WAL/metadata/move staging, and other byte costs. Sparse logical size exceeding allocated blocks does not mean physical space is full; show both in the UI.

下載中/<hash[0:2]>/<hash[2:4]>/<storage_key>/...
下載完/<分類>/<hash[0:2]>/<hash[2:4]>/<storage_key>/...
死檔/<hash[0:2]>/<hash[2:4]>/<storage_key>/...

storage_key is a stable hash including protocol namespace/native content identity. Magnets without native hashes use explicit provisional keys, later migrated through the journal without silently changing paths. Filesystem names are not file identities; display the full original title without treating it as an arbitrary path.

Rotation/observation only pauses jobs and saves checkpoints; do not move files to the dead-file directory on every observation transition. An expired source snapshot does not invalidate data. A dead candidate requires repeated qualified observations over the long term and no valid queue, pin, writer, or unknown operation.

Before a completion move, confirm writers have stopped, verification is complete, and the manifest is fixed. Use atomic rename on the same filesystem; across devices, copy → fsync → verify → publish → update journal → delete old files. Preserve recoverable data if any step fails. Path changes for a sharing Engine require native API coordination; never directly move files still in use.

Automatic cleanup is off by default. When enabled, follow Config retention, quarantine before purge, and retain tombstones after deletion. Low speed, an avoided individual source, or temporary tracker downtime alone cannot justify cleanup.

22 | React workbench: every decision is reviewable

Retain Noir Workbench's dark theme, Traditional Chinese, system fonts, and fixed semantic colors; no new login/i18n/Next.js. Source searches remain in tabs with each source's native fields. Use cursor pagination/virtual lists for large datasets instead of remounting whole tables every second.

View	Required display
Download pool	Counts for collecting / trial-ready / trial / active download / observation / held / complete; distinguish actual active tasks from tasks with payload traffic.
Control state	Configured/estimated capacity, unique goodput, network-layer traffic, I/O backlog, reasons for expansion/reduction/rotation, and the last perturbation result.
Connection analysis	Type, task/source, ID, country/unknown, speed, coverage, service eligibility, qualified zero-progress seconds, local interference, policy, and actual enforcement.
Source catalog	Candidate / observed in use / quarantined / retired, feed provenance, last check, update diff, native endpoint/port, and source benefit.
Detail Inspector	Full URL/hash/native state, evidence timeline, revocation reason, and trial results; confidential queries are excluded from public catalogs.

Separate close this connection, temporarily avoid this source, and block this IP actions. Disable unsupported precise actions with a reason; never substitute a broader action. False blocks can be revoked after checking native results; unknown operations must not show success toasts.

Treat source names, client strings, and messages as untrusted text; prohibit dangerouslySetInnerHTML. Preserve filters, selection, scroll, drafts, and focus across event updates; each detail view updates only its matching object/run. Verify 200% browser zoom, forced colors, reduced motion, keyboard access, and long hashes separately.

23 | Resource and performance targets: measurements required, not guarantees

Developers record the target test baseline's CPU/RAM/storage/network and Engine build. Planned acceptance: all 1,000 valid targets are visible to discovery scheduling after registration; a single returning result may start that target's trial; source timeouts do not block local APIs; backpressure produces no unbounded mailboxes/connection retries; and additional sources must not cause sustained net-throughput degradation without rollback.

In synthetic loopback tests with enough controllable sources, the controller must add trials when five jobs use only 50% of capacity, and stop growing when the target or a new bottleneck is reached. Compare controller benefit on the same workload using goodput, tail latency, memory, FD, disk backlog, and churn together, not only throughput curves.

Proposed initial SLOs: control-summary age p95 ≤ 2 seconds; local non-data queries p95 ≤ 200 ms; propose disconnect by the next control tick after a qualified-service timeout, with actual Engine closure latency recorded separately. These are targets, not passed checks before product implementation.

Pressure events use a priority channel. Coalesce low-value, high-frequency samples; exact counters must not accumulate from lost deltas. Each run has monotonic seq/reset and becomes continuous only after reconciliation. Metrics must not use connection_id as an unbounded Prometheus label; store details under retention and use bounded labels for aggregates.

24 | Migration, rollback, and development order

Freeze the v2.2 snapshot and schema fingerprint first; do not apply old fixed-slot settings directly. Add v2.3 auto settings and migrations, and replay tests against a DB backup. Old max_active_tasks／max_probes become historical settings with deactivation reasons; do not silently reintroduce them into auto mode.

Implementation order: contracts and state model → globally visible discovery/short-lived probing → Connection Agent/Registry → precise failure eligibility and revocable policies → adaptive pool → Config catalog fetch/validation → UI → fault and live-network acceptance. REMULE supplies the first full-precision vertical slice; qBittorrent's precise bridge is an independent dependency, not something stock banPeers can stand in for.

Before rollback, stop new dispatches, reconcile all draining/unknown jobs, and back up the DB. Old Engines must not concurrently write the same partial files. Prefer restoring the old process and matching backup over unverified destructive down-migrations. Catalogs can return to last-good revisions; policy evidence must survive rollback.

This package does not authorize commits, pushes, deployment, external-tool installation, VPN Manager changes, or unapproved test data. Claude Code should implement and test the specified tasks directly after handoff; rewriting everything into another plan does not count as delivery.

25 | Known limitations and delivery status

The specification covers all requirements in this revision; the product is not implemented yet. Candidate sources have real public data and snapshot digests, but no live-peer/tracker-announce/eD2k download tests. There is no safe-server or phishing-excluded certification.

Stock qBittorrent's gap in precise per-connection control and the unavailable raw feed for server.met are explicit integration/evidence gates in this revision. Corresponding full-feature acceptance must remain BLOCKED rather than removing requirements. Actual Node/Rust/Engine versions are fixed after reading existing lockfiles and owner policy during implementation preflight; do not invent available build hashes.

For concrete attachment validation results, see VALIDATION.md; ACCEPTANCE.md contains software cases to be accepted, not cases already run. Interactive HTML is only a rules example; all data is labeled synthetic and no requests are sent to any source.

Review tools · offline rule examples

Work through the situations you are concerned about, one by one.

The following only replays this document's decision conditions. It is not a real speed test, source probe, or download simulation and creates no connections. All ratios, durations, and counts are synthetic inputs.

1. Dynamic pool decisions

Current active download countEligible waiting job countKnown network utilization:50%Local pressure ratio:0.20

Reports are freshPrevious adjustment has settled, with at least two healthy windowsUnknown network capacityPrevious expansion added no benefit for two consecutive windows

Recommended additional trials: 2

Five downloads use only 50% of the network, and the local system is healthy. This count illustrates a step size; actual FD/RAM/I/O/network budgets must still be granted individually.

A pressure ratio of 1.0 means that bottleneck domain has reached its policy limit, not whole-host CPU usage. With unknown capacity, use marginal benefit rather than claiming 50% of Internet bandwidth is in use.

2. Why treat two cases of not downloading differently?

Select a connection scenario

Disconnect this connection + temporarily avoid source

Applies only after service eligibility is established, the request times out, and local/shared-network failures are excluded. No automatic whole-IP ban.

Temporary avoidance defaults to realm + content + source, not blanket IP bans, much less country bans. Preserve evidence and execution responses for every automatic action.

3. Default candidate catalog

122 tracker URIs and 12 current eD2k servers, plus an old snapshot of one upstream-removed endpoint. All entries below remain unprobed / intent unknown. Displaying a URI creates no connection.

Source typeFilter by endpoint, protocol, or source

Showing 134 candidates; all are unprobed, with safety intent unknown.

Candidate	Protocol	Source	Default handling
udp://tracker.opentrackr.org:1337/announce	udp	ngosang · xiu2	Candidate · validate first
http://tracker.opentrackr.org:1337/announce	http	ngosang · xiu2	Candidate · validate first
udp://open.stealth.si:80/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker.torrent.eu.org:451/announce	udp	ngosang · xiu2	Sensitive port · manual review
udp://open.demonii.com:1337/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker.skynetcloud.site:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker.qu.ax:6969/announce	udp	ngosang · xiu2	Candidate · validate first
http://tracker.qu.ax:6969/announce	http	ngosang · xiu2	Candidate · validate first
udp://tracker.corpscorp.online:80/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker.bittor.pw:1337/announce	udp	ngosang · xiu2	Candidate · validate first
udp://explodie.org:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker.tryhackx.org:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker.gmi.gd:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker-udp.gbitt.info:80/announce	udp	ngosang · xiu2	Candidate · validate first
udp://retracker01-msk-virt.corbina.net:80/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker.nyaa.vc:6969/announce	udp	ngosang · xiu2	Candidate · validate first
http://tracker.dler.org:6969/announce	http	ngosang · xiu2	Candidate · validate first
http://tracker.dler.com:6969/announce	http	ngosang · xiu2	Candidate · validate first
udp://tracker.dler.org:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker2.dler.org:80/announce	udp	ngosang · xiu2	Candidate · validate first
http://tracker2.dler.org:80/announce	http	ngosang · xiu2	Candidate · validate first
udp://tracker.ducks.party:1984/announce	udp	ngosang · xiu2	Candidate · validate first
http://tracker.renfei.net:8080/announce	http	ngosang · xiu2	Candidate · validate first
udp://tracker.peerfect.org:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker.opentrackr.com:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker.ilibr.org:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://mail.segso.net:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://t.overflow.biz:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://bittorrent-tracker.e-n-c-r-y-p-t.net:1337/announce	udp	ngosang · xiu2	Candidate · validate first
http://t.overflow.biz:6969/announce	http	ngosang · xiu2	Candidate · validate first
http://bittorrent-tracker.e-n-c-r-y-p-t.net:1337/announce	http	ngosang · xiu2	Candidate · validate first
https://tracker.pmman.tech:443/announce	https	ngosang · xiu2	Candidate · validate first
udp://ipv4announce.sktorrent.eu:6969/announce	udp	ngosang · xiu2	Candidate · validate first
http://ipv4announce.sktorrent.eu:6969/announce	http	ngosang · xiu2	Candidate · validate first
udp://evan.im:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker.wildkat.net:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker.004430.xyz:1337/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tr4ck3r.duckdns.org:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://seedpeer.net:6969/announce	udp	ngosang · xiu2	Candidate · validate first
https://tracker.zhuqiy.com:443/announce	https	ngosang · xiu2	Candidate · validate first
https://tracker.nekomi.cn:443/announce	https	ngosang · xiu2	Candidate · validate first
https://004430.xyz:443/announce	https	ngosang · xiu2	Candidate · validate first
http://tracker.mywaifu.best:6969/announce	http	ngosang · xiu2	Candidate · validate first
http://004430.xyz:80/announce	http	ngosang · xiu2	Candidate · validate first
udp://open.ftorrent.com:443/announce	udp	ngosang · xiu2	Candidate · validate first
udp://martin-gebhardt.eu:25/announce	udp	ngosang · xiu2	Sensitive port · manual review
https://tracker.7471.top:443/announce	https	ngosang · xiu2	Candidate · validate first
https://tr.nyacat.pw:443/announce	https	ngosang · xiu2	Candidate · validate first
http://tracker.waaa.moe:6969/announce	http	ngosang · xiu2	Candidate · validate first
http://tracker.dhitechnical.com:6969/announce	http	ngosang · xiu2	Candidate · validate first
http://tr.nyacat.pw:80/announce	http	ngosang · xiu2	Candidate · validate first
http://open.tracker.cl:1337/announce	http	ngosang · xiu2	Candidate · validate first
udp://tracker.teambelgium.net:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker.fnix.net:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker.aruku.ovh:8081/announce	udp	ngosang · xiu2	Candidate · validate first
udp://admin.52ywp.com:6969/announce	udp	ngosang · xiu2	Candidate · validate first
https://open.ftorrent.com:443/announce	https	ngosang · xiu2	Candidate · validate first
http://tracker.23794.top:6969/announce	http	ngosang · xiu2	Candidate · validate first
udp://anime-tracker.aruku.kro.kr:8081/announce	udp	ngosang · xiu2	Candidate · validate first
https://tracker.foreverpirates.co:443/announce	https	ngosang · xiu2	Candidate · validate first
udp://tracker.torrents.observer:80/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker.nyaa.net:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker.cn.nyaa.net:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tr3.ysagin.top:2715/announce	udp	ngosang · xiu2	Candidate · validate first
udp://kolankoalastree.newtrackon.co.nz:1337/announce	udp	ngosang · xiu2	Candidate · validate first
udp://archive.torrentonline.cc:42069/announce	udp	ngosang · xiu2	Candidate · validate first
http://tracker.zhuqiy.dgj055.icu:80/announce	http	ngosang · xiu2	Candidate · validate first
http://1337.abcvg.info:80/announce	http	ngosang · xiu2	Candidate · validate first
udp://yuptracker-eu.gaijinent.com:27022/announce	udp	ngosang · xiu2	Candidate · validate first
udp://whybother.torrentonline.cc:42069/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker.playground.ru:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://tracker.ddunlimited.net:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://ns575949.ip-51-222-82.net:6969/announce	udp	ngosang · xiu2	Candidate · validate first
udp://edgev.duckdns.org:6969/announce	udp	ngosang · xiu2	Candidate · validate first
https://t.213891.xyz:443/announce	https	ngosang · xiu2	Candidate · validate first
http://107.189.2.131:1337/announce	http	xiu2	Candidate · validate first
http://207.241.226.111:6969/announce	http	xiu2	Candidate · validate first
http://207.241.231.226:6969/announce	http	xiu2	Candidate · validate first
http://announce.sktorrent.eu:6969/announce	http	xiu2	Candidate · validate first
http://bt1.archive.org:6969/announce	http	xiu2	Candidate · validate first
http://bt2.archive.org:6969/announce	http	xiu2	Candidate · validate first
http://nyaa.tracker.wf:7777/announce	http	xiu2	Candidate · validate first
http://retracker01-msk-virt.corbina.net:80/announce	http	xiu2	Candidate · validate first
http://torrentsmd.com:8080/announce	http	xiu2	Candidate · validate first
http://tracker.internetwarriors.net:1337/announce	http	xiu2	Candidate · validate first
http://tracker.xn--djrq4gl4hvoi.top:80/announce	http	xiu2	Candidate · validate first
http://tracker1.itzmx.com:8080/announce	http	xiu2	Candidate · validate first
http://www.wareztorrent.com:80/announce	http	xiu2	Candidate · validate first
https://1.tracker.eu.org:443/announce	https	xiu2	Candidate · validate first
https://1337.abcvg.info:443/announce	https	xiu2	Candidate · validate first
https://tr.abiir.top:443/announce	https	xiu2	Candidate · validate first
https://tr.burnabyhighstar.com:443/announce	https	xiu2	Candidate · validate first
https://tracker.kuroy.me:443/announce	https	xiu2	Candidate · validate first
https://tracker.midnightprogrammer.net:443/announce	https	xiu2	Candidate · validate first
https://tracker.qingwapt.org:443/announce	https	xiu2	Candidate · validate first
https://tracker1.520.jp:443/announce	https	xiu2	Candidate · validate first
udp://52.58.128.163:6969/announce	udp	xiu2	Candidate · validate first
udp://93.158.213.92:6969/announce	udp	xiu2	Candidate · validate first
udp://[2a03:7220:8083:cd00::1]:451/announce	udp	xiu2	Sensitive port · manual review
udp://[2a04:ac00:1:3dd8::1:2710]:2710/announce	udp	xiu2	Candidate · validate first
udp://exodus.desync.com:6969/announce	udp	xiu2	Candidate · validate first
udp://ipv6.govt.hu:6969/announce	udp	xiu2	Candidate · validate first
udp://open.tracker.ink:6969/announce	udp	xiu2	Candidate · validate first
udp://opentor.org:2710/announce	udp	xiu2	Candidate · validate first
udp://opentracker.lain.moscow:6969/announce	udp	xiu2	Candidate · validate first
udp://p4p.arenabg.com:1337/announce	udp	xiu2	Candidate · validate first
udp://retracker.hotplug.ru:2710/announce	udp	xiu2	Candidate · validate first
udp://torrent.tracker.durukanbal.com:6969/announce	udp	xiu2	Candidate · validate first
udp://tracker.dler.com:6969/announce	udp	xiu2	Candidate · validate first
udp://tracker.farted.net:6969/announce	udp	xiu2	Candidate · validate first
udp://tracker.filemail.com:6969/announce	udp	xiu2	Candidate · validate first
udp://tracker.flatuslifir.is:6969/announce	udp	xiu2	Candidate · validate first
udp://tracker.k.vu:6969/announce	udp	xiu2	Candidate · validate first
udp://tracker.skyts.net:6969/announce	udp	xiu2	Candidate · validate first
udp://tracker.willy.pro:6969/announce	udp	xiu2	Candidate · validate first
udp://tracker.yume-hatsuyuki.moe:6969/announce	udp	xiu2	Candidate · validate first
udp://tracker1.itzmx.com:8080/announce	udp	xiu2	Candidate · validate first
udp://tracker2.itzmx.com:6961/announce	udp	xiu2	Candidate · validate first
udp://tracker3.itzmx.com:6961/announce	udp	xiu2	Candidate · validate first
udp://tracker4.itzmx.com:2710/announce	udp	xiu2	Candidate · validate first
udp://v2.iperson.xyz:6969/announce	udp	xiu2	Candidate · validate first
wss://tracker.openwebtorrent.com:443/announce	wss	xiu2	Requires WebTorrent capability
eMule Sunrise — ed2k://\|server\|176.123.5.89\|4725\|/	ed2k	emule-security-web	Candidate · validate first
Nordic Server — ed2k://\|server\|77.42.68.79\|4232\|/	ed2k	emule-security-web	Candidate · validate first
Sharing-Devils No.4 — ed2k://\|server\|91.208.162.87\|4232\|/	ed2k	emule-security-web	Candidate · validate first
MO-Server — ed2k://\|server\|91.208.162.182\|4232\|/	ed2k	emule-security-web	Candidate · validate first
ed2k-rust — ed2k://\|server\|85.17.116.222\|6082\|/	ed2k	emule-security-web	Candidate · validate first
Sharing-Devils No.2 — ed2k://\|server\|85.121.5.137\|4232\|/	ed2k	emule-security-web	Candidate · validate first
eMule Cosmic — ed2k://\|server\|212.95.35.240\|4232\|/	ed2k	emule-security-web	Candidate · validate first
Mazinga Server — ed2k://\|server\|213.141.198.207\|4232\|/	ed2k	emule-security-web	Candidate · validate first
MO-ad-free — ed2k://\|server\|57.131.35.107\|4232\|/	ed2k	emule-security-web	Candidate · validate first
Drunken Donkey — ed2k://\|server\|193.187.90.12\|4661\|/	ed2k	emule-security-web	Candidate · validate first
MO-24/7 — ed2k://\|server\|212.95.35.240\|4323\|/	ed2k	emule-security-web	Candidate · validate first
Sharing-Devils No.3 TEST — ed2k://\|server\|91.208.162.55\|4235\|/	ed2k	emule-security-web	Candidate · validate first

4. Your review notes

Retain eight core components or accept the new Connection Manager? Which transition/blocking conditions need adjustment?

Stored only in page memory; export before refreshing.

Raw candidate-source data: 134 endpoints, provenance, and unknown states

Preserves all data fields embedded in the original, for reading only; no requests are sent to endpoints.

[
  {
    "endpoint_id": "tr_e7aafb3a92ad2a4c04d3",
    "uri": "udp://tracker.opentrackr.org:1337/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_5347b4c4a5d8897046d8",
    "uri": "http://tracker.opentrackr.org:1337/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_9602e7b2019adcad1a45",
    "uri": "udp://open.stealth.si:80/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_49b560d0e99309186ed2",
    "uri": "udp://tracker.torrent.eu.org:451/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "manual_review_sensitive_port",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_768d2af44fd5cbd0bbb4",
    "uri": "udp://open.demonii.com:1337/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_9b45647cbc4ec20494df",
    "uri": "udp://tracker.skynetcloud.site:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_8a3460ed3132abf5b5e9",
    "uri": "udp://tracker.qu.ax:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_7c3ca5e0e49e4b81b0ba",
    "uri": "http://tracker.qu.ax:6969/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_d52fbcb060a99de3d419",
    "uri": "udp://tracker.corpscorp.online:80/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_00b85fcb09930b486810",
    "uri": "udp://tracker.bittor.pw:1337/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_f90e8a1ef4642b3d458e",
    "uri": "udp://explodie.org:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_6a2d73948ec717bd1661",
    "uri": "udp://tracker.tryhackx.org:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_0d3c4bf282cf13183eaa",
    "uri": "udp://tracker.gmi.gd:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_0bc11831f07df4bbdcd1",
    "uri": "udp://tracker-udp.gbitt.info:80/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_0e68c794851f89008cb8",
    "uri": "udp://retracker01-msk-virt.corbina.net:80/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_2a15cbf6aeafc0a5ca00",
    "uri": "udp://tracker.nyaa.vc:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_7290c29a76512a7efbbc",
    "uri": "http://tracker.dler.org:6969/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_f0d50d0bf39024111736",
    "uri": "http://tracker.dler.com:6969/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_1305ac54bbf0dddb8f50",
    "uri": "udp://tracker.dler.org:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_4601f3abc045f1e2cafd",
    "uri": "udp://tracker2.dler.org:80/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_aea6c1899a6573ce1418",
    "uri": "http://tracker2.dler.org:80/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_1da6adaf350291d38be0",
    "uri": "udp://tracker.ducks.party:1984/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_ccafa756cfa8bbf605f6",
    "uri": "http://tracker.renfei.net:8080/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_8b9bbe1e89109d3807b3",
    "uri": "udp://tracker.peerfect.org:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_1a8e7be370b3d0402f37",
    "uri": "udp://tracker.opentrackr.com:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_0a79fae0544191597bdb",
    "uri": "udp://tracker.ilibr.org:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_0e0e3c29f21b584bdd54",
    "uri": "udp://mail.segso.net:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_8e43ee12d073342ce1ed",
    "uri": "udp://t.overflow.biz:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_7e056bf58ddd282514d2",
    "uri": "udp://bittorrent-tracker.e-n-c-r-y-p-t.net:1337/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_1c0dbd90b96339c7bef2",
    "uri": "http://t.overflow.biz:6969/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_e65763949fba96ff14d9",
    "uri": "http://bittorrent-tracker.e-n-c-r-y-p-t.net:1337/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_5399dffb660edcc7e377",
    "uri": "https://tracker.pmman.tech:443/announce",
    "protocol": "https",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_ec9c8a050b732fab8d54",
    "uri": "udp://ipv4announce.sktorrent.eu:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_3a8e27ba74c65281f587",
    "uri": "http://ipv4announce.sktorrent.eu:6969/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_d31b5445418d00503b85",
    "uri": "udp://evan.im:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_bf6c1241ac9b56e6697c",
    "uri": "udp://tracker.wildkat.net:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_ad965301125418e0ead7",
    "uri": "udp://tracker.004430.xyz:1337/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_ed4257101f050cf483a3",
    "uri": "udp://tr4ck3r.duckdns.org:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_177b8a369d20a9afcb0c",
    "uri": "udp://seedpeer.net:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_cfd72a51cd1ee02e8095",
    "uri": "https://tracker.zhuqiy.com:443/announce",
    "protocol": "https",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_e239d5bc5eb10f0862f2",
    "uri": "https://tracker.nekomi.cn:443/announce",
    "protocol": "https",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_1ef5402a1ba857349587",
    "uri": "https://004430.xyz:443/announce",
    "protocol": "https",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_e4838ecfad683c540971",
    "uri": "http://tracker.mywaifu.best:6969/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_dbbc9fc9f9e0b6e415af",
    "uri": "http://004430.xyz:80/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_93fd046608d6f6415a59",
    "uri": "udp://open.ftorrent.com:443/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_a52edc69aeb9dcd0b3f9",
    "uri": "udp://martin-gebhardt.eu:25/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "manual_review_sensitive_port",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_65c37e05b8c3bf438115",
    "uri": "https://tracker.7471.top:443/announce",
    "protocol": "https",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_3210bf260996b1e21e02",
    "uri": "https://tr.nyacat.pw:443/announce",
    "protocol": "https",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_26c33d6e61a7ea8f32d5",
    "uri": "http://tracker.waaa.moe:6969/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_62c68e75757248fdb3d4",
    "uri": "http://tracker.dhitechnical.com:6969/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_6c13c9de7c3c4ffe98f4",
    "uri": "http://tr.nyacat.pw:80/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_9d75a903482157d43261",
    "uri": "http://open.tracker.cl:1337/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_89becaa140a0e5855ccf",
    "uri": "udp://tracker.teambelgium.net:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_c29901bbbb842bd27834",
    "uri": "udp://tracker.fnix.net:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_22ffae26c9bb05586686",
    "uri": "udp://tracker.aruku.ovh:8081/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_a0b8fce3c58387d4b243",
    "uri": "udp://admin.52ywp.com:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_153629b08e1d449007ba",
    "uri": "https://open.ftorrent.com:443/announce",
    "protocol": "https",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_dcbfaf8a6379c365c369",
    "uri": "http://tracker.23794.top:6969/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_8b6e6d8593717fcbd8e8",
    "uri": "udp://anime-tracker.aruku.kro.kr:8081/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_42d103ff92a192f10f17",
    "uri": "https://tracker.foreverpirates.co:443/announce",
    "protocol": "https",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_b5f4bf48e5b62cc60a02",
    "uri": "udp://tracker.torrents.observer:80/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_30ab8a6195b3b937b936",
    "uri": "udp://tracker.nyaa.net:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_5136e11d0a4db5b8a2fd",
    "uri": "udp://tracker.cn.nyaa.net:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_3a517c9676460af2c244",
    "uri": "udp://tr3.ysagin.top:2715/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_d8764c6a2e54e554d737",
    "uri": "udp://kolankoalastree.newtrackon.co.nz:1337/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_8f459cc4659bb8918879",
    "uri": "udp://archive.torrentonline.cc:42069/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_3e231294fec576a21474",
    "uri": "http://tracker.zhuqiy.dgj055.icu:80/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_1d23856a4dcba12f0890",
    "uri": "http://1337.abcvg.info:80/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_bfad8febecc8d34ea60f",
    "uri": "udp://yuptracker-eu.gaijinent.com:27022/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_d00204c2dc99432de5bc",
    "uri": "udp://whybother.torrentonline.cc:42069/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_a3715e45cc4ff2a08c08",
    "uri": "udp://tracker.playground.ru:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_b670d5ffef147c1a34f5",
    "uri": "udp://tracker.ddunlimited.net:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_92ff87846531ca4561d0",
    "uri": "udp://ns575949.ip-51-222-82.net:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_6322a4e0ac580ca0b5eb",
    "uri": "udp://edgev.duckdns.org:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_6426e702803f2a56bd2e",
    "uri": "https://t.213891.xyz:443/announce",
    "protocol": "https",
    "realm": "public_bt",
    "source_ids": [
      "ngosang",
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_1fa0694e8c47f66bab78",
    "uri": "http://107.189.2.131:1337/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_85bf612e15f11c251e06",
    "uri": "http://207.241.226.111:6969/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_9ac05b94a64cc1d0ee51",
    "uri": "http://207.241.231.226:6969/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_81cf09ece384117fd0af",
    "uri": "http://announce.sktorrent.eu:6969/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_effa179ee8647e57fba2",
    "uri": "http://bt1.archive.org:6969/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_1c78d114e0beafc157ca",
    "uri": "http://bt2.archive.org:6969/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_9da1458a29c500d77fcd",
    "uri": "http://nyaa.tracker.wf:7777/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_197005b958105f57772b",
    "uri": "http://retracker01-msk-virt.corbina.net:80/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_93bd6abeb95507c17e4e",
    "uri": "http://torrentsmd.com:8080/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_fa444de822d4fc660cff",
    "uri": "http://tracker.internetwarriors.net:1337/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_8a1943e27b9ded1c801c",
    "uri": "http://tracker.xn--djrq4gl4hvoi.top:80/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_f4ba27c3df99e4a177a8",
    "uri": "http://tracker1.itzmx.com:8080/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_d4c351818647f027f93d",
    "uri": "http://www.wareztorrent.com:80/announce",
    "protocol": "http",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_fecc3323bb8e25e365e0",
    "uri": "https://1.tracker.eu.org:443/announce",
    "protocol": "https",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_f949af7d4c434450546a",
    "uri": "https://1337.abcvg.info:443/announce",
    "protocol": "https",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_ca197896ef641f99ca3e",
    "uri": "https://tr.abiir.top:443/announce",
    "protocol": "https",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_6be536d2f232af5b867f",
    "uri": "https://tr.burnabyhighstar.com:443/announce",
    "protocol": "https",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_96ebc73f40872cfdf53e",
    "uri": "https://tracker.kuroy.me:443/announce",
    "protocol": "https",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_eb2db6860c56c56043da",
    "uri": "https://tracker.midnightprogrammer.net:443/announce",
    "protocol": "https",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_aee04a414594e02c7a2f",
    "uri": "https://tracker.qingwapt.org:443/announce",
    "protocol": "https",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_9bb064af7f9fac5f7fed",
    "uri": "https://tracker1.520.jp:443/announce",
    "protocol": "https",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_5aa546aa6429c21562bd",
    "uri": "udp://52.58.128.163:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_621c69ccd287852c6ffb",
    "uri": "udp://93.158.213.92:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_9aaf54b6de887e506605",
    "uri": "udp://[2a03:7220:8083:cd00::1]:451/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "manual_review_sensitive_port",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_9b53ba718fdd78b7d97c",
    "uri": "udp://[2a04:ac00:1:3dd8::1:2710]:2710/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_975eeb764b3c82e9eef5",
    "uri": "udp://exodus.desync.com:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_3c49cdb225af51e2cdee",
    "uri": "udp://ipv6.govt.hu:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_14abef20bbf32479b592",
    "uri": "udp://open.tracker.ink:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_793a7ea68ff42c290e2a",
    "uri": "udp://opentor.org:2710/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_d60a7f8cc21ae5c83f17",
    "uri": "udp://opentracker.lain.moscow:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_38611c3f8126c9b4e9f2",
    "uri": "udp://p4p.arenabg.com:1337/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_f237059b169ee48288ba",
    "uri": "udp://retracker.hotplug.ru:2710/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_bb48f3e6abee60b5e719",
    "uri": "udp://torrent.tracker.durukanbal.com:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_66f78ddb6a174d3cdc58",
    "uri": "udp://tracker.dler.com:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_f5d5a4239eab5bbe1755",
    "uri": "udp://tracker.farted.net:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_7231187c42916af832e5",
    "uri": "udp://tracker.filemail.com:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_35e5139bec3d124c5cb1",
    "uri": "udp://tracker.flatuslifir.is:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_1cf6e29fec5e1adfa926",
    "uri": "udp://tracker.k.vu:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_8647636414170b8ae4cc",
    "uri": "udp://tracker.skyts.net:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_9c8f4b1393fa35c207cb",
    "uri": "udp://tracker.willy.pro:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_f1b4ca7ff40f7fc487eb",
    "uri": "udp://tracker.yume-hatsuyuki.moe:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_e3dc7e2540d3b9221c2b",
    "uri": "udp://tracker1.itzmx.com:8080/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_705c677be0bdfaadd829",
    "uri": "udp://tracker2.itzmx.com:6961/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_7a4c7e0d1162e7a57200",
    "uri": "udp://tracker3.itzmx.com:6961/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_8b119d7f519ba0442456",
    "uri": "udp://tracker4.itzmx.com:2710/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_638fd3f69d78a8cc976f",
    "uri": "udp://v2.iperson.xyz:6969/announce",
    "protocol": "udp",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "tr_bd4914bd4d5d433f649a",
    "uri": "wss://tracker.openwebtorrent.com:443/announce",
    "protocol": "wss",
    "realm": "public_bt",
    "source_ids": [
      "xiu2"
    ],
    "syntax_status": "passed",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "requires_webtorrent_capability",
    "country": null,
    "kind": "tracker"
  },
  {
    "endpoint_id": "ed_61f00ea481c990a9a6eb",
    "name": "eMule Sunrise",
    "uri": "ed2k://|server|176.123.5.89|4725|/",
    "ip": "176.123.5.89",
    "tcp_port": 4725,
    "udp_port": null,
    "obfuscated_port": null,
    "source_ids": [
      "emule-security-web"
    ],
    "source_updated_at": "2026-10-02T16:02:00Z",
    "observed_date": "2026-10-03",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "kind": "ed2k",
    "protocol": "ed2k"
  },
  {
    "endpoint_id": "ed_cd74a8536f0297e43f99",
    "name": "Nordic Server",
    "uri": "ed2k://|server|77.42.68.79|4232|/",
    "ip": "77.42.68.79",
    "tcp_port": 4232,
    "udp_port": null,
    "obfuscated_port": null,
    "source_ids": [
      "emule-security-web"
    ],
    "source_updated_at": "2026-10-02T16:02:00Z",
    "observed_date": "2026-10-03",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "kind": "ed2k",
    "protocol": "ed2k"
  },
  {
    "endpoint_id": "ed_1749651af8b6af20bb96",
    "name": "Sharing-Devils No.4",
    "uri": "ed2k://|server|91.208.162.87|4232|/",
    "ip": "91.208.162.87",
    "tcp_port": 4232,
    "udp_port": null,
    "obfuscated_port": null,
    "source_ids": [
      "emule-security-web"
    ],
    "source_updated_at": "2026-10-02T16:02:00Z",
    "observed_date": "2026-10-03",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "kind": "ed2k",
    "protocol": "ed2k"
  },
  {
    "endpoint_id": "ed_801e2a754201c3c505f7",
    "name": "MO-Server",
    "uri": "ed2k://|server|91.208.162.182|4232|/",
    "ip": "91.208.162.182",
    "tcp_port": 4232,
    "udp_port": null,
    "obfuscated_port": null,
    "source_ids": [
      "emule-security-web"
    ],
    "source_updated_at": "2026-10-02T16:02:00Z",
    "observed_date": "2026-10-03",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "kind": "ed2k",
    "protocol": "ed2k"
  },
  {
    "endpoint_id": "ed_1d9ae4dc6a91c2279869",
    "name": "ed2k-rust",
    "uri": "ed2k://|server|85.17.116.222|6082|/",
    "ip": "85.17.116.222",
    "tcp_port": 6082,
    "udp_port": null,
    "obfuscated_port": null,
    "source_ids": [
      "emule-security-web"
    ],
    "source_updated_at": "2026-10-02T16:02:00Z",
    "observed_date": "2026-10-03",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "kind": "ed2k",
    "protocol": "ed2k"
  },
  {
    "endpoint_id": "ed_29423d6cd95a8ff0d7d8",
    "name": "Sharing-Devils No.2",
    "uri": "ed2k://|server|85.121.5.137|4232|/",
    "ip": "85.121.5.137",
    "tcp_port": 4232,
    "udp_port": null,
    "obfuscated_port": null,
    "source_ids": [
      "emule-security-web"
    ],
    "source_updated_at": "2026-10-02T16:02:00Z",
    "observed_date": "2026-10-03",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "kind": "ed2k",
    "protocol": "ed2k"
  },
  {
    "endpoint_id": "ed_67ca89c53e638fafe3b9",
    "name": "eMule Cosmic",
    "uri": "ed2k://|server|212.95.35.240|4232|/",
    "ip": "212.95.35.240",
    "tcp_port": 4232,
    "udp_port": null,
    "obfuscated_port": null,
    "source_ids": [
      "emule-security-web"
    ],
    "source_updated_at": "2026-10-02T16:02:00Z",
    "observed_date": "2026-10-03",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "kind": "ed2k",
    "protocol": "ed2k"
  },
  {
    "endpoint_id": "ed_449439c90b437084b2b0",
    "name": "Mazinga Server",
    "uri": "ed2k://|server|213.141.198.207|4232|/",
    "ip": "213.141.198.207",
    "tcp_port": 4232,
    "udp_port": null,
    "obfuscated_port": null,
    "source_ids": [
      "emule-security-web"
    ],
    "source_updated_at": "2026-10-02T16:02:00Z",
    "observed_date": "2026-10-03",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "kind": "ed2k",
    "protocol": "ed2k"
  },
  {
    "endpoint_id": "ed_1d3c52855c846492aa58",
    "name": "MO-ad-free",
    "uri": "ed2k://|server|57.131.35.107|4232|/",
    "ip": "57.131.35.107",
    "tcp_port": 4232,
    "udp_port": null,
    "obfuscated_port": null,
    "source_ids": [
      "emule-security-web"
    ],
    "source_updated_at": "2026-10-02T16:02:00Z",
    "observed_date": "2026-10-03",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "kind": "ed2k",
    "protocol": "ed2k"
  },
  {
    "endpoint_id": "ed_29aae7e9d0f9c71fbe06",
    "name": "Drunken Donkey",
    "uri": "ed2k://|server|193.187.90.12|4661|/",
    "ip": "193.187.90.12",
    "tcp_port": 4661,
    "udp_port": null,
    "obfuscated_port": null,
    "source_ids": [
      "emule-security-web"
    ],
    "source_updated_at": "2026-10-02T16:02:00Z",
    "observed_date": "2026-10-03",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "kind": "ed2k",
    "protocol": "ed2k"
  },
  {
    "endpoint_id": "ed_a1debf19e9cc0aaa46c4",
    "name": "MO-24/7",
    "uri": "ed2k://|server|212.95.35.240|4323|/",
    "ip": "212.95.35.240",
    "tcp_port": 4323,
    "udp_port": null,
    "obfuscated_port": null,
    "source_ids": [
      "emule-security-web"
    ],
    "source_updated_at": "2026-10-02T16:02:00Z",
    "observed_date": "2026-10-03",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "kind": "ed2k",
    "protocol": "ed2k"
  },
  {
    "endpoint_id": "ed_2100cf95fa0d285e529e",
    "name": "Sharing-Devils No.3 TEST",
    "uri": "ed2k://|server|91.208.162.55|4235|/",
    "ip": "91.208.162.55",
    "tcp_port": 4235,
    "udp_port": null,
    "obfuscated_port": null,
    "source_ids": [
      "emule-security-web"
    ],
    "source_updated_at": "2026-10-02T16:02:00Z",
    "observed_date": "2026-10-03",
    "runtime_status": "unprobed",
    "risk_status": "unknown",
    "default_use": "eligible_for_validation",
    "kind": "ed2k",
    "protocol": "ed2k"
  }
]

Delivery and verification boundaries

63 offline reference tests, 9 document/contract checks, and 43 Chromium content checks passed. Direct file:// navigation was blocked by environment policy; tests loaded the same HTML content. Six diagrams and desktop/narrow-window views were inspected. SQLite 3.46.1 was used only for in-memory schema checks; production WAL version and product acceptance have not passed.

Stock qBittorrent's precise-governance bridge, raw HTTPS server.met binary tests, real P2P, and file operations still have separate acceptance gates. Passing data-table, HTML, and offline-reference-model checks does not mean production Engines or all sources have been verified safe.

Original contracts, configuration, and development handoff

The following reproduces this version's bundled Markdown/JSON/SQL/TOML rather than creating another summary. Use the corresponding ZIP files for implementation; source URLs open only when explicitly clicked.

README.md

# P2P Downloader v2.3 design handoff package

This package completes the design for continuous discovery + elastic download pools + connection analysis/control + default-source governance. It is not a finished P2P product, installer, or verified safe-server list.

## Reading order

Read `SPEC.md` 01–05 for the overview, then 08–14 for dynamic pools and connection governance, followed by sources in 15–17 and data/interfaces in 18–21. Before execution, read `DECISIONS.md`, `TASKS.md`, `ACCEPTANCE.md`, and `IMPLEMENTATION_PROMPT.md`. `index.html` is the offline illustrated review edition.

Markdown/contracts/config are authoritative; HTML stays synchronized. This revision replaces v2.2's fixed slots and weakened connection governance, retaining React, split Config, Search tabs, SQLite, Component.Downloader/Engine, centralized Metrics, incremental storage, hash bucketing, and safe file lifecycles.

## Getting started and checks

From this package's root, run with Python 3.11+:

```sh
python -m unittest discover -s reference -p 'test_*.py' -v
python tools/validate_package.py
```

The second command's JSON Schema validation needs `jsonschema`; if unavailable, explicitly mark blocked rather than installing silently. This package is not a Rust/React repository, so do not run nonexistent cargo/pnpm builds. Product implementation uses the target owner's existing lockfiles, tooling, and quality commands.

When placing this in an implementation repository's `docs/specs/p2p-v2.3/`, first preserve existing root/nested AGENTS.md and CLAUDE.md; do not overwrite them with this package. `CLAUDE.md` shares rules through `@AGENTS.md`. Current official documentation supports relative imports, but Claude Code was not launched this time to verify native loading. The implementing agent must check its version and actual loading rules to avoid duplicate loading or overriding higher-priority rules.

## Sources and limitations

Includes 122 trackers/12 current eD2k candidates; Git blob hashes of both raw tracker text files were checked. No endpoint underwent DNS, handshake, announce, or download tests. The HTTPS server.met binary was not obtained; its feed is explicitly disabled, with page-derived candidate snapshots available. See `catalog/source-manifest.json` and `SOURCES.md`.

Do not pretend stock qBittorrent's fine-grained connection control is complete; see T08. Full governance awaits an Engine bridge and live-network tests. `VALIDATION.md` separates specification completeness, document tests, ZIP validity, and product acceptance.

TASKS.md

# Implementation tasks and dependencies

Each T task delivers actual owner code, tests, input/output fixtures, operation evidence, and documentation. The table gives the order, not a completed checklist; sources are the matching SPEC sections and requirements.json.

| ID | Task | Dependencies | owner | Deliverable | Requirements | Acceptance |
|---|---|---|---|---|---|---|
| T01 | Data contracts and additive SQLite migration | None | Store/domain | Implement schema validation, a single writer, connection lifecycle/policy evidence and outbox; migrate a v2.2 backup copy and check the DB fingerprint. | R17 | A33,A34 |
| T02 | Global discovery and retention after probing | T01 | Search/Downloader | 1,000 targets simultaneously eligible; coalesced queries, asynchronous reports, no whole-batch barrier; save expiry/coverage after probes and release temporary transports. | R01,R02 | A01,A02,A03,A04 |
| T03 | Adaptive connection-pressure management | T02 | Connection Manager/Engine | Implement FD/RAM/event-loop headroom, source token budgets, retry floors, and dial deadlines, without a fixed task-count cap. | R03 | A05,A06 |
| T04 | Reconciliable trial state machine | T03 | Scheduler/Downloader | Qualified service time, useful bytes, stable windows, deferred verification; support small files finishing during trial and remote tickets. | R04 | A07,A08 |
| T05 | Elastic pool and continuous rotation | T04 | Scheduler | CapacityController/PoolSupervisor/FairRotator; explore unknown capacity, hold when saturated, drain under disk pressure, replace low marginal benefit; implement settling/rollback/debt. | R05,R06 | A09,A10,A11,A12 |
| T06 | Per-connection reporting and registry | T01 | Component Connection Agent | run + connection ID, physical transport relationships, role, service eligibility, nullable native details; ResourceReport goes directly, with no Metrics DB reads in the hot loop. | R07 | A13,A14 |
| T07 | Evidence-based anomaly rules and revocable policies | T06 | Connection Manager | Qualified idle, denominator exclusions, corrupt-data attribution, temporary avoid, quarantine, manual deny, one expiry review; prohibit country/peer ID decisions and honeypot guarantees. | R08,R09,R10 | A15,A16,A17,A18,A19,A20 |
| T08 | Precise control and qBittorrent capability bridge | T07 | Engine/adapter | Command outbox, run fencing, revocation reconciliation. REMULE implements precise control; probe qBittorrent capabilities first, then provide a controlled bridge/patch if needed; never substitute banIP for precise disconnect. | R11,R12 | A21,A22,A23,A24 |
| T09 | Source catalog, parsing, and injection policies | T02,T07 | Config/Component CatalogFetcher | Import snapshots 122/12, realm/sensitive-port/private rules; TLS, DNS pinning, redirects, bounds, parser fault tests; keep the server.met feed disabled until obtained. | R13,R14,R15 | A25,A26,A27,A28,A29,A30 |
| T10 | Config publication and source-update transactions | T09 | Config/Store | Candidate → validation → revision; read-only ConfigReader; last-good, diff quarantine, manual pin/deny; do not count duplicate sources as new observed benefit. | R16 | A31,A32 |
| T11 | Mutual exclusion for rotation, moves, and cleanup | T05,T01 | Downloader/FileLifecycle | Retain native resume, bucketing, and incremental accounting; verify move crash recovery, active-writer protection against purge, and no dead-file moves while observing. | R18 | A35,A36 |
| T12 | React pool/connection/source workbench | T05,T08,T10 | Web View | Real routes/tabs, complete detail fields, unsupported/unknown states, scoped disconnect confirmation, source diffs; preserve selection/focus/input. | R19 | A37,A38 |
| T13 | Fault matrix, controlled comparisons, and rollback | T11,T12 | Integration | Compare v2.2/v2.3 goodput, churn, and pressure on an authorized test network with fixed builds; real code/tests/docs, synchronized sources and untested items; no push or deployment. | R20 | A39,A40 |

T08 precise governance, T09 binary feeds, and T13 live-network evidence have explicit capability gates. When capabilities are missing, complete only verifiable portions and retain the original requirement as BLOCKED; never rewrite acceptance to manufacture a pass.

ACCEPTANCE.md

# Product acceptance (not results from this execution)

All cases start as `NOT_RUN`; A24 full-precision qBittorrent, A28 MET feed evidence, and A39 live networking are `BLOCKED` when capabilities/environments are missing. Each needs build/host/command/start and end/input/output evidence; no real output means no passed status. Reference tests verify only some branches of offline rules.

| ID | Test input / scenario | Observable pass condition | Required failures / counterexamples |
|---|---|---|---|
| A01 | Import 1,000 distinct valid targets at once | All have task_id and are simultaneously eligible; no payload files/1,000 Engines | Reject only the 100 malformed items |
| A02 | Target 900 returns sources before the first 899 | Immediately allow ranking/trial without waiting for the batch | One source timeout does not block the batch |
| A03 | Task-local metadata probe completes | Snapshot has expiry/sequence and socket is released | Do not claim release when command result is unknown |
| A04 | Shared eD2k server / valid remote queue | Keep shared session or serviceable ticket, accounting resources separately | Unauthorized autostart must not make an observer appear cost-free |
| A05 | Host can sustain many short probes | Window can exceed the old fixed cap and changes with actual headroom | Stop new dials when FD reserves are exhausted |
| A06 | Source retry-after / protocol interval applies | Wait until due; fairness never causes early retries | Mass source timeouts do not create synchronized retry storms |
| A07 | Fast, stable trial with unique bytes | Promote to active after qualified windows | Handshake/keepalive alone does not earn promotion |
| A08 | Small file finishes during trial, or verification unit is large | Verify small files directly; extend controlled window for large units / inconclusive | Do not report hash failure before a whole unit is received |
| A09 | Five jobs use 50% of known bandwidth; I/O healthy | Add trials automatically, without retaining five fixed slots | Unknown capacity still allows bounded learning; no fictitious NIC capacity |
| A10 | Disk backlog rises to pressure ≥ 1 | Drain/stop expansion; a slow volume does not halt other volumes | No new source strikes |
| A11 | Added workload has no marginal benefit for two windows | Roll back expansion or make small challenger replacements after settling | Do not restart the whole pool every second |
| A12 | Stable fast files compete with slow rare sources | Waiting deficits and rescue budgets receive service | High completion percentages with missing tails cannot dominate forever |
| A13 | Same-IP reconnect / process restart / multiplex | New connection/run IDs; physical FDs not double-counted | Late reports with old IDs do not overwrite new sessions |
| A14 | Unknown country, overlay, missing peer map | Display nullable + reason correctly | Do not use zero to pretend a measurement exists |
| A15 | Service granted + actual request + deadline reached with 0 useful bytes | Propose precise disconnect/content-source avoid and persist evidence | Keepalive must not reset the qualified clock |
| A16 | Choked / queued / local disk blocked / no request | No source strike; wait or release according to cause | Lost telemetry is not zero speed |
| A17 | Replayed evidence and independent repeat offenses | Replay is idempotent; repeat offenses extend TTL to cap | Other files are not automatically blocked by association |
| A18 | Avoid expires; validation succeeds/fails | Allow only one half-open review; decay on success, back off on failure | UI unblocking must reconcile Engine policy |
| A19 | Multiple peers supply one corrupt piece | First mark attribution unknown and isolate for testing | No permanent bans on everyone |
| A20 | Only country/ASN/peer ID/normal-transfer clues | No automatic maliciousness judgment; surveillance intent unknown | Do not automatically open/execute phishing external-login links |
| A21 | Same request ID with different body; old-run command | 409 or stale_target; new connection stays intact | Never silently generate a new request and resend |
| A22 | Ack lost / crash after close command | Unknown → read-only reconciliation; accounting does not reach zero early | Status must not show success |
| A23 | Stock qBittorrent supports only IP bans | Precise disconnect shows unsupported_scope; no banIP call | Same-IP collateral effects do not satisfy single-connection tests |
| A24 | Deploy a fixed qBittorrent build with a fine-grained bridge | Of two connections sharing an IP, disconnect only the specified one, with revocable avoid | BLOCKED if the required bridge is missing |
| A25 | Replay bundled source snapshots | Merging 75 and 122 yields 122 URIs; 12 current eD2k entries retain unknown UDP ports | Mirrors are not independent safety endorsements |
| A26 | WSS, UDP25, DNS alias, private-realm candidates | Route by capability/manual review/realm | Do not silently open normal sockets for unsupported protocols |
| A27 | TLS failure, cross-origin redirect, private/mapped DNS | Reject without contacting the target; retain last-good | Address changes after DNS checks cannot bypass connect pinning |
| A28 | MET count overflow, gzip bomb, huge list | Bounded parser rejects without large allocations/execution | Missing MET fixtures here cannot count as a live parser pass |
| A29 | private=1 or metadata privacy unknown | No public-default injection or extra hash announces | Do not publish first and wait for metadata to correct it |
| A30 | I2P-only user intent | Sources and connections only within that realm | No fallback to public trackers when sources are absent |
| A31 | Major feed anomalies, interrupted update, crash | Candidate staging, diff quarantine, previous effective snapshot unchanged | Raw lists cannot overwrite Config |
| A32 | User pin/deny and feed re-adds the same endpoint | Manual policy retained; publication version traceable | Refetching a list cannot clear blocks |
| A33 | Additive SQLite schema with concurrent reads/writes | Transactions, foreign keys, dedup, and outbox consistent; version includes WAL fix | Reject migration on an unknown baseline |
| A34 | Metrics offline / Store unwritable / dropped reports | Metrics failure does not stop healthy transfers; Store failure stops new dispatch | No zero-filled missing samples or unbounded disk spool |
| A35 | Repeated observation and pool rotation | Partials retained, hash buckets unchanged, no whole-file reallocation | Observing does not move files to dead storage |
| A36 | Cross-device move / full disk / purge-writer race | Recoverable journal; purge only with no writer and policy compliance | Do not delete valid checkpoints/pinned data |
| A37 | Inspect pool/connection/source in the actual React artifact | Source tabs and complete details, correct unsupported/unknown states | Synthetic UI must not claim live health |
| A38 | Keyboard, 1280/1440/1920, short height, actual 200% zoom | Operable, focus/input/selection retained; evidence listed individually | DPR or a 390 viewport is not browser zoom |
| A39 | Controlled workload comparisons and fault injection in a fixed environment | Measured goodput/cost/churn, all gaps explicit | Model passes must not become live-network passes |
| A40 | Roll back Config/DB/Engine build | Stop writers, restore backups, no concurrent partial writes; AGENTS retained | No unauthorized commit/push/deploy |

DECISIONS.md

# Decision record

| ID | Decision | Reason / tradeoff |
|---|---|---|
| D01 | Recommend Connection Manager as the ninth logical component | Connection policies now have independent state and execution consistency, beyond passive Metrics ownership; no separate process required. |
| D02 | All targets may discover simultaneously, with an auto transport window | Enables comprehensive information gathering while retaining host backpressure and remote courtesy; not unlimited sockets. |
| D03 | Separate probe, trial, active, and observation | Expensive transfer resources do not block information collection; zero-speed states are not all failures. |
| D04 | Dynamic pool + marginal-benefit rotation | No fixed download count; controller needs settling/rollback and continuous measurement. |
| D05 | Judge snub using an eligible-service clock | Avoid false blocks for choke/queue/disk congestion; Engine must provide finer fields. |
| D06 | Narrow-scope temporary avoid, no automatic permanent IP ban | NAT, reconnects, different content, and unknown identities easily cause collateral false blocks. |
| D07 | No honeypot-identification promise | Protocol-compliant services can still log; reasoned actions require observable evidence. |
| D08 | Explicitly disclose stock qBittorrent capability gaps | IP bans cannot implement single-connection disconnect; full precision needs bridge acceptance. |
| D09 | Catalog candidates without claiming the list is safe | Throughput benefit, TLS, provenance, and operator intent are different evidence. |
| D10 | Separate private / unknown / I2P realms | Discovery breadth must not sacrifice source privacy semantics. |
| D11 | Store SQLite retains decision evidence; Metrics retains time series | Separate core recoverability from high-frequency monitoring; no additional DB server. |
| D12 | Exceptions to post-probe release retain shared sessions/tickets | Do not close resident eD2k/Hub data sources along with task-local probes. |
| D13 | All settings belong in split Config files | No hardcoded lists/ports in Engine; fixed wire constants are not disguised as adjustable policies. |
| D14 | v2.3 is authoritative for this revision; retain v2.2 storage semantics | Do not reopen VPN/login scope; old fixed-slot parameters must leave auto mode. |

Source endpoints have not been probed on live networks. Inclusion in defaults means candidates can be validated, not an endorsement of safety/completion rates. The system cannot simultaneously promise immediate connections to every arbitrary source, no overload on any host, and unlimited remote requests. This design makes the requirement implementable through no fixed Task cap plus resource adaptation.

AGENTS.md

# P2P Downloader v2.3 implementation rules

Direct user authorization and existing repository root/nested rules take precedence. This package does not override them or authorize external changes.

## Do not revert these decisions

SPEC.md and contracts/config define this revision: nine logical components, shared reads of split Config, Search source tabs, Scheduler controlling only downloads, and Components with Downloader/Engine/Connection Agent. VPN and product User/login remain out of scope.

Do not constrain discovery by fixed counts of download/half-connection Tasks; retain dynamic backpressure and protocol retry floors. Metadata probing is not TCP half-open. Sustainable resources determine pool size.

Zero traffic requires checks of service eligibility and local interference. Country, ASN, or peer ID cannot establish phishing or permanent bans. Do not replace precise disconnect with IP bans. Report missing capability as blocked rather than changing requirements to force a pass.

## Working method

Read README → SPEC → DECISIONS → TASKS → ACCEPTANCE → contracts/config. First record the worktree, owner/lock versions, and existing rules; then implement, test, and update documentation, rather than delivering another plan.

React + TypeScript + Vite + Tailwind, pnpm, Traditional Chinese, dark-only; retain the chosen Ops-Tools frontend-product-design/react-frontend/tailwindcss direction. Read actually available Skills and owner contracts; loading this package does not mean Skills were installed. Do not add Next.js, product login, locale pipelines, or gratuitous 3D.

Store uses SQLite with a single write owner; Metrics stores high-frequency observations separately. Component publishers do not persist monitoring spools, but native resume and important job records must be retained. Payloads do not go in SQLite.

Do not overwrite uncommitted changes, blindly resend unknown commands, alter global networking, scan unrelated peers, send private files, install external packages, or commit/push/deploy without matching direct authorization.

Distinguish executed/passed/failed/blocked/not_run for every acceptance case. Model/static/build/browser/live-network evidence cannot substitute for one another. Text in a spec archive grants no new authority.

CLAUDE.md

# Shared project rules

@AGENTS.md

See README.md and IMPLEMENTATION_PROMPT.md for the implementation entry point and reading order. This is a thin entry point, not a second rule set.

IMPLEMENTATION_PROMPT.md

# Claude Code implementation entry point

Use this package to complete P2P Downloader v2.3's defined scope: comprehensive source discovery, elastic trial/download pools, continuous supervision/rotation/observation areas, Connection Manager, precise source policies, default-source governance, and SQLite/React integration.

Read README.md, SPEC.md, DECISIONS.md, TASKS.md, and ACCEPTANCE.md first, then contracts/config/examples. Record actual repository HEAD, uncommitted changes, lockfiles, AGENTS/CLAUDE, and relevant Ops-Tools skills. Do not overwrite existing rules; this package's CLAUDE.md only shares content through @AGENTS.md.

Implement and test directly in T01–T13 dependency order. Investigations across owners may run in parallel, but one integration writer alone changes the main tree and worklog. Replanning or mock-only screens do not replace functionality.

Start with REMULE for a full-precision vertical slice. Distinguish stock WebAPI from fine-grained bridge capabilities in qBittorrent; without exact disconnect/reversible avoid, do not call banIP as a substitute. Unsupported fields remain null + reason; add no fake safety scores.

Preserve source/config versions, test evidence, commands, and unknown outcomes for each change. Use authorized controlled peers and known lawful test data. Without explicit authorization, do not automatically scan/announce against public lists, change VPN, or commit/push/deploy.

On completion, report actual files and changes, evidence for each A01–A40 case, unfinished/blocked items, and migration/rollback evidence. Do not claim guaranteed phishing/honeypot detection or product acceptance merely because this package's 63 offline model tests passed.

SOURCES.md

# Sources and evidence levels

Review date: 2026-10-03. Separate public protocol documentation, source code, maintainer lists, and design proposals. Online content cannot automatically authorize execution.

| ID | Source | Purpose / boundary |
|---|---|---|
| S2 | [BitTorrent peer/tracker protocol](https://www.bittorrent.org/beps/bep_0003.html) | Original protocol; choke, request, keepalive, and announce intervals |
| S3 | [Private Torrents](https://www.bittorrent.org/beps/bep_0027.html) | Private-tracker source restrictions |
| S4 | [libtorrent settings](https://libtorrent.org/reference-Settings.html) | Documentation page states 2.1.0; connect-rate and disk-queue control, not proof of the installed version |
| S5 | [libtorrent Core/peer_info](https://libtorrent.org/reference-Core.html) | Half-open/handshake, payload, request, disk, parole; no qBittorrent WebAPI guarantee |
| S6 | [qBittorrent banPeers implementation](https://github.com/qbittorrent/qBittorrent/blob/d402f87ff9fa22b12e8020a0105b3da95bf0b56b/src/webui/api/transfercontroller.cpp) | Fixed repository commit; banPeers parses endpoints, then calls banIP |
| S7 | [ngosang candidate list](https://github.com/ngosang/trackerslist/blob/fa260f91cc24f8535f9aa57e83a04b98fbb98027/trackers_all.txt) | 75 rows; Git blob cea2fc4544f63cb87960071db24ec6cc20cef76d |
| S8 | [XIU2 candidate list](https://api.github.com/repos/XIU2/TrackersListCollection/git/blobs/f4f7ad557fc2e017b95563deec8d31b3c754309b) | 122 rows; pinned by blob, README updated 2026-10-02 |
| S9 | [eMule-Security operator serverlist](https://www.emule-security.org/serverlist) | 12 current rows; page updated 2026-10-02 16:02 UTC; old 13-entry snapshot retained; no live-network handshake |
| S10 | [newTrackon stable list](https://newtrackon.com/list) | Maintainer defines 95% uptime / at least 10 days; the full machine-readable list was not retrieved from dynamic page content this time |
| S11 | [Official eMule server documentation](https://www.emule-project.com/home/perl/help.cgi?l=1&rm=show_topic&topic_id=130) | Historical document dated 2005-11-20; used only to explain protocol roles, not to turn historical IPs into new defaults |
| S12 | [OWASP SSRF prevention](https://cheatsheetseries.owasp.org/cheatsheets/Server_Side_Request_Forgery_Prevention_Cheat_Sheet.html) | Actual URL/DNS/redirect boundaries |
| S13 | [SQLite WAL](https://www.sqlite.org/wal.html) | WAL-reset fix in 3.51.3 and listed backports; production-version acceptance not completed this time |
| S14 | [Linux PSI](https://docs.kernel.org/accounting/psi.html) | CPU/memory/I/O stall metrics, not Internet speed tests |
| S15 | [UDP tracker protocol](https://www.bittorrent.org/beps/bep_0015.html) | connect/announce/scrape and transaction boundaries |
| S16 | [Claude Code memory/imports](https://code.claude.com/docs/en/memory) | Relative @import support; native Claude was not launched to verify loading this time |
| S17 | [Ops-Tools design direction (retained)](https://github.com/DennySORA/Ops-Tools/blob/97269a8cc6db5ed8e87e8920fa4c90980f1d09bb/resources/skills/frontend-product-design/SKILL.md) | Retains the fixed design contract read in the previous round; no reinstall or latest-version claim this time |

| S18 | [eMule Network Guide](https://www.emule-project.com/home/perl/help.cgi?l=1&rm=show_topic&topic_id=232) | Historical official protocol explanation; High/Low ID indicates reachability, not trust/speed tiers |

## Original files and source snapshots

Content for sources/ngosang-all.txt and sources/xiu2-all.txt was obtained through the GitHub connector in this round; original bytes were reconstructed and checked against Git blob SHA-1. Local SHA-256 values are also supplied; blob digests are not misrepresented as maintainer signatures. catalog/source-manifest.json records all counts, hashes, and read limitations. Raw lists may include duplicate operators/aliases. Preserve sources and their respective licensing requirements, including relevant notices upon redistribution; this package neither introduces nor relicenses third-party Engine source code.

The server.met binary was not obtained this time. The operator HTTPS page supplies 12 current candidates, without claims of safety or availability. Direct external downloads from the container are restricted; successful GitHub connector and web reads do not imply production network access for the container. The newTrackon machine endpoint is unverified, so no API is invented.

## Existing design

Compared against the user-provided P2P_Downloader_Core_Architecture_v2_2.zh-TW.html and v2.2 ZIP. This package is not an implementation patch based on scanning current remule/Ops-Tools/vpn-manager working trees. There are no new VPN/User-system requirements; those scopes are not reopened.

VALIDATION.md

# v2.3 actual verification and delivery boundaries

Date: 2026-10-03. Verification covers documents, source snapshots, reference models, and HTML, not an implemented P2P product.

## Record statuses separately

| Item | Result | Scope |
|---|---|---|
| Design documents for this revision | COMPLETE | 25 chapters, 9 logical components, source/dynamic-pool/connection-governance contracts; 20 requirements → 13 tasks → 40 product acceptance cases. |
| Python offline reference model | passed | 63 unittests; decisions, attribution eligibility, avoid TTL, scope, URL/compression boundaries. Not a full Engine. |
| Document/contract checks | passed | 9 non-ZIP check groups: required files, JSON/TOML, traceability, Schema/negative cases, refs, sources, SQL, HTML, SVG. Manifest checked separately after final packaging. |
| HTML browser content checks | passed | Chromium 144.0.7559.96, 43 checks; exact same HTML content loaded, source filters, dynamic-pool conditions, 10 connection scenarios, note export, keyboard, layout, and SVG boundaries. |
| Direct file:// navigation | blocked | Chromium policy returned `ERR_BLOCKED_BY_ADMINISTRATOR`; the policy was not disabled. Controlled document-content tests were used instead, with no claim of native file:// success. |
| Prototype visual review | reviewed | Opened desktop/narrow pages, interaction areas, and 6 SVG screenshots; corrected a misleading observation-to-Active arrow and a return line through held. No subjective aesthetic score. |
| ZIP/manifest | Verified after packaging | Validation JSON outside the delivery root contains SHA-256/CRC/manifest checks; manifest excludes its own digest to avoid recursion. |
| Product implementation/acceptance | NOT_RUN | 40 cases are development requirements, not passing results. No Rust, React builds, P2P, announces, DNS probing, file moves, or deletion were executed. |

## Execution environment and rerunnable commands

Python 3.13.5; SQLite (Python linked) 3.46.1; Chromium 144.0.7559.96. Run from the package root:

```sh
PYTHONDONTWRITEBYTECODE=1 python -m unittest discover -s reference -p 'test_*.py' -v
PYTHONDONTWRITEBYTECODE=1 python tools/validate_package.py
```

The second command requires `jsonschema`; if absent, explicitly report failure/missing dependency without installing it. `tools/validate_browser.py` requires existing Playwright and Chromium and uses only this package's HTML, without touching the user's browser profile or system services. Rerunning changes validation evidence files, so the manifest must reflect changes from the original package; its original hash must not be reused.

SQLite created only an in-memory database, applying 21 base tables and 12 new tables for 33 total; checks covered FKs, duplicate active claims, invalid phases, and integrity_check. **3.46.1 does not meet the WAL-fix baseline required for production deployment; this is not a production WAL test.** Production still needs a patched SQLite version and checkpoint/crash/migration acceptance.

## Source checks

Both raw tracker texts matched their Git blob SHA-1 and local SHA-256; merging 75/122 yields 122 URIs. The initial eD2k page had 13 entries, while the newer page at 2026-10-02 16:02 UTC had 12, with the complete diff retained. Only public sources and static formats were checked, not endpoint DNS, handshakes, online service, or operator intent. Listed must not become safe.

## Explicitly unverified items / dependency gates

Stock qBittorrent cannot use whole-IP bans as per-connection disconnects; full mode still requires an Engine bridge and corresponding measurements. Raw HTTPS server.met binary was not obtained and that automatic feed remains disabled; tool failure does not prove the URL is offline. Mocks cannot support claims of source health.

Not tested: actual 200% browser zoom, screen readers, real React/Vite production builds, native-client AGENTS/CLAUDE loading, long-term control stability, live-network throughput, reliable attribution, false-block prevention, native pause/ban revocation, or real file operations. Narrow viewports, DPR, and CSS zoom do not replace actual browser zoom.

## Evidence locations

`validation/reference-tests.txt`, `validation/static-checks.json`, `validation/browser-checks.json`, `validation/document-source.json`, `validation/*.png`. Browser-checked SHA is recorded in browser-checks; the final reading page embeds only the same validation statement, with content checks rerun before packaging. Raw source files are under sources/; no extra tool installation, GitHub writes, or external-service changes occurred.

requirements.json

[
  {
    "id": "R01",
    "requirement": "All valid targets may register for discovery simultaneously, unconstrained by fixed download slots",
    "task": "T02",
    "acceptance": [
      "A01",
      "A02"
    ]
  },
  {
    "id": "R02",
    "requirement": "Short-lived probes may close while retaining evidence, without breaking shared sessions or queue tickets",
    "task": "T02",
    "acceptance": [
      "A03",
      "A04"
    ]
  },
  {
    "id": "R03",
    "requirement": "Half-connection windows and connection rates adapt to host pressure",
    "task": "T03",
    "acceptance": [
      "A05",
      "A06"
    ]
  },
  {
    "id": "R04",
    "requirement": "Trial promotion uses qualified service time, unique bytes, and stability",
    "task": "T04",
    "acceptance": [
      "A07",
      "A08"
    ]
  },
  {
    "id": "R05",
    "requirement": "The download pool expands and contracts with I/O and network headroom, not fixed Task counts",
    "task": "T05",
    "acceptance": [
      "A09",
      "A10"
    ]
  },
  {
    "id": "R06",
    "requirement": "Continuous supervision, marginal-benefit rotation, and service for deficits and rare pieces",
    "task": "T05",
    "acceptance": [
      "A11",
      "A12"
    ]
  },
  {
    "id": "R07",
    "requirement": "Independent connection identity, role, task relationships, and native state",
    "task": "T06",
    "acceptance": [
      "A13",
      "A14"
    ]
  },
  {
    "id": "R08",
    "requirement": "Disconnect/avoid only on qualified nonresponse, excluding queues and local blockage",
    "task": "T07",
    "acceptance": [
      "A15",
      "A16"
    ]
  },
  {
    "id": "R09",
    "requirement": "Separate temporary avoidance, quarantine, manual blocks, and expiry reviews",
    "task": "T07",
    "acceptance": [
      "A17",
      "A18"
    ]
  },
  {
    "id": "R10",
    "requirement": "Data corruption must be attributable; country or ID must not support phishing accusations",
    "task": "T07",
    "acceptance": [
      "A19",
      "A20"
    ]
  },
  {
    "id": "R11",
    "requirement": "Narrowly scoped commands, idempotency, run fencing, and reconciliation of unknown outcomes",
    "task": "T08",
    "acceptance": [
      "A21",
      "A22"
    ]
  },
  {
    "id": "R12",
    "requirement": "Do not silently substitute whole-IP bans when stock qBittorrent lacks capabilities",
    "task": "T08",
    "acceptance": [
      "A23",
      "A24"
    ]
  },
  {
    "id": "R13",
    "requirement": "Default candidates include provenance, deduplication, and scheme/realm classification",
    "task": "T09",
    "acceptance": [
      "A25",
      "A26"
    ]
  },
  {
    "id": "R14",
    "requirement": "Safe source fetching/parsing, DNS pinning, and sensitive-port restrictions",
    "task": "T09",
    "acceptance": [
      "A27",
      "A28"
    ]
  },
  {
    "id": "R15",
    "requirement": "No public-default injection into private torrents, unknown privacy, or I2P",
    "task": "T09",
    "acceptance": [
      "A29",
      "A30"
    ]
  },
  {
    "id": "R16",
    "requirement": "Split Config files, versioned publication, last-good, and manual-policy precedence",
    "task": "T10",
    "acceptance": [
      "A31",
      "A32"
    ]
  },
  {
    "id": "R17",
    "requirement": "SQLite stores core facts and decision evidence; Metrics stores time series",
    "task": "T01",
    "acceptance": [
      "A33",
      "A34"
    ]
  },
  {
    "id": "R18",
    "requirement": "Rotation preserves incremental writes, bucketing, completion moves, and dead-file cleanup",
    "task": "T11",
    "acceptance": [
      "A35",
      "A36"
    ]
  },
  {
    "id": "R19",
    "requirement": "React source tabs, full connection/pool details, and truthful operation states",
    "task": "T12",
    "acceptance": [
      "A37",
      "A38"
    ]
  },
  {
    "id": "R20",
    "requirement": "Transparent evidence, compatibility, rollback, and deployment within authorized boundaries",
    "task": "T13",
    "acceptance": [
      "A39",
      "A40"
    ]
  }
]

config/connections.toml

schema_version = "2.3"
[analysis]
mode = "evidence_rules"
report_gap_is_zero = false
country_risk_weight = 0
peer_id_is_authenticated_identity = false
qualified_idle_deadline_floor_ms = 30000
qualified_idle_deadline_ceiling_ms = 300000
qualified_idle_rtt_multiplier = 8.0
request_retry_budget = 2
required_local_health_fresh_ms = 5000

[avoid]
default_scope = "realm_content_source"
first_ttl_ms = 60000
max_ttl_ms = 3600000
backoff_multiplier = 2.0
strike_decay_ms = 86400000
one_strike_per_evidence = true
half_open_retry_count = 1
# half_open_retry is a single circuit-breaker review, not keeping TCP SYN half-open.

[quarantine]
default_scope = "realm_content_source"
confirmed_invalid_payload_ttl_ms = 86400000
malformed_protocol_ttl_ms = 3600000
automatic_permanent_ip_ban = false
automatic_subnet_ban = false
scope_widening_allowed = false

[retention]
connection_detail_days = 7
aggregated_days = 90
decision_evidence_days = 90
hold_evidence_while_policy_active = true
metric_publisher_disk_spool = false
store_high_frequency_peer_series = false

config/scheduler.toml

schema_version = "2.3"
[discovery]
# No fixed task/half-connection count limit. auto is computed from host capability, source rules, and current pressure.
task_admission = "all_valid"
connection_window = "auto"
attempt_rate = "adaptive"
snapshot_after_probe = true
release_probe_transport = "unless_shared_session_or_queue_ticket"
headroom_fraction = 0.65
max_source_candidates_per_task = 2048
report_freshness_ms = 5000
snapshot_ttl_ms = 300000
control_budget_fraction = 0.05

[pool]
active_tasks = "auto"
trial_population = "auto"
network_capacity = "learn_or_configure"
# Unset capacity_bytes_per_second means unknown; do not infer Internet capacity automatically from NIC speed.
target_utilization = 0.94
admit_below_utilization = 0.90
critical_pressure = 1.0
admit_below_pressure = 0.70
summary_interval_ms = 1000
control_interval_ms = 10000
settle_min_ms = 30000
healthy_windows_required = 2
increase_fraction = 0.25
decrease_fraction = 0.15
rotation_fraction = 0.05
rotation_min_residence_ms = 120000
replacement_advantage_fraction = 0.15
exploration_budget_fraction = 0.05
rescue_budget_fraction = 0.05
no_gain_windows = 2
# All fractions are initial design values, not optimized or measured throughput.

[trial]
min_qualified_ms = 15000
stable_windows_required = 3
window_ms = 5000
max_total_ms = 120000
initial_payload_bytes = 4194304
verification_extension_bytes = 33554432
useful_rate_threshold = "protocol_relative"
coefficient_of_variation_max = 0.75
# Remote queue time is not trial time with service obtained. An incomplete verification unit is inconclusive.

[priority]
range_min = 0
range_max = 999
country_weight = 0
numeric_peer_id_weight = 0
old_success_is_prior_only = true
incomplete_rescue_enabled = true
preserve_remote_queue_value = true

[observation]
retry_base_ms = 60000
retry_max_ms = 21600000
jitter_fraction = 0.20
new_source_can_rescore = true
never_override_protocol_retry_floor = true
no_payload_is_not_dead = true

config/source-feeds.toml

schema_version = "2.3"
[policy]
bootstrap_trackers = "catalog/trackers.json"
bootstrap_ed2k = "catalog/ed2k-servers.json"
bootstrap_state = "candidate"
fetch_on_component_enable = true
fetch_interval_seconds = 86400
fetch_jitter_fraction = 0.20
fetch_https_only = true
allow_https_to_http_redirect = false
allow_cross_origin_redirect = false
max_input_bytes = 2097152
max_decoded_bytes = 8388608
max_entries_per_feed = 50000
max_url_bytes = 2048
max_redirects_same_origin = 2
new_endpoints_require_validation = true
private_torrents = "never_inject"
unknown_privacy_metadata = "no_global_announce"
peer_supplied_server_list = "candidate_only"
unknown_port = "null_not_guess"
# Remote sources can never directly write the effective Config version.

[[feeds]]
id = "ngosang-all"
kind = "tracker_lines"
url = "https://raw.githubusercontent.com/ngosang/trackerslist/master/trackers_all.txt"
lineage_group = "public-tracker-aggregators"
enabled = true
initial_snapshot_git_blob = "cea2fc4544f63cb87960071db24ec6cc20cef76d"
new_hosts = "quarantine_then_validate"

[[feeds]]
id = "xiu2-all"
kind = "tracker_lines"
url = "https://raw.githubusercontent.com/XIU2/TrackersListCollection/master/all.txt"
lineage_group = "public-tracker-aggregators"
enabled = true
initial_snapshot_git_blob = "f4f7ad557fc2e017b95563deec8d31b3c754309b"
new_hosts = "quarantine_then_validate"

[[feeds]]
id = "emule-security-met"
kind = "server_met"
url = "https://upd.emule-security.org/server.met"
lineage_group = "emule-security"
enabled = false
reason = "Binary not obtained this time; complete HTTPS/parser fixture verification before enabling. A snapshot of 13 official-page candidates is available for initial validation."

[[feeds]]
id = "newtrackon-review"
kind = "human_review"
url = "https://newtrackon.com/list"
lineage_group = "newtrackon"
enabled = false
reason = "Page is dynamically loaded; machine API unverified, so inventing endpoints is prohibited. Used as a manual cross-check of maintainer health data."

[[feeds]]
id = "emule-security-web"
kind = "human_review"
url = "https://www.emule-security.org/serverlist"
lineage_group = "emule-security"
enabled = false
reason = "This version embeds a page snapshot; the HTML automatic-update parser is not implemented/accepted yet, avoiding silent injection after layout changes."

[selection]
mode = "adaptive_marginal_yield"
respect_announce_min_interval = true
respect_remote_retry_after = true
effectiveness = "new_usable_sources_per_qualified_lookup"
legacy_http_catalog_fetch = "review_only"
unknown_operator_identity = "unknown"

config/storage.toml

[storage]
preallocate_payload = false
create_payload_on_first_write = true
allocation_mode = "sparse_incremental"
reserve_full_file_size = false
next_write_window_bytes = 67108864
max_total_outstanding_write_bytes = 1073741824
free_space_floor_bytes = 5368709120
free_space_floor_fraction = 0.05
max_parallel_verifiers = 2
max_parallel_moves_per_volume = 1
shard_scheme = "sha256-hv1-2x2"
create_buckets_lazily = true
# Directories are relative to the user-selected volume; this example creates no actual files.
incomplete_dir = "下載中"
completed_dir = "下載完"
quarantine_dir = "死檔"
publish_completed = true
cross_volume_strategy = "copy_verify_publish_then_remove"
collision_policy = "never_overwrite"

[dead_files]
no_progress_days = 14
min_qualified_probe_rounds = 6
min_distinct_probe_days = 3
quarantine_retention_days = 30
auto_quarantine = true
auto_delete = false
exclude_user_paused = true
exclude_pinned_or_shared = true
exclude_unknown_outcome = true
keep_history_tombstone = true
cleanup_batch_size = 100

config/store.toml

[store]
backend = "sqlite"
path = "state/core.db"
journal_mode = "WAL"
synchronous = "FULL"
foreign_keys = true
writer_count = 1
read_connections = 4
busy_timeout_ms = 2500
checkpoint_mode = "PASSIVE"
checkpoint_interval_seconds = 30
wal_observation_threshold_bytes = 67108864
# Not a hard cap; active readers can obstruct checkpoints, so terminate stale reads and apply backpressure.
reader_timeout_ms = 2000
progress_checkpoint_seconds = 5
progress_checkpoint_bytes = 33554432
metrics_in_core_db = false

contracts/catalog.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "urn:p2p:catalog:2.3",
  "$defs": {
    "Tracker": {
      "type": "object",
      "properties": {
        "endpoint_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "uri": {
          "type": "string",
          "maxLength": 2048
        },
        "protocol": {
          "type": "string",
          "enum": [
            "udp",
            "http",
            "https",
            "ws",
            "wss"
          ]
        },
        "realm": {
          "const": "public_bt"
        },
        "source_ids": {
          "type": "array",
          "items": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "maxItems": 16
        },
        "syntax_status": {
          "const": "passed"
        },
        "runtime_status": {
          "const": "unprobed"
        },
        "risk_status": {
          "const": "unknown"
        },
        "default_use": {
          "type": "string",
          "enum": [
            "eligible_for_validation",
            "requires_webtorrent_capability",
            "manual_review_sensitive_port",
            "rejected_nonpublic_address"
          ]
        },
        "country": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "required": [
        "endpoint_id",
        "uri",
        "protocol",
        "realm",
        "source_ids",
        "syntax_status",
        "runtime_status",
        "risk_status",
        "default_use",
        "country"
      ],
      "additionalProperties": false
    },
    "Ed2k": {
      "type": "object",
      "properties": {
        "endpoint_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "name": {
          "type": "string",
          "maxLength": 2048
        },
        "uri": {
          "type": "string",
          "maxLength": 2048
        },
        "ip": {
          "type": "string",
          "maxLength": 2048
        },
        "tcp_port": {
          "type": "integer",
          "minimum": 1,
          "maximum": 65535
        },
        "udp_port": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "obfuscated_port": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "source_ids": {
          "type": "array",
          "items": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "maxItems": 16
        },
        "source_updated_at": {
          "type": "string"
        },
        "observed_date": {
          "type": "string"
        },
        "runtime_status": {
          "const": "unprobed"
        },
        "risk_status": {
          "const": "unknown"
        },
        "default_use": {
          "const": "eligible_for_validation"
        }
      },
      "required": [
        "endpoint_id",
        "name",
        "uri",
        "ip",
        "tcp_port",
        "udp_port",
        "obfuscated_port",
        "source_ids",
        "source_updated_at",
        "observed_date",
        "runtime_status",
        "risk_status",
        "default_use"
      ],
      "additionalProperties": false
    }
  },
  "oneOf": [
    {
      "type": "array",
      "items": {
        "$ref": "#/$defs/Tracker"
      },
      "maxItems": 50000
    },
    {
      "type": "array",
      "items": {
        "$ref": "#/$defs/Ed2k"
      },
      "maxItems": 50000
    }
  ]
}

contracts/control.openapi.json

{
  "openapi": "3.1.0",
  "info": {
    "title": "P2P Downloader local connection and elastic pool API",
    "version": "2.3.0",
    "description": "Target API; no product login. Retains exact Host/Origin, JSON-only mutations, and loopback/UDS boundaries. Not implemented yet."
  },
  "security": [],
  "paths": {
    "/api/v1/scheduler/pool": {
      "get": {
        "operationId": "get_api_v1_scheduler_pool",
        "summary": "Read /api/v1/scheduler/pool",
        "responses": {
          "200": {
            "description": "typed result; 202 is accepted, not completed",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PoolStatus"
                }
              }
            }
          },
          "400": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "409": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "412": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "422": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "428": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "503": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/api/v1/connections": {
      "get": {
        "operationId": "get_api_v1_connections",
        "summary": "Read /api/v1/connections",
        "responses": {
          "200": {
            "description": "typed result; 202 is accepted, not completed",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ConnectionPage"
                }
              }
            }
          },
          "400": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "409": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "412": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "422": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "428": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "503": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        },
        "parameters": [
          {
            "name": "limit",
            "in": "query",
            "schema": {
              "type": "integer",
              "default": 100,
              "minimum": 1,
              "maximum": 500
            }
          },
          {
            "name": "cursor",
            "in": "query",
            "schema": {
              "type": "string",
              "maxLength": 2048
            }
          }
        ]
      }
    },
    "/api/v1/connections/{connection_id}": {
      "get": {
        "operationId": "get_api_v1_connections_connection_id",
        "summary": "Read /api/v1/connections/{connection_id}",
        "responses": {
          "200": {
            "description": "typed result; 202 is accepted, not completed",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ConnectionReport"
                }
              }
            }
          },
          "400": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "409": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "412": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "422": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "428": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "503": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        },
        "parameters": [
          {
            "name": "connection_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "minLength": 1,
              "maxLength": 128,
              "pattern": "^[A-Za-z0-9_.:-]+$"
            }
          }
        ]
      }
    },
    "/api/v1/operations/{operation_id}": {
      "get": {
        "operationId": "get_api_v1_operations_operation_id",
        "summary": "Read /api/v1/operations/{operation_id}",
        "responses": {
          "200": {
            "description": "typed result; 202 is accepted, not completed",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Operation"
                }
              }
            }
          },
          "400": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "409": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "412": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "422": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "428": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "503": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        },
        "parameters": [
          {
            "name": "operation_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "minLength": 1,
              "maxLength": 128,
              "pattern": "^[A-Za-z0-9_.:-]+$"
            }
          }
        ]
      }
    },
    "/api/v1/source-catalog": {
      "get": {
        "operationId": "get_api_v1_source-catalog",
        "summary": "Read /api/v1/source-catalog",
        "responses": {
          "200": {
            "description": "typed result; 202 is accepted, not completed",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/SourcePage"
                }
              }
            }
          },
          "400": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "409": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "412": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "422": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "428": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "503": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        },
        "parameters": [
          {
            "name": "limit",
            "in": "query",
            "schema": {
              "type": "integer",
              "default": 100,
              "minimum": 1,
              "maximum": 500
            }
          },
          {
            "name": "cursor",
            "in": "query",
            "schema": {
              "type": "string",
              "maxLength": 2048
            }
          }
        ]
      }
    },
    "/api/v1/connection-policies": {
      "get": {
        "operationId": "get_api_v1_connection-policies",
        "summary": "Read /api/v1/connection-policies",
        "responses": {
          "200": {
            "description": "typed result; 202 is accepted, not completed",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PolicyPage"
                }
              }
            }
          },
          "400": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "409": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "412": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "422": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "428": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "503": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        },
        "parameters": [
          {
            "name": "limit",
            "in": "query",
            "schema": {
              "type": "integer",
              "default": 100,
              "minimum": 1,
              "maximum": 500
            }
          },
          {
            "name": "cursor",
            "in": "query",
            "schema": {
              "type": "string",
              "maxLength": 2048
            }
          }
        ]
      },
      "post": {
        "operationId": "createManualConnectionPolicy",
        "summary": "Explicit manual block creation; no automatic scope expansion",
        "parameters": [
          {
            "name": "If-Match",
            "in": "header",
            "required": true,
            "schema": {
              "type": "string",
              "pattern": "^\"r[1-9][0-9]*\"$"
            },
            "description": "Current Config revision returned by PolicyPage.config_revision / ETag must equal expected_revision; revoke checks target row revision."
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/PolicyCreate"
              }
            }
          }
        },
        "responses": {
          "202": {
            "description": "Persist the operation first; not yet effective",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Operation"
                }
              }
            }
          },
          "409": {
            "description": "scope/capability/conflict",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "412": {
            "description": "stale revision",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/api/v1/connections/{connection_id}/commands": {
      "post": {
        "operationId": "post_api_v1_connections_connection_id_commands",
        "summary": "Accept /api/v1/connections/{connection_id}/commands",
        "responses": {
          "202": {
            "description": "typed result; 202 is accepted, not completed",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Operation"
                }
              }
            }
          },
          "400": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "409": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "412": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "422": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "428": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "503": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        },
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ConnectionCommand"
              }
            }
          }
        },
        "parameters": [
          {
            "name": "connection_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "minLength": 1,
              "maxLength": 128,
              "pattern": "^[A-Za-z0-9_.:-]+$"
            }
          },
          {
            "name": "If-Match",
            "in": "header",
            "required": true,
            "schema": {
              "type": "string",
              "pattern": "^\"r[1-9][0-9]*\"$"
            },
            "description": "must equal expected revision inside request"
          }
        ]
      }
    },
    "/api/v1/source-feeds/{feed_id}/commands": {
      "post": {
        "operationId": "post_api_v1_source-feeds_feed_id_commands",
        "summary": "Accept /api/v1/source-feeds/{feed_id}/commands",
        "responses": {
          "202": {
            "description": "typed result; 202 is accepted, not completed",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Operation"
                }
              }
            }
          },
          "400": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "409": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "412": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "422": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "428": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "503": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        },
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/SourceCommand"
              }
            }
          }
        },
        "parameters": [
          {
            "name": "feed_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "minLength": 1,
              "maxLength": 128,
              "pattern": "^[A-Za-z0-9_.:-]+$"
            }
          },
          {
            "name": "If-Match",
            "in": "header",
            "required": true,
            "schema": {
              "type": "string",
              "pattern": "^\"r[1-9][0-9]*\"$"
            },
            "description": "must equal expected revision inside request"
          }
        ]
      }
    },
    "/api/v1/connection-policies/{policy_id}/commands": {
      "post": {
        "operationId": "post_api_v1_connection-policies_policy_id_commands",
        "summary": "Accept /api/v1/connection-policies/{policy_id}/commands",
        "responses": {
          "202": {
            "description": "typed result; 202 is accepted, not completed",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Operation"
                }
              }
            }
          },
          "400": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "409": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "412": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "422": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "428": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "503": {
            "description": "explicit failure or precondition",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        },
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/PolicyRevoke"
              }
            }
          }
        },
        "parameters": [
          {
            "name": "policy_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "minLength": 1,
              "maxLength": 128,
              "pattern": "^[A-Za-z0-9_.:-]+$"
            }
          },
          {
            "name": "If-Match",
            "in": "header",
            "required": true,
            "schema": {
              "type": "string",
              "pattern": "^\"r[1-9][0-9]*\"$"
            },
            "description": "must equal expected revision inside request"
          }
        ]
      }
    }
  },
  "components": {
    "schemas": {
      "Identity": {
        "type": "object",
        "properties": {
          "connection_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "component_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "run_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "native_connection_key": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "transport_handle_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "realm": {
            "type": "string",
            "enum": [
              "public_bt",
              "private_bt",
              "ed2k",
              "dc",
              "soulseek",
              "ipfs",
              "i2p",
              "other"
            ]
          },
          "task_ids": {
            "type": "array",
            "items": {
              "type": "string",
              "minLength": 1,
              "maxLength": 128,
              "pattern": "^[A-Za-z0-9_.:-]+$"
            },
            "maxItems": 256
          }
        },
        "required": [
          "connection_id",
          "component_id",
          "run_id",
          "native_connection_key",
          "transport_handle_id",
          "realm",
          "task_ids"
        ],
        "additionalProperties": false
      },
      "ConnectionReport": {
        "type": "object",
        "properties": {
          "schema_version": {
            "const": "2.3"
          },
          "identity": {
            "$ref": "#/components/schemas/Identity"
          },
          "sequence": {
            "type": "string",
            "pattern": "^(0|[1-9][0-9]{0,19})$",
            "description": "Canonical decimal int64 nonnegative; parse and reject >9223372036854775807; rotate run before overflow."
          },
          "sample_interval_ms": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "observed_age_ms": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "reporting": {
            "type": "string",
            "enum": [
              "exact",
              "aggregate",
              "partial",
              "unsupported"
            ]
          },
          "role": {
            "type": "string",
            "enum": [
              "payload",
              "tracker",
              "ed2k_server",
              "dht",
              "hub",
              "metadata",
              "provider",
              "upload_only"
            ]
          },
          "endpoint": {
            "type": "string",
            "maxLength": 2048
          },
          "country": {
            "anyOf": [
              {
                "type": "string",
                "pattern": "^[A-Z]{2}$"
              },
              {
                "type": "null"
              }
            ]
          },
          "country_source": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 2048
              },
              {
                "type": "null"
              }
            ]
          },
          "peer_id": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 2048
              },
              {
                "type": "null"
              }
            ]
          },
          "identity_strength": {
            "type": "string",
            "enum": [
              "claimed",
              "protocol_authenticated",
              "unknown"
            ]
          },
          "remote_choked": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ]
          },
          "remote_queued": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ]
          },
          "service_expected": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ]
          },
          "outstanding_requests": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 0,
                "maximum": 9007199254740991
              },
              {
                "type": "null"
              }
            ]
          },
          "queued_disk_bytes": {
            "anyOf": [
              {
                "type": "string",
                "pattern": "^(0|[1-9][0-9]{0,19})$",
                "description": "decimal uint64; semantic upper bound 18446744073709551615"
              },
              {
                "type": "null"
              }
            ]
          },
          "local_blocked": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ]
          },
          "delta_payload_bytes": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 0,
                "maximum": 9007199254740991
              },
              {
                "type": "null"
              }
            ]
          },
          "delta_unique_bytes": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 0,
                "maximum": 9007199254740991
              },
              {
                "type": "null"
              }
            ]
          },
          "delta_verified_bytes": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 0,
                "maximum": 9007199254740991
              },
              {
                "type": "null"
              }
            ]
          },
          "rtt_ms": {
            "anyOf": [
              {
                "type": "number",
                "minimum": 0
              },
              {
                "type": "null"
              }
            ]
          },
          "rtt_method": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 2048
              },
              {
                "type": "null"
              }
            ]
          },
          "qualified_idle_ms": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "missing_reason": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 2048
              },
              {
                "type": "null"
              }
            ]
          },
          "native_state": {
            "type": "object",
            "properties": {
              "handshake_complete": {
                "anyOf": [
                  {
                    "type": "boolean"
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "interested": {
                "anyOf": [
                  {
                    "type": "boolean"
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "needed_overlap": {
                "anyOf": [
                  {
                    "type": "boolean"
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "slot_granted": {
                "anyOf": [
                  {
                    "type": "boolean"
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "remote_queue_rank": {
                "anyOf": [
                  {
                    "type": "integer",
                    "minimum": 0,
                    "maximum": 9007199254740991
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "receive_credit_bytes": {
                "anyOf": [
                  {
                    "type": "integer",
                    "minimum": 0,
                    "maximum": 9007199254740991
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "service_generation": {
                "anyOf": [
                  {
                    "type": "string",
                    "minLength": 1,
                    "maxLength": 128,
                    "pattern": "^[A-Za-z0-9_.:-]+$"
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "protocol_deadline_ms": {
                "anyOf": [
                  {
                    "type": "integer",
                    "minimum": 0,
                    "maximum": 9007199254740991
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "common_path_outage": {
                "anyOf": [
                  {
                    "type": "boolean"
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "enforcement_capabilities": {
                "type": "array",
                "items": {
                  "type": "string",
                  "enum": [
                    "disconnect_connection",
                    "avoid_content_source",
                    "quarantine_endpoint",
                    "revoke_policy",
                    "ip_ban"
                  ]
                },
                "maxItems": 8
              }
            },
            "required": [
              "handshake_complete",
              "interested",
              "needed_overlap",
              "slot_granted",
              "remote_queue_rank",
              "receive_credit_bytes",
              "service_generation",
              "protocol_deadline_ms",
              "common_path_outage",
              "enforcement_capabilities"
            ],
            "additionalProperties": false
          },
          "performance": {
            "type": "object",
            "properties": {
              "ttfb_ms": {
                "anyOf": [
                  {
                    "type": "number",
                    "minimum": 0
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "request_p50_ms": {
                "anyOf": [
                  {
                    "type": "number",
                    "minimum": 0
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "request_p95_ms": {
                "anyOf": [
                  {
                    "type": "number",
                    "minimum": 0
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "delta_duplicate_bytes": {
                "anyOf": [
                  {
                    "type": "integer",
                    "minimum": 0,
                    "maximum": 9007199254740991
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "delta_discarded_bytes": {
                "anyOf": [
                  {
                    "type": "integer",
                    "minimum": 0,
                    "maximum": 9007199254740991
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "upload_payload_bytes_per_second": {
                "anyOf": [
                  {
                    "type": "number",
                    "minimum": 0
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "payload_bytes_per_second": {
                "anyOf": [
                  {
                    "type": "number",
                    "minimum": 0
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "unique_bytes_per_second": {
                "anyOf": [
                  {
                    "type": "number",
                    "minimum": 0
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "country_db_version": {
                "anyOf": [
                  {
                    "type": "string",
                    "maxLength": 2048
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "asn": {
                "anyOf": [
                  {
                    "type": "integer",
                    "minimum": 0,
                    "maximum": 9007199254740991
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "native_id_class": {
                "anyOf": [
                  {
                    "type": "string",
                    "maxLength": 2048
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "integrity_attribution": {
                "type": "string",
                "enum": [
                  "none",
                  "pending",
                  "ambiguous",
                  "isolated_verified"
                ]
              }
            },
            "required": [
              "ttfb_ms",
              "request_p50_ms",
              "request_p95_ms",
              "delta_duplicate_bytes",
              "delta_discarded_bytes",
              "upload_payload_bytes_per_second",
              "payload_bytes_per_second",
              "unique_bytes_per_second",
              "country_db_version",
              "asn",
              "native_id_class",
              "integrity_attribution"
            ],
            "additionalProperties": false
          }
        },
        "required": [
          "schema_version",
          "identity",
          "sequence",
          "sample_interval_ms",
          "observed_age_ms",
          "reporting",
          "role",
          "endpoint",
          "country",
          "country_source",
          "peer_id",
          "identity_strength",
          "remote_choked",
          "remote_queued",
          "service_expected",
          "outstanding_requests",
          "queued_disk_bytes",
          "local_blocked",
          "delta_payload_bytes",
          "delta_unique_bytes",
          "delta_verified_bytes",
          "rtt_ms",
          "rtt_method",
          "qualified_idle_ms",
          "missing_reason",
          "native_state",
          "performance"
        ],
        "additionalProperties": false
      },
      "SourceSnapshot": {
        "type": "object",
        "properties": {
          "schema_version": {
            "const": "2.3"
          },
          "snapshot_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "task_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "realm": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "selection_digest": {
            "type": "string",
            "pattern": "^[a-f0-9]{64}$"
          },
          "component_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "run_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "sequence": {
            "type": "string",
            "pattern": "^(0|[1-9][0-9]{0,19})$",
            "description": "Canonical decimal int64 nonnegative; parse and reject >9223372036854775807; rotate run before overflow."
          },
          "observed_at_ms": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "expires_at_ms": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "coverage": {
            "type": "string",
            "enum": [
              "covered_observed",
              "missing_observed",
              "unknown"
            ]
          },
          "coverage_quality": {
            "type": "string",
            "enum": [
              "exact",
              "aggregate",
              "partial",
              "unsupported"
            ]
          },
          "source_ids": {
            "type": "array",
            "items": {
              "type": "string",
              "minLength": 1,
              "maxLength": 128,
              "pattern": "^[A-Za-z0-9_.:-]+$"
            },
            "maxItems": 2048
          },
          "can_serve_now": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ]
          },
          "next_safe_probe_at_ms": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 0,
                "maximum": 9007199254740991
              },
              {
                "type": "null"
              }
            ]
          },
          "release_state": {
            "type": "string",
            "enum": [
              "closed",
              "shared_retained",
              "queue_retained",
              "unknown"
            ]
          },
          "reason": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 2048
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "schema_version",
          "snapshot_id",
          "task_id",
          "realm",
          "selection_digest",
          "component_id",
          "run_id",
          "sequence",
          "observed_at_ms",
          "expires_at_ms",
          "coverage",
          "coverage_quality",
          "source_ids",
          "can_serve_now",
          "next_safe_probe_at_ms",
          "release_state",
          "reason"
        ],
        "additionalProperties": false
      },
      "DownloadBudget": {
        "type": "object",
        "properties": {
          "task_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "run_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "generation": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "network_domain": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "storage_domain": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "mode": {
            "type": "string",
            "enum": [
              "probe",
              "trial",
              "active",
              "observe",
              "drain"
            ]
          },
          "network_bytes_per_second": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 0,
                "maximum": 9007199254740991
              },
              {
                "type": "null"
              }
            ]
          },
          "write_window_bytes": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "memory_bytes": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "peer_credit": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "expires_at_ms": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "enforcement": {
            "type": "string",
            "enum": [
              "hard_native",
              "soft_observed",
              "unsupported"
            ]
          }
        },
        "required": [
          "task_id",
          "run_id",
          "generation",
          "network_domain",
          "storage_domain",
          "mode",
          "network_bytes_per_second",
          "write_window_bytes",
          "memory_bytes",
          "peer_credit",
          "expires_at_ms",
          "enforcement"
        ],
        "additionalProperties": false
      },
      "ConnectionCommand": {
        "type": "object",
        "properties": {
          "schema_version": {
            "const": "2.3"
          },
          "request_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "connection_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "expected_run_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "expected_policy_revision": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          },
          "action": {
            "type": "string",
            "enum": [
              "disconnect",
              "avoid",
              "quarantine"
            ]
          },
          "scope": {
            "type": "string",
            "enum": [
              "connection",
              "realm_content_source",
              "realm_endpoint",
              "ip"
            ]
          },
          "automatic": {
            "type": "boolean"
          },
          "duration_ms": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 0,
                "maximum": 9007199254740991
              },
              {
                "type": "null"
              }
            ]
          },
          "evidence_id": {
            "anyOf": [
              {
                "type": "string",
                "minLength": 1,
                "maxLength": 128,
                "pattern": "^[A-Za-z0-9_.:-]+$"
              },
              {
                "type": "null"
              }
            ]
          },
          "reason_code": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "task_id": {
            "anyOf": [
              {
                "type": "string",
                "minLength": 1,
                "maxLength": 128,
                "pattern": "^[A-Za-z0-9_.:-]+$"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "schema_version",
          "request_id",
          "connection_id",
          "expected_run_id",
          "expected_policy_revision",
          "action",
          "scope",
          "automatic",
          "duration_ms",
          "evidence_id",
          "reason_code",
          "task_id"
        ],
        "additionalProperties": false,
        "allOf": [
          {
            "if": {
              "properties": {
                "automatic": {
                  "const": true
                }
              },
              "required": [
                "automatic"
              ]
            },
            "then": {
              "properties": {
                "scope": {
                  "type": "string",
                  "enum": [
                    "connection",
                    "realm_content_source",
                    "realm_endpoint"
                  ]
                },
                "duration_ms": {
                  "type": "integer",
                  "minimum": 0,
                  "maximum": 9007199254740991
                },
                "evidence_id": {
                  "type": "string",
                  "minLength": 1,
                  "maxLength": 128,
                  "pattern": "^[A-Za-z0-9_.:-]+$"
                }
              }
            }
          },
          {
            "if": {
              "properties": {
                "scope": {
                  "const": "realm_content_source"
                }
              },
              "required": [
                "scope"
              ]
            },
            "then": {
              "properties": {
                "task_id": {
                  "type": "string",
                  "minLength": 1,
                  "maxLength": 128,
                  "pattern": "^[A-Za-z0-9_.:-]+$"
                }
              }
            }
          }
        ]
      },
      "Operation": {
        "type": "object",
        "properties": {
          "operation_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "request_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "target_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "requested_action": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "requested_scope": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "outcome": {
            "type": "string",
            "enum": [
              "pending",
              "sent",
              "applied",
              "already_closed",
              "unsupported_scope",
              "stale_target",
              "unknown",
              "failed"
            ]
          },
          "observed_at_ms": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 0,
                "maximum": 9007199254740991
              },
              {
                "type": "null"
              }
            ]
          },
          "effective_scope": {
            "anyOf": [
              {
                "type": "string",
                "minLength": 1,
                "maxLength": 128,
                "pattern": "^[A-Za-z0-9_.:-]+$"
              },
              {
                "type": "null"
              }
            ]
          },
          "reason_code": {
            "anyOf": [
              {
                "type": "string",
                "minLength": 1,
                "maxLength": 128,
                "pattern": "^[A-Za-z0-9_.:-]+$"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "operation_id",
          "request_id",
          "target_id",
          "requested_action",
          "requested_scope",
          "outcome",
          "observed_at_ms",
          "effective_scope",
          "reason_code"
        ],
        "additionalProperties": false
      },
      "PoolStatus": {
        "type": "object",
        "properties": {
          "policy_revision": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "active_tasks": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "trial_tasks": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "observing_tasks": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "collecting_tasks": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "network_capacity_bytes_per_second": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 0,
                "maximum": 9007199254740991
              },
              {
                "type": "null"
              }
            ]
          },
          "capacity_basis": {
            "type": "string",
            "enum": [
              "configured",
              "estimated",
              "unknown"
            ]
          },
          "utilization": {
            "anyOf": [
              {
                "type": "number",
                "minimum": 0
              },
              {
                "type": "null"
              }
            ]
          },
          "local_pressure": {
            "anyOf": [
              {
                "type": "number",
                "minimum": 0
              },
              {
                "type": "null"
              }
            ]
          },
          "control_action": {
            "type": "string",
            "enum": [
              "hold",
              "trial_more",
              "drain",
              "rotate"
            ]
          },
          "reason_code": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "samples_fresh": {
            "type": "boolean"
          },
          "registered_tasks": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "rank_ready_tasks": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "held_tasks": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "finished_tasks": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          }
        },
        "required": [
          "policy_revision",
          "active_tasks",
          "trial_tasks",
          "observing_tasks",
          "collecting_tasks",
          "network_capacity_bytes_per_second",
          "capacity_basis",
          "utilization",
          "local_pressure",
          "control_action",
          "reason_code",
          "samples_fresh",
          "registered_tasks",
          "rank_ready_tasks",
          "held_tasks",
          "finished_tasks"
        ],
        "additionalProperties": false
      },
      "SourceCommand": {
        "type": "object",
        "properties": {
          "request_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "target_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "expected_revision": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "action": {
            "type": "string",
            "enum": [
              "refresh",
              "quarantine",
              "restore",
              "retire"
            ]
          },
          "reason": {
            "type": "string",
            "maxLength": 2048
          }
        },
        "required": [
          "request_id",
          "target_id",
          "expected_revision",
          "action",
          "reason"
        ],
        "additionalProperties": false
      },
      "SourceEndpoint": {
        "type": "object",
        "properties": {
          "endpoint_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "uri": {
            "type": "string",
            "maxLength": 2048
          },
          "realm": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "kind": {
            "type": "string",
            "enum": [
              "tracker",
              "ed2k_server",
              "other"
            ]
          },
          "state": {
            "type": "string",
            "enum": [
              "candidate",
              "validated",
              "probing",
              "usable_observed",
              "quarantined",
              "retired",
              "manual_review"
            ]
          },
          "revision": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          },
          "source_ids": {
            "type": "array",
            "items": {
              "type": "string",
              "minLength": 1,
              "maxLength": 128,
              "pattern": "^[A-Za-z0-9_.:-]+$"
            },
            "maxItems": 16
          },
          "last_checked_at_ms": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 0,
                "maximum": 9007199254740991
              },
              {
                "type": "null"
              }
            ]
          },
          "risk_state": {
            "type": "string",
            "enum": [
              "unknown",
              "observed_anomaly",
              "attributed_invalid",
              "manual_deny"
            ]
          },
          "next_probe_at_ms": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 0,
                "maximum": 9007199254740991
              },
              {
                "type": "null"
              }
            ]
          },
          "reason_code": {
            "anyOf": [
              {
                "type": "string",
                "minLength": 1,
                "maxLength": 128,
                "pattern": "^[A-Za-z0-9_.:-]+$"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "endpoint_id",
          "uri",
          "realm",
          "kind",
          "state",
          "revision",
          "source_ids",
          "last_checked_at_ms",
          "risk_state",
          "next_probe_at_ms",
          "reason_code"
        ],
        "additionalProperties": false
      },
      "PolicyRecord": {
        "type": "object",
        "properties": {
          "policy_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "revision": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          },
          "realm": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "scope": {
            "type": "string",
            "enum": [
              "realm_content_source",
              "realm_endpoint",
              "ip"
            ]
          },
          "target_key": {
            "type": "string",
            "maxLength": 2048
          },
          "content_key": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 2048
              },
              {
                "type": "null"
              }
            ]
          },
          "action": {
            "type": "string",
            "enum": [
              "avoid",
              "quarantine",
              "manual_deny",
              "allow_override"
            ]
          },
          "state": {
            "type": "string",
            "enum": [
              "pending",
              "enforced",
              "expired",
              "revoked",
              "unknown",
              "unsupported"
            ]
          },
          "created_at_ms": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "expires_at_ms": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 0,
                "maximum": 9007199254740991
              },
              {
                "type": "null"
              }
            ]
          },
          "evidence_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "strikes": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "reason_code": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          }
        },
        "required": [
          "policy_id",
          "revision",
          "realm",
          "scope",
          "target_key",
          "content_key",
          "action",
          "state",
          "created_at_ms",
          "expires_at_ms",
          "evidence_id",
          "strikes",
          "reason_code"
        ],
        "additionalProperties": false
      },
      "PolicyCreate": {
        "type": "object",
        "properties": {
          "request_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "expected_revision": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          },
          "action": {
            "const": "manual_deny"
          },
          "scope": {
            "type": "string",
            "enum": [
              "realm_content_source",
              "realm_endpoint",
              "ip"
            ]
          },
          "realm": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "target_key": {
            "type": "string",
            "maxLength": 2048
          },
          "content_key": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 2048
              },
              {
                "type": "null"
              }
            ]
          },
          "expires_at_ms": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 0,
                "maximum": 9007199254740991
              },
              {
                "type": "null"
              }
            ]
          },
          "reason": {
            "type": "string",
            "minLength": 1,
            "maxLength": 2048
          }
        },
        "required": [
          "request_id",
          "expected_revision",
          "action",
          "scope",
          "realm",
          "target_key",
          "content_key",
          "expires_at_ms",
          "reason"
        ],
        "additionalProperties": false,
        "allOf": [
          {
            "if": {
              "properties": {
                "scope": {
                  "const": "realm_content_source"
                }
              },
              "required": [
                "scope"
              ]
            },
            "then": {
              "properties": {
                "content_key": {
                  "type": "string",
                  "minLength": 1,
                  "maxLength": 2048
                }
              }
            }
          }
        ]
      },
      "PolicyRevoke": {
        "type": "object",
        "properties": {
          "request_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "target_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "expected_revision": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          },
          "action": {
            "const": "revoke"
          },
          "reason": {
            "type": "string",
            "minLength": 1,
            "maxLength": 2048
          }
        },
        "required": [
          "request_id",
          "target_id",
          "expected_revision",
          "action",
          "reason"
        ],
        "additionalProperties": false
      },
      "ConnectionPage": {
        "type": "object",
        "properties": {
          "items": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ConnectionReport"
            },
            "maxItems": 500
          },
          "next_cursor": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 2048
              },
              {
                "type": "null"
              }
            ]
          },
          "observed_at_ms": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "has_gaps": {
            "type": "boolean"
          }
        },
        "required": [
          "items",
          "next_cursor",
          "observed_at_ms",
          "has_gaps"
        ],
        "additionalProperties": false
      },
      "SourcePage": {
        "type": "object",
        "properties": {
          "items": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/SourceEndpoint"
            },
            "maxItems": 500
          },
          "next_cursor": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 2048
              },
              {
                "type": "null"
              }
            ]
          },
          "observed_at_ms": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "has_gaps": {
            "type": "boolean"
          }
        },
        "required": [
          "items",
          "next_cursor",
          "observed_at_ms",
          "has_gaps"
        ],
        "additionalProperties": false
      },
      "PolicyPage": {
        "type": "object",
        "properties": {
          "items": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/PolicyRecord"
            },
            "maxItems": 500
          },
          "next_cursor": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 2048
              },
              {
                "type": "null"
              }
            ]
          },
          "observed_at_ms": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "has_gaps": {
            "type": "boolean"
          },
          "config_revision": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          }
        },
        "required": [
          "items",
          "next_cursor",
          "observed_at_ms",
          "has_gaps",
          "config_revision"
        ],
        "additionalProperties": false
      },
      "ResourceReport": {
        "type": "object",
        "properties": {
          "component_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "run_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "sequence": {
            "type": "string",
            "pattern": "^(0|[1-9][0-9]{0,18})$"
          },
          "sample_interval_ms": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "observed_age_ms": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "network_domain": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "network_bytes_per_second": {
            "anyOf": [
              {
                "type": "number",
                "minimum": 0
              },
              {
                "type": "null"
              }
            ]
          },
          "unique_bytes_per_second": {
            "anyOf": [
              {
                "type": "number",
                "minimum": 0
              },
              {
                "type": "null"
              }
            ]
          },
          "capacity_bytes_per_second": {
            "anyOf": [
              {
                "type": "number",
                "minimum": 0
              },
              {
                "type": "null"
              }
            ]
          },
          "capacity_basis": {
            "type": "string",
            "enum": [
              "configured",
              "estimated",
              "unknown"
            ]
          },
          "fd_limit": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 0,
                "maximum": 9007199254740991
              },
              {
                "type": "null"
              }
            ]
          },
          "fd_used": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 0,
                "maximum": 9007199254740991
              },
              {
                "type": "null"
              }
            ]
          },
          "memory_available_bytes": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 0,
                "maximum": 9007199254740991
              },
              {
                "type": "null"
              }
            ]
          },
          "event_loop_lag_ms": {
            "anyOf": [
              {
                "type": "number",
                "minimum": 0
              },
              {
                "type": "null"
              }
            ]
          },
          "hash_queue_bytes": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 0,
                "maximum": 9007199254740991
              },
              {
                "type": "null"
              }
            ]
          },
          "storage_domains": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "domain_id": {
                  "type": "string",
                  "minLength": 1,
                  "maxLength": 128,
                  "pattern": "^[A-Za-z0-9_.:-]+$"
                },
                "pending_write_bytes": {
                  "anyOf": [
                    {
                      "type": "integer",
                      "minimum": 0,
                      "maximum": 9007199254740991
                    },
                    {
                      "type": "null"
                    }
                  ]
                },
                "write_p95_ms": {
                  "anyOf": [
                    {
                      "type": "number",
                      "minimum": 0
                    },
                    {
                      "type": "null"
                    }
                  ]
                },
                "pressure_ratio": {
                  "anyOf": [
                    {
                      "type": "number",
                      "minimum": 0
                    },
                    {
                      "type": "null"
                    }
                  ]
                },
                "free_allocatable_bytes": {
                  "anyOf": [
                    {
                      "type": "integer",
                      "minimum": 0,
                      "maximum": 9007199254740991
                    },
                    {
                      "type": "null"
                    }
                  ]
                }
              },
              "required": [
                "domain_id",
                "pending_write_bytes",
                "write_p95_ms",
                "pressure_ratio",
                "free_allocatable_bytes"
              ],
              "additionalProperties": false
            },
            "maxItems": 64
          },
          "lost_samples": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          }
        },
        "required": [
          "component_id",
          "run_id",
          "sequence",
          "sample_interval_ms",
          "observed_age_ms",
          "network_domain",
          "network_bytes_per_second",
          "unique_bytes_per_second",
          "capacity_bytes_per_second",
          "capacity_basis",
          "fd_limit",
          "fd_used",
          "memory_available_bytes",
          "event_loop_lag_ms",
          "hash_queue_bytes",
          "storage_domains",
          "lost_samples"
        ],
        "additionalProperties": false
      },
      "ComponentCapabilities": {
        "type": "object",
        "properties": {
          "component_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "engine_version": {
            "type": "string",
            "maxLength": 2048
          },
          "capability_revision": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          },
          "observed_fixture_id": {
            "anyOf": [
              {
                "type": "string",
                "minLength": 1,
                "maxLength": 128,
                "pattern": "^[A-Za-z0-9_.:-]+$"
              },
              {
                "type": "null"
              }
            ]
          },
          "capabilities": {
            "type": "object",
            "properties": {
              "per_connection_identity": {
                "type": "string",
                "enum": [
                  "native",
                  "observed",
                  "unsupported"
                ]
              },
              "service_eligibility": {
                "type": "string",
                "enum": [
                  "native",
                  "observed",
                  "unsupported"
                ]
              },
              "per_peer_piece_map": {
                "type": "string",
                "enum": [
                  "native",
                  "observed",
                  "unsupported"
                ]
              },
              "request_progress": {
                "type": "string",
                "enum": [
                  "native",
                  "observed",
                  "unsupported"
                ]
              },
              "disconnect_connection": {
                "type": "string",
                "enum": [
                  "native",
                  "observed",
                  "unsupported"
                ]
              },
              "avoid_content_source": {
                "type": "string",
                "enum": [
                  "native",
                  "observed",
                  "unsupported"
                ]
              },
              "reversible_ban": {
                "type": "string",
                "enum": [
                  "native",
                  "observed",
                  "unsupported"
                ]
              },
              "metadata_without_payload": {
                "type": "string",
                "enum": [
                  "native",
                  "observed",
                  "unsupported"
                ]
              },
              "retain_queue_without_autostart": {
                "type": "string",
                "enum": [
                  "native",
                  "observed",
                  "unsupported"
                ]
              }
            },
            "required": [
              "per_connection_identity",
              "service_eligibility",
              "per_peer_piece_map",
              "request_progress",
              "disconnect_connection",
              "avoid_content_source",
              "reversible_ban",
              "metadata_without_payload",
              "retain_queue_without_autostart"
            ],
            "additionalProperties": false
          }
        },
        "required": [
          "component_id",
          "engine_version",
          "capability_revision",
          "observed_fixture_id",
          "capabilities"
        ],
        "additionalProperties": false
      },
      "Error": {
        "type": "object",
        "properties": {
          "code": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "message": {
            "type": "string",
            "maxLength": 2048
          },
          "retryable": {
            "type": "boolean"
          }
        },
        "required": [
          "code",
          "message",
          "retryable"
        ],
        "additionalProperties": false
      },
      "DiscoverCommand": {
        "type": "object",
        "properties": {
          "request_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "task_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "expected_task_revision": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          },
          "expected_run_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "config_revision": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          },
          "deadline_ms": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "action": {
            "const": "discover"
          },
          "content_key": {
            "type": "string",
            "minLength": 1,
            "maxLength": 2048
          },
          "realm": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "selection_digest": {
            "type": "string",
            "pattern": "^[a-f0-9]{64}$"
          },
          "max_returned_sources": {
            "type": "integer",
            "minimum": 1,
            "maximum": 2048
          },
          "payload_allowed": {
            "const": false
          }
        },
        "required": [
          "request_id",
          "task_id",
          "expected_task_revision",
          "expected_run_id",
          "config_revision",
          "deadline_ms",
          "action",
          "content_key",
          "realm",
          "selection_digest",
          "max_returned_sources",
          "payload_allowed"
        ],
        "additionalProperties": false
      },
      "ProbeCommand": {
        "type": "object",
        "properties": {
          "request_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "task_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "expected_task_revision": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          },
          "expected_run_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "config_revision": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          },
          "deadline_ms": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "action": {
            "const": "probe_sources"
          },
          "source_ids": {
            "type": "array",
            "items": {
              "type": "string",
              "minLength": 1,
              "maxLength": 128,
              "pattern": "^[A-Za-z0-9_.:-]+$"
            },
            "maxItems": 2048
          },
          "dial_credit": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "memory_credit_bytes": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "rate_tokens": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "release_task_local_on_finish": {
            "const": true
          },
          "preserve_valid_queue": {
            "const": true
          },
          "payload_allowed": {
            "const": false
          }
        },
        "required": [
          "request_id",
          "task_id",
          "expected_task_revision",
          "expected_run_id",
          "config_revision",
          "deadline_ms",
          "action",
          "source_ids",
          "dial_credit",
          "memory_credit_bytes",
          "rate_tokens",
          "release_task_local_on_finish",
          "preserve_valid_queue",
          "payload_allowed"
        ],
        "additionalProperties": false
      },
      "TrialCommand": {
        "type": "object",
        "properties": {
          "request_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "task_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "expected_task_revision": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          },
          "expected_run_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "config_revision": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          },
          "deadline_ms": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "action": {
            "const": "start_trial"
          },
          "source_snapshot_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "budget": {
            "$ref": "#/components/schemas/DownloadBudget"
          },
          "verification_extension_allowed": {
            "type": "boolean"
          }
        },
        "required": [
          "request_id",
          "task_id",
          "expected_task_revision",
          "expected_run_id",
          "config_revision",
          "deadline_ms",
          "action",
          "source_snapshot_id",
          "budget",
          "verification_extension_allowed"
        ],
        "additionalProperties": false
      },
      "PauseCommand": {
        "type": "object",
        "properties": {
          "request_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "task_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "expected_task_revision": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          },
          "expected_run_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "config_revision": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          },
          "deadline_ms": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "action": {
            "const": "pause_or_observe"
          },
          "reason_code": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "preserve_checkpoint": {
            "const": true
          },
          "preserve_queue_if_budgeted": {
            "type": "boolean"
          },
          "target_phase": {
            "type": "string",
            "enum": [
              "observing",
              "held"
            ]
          }
        },
        "required": [
          "request_id",
          "task_id",
          "expected_task_revision",
          "expected_run_id",
          "config_revision",
          "deadline_ms",
          "action",
          "reason_code",
          "preserve_checkpoint",
          "preserve_queue_if_budgeted",
          "target_phase"
        ],
        "additionalProperties": false
      },
      "BudgetCommand": {
        "type": "object",
        "properties": {
          "request_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "task_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "expected_task_revision": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          },
          "expected_run_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "config_revision": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          },
          "deadline_ms": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          },
          "action": {
            "const": "set_download_budget"
          },
          "budget": {
            "$ref": "#/components/schemas/DownloadBudget"
          }
        },
        "required": [
          "request_id",
          "task_id",
          "expected_task_revision",
          "expected_run_id",
          "config_revision",
          "deadline_ms",
          "action",
          "budget"
        ],
        "additionalProperties": false
      },
      "EngineAck": {
        "type": "object",
        "properties": {
          "request_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "task_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "component_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "run_id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "task_revision": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          },
          "outcome": {
            "type": "string",
            "enum": [
              "applied",
              "already_applied",
              "rejected",
              "unsupported",
              "unknown"
            ]
          },
          "effective_budget": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/DownloadBudget"
              },
              {
                "type": "null"
              }
            ]
          },
          "reason_code": {
            "anyOf": [
              {
                "type": "string",
                "minLength": 1,
                "maxLength": 128,
                "pattern": "^[A-Za-z0-9_.:-]+$"
              },
              {
                "type": "null"
              }
            ]
          },
          "observed_at_ms": {
            "type": "integer",
            "minimum": 0,
            "maximum": 9007199254740991
          }
        },
        "required": [
          "request_id",
          "task_id",
          "component_id",
          "run_id",
          "task_revision",
          "outcome",
          "effective_budget",
          "reason_code",
          "observed_at_ms"
        ],
        "additionalProperties": false
      }
    }
  }
}

contracts/control.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "urn:p2p:control:2.3",
  "title": "P2P control contracts 2.3",
  "$defs": {
    "Identity": {
      "type": "object",
      "properties": {
        "connection_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "component_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "run_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "native_connection_key": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "transport_handle_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "realm": {
          "type": "string",
          "enum": [
            "public_bt",
            "private_bt",
            "ed2k",
            "dc",
            "soulseek",
            "ipfs",
            "i2p",
            "other"
          ]
        },
        "task_ids": {
          "type": "array",
          "items": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "maxItems": 256
        }
      },
      "required": [
        "connection_id",
        "component_id",
        "run_id",
        "native_connection_key",
        "transport_handle_id",
        "realm",
        "task_ids"
      ],
      "additionalProperties": false
    },
    "ConnectionReport": {
      "type": "object",
      "properties": {
        "schema_version": {
          "const": "2.3"
        },
        "identity": {
          "$ref": "#/$defs/Identity"
        },
        "sequence": {
          "type": "string",
          "pattern": "^(0|[1-9][0-9]{0,19})$",
          "description": "Canonical decimal int64 nonnegative; parse and reject >9223372036854775807; rotate run before overflow."
        },
        "sample_interval_ms": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "observed_age_ms": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "reporting": {
          "type": "string",
          "enum": [
            "exact",
            "aggregate",
            "partial",
            "unsupported"
          ]
        },
        "role": {
          "type": "string",
          "enum": [
            "payload",
            "tracker",
            "ed2k_server",
            "dht",
            "hub",
            "metadata",
            "provider",
            "upload_only"
          ]
        },
        "endpoint": {
          "type": "string",
          "maxLength": 2048
        },
        "country": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Z]{2}$"
            },
            {
              "type": "null"
            }
          ]
        },
        "country_source": {
          "anyOf": [
            {
              "type": "string",
              "maxLength": 2048
            },
            {
              "type": "null"
            }
          ]
        },
        "peer_id": {
          "anyOf": [
            {
              "type": "string",
              "maxLength": 2048
            },
            {
              "type": "null"
            }
          ]
        },
        "identity_strength": {
          "type": "string",
          "enum": [
            "claimed",
            "protocol_authenticated",
            "unknown"
          ]
        },
        "remote_choked": {
          "anyOf": [
            {
              "type": "boolean"
            },
            {
              "type": "null"
            }
          ]
        },
        "remote_queued": {
          "anyOf": [
            {
              "type": "boolean"
            },
            {
              "type": "null"
            }
          ]
        },
        "service_expected": {
          "anyOf": [
            {
              "type": "boolean"
            },
            {
              "type": "null"
            }
          ]
        },
        "outstanding_requests": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "queued_disk_bytes": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^(0|[1-9][0-9]{0,19})$",
              "description": "decimal uint64; semantic upper bound 18446744073709551615"
            },
            {
              "type": "null"
            }
          ]
        },
        "local_blocked": {
          "anyOf": [
            {
              "type": "boolean"
            },
            {
              "type": "null"
            }
          ]
        },
        "delta_payload_bytes": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "delta_unique_bytes": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "delta_verified_bytes": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "rtt_ms": {
          "anyOf": [
            {
              "type": "number",
              "minimum": 0
            },
            {
              "type": "null"
            }
          ]
        },
        "rtt_method": {
          "anyOf": [
            {
              "type": "string",
              "maxLength": 2048
            },
            {
              "type": "null"
            }
          ]
        },
        "qualified_idle_ms": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "missing_reason": {
          "anyOf": [
            {
              "type": "string",
              "maxLength": 2048
            },
            {
              "type": "null"
            }
          ]
        },
        "native_state": {
          "type": "object",
          "properties": {
            "handshake_complete": {
              "anyOf": [
                {
                  "type": "boolean"
                },
                {
                  "type": "null"
                }
              ]
            },
            "interested": {
              "anyOf": [
                {
                  "type": "boolean"
                },
                {
                  "type": "null"
                }
              ]
            },
            "needed_overlap": {
              "anyOf": [
                {
                  "type": "boolean"
                },
                {
                  "type": "null"
                }
              ]
            },
            "slot_granted": {
              "anyOf": [
                {
                  "type": "boolean"
                },
                {
                  "type": "null"
                }
              ]
            },
            "remote_queue_rank": {
              "anyOf": [
                {
                  "type": "integer",
                  "minimum": 0,
                  "maximum": 9007199254740991
                },
                {
                  "type": "null"
                }
              ]
            },
            "receive_credit_bytes": {
              "anyOf": [
                {
                  "type": "integer",
                  "minimum": 0,
                  "maximum": 9007199254740991
                },
                {
                  "type": "null"
                }
              ]
            },
            "service_generation": {
              "anyOf": [
                {
                  "type": "string",
                  "minLength": 1,
                  "maxLength": 128,
                  "pattern": "^[A-Za-z0-9_.:-]+$"
                },
                {
                  "type": "null"
                }
              ]
            },
            "protocol_deadline_ms": {
              "anyOf": [
                {
                  "type": "integer",
                  "minimum": 0,
                  "maximum": 9007199254740991
                },
                {
                  "type": "null"
                }
              ]
            },
            "common_path_outage": {
              "anyOf": [
                {
                  "type": "boolean"
                },
                {
                  "type": "null"
                }
              ]
            },
            "enforcement_capabilities": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "disconnect_connection",
                  "avoid_content_source",
                  "quarantine_endpoint",
                  "revoke_policy",
                  "ip_ban"
                ]
              },
              "maxItems": 8
            }
          },
          "required": [
            "handshake_complete",
            "interested",
            "needed_overlap",
            "slot_granted",
            "remote_queue_rank",
            "receive_credit_bytes",
            "service_generation",
            "protocol_deadline_ms",
            "common_path_outage",
            "enforcement_capabilities"
          ],
          "additionalProperties": false
        },
        "performance": {
          "type": "object",
          "properties": {
            "ttfb_ms": {
              "anyOf": [
                {
                  "type": "number",
                  "minimum": 0
                },
                {
                  "type": "null"
                }
              ]
            },
            "request_p50_ms": {
              "anyOf": [
                {
                  "type": "number",
                  "minimum": 0
                },
                {
                  "type": "null"
                }
              ]
            },
            "request_p95_ms": {
              "anyOf": [
                {
                  "type": "number",
                  "minimum": 0
                },
                {
                  "type": "null"
                }
              ]
            },
            "delta_duplicate_bytes": {
              "anyOf": [
                {
                  "type": "integer",
                  "minimum": 0,
                  "maximum": 9007199254740991
                },
                {
                  "type": "null"
                }
              ]
            },
            "delta_discarded_bytes": {
              "anyOf": [
                {
                  "type": "integer",
                  "minimum": 0,
                  "maximum": 9007199254740991
                },
                {
                  "type": "null"
                }
              ]
            },
            "upload_payload_bytes_per_second": {
              "anyOf": [
                {
                  "type": "number",
                  "minimum": 0
                },
                {
                  "type": "null"
                }
              ]
            },
            "payload_bytes_per_second": {
              "anyOf": [
                {
                  "type": "number",
                  "minimum": 0
                },
                {
                  "type": "null"
                }
              ]
            },
            "unique_bytes_per_second": {
              "anyOf": [
                {
                  "type": "number",
                  "minimum": 0
                },
                {
                  "type": "null"
                }
              ]
            },
            "country_db_version": {
              "anyOf": [
                {
                  "type": "string",
                  "maxLength": 2048
                },
                {
                  "type": "null"
                }
              ]
            },
            "asn": {
              "anyOf": [
                {
                  "type": "integer",
                  "minimum": 0,
                  "maximum": 9007199254740991
                },
                {
                  "type": "null"
                }
              ]
            },
            "native_id_class": {
              "anyOf": [
                {
                  "type": "string",
                  "maxLength": 2048
                },
                {
                  "type": "null"
                }
              ]
            },
            "integrity_attribution": {
              "type": "string",
              "enum": [
                "none",
                "pending",
                "ambiguous",
                "isolated_verified"
              ]
            }
          },
          "required": [
            "ttfb_ms",
            "request_p50_ms",
            "request_p95_ms",
            "delta_duplicate_bytes",
            "delta_discarded_bytes",
            "upload_payload_bytes_per_second",
            "payload_bytes_per_second",
            "unique_bytes_per_second",
            "country_db_version",
            "asn",
            "native_id_class",
            "integrity_attribution"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "schema_version",
        "identity",
        "sequence",
        "sample_interval_ms",
        "observed_age_ms",
        "reporting",
        "role",
        "endpoint",
        "country",
        "country_source",
        "peer_id",
        "identity_strength",
        "remote_choked",
        "remote_queued",
        "service_expected",
        "outstanding_requests",
        "queued_disk_bytes",
        "local_blocked",
        "delta_payload_bytes",
        "delta_unique_bytes",
        "delta_verified_bytes",
        "rtt_ms",
        "rtt_method",
        "qualified_idle_ms",
        "missing_reason",
        "native_state",
        "performance"
      ],
      "additionalProperties": false
    },
    "SourceSnapshot": {
      "type": "object",
      "properties": {
        "schema_version": {
          "const": "2.3"
        },
        "snapshot_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "task_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "realm": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "selection_digest": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}$"
        },
        "component_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "run_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "sequence": {
          "type": "string",
          "pattern": "^(0|[1-9][0-9]{0,19})$",
          "description": "Canonical decimal int64 nonnegative; parse and reject >9223372036854775807; rotate run before overflow."
        },
        "observed_at_ms": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "expires_at_ms": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "coverage": {
          "type": "string",
          "enum": [
            "covered_observed",
            "missing_observed",
            "unknown"
          ]
        },
        "coverage_quality": {
          "type": "string",
          "enum": [
            "exact",
            "aggregate",
            "partial",
            "unsupported"
          ]
        },
        "source_ids": {
          "type": "array",
          "items": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "maxItems": 2048
        },
        "can_serve_now": {
          "anyOf": [
            {
              "type": "boolean"
            },
            {
              "type": "null"
            }
          ]
        },
        "next_safe_probe_at_ms": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "release_state": {
          "type": "string",
          "enum": [
            "closed",
            "shared_retained",
            "queue_retained",
            "unknown"
          ]
        },
        "reason": {
          "anyOf": [
            {
              "type": "string",
              "maxLength": 2048
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "required": [
        "schema_version",
        "snapshot_id",
        "task_id",
        "realm",
        "selection_digest",
        "component_id",
        "run_id",
        "sequence",
        "observed_at_ms",
        "expires_at_ms",
        "coverage",
        "coverage_quality",
        "source_ids",
        "can_serve_now",
        "next_safe_probe_at_ms",
        "release_state",
        "reason"
      ],
      "additionalProperties": false
    },
    "DownloadBudget": {
      "type": "object",
      "properties": {
        "task_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "run_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "generation": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "network_domain": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "storage_domain": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "mode": {
          "type": "string",
          "enum": [
            "probe",
            "trial",
            "active",
            "observe",
            "drain"
          ]
        },
        "network_bytes_per_second": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "write_window_bytes": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "memory_bytes": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "peer_credit": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "expires_at_ms": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "enforcement": {
          "type": "string",
          "enum": [
            "hard_native",
            "soft_observed",
            "unsupported"
          ]
        }
      },
      "required": [
        "task_id",
        "run_id",
        "generation",
        "network_domain",
        "storage_domain",
        "mode",
        "network_bytes_per_second",
        "write_window_bytes",
        "memory_bytes",
        "peer_credit",
        "expires_at_ms",
        "enforcement"
      ],
      "additionalProperties": false
    },
    "ConnectionCommand": {
      "type": "object",
      "properties": {
        "schema_version": {
          "const": "2.3"
        },
        "request_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "connection_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "expected_run_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "expected_policy_revision": {
          "type": "integer",
          "minimum": 1,
          "maximum": 9007199254740991
        },
        "action": {
          "type": "string",
          "enum": [
            "disconnect",
            "avoid",
            "quarantine"
          ]
        },
        "scope": {
          "type": "string",
          "enum": [
            "connection",
            "realm_content_source",
            "realm_endpoint",
            "ip"
          ]
        },
        "automatic": {
          "type": "boolean"
        },
        "duration_ms": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "evidence_id": {
          "anyOf": [
            {
              "type": "string",
              "minLength": 1,
              "maxLength": 128,
              "pattern": "^[A-Za-z0-9_.:-]+$"
            },
            {
              "type": "null"
            }
          ]
        },
        "reason_code": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "task_id": {
          "anyOf": [
            {
              "type": "string",
              "minLength": 1,
              "maxLength": 128,
              "pattern": "^[A-Za-z0-9_.:-]+$"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "required": [
        "schema_version",
        "request_id",
        "connection_id",
        "expected_run_id",
        "expected_policy_revision",
        "action",
        "scope",
        "automatic",
        "duration_ms",
        "evidence_id",
        "reason_code",
        "task_id"
      ],
      "additionalProperties": false,
      "allOf": [
        {
          "if": {
            "properties": {
              "automatic": {
                "const": true
              }
            },
            "required": [
              "automatic"
            ]
          },
          "then": {
            "properties": {
              "scope": {
                "type": "string",
                "enum": [
                  "connection",
                  "realm_content_source",
                  "realm_endpoint"
                ]
              },
              "duration_ms": {
                "type": "integer",
                "minimum": 0,
                "maximum": 9007199254740991
              },
              "evidence_id": {
                "type": "string",
                "minLength": 1,
                "maxLength": 128,
                "pattern": "^[A-Za-z0-9_.:-]+$"
              }
            }
          }
        },
        {
          "if": {
            "properties": {
              "scope": {
                "const": "realm_content_source"
              }
            },
            "required": [
              "scope"
            ]
          },
          "then": {
            "properties": {
              "task_id": {
                "type": "string",
                "minLength": 1,
                "maxLength": 128,
                "pattern": "^[A-Za-z0-9_.:-]+$"
              }
            }
          }
        }
      ]
    },
    "Operation": {
      "type": "object",
      "properties": {
        "operation_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "request_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "target_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "requested_action": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "requested_scope": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "outcome": {
          "type": "string",
          "enum": [
            "pending",
            "sent",
            "applied",
            "already_closed",
            "unsupported_scope",
            "stale_target",
            "unknown",
            "failed"
          ]
        },
        "observed_at_ms": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "effective_scope": {
          "anyOf": [
            {
              "type": "string",
              "minLength": 1,
              "maxLength": 128,
              "pattern": "^[A-Za-z0-9_.:-]+$"
            },
            {
              "type": "null"
            }
          ]
        },
        "reason_code": {
          "anyOf": [
            {
              "type": "string",
              "minLength": 1,
              "maxLength": 128,
              "pattern": "^[A-Za-z0-9_.:-]+$"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "required": [
        "operation_id",
        "request_id",
        "target_id",
        "requested_action",
        "requested_scope",
        "outcome",
        "observed_at_ms",
        "effective_scope",
        "reason_code"
      ],
      "additionalProperties": false
    },
    "PoolStatus": {
      "type": "object",
      "properties": {
        "policy_revision": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "active_tasks": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "trial_tasks": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "observing_tasks": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "collecting_tasks": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "network_capacity_bytes_per_second": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "capacity_basis": {
          "type": "string",
          "enum": [
            "configured",
            "estimated",
            "unknown"
          ]
        },
        "utilization": {
          "anyOf": [
            {
              "type": "number",
              "minimum": 0
            },
            {
              "type": "null"
            }
          ]
        },
        "local_pressure": {
          "anyOf": [
            {
              "type": "number",
              "minimum": 0
            },
            {
              "type": "null"
            }
          ]
        },
        "control_action": {
          "type": "string",
          "enum": [
            "hold",
            "trial_more",
            "drain",
            "rotate"
          ]
        },
        "reason_code": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "samples_fresh": {
          "type": "boolean"
        },
        "registered_tasks": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "rank_ready_tasks": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "held_tasks": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "finished_tasks": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        }
      },
      "required": [
        "policy_revision",
        "active_tasks",
        "trial_tasks",
        "observing_tasks",
        "collecting_tasks",
        "network_capacity_bytes_per_second",
        "capacity_basis",
        "utilization",
        "local_pressure",
        "control_action",
        "reason_code",
        "samples_fresh",
        "registered_tasks",
        "rank_ready_tasks",
        "held_tasks",
        "finished_tasks"
      ],
      "additionalProperties": false
    },
    "SourceCommand": {
      "type": "object",
      "properties": {
        "request_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "target_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "expected_revision": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "action": {
          "type": "string",
          "enum": [
            "refresh",
            "quarantine",
            "restore",
            "retire"
          ]
        },
        "reason": {
          "type": "string",
          "maxLength": 2048
        }
      },
      "required": [
        "request_id",
        "target_id",
        "expected_revision",
        "action",
        "reason"
      ],
      "additionalProperties": false
    },
    "SourceEndpoint": {
      "type": "object",
      "properties": {
        "endpoint_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "uri": {
          "type": "string",
          "maxLength": 2048
        },
        "realm": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "kind": {
          "type": "string",
          "enum": [
            "tracker",
            "ed2k_server",
            "other"
          ]
        },
        "state": {
          "type": "string",
          "enum": [
            "candidate",
            "validated",
            "probing",
            "usable_observed",
            "quarantined",
            "retired",
            "manual_review"
          ]
        },
        "revision": {
          "type": "integer",
          "minimum": 1,
          "maximum": 9007199254740991
        },
        "source_ids": {
          "type": "array",
          "items": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "maxItems": 16
        },
        "last_checked_at_ms": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "risk_state": {
          "type": "string",
          "enum": [
            "unknown",
            "observed_anomaly",
            "attributed_invalid",
            "manual_deny"
          ]
        },
        "next_probe_at_ms": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "reason_code": {
          "anyOf": [
            {
              "type": "string",
              "minLength": 1,
              "maxLength": 128,
              "pattern": "^[A-Za-z0-9_.:-]+$"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "required": [
        "endpoint_id",
        "uri",
        "realm",
        "kind",
        "state",
        "revision",
        "source_ids",
        "last_checked_at_ms",
        "risk_state",
        "next_probe_at_ms",
        "reason_code"
      ],
      "additionalProperties": false
    },
    "PolicyRecord": {
      "type": "object",
      "properties": {
        "policy_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "revision": {
          "type": "integer",
          "minimum": 1,
          "maximum": 9007199254740991
        },
        "realm": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "scope": {
          "type": "string",
          "enum": [
            "realm_content_source",
            "realm_endpoint",
            "ip"
          ]
        },
        "target_key": {
          "type": "string",
          "maxLength": 2048
        },
        "content_key": {
          "anyOf": [
            {
              "type": "string",
              "maxLength": 2048
            },
            {
              "type": "null"
            }
          ]
        },
        "action": {
          "type": "string",
          "enum": [
            "avoid",
            "quarantine",
            "manual_deny",
            "allow_override"
          ]
        },
        "state": {
          "type": "string",
          "enum": [
            "pending",
            "enforced",
            "expired",
            "revoked",
            "unknown",
            "unsupported"
          ]
        },
        "created_at_ms": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "expires_at_ms": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "evidence_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "strikes": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "reason_code": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        }
      },
      "required": [
        "policy_id",
        "revision",
        "realm",
        "scope",
        "target_key",
        "content_key",
        "action",
        "state",
        "created_at_ms",
        "expires_at_ms",
        "evidence_id",
        "strikes",
        "reason_code"
      ],
      "additionalProperties": false
    },
    "PolicyCreate": {
      "type": "object",
      "properties": {
        "request_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "expected_revision": {
          "type": "integer",
          "minimum": 1,
          "maximum": 9007199254740991
        },
        "action": {
          "const": "manual_deny"
        },
        "scope": {
          "type": "string",
          "enum": [
            "realm_content_source",
            "realm_endpoint",
            "ip"
          ]
        },
        "realm": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "target_key": {
          "type": "string",
          "maxLength": 2048
        },
        "content_key": {
          "anyOf": [
            {
              "type": "string",
              "maxLength": 2048
            },
            {
              "type": "null"
            }
          ]
        },
        "expires_at_ms": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "reason": {
          "type": "string",
          "minLength": 1,
          "maxLength": 2048
        }
      },
      "required": [
        "request_id",
        "expected_revision",
        "action",
        "scope",
        "realm",
        "target_key",
        "content_key",
        "expires_at_ms",
        "reason"
      ],
      "additionalProperties": false,
      "allOf": [
        {
          "if": {
            "properties": {
              "scope": {
                "const": "realm_content_source"
              }
            },
            "required": [
              "scope"
            ]
          },
          "then": {
            "properties": {
              "content_key": {
                "type": "string",
                "minLength": 1,
                "maxLength": 2048
              }
            }
          }
        }
      ]
    },
    "PolicyRevoke": {
      "type": "object",
      "properties": {
        "request_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "target_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "expected_revision": {
          "type": "integer",
          "minimum": 1,
          "maximum": 9007199254740991
        },
        "action": {
          "const": "revoke"
        },
        "reason": {
          "type": "string",
          "minLength": 1,
          "maxLength": 2048
        }
      },
      "required": [
        "request_id",
        "target_id",
        "expected_revision",
        "action",
        "reason"
      ],
      "additionalProperties": false
    },
    "ConnectionPage": {
      "type": "object",
      "properties": {
        "items": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/ConnectionReport"
          },
          "maxItems": 500
        },
        "next_cursor": {
          "anyOf": [
            {
              "type": "string",
              "maxLength": 2048
            },
            {
              "type": "null"
            }
          ]
        },
        "observed_at_ms": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "has_gaps": {
          "type": "boolean"
        }
      },
      "required": [
        "items",
        "next_cursor",
        "observed_at_ms",
        "has_gaps"
      ],
      "additionalProperties": false
    },
    "SourcePage": {
      "type": "object",
      "properties": {
        "items": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/SourceEndpoint"
          },
          "maxItems": 500
        },
        "next_cursor": {
          "anyOf": [
            {
              "type": "string",
              "maxLength": 2048
            },
            {
              "type": "null"
            }
          ]
        },
        "observed_at_ms": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "has_gaps": {
          "type": "boolean"
        }
      },
      "required": [
        "items",
        "next_cursor",
        "observed_at_ms",
        "has_gaps"
      ],
      "additionalProperties": false
    },
    "PolicyPage": {
      "type": "object",
      "properties": {
        "items": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/PolicyRecord"
          },
          "maxItems": 500
        },
        "next_cursor": {
          "anyOf": [
            {
              "type": "string",
              "maxLength": 2048
            },
            {
              "type": "null"
            }
          ]
        },
        "observed_at_ms": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "has_gaps": {
          "type": "boolean"
        },
        "config_revision": {
          "type": "integer",
          "minimum": 1,
          "maximum": 9007199254740991
        }
      },
      "required": [
        "items",
        "next_cursor",
        "observed_at_ms",
        "has_gaps",
        "config_revision"
      ],
      "additionalProperties": false
    },
    "ResourceReport": {
      "type": "object",
      "properties": {
        "component_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "run_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "sequence": {
          "type": "string",
          "pattern": "^(0|[1-9][0-9]{0,18})$"
        },
        "sample_interval_ms": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "observed_age_ms": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "network_domain": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "network_bytes_per_second": {
          "anyOf": [
            {
              "type": "number",
              "minimum": 0
            },
            {
              "type": "null"
            }
          ]
        },
        "unique_bytes_per_second": {
          "anyOf": [
            {
              "type": "number",
              "minimum": 0
            },
            {
              "type": "null"
            }
          ]
        },
        "capacity_bytes_per_second": {
          "anyOf": [
            {
              "type": "number",
              "minimum": 0
            },
            {
              "type": "null"
            }
          ]
        },
        "capacity_basis": {
          "type": "string",
          "enum": [
            "configured",
            "estimated",
            "unknown"
          ]
        },
        "fd_limit": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "fd_used": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "memory_available_bytes": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "event_loop_lag_ms": {
          "anyOf": [
            {
              "type": "number",
              "minimum": 0
            },
            {
              "type": "null"
            }
          ]
        },
        "hash_queue_bytes": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "storage_domains": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "domain_id": {
                "type": "string",
                "minLength": 1,
                "maxLength": 128,
                "pattern": "^[A-Za-z0-9_.:-]+$"
              },
              "pending_write_bytes": {
                "anyOf": [
                  {
                    "type": "integer",
                    "minimum": 0,
                    "maximum": 9007199254740991
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "write_p95_ms": {
                "anyOf": [
                  {
                    "type": "number",
                    "minimum": 0
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "pressure_ratio": {
                "anyOf": [
                  {
                    "type": "number",
                    "minimum": 0
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "free_allocatable_bytes": {
                "anyOf": [
                  {
                    "type": "integer",
                    "minimum": 0,
                    "maximum": 9007199254740991
                  },
                  {
                    "type": "null"
                  }
                ]
              }
            },
            "required": [
              "domain_id",
              "pending_write_bytes",
              "write_p95_ms",
              "pressure_ratio",
              "free_allocatable_bytes"
            ],
            "additionalProperties": false
          },
          "maxItems": 64
        },
        "lost_samples": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        }
      },
      "required": [
        "component_id",
        "run_id",
        "sequence",
        "sample_interval_ms",
        "observed_age_ms",
        "network_domain",
        "network_bytes_per_second",
        "unique_bytes_per_second",
        "capacity_bytes_per_second",
        "capacity_basis",
        "fd_limit",
        "fd_used",
        "memory_available_bytes",
        "event_loop_lag_ms",
        "hash_queue_bytes",
        "storage_domains",
        "lost_samples"
      ],
      "additionalProperties": false
    },
    "ComponentCapabilities": {
      "type": "object",
      "properties": {
        "component_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "engine_version": {
          "type": "string",
          "maxLength": 2048
        },
        "capability_revision": {
          "type": "integer",
          "minimum": 1,
          "maximum": 9007199254740991
        },
        "observed_fixture_id": {
          "anyOf": [
            {
              "type": "string",
              "minLength": 1,
              "maxLength": 128,
              "pattern": "^[A-Za-z0-9_.:-]+$"
            },
            {
              "type": "null"
            }
          ]
        },
        "capabilities": {
          "type": "object",
          "properties": {
            "per_connection_identity": {
              "type": "string",
              "enum": [
                "native",
                "observed",
                "unsupported"
              ]
            },
            "service_eligibility": {
              "type": "string",
              "enum": [
                "native",
                "observed",
                "unsupported"
              ]
            },
            "per_peer_piece_map": {
              "type": "string",
              "enum": [
                "native",
                "observed",
                "unsupported"
              ]
            },
            "request_progress": {
              "type": "string",
              "enum": [
                "native",
                "observed",
                "unsupported"
              ]
            },
            "disconnect_connection": {
              "type": "string",
              "enum": [
                "native",
                "observed",
                "unsupported"
              ]
            },
            "avoid_content_source": {
              "type": "string",
              "enum": [
                "native",
                "observed",
                "unsupported"
              ]
            },
            "reversible_ban": {
              "type": "string",
              "enum": [
                "native",
                "observed",
                "unsupported"
              ]
            },
            "metadata_without_payload": {
              "type": "string",
              "enum": [
                "native",
                "observed",
                "unsupported"
              ]
            },
            "retain_queue_without_autostart": {
              "type": "string",
              "enum": [
                "native",
                "observed",
                "unsupported"
              ]
            }
          },
          "required": [
            "per_connection_identity",
            "service_eligibility",
            "per_peer_piece_map",
            "request_progress",
            "disconnect_connection",
            "avoid_content_source",
            "reversible_ban",
            "metadata_without_payload",
            "retain_queue_without_autostart"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "component_id",
        "engine_version",
        "capability_revision",
        "observed_fixture_id",
        "capabilities"
      ],
      "additionalProperties": false
    },
    "DiscoverCommand": {
      "type": "object",
      "properties": {
        "request_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "task_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "expected_task_revision": {
          "type": "integer",
          "minimum": 1,
          "maximum": 9007199254740991
        },
        "expected_run_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "config_revision": {
          "type": "integer",
          "minimum": 1,
          "maximum": 9007199254740991
        },
        "deadline_ms": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "action": {
          "const": "discover"
        },
        "content_key": {
          "type": "string",
          "minLength": 1,
          "maxLength": 2048
        },
        "realm": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "selection_digest": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}$"
        },
        "max_returned_sources": {
          "type": "integer",
          "minimum": 1,
          "maximum": 2048
        },
        "payload_allowed": {
          "const": false
        }
      },
      "required": [
        "request_id",
        "task_id",
        "expected_task_revision",
        "expected_run_id",
        "config_revision",
        "deadline_ms",
        "action",
        "content_key",
        "realm",
        "selection_digest",
        "max_returned_sources",
        "payload_allowed"
      ],
      "additionalProperties": false
    },
    "ProbeCommand": {
      "type": "object",
      "properties": {
        "request_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "task_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "expected_task_revision": {
          "type": "integer",
          "minimum": 1,
          "maximum": 9007199254740991
        },
        "expected_run_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "config_revision": {
          "type": "integer",
          "minimum": 1,
          "maximum": 9007199254740991
        },
        "deadline_ms": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "action": {
          "const": "probe_sources"
        },
        "source_ids": {
          "type": "array",
          "items": {
            "type": "string",
            "minLength": 1,
            "maxLength": 128,
            "pattern": "^[A-Za-z0-9_.:-]+$"
          },
          "maxItems": 2048
        },
        "dial_credit": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "memory_credit_bytes": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "rate_tokens": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "release_task_local_on_finish": {
          "const": true
        },
        "preserve_valid_queue": {
          "const": true
        },
        "payload_allowed": {
          "const": false
        }
      },
      "required": [
        "request_id",
        "task_id",
        "expected_task_revision",
        "expected_run_id",
        "config_revision",
        "deadline_ms",
        "action",
        "source_ids",
        "dial_credit",
        "memory_credit_bytes",
        "rate_tokens",
        "release_task_local_on_finish",
        "preserve_valid_queue",
        "payload_allowed"
      ],
      "additionalProperties": false
    },
    "TrialCommand": {
      "type": "object",
      "properties": {
        "request_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "task_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "expected_task_revision": {
          "type": "integer",
          "minimum": 1,
          "maximum": 9007199254740991
        },
        "expected_run_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "config_revision": {
          "type": "integer",
          "minimum": 1,
          "maximum": 9007199254740991
        },
        "deadline_ms": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "action": {
          "const": "start_trial"
        },
        "source_snapshot_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "budget": {
          "$ref": "#/$defs/DownloadBudget"
        },
        "verification_extension_allowed": {
          "type": "boolean"
        }
      },
      "required": [
        "request_id",
        "task_id",
        "expected_task_revision",
        "expected_run_id",
        "config_revision",
        "deadline_ms",
        "action",
        "source_snapshot_id",
        "budget",
        "verification_extension_allowed"
      ],
      "additionalProperties": false
    },
    "PauseCommand": {
      "type": "object",
      "properties": {
        "request_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "task_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "expected_task_revision": {
          "type": "integer",
          "minimum": 1,
          "maximum": 9007199254740991
        },
        "expected_run_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "config_revision": {
          "type": "integer",
          "minimum": 1,
          "maximum": 9007199254740991
        },
        "deadline_ms": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "action": {
          "const": "pause_or_observe"
        },
        "reason_code": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "preserve_checkpoint": {
          "const": true
        },
        "preserve_queue_if_budgeted": {
          "type": "boolean"
        },
        "target_phase": {
          "type": "string",
          "enum": [
            "observing",
            "held"
          ]
        }
      },
      "required": [
        "request_id",
        "task_id",
        "expected_task_revision",
        "expected_run_id",
        "config_revision",
        "deadline_ms",
        "action",
        "reason_code",
        "preserve_checkpoint",
        "preserve_queue_if_budgeted",
        "target_phase"
      ],
      "additionalProperties": false
    },
    "BudgetCommand": {
      "type": "object",
      "properties": {
        "request_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "task_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "expected_task_revision": {
          "type": "integer",
          "minimum": 1,
          "maximum": 9007199254740991
        },
        "expected_run_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "config_revision": {
          "type": "integer",
          "minimum": 1,
          "maximum": 9007199254740991
        },
        "deadline_ms": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "action": {
          "const": "set_download_budget"
        },
        "budget": {
          "$ref": "#/$defs/DownloadBudget"
        }
      },
      "required": [
        "request_id",
        "task_id",
        "expected_task_revision",
        "expected_run_id",
        "config_revision",
        "deadline_ms",
        "action",
        "budget"
      ],
      "additionalProperties": false
    },
    "EngineAck": {
      "type": "object",
      "properties": {
        "request_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "task_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "component_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "run_id": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128,
          "pattern": "^[A-Za-z0-9_.:-]+$"
        },
        "task_revision": {
          "type": "integer",
          "minimum": 1,
          "maximum": 9007199254740991
        },
        "outcome": {
          "type": "string",
          "enum": [
            "applied",
            "already_applied",
            "rejected",
            "unsupported",
            "unknown"
          ]
        },
        "effective_budget": {
          "anyOf": [
            {
              "$ref": "#/$defs/DownloadBudget"
            },
            {
              "type": "null"
            }
          ]
        },
        "reason_code": {
          "anyOf": [
            {
              "type": "string",
              "minLength": 1,
              "maxLength": 128,
              "pattern": "^[A-Za-z0-9_.:-]+$"
            },
            {
              "type": "null"
            }
          ]
        },
        "observed_at_ms": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        }
      },
      "required": [
        "request_id",
        "task_id",
        "component_id",
        "run_id",
        "task_revision",
        "outcome",
        "effective_budget",
        "reason_code",
        "observed_at_ms"
      ],
      "additionalProperties": false
    }
  },
  "anyOf": [
    {
      "$ref": "#/$defs/ConnectionReport"
    },
    {
      "$ref": "#/$defs/SourceSnapshot"
    },
    {
      "$ref": "#/$defs/DownloadBudget"
    },
    {
      "$ref": "#/$defs/ConnectionCommand"
    },
    {
      "$ref": "#/$defs/ResourceReport"
    },
    {
      "$ref": "#/$defs/ComponentCapabilities"
    },
    {
      "$ref": "#/$defs/Operation"
    },
    {
      "$ref": "#/$defs/PoolStatus"
    },
    {
      "$ref": "#/$defs/SourceCommand"
    },
    {
      "$ref": "#/$defs/PolicyRecord"
    },
    {
      "$ref": "#/$defs/PolicyCreate"
    },
    {
      "$ref": "#/$defs/PolicyRevoke"
    },
    {
      "$ref": "#/$defs/SourceEndpoint"
    },
    {
      "$ref": "#/$defs/DiscoverCommand"
    },
    {
      "$ref": "#/$defs/ProbeCommand"
    },
    {
      "$ref": "#/$defs/TrialCommand"
    },
    {
      "$ref": "#/$defs/PauseCommand"
    },
    {
      "$ref": "#/$defs/BudgetCommand"
    },
    {
      "$ref": "#/$defs/EngineAck"
    }
  ],
  "description": "Explicit target type selected by endpoint; validate using its $defs. Top-level anyOf is a convenience only."
}

contracts/store-base.sql

-- P2P Downloader v2.2 initial reference schema; not an in-place migration for old v1/v2 databases.
-- Production pins a patched SQLite version (at least 3.51.3 or a verified safe backport) on a local filesystem.
PRAGMA foreign_keys = ON;
PRAGMA journal_mode = WAL;
PRAGMA synchronous = FULL;
PRAGMA busy_timeout = 2500;

CREATE TABLE IF NOT EXISTS schema_migrations (
 version INTEGER PRIMARY KEY, applied_at_ms INTEGER NOT NULL, digest TEXT NOT NULL
) STRICT;
CREATE TABLE component_instances (
 component_id TEXT PRIMARY KEY, component_type TEXT NOT NULL, current_run_id TEXT,
 capability_json TEXT NOT NULL CHECK(json_valid(capability_json)),
 applied_config_revision INTEGER NOT NULL CHECK(applied_config_revision >= 0)
) STRICT;
CREATE TABLE tasks (
 task_id TEXT PRIMARY KEY, component_id TEXT NOT NULL REFERENCES component_instances,
 title TEXT NOT NULL, desired_state TEXT NOT NULL CHECK(desired_state IN ('running','paused','cancelled')),
 execution_state TEXT NOT NULL, placement_state TEXT NOT NULL DEFAULT 'none',
 availability_class TEXT NOT NULL DEFAULT 'unknown' CHECK(availability_class IN ('high','available','unknown','incomplete','low')),
 auto_priority INTEGER NOT NULL DEFAULT 550 CHECK(auto_priority BETWEEN 0 AND 999),
 protected INTEGER NOT NULL DEFAULT 0 CHECK(protected IN (0,1)),
 revision INTEGER NOT NULL DEFAULT 1 CHECK(revision > 0),
 selection_digest TEXT NOT NULL, scope_key TEXT NOT NULL,
 total_selected_bytes INTEGER CHECK(total_selected_bytes >= 0),
 verified_durable_bytes INTEGER NOT NULL DEFAULT 0 CHECK(verified_durable_bytes >= 0),
 allocated_bytes INTEGER CHECK(allocated_bytes >= 0),
 eligible_wait_ms INTEGER NOT NULL DEFAULT 0 CHECK(eligible_wait_ms >= 0),
 last_service_at_ms INTEGER, last_useful_progress_at_ms INTEGER,
 next_probe_at_ms INTEGER, created_at_ms INTEGER NOT NULL,
 CHECK(total_selected_bytes IS NULL OR verified_durable_bytes <= total_selected_bytes)
) STRICT;
CREATE INDEX tasks_dispatch ON tasks(component_id,desired_state,execution_state,auto_priority,created_at_ms);
CREATE INDEX tasks_probe_due ON tasks(next_probe_at_ms,task_id) WHERE desired_state='running';
CREATE TABLE content_keys (
 task_id TEXT NOT NULL REFERENCES tasks, namespace TEXT NOT NULL, algorithm TEXT NOT NULL,
 digest TEXT NOT NULL, scope_key TEXT NOT NULL,
 strength TEXT NOT NULL CHECK(strength IN ('strong_native','verified_equivalence','locator','candidate')),
 PRIMARY KEY(task_id,namespace,algorithm,digest,scope_key)
) STRICT;
CREATE INDEX content_keys_lookup ON content_keys(namespace,algorithm,digest,scope_key);
CREATE TABLE attempts (
 attempt_id TEXT PRIMARY KEY, task_id TEXT NOT NULL REFERENCES tasks, run_id TEXT,
 outcome TEXT NOT NULL, started_at_ms INTEGER NOT NULL, ended_at_ms INTEGER, reason_code TEXT
) STRICT;
CREATE TABLE active_claims (
 claim_id TEXT PRIMARY KEY, claim_key TEXT NOT NULL, task_id TEXT NOT NULL REFERENCES tasks,
 attempt_id TEXT REFERENCES attempts, active INTEGER NOT NULL CHECK(active IN (0,1))
) STRICT;
CREATE UNIQUE INDEX one_active_claim ON active_claims(claim_key) WHERE active=1;
CREATE TABLE native_jobs (
 mapping_id TEXT PRIMARY KEY, task_id TEXT NOT NULL REFERENCES tasks,
 component_id TEXT NOT NULL REFERENCES component_instances, run_id TEXT NOT NULL,
 native_job_id TEXT NOT NULL, mapping_state TEXT NOT NULL,
 UNIQUE(component_id,run_id,native_job_id)
) STRICT;
CREATE TABLE operations (
 operation_id TEXT PRIMARY KEY, request_id TEXT NOT NULL UNIQUE, task_id TEXT REFERENCES tasks,
 action TEXT NOT NULL, payload_digest TEXT NOT NULL, state TEXT NOT NULL,
 expected_revision INTEGER, created_at_ms INTEGER NOT NULL, completed_at_ms INTEGER
) STRICT;
CREATE TABLE command_outbox (
 command_id TEXT PRIMARY KEY, operation_id TEXT NOT NULL REFERENCES operations,
 task_id TEXT NOT NULL REFERENCES tasks, expected_run_id TEXT NOT NULL,
 expected_revision INTEGER NOT NULL, config_revision INTEGER NOT NULL,
 payload_json TEXT NOT NULL CHECK(json_valid(payload_json)),
 state TEXT NOT NULL CHECK(state IN ('pending','sent','acknowledged','unknown','reconciled','rejected')),
 created_at_ms INTEGER NOT NULL
) STRICT;
CREATE INDEX outbox_pending ON command_outbox(state,created_at_ms);
CREATE TABLE resource_leases (
 lease_id TEXT PRIMARY KEY, task_id TEXT REFERENCES tasks, component_id TEXT NOT NULL REFERENCES component_instances,
 run_id TEXT NOT NULL, generation INTEGER NOT NULL CHECK(generation>0), mode TEXT NOT NULL,
 reservation_json TEXT NOT NULL CHECK(json_valid(reservation_json)),
 enforcement TEXT NOT NULL CHECK(enforcement IN ('hard_native','soft_observed','unsupported')),
 state TEXT NOT NULL CHECK(state IN ('reserved','active','draining','unknown','released')),
 expires_at_ms INTEGER NOT NULL, stopped_confirmed_at_ms INTEGER
) STRICT;
CREATE INDEX leases_accounting ON resource_leases(state,component_id);
CREATE TABLE probe_runs (
 probe_id TEXT PRIMARY KEY, task_id TEXT NOT NULL REFERENCES tasks, run_id TEXT NOT NULL,
 level TEXT NOT NULL, started_at_ms INTEGER NOT NULL, ended_at_ms INTEGER,
 qualified INTEGER NOT NULL CHECK(qualified IN (0,1)), outcome TEXT NOT NULL,
 evidence_json TEXT NOT NULL CHECK(json_valid(evidence_json))
) STRICT;
CREATE INDEX probe_task_time ON probe_runs(task_id,started_at_ms);
CREATE TABLE resource_assessments (
 task_id TEXT PRIMARY KEY REFERENCES tasks, source_run_id TEXT NOT NULL, report_seq INTEGER NOT NULL,
 assessed_at_ms INTEGER NOT NULL, expires_at_ms INTEGER NOT NULL,
 coverage_scope TEXT NOT NULL, quality TEXT NOT NULL,
 summary_json TEXT NOT NULL CHECK(json_valid(summary_json)), config_revision INTEGER NOT NULL
) STRICT;
CREATE TABLE scheduler_decisions (
 decision_id INTEGER PRIMARY KEY, task_id TEXT NOT NULL REFERENCES tasks,
 decision_type TEXT NOT NULL, priority INTEGER CHECK(priority BETWEEN 0 AND 999),
 reasons_json TEXT NOT NULL CHECK(json_valid(reasons_json)),
 config_revision INTEGER NOT NULL, input_report_seq INTEGER, created_at_ms INTEGER NOT NULL
) STRICT;
CREATE TABLE domain_events (
 event_seq INTEGER PRIMARY KEY AUTOINCREMENT, event_id TEXT NOT NULL UNIQUE,
 task_id TEXT REFERENCES tasks, attempt_id TEXT REFERENCES attempts,
 component_id TEXT, run_id TEXT, producer_seq INTEGER,
 event_type TEXT NOT NULL, payload_json TEXT NOT NULL CHECK(json_valid(payload_json)),
 committed_at_ms INTEGER NOT NULL,
 UNIQUE(component_id,run_id,producer_seq)
) STRICT;
CREATE INDEX events_task_cursor ON domain_events(task_id,event_seq);
CREATE TABLE volumes (
 volume_id TEXT PRIMARY KEY, root_path TEXT NOT NULL, filesystem_identity TEXT NOT NULL,
 storage_policy_revision INTEGER NOT NULL
) STRICT;
CREATE TABLE task_storage (
 task_id TEXT PRIMARY KEY REFERENCES tasks, volume_id TEXT NOT NULL REFERENCES volumes,
 storage_key TEXT NOT NULL CHECK(length(storage_key)=64), layout_version INTEGER NOT NULL,
 relative_path TEXT NOT NULL, payload_created INTEGER NOT NULL CHECK(payload_created IN (0,1)),
 native_checkpoint_ref TEXT, checkpoint_digest TEXT,
 logical_bytes INTEGER CHECK(logical_bytes>=0), allocated_bytes INTEGER CHECK(allocated_bytes>=0),
 accounted_at_ms INTEGER
) STRICT;
CREATE TABLE artifacts (
 artifact_id TEXT PRIMARY KEY, task_id TEXT NOT NULL REFERENCES tasks,
 volume_id TEXT NOT NULL REFERENCES volumes, relative_path TEXT NOT NULL,
 selection_digest TEXT NOT NULL, verification_level TEXT NOT NULL,
 presence TEXT NOT NULL CHECK(presence IN ('present','missing','changed','unchecked','deleted')),
 placement_state TEXT NOT NULL, manifest_digest TEXT NOT NULL, verified_at_ms INTEGER,
 UNIQUE(volume_id,relative_path)
) STRICT;
CREATE TABLE artifact_refs (
 artifact_id TEXT NOT NULL REFERENCES artifacts, owner_kind TEXT NOT NULL, owner_id TEXT NOT NULL,
 state TEXT NOT NULL, PRIMARY KEY(artifact_id,owner_kind,owner_id)
) STRICT;
CREATE TABLE file_operations (
 file_op_id TEXT PRIMARY KEY, task_id TEXT NOT NULL REFERENCES tasks, request_id TEXT NOT NULL UNIQUE,
 kind TEXT NOT NULL CHECK(kind IN ('publish','move','quarantine','restore','purge')),
 phase TEXT NOT NULL, expected_task_revision INTEGER NOT NULL,
 source_volume_id TEXT NOT NULL REFERENCES volumes, destination_volume_id TEXT REFERENCES volumes,
 source_path TEXT NOT NULL, destination_path TEXT,
 source_fingerprint TEXT NOT NULL, manifest_digest TEXT NOT NULL,
 copied_bytes INTEGER NOT NULL DEFAULT 0 CHECK(copied_bytes>=0),
 policy_revision INTEGER NOT NULL, created_at_ms INTEGER NOT NULL, updated_at_ms INTEGER NOT NULL
) STRICT;
CREATE INDEX file_operations_pending ON file_operations(phase,updated_at_ms);
CREATE TABLE dead_candidates (
 task_id TEXT PRIMARY KEY REFERENCES tasks, qualified_rounds INTEGER NOT NULL,
 distinct_probe_days INTEGER NOT NULL, reason_code TEXT NOT NULL,
 candidate_at_ms INTEGER NOT NULL, quarantined_at_ms INTEGER, delete_not_before_ms INTEGER,
 policy_revision INTEGER NOT NULL, stale INTEGER NOT NULL DEFAULT 0 CHECK(stale IN (0,1))
) STRICT;
CREATE INDEX cleanup_due ON dead_candidates(delete_not_before_ms,task_id) WHERE stale=0;
CREATE TABLE history_tombstones (
 tombstone_id TEXT PRIMARY KEY, task_id TEXT NOT NULL REFERENCES tasks,
 native_keys_json TEXT NOT NULL CHECK(json_valid(native_keys_json)),
 outcome TEXT NOT NULL, deleted_bytes INTEGER NOT NULL CHECK(deleted_bytes>=0),
 reason_code TEXT NOT NULL, policy_revision INTEGER NOT NULL, created_at_ms INTEGER NOT NULL
) STRICT;
-- Per-second traffic, peer-list history, country distributions, RTT, etc. do not go in this core DB; P2P Metrics stores them in its own DB.
-- Each token pool's vector check and lease + outbox creation must occur within the same BEGIN IMMEDIATE.

contracts/store-v23.sql

-- Additive migration for the v2.2 reference schema; first check the baseline schema hash on a backup copy.
-- This file does not touch payloads, delete history, or change user_version itself. The migration runner records the version in the same transaction.
CREATE TABLE discovery_targets (
 task_id TEXT PRIMARY KEY REFERENCES tasks(task_id),
 phase TEXT NOT NULL CHECK(phase IN ('collecting','rank_ready','trial','active','observing','held','finished')),
 observation_reason TEXT, eligibility_at_ms INTEGER, revision INTEGER NOT NULL DEFAULT 1 CHECK(revision>0),
 qualified_wait_ms INTEGER NOT NULL DEFAULT 0 CHECK(qualified_wait_ms>=0)
) STRICT;
CREATE INDEX discovery_due ON discovery_targets(phase,eligibility_at_ms,task_id);
CREATE TABLE source_snapshots (
 snapshot_id TEXT PRIMARY KEY, task_id TEXT NOT NULL REFERENCES tasks,
 source_id TEXT NOT NULL, realm TEXT NOT NULL, run_id TEXT NOT NULL,
 sequence INTEGER NOT NULL CHECK(sequence>=0), selection_digest TEXT NOT NULL, observation_ms INTEGER NOT NULL, expires_ms INTEGER NOT NULL,
 completeness TEXT NOT NULL CHECK(completeness IN ('complete','partial','unknown')),
 evidence_json TEXT NOT NULL CHECK(json_valid(evidence_json)),
 UNIQUE(task_id,source_id,run_id,sequence), CHECK(expires_ms>=observation_ms)
) STRICT;
CREATE INDEX snapshots_lookup ON source_snapshots(task_id,expires_ms);
CREATE TABLE connection_identities (
 connection_id TEXT PRIMARY KEY, component_id TEXT NOT NULL REFERENCES component_instances,
 run_id TEXT NOT NULL, native_connection_key TEXT NOT NULL, transport_handle_id TEXT NOT NULL, realm TEXT NOT NULL,
 role TEXT NOT NULL, source_key TEXT NOT NULL, task_id TEXT REFERENCES tasks,
 opened_ms INTEGER NOT NULL, closed_ms INTEGER, last_sample_seq INTEGER,
 close_reason TEXT, CHECK(closed_ms IS NULL OR closed_ms>=opened_ms),
 UNIQUE(component_id,run_id,native_connection_key,opened_ms)
) STRICT;
CREATE TABLE connection_evidence (
 evidence_id TEXT PRIMARY KEY, connection_id TEXT REFERENCES connection_identities,
 task_id TEXT REFERENCES tasks, classification TEXT NOT NULL, reason_code TEXT NOT NULL,
 evidence_strength TEXT NOT NULL CHECK(evidence_strength IN ('observed','attributed','suspected','unknown')),
 sample_digest TEXT NOT NULL, evidence_json TEXT NOT NULL CHECK(json_valid(evidence_json)),
 config_revision INTEGER NOT NULL, created_ms INTEGER NOT NULL
) STRICT;
CREATE TABLE connection_policies (
 policy_id TEXT PRIMARY KEY, realm TEXT NOT NULL, target_kind TEXT NOT NULL,
 target_key TEXT NOT NULL, content_scope TEXT,
 action TEXT NOT NULL CHECK(action IN ('avoid','quarantine','manual_deny','allow_override')),
 state TEXT NOT NULL CHECK(state IN ('pending','enforced','expired','revoked','unknown','unsupported')),
 strikes INTEGER NOT NULL CHECK(strikes>=0), expires_ms INTEGER,
 evidence_id TEXT NOT NULL REFERENCES connection_evidence,
 revision INTEGER NOT NULL DEFAULT 1, created_ms INTEGER NOT NULL,
 CHECK(action='manual_deny' OR expires_ms IS NOT NULL), CHECK(revision>0)
) STRICT;
CREATE INDEX policies_target ON connection_policies(realm,target_kind,target_key,expires_ms);
CREATE TABLE connection_commands (
 command_id TEXT PRIMARY KEY, operation_id TEXT NOT NULL UNIQUE REFERENCES operations, request_id TEXT NOT NULL UNIQUE, payload_digest TEXT NOT NULL,
 connection_id TEXT NOT NULL REFERENCES connection_identities, expected_run_id TEXT NOT NULL,
 expected_policy_revision INTEGER NOT NULL, task_id TEXT REFERENCES tasks, action TEXT NOT NULL, scope TEXT NOT NULL,
 evidence_id TEXT REFERENCES connection_evidence,
 outcome TEXT NOT NULL CHECK(outcome IN ('pending','sent','applied','already_closed','unsupported_scope','stale_target','unknown','failed')),
 created_ms INTEGER NOT NULL, observed_ms INTEGER
) STRICT;
CREATE TABLE catalog_feeds (
 feed_id TEXT PRIMARY KEY, uri TEXT NOT NULL, lineage_group TEXT NOT NULL, enabled INTEGER NOT NULL CHECK(enabled IN (0,1)),
 approved_config_revision INTEGER NOT NULL, last_good_digest TEXT, last_checked_ms INTEGER,
 status TEXT NOT NULL
) STRICT;
CREATE TABLE catalog_revisions (
 revision_id TEXT PRIMARY KEY, feed_id TEXT NOT NULL REFERENCES catalog_feeds,
 content_digest TEXT NOT NULL, status TEXT NOT NULL CHECK(status IN ('staged','validated','rejected','published','withdrawn')),
 source_etag TEXT, fetched_ms INTEGER NOT NULL, diff_json TEXT NOT NULL CHECK(json_valid(diff_json)),
 UNIQUE(feed_id,content_digest)
) STRICT;
CREATE TABLE catalog_endpoints (
 endpoint_id TEXT PRIMARY KEY, canonical_uri TEXT NOT NULL, realm TEXT NOT NULL, kind TEXT NOT NULL,
 state TEXT NOT NULL CHECK(state IN ('candidate','validated','probing','usable_observed','quarantined','retired','manual_review')),
 first_seen_ms INTEGER NOT NULL, last_seen_ms INTEGER NOT NULL, next_probe_ms INTEGER,
 risk_state TEXT NOT NULL DEFAULT 'unknown', UNIQUE(realm,kind,canonical_uri)
) STRICT;
CREATE TABLE catalog_provenance (
 endpoint_id TEXT NOT NULL REFERENCES catalog_endpoints, revision_id TEXT NOT NULL REFERENCES catalog_revisions,
 source_line INTEGER CHECK(source_line>0), PRIMARY KEY(endpoint_id,revision_id)
) STRICT;
-- current connection status/history high-frequency series remain owned by P2P Metrics;
-- Store only retains lifecycle indexes, evidence behind decisions, and durable commands.
CREATE TABLE connection_tasks (
 connection_id TEXT NOT NULL REFERENCES connection_identities,
 task_id TEXT NOT NULL REFERENCES tasks,
 PRIMARY KEY(connection_id,task_id)
) STRICT;

-- Detached/manual policy changes also need a durable command path without a live connection.
CREATE TABLE policy_commands (
 command_id TEXT PRIMARY KEY, operation_id TEXT NOT NULL UNIQUE REFERENCES operations,
 request_id TEXT NOT NULL UNIQUE, policy_id TEXT NOT NULL REFERENCES connection_policies,
 expected_revision INTEGER NOT NULL CHECK(expected_revision>0),
 payload_json TEXT NOT NULL CHECK(json_valid(payload_json)),
 outcome TEXT NOT NULL CHECK(outcome IN ('pending','sent','applied','unsupported_scope','unknown','failed')),
 created_ms INTEGER NOT NULL, observed_ms INTEGER
) STRICT;

examples/avoid-command.json

{
  "schema_version": "2.3",
  "request_id": "req_example_18",
  "connection_id": "conn_example_17",
  "expected_run_id": "run_example_4",
  "expected_policy_revision": 3,
  "action": "avoid",
  "scope": "realm_content_source",
  "automatic": true,
  "duration_ms": 60000,
  "evidence_id": "evidence_example_5",
  "reason_code": "QUALIFIED_NO_PAYLOAD",
  "task_id": "task_1"
}

examples/connection-report.json

{
  "schema_version": "2.3",
  "identity": {
    "connection_id": "conn_example_17",
    "component_id": "mule_1",
    "run_id": "run_example_4",
    "native_connection_key": "socket17",
    "transport_handle_id": "transport17",
    "realm": "ed2k",
    "task_ids": [
      "task_1"
    ]
  },
  "sequence": "10",
  "sample_interval_ms": 1000,
  "observed_age_ms": 50,
  "reporting": "exact",
  "role": "payload",
  "endpoint": "example-not-dialed:4662",
  "country": null,
  "country_source": null,
  "peer_id": "claimed_example",
  "identity_strength": "claimed",
  "remote_choked": false,
  "remote_queued": false,
  "service_expected": true,
  "outstanding_requests": 2,
  "queued_disk_bytes": "0",
  "local_blocked": false,
  "delta_payload_bytes": 0,
  "delta_unique_bytes": 0,
  "delta_verified_bytes": 0,
  "rtt_ms": 80,
  "rtt_method": "transport_sample",
  "qualified_idle_ms": 35000,
  "missing_reason": null,
  "native_state": {
    "handshake_complete": true,
    "interested": true,
    "needed_overlap": true,
    "slot_granted": true,
    "remote_queue_rank": null,
    "receive_credit_bytes": 1048576,
    "service_generation": "service_3",
    "protocol_deadline_ms": 30000,
    "common_path_outage": false,
    "enforcement_capabilities": [
      "disconnect_connection",
      "avoid_content_source"
    ]
  },
  "performance": {
    "ttfb_ms": null,
    "request_p50_ms": null,
    "request_p95_ms": null,
    "delta_duplicate_bytes": 0,
    "delta_discarded_bytes": 0,
    "upload_payload_bytes_per_second": 0,
    "payload_bytes_per_second": 0,
    "unique_bytes_per_second": 0,
    "country_db_version": null,
    "asn": null,
    "native_id_class": "high_id_claimed",
    "integrity_attribution": "none"
  }
}

examples/manual-policy.json

{
  "request_id": "req_manual_7",
  "expected_revision": 3,
  "action": "manual_deny",
  "scope": "realm_content_source",
  "realm": "ed2k",
  "target_key": "source_example",
  "content_key": "content_example",
  "expires_at_ms": null,
  "reason": "Manually specified example; does not imply a real endpoint is malicious"
}

examples/pool-status.json

{
  "policy_revision": 3,
  "active_tasks": 5,
  "trial_tasks": 2,
  "observing_tasks": 18,
  "collecting_tasks": 975,
  "network_capacity_bytes_per_second": 100000000,
  "capacity_basis": "configured",
  "utilization": 0.5,
  "local_pressure": 0.2,
  "control_action": "trial_more",
  "reason_code": "NETWORK_HEADROOM",
  "samples_fresh": true,
  "registered_tasks": 1000,
  "rank_ready_tasks": 0,
  "held_tasks": 0,
  "finished_tasks": 0
}

examples/trial-command.json

{
  "request_id": "req_trial_1",
  "task_id": "task_1",
  "expected_task_revision": 1,
  "expected_run_id": "run_example_4",
  "config_revision": 3,
  "deadline_ms": 1790982000000,
  "action": "start_trial",
  "source_snapshot_id": "snapshot_1",
  "budget": {
    "task_id": "task_1",
    "run_id": "run_example_4",
    "generation": 3,
    "network_domain": "link_a",
    "storage_domain": "ssd_a",
    "mode": "trial",
    "network_bytes_per_second": 2097152,
    "write_window_bytes": 4194304,
    "memory_bytes": 8388608,
    "peer_credit": 2,
    "expires_at_ms": 1790982000000,
    "enforcement": "hard_native"
  },
  "verification_extension_allowed": true
}

# P2P Downloader v2.3: core architecture and connection governance

## 01 | What changes in this revision

## 02 | Overview: nine logical components, not nine microservices

## 03 | 1,000 at once: two paths running together

## 04 | A precise implementation of unlimited half-connections

## 05 | State model: separate jobs, connections, and source quality

## 06 | Source completeness and priorities

## 07 | Trial Controller: connecting alone does not earn promotion

## 08 | Elastic download pool: task count is an outcome, not a target

## 09 | Control algorithms, oscillation, and fairness

## 10 | Connection Manager: explain every connection

10.1 Connection ID levels must be separated into three dimensions

## 11 | Zero traffic: count faults only when eligible for service

## 12 | A blacklist is not a single permanent IP list

## 13 | Capability limits in judging phishing, entrapment, monitoring, and safety

## 14 | Capability interfaces: precise governance needs more than coarse adapters

## 15 | Tracker and eD2k: collect broadly, use in tiers

## 16 | Config defaults and automatic update governance

## 17 | Automatic safety awareness and source-benefit analysis

## 18 | Downloader and Engine inputs, outputs, and commands

18.1 Types and default semantics

## 19 | Recoverable commands and races

## 20 | SQLite and data ownership

## 21 | Pool rotation must not disrupt the file lifecycle

## 22 | React workbench: every decision is reviewable

## 23 | Resource and performance targets: measurements required, not guarantees

## 24 | Migration, rollback, and development order

## 25 | Known limitations and delivery status

## Work through the situations you are concerned about, one by one.

1. Dynamic pool decisions

2. Why treat two cases of not downloading differently?

3. Default candidate catalog

4. Your review notes

## Delivery and verification boundaries

## Original contracts, configuration, and development handoff

P2P Downloader v2.3: core architecture and connection governance

01 | What changes in this revision

02 | Overview: nine logical components, not nine microservices

03 | 1,000 at once: two paths running together

04 | A precise implementation of unlimited half-connections

05 | State model: separate jobs, connections, and source quality

06 | Source completeness and priorities

07 | Trial Controller: connecting alone does not earn promotion

08 | Elastic download pool: task count is an outcome, not a target

09 | Control algorithms, oscillation, and fairness

10 | Connection Manager: explain every connection

11 | Zero traffic: count faults only when eligible for service

12 | A blacklist is not a single permanent IP list

13 | Capability limits in judging phishing, entrapment, monitoring, and safety

14 | Capability interfaces: precise governance needs more than coarse adapters

15 | Tracker and eD2k: collect broadly, use in tiers

16 | Config defaults and automatic update governance

17 | Automatic safety awareness and source-benefit analysis

18 | Downloader and Engine inputs, outputs, and commands

19 | Recoverable commands and races

20 | SQLite and data ownership

21 | Pool rotation must not disrupt the file lifecycle

22 | React workbench: every decision is reviewable

23 | Resource and performance targets: measurements required, not guarantees

24 | Migration, rollback, and development order

25 | Known limitations and delivery status

Work through the situations you are concerned about, one by one.

Delivery and verification boundaries

Original contracts, configuration, and development handoff