📐annotation-orchestration

The groupant beside models/annotation-orchestration.groupant in the Mova repository: what the code computes, what it never does, how to go back from its outputs, its invariants, cost and checks.

Facts

Components

Obernants

The typed relations around the forward model: the behaviour complement (what the code never does), the reverse reconstruction (every input compatible with an output) and specialised views.

Model text

descriptant

annotation-orchestration: wave27

ann.rs is an existing cross-group gate/type dependency, not duplicate ownership. main and batch share Outcome::add_patch_reply/finish; llm direct fixed+variable concatenation differs by two separating newlines from codex message-block join. hints advise only; repair precedes draft gates; optional post-gate FEATS replacement is not re-gated.

This source-bound partial group organizes existing Mova code. Native evidence and excluded effects are recorded in source sidecars and the root wave27 report. Registration is not a universal proof or whole-system runtime claim.

2026-10-31 wave38: scoped child-composition relations distinguish admission, persistence, strict-consumer framing and history preimages. Integrated validation and its limits are recorded in the wave38 receipt; these additions do not certify every parent branch.

Paired composition memory — 2026-11-01

Composing the resume vidtvorant with strict-consumer and append-failure obernants exposed two distinct framing failures: merged JSON objects, then a blank physical line introduced by an overly broad repair. Parent compatibility must retain physical bytes as well as parsed rows; a tolerant local reader loses the observation needed to diagnose the latter. Request-subset reconstruction preserves history ambiguity and does not measure inference quality. See the source-grounded cases, with the existing wave38 evidence and unsupported strict-reader domains kept explicit.

2026-11-01 fresh-worker startup composition: cycle polling follows a successful async launch, so the launch must first observe the exact known child's complete PID or successful completed results. The child now publishes PID atomically; a bounded five-second handshake keeps missing startup state distinct from a malformed/stale preexisting lock. Timeout retains uncertainty and never permits a new teacher call automatically. The source startup model retains the deterministic delayed-child counterexample, bounded controls and existing-worker identity limits. Annotation state, DB ingestion and worker-source migration remain separate operational decisions.

The parent also owns reusable typed Fish preparation/execution and immutable swarm supervision. Artifact byte pins and typed Task identities remain separate joins; native/transport acceptance does not establish semantic truth, source-phase eligibility or training authority. The exact attached child/source closure is structural evidence only. See model.md for the prepared executor composition and its explicit external observer boundary.

The bounded batch/page branch preserves source-ID intent accounting separately from Task jobs, native preparation, actual model review and semantic/training authority. Private corpus/frontier/carryover policy supplies pinned inputs; public code does not import it. Missing preparation stays explicit rather than disappearing from global scope. STOP and a completed local label alone do not establish a nonreplaying handoff.

model

annotation-orchestration

forward

Draft Ann/Item -> optional repair/hints -> llm prompt blocks -> batch request/state -> codex snapshot+partial queue -> batch reply parsing -> main Outcome patch/blind gates -> finish files/report and optional corpus. Only the bounded pure/helper and fake-process prefix is executed.

invariant

Unique ids, consistent forms and in-range state indices are required at adapters. Accepted patch outputs pass existing ann::check. Queue final name follows all local successes under immutable inputs/single worker; finish is not transactional.

cost

B bytes, R requests, P partial rows, N tokens: prompt/serialization O(B), map operations logarithmic, partial request matching O(P*R), plus delegated expert/gate/training/transport work. No runtime speed or remote-cost estimate.

composition

ann.rs is an existing cross-group gate/type dependency, not duplicate ownership. main and batch share Outcome::add_patch_reply/finish; llm direct fixed+variable concatenation differs by two separating newlines from codex message-block join. hints advise only; repair precedes draft gates; optional post-gate FEATS replacement is not re-gated.

domain

Bounded synthetic annotations, valid unique item ids and ordinary files; fake executable integration fixtures on Unix. Live effects remain modeled only.

limitations

No live teacher/API/corpus/model writes. No proof of crash durability, filesystem adversary or remote inference quality.

checks

• 11 owned unit checks and6 fake-process integration checks, twice debug/release (see retained named outcomes)
• Six compiled production mutations, nonzero test exits and exact restoration

canonical_surface_composition

Domain: the separate bounded Fish preparation path, not every legacy annotation route. Observation: request publication, findings and optional unauthorized GPU candidate. For the six raw semantic fields s, native decoder D and encoder E, preparation requires D(s) to exist and E(D(s))=s before native agreement or raw-string context policy P. Thus P(s)=P(E(D(s))) on admitted surfaces; candidate hashes alone did not imply this representation consistency. Opaque provenance is outside s and remains unchanged.

A counterexample on the previous source used two matching candidates with padded character, narration scope and no speaker. Native parsing succeeded and the raw policy missed both exclusions; the actual CLI produced an eligible but training-unauthorized candidate. Current preparation rejects before output-directory creation. Canonical Character still produces speaker/scope findings, while canonical Narrator can prepare an unauthorized candidate. This is finite Rust/CLI evidence plus a source-derived roundtrip condition, not a semantic theorem. Parent composition must not transport this stricter domain to the unchanged permissive legacy parser or confuse request publication with trainer admission. See the representation review.

prepared_executor_composition

Domain: bounded prepared annotation Tasks, immutable source/profile/queue pins and one configured review executor per reservation. The reusable API exports the same native types used by preparation and returned-draft validation. The executor and Fish swarm own separate operational leaves under this parent; the earlier legacy/fake-process evidence above does not establish every new runtime trace.

Prepared queue -> verify raw Task/profile/source byte pins -> deserialize native Task -> recompute compact typed Task identity -> evaluate/render under the configured profile -> durable attempt/reservation -> configured CLI process -> retained response/error/uncertainty -> strict returned-draft validation -> review-only receipt. File identity and typed identity are two checks. A pretty JSON file SHA is not expected to equal the compact typed Task SHA; each must match its own declared observation. Retained attempts prevent an uncertain process history from becoming an automatic blind retry. A per-job completion receipt does not establish campaign completion.

Swarm deadline propagation and boundary observation join immutable queue/config identity, current reservation, accepted child PID, same-task receipt and explicit observer result. Missing/exited/timeout uncertainty remains distinct from an explicit known-not-started rejection. A paused or terminal boundary must retain uncertainty and receipts; PID absence alone does not prove quiescence. Observer semantics are an explicit external interface, not silently proved by the swarm leaf.

artifact_typed_identity_partition

For raw JSON bytes b and exported typed deserialization D, artifact identity is H(b), while Task identity is H(S(D(b))) for the compact typed serialization S. The serializer fiber {b':D(b')=D(b)} may contain many whitespace/key-order variants with different artifact hashes. Reject a stale raw pin even if typed content matches; compare typed identity after the byte pin and deserialization succeed. Counterexample: an indentation change preserves the typed Task and changes the pretty-file pin. This source-derived relation relies on trusted parsing/serialization and collision resistance; it is not a semantic-equivalence proof for arbitrary programs.

review_authority_partition

Preparation, native admission, transport execution, returned-draft contract acceptance, semantic review, source-phase join, DB import and GPU training are distinct observations. The reusable executor publishes review-only results and cannot infer teaching authority from no structural findings. Unknown context/source phase, correlated producers and original/draft findings survive the operational join. A matching receipt identity establishes a task-specific observed result, not semantic gold, learning gain or permission to import/train.

Source bindings now cover the shared API, executor and swarm in addition to the preserved legacy annotation path. Finite fake-executor and native preparation tests remain scoped evidence; configured live transport requires its own actual receipts. No global exactly-once, hostile-filesystem, crash-liveness or semantic correctness theorem follows from this parent attachment.

Actual transport counterexamples: a configured CLI can finish with exit0 while its result fails strict bound-reply JSON parsing, or while unresolved observations exceed the admitted native representation. These are invalid_response outcomes with replay authorization false, not completed contract-accepted annotations. Prompt/schema constraints and native returned-draft checks must agree; schema character length alone does not imply a UTF8-byte limit. Preserve the rejected response and its task/request identity rather than repairing it into success or blindly repeating the completed call.

process_closure_partition

Partition an invalid returned draft into ClosedRejected versus UnknownProcess. ClosedRejected requires bound task/profile/config/reservation/receipt identities, no outer timeout, inner invalid_response with exit0, and explicit model-process started/reaped/group-absent observations from the trusted executor. Only this case may become quarantined_review_only and allow a different fresh queue entry; it never becomes accepted data or replay permission. Missing/false/null proof, mismatched commitments, outer timeout or unknown child outcome retains uncertainty before STOP/expiry/next-job claims. Observing one declared process group absent does not prove that arbitrary escaped descendants are absent. This relation composes the native executor, swarm retained audit and the external priority observer; each checks its own binding rather than trusting a status name.

Bounded batch and page admission

Domain: declared source packets, bounded typed Tasks, immutable source intents and retained local attempt histories. Public batch packing composes only compatible source/document/order/profile observations under existing native evaluate/render. Artifact mosaics and removed context references remain explicit; merging context is not semantic equivalence. Public paging joins intended source IDs to queued Task.target_ids or explicit deferrals/rejections, while source ownership stays disjoint across pages.

The complement excludes incomplete/repeated accounting, silent loss of oversized/unprepared next targets, promotion of cache presence into review, and erasure of uncertain attempts at STOP/expiry. The reverse relation retains all source/attempt histories compatible with pinned outcomes; source totals cannot reconstruct job counts or semantic truth. For page I, queued set Q, rejected R and deferred D must partition I. Quarantined returned annotations are not validated reviews. Schema-valid outer objects may hold invalid embedded annotation strings. Component native tests and source bindings support bounded joins; no model-quality, training permission, throughput or whole-system proof follows.

catalog

behavior-complement

Unknown reply ids, missing/broken/gate-failed patches do not become accepted final annotations. Queue rejects sticky failures before launch, but existing final sentinel bypasses validation. No inference from fake success to live quality.

reverse-reconstruction

Final Ann admits many draft/patch antecedents; result envelopes admit overwritten duplicates/discarded thinking. Queue final permits fresh or resumed execution histories; source state and prompt are not uniquely recoverable.

representation-transport

Request chunks index State items and matching drafts; this unchecked alignment is needed before reply custom_id strings can map through main patch gates.

gate-order

Model validation before queue effects, snapshot/partial validation before resume calls, and missing/broken/tree gates before accepted patch output. Later finish failures can leave earlier writes.

effect-boundary

Fake tests exercise local subprocess/filesystem boundaries with temporary files, not live teachers. finish optional UDPipe/corpus/training paths are unexecuted.

cost-join

Source byte and gate costs add to partial lookup P*R and external effects; compatibility USD zero for Codex is not subscription billing or zero compute.

wave38

Queue publication composition models

These source-derived relations observe the Codex queue branch and its JSONL boundary, under stable requests, a single worker, absent preexisting final sentinel, validated partial envelopes and successful stated effects. They do not establish annotation quality, external model behavior or crash durability. The manifest binds the actual source revisions.

strict_record_transport

Type: framing_consumer_domain. Let B be existing partial bytes, Q unique request ids, and P ids of its parsed nonblank succeeded rows. Define tail(B) as the suffix after the last LF and sep(B) as tail(B) containing a non-whitespace character under the worker's current trim predicate. After complete validation, the worker appends LF iff sep(B), then appends each new result row with LF. Thus a real unterminated record is separated, while a whitespace-only tail remains a prefix of the next row.

A strict consumer parses every physical line as JSON, unlike the worker's nonblank-row projection. Its stronger admitted domain requires every existing completed physical line and any non-whitespace final tail to be a complete JSON row, and any final whitespace-only suffix to contain only JSON whitespace (space, TAB, CR) and be followed by at least one new row, unless that suffix is empty. On this domain, successful publication retains B as a byte prefix and transports the parsed records in order P ++ filter(Q,id not in P), without introducing a blank physical line. A complete last row ending in bare CR is valid JSON plus whitespace; adding LF yields CRLF.

Counterexample to the earlier separator rule: B=" " followed by a successful row. Unconditional LF for any nonempty non-LF tail creates a blank line that a strict consumer rejects; preserving the spaces as JSON-leading whitespace retains compatibility. Preexisting blank physical lines, all-done whitespace tails and Unicode-only whitespace are not promised strict-reader acceptance; the tolerant worker can admit more inputs. The integrated strict-reader regression owns executable evidence. Files already carrying a final sentinel bypass queue validation and are outside the transition domain.

resume_work_preimages

Type: operational_work_fiber. Fix Q with unique ids and an accepted ordered partial subset P. Observe source-level calls to ask during one successful completion. The call sequence is filter(Q,id not in set(P)); its length is |Q|-|P|. Separator repair adds no ask and does not change request identity. Partial order is retained, so Q=[a,b,c], P=[b] publishes [b,a,c] while asking only [a,c]. This concerns the queue's call schedule, not internal work or billing of a subprocess.

For fixed final row order S, every accepted P satisfying S=P ++ filter(Q,id not in set(P)) remains a compatible initial state, together with arbitrary prior failed attempts and supplied row bodies admitted by the envelope checks. Final bytes do not uniquely reconstruct which prior rows came from a real call, a supplied partial or earlier explicit resumes. An ask failure leaves completed rows and the optional separator; sticky failure prevents implicit new calls until explicitly cleared. A final-file observation alone is not evidence of training quality or persistent learned knowledge.

Parsing and validation retain the existing O(B+|P|*|Q|) work plus serialization and external calls. The new tail decision does not imply a measured lesson-throughput improvement. Fake-process fixtures test byte framing, order, skip counts and explicit failure/resume only.

This page in Markdown → https://md.groupants.elamur.ai/free/en/mova/models/annotation-orchestration.groupant/