Skip to content

Server product contract

This additive contract is separate from the schema-2 canonical record archive. Server Phase 8 and narrow Phase 9 consumption are operator-accepted at 744b840 / v0.6.19-phase8-q2; see acceptance and future scope and qualification limits. This document does not activate processing. GOES/HRIT and its existing color recipes are the production adapters; the non-imagery processor is test-only.

The compiled registry declares each processor's versioned input kinds, semantic and configuration revisions, output schemas, ordering/state requirements and bounded resource estimates. Scheduling, supervision, durable publication and delivery consume those declarations. A protocol adapter supplies reconstruction, typed metadata validation, partial-revision preference and opaque state. A stateless processor needs only durable progress and may produce no assets.

products.hpp defines envelope version 1. Its fields are:

Field Contract
version Integer 1. Unknown versions fail validation.
observationId Full SHA-256 logical observation identifier supplied and validated by the typed adapter.
receptionId SHA-256 of the canonical JSON array ["rfsentry-product-reception-v1", namespace, producerUuid, streamUuid, runEpoch, observationId].
kind observations, messages or product.
source Original canonical record identity; exact decimal sequence, never a database ordinal.
inputs At most 256 original first/last identity and canonical-hash ranges, labelled contributing or context. Sparse missing input remains separate evidence.
processor Registered ID, semantic revision, configuration revision and full configuration SHA-256.
recipe Null or a versioned recipe ID/revision.
revision Positive exact decimal revision.
completeness partial or complete.
missingInputs At most 256 reason/range entries; unknown extent has null bounds. Imagery-specific masks belong to the output schema.
times Distinct observation (nullable), first/last reception and processing UTC milliseconds, encoded as decimal strings.
output Registered schema name/version and its validated typed metadata.
assets Zero to sixteen immutable descriptors: role, supported format, exact encoded byte size and SHA-256. No path or remote URL.
execution Server instance, build, backend and processing time. Execution provenance does not contribute to reception identity.

The complete manifest is bounded to 128 KiB. Schema validators receive the whole envelope so they can bind metadata to original lineage and asset descriptors, including decoded allocation bounds. A native in-memory product structure is not a wire validator. Transfer chunks are at most 256 KiB.

The semantic content hash excludes execution provenance, product revision, processing time and transport receipt times. Adapters also normalize their typed metadata to exclude transport-only presentation fields. Replaying equivalent output on another Server/backend is idempotent. A complete revision supersedes a partial; a delayed partial cannot replace a complete. The typed adapter ranks partials. Different complete results are conflicts and must remain inspectable rather than silently overwrite.

Stateful checkpoint envelopes bind schema/version, processor/revision, configurationRevision, configuration hash, source and original input position to an opaque byte size and hash. Streaming save/restore is independent of output format. Checkpoints, processor progress, acquisition durability/ACKs and browser discovery/fetch positions are distinct authorities.

A missing or changed checkpoint configuration revision returns processor-checkpoint-incompatible. Recovery must select a compatible checkpoint or an explicit valid replay boundary; an unchanged configuration hash does not prove unchanged configuration semantics. Contributing/context and known missing input ranges must match the source's producer namespace, producer and stream. A range may describe another run epoch; its two endpoints must share that run. Both null missing-input endpoints explicitly mean unknown extent.

Processing admission is independent of SQLite capacity policy. It measures CPU affinity and visible cgroup quota, host available memory and visible cgroup memory limits. Aggregate accounting is observed resident memory plus the unmaterialized part of each reserved peak, plus shared work. Optional processing must leave explicit protected memory/CPU and additional acquisition headroom when co-location is selected. Unknown host capacity stops admission. Resource declarations and admission alone do not qualify a decoder's working set. Runtime supervision/recovery is implemented and tested; workload-specific peaks and unmeasured hardware limits remain separate from the accepted functional scope.

The generic worker channel uses a fixed executable entry point, bounded CBOR messages and 256-KiB asset/checkpoint chunks. Each worker owns one original producer/stream context and checks registered input kinds/versions. Its adapter keeps decoding semantics. Result ownership transfers into a bounded immutable queue; declarations must reserve the transient old-plus-new output peak. Checkpoint save and restore are sequential pull operations, with exact offsets and declared size limits. Cancellation is terminal for that worker object, and callers must retain its resource reservation until the process is reaped.

The supervisor opens process-bound CPU/RSS observation handles behind a private startup barrier. The worker then disables process dumping before accepting configuration or canonical input. Retained handles remain readable when the packaged ProtectProc=invisible policy hides subsequent procfs path lookups; privacy is not relaxed to obtain telemetry. Cancellation retains ownership until reaping, and observation failures remain explicit. Bounded worker failure text survives IPC into scheduler status and the processing journal event.

The channel is connected to the generic scheduler and a compiled native GOES registration. A test-only stateful observation processor exercises the same scheduler, canonical archive reads, durable publication, cancellation and restart. A worker checkpoint chunk alone does not establish durable processing progress.

Compiled processors may also declare immutable-product inputs, required named slots, bounded input resource costs and supported child processors. This graph must be acyclic. These stateless tasks use the same supervised channel and aggregate admission as record processors. Each asset is pulled once in exact 256-KiB ranges and verified against its immutable descriptor before outputs are eligible for publication. No path or network authority is passed to an adapter.

Publication and recovery

Products use an additive catalog (schema 1 foundation, 2 immutable tasks, 3 failure recovery, 4 packs, 5 partial retirement, 6 exact processing coverage) under <local-state>/products/<archiveUuid>/catalog.sqlite; immutable assets, checkpoints, canonical replay journals and staging live in the selected archive's products-v1 directory. Owner locks, source-generation markers, inode and mount bindings prevent fallback to missing/replaced storage. Existing record schema 2 and its WAL are unchanged. The product catalog uses FULL-synchronous SQLite WAL transactions and incremental reclamation. Interactive reads use independent read-only snapshots with a four-reader/eight-waiter FIFO admission queue. Catalog transactions end before asset transfer; a separate short acquisition gate protects the lookup/open interval against retention, and open descriptors remain readable after unlink. The product WAL has a 32-MiB write ceiling, non-waiting checkpoint maintenance, and metadata/filesystem accounting that includes WAL and shared-memory files. The record archive retains its existing independent schema and capacity policy.

  1. Acquire an original stream/context generation and reserve metadata and old-plus-new allocation peaks. Staging ownership commits before file creation.
  2. Stream bounded chunks into a batch-owned pack (small assets) or owned loose file (large assets/checkpoints), checking declared length, hash and limits. Record extent ownership; packed bytes remain pending until group sync.
  3. Store validated pending output manifests with only batch-owned asset descriptors. Save a streamed opaque checkpoint or append a bounded hash-chained canonical replay journal bound to the prior checkpoint/configuration.
  4. Synchronize completed packs and both asset directories, then durably prepare its position/checkpoint/replay tuple. One catalog transaction publishes revisions, links and changes and advances that tuple.
  5. Only after commit reclaim unreferenced prior assets/checkpoints/journals. Recovery publishes a prepared current-generation batch or abandons unfinished staging. Work is bounded per maintenance turn. Replayed output is idempotent.

A cancelled worker's reservation stays charged through process reaping. Late results fail their generation fence. Acquisition durability/ACKs remain owned by the record archive; product-storage pressure cannot advance those ACKs or force record retirement. Product retention is independently explicit and emits change records; a compact tombstone prevents processing replay from resurrecting a retired product.

Matching hints are compact scheduler metadata, separate from logical observation metadata. The first such publication upgrades only the product catalog to schema 2, adding bounded task/group/input-reference tables. It does not change record schema 2 or enable a processor. Input references, pending tasks and published source versions commit together. A changed input signature fences an older running task; task output and queue completion commit together. Product expiry does not pin source assets, and expired task inputs are counted explicitly. Idle record owners can yield at a durable point so a task fits a one-worker allowance. Disabling or pausing its parent stops task admission and cancels owned workers while retaining their reservations through reaping.

Stateful adapters can freeze an exact checkpoint-size plan before storage reservation. The conservative declared maximum remains the fallback. This avoids rejecting an actual replacement that fits solely because its theoretical maximum does not fit. The prior checkpoint remains referenced until publication commits. Retained, already materialized outputs may recover under their persisted producer binding after a configuration-semantics upgrade if their typed schema remains supported. That validation mode never authorizes restoring an incompatible checkpoint or producing new output with an obsolete configuration revision.

The GOES adapter uses the shared C++ reconstruction library, preserving original LRIT/text bytes, native raster pixels, receipt times and exact canonical lineage. Historical execution is a nonsemantic scheduling hint. It coalesces intermediate mosaic renders while preserving immediately eligible files, complete candidates and terminal partials. Dirty strips remain recoverable in the unchanged native checkpoint; cadence state needs no new checkpoint/configuration identity. It isolates item limits and codec failures, preserving original evidence and valid partial/base products while later input continues. Native gap/timeout finalization drains bounded products cooperatively. Browser reconstruction keeps its existing partial-flush policy. Native geometry is checked before pixel allocation. GOES-specific schema fields and assembler state stay outside the scheduler/store.

Delivery

The authenticated GET endpoints /api/v1/products/capabilities, catalog, changes, detail and asset reuse browser trust and records.read stream scope. Catalog pages contain at most 32 manifests and 256 KiB, newest first, with a stable ordinal fence and a change cursor. The tuple continuation contains receipt time and product ID. Changes are bounded; expired/future/generation- changed cursors explicitly require another bounded snapshot. Detail can select an immutable revision and reports conflicting complete revisions.

Asset requests select only an authorized stream/product/revision/role/hash and an exact offset/count of at most 256 KiB. Responses bind ETag, Content-Range and byte length. Arbitrary filesystem paths and remote URLs are unsupported. Checkpoints and replay journals are never downloadable as product assets.

The generic sources page exposes original producer namespace/stream contexts and declared inputs/output schemas even after corresponding records expire. Recent-history activation anchors its window to the retained tail, including disconnected appliances. Idle live owners yield a constrained worker slot to backfill, with fresh-input probes requesting a yield at a durable safe point.

The browser selects Server products explicitly. Its separate synchronization worker commits discovery cursors with pending-work records, transfers immutable 256-KiB ranges into OPFS, and verifies length/hash and successful close before typed adapter dispatch. SATCOM imports reuse the completed-product publication boundary and existing archive/viewers. An IndexedDB transaction publishes asset references, product revision and completed-fetch receipt together. Previous assets survive failed replacement; bounded garbage records retire them after commit. Reload resumes pending transfer; Server deletion does not delete browser retention. Discovery/fetch positions never serve as decoder state or ACKs.

GOES schema 2 adds compact PNG thumbnails and explicit received-pixel evidence: coverageEncoding is lsb-received-v1, all-received or unknown. An LSB mask has exactly ceil(width*height/8) bytes; placeholder grayscale values never imply missing evidence. Native dimensions/assets remain unchanged. Schema 1 remains readable. Both versions use the compatible opaque assembler checkpoint; this asset-only schema addition does not change configuration/reconstruction semantics. Multiplexed first/last canonical ranges are labelled context, with exact hashes. Thumbnail encoding is excluded from semantic conflict detection.

The shared C++ imagery library implements the existing natural-color/Day-Night pixel semantics, pinned color tables and the browser's Astronomy Engine model, with streamed PNG rows and bounded native PNG/JPEG/GIF decoding. The compiled goes-color product-input adapter now registers Natural Color and Day/Night configuration recipes and the typed goes.hrit.color version-1 output. Matching uses original source/epoch/configuration, exact ABI spacecraft/sector/scan and resolution-independent received navigation. Complete legacy images remain eligible; partials require a received-pixel mask. Day/Night requires broadcast Kelvin calibration and navigation. A missing prerequisite or deterministic recipe failure records a deferred task outcome; successful base products are unchanged.

Both new base publication hints and bounded retained-catalog pages feed the same durable task groups. Retained matching saves its snapshot position, reads only compact matching details outside database ownership, and charges the existing I/O limiter. It never reconstructs records merely to derive retained images. Matching is idempotent across restart and input revision changes fence stale results. Pending/running tasks are limited to 256; a full queue retains matching references and refills later instead of failing base publication. The most recent 256 deferred task contexts remain deliberately retryable; older diagnostic contexts expire while their unchanged signatures prevent automatic retry loops. All detailed failure retention remains independently bounded.

Admission includes scalar inputs, one encoded/decode overlap, encoder/output ownership and IPC copies. When a task fits only after its record owner exits, the existing scheduler yields at a durable boundary for one task, retains the worker reservation through reaping, then resumes the saved record position. Capable hosts can continue independent record and recipe workers concurrently.

Browser discovery prioritizes recent thumbnails/details/text. Native imagery is selected on demand by default, or automatically within an operator-selected recent window. Originals are on demand or explicitly retained. These policies reuse the synchronization journal, OPFS objects and SATCOM publication receipt; adding an asset to the same revision preserves the reception and previously retained matching assets. Selection/export requests use the existing source port. A shared browser staging lock and aggregate pending-byte check bound concurrent sources. Transfer turns yield between assets; selection can interrupt a background transfer at its durable prefix and resume it later. Memory admission remains separate and covers metadata parsing/publication; full images are not hydrated into RAM for download. Quota/network failures retain pending work and prior publication.

Unsupported schemas with valid common envelopes are accounted for atomically with discovery, with 128 compact recent references plus aggregate counts. They do not stop compatible products. Installing an adapter or changing fetch policy starts a bounded snapshot resynchronization; retained local products survive. Existing completed receipts are reused, and changed fetch policies also apply to products already discovered. The UI distinguishes remote roles, local thumbnails and native offline readiness. Functional acceptance and exact-source installed qualification are recorded in validation. They do not establish universal production GOES working sets or catch-up speed.

Batch-owned product packs (0.6.18)

The first new publication batch upgrades the additive catalog to schema 4. Older binaries reject this version; record schema 2, checkpoint envelopes and canonical replay formats are unchanged. Existing loose assets remain readable without migration. New small assets stream in existing bounded chunks into batch-owned p-<uuid> packs. The target is the smaller of 64 MiB, one quarter of the staging allowance and one quarter of the asset allowance. Larger assets use the existing streamed loose-file path; the target is not an image-size cap. Packs roll at the target or 512 extents, with at most 128 per batch. No whole pack is retained in RAM.

Logical hashes, lengths, roles and revision identities are unchanged. Internal locators bind a pack identifier, byte offset and length. Browser and native recipe reads use the same authorized range interface, acquiring an open file under the existing reader lifetime gate before releasing the catalog snapshot. Open readers retain a bounded physical-file pin. Retention and compaction keep the old allocation charged until those range reads close their descriptors; publication and other readers continue while a pin exists.

Pack ownership precedes file creation. Each unfinished append has an allocation reservation; completed unsealed bytes remain charged to staging and asset limits, including future allocation until synchronization. Preparation rejects unfinished tails, synchronizes every completed pack and both directories, then atomically records durable locators with the prepared recovery tuple. Only that prepared batch can publish products/outcomes and processing progress. Before streaming a large loose asset or checkpoint, completed asset packs may synchronize early and release their staging charge; their physical allocation stays charged and they remain owned by the unpublished batch. This preserves large-file staging headroom. An unsealed extent is never a durable duplicate; competing batches may safely stage the same hash, and publication retains one logical asset. Recovery abandons an unprepared pack or publishes the already synchronized prepared batch. Partially written tails are never interpreted as committed assets.

Final allocation is sampled after the writer closes, using authoritative file attributes where supported, so transient open-file preallocation does not become a permanent charge. A bounded startup checkpoint pass and maintenance pages reconcile older immutable-file charges without rewriting payloads or limits.

Physical pack allocation stays charged after individual assets expire. Whole unreferenced packs are unlinked and directory-synchronized before their ownership is deleted. Bounded maintenance examines at most 32 packs per compaction pass, rewrites at most one pack (up to 64 MiB and 512 extents) through a 256-KiB buffer, and normally requires at least one quarter dead logical bytes. Storage pressure can reclaim smaller dead fractions. Old-plus-new disk headroom is reserved first; all copied assets are hash verified. New data and directory names are synchronized before an atomic locator switch; old-pack deletion follows separately. Interrupted compaction leaves either old locators or complete new locators, with the unused copy still owned and reclaimable. Compaction uses the shared processing I/O allowance; startup recovery without a limiter only reclaims unused files.

The two-second work allowance measures worker and supervisor CPU, excluding storage/pacing waits. Separate 5-second live / 10-second catch-up admission deadlines bound publication latency, alongside existing output, memory, byte, cancellation and consumed-prefix bounds. One indivisible item and its durable commit may exceed a deadline. Adaptation uses work time rather than total batch duration. No asynchronous writer queue or parallel ordered assembler is added.

Processing throughput and bounded safe points (0.6.17)

Record pages retain the archive's 4-MiB payload limit. GOES declares a 512-record maximum (the archive ceiling); the scheduler starts at at most 64 and adapts within the processor declaration. Four successful inexpensive full batches allow growth; slow/output-heavy batches or publication capacity reduce the target. Recovery can grow a previously reduced target again. At the live edge a read returns available input promptly and the target is at most 64; it does not wait to fill.

Input admission within a page stops at a complete primary-record boundary after two seconds, 32 outputs/outcomes, 1 MiB of manifest metadata, or the smaller of 64 MiB, one quarter of the asset allowance and the staging allowance. An indivisible record's outputs and required durability operations can take longer; existing processor-output, pending-metadata, asset and filesystem hard limits still apply. Unconsumed records and future gap events are excluded from the in-place replay prefix. Its original resume identity is the last consumed primary record; dependencies stay with their primary, and terminal gap-only pages retain their exact archive resume position. The next read starts there.

Full snapshots remain streamed. Normal replay allowance is one quarter of the last snapshot size, bounded to 1–64 MiB and reduced to leave room for the old snapshot plus the declared replacement within the configured checkpoint quota. A zero allowance uses snapshots instead. The existing 64-MiB journal/recovery bound remains unchanged. Snapshot age is at most 15 minutes of active work; initial state, idle state changes, failure isolation and explicit history-end boundaries still require their existing safe snapshots. Unchanged idle state with no journal needs no periodic full copy. Every progress/output commit remains durable between snapshots, and the prior recovery pair survives until replacement publication commits. Existing journal appends synchronize the file; the directory barrier is required only when creating its name. Ownership/update transactions are combined only when the journal already has a durable context or batch owner.

Each new staged file is synchronized once after its final namespace operations. Verified existing duplicates with published or ready ownership need no barrier for the discarded temporary inode. An interrupted, unprepared inode still needs a file barrier even when its current bytes match. New-file synchronization releases catalog ownership while retaining the stage reservation and open file; independent admitted jobs can continue. Generation and storage admission are rechecked afterward, before the ready marker. Their final and staging directory names are synchronized once per batch at prepare, before the prepared marker can commit. Until then they remain accounted unprepared ownership, abandoned on recovery; no product references or progress advance. The no-replace rename remains preferred. The link/unlink fallback synchronizes its final single-link inode before preparation; interruption before that point leaves accounted unprepared work, never a recoverable success. Allocated bytes after fsync and release of the staging reservation commit together. Both directory barriers also cover duplicate asset cleanup.

Routine reclamation coalesces to five-second turns with dirty/continuation triggers. Cleanup synchronizes changed directory contents before deleting durable ownership. Empty turns do not write catalog rows or synchronize unchanged directories. Vacuum retains reusable working pages and runs at a minute cadence or under storage pressure. WAL reclamation remains non-waiting, triggers around 8 MiB/elapsed turns, and retains the 32-MiB hard admission ceiling. Pressure requests immediate bounded cleanup after pending ownership is abandoned.

The CPU meter includes worker and supervisor-thread work; it shares the admitted aggregate CPU allowance without an extra hidden one-core cap. The configured I/O ceiling still applies to reads, replay writes, assets and snapshots. Pacing uses the actual deadline instead of rounding every short delay up to ten milliseconds. Filesystem free-space values remain fresh; only the immutable relationship of the already-open index/asset filesystem anchors is cached for SQLite admission.

Runtime performance, catalog maintenance and ioTimings counters expose batch sizes, snapshot reasons/bytes, limiter waits, IPC serialization/polling, file hashing/verification/writes, SQLite/file/directory synchronization and cleanup work. These are cumulative scoped timers; nested/concurrent values must not be added as elapsed wall time. Completed task status entries retire after their durable outcomes/totals have been retained. The administration page exposes record-worker counters under Processing timings and batches.

Failed work and continuation (0.6.15 implementation)

Expected item failures are version-1 processing outcomes, separate from product observations and acquisition ACKs. They include an original identity/range, hash where available, semantic producer binding, work unit/stage, stable code, cause, severity and disposition. The generic worker transports bounded outcomes; the catalog publishes them in the same transaction as progress and its compatible checkpoint/replay reference. An unprepared failure cannot advance progress. Retention keeps the latest 1,024 detailed outcomes instance-wide, with aggregate counts and first/last occurrence times retained per context. Recovery replay observations are counted separately from newly failed input units.

Worker publication validates output structure and typed metadata before transfer. Only unresolved canonical endpoint hashes and execution origin may be null at that private boundary; the parent fills them and repeats strict validation before durable publication. Network/catalog manifests never use the private validation mode. Adapters report the current work before generating each output so a structural failure remains attributable to the affected item during recovery.

Malformed/truncated/unsupported input and explicit per-item limits do not stop the stream. The GOES adapter retains original evidence, preserves valid DCS sub-records, and omits unavailable views. Genuine allocator failures and unsafe exceptions retire the worker. The supervisor replays committed state, permits two failed executions of attributable work, then applies an adapter disposition on a fresh owner. A disposition is checkpointed before its recovery ledger can be retired. Multiple failures in one pending batch retain separate decisions. Build/resource-policy bindings permit another attempt after a relevant change; logical reception identity remains independent of execution provenance.

Aggregate resource waits and storage/commit failures remain infrastructure conditions. They retry through admission without labeling input corrupt or advancing unsafe progress. Cancelled workers retain reservations until reaped. Optional immutable tasks can yield to foreground work or pressure. Failed tasks remain durably deferred, and optional thumbnail failures preserve native imagery.

GOES output schema 3 explicitly lists unavailable native, thumbnail, coverage or text views. Its scientific identity is compatible with schema 2. Adding a ready thumbnail creates an immutable revision of the same reception; a delayed failed thumbnail cannot remove a ready asset or create a false complete-result conflict. Actual conflicting complete scientific results remain explicit.

GET /api/v1/products/failures?streamUuid=... returns bounded authorized history; GET /api/v1/products/processing?streamUuid=... exposes scoped upstream health independently of catalog transfer. Capability fields advertise these extensions; older Servers remain usable with upstream health reported as unknown. The administration action POST /api/v1/processing/reprocess accepts an outcomeId. It requires existing enabled stream intent and schedules a bounded lower-priority replay, or requeues retained immutable inputs. It neither rewinds live processing nor activates an inactive stream. Missing input remains explicit.

Worker diagnostics retain native codec reasons/return codes, requested/observed allocation data, effective containment, exception type/message, and matching ELF build identity. Wrapped native throws capture origin addresses before unwinding; fallback stacks are explicitly labeled as catch-site only. Fatal signals use a fixed private-channel frame and preserve exit observations; core dumps remain disabled. Installed binaries retain line tables with normalized source paths. Repeated log samples are rate limited; durable outcomes retain the full bounded diagnostic. Supervision timestamps, input attempts, durable progress, checkpoint positions and publication times have distinct meanings.

The accepted-source evidence and outstanding limits keep functional acceptance distinct from performance and incident diagnosis.

Superseded partials (0.6.19, catalog schema 5)

Whole-observation age/byte retention and obsolete partial retirement are separate. A newly preferred revision queues its replaced partial in the same transaction. Maintenance also resumes a bounded scan of pre-existing history. Only non-current, non-conflicting partials can retire. Active derivative workers lease exact inputs until reaping; durable matching input references remain protected. Original-role asset references remain until whole-product expiry. Retired revisions retain their revision number and semantic digest with an empty manifest; exact old revision requests return 410 product-revision-expired. Current-product detail remains available with revision omitted/zero. Replay deduplicates against tombstones.

Asset reference release is transactional. File unlink precedes durable ownership removal; affected packs receive priority reclamation. Copy/verification/pacing runs outside the catalog writer lock with temporary allocation reserved and the old pack pinned. Locators switch in one transaction after the replacement is synced. partialRetirement reports scan completion, retired/pending revisions, queued packs and physically reclaimed product bytes (net of compaction replacements). This counter includes ordinary product garbage reclamation; live asset usage is the authoritative remaining physical charge. No record schema or ACK change.

Consumers must coalesce superseded partial jobs and resolve retired revisions to current detail. Discovery cursors commit with replacement work; asset length/hash bindings never change mid-transfer. A retired Server item never commands deletion of an independently retained browser product. Schema 5 is incompatible with older Server binaries; capabilities include revisionRetirement: 1.

Foreground and historical ownership (0.6.19-3, catalog schema 6)

A persisted coordinator selects a short bounded bootstrap at the committed tail for foreground processing. The existing recent-history setting is a coverage target; it never makes current reception wait for that full duration. Historical work selects newest missing continuous ranges first and consumes each forwards. Primary ranges are bounded by 30-minute receipt buckets, 131,072 records and 256 MiB of input without loading a whole range into RAM. The archive seek token and exact original endpoints define the task, not private SQLite row IDs. Pagination is followed incrementally with one historical planning page per controller turn across streams. Selected ranges have separate recovery identities and retain a finite context fence. Optional adapter replay-floor and context limits permit bounded assembly completion beyond the primary range.

Schema 6 stores coalesced exact coverage intervals. Publication commits coverage and pending recovery coverage with outputs/outcomes and processor progress. Range completion is explicit; expired/unavailable tasks retain a disposition rather than fabricated successful coverage. A stale foreground is fenced and preserved as supervised handoff work, which restores its compatible checkpoint/replay and flushes honest partials before releasing recovery assets. Existing products and originals stay intact. Completed counts transfer without moving live input time. A finite legacy hint set may cause conservative idempotent replay; it never creates inferred coverage across missing originals or UUID-ordered epochs.

Foreground input and ready tasks precede background I/O at bounded chunk boundaries under the existing aggregate ceiling. Checkpoint replacement turns remain owned through catalog commit. Historical admission yields when aggregate recovery headroom is insufficient. Resource ceilings, publication packs, image quality, item-error continuation, record schema 2 and acquisition ACKs are unchanged.