Status: Draft for Internal Review
Type: Standards Track
Category: Core
Created: 2025-10-02
Type: Standards Track
Category: Core
Created: 2025-10-02
Cowboy Cloud and Cowboy Chain. This CIP specifies the Cowboy protocol. Cowboy Cloud runs on this protocol today. Cowboy Chain, a public network on the same protocol, is under consideration for a future release. Where the two differ, this CIP says so.
CIP-2: Verifiable Asynchronous Off-chain Computation Framework
Abstract
Background
Smart contracts request data fetching, computation, or AI model inference from off-chain runners.Goal
Specify asynchronous dispatch with deterministic, stake-weighted VRF selection using a Fisher-Yates shuffle to resist correlation attacks and Sybil manipulation. Developers choose verification rules and supply mandatory result schemas. Callbacks use deferred transactions (per CIP-1).Motivation
Cowboy’s on-chain Python contracts need off-chain runners to execute AI/ML jobs, process large datasets, and call Web2 APIs. Developers can:- Run Python-based AI model inferences or heavy computations off-chain.
- Use an asynchronous, deferred transaction model to prevent network congestion from off-chain interactions.
- Use a stake-weighted VRF-based system to eliminate centralized schedulers and allow anyone to verify task assignments.
- Require task and result schemas to reduce ambiguity and ensure Runners can reliably execute and be verified.
- Select the number of Runners, the verification mode, and optional Runner pool constraints for their application’s security needs.
Specification
The key words MUST, MUST NOT, REQUIRED, SHOULD, SHOULD NOT, and MAY in this document are to be interpreted as described in RFC 2119.The framework consists of seven on-chain System Actor components and the off-chain Runner network:
0x0006is allocated toDUAL_BASEFEE(CIP-3). The post-2026-04 address space extends through0x13and includes a virtual entry at0x1D; the canonical assignments live in whitepaper §9.1 and the per-CIP specifications that introduce each address.
1. Task Definition and Result Schema
Every off-chain task submission must include aresult_schema. This mandatory payload defines the explicit output constraints of the task, enabling objective validation by the protocol.
The schema defines at minimum:
max_return_bytes: Maximum result size to prevent gas-bombing attacks.expected_execution_ms: Target execution time to help Runners assess feasibility.data_format: Expected data structure (e.g., JSON schema, binary format).
Http job, the committed data is the response body: the parsed JSON value for an application/json response, {"raw": <base64>, "content_type": <type>} otherwise, or {"result": <value>} when an extraction selector is set. The response status and headers are not part of data unless the job opts in with the X-Cowboy-Return-Headers request header. Then data is {"status", "headers", "data"}, with the body-only value under the inner data (CIP-6 §9.3.1). A job can opt in only when its result is not compared across runners, that is, at most one runner or None / EconomicBond verification. Other jobs fail before the request is sent, so response headers such as Date, which differ per request, never enter a committee comparison.
2. Job Specification
Every job submitted to the Dispatcher carries aJobSpec:
This table is the complete
JobSpec field set, in wire order. The
job_spec_hash recipe and the generated-field rules (job_id, submitter,
submitted_at, req_hash, run_root are node-stamped and excluded from the client
submission wire) are specified in CIP-11 §12.6. Any field added to the struct
MUST be added to this table and to the CIP-11 §12.6 preimage enumeration in
the same change.
The byte-level canonical encoding of JobSpec and its nested types is defined in CIP-11 §12.6.
3. Core Workflow (Asynchronous & Deferred)
3.1 JobSpec Validation Caps
Step 1 above validates every submittedJobSpec authoritatively before any
selection work. Admission decodes one wire form, the canonical codec JobSpec; an
actor’s SDK job envelope is normalized into that form before admission, so the
caps below apply to every job. These are raw-input upper bounds that the chain does not otherwise
recompute. Admission rejects these excessive inputs early to prevent DoS.
When
job_type == Agent, the following caps bound the
per-job agent reasoning loop, enforced in the same validate() gate. The agent loop is
additionally bounded by bounds.max_wall_time_seconds above; these caps further bound
model/tool-call cost amplification within that wall-clock window.
The structural checks require
verification.runners ≥ 1 and verification.threshold ∈ 1..=runners; DNS verifier checks (DnsTxtRecordMatch / DnsCnameMatch) are unsupported: node admission rejects jobs containing either variant with UnsupportedInstruction. Codec validation may reject an invalid combination earlier. Neither check can dispatch a DNS-verification job. For JobType::Agent, the
path-bearing fields system_prompt_path, session_dir, and session_id MUST be safe
relative paths, rejected (unsafe_path) if empty, absolute (leading / or \),
carrying a colon (:) anywhere (drive letter or URI scheme), or containing a .. path
segment (including a segment that Win32 trailing dot/space stripping would collapse to ..,
e.g. .. or ...). This is an on-chain pre-filter. The runner additionally
canonicalizes the system_prompt_path read and confines it under the mounted volume root:
volumes are mounted per CIP-9 §12.1 (/mnt/volumes/{volume}/) inside the container-isolation
boundary of CIP-10 §14, and the canonicalization + root-prefix containment itself is
enforced by the runner. With both layers, an
agent path traversal is rejected here at admission and, were one ever admitted, still
cannot escape the mounted volume at the runner.
The request and retry limits have separate scopes:
verification.runners(≤ 64) bounds the request, not the committee that runs. For quorum modes the dispatcher computes the effective committee size adaptively and clips it toM_max(§5.1); forNone/EconomicBondit dispatches exactly one runner (§5.1, Scope of adaptive sizing). A submitter may name up to 64 runners, but the verification mode and adaptive sizing govern how many are actually selected.bounds.max_retries(per-job execution retries, ≤ 10) is distinct fromMAX_RETRIES(default 3) in §6.3 (Timeout-based re-selection), which counts runner-selection retry rounds before a job is markedFailed. They are unrelated knobs.
max_price is not required to be positive: max_price = 0 denotes a best-effort /
unpriced job. The dispatcher escrows max_price + tip only when that sum is positive,
and itself submits internal jobs with max_price = 0. With both operands u64, the
escrow sum MUST be computed with overflow-checked (or widened) arithmetic; a submission
whose sum overflows is rejected at admission, never wrapped. Default filling for
omitted bounds and the per-job-type timeout belongs to upstream normalization,
before canonical encoding. The dispatcher validates the explicit decoded values;
it does not fill omitted fields or replace zero values with defaults. Resource
lower bounds depend on the job type: for example, an Agent job requires a positive
bounds.max_wall_time_seconds. timeout_blocks must satisfy the codec and node
admission constraints. The caps in this section, the table above, the agent
job-type caps, and the structural checks, are the values admission enforces
against raw submitter input.
4. Runner Registry & Candidate List Construction
The System Actor is0x0000...0001.
The Registry maintains runners with full registration data including stake, capabilities, rate card, health, and reputation. The runner stake floor is stake ≥ max(10,000 CBY, 1.5 × declared_max_job_value) (CBY-denominated; see §12 for the HOLD rationale on CBY-vs-USD pegging). A workload slot needs no registration of its own: it claims under the stake of the host Runner it is bound to (CIP-10 §17.3.5).
RunnerRegister is self-submitted: the transaction sender MUST equal registration.address. A mismatch returns Unauthorized (1211) before the registration handler reads or changes state. The outer transaction’s nonce and chain id provide replay protection; the inner registration signature proves key possession.
Candidate list construction (at submission_block):
- The runner has
HealthStatus::Healthy, with a heartbeat received withinheartbeat_timeout_blocks. - The runner has
reputation ≥ 50, using the EMA-updated reputation defined in §6.1. - The runner supports the required
JobTypeand, forLlm/Agentjobs, the requested model (see Model advertisement below) - If
tee_required, the runner must declare TEE support (attestation verified by TEE Verifier0x05). Interim: while the binding gate is dormant, selection falls back to the runner’s declaredtee_supportwhen no measurement binding exists; an existing binding’s status, expiry and TEE type are checked. - The estimated cost is ≤
job_spec.max_price. - The runner has
active_jobs < max_concurrent_jobsbefore D, or for a runner with no class fields; D slot classes apply after its height to a runner advertising them. - For the optional Entitlement filter, if
required_runner_pool = Some(pool_id), the Entitlement Registry (0x07) must confirm that the runner holds an Entitlement withScope::RunnerPool(pool_id)andAction::RunnerJoinPool(pool_id)that is direct (parent_id = None), has not expired, and has not exceeded itsmax_uses(see §7.3). When the pool filter leaves fewer eligible Runners than the job needs, selection fails withInsufficientRunners(1607).
supported_models: the set of model names it serves for Llm/Agent jobs, in the namespace jobs request. ["*"] advertises any model; an empty set matches only jobs with no model constraint. A runner advertising the llm or agent job type MUST advertise at least one model (["*"] is the explicit any-model opt-out). The capability filter admits a runner for a model-bearing job only when supported_models contains "*" or the job’s model: Agent jobs match the requested model string directly; Llm jobs match blake3_id(name) against the job’s model_id, with the no-model encoding blake3_id("") treated as unconstrained. The set is bounded and validated identically at registration and on every RunnerUpdateCapabilities (≤ 64 entries, ≤ 128 bytes each; entries non-empty, unique, and free of leading/trailing whitespace). Selection compares these strings without normalization. The same predicate scopes the capability-eligible pool that adaptive committee sizing draws against (§5.1): a model served by few runners sizes its committee from that smaller pool rather than the full active set. Capabilities are part of the registration record and may be replaced in place, wholesale, not merged, via a RunnerUpdateCapabilities registry transaction (owner-authenticated, same registry actor 0x0000...0001), taking effect at the next block’s selection without deregistering; in-flight assignments are unaffected.
For an Llm job carrying a response_schema, CIP-45 specializes the model predicate above: the runner MUST advertise structured_output, which registration and RunnerUpdateCapabilities accept only alongside the llm job type. An unconstrained (Auto) structured job needs that flag but no concrete model match. A named structured job additionally requires an entry other than "*" whose blake3_id(name) equals model_id; "*" does not match its named model. Plain Llm and Agent jobs retain the model predicate above and ignore structured_output. This predicate is applied before selecting the structured job’s single runner.
After filtering, candidates are sorted ascending by address bytes to produce a globally consistent, deterministic ordered list. Every node must produce the identical ordered list.
The filtered and sorted list is fixed at submission_block. Runners who join or leave after submission do not affect the selection for this job.
D: slot classes
This section activates atRUNNER_SLOT_CLASSES_ACTIVATION_HEIGHT under
CIP-50. It adds two optional, fixed scalar
capability fields: max_concurrent_tasks and
max_concurrent_sessions. They MUST be supplied together, are
nonnegative, and sum to at most 2,048. At/after D, registration and
capability updates with a partial pair, an
out-of-range scalar or sum above 2,048 MUST be refused as InvalidData
(1213) without changing registration. A zero cap disables new assignments
of that class. The native parent of a route session uses the session class;
ordinary on-chain jobs use the task class. A room parent’s materialized
Agent child
is runner-local, is never submitted to consensus, and occupies
no on-chain slot. A session remains a job; these are slot limits, not CPU/RAM quotas.
For class-advertising runners after D, the registry’s dense job-type masks
and eligible-population counts MUST omit RouteInvocation when the session
cap is zero and omit task job-type bits when the task cap is zero. Apply the
same gated rule to register/update, snapshot construction and dispatch, so
zero-cap candidates cannot occupy the bounded published selection snapshot
or inflate adaptive committee sizing. Below D retain the old masks.
Below D’s height, the lenient registration/update decoder MUST ignore both
fields and preserve the old stored bytes and single-pool behavior. At/after
the height, absence of both fields keeps today’s single pool for either
job class, with active_jobs < min(max_concurrent_jobs, 2048). It MUST NOT
implicitly turn a runner into task-only or give it zero session slots.
When both fields are present, they replace the single-pool allocation for
new selection: the prospective class occupancy MUST fit that class’s cap,
and total occupancy MUST fit their sum and the physical 2,048-entry limit.
The capability fields have type Option<u32> with
#[serde(default, skip_serializing_if = "Option::is_none")].
Per-class counters start at the height in separate runner-keyed rows under
Job Dispatcher 0x02:
Class byte 0 means task, 1 means session. A committee job’s markers
include the runner so every assignment can release its own counter. Every
assignment installed from that height, including a redraw of an older job,
MUST atomically write a per-runner/per-job assignment class marker and
increment the class counter. This also applies while a runner still uses
the compatibility single pool, so later capability updates cannot lose its
counted work. Existing assignments are not scanned or migrated. Define:
active_jobs MUST continue mirroring the complete runner job index.
Subtraction must not underflow. For class-advertising runners, admit only
when the prospective chosen-class count is within its cap and
prospective_total <= task_cap + session_cap <= 2048. Legacy jobs therefore
consume aggregate capacity, never disappear at the height, and are not
retroactively guessed into a class. A capability reduction cannot justify
a new assignment beyond these bounds; existing work can still release.
A release decrements a class counter only if its assignment marker exists;
it removes that marker atomically. An unmarked legacy release only changes
the existing index/total. Repeated releases do not decrement again. Apply
this rule to normal completion, timeout, cancellation, session closure,
committee replacement, CBSS key-delivery assignments and any separately
gated operator force-end. Both prepare_runner_job_add /
apply_runner_job_add and the metered job-index hooks MUST use the same
capacity rules; no alternate assignment path may bypass them. Added
accesses and counter/marker serialization are gated and charged before work.
Runners MUST re-advertise capabilities after the network publishes D as
active, not just when deploying the dormant binary. Startup alone does not
update registration. Outpost’s capability-update step and external operators
use the chain’s gate state; until that update a runner retains the compatible
single pool. The CLI’s whole-schema check, runner-node parser and fixed-shape
registration patcher MUST ship compatible readers before activation. Absent
fields serialize byte-identically and have old-row golden vectors.
Existing anchors at core 734db73a7c712d0efa2d0fa16f17ca891d5a5879:
capabilities,
RunnerCapabilities / MAX_RUNNER_CONCURRENT_JOBS;
dispatcher filter,
max_concurrent_jobs; and
job-index operations,
prepare_runner_job_add, apply_runner_job_add, sync_active_jobs,
add_runner_job_with_gas and the corresponding remove hook. These currently
maintain one complete index and its total count, without class markers.
Conformance MUST cover a pre-height assignment released after D, an older
job redrawn after D, post-height class releases, repeated cleanup, runners
before/after re-advertisement, class-cap reductions, and tasks admitted while
the session class is saturated. Test both add paths and all release paths.
5. Verifiable Runner Selection (Fisher-Yates VRF)
5.1 Adaptive committee sizing
The committee size adapts to the active runner populationN_active and the Herfindahl-Hirschman Index HHI of effective stake:
0x09 under system:cip2:committee.*):
HHI computation.
effective_stake per CIP-13 §3.2 is registration.stake + delegation_totals.total_active.
Worked example.
At low concentration (HHI ≤ 0.30), M saturates at
M_max = 9; at very concentrated runner sets (HHI > 0.40) and small N_active, M scales back toward the floor. The clip bounds prevent both committee-size explosion (DoS via large committees) and undersized committees on small networks.
The scope of adaptive sizing covers the quorum verification modes, MajorityVote, StructuredMatch, Deterministic, and SemanticSimilarity (the N ≥ 2 / N ≥ 3 rows of the §9 table). It does not apply to the single-runner modes: a job with verification.mode ∈ {None, EconomicBond} MUST be dispatched with M = 1, N_threshold = 1, selected via the §5.2 immediate mode (0x00), per the §9 table and WP §9.2 (economic_bond = 1 runner). No output of the formula above can be 1 at defaults (dispatch additionally caps M at the eligible pool, a separate mechanism, see the N_active = 3 worked-example row). M_min = 3 is a quorum-mode floor matching the BFT N ≥ 3 minimum, not a lower bound on single-runner dispatch. In both cases verification.runners remains a raw request bound (the §3.1 structural checks are unchanged), and the chain writes the effective runners/threshold values into the stored spec at submission. Single-runner dispatch does not provide proposer-inclusion neutrality. Submitters that need selection neutrality SHOULD request a quorum mode. Security Considerations (VRF Grinding) explains this trade-off.
5.2 VRF Seed (deterministic, no private key required)
The randomness source for runner selection is a verifiedcommonware threshold-VRF Seed { round: Round(epoch, view), signature } identified by a named absolute consensus round, never a block hash, never a height-anchored beacon (R_{H-1}/R_n addressed by height), and never “the seed of whatever round finalizes height S”. Height S and Seed.round are not interchangeable.
M == 1: selection is immediate in submission blockS(no added latency), using the parent beaconR_{S-1}(notation below), known before executingS. Immediate mode trades proposer-inclusion neutrality for zero added latency (see Security Considerations).M > 1: commit-then-reveal.JobSubmitbinds the job in blockS; the committee is selected later from the verified seed of the absolute future roundr_seed = advance_round(r_submit, K), wherer_submit = Round(epoch, view)is the round in which blockSwas proposed andK = SELECTION_SEED_DELAY_VIEWS(value set in CIP-11 §13).commonwareproduces exactly one valid seed per absolute round, whether the round notarizes, finalizes, or nullifies, so a withholding leader can delay the reveal but cannot re-rollr_seed.
S proposed in round r_submit (the block’s consensus round, block.context.round), the parent beacon R_{S-1} is the verified Seed of the absolute round immediately preceding r_submit in total round order, a seed that exists even if that preceding round nullified. The subscript is block-parentage shorthand: R_{S-1} is never a height-addressed seed lookup, and “the seed of height S-1” is not the same object.
The selection preimage uses the domain cowboy-runner-select-v3: with a consensus-critical mode byte (0x00 = immediate M == 1, 0x01 = delayed M > 1):
M == 1, R is the parent beacon R_{S-1}; for M > 1, R is the threshold seed whose Seed.round equals the bound r_seed. The seed is a public, consensus-verified value. No dispatcher private key is involved, so any node can recompute the selection. The cowboy-runner-select-v2: domain belongs exclusively to the retired block_hash preimage and MUST NOT be used with this preimage. CIP-11 §9.2 is the normative definition of the selection algorithm (canonical_seed_bytes(R) := beacon_hash_v1(R) and its hash material, the advance_round round arithmetic, including the rule when the referenced future round is not yet mappable under the known epoch schedule, the weighted_draw/partition iteration semantics, and the M > 1 pending-selection timing and storage); SELECTION_SEED_DELAY_VIEWS is set in CIP-11 §13; activation follows CIP-11 §13/§14. The normative CIP-11 sections are those of CIP-11 r1.3; the earlier v2 selection-seed function is retired.
The selection seed uses keccak256, the project-standard hash function (consistent with job ID generation, timer ID generation, token ID generation, etc.). The Actor randomness API uses HKDF-SHA256 specifically because it is a security-critical PRF exposed to Actor code; the runner selection seed has no such requirement.
5.3 Stake × √reputation weighted Fisher-Yates shuffle (select M from N)
Why
sqrt(r) and not r^1 or log(r):
r^0(stake-only) gives no reputation signal and is vulnerable to pure stake-monopoly.r^1rewards established runners too aggressively and locks out new entrants.r^0.5(=sqrt(r)) is the geometric-mean middle ground; a 4× reputation differential becomes a 2× selection-probability differential. Matches the heuristic Polkadot uses in NPoS phragmen and the staking-as-collateral literature.
- Selected runners are pairwise independent: no two selections are correlated
- Higher stake increases the probability of selection and provides Sybil resistance.
- Higher reputation increases selection weight without locking out new entrants.
- Same
seed+ samecandidatesalways produces the same result (determinism) - Any node can independently verify the selection (verifiability)
Given
(candidates_snapshot, seed, M), re-run the above algorithm to verify that msg.sender is among the selected set. The candidates_snapshot Merkle root is stored at submission time.
6. Reputation and Non-Reveal Handling
This section covers reputation updates and missing-reveal classification. A committed runner that has not revealed when its job settles, times out, or replaces its committee receives the non-delivery reputation penalty and no payment. If its reveal deadline has not passed, its stake is unchanged. A crash attestation exempts only the slash, never the reputation penalty. Only an expired, unattested non-reveal incurs the §11 non-reveal slash.6.1 EMA reputation with 14-day half-life
A revealed operational failure is distinct from both a valid quorum dissenter and a non-reveal. StructuredMatch schema violations or INVALID comparison fingerprints, MajorityVote missing/INVALID vote keys, Deterministic INVALID canonical results (CIP-23 §3.5.2), SemanticSimilarity missing/malformed embeddings (including zero or non-finite squared norms) or a self-reported model mismatch receive no payment and no stake slash. Each records one assignment, no completion, one timeout and one consecutive timeout, with score-zero
apply_reputation_score; the existing consecutive-timeout probation and jail-floor rules apply. They are also excluded from aggregator election, MRU routing rewards and rescue bonuses. Unattributable native light-client verification failures remain unpaid without an EMA penalty.
PublishChainRoot rejects an absent/non-hex roots_blob, wrong/missing height, malformed present msg_hashes/deliverers, and duplicate deliverer keys after hex normalization before storing a result. For the signed committee backend targeting a Cowboy anchor, admission checks signature recovery and the source-kind anchor/blob lengths whenever both chain entries in the governance-pinned registry are present, independently of the adjudication declaration. When the destination entry is absent, signature and anchor/blob-length checks cannot run; a reveal that fails those checks cannot later be paid, count toward quorum, or be anchored even if configuration returns. Configuration loss skips only checks whose inputs are missing; undeclared adjudication does not excuse a missing, wrong-signer or non-recovering signature or an invalid blob length. If required registry configuration is missing or adjudication is unusable during an assignment, reveals passing the available checks remain stored and pending even when they reach threshold. No settlement payment or anchor write occurs; ordinary timeout/refund proceeds and each accepted revealer stays neutral. Configuration loss is not runner non-delivery. A rejected reveal does not fulfill delivery: absent an accepted reveal, settlement or timeout follows §6.2’s non-reveal rules (in-window or crash-attested: reputation only; expired and unattested: slash). Verifier-side malformed-root and neutral-height filters are defence in depth for stored/legacy data, not lifecycle exemptions from these admission rules. Omitted optional delivery fields mean empty collections; a present null or wrong-typed field is malformed. Deliverer hash keys normalize to lowercase hex without an optional 0x; duplicate normalized keys and duplicate raw JSON keys are refused.
JobSubmit parses, safety-checks and compiles every JsonSchemaValid check before creating pending work or escrow. Invalid, unsafe or unsupported schemas are rejected with the existing deterministic admission errors; validation never retrieves external schemas. For legacy jobs with unusable verifier schemas, timeout attribution is neutral for the committee: no reputation penalty or stake slash, and ordinary retry exhaustion/refund proceeds. A settlement transaction that attempts to compile such a schema retains its existing error and rolls back. A missing job specification is logged and skipped at timeout, without runner attribution.
Valid quorum dissent is slashable fabricated output: the losing canonical MajorityVote cohort, a valid Deterministic result outside the first valid reference cohort when that cohort reaches threshold, a valid SemanticSimilarity embedding outside the winning cluster, or a losing chain-root (roots_blob, msg_hashes, deliverers) bucket. StructuredMatch grouping dissent does not slash. The dissent slash uses §11’s ordinary stake-slash figure, not non_reveal_slash_bps.
Parameters (stored at 0x09 under system:cip2:reputation_config as a single JSON-serialized ReputationConfig blob; the .* notation names logical fields of that struct, not separate storage sub-keys, cf. system:cip2:non_reveal_config):
Runners enter with
reputation = 50. The EMA and its floor/ceiling rules apply to every subsequent update.
E3 decline reputation transition
Only an accepted single-runner task decline at/after E3 takes this transition; below E3 it is unreachable. Work in integerema_value_x1e9 units with the existing ReputationConfig and the same
executing decision height h a timeout would use. This is the score-zero
EMA part of a no-commit timeout, before any timeout-counter, probation or
jail mutation. Define:
one_minus_alpha_q63 and current_reputation_x1e9 are the existing
bit-exact helpers, including lazy decay and the never-updated sentinel.
cfg.floor/ceiling abbreviate reputation_floor_x1e9 /
reputation_ceiling_x1e9. With default divisor 5, the move is ceil(D/5).
The first-update timeout would set the score directly to the floor, so its
D is the entire prior-to-floor decrement; it must not silently use the
ordinary-history alpha step. At the floor D == 0 and the decline effect is
zero; there is no forced loss through the floor. Positive D rounds upward.
Use wide multiplication and quotient/remainder ceiling division to avoid
overflow.
Increment reputation.assignments with the existing saturating-u64 rule.
Keep completions, timeouts, consecutive_timeouts, probation_until and
jail state unchanged; do not trigger probation or a jail-floor reset.
Increment the separate lazy per-epoch decline counter, then synchronize
selection eligibility and its snapshots using the existing height-aware
hooks. There is no fresh-runner exemption from the normal selection
threshold: the default fresh-runner vector below falls below 50e9 and is
ineligible until ordinary policy makes it eligible. Legacy score views may
reflect the assignment-counter increment; do not substitute them for EMA
selection.
Normative vectors use h = 100, default half-life 1,209,600, default ceiling
200e9 and divisor 5. Floor is zero except in the last row, where it is 1e9.
All unchanged counters/flags retain their input values; assignments becomes
1 for the fresh row and 21 for each row starting from 20.
The baseline PROBATION_TIMEOUT_THRESHOLD is 5, so the near-probation
vector starts and ends at 4 consecutive timeouts. Retain its input
probation_until and jail state, and require that no probation or jail reset
occurs; its EMA values are unchanged.
At this configuration
alpha_q63 = 5,285,345,835,483. Every row stamps
last_update_block = 100 and changes neither timeouts nor probation/jail.
Implementations MUST pin these vectors, counter/selection effects and both
sides of the E3 gate. The merged E3 partial transition
and normative vectors preserve this contract.
Baseline anchors are
EMA arithmetic,
current_reputation_x1e9 / apply_reputation_score, and
full operational failure,
record_operational_failure. E3 uses the defined partial transition, not
that helper’s full timeout effects.
6.2 Non-reveal classification
If settlement, timeout or committee replacement closes the job at or before a committed runner’s reveal deadline, the runner receives the §6.1 operational-failure reputation write immediately: one assignment, no completion, one timeout, one consecutive timeout and score-zero EMA (including the existing probation rule). It receives no payment, and its stake is unchanged, with or without a crash attestation. No deferred penalty or later slash is scheduled for that closed window. A runner whose deadline already passed receives the same reputation penalty if crash-attested; otherwise it receives the configured NonReveal slash and reputation reset. An assigned runner with neither a commitment nor a result receives the same operational-failure consequence at settlement only after its current assignment’s commit window has closed. A replacement still inside that window (including its deadline) is not penalized. An Assigned private-volume job classifies its outgoing committee before the terminal refund; it still does not retry. PendingKeyDelivery is separate and incurs no timeout execution penalty. An accepted E3 pre-start decline is the explicit exception: it uses the partial EMA/counter rule in §6.1 and, for private work, fails with refund without a redraw. Stored malformed reveals that cannot form a valid quorum receive the same operational consequence at timeout; valid below-threshold reveals are preserved without a penalty. Settlement also deletes the first-assignment timeout record: a later commit is checked againstsubmitted_at + commit_deadline_blocks instead of the removed assignment-time anchor, so the earlier fallback deadline fails closed.
A commitment is adjudicated only against its own assignment round. A stored commitment whose commit block precedes the current round’s assigned_at is stale and is treated as absent for this round: the runner receives the non-committer operational consequence, never an expired-window slash based on the old round. If no timeout record remains, both timeout classifiers use the job specification’s submitted_at as the assignment anchor. This rule does not delete old commitment rows.
At a terminal settlement or timeout/replacement decision, an unrevealed commitment is classified using the actual executing decision height and that runner’s stored commitment height, even when processing an older due bucket. The decision height is an explicit input so a service-height clock can supply it independently of the due index. Deadline equality is in-window; only a strictly later decision is eligible for the NonReveal slash.
SubmitCrashAttestation system instruction (opcode 97). There is no free-standing signed CrashAttestation struct on the wire. The instruction carries only:
tx.from (self-attestation; the tx signature authenticates it, no separate self_signature field), and the block is implicit. The chain persists a CrashAttestationRecord { runner, job_id, crash_signal, submitted_at_block } under the Result Verifier actor. Admissible at or before service height commit_service_height + crash_exemption_blocks (UpdateNonRevealConfig param, opcode 98); requires an existing commitment and no prior reveal; idempotent. For non-reveals subject to classification, the attestation does not get the runner the job payment, but converts “proven dishonesty” (slash) to “operational failure” (reputation hit only). It does not suppress the reputation write at any decision height; before the reveal deadline, stake is protected even without an attestation.
Why a crash exemption for non-reveals classified after their deadline:
- Without exemption, legitimate hardware faults cause runner stake destruction, which discourages decentralised runner participation.
- After the reveal deadline, the default slash prices withholding more strongly than a reputation penalty alone.
- To claim a crash exemption from that slash, runners must submit an attestation, leaving an on-chain trail. Repeated
CrashAttestations from the same runner trigger Tier-2 review (default: ≥ 5 attestations in 1,000-block window causes an automatic flag).
runner.llm/runner.http/runner.mcp envelopes do not accept commitments and are not examples of this case. The committee non-revealer receives the operational-failure penalty with unchanged stake. Settlement records operational failures, including non-revealers, in VerifiedResult.runners_failed and runners_unrewarded; these fields are omitted when empty. NonRevealOperationalFailure is a node tracing record, not a new receipt event topic. Timeout/replacement uses the same reputation update and tracing record. The expired-window slash remains reachable through both long-timeout settlement and timeout/replacement. The deferred non-reveal due-index writer currently has no production callers and is not needed to reach either slash path. The deferred pass is therefore unreachable in this release and must adopt the lifecycle item-quarantine rule for Data faults before any production writer is added.
For ordinary jobs, assignment timeout, the 60% commit phase,
individual commit-to-reveal windows, and crash-exemption windows exclude the
union of Council pauses on the Runner Registry (0x01), Job Dispatcher (0x02),
and Result Verifier (0x03). Overlapping pauses count once. Admission and each
reassignment store their service-height anchor; each commitment stores its
service height after the hash. A later cumulative pause total is never used to
reconstruct an earlier event’s clock. Paused commits/reveals are refused, and a
retry after unpause uses the remaining service-time window. Non-reveal
classification compares service heights; its slash, reputation, and
crash-attestation submission records retain real block heights. Native session
authorization, capability expiry and financial/reconciliation deadlines remain
real-height deadlines. Clients must retry pause/window execution errors and
interpret deadline projections on this service clock; a successful HTTP response
alone does not establish successful job execution.
reveal_window_blocks defaults to 60 service blocks measured from the individual runner’s commitment (~1 minute at 1s blocks). The deadline is commit_service_height + reveal_window_blocks; it is independent of the job’s commit deadline. Tier-0 tunable.
While any job-trio actor is paused, new JobSubmit admission is refused at
transaction scope with the existing
ActorPaused error. This includes ordinary
jobs and native SessionOpen: both reserve lifecycle capacity whose service is
stopped by the same pause, although native deadlines remain real-height. Pending selection,
expiry and deferred non-reveal classification wait without consuming the job or
penalizing runners. Proposers suppress consumed-seed commitments for all three
actors; after unpause, the same pending round’s verified seed can be committed
again. If an independent dependency pauses during assignment, that record and
its snapshot remain pending while unrelated records from the round may proceed.
The timeout transition records the original runner’s disposition (NoFailure, OperationalFailure or Slashable) alongside original_runner and the new assigned_at in JobTimeoutRecord. A bounded sweep retains that disposition with its runner frontier before publishing the replacement. Successful settlement may transfer the 5% stake-funded rescue bonus only for a recorded Slashable original (expired, unattested non-reveal or proven dishonesty). It never recomputes that decision from settlement height. Operational timeout, in-window non-reveal and crash-attested failure pay no rescue bonus: the replacement retains its ordinary job payment, and the original stake remains untouched. An absent disposition never authorizes a stake debit. This implements the WP operational-failure protection; it does not introduce another bonus funding source.
Before any job write, admission reserves
both expiry and record reap in the bounded lifecycle calendar. Buckets span 128
blocks and contain at most 1,024 entries of 53 bytes. Each obligation probes its
first eligible bucket and at most seven later buckets. If either obligation has
no slot, admission returns existing InvalidData (E1213) without creating a job.
There is no unindexed-job success path and no terminal append which can leak.
Ordinary buckets use the pause-excluding service clock above; native buckets
use real height. They share one admission planner and per-job reservation ledger,
with separate namespace/cursor fields and fixed shares of one service allowance.
For ordinary jobs, let T be the admitted timeout, s the submission service
height, and D = (8 + 1) * 128 = 1,152. The immutable retry horizon is
H = s + 5 * (T + D): one pending-selection interval and up to four assignment
intervals, including three retries. A replacement must reserve its next expiry
before changing the runner set, and must satisfy next_expiry + D <= H.
Re-selection uses only surplus service after guaranteed work has been covered;
without that surplus or a replacement slot, timeout terminates and refunds the
job. Retry also requires the expiry to belong to the newest due service bucket
(ordinal == newest). If deferral carries an expiry into an older bucket,
including a non-trio dependency pause that outlasts its 128-service-block span,
service terminates and fully refunds the remaining escrow without incrementing
the retry count, even if a replacement slot and surplus are available.
Quorum Pending jobs reserve their initial expiry at s + T + D, so even
an admitted T = 3 can await the earliest usable seed at s + 4, including
across a calendar bucket boundary. They expire if the seed never becomes
available. Assignment is allowed through service height s + T + D, inclusive;
at that last anchor exactly four T + D intervals remain before H.
The first Pending-to-Assigned transition must re-arm expiry at the assignment’s
service height; if no bounded spill slot fits before the immutable horizon, it
fails and refunds that admitted job without assigning runners.
Every ordinary job reserves reap at H + 86,400, whether it later completes,
cancels or fails. Paid terminal transitions release unused expiry capacity and
retain this reap slot. This preserves at least 86,400 service blocks after the
latest permitted terminal transition, rather than rescheduling from the actual
terminal block. After reap, status queries return not found. A stale non-reveal
entry whose JobSpec has been reaped is consumed without a penalty.
Native sessions reserve expiry at their authenticated expires_at, with the
lifetime limit from the route policy rather than the ordinary 1,000,000-block cap.
That declaration is actor-settable and is validated as nonzero; there is no
independent protocol lifetime ceiling. Its due-height bound is therefore only
the route’s declared lifetime, not the ordinary fixed future-window limit.
Per-bucket admission capacity continues to bound the reserved service work.
Their reap due height is expires_at + 75 + 86,400. Native financial and token
deadlines remain real heights even when lifecycle service is paused. The
independent financial reconciliation queue continues during a job-trio pause
(or a calendar Data stall), subject to its own dependency pauses and fault
boundary; both lifecycle calendars still defer. An early
final report may retire the execution slot without starting close; it therefore
keeps the expiry reservation until first close intent. Expiry guarantees that
close. Subject to the funded native close stage in the expired-session recovery
exception below, reap runs the idempotent financial finalizer as a separate
bounded stage before deleting JobSpec or other ordinary job records.
Native expiry and record reap have reserved
calendar capacity. An early final report releases execution capacity but keeps
its real-height expiry obligation until the first close intent; delayed service
does not move expires_at or the financial reconciliation deadline. Before the
ordinary JobSpec/dispatcher/verifier families are reaped, the existing native
financial finalizer must finish. Native mount/capability cleanup continues through
its bounded revocation queue. The route admission pin, job-to-session handle,
per-report nonce receipts, terminal session state, route-admission nonce/replay
receipts and retained native access fences remain under their existing owners;
the generic job reaper does not delete them. Nonce receipts provide replay
protection. Their retention/deletion requires a separate design proving that the
nonce domain is closed and reserving capacity for the report count; it is outside
this lifecycle change.
Reaping deletes dispatcher and verifier records, their manifest-indexed chunks, issued attachments (job_att:), per-runner seal requests (job_seal_req:), the per-job seal-sequence index (cip9sr_job:), its indexed seal requests (cip9sr:), partial key deliveries (cip9_key_delivery:), and Storage Manager tokens (ras:token:{hash}). Issuance records each token hash in the bounded binary job_cap_tokens: index (32 bytes per hash, at most MAX_ATTACHMENTS_PER_JOB = 64); cleanup deletes all indexed tokens before deleting that handle. This applies to grantless attachment jobs and jobs cancelled from PendingKeyDelivery. A reachable public M=1 retry deletes the outgoing issued-attachment row, tokens and token index before replacing its runner handle. The helper also covers seal/delivery and verifier records, but those are synthetic bounds in the public-retry fixture. Bare M>1 retries delete outgoing verifier records before replacement makes their runner identities unreachable.
The reaper uses each family’s reader discriminator and byte bounds: an inline
binary JobSpec may begin with manifest magic in its submitter address. Each
lifecycle stage and its frontier share a rollback boundary. A paused dependency
(including Storage Manager, Session, or Container Registry) defers that item;
its job records, financial liability and exact obligation remain intact. The
service rotates blocked items and scans beyond blocked buckets even when one
turn cannot inspect every blocked item, so unrelated
items and the other domain continue. Except for the funded native close stage
specified below, Reap waits for a still-live job’s preceding
expiry and emits lifecycle_entry_deferred_predecessor instead of discarding
that reap obligation. Dependency pauses emit lifecycle_entry_deferred_pause. The canonical cursor contains
two big-endian u64 words: the retired admission frontier and the fair scan
frontier. Admission never treats a skipped bucket as retired. Lifecycle actor
writes cover Runner Registry (0x01), Job Dispatcher (0x02), Result Verifier
(0x03), unpausable Governance (0x09), Storage Manager (0x0A), Session
(0x0C), and Container Registry (0x13). Route Registry (0x0E) is read only
on these paths. The same typed pause deferral covers every writable dependency;
container refund helpers preserve pause and Infrastructure error identity.
Identifiable malformed entries, reservation handles, or job status/spec records
are quarantined in place: roll back the item, retain its service entry together
with every job and reservation record, and record
lifecycle_entry_quarantined_data, a zero-amount runner.lifecycle attribution
in the block fee journal. Its protocol-scope audit names the domain, calendar key,
job ID and reservation key, with economic disposition preserved. A job ID from
an undecodable complete row is diagnostic data, not verified identity. Complete
ordinary and native rows that cannot decode retain their exact bytes. Payerless
service continues for other entries that do not require strict bucket reads.
Quarantine never empties a bucket or retires its
admission frontier, including on later turns: only successful service removes an
obligation. Missing specifications and corrupt job-status records cannot prove
that escrow was settled; both expiry and reap remain indexed until repair.
Every native obligation is retained on Data faults, including expiry and all
reap stages. A decoded native row stalls with lifecycle_financial_stalled_data
and rotates past unrelated work; this audit covers the entire native obligation,
not only the financial stage byte. A complete undecodable native row uses the
same raw retention and lifecycle_entry_quarantined_data audit as an ordinary
row; it does not stall unrelated native service. Unreadable bucket state (framing or aggregate work) or
cursor state still rolls back the domain turn with lifecycle_domain_stalled_data.
Neither a kind/slot disagreement nor a cleared stage byte alone authorizes
discarding an obligation. Real-height native maintenance remains independent.
In both domains, a retained undecodable row makes strict bucket reads refuse
with InvalidData until repair. Paid terminal transitions, admission probes and
expiry re-arming for co-located jobs fail when they need that bucket. Payerless
items requiring the same strict read retain their own obligations as Data faults;
other entries and buckets can still receive service. For any retained quarantine
or job-record fault, retirement cannot pass the damaged bucket. Ordinary admission
narrows as the fixed cursor-to-future window fills, with the longest timeouts
refused first, and eventually refuses every timeout until repair. Once the fair
scan cannot reach the newest bucket within its bounded service turn, the
ordinal == newest retry allowance is unavailable: affected retry-eligible jobs
are failed and refunded instead of retried.
Before either expiry or reap can complete a stage, service reads the retained
reservation and requires its domain and the selected kind’s nonzero slot to
match the serviced bucket. The due bucket must be within the same eight-slot
first-fit window used by admission. Reap also requires the recorded due height
to equal the reservation horizon plus record retention; expiry checks its
assignment anchor plus the retained specification’s timeout before active
expiry or native close, including the additional pending-seed interval for an
unassigned ordinary committee. Except for verified stale native Expiry retirement
under the recovery rule below, any disagreement is a retained Data fault. A released
expiry cannot enter either the terminal expiry fast path or native close, and
a stale expiry decoded as reap cannot delete the family before its reap slot.
A non-final stage must leave positive work sufficient for its next stage. Native
financial reconciliation verifies that the residual covers reap_stage_work from
the retained specification before making any financial changes. Insufficient
work is a Data fault that retains the original row. Service writers validate
newly encoded entries and aggregate work against the reader’s rules; raw
quarantine bytes remain verbatim, and a failed write validation rolls back the
domain turn rather than committing an unreadable row.
Before destructive reap, service reads the retained JobSpec root (and the first
chunk when present) and cross-checks its ordinary/native type prefix against the
calendar domain. Native specifications are decoded in full; ordinary chunked
specifications retain the existing manifest-based deletion checks. For a native
record it also checks the job-to-session handle and the actual session binding, closure,
terminal state, released job/session slots and zero remaining escrow. The
non-financial delete stage cannot proceed until financial finalization is
complete, regardless of the entry’s stage byte. A mismatch is a Data fault with
the same retention rules. This integrity model catches malformed rows and
disagreement with retained job/session state; well-formed corruption that passes
those cross-checks is outside the model. No refund, slash, terminal status or
completed financial settlement is inferred from damaged data. A nonterminal
job remains a predecessor dependency after its slot binding is validated,
except for the gated, separately funded native Reap close stage below.
Self-consistent corruption that passes these row/reservation/job/session checks
remains outside this integrity model.
Recovery of expired native sessions uses the following narrow exceptions
to nonterminal-predecessor deferral, native Reap stage order and retention of
slot disagreements activate at
ROUTE_ADMISSION_GATING_FIX_ACTIVATION_HEIGHT, selected per network under
CIP-50. The gate lands at NOT_SCHEDULED for
every network. Below it, SessionClose, Expiry and Reap retain their exact old
behavior, charges, bytes and observations. These exceptions apply only to
verified native session obligations; all other retention and pause rules remain.
At and above the gate, an authenticated RouteInvocation SessionClose
from the session’s actor or admitted_relayer, executed at real height
height >= expires_at, MUST perform caller-paid timeout recovery through
the existing instruction. It MUST validate the retained native JobSpec,
descriptor and its immutable signed expiry, admission pin, actual session,
runner binding, intact reservation and escrow before repair or close.
This includes overdue jobs admitted below the gate and jobs whose expiry
entry is missing; an empty bucket alone is never evidence of completion.
Only an absent job-to-session index may be rebuilt. Derive the session id
from the retained native SessionOpen descriptor by bounded point reads;
verify the job/descriptor id and digest, startup identity, pinned policy and
session/job/actor/runner/expiry/escrow bindings without first requiring that
missing index. Restore it only after those checks succeed. An existing
conflicting index, or missing, undecodable or inconsistent specification,
descriptor, pin, session or reservation, MUST NOT be guessed, overwritten or
reconstructed by a scan. Retain the obligation and its liability with a
deterministic diagnostic.
For an outstanding execution obligation, successful recovery MUST use the
existing atomic timeout-close, revocation and accounting transition: the job
becomes Failed, closed_at is clamped to the signed expiry, execution
capacity is released and reconciliation remains retained until settlement.
Runner exposure, inflight stake, job and
session states, slots, escrow and the reconciliation queue MUST stay
consistent. Recovery height does not extend the signed reporting deadline:
reports after expires_at + 75 remain inadmissible. With no accepted report,
reconciliation refunds the entire escrow to the actor/payer and pays no runner
for unreported usage. Completion releases both job and session slots and
leaves zero residual escrow. An already-closed session retains its terminal
outcome under the existing idempotent close rule; repeated recovery MUST NOT
duplicate effects. Reserve and charge every added read, decode and write
before work using U2’s height-selected metering. Legacy recovery is paid by the transaction;
it MUST NOT consume an unfunded legacy Reap allowance or silently enlarge it.
For native sessions admitted at or above the gate, admission MUST reserve a
separate Reap close stage, ahead of financial finalization and deletion,
with 144 work for close and 32 for financial finalization. The entry’s total
reserved work MUST be reap_stage_work + 32 + 144, and its maximum stage MUST
be max(reap_stage_work, 144), with corresponding bucket capacity reserved
at admission. At the current bounds, a 128-block bucket holds about 17
single-mount native jobs instead of about 34; admission MUST refuse
deterministically when the bucket is full.
After validating the same retained bindings and intact reservation,
that funded stage may perform overdue timeout close despite a nonterminal
predecessor; the financial stage’s allowance MUST NOT fund close. If the
validated session is already terminal, the close stage is a no-op and proceeds
to the existing financial and deletion stages without repeating close effects.
Legacy Reap remains unfunded for close and MUST defer a nonterminal job, including
after activation. No stage byte alone authorizes close, settlement or deletion.
A stale native Expiry row may be retired with an audit only after its
execution obligation is verified as discharged. If the reservation remains,
its expiry slot MUST be zero or a different ordinal, and the verified native
binding MUST identify an actual terminal closed session with
job_slot_released == true. If the reservation is absent, a retained
terminal job still requires its native binding and actual terminal closed
session with job_slot_released == true. After successful reap has deleted
the job, use the retained job-to-session handle and terminal session to verify
identity, released job and session slots and zero remaining escrow.
A missing JobSpec alone MUST
NOT imply successful reap. An absent reservation with a live nonterminal job,
or undecodable or conflicting evidence, remains quarantined. Only the verified
stale Expiry obligation is removed; its audit permits the retired frontier
to advance without discarding live liability. Ordinary jobs and Reap
obligations receive no stale-slot exception.
Retained calendar, reservation and session rows from the previous release
MUST remain decodable and valid under their authenticated legacy rules.
Any absent new optional field MUST re-encode byte-identically. Recovery
does not make undecodable rows repairable. Conformance tests MUST cover
below/at/above the gate, a legacy assignment recovered across it, caller-paid
legacy close, funded post-gate Reap close, missing index and expiry entry,
wrong-slot rows before and after successful reap, and the opposite live-job
case. Include corruption, pause, insufficient access, repeat recovery, old-row
decode/re-encoding fixtures, exact refund/stake/slot accounting, zero residual
custody and audited advancement of the retired frontier.
Unidentifiable cursor/bucket metadata faults, including a future cursor, roll
back that domain for the turn and record lifecycle_domain_stalled_data in the
same journal. The other domain and later passes continue. This domain remains
stalled until its metadata is repaired; it has no completion bound during a
persistent Data fault. A damaged shared pause-accounting row stalls both clock
consumers rather than guessing pause coverage. Pending-selection and deferred
non-reveal item Data faults also roll back and retain the affected record and
frontier, with lifecycle_selection_stalled_data or
lifecycle_nonreveal_stalled_data; a verified pending seed can be replayed after
repair. A slash-page dependency pause rolls back the whole page, including any
rescue transfer, retains its FIFO head and intent, and records
slash_family_deferred_pause; service resumes after unpause. Slash Data stalls
retain the page with slash_family_stalled_data. The separate native
maintenance queue retains its frontier with lifecycle_maintenance_stalled_data
on a metadata fault. Infrastructure errors propagate and reject local block execution. Typed dependency pauses are bounded
deferrals, not Data quarantine or Infrastructure failure. A local stage guard
contains a corrupt understated work allowance before it can poison the aggregate
BlockStart meter. A reused transaction work meter’s OutOfAccesses is also a
deterministic item Data stall; genuine storage/infrastructure errors retain their
identity. Control-reserve exhaustion defers rather than rejecting a block.
Diagnostics require no separate actor-storage write.
BlockStart stays 1,089, including
Timeout 544 and Container 75. A queued pslash page takes priority on even real
turns, leaving at least 288 for lifecycle; odd turns have 544. Both calendars stop
during the job-trio pause. Because repeated pauses can remove all odd real turns,
admission conservatively budgets 288 on every unpaused turn. Domain priority
alternates on service-height parity. Each turn reserves 22 control operations and 31
for native maintenance (one metadata read plus a bounded 30-operation item), leaving
235 for lifecycle stages. Already-spent control is deducted from the remaining
hold. Runtime may use an idle domain’s remaining turn, but fixed future admission
shares do not transfer between domains.
Each 128-block bucket reserves 63 of its domain’s 64 priority turns. For largest
indivisible stage m, its admitted work is at most 63 * (235 - (m - 1)), including
packing loss. The ordinary and native shares together use the same 128 turns;
each retains one unreserved turn for alignment and finite pause catch-up. The
largest admitted stage is at most 229, so it fits every guaranteed turn. Committee
penalties are staged by runner ordinal, preserving the first original-runner SC
disposition; monetary/reputation effects use the real execution height.
The shared A job-family inventory is 20 + 7M + S + R(M + 1) + 3A. Production
ordinary and native result writers here have R=0; maximum committee and
attachment counts are exclusive. Both verifier result writers serialize one
inline JSON row and have no chunk writer; native reports return through the
native handler before those writers. A source inventory pins that restriction.
The metered maximum attachment fixture retains five JobSpec chunks, one runner
and 64 attachments but zero result chunks: its complete lifecycle reap costs
229, at the unchanged 229 stage cap and within the 235 per-turn item allowance.
At that maximum stage, bucket_capacity(229) = 63 * (235 - 228) = 441, so only
one such five-chunk/64-attachment ordinary job fits a bucket (two require 458).
Lifecycle adds status, pending-handle and reservation read/delete operations,
plus one first-chunk type probe for a chunked specification. The validated
root/manifest is reused during deletion. Slot binding adds one read to every
reap stage; expiry’s corresponding read fits its existing stage bounds. Native deletion
adds the job-to-session handle and validated session reads within its reserved
stage; its maximum inline 64-attachment deletion inventory is measured at 225
and pinned to the reservation. Pending-selection/native financial work remains
separately bounded.
Admission records include these shape-dependent work and maximum-stage terms;
this changes reservation bytes for affected shapes while all phase budgets and
access tariffs remain fixed. A cheap completed ordinary M=1/no-attachment job
costs 31, independently measured. Its reap-only ceiling is floor(63 * 205 / 31) = 416 jobs per 128 service
blocks, exactly 3.25/block at both identity and maximum access scalars. It is the
same with native idle or saturated under the fixed admission shares. Concurrent
expiry obligations and larger shapes reduce the ceiling. This intentionally
backpressures otherwise affordable traffic above guaranteed lifecycle capacity.
No per-sender reservation quota, cleanup deposit or occupancy surcharge is added;
extra spill probes pay one structural read each, and global basefees respond to
resource utilization rather than calendar occupancy.
After a finite union pause of P real blocks, assuming the native cursor was
caught up before the pause and no new pause follows, a conservative catch-up
bound is 128 * 63 * (ceil(P / 128) + 2) + 256 unpaused real blocks. Each delayed
native bucket needs at most 63 priority turns, while ongoing admitted buckets use
at most 63 of each 64 new native turns. Repeated/Tier-4 pauses with no finite union
bound have no finite drain promise. Ordinary admission also bounds its
cursor-to-future index window and refuses while a stalled cursor would exceed
it. Native future due heights instead depend on the actor-set route lifetime;
there is no independent fixed native lifetime/window ceiling.
Dependency pauses have a separate catch-up qualification. If the domain was
caught up before a finite dependency-pause interval of P service turns, all
required dependencies remain unpaused afterward, and no Data stall intervenes,
its delayed obligations complete within the conservative recovery horizon
128 * 64 * (ceil(P / 128) + 2) + 256 subsequent unpaused service turns. There
are at most ceil(P/128)+2 delayed buckets; each needs at most 63 priority turns
for its reserved work and one additional turn for returning the fair cursor over
already-drained buckets. Ongoing healthy admissions use at most 63 of each 64
priority turns, leaving recovery progress. Native financial and token deadlines
remain unchanged. Repeated pauses without a finite bound have no finite drain
promise; fair scanning still gives unrelated ready obligations service.
The following row and measured-shape record preserve the historical terminal access-reservation audit (table 25). The current access-weight table is specified in CIP-43. Cancellation reserves 42 point reads and 33 writes plus a separate 2-read/2-write lifecycle release, covering the maximum five-chunk specification, nine assigned runners, container-lock refund, with one read of headroom. Its complete single-signer envelope is 87 structural accesses (118 charged at the 1.35× launch scalar). Grant cleanup retains its separate committed-volume reservations. Result submission separately prepays three reads and two writes for each operational non-deliverer (including a never-committing member whose commit window closed), covering registration and preservation of the active selection snapshot, before reputation or stake mutation. It keeps its 24-read/18-write base and payout/slash reservations; the committee reservation adds two fixed writes for the MRU reward and job back-pointer. The non-replacement rows cover terminal timeout-record deletion and lifecycle release. Committee reveals add one service-clock read; commitment reserves 9 reads/5 writes and crash attestation 5 reads/1 write. A permitted stake-funded replacement rescue additionally prepays one membership read plus max(81, 12 + 9K) reads, max(61, 7 + 7K) writes and five Scan(1) operations, where K is the original runner’s committed selection-mask population (at most 8). This covers either its direct transfer with expiry maintenance and snapshot-aware dense-index removals or fixed admission of a frozen bonus behind a principal lock; these costs do not scale with the replacement committee. A non-TEE single-runner eight-index rescue reserves 254 structural accesses including the signer envelope (343 charged at launch and the maximum scalar). Every TEE-required result additionally prepays two reads and four writes before light CAE verification, including the nonce and audit-digest GC indexes, independently of committee size or terminal outcome. The corresponding TEE rescue reserves 260 structural / 351 charged accesses. For M=9 with six payouts and three operational non-revealers, TEE settlement reserves 279 structural / 377 charged without rescue, or 457 / 617 with eight-index rescue. The 432-shape terminal audit covers both TEE settings across committees 1–9, cash/container settlement, original/replacement assignment, three rescue states and both snapshot settings; the measured worst use/reserve ratio is 87/98. A separate 24-shape single-runner container audit includes valid metered billing CAEs, whose additional two reads and two writes fit the existing terminal row: its worst ratio is 72/74, retaining one unit of headroom. Clients must estimate settlement work rather than treat the base as a complete limit.
6.3 Timeout-based re-selection
For the case where a selected runner never commits in the first place (distinct from the commit-without-reveal case handled above), timeout-based re-selection preserves liveness:- Selected runners have
timeout_blocksto submit their result commitment. - If no commitment is received within
timeout_blocks:- All timed-out runners receive a reputation penalty per §6.1 (a timeout outcome receives score 0)
- Dispatcher triggers re-selection:
retry_seed = Keccak256(original_seed || "retry:" || retry_count_le4) - Timed-out runners are excluded from the retry candidate list
- A new set of M runners is selected from the remaining candidates
- After
MAX_RETRIES(default: 3) consecutive failures, the job transitions toFailedand the persistent non-responders receive an additional reputation hit - After
SLASH_THRESHOLDconsecutive slashes, a stake slash is triggered per §11
skip_task interface; explicit skipping creates adverse incentives (runners cherry-picking jobs) and unnecessary on-chain transactions.
6.4 Failure delivery
When the chain gives up on a job with a callback, it notifies that callback so an actor awaiting the runner call resumes.-
A job that fails on a terminal path carries one of four reasons:
retries_exhausted: the job was re-selectedMAX_RETRIEStimes (§6.3, step 3) and timed out again.no_replacement_available: covers every other case where no committee could serve the job:- a timed-out job that couldn’t be re-selected before reaching
MAX_RETRIES; - a
Pendingjob that expired, or whose selection found no available runner; - a job whose re-armed expiry couldn’t be scheduled;
- a job whose key delivery found no runner.
- a timed-out job that couldn’t be re-selected before reaching
pending_key_delivery_timeout: aPendingKeyDeliveryjob reached its expiry.private_attachment_timeout: an assigned job whose runner held private issued attachments timed out. It can’t be retried (§6.2).
-
Failure delivery applies to a job whose
callback.handleris non-empty and that is not a route invocation. A callback is always self-addressed:callback.actoris the submitter. -
The callback receives the chain’s
JobFailureunder a top-levelfailurekey of the callback payload, in place ofresult(continuation shape) ordata(legacy shape). The body has exactly the keys:kind:"failure";v:1;job_id:0xand 64 lowercase hex digits;reason;attempts: the job’s retry count.
resultordata, so a failure at a callback is always chain-authored. A runner result shaped like aJobFailureis an ordinary result. -
In the same state transition as the
Failedstatus and the refund, the Job Dispatcher MUST append(job_id, reason, attempts)to a FIFO queue of at mostJOB_FAILURE_DELIVERY_MAX_QUEUE(4,096) rows. -
Delivery.
- Each block’s NativeTimer phase MUST take up to
JOB_FAILURE_DELIVERY_PER_BLOCK(1) row from the head of the queue. Rows MUST leave the queue only from its head. - Each row becomes a deferred call from the submitter to its callback handler, and runs in a later block.
- When the block’s or the chain’s deferred capacity refuses the call, the row stays at the head and the drain stops until the next block. This is not a drop.
- When the submitter is at its pending deferred-call cap (
MAX_PENDING_DEFERRED_PER_ACTOR), the row is re-appended at the tail instead, so other submitters’ rows aren’t held up. A row is re-queued at most 4 times (MAX_REQUEUES). A re-queue counts toward the block’s limit and ends that block’s drain, and the row is taken again in a later block. - A row has no age limit. The job’s spec stays readable for at least
JOB_RECORD_RETENTION_BLOCKSservice blocks after the job ends, and Job Dispatcher pauses don’t count toward them, so only a capacity refusal lasting that long makes the row a drop (item 7). - The drain has a fixed share of the NativeTimer phase’s native allowance, and the phase still fits its full due-timer window.
- Each block’s NativeTimer phase MUST take up to
-
The callback runs with the job’s declared resume budget, the same cycle and cell limits a result callback gets. The submitter pays for it like any deferred child: the maximum fee is held before the handler runs, then settled to actual use. A submitter that can’t be held gets
DeferredPayerUnfunded(E1015), and the handler doesn’t run. Like a result callback, the call runs in the User lane: it is minted with a non-zero origin unique to the delivery and a deferred gas pool holding its declared budget. So JobSubmit’s funding check (E1622) prices it correctly, and one heavy callback can’t exhaust the smaller Timer lane and cost a later callback its delivery. -
A failure is not delivered when:
- the queue is full;
- the row was already re-queued 4 times because the submitter stayed at its pending deferred-call cap, or the queue is full when it would be re-queued;
- the job’s spec can’t be read.
- While the Council has paused the Job Dispatcher, the queue MUST be neither drained nor modified.
-
Actor view (
cowboy_sdk).- An await inside a
trythat catches the failure raisesJobFailed(reason, job_id, attempts)(E1621). For a generated off-chain proxy it raisesOffchainError("unavailable: <reason>").- The
trymust name the error its await raises:OffchainErroraround a generated off-chain proxy (a module-level function the off-chain build exports), andJobFailedaround any other await, imported at module level fromcowboy_sdkand not rebound. A tuple of both is accepted. Atrythat names only the other error is refused at compile time. - Only a generated proxy’s result decoder sees the failure. Any other callee raises
JobFailedwithout calling its decoder.
- The
- Any other await ends the method when its job fails: the continuation is deleted, the method returns
None, and nothing after the await runs. This includes every@runner.continuationmethod, and bare awaits. It holds even when the continuation has expired or a key it guards has changed: those checks protect the code after the await, which doesn’t run. - A dropped failure, or an E1015 callback, leaves the continuation stored, and it counts toward the actor’s 100-continuation limit.
- An await inside a
7. Entitlement Registry (0x0000…0007)
The Entitlement Registry is a system Actor that provides a unified, on-chain permission management layer. For this CIP, its primary role is Runner Pool access control (gating job assignments to a curated set of runners). It also provides capability grants consumed by other subsystems (Token admin delegation, Actor access control, etc.).
The role registry is removed. GET /entitlements/address/{address} returns address and entitlements; it no longer returns roles.
7.1 Core Type System
The Entitlement type system:EachA direct grant (Entitlementrecord covers one(Scope, Action)pair. Granting multiple actions requires multipleGrantcalls. This keeps revocation granular: revoking one action does not affect others.
parent_id = None) with a nonzero max_uses is deleted on its final use, when used_count == max_uses. An exhausted delegated grant is retained until revoked and cannot authorize another use. Exhausting an amount ceiling alone does not delete a grant.
7.2 System Instructions (instruction numbers 30–32; 33–35 retired)
EntitlementCreateRole, EntitlementAssignRole, and EntitlementRevokeRole, are permanently retired. Decoders MUST reject them, and these tags MUST NOT be reused.
CIP-2 v3 has additional parameter-governance opcodes. The CIP-2 v3 mechanism parameters are governance-tunable via their own system opcodes (94–96, 98–100), each restricted to GOVERNANCE_SYSTEM_ACTOR (0x09); opcode 97 (SubmitCrashAttestation) sits in the same numeric block but is a runner self-attestation, not a governance update. This CIP MUST enumerate them:
7.3 Runner Pool Membership Model
A Runner Pool is an on-chain access-control list identified bypool_id: Vec<u8>. Membership is represented as an Entitlement:
cby- is a reserved platform pool and MUST be a CIP-10 §5.11 registry name; any other id is a non-zero 20-byte owner address followed by a registry name, at most 83 bytes in all. EntitlementGrant and EntitlementRevoke for Scope::RunnerPool(p) MUST reject unless the sender owns p: a genesis.system_deployers sender for a reserved id, otherwise the address p[..20]. Any other id form rejects, and so does an id under cby-example-. A role MUST NOT confer pool membership. This rule covers every pool id, including job pools. EntitlementGrant for Scope::RunnerPool(p) MUST carry Action::RunnerJoinPool(p) and revocable = true. Only the pool’s owner revokes a membership; the grantee cannot. An owner’s re-grant to a current member may change only valid_until, renewing the membership in place. Pool membership comes only from registry grants: RunnerRegister rejects a non-empty self-declared entitlements list with InvalidData (1213).
Candidate filter check (step 7 of §4, at submission_block):
parent_id = None) Entitlement matching (grantee, scope, action) exists; a delegated entitlement or a role confers no membership, the same rule CIP-10 §17.3 applies to host pools. If fewer Runners pass than the job needs, selection fails with InsufficientRunners (1607). used_count is not incremented by the membership check, only by explicit max_uses-bounded grants (e.g. one-time trial membership).
Access modes:
7.4 Gas Costs
7.5 Safety Limits
7.6 Integration Requirements
- If the Entitlement Registry Actor does not exist, all checks return
false(no runner is admitted via pool filter). Jobs withrequired_runner_pool = Noneare unaffected. - Token
owner == callerchecks remain the first-priority gate; Entitlement provides an additional delegation path, not a replacement. - Entitlement instructions use 30–32; retired tags 33–35 remain reserved and cannot be reused.
8. Result Submission: Commit-Reveal + Designated Aggregator
The commit-reveal + aggregator model reduces on-chain Gas by ~(N-1)/N compared to having all runners independently submit full results to chain, and prevents runners from copying each other’s results after seeing them.
- All M selected runners execute the job independently.
- The aggregator is selected from the committee per §8.1 and coordinates submission.
- Runners cannot copy others’ results after seeing them (commitment pre-locks the result).
- Aggregator cannot forge other runners’ results (commitment-bound).
- If the aggregator fails, other runners may submit individual reveals after the per-job reveal deadline (
JobSpec.timeout_blocks, CIP-11); Result Verifier falls back to self-aggregation. (Note: there is no distinctaggregator_timeout_blocksconstant in code.AggregatorConfigcarries only{eligibility_percentile, bonus_bps}; the fallback is gated by the per-jobtimeout_blocks, not an aggregator-level timeout.) - Section §6.2 defines the
CrashAttestation-gated classification of non-reveals.
8.1 Aggregator selection — eligibility threshold + uniform random
The aggregator is selected as follows:ineligible set does not exclude it. The election runs over the runners with a stored result, and non-reveal classification happens after it, so at election time a non-revealer is in neither runners_to_slash nor runners_unrewarded. Reading pool as the drawn committee would admit a runner that the implementation never considers and that cannot be paid, since payment uses the same submitted set. That is exactly the elected-but-unpayable aggregator this filter exists to prevent, so submitted is normative: with committee {A, B, C} where C never reveals, the pool is {A, B} and not {A, B, C}, which changes the percentile threshold, the eligible set and therefore the elected aggregator.
The ineligible filter is normative because election carries aggregator_bonus; an elected-but-unpayable aggregator strands that bonus outright, neither paid, burned, nor sent to treasury. The percentile excludes low-reputation griefers. A fresh griefer at the registration default sits above the median when the committee is uniformly fresh. The exclusion covers runners_unrewarded and runners_to_slash because election rewards completed submissions, as CIP-11 §9.4 specifies. A state-dependent fault cannot be attributed without punishing an honest runner that lost a build-vs-verify race. Withholding the reward requires no attribution of dishonesty.
Note the fallback subtracts ineligible before the percentile, and never falls back to the full committee: an ineligible runner cannot be re-admitted by an empty eligible set. When the whole committee is ineligible the result is no aggregator at all, and the distribution falls back to pre-aggregator semantics with aggregator_bonus = 0.
Aggregator identity carries aggregator_bonus and therefore payment distribution, so two implementations that disagree here fork. “Reputation ≥ the 50th percentile” admits several standard readings that select different pools. Over [1,2,3,4,5,6], the integer lower-rank rule above yields threshold 3 and a 4-member pool, while linear interpolation yields 3.5 and a 3-member pool, so seed mod 4 and seed mod 3 pick different runners from identical inputs. Seed byte order and indexing the committee rather than the sorted sequence can also change the selection.
Why eligibility + uniform-random and not pure highest-reputation:
- “Highest reputation” gives new runners zero probability of aggregating. They cannot build their reputation by aggregating successfully.
- Eligibility threshold (p50) ensures aggregators are competent without locking new runners out permanently. Once a new runner crosses p50, they enter the eligibility pool.
- Uniform random within the eligible set prevents any deterministic-tie-breaker from concentrating aggregator share at a single high-reputation runner.
8.2 Aggregator bonus — 1.5% of gross
(89% − 1.5%) = 87.5% divided across non-aggregator runners pro-rata to commit-reveal weight, plus 1.5% aggregator bonus.
Cash and container settlement exclude the union of runners_to_slash and runners_unrewarded. Operational failures are in runners_failed and runners_unrewarded, with no stake slash: schema-invalid StructuredMatch results or INVALID comparison fingerprints, missing/INVALID canonical MajorityVote keys, INVALID Deterministic results, missing/malformed SemanticSimilarity embeddings (including zero or non-finite squared norms) or a self-reported model mismatch. Rejected chain-root reveals follow the non-reveal rules; their defensive verifier filters do not promise lifecycle neutrality. The same exclusion applies to aggregator election, the rescue bonus and MRU routing reward. StructuredMatch grouping dissent alone remains payable and unslashed, but does not earn the MRU reward.
An excluded dissenter’s equal-payment share MUST be redistributed to the remaining consensus cohort (per_runner = equal_pool / (n - s), before integer remainder assignment, for n submitters and s excluded runners), so the runner pool rewards the runners that completed verification instead of being burned; the rescue bonus uses the same payout-eligible cohort.
Aggregator bonus paid only on successful settlement (verification mode check passes, no slash event). Failed aggregations cost the aggregator the bonus; the §6.2 non-reveal classification handles outright dishonesty.
9. Verification Modes
The two single-runner rows (
None, EconomicBond) are dispatched with M = 1 via the §5.2 immediate mode; adaptive committee sizing applies only to the quorum rows (§5.1, Scope of adaptive sizing).
In EconomicBond mode, EconomicBond settlement accepts the single revealed result, with the runner’s slashable stake bond validated at dispatch; the settlement arm enforces exactly one result. The mode’s assurance is that slashable bond plus the §6 reputation/timeout machinery. CIP-45 additionally requires a structured result’s format, schema, reported model name, and size to pass submission-time admission before it can enter settlement. Those checks establish admissibility, not whether the value is true or the claimed model actually ran; rejection does not classify or slash the runner. An admissible structured failure object settles like an admissible value. Beyond these admission checks, objective-failure classification (schema violation, timeout, empty/garbage output, non-delivery, wrong model, prompt-injection leak) and objective-failure challenge-window semantics are out of scope for this CIP; WP §9.2 defines them as the target semantics for the mode (1 runner, use case “subjective generation”).
An accepted reveal that leaves no consensus or a valid cohort below threshold returns pending success, with its result persisted. This applies to generic quorum modes and chain-root verification. In generic modes, it does not roll back honest peers merely because an earlier accepted malformed result supplied no valid vote; settlement or timeout later applies that submitter’s operational consequence. Rejected chain-root reveals are not persisted and instead follow the non-reveal rules above.
Quorum comparison canonicalizes integral JSON numbers such as 5 and 5.0 to the same integer. Non-integral numbers, NaN, infinity, or values exceeding the codec limits have no comparison key. Results that need decimal values MUST express them as scaled integers (with an agreed scale) or strings. In the Python SDK, Verify.majority_vote(field=None) compares the entire result.data, including nested values; set field to compare only that field. A missing selected field is invalid. If every MajorityVote result is invalid, the verifier reports NoConsensus and the submission remains pending; StructuredMatch values excluded from grouping cannot contribute toward its threshold. PublishChainRoot and DNS use their dedicated verification paths.
9.1 VerifierCheck variants
VerifierCheck is the per-check enum used inside verification.checks: Vec<VerifierCheck>. The supported variants:
f64 fields above are the node’s in-memory representation only. On the canonical
wire, and therefore in every hash preimage, tolerance/min/max are
scaled-integer Nano values per CIP-11 §12.6 (implementations map
f64 ↔ Nano at the boundary); canonical encodings never contain floats, per
the whitepaper’s no-floats rule.
The codec retains DnsTxtRecordMatch and DnsCnameMatch representations, but node admission rejects both before dispatch (§3.1). They are not supported verifier checks.
9.2 SemanticSimilarity embedding pinning
SemanticSimilarity mode (N ≥ 3; cosine similarity clustering; largest cluster wins) requires a pinned embedding model so that a runner cannot collude with the embedding choice. The default:
model_id field in §1). Changes follow the CIP-12 §5.1 payload floors:
- Per CIP-12 §5.1, model-registry flags/bans require at least Tier 1.
- The specific entry
system:cip2:semantic_similarity_embedding_modelis changed byUpdateSemanticSimilarityModel, which requires at least Tier 0 under the technical whitepaper and CIP-12 §5.1. The model remains a consensus-verification input: every verifier must use the same governed identifier.
10. JobType::Custom Extension Pattern
CIP-2’s existing JobType::Custom { executor_hash: [u8; 32], params: Vec<u8> } is the established mechanism for adding new verifier-bearing job types without expanding the JobType discriminant set.
Pattern for a new built-in verifier:
- Build the verifier as a deterministic executor binary using Rust with a reproducible build.
- Hash the binary with BLAKE3.
- Pin the hash via governance: write a record at
GOVERNANCE_SYSTEM_ACTOR=0x09keyedsystem:executor_registry:<name>. - Issue jobs as
JobType::Custom { executor_hash: PINNED_HASH, params: <serialized job-specific params> }. - Runners that have whitelisted the executor execute the job. Verification proceeds via the standard
VerifierCheckchain using the supported checks in §9.1.
JobType for every new built-in verifier and keeps the discriminant space stable.
10.1 Governance pinning vs. open executors
JobType::Custom accepts any executor_hash, including user-supplied ones. The protocol does not require governance pinning. Governance pinning is the convention for protocol-level executors used by system actors; user-deployed verification jobs (e.g., a DAO running custom market-data validation) can use any hash they trust.
The distinction is purely operational: governance-pinned executors can be referenced by system actors because the hash is itself part of the chain’s normative state. User-supplied hashes are the user’s own trust assumption.
11. Slash Distribution Schema
Under bounded delegated slashing (rules-v2), timeout, deferred non-reveal, ResultSubmit dissent/non-reveal, and fraud conviction enqueue durable liability when the runner has retained delegation tranches. Reputation penalties, exclusion, and payment withholding apply at classification; principal and slash-distribution transfers are processed by the bounded service in CIP-13 §3.6.1. The runner cannot gain a new assignment or withdraw locked principal while an intent remains open. The FIFO has no fixed admission cap, so a payerless classifier cannot fail because the old 32-entry pending-slash queue is full. Distribution, beneficiary, offense height, and epoch-cap policy are frozen per intent. The service retains the 1,089-unit BlockStart allowance and alternates slash/ordinary timeout turns only while work is pending; a 6,400-tranche FIFO head needs at most 2,401 service items (4,802 blocks, excluding pause/capacity deferral and recovery stalls). The bridge-specific 32-tranche first-publication and delegation-growth restrictions remain admission bounds after conviction becomes paged; relaxing them is a follow-up after bounded payout work. Conviction itself has no tranche-count veto, admits each proven signer independently of retained tranche count, and applies the immediate reputation penalty. These admission bounds are distinct from the removed 32-entry pending-slash queue cap. Slashes accepted under a RevealAuction lock instead enter its permissionless competing queue and are outside the BlockStart completion bound. Non-delegated slashes retain their atomic path. A persistent Data fault at a Service head stalls the whole global service queue, including unrelated runners, for an unbounded time until operator repair; its turn rolls back and the block commits. Corrupt runner-registration fields (including the pending mirror) and selection-snapshot overrides remain outside this recovery guarantee and can still fail payerless BlockStart. Service never takes or releases a live Reveal lock. Matured claims remain blocked during a drain. Finalization re-stamps the dispute cooldown only on the below-minimum-self-stake reputation-reset branch. A frozen rescue intent survives reaping of the original terminal timeout row and remains payable from the original runner’s stake. Only a recordedSlashable disposition can create this entitlement; operational failure, no failure and an absent disposition never authorize it. When pending-runner exclusion shrinks a new committee toward its governed minimum, its absolute approval threshold falls; that floor is a security parameter.
0x09 under system:cip2:slash_distribution.{burn_bps, submitter_bps, treasury_bps}. Genesis values (10000, 0, 0), consistent with WP §8.4 commitment C7 (“Slashed stake | 100% | Burned”). Submitter and treasury shares are inactive at launch; the schema supports a future amendment.
Any non-trivial change (any bps shifted away from the (10000, 0, 0) default) requires a Tier-3 governance proposal that also amends WP §8.4 C7 in lockstep. The schema-level flexibility does not unilaterally override the C7 commitment. CIP-12 §5.1 Tier-3 row implicitly covers this because changing slash distribution is a substantive economic-mechanism change, not a scalar tweak.
With a Tier-0 schema and Tier-3 mutability, the field structure lives in code from the outset (no schema change when the C7 amendment lands); only governance authority changes per-amendment. This avoids the “schema added later” trap that creates two competing code paths.
Non-reveal slash magnitude (used in §6.2 path 3):
The 25% fractional slash is the architecture-review recommendation; the absolute cap prevents catastrophic overshoot on extremely large stake positions.
12. Stake Floor (HOLD on CBY-denominated)
The runner stake floor is preserved asmax(10,000 CBY, 1.5 × declared_max_job_value) (CBY-denominated, not USD-pegged). Per the architecture-review Decision Register item #4, the analysis default is CBY-denominated stake floor with documented Tier-0 monitoring cadence rather than USD-pegged via TWAP oracle.
- The Cowboy Foundation publishes monthly the implied USD value of the 10,000-CBY floor and the median runner’s effective stake. If the implied USD floor drifts outside the target band
[$1,000, $10,000]for two consecutive monthly reviews, a Tier-0 governance proposal MUST be filed to adjustMIN_RUNNER_STAKE_CBY. - This CIP does NOT introduce a consensus-layer CBY/USD oracle. Re-pegging is a future option gated on a forthcoming oracle CIP.
- If CBY appreciates 10×+ and the 10,000-CBY floor becomes punitive for small runners, the monitoring cadence above triggers a Tier-0 adjustment. The dispatcher continues to admit runners meeting the formula until that proposal lands.
13. Randomness Source
The selection seed IKM is thecommonware threshold-BLS beacon: a verified Seed { round: Round(epoch, view), signature } for a named absolute round, with the timing and domain rules of §5 and the security assumption that t-of-n validators are honest. There is no selection-seed stage in which the IKM is a block hash, an execution hash, a proposer timestamp, or any proposer-local value (e.g. a proposer EC-VRF output): a proposer-generated seed is grindable and can steer committee membership.
The Actor randomness API is independent of this path and unchanged: Actors keep HKDF(beacon, label) with no Actor-code change.
14. Governance Parameters
The mechanisms in §5–§11 are in effect for all jobs; the values in those sections are the launch defaults. Each parameter group is mutable through its own governance proposal instruction, at the tier its defining section assigns. Proposal payloads are atomic per group. Each proposal replaces the group’s full config, not a single field:
The VRF draw-weight floor (
w_min_floor, §5.3) is a protocol constant. No governance proposal payload carries it.
Jobs in flight when a parameter changes retain their committee, aggregator, and verification mode for completion; new jobs use the updated values.
15. Open Questions Deferred to Phase-5 Simulation
- If a single large runner exits/enters and HHI shifts from 0.10 to 0.50 in one epoch, M halves. The smoothing factor
α = 0.125damps this, but extreme cases may still cause perceptible per-job cost swings. Phase-5: simulate with realistic runner-set dynamics. - The reputation half-life of 14 days is the launch default; longer is more stable but slower to recover from rare-event mistakes; shorter is more reactive but lets recent bad runners re-enter selection too fast.
- The
crash_exemption_blocks = 50default allows hardware reboot signal propagation while deterring “stall, observe, decide” tactical non-reveals. Phase-5: model attacker dwell time against block-time-to-attestation latency. - For the VRF weight
sqrt(reputation), whetherr^0.5orr^0.4better matches empirical merit signals remains open. Sensitivity to the exponent is high in the upper tail. - SlashDistribution
(10000, 0, 0)HOLD vs(5000, 2000, 3000)AMEND, gated on Decision Register #1 (WP §8.4 C7 amendment).
Rationale
- A ring buffer selects N consecutive indices, so an adversary’s adjacent active-list positions are always selected together for an N-runner job. Fisher-Yates with independent weighted draws removes this correlation.
-
Equal-probability selection ignores stake, making Sybil attacks cheap. Pure-stake weighting amplifies “rich-get-richer”.
sqrt(reputation)weights selection by reputation: a 4× reputation differential becomes a 2× selection-probability differential. This does not enable reputation-mining attacks or lock out new entrants. -
A static
M=5committee costs too much in a large decentralised network and provides too little protection when stake is concentrated. HHI scales M with concentration;M_min/M_maxbound it. - The EMA reputation model uses a 14-day half-life. The decay lets runners recover from rare bad events while delaying re-entry for a recent bad runner.
- Always choosing the highest-reputation runner excludes new aggregators. Uniform-random selection among eligible runners allows entry while limiting aggregation to ≥ p50 runners.
-
Under the non-reveal classification with
CrashAttestation, non-delivery always costs reputation when settlement, timeout or replacement closes the assignment. An open reveal window protects stake; an expired, unattested commitment is slashable. A crash attestation protects stake after the deadline but never removes the reputation penalty. Withholding during the default 30-block job timeout is therefore priced by reputation even though its 60-block reveal window remains open. -
Deriving the seed from the consensus threshold beacon (
Keccak256(domain || mode || canonical_seed_bytes(R) || job_id || submitted_at)) instead of a dispatcher private key eliminates the hardcoded-key security hole. The threshold seed is consensus-verified, unique per absolute round, and globally consistent. No single proposer can grind the randomness source itself. ForM > 1the commit-then-reveal path closes proposer selection bias;M == 1retains the bounded inclusion-timing residual described in Security Considerations. -
Timeout re-selection avoids
skip_taskbecauseskip_taskcreates adverse incentives (runners selectively skip low-value jobs) and adds unnecessary on-chain transactions. Before E3, passive timeout with reputation penalty is the recovery path. After E3, the bounded, single-runner assignment decline is the explicit exception, with its reduced EMA penalty and private-volume terminal-failure rule. - If every runner submitted to the chain, it would cost Gas × N and permit copying. Commit-reveal prevents copying; off-chain aggregation reduces Gas costs. The eligibility-threshold selection (§8.1) is preferred over a highest-reputation tie-breaker because it allows new runners to bootstrap their reputation.
- Callbacks run as deferred transactions (CIP-1), so off-chain execution does not block the main chain execution path.
- Result schemas define the output constraints for developers and Runners. They prevent gas-bombing and simplify result verification.
-
Adding a new
JobTypediscriminant for every new built-in verifier fragments the type space. The existingJobType::Custom { executor_hash, params }covers all cases; governance pinning of the hash makes a verifier “built-in” without protocol changes. -
Without pinning, a runner could collude with the embedding-model choice. The governed identifier is updated through the Tier-0
UpdateSemanticSimilarityModelpayload; the general model-registry flags/bans path remains Tier 1. -
To preserve the C7 defaults,
SlashDistribution { burn_bps, submitter_bps, treasury_bps }is in code from the outset, but defaults(10000, 0, 0)preserve WP §8.4 C7. The schema supports a future challenger-bounty amendment. - Pool membership uses an on-chain Entitlement record with expiry, rate-limit, and delegatability fields. This allows time-bounded trial access and revocable membership without protocol changes; pool membership is non-delegatable.
-
Each Entitlement record carries one
(Scope, Action)pair. Revocation leaves other actions unchanged, and membership checks cost O(1) per action.
System Actors and Runner Integration
CIP-2 directly claims0x01 (Runner Registry), 0x02 (Job Dispatcher), 0x03 (Result Verifier), 0x04 (Secrets Manager), 0x05 (TEE Verifier), and 0x07 (Entitlement Registry). The canonical allocation table is in whitepaper §9.1.
Runners MUST pin the complete /chain-info.activation.runtime_fingerprint from
an independently reviewed release set through
COWBOY_EXPECTED_RUNTIME_FINGERPRINT. The fingerprint covers the chain ID,
compiled activation heights, and numeric policy values, including
RULESET_REVISION. Each released consensus ruleset MUST increase that revision
once, including releases without an activation-height change. All changes in the
rules-v2 release share revision 1; individual changes within a release do not
increase it. Governance values are excluded. Missing, malformed, mismatched, or
stale compatibility evidence refuses runner signing and submission;
/statusz.activation_refusal exposes that refusal.
Operators rotate the reviewed expectation with the matching node release.
For rules-v2 the published object has three compiled BANK/PAYMENT heights,
four numeric policy entries, and an empty governance section. The runner MUST
reject a nonempty governance section. It establishes compatibility after its
finalized-event subscription catches up, re-reads /chain-info on reconnect,
governance.param.changed, or a gap, and revokes agreement when the feed closes
or stops answering keepalives. A governance event is only a reason to re-read:
its payload MUST NOT supply activation values or replace the reviewed expected
fingerprint. Agreement does not expire on a polling cadence while the feed
remains healthy; an unreadable activation response revokes it and retries on
backoff. Admission, signing, and submission continue to check the shared
compatibility state at their existing boundaries.
Timeout re-selection (§6.3) provides job liveness when a runner does not execute its assignment. JobType::Custom provides the extension mechanism in §10. Runners SHOULD handle CrashAttestation events from the Result Verifier; a crash without a valid attestation receives the ordinary slash disposition.
Security Considerations
-
Selection can be influenced by a submitter choosing job bytes /
submitted_ator a proposer/leader influencing the randomness source (a block hash is proposer-assembled, and a height-anchored beacon can drift across rounds under a withholding leader, which is why neither is an acceptable seed source). The absolute-round threshold seed (§5; CIP-11 §9.2, §15.9) closes both paths forM > 1committees: the job binds before the seed for the named future round exists, and that round’s seed is unique. A withholding leader can delay it but cannot re-roll it. ForM == 1, two residuals remain: the submitter may know the parent beacon before submitting, and the proposer of the including block, who sees the pendingJobSubmitand already knows the parent beacon, can include, omit, or defer the transaction to sample a different parent beacon (inclusion-timing selection). Immediate mode therefore does not provide proposer-inclusion neutrality. Both residuals are MEV/fairness-bounded (each attempt is an ordinary paid job, deferral is bounded by normal mempool/liveness/economic costs, and the selected runner stays economically accountable), not a committee-independence break. Submitters that need selection neutrality SHOULD request a quorum verification mode (which dispatchesM > 1wheneverN_activepermits; §5.1, Scope of adaptive sizing). -
The
stake · sqrt(reputation)weight (§5.3) weights selection by reputation without enabling reputation-mining or pure stake monopoly. The adaptive committee rule (§5.1) further mitigates concentration by scaling M with the measured HHI of effective stake. - The Aggregator sees all results before submitting to chain. Mitigations: (1) other runners’ commitments are locked before Aggregator submits; (2) other runners can independently reveal if Aggregator is unresponsive; (3) Aggregator’s extra reward is forfeit if the submitted VerifiedResult is later challenged; (4) the eligibility-threshold + uniform-random selection (§8.1) prevents permanent aggregator capture by a single high-reputation runner.
-
Minimum stake (
MIN_STAKE = 10,000 CBY) and reputation threshold (min_reputation = 50) provide economic deterrence. The Entitlement pool mechanism (§7) allows job submitters to further restrict runner eligibility. -
A malicious developer could write a callback that always fails, preventing runners from being paid. The
failed_callbackscounter accrues as a reputational penalty, and runners may blacklist actors with high failure rates. -
The candidate list is fixed at
submission_block. The Merkle root of the candidate list must be stored on-chain at submission time to enable re-selection verification. Runners who join or leave post-submission do not affect the snapshot. -
The default
SlashDistribution = (10000, 0, 0)preserves WP §8.4 commitment C7. Any non-trivial change requires Tier-3 governance that also amends C7 in lockstep. The schema-level flexibility does not unilaterally override the C7 commitment. - The CBY-denominated floor may drift relative to USD purchasing power. The §12 monitoring cadence and the lack of consensus-layer oracle dependency are the v3 trade-off; re-pegging is gated on a forthcoming oracle CIP.
-
Each address is limited to 256 Entitlements.
EntitlementGrantconsumes 500 Cells to deter spam. Direct grants are deleted at their final use; exhausted delegated grants remain until revoked. Expired grants fail permission checks but remain stored and count toward the 256-entry cap until revoked. -
delegation_depth_max(max 5) and the requirement that delegated constraints be a strict subset of parent constraints prevent privilege escalation through chained delegation. -
Pool Entitlements with
valid_untilset are automatically ineligible after the specified block. Node operators running compliance-sensitive pools should set time-bounded grants and renew via governance.
J: native execution liveness across activation
J1: block-time cycle denomination
AtEXECUTION_CYCLE_LIMITS_ACTIVATION_HEIGHT, height-selected lane limits and resume execution limits
replace the old denomination. Values remain named parameters until the J1
benchmark supplies them; no provisional measurement authorizes scheduling:
The merged J1 parameter scaffold retains the legacy cycle
ceilings and unset headrooms pending calibration. It does not resolve these
benchmark placeholders or authorize scheduling.
At and above
EXECUTION_CYCLE_LIMITS_ACTIVATION_HEIGHT, select
J1_BLOCK_CYCLES_TARGET at read time when no BasefeeConfig row is stored
or its stored block_cycles_target equals the pre-gate compiled
BLOCK_CYCLES_TARGET (20,000,000). These are the default cases; a stored
non-default target MUST be preserved. Row presence alone does not establish
an explicit override: genesis writes a complete row, and every
UpdateBasefeeConfig rewrites all fields. A governance value of exactly
20,000,000 is indistinguishable from the default and therefore follows J1.
This height-selected read MUST NOT write the row at activation or use
CIP-50’s one-shot activation-write mechanism.
The height-selected target helper preserves that
default-versus-explicit distinction.
Limits alone are insufficient: the benchmark’s admissible 20,626-cycle
actor, repeatedly replacing within an eight-million-character string, takes
1.4–1.7 seconds against the default 800 ms proposal budget. A smaller lane
cannot exclude such unpriced size-dependent native work while retaining the
default/minimum resume budget.
Size-dependent builtin pricing activates independently at
PVM_SIZED_BUILTIN_METERING_ACTIVATION_HEIGHT (Upgrade 1); J1’s lane and
resume limits retain EXECUTION_CYCLE_LIMITS_ACTIVATION_HEIGHT (Upgrade 3).
For every chain id, the declared prerequisite is
H(PVM_SIZED_BUILTIN_METERING_ACTIVATION_HEIGHT) <= H(EXECUTION_CYCLE_LIMITS_ACTIVATION_HEIGHT).
Both gates land at NOT_SCHEDULED; equal scheduled heights are permitted.
The native frame configuration selects builtin pricing
by the chain id and execution height independently of memory metering.
Before PVM_SIZED_BUILTIN_METERING_ACTIVATION_HEIGHT is scheduled on any
network, both frozen-importer gas depending on the build directory
and in-process registry probe costs depending on earlier frames
MUST be resolved (scheduling preconditions).
At and above the sized-builtin gate, size-dependent string and bytes
builtins MUST charge Cycles per byte for work whose time scales with
input/output length, including search/replace, splitting, comparison and
construction/copying. Per-byte work is a Cycles-only charge; the existing
memory-cell guard and its charges remain unchanged. Retain the existing
base operation charge. The four per-byte rates keep the names
J1_STRING_SCAN_CYCLES_PER_BYTE, J1_STRING_COPY_CYCLES_PER_BYTE,
J1_BYTES_SCAN_CYCLES_PER_BYTE and J1_BYTES_COPY_CYCLES_PER_BYTE.
The merged rate constants and native surcharge
keep those identities separate from lane calibration.
Charges MUST be proportional to the work performed, using a deterministic
formula for each operation. Charge the bytes scanned (UTF-8 bytes for
strings, bytes for byte sequences) and a conservative bound on bytes copied
before the corresponding native scan, allocation or copy, including
every operand scanned and repeated copies. Incremental work is charged
before each bounded step. In particular:
- Hash tables charge for each key hashed according to its length and for each probe comparison, never for the table’s size. Iterators charge per element yielded, not for the remaining container.
- JSON scanners and string parsers charge the span consumed from the supplied index, not the whole document. Regex charges a constant per engine step plus the characters consumed, not the input’s whole length at every step.
- Constant-time operations incur no scan charge: string/bytes length and truthiness, ASCII string indexing, bytes/bytearray indexing and a list pop from the end. Non-ASCII string indexing charges the scan to the selected position; deque rotation charges
min(abs(k), n)elements. - Big-integer work uses the deterministic square of the number of 64-bit words; Unicode normalization charges linearly in the input length.
J1_FRAME_HEADROOM and J1_PROPOSE_HEADROOM positive before activation is
scheduled. At and above
EXECUTION_CYCLE_LIMITS_ACTIVATION_HEIGHT, preserve the lane allocation
relationship sum(lane_cycles) == 4 * J1_BLOCK_CYCLES_TARGET, using the
compiled J1_BLOCK_CYCLES_TARGET, never the governed
BasefeeConfig.block_cycles_target. Preserve
MAX_RESUME_CYCLES == LANE_USER_CYCLES for each active limit set. Require
MAX_RESUME_CYCLES >= DEFAULT_RESUME_CYCLES (1,000,000) and
MAX_RESUME_CYCLES >= MIN_RESUME_CYCLES (102,000 at baseline). The J1
benchmark must also prove admitted minimum frames still fit their lanes.
The merged native selector and invariants retain these
lane and resume relationships.
Gate block validity, frame meters, proposal selection and route-admission
lane-fit checks consistently. CLI and other signers carry both limit sets
and choose by the chain’s published EXECUTION_CYCLE_LIMITS_ACTIVATION_HEIGHT
state. Below EXECUTION_CYCLE_LIMITS_ACTIVATION_HEIGHT, the exact old limits
and validation remain in force.
Signature time is not an execution
rule selector. A job signed below EXECUTION_CYCLE_LIMITS_ACTIVATION_HEIGHT,
whether admitted before that height or submitted afterwards, MUST retain its
original signed JobSpec, hashes, callback declaration and resume escrow.
Historical decoding and validation MUST continue accepting the old
resume-budget range. Do not shrink a shared
codec maximum so that previously valid jobs stop decoding or fail readback.
New admission at or above EXECUTION_CYCLE_LIMITS_ACTIVATION_HEIGHT MUST
separately enforce the active maximum; a pre-height signature first submitted
afterwards may therefore require a new signed job with a smaller budget.
Most JobSpecs instead originate in
actor code. The frozen SDK’s client-side maximum (22,400,000) cannot change
at the height: native admission MUST still enforce the active maximum for
actor-originated submissions. An actor explicitly requesting a now-too-large
budget receives that deterministic refusal and needs an authorized code or
configuration update to request a valid budget. Actors omitting the budget
retain the accepted 1,000,000-cycle default; do not silently edit frozen SDK
validation or previously stored JobSpecs.
For an already-admitted job whose signed resume budget exceeds the new
maximum, every callback/resume frame executed at or above
EXECUTION_CYCLE_LIMITS_ACTIVATION_HEIGHT MUST natively
use effective_cycles = min(signed_resume_cycles, active_MAX_RESUME_CYCLES).
This includes result and chain-authored failure callbacks and previously
queued continuations. Use the effective amount for lane-fit eligibility,
reservation and the execution meter, so the old declared maximum cannot
strand a callback forever or permit an over-limit frame. Leave the stored
signed budget unchanged; charge actual work under the existing accounting
rule and release unused escrow normally. If the callback exhausts this
smaller meter, use the ordinary deterministic out-of-cycles/failure path,
not an infrastructure halt, a fabricated success or an endless deferral.
Newly minted native RunnerCallback children at or above
EXECUTION_CYCLE_LIMITS_ACTIVATION_HEIGHT set their cycles limit to the
effective budget before their child digest/fee reservation is built.
A child already queued across EXECUTION_CYCLE_LIMITS_ACTIVATION_HEIGHT
retains its committed cycles_limit and digest/proof-of-origin bytes: clamp
its native lane-fit, execution reservation and meter without rewriting that
transaction. Existing excess fee/escrow
holds settle/refund through the normal rule; do not retroactively change an
origin receipt’s deferred-transaction hash.
The native transaction boundary applies the shared
resume/frame clamp without rewriting the signed input.
At EXECUTION_CYCLE_LIMITS_ACTIVATION_HEIGHT, decouple both existing
Cells/Cycles aliases explicitly:
MAX_RESUME_CELLS currently aliases MAX_RESUME_CYCLES, and transaction
admission currently compares both cycles_limit and cells_limit to
LANE_SYSTEM_CYCLES. The active resume Cells maximum MUST instead retain
its independent cell bound from below that height (22,400,000 cells), and
the active transaction Cells admission maximum its independent bound from
below that height (32,800,000 cells), regardless of the new cycle caps.
Keep the existing cell minima/defaults and historical validation. A future cell-limit change
requires its own explicit rule; sized-builtin per-byte work is a Cycles charge,
not a reduction in authorized Cells.
The independent Cells bounds preserve both maxima.
Enforce the cap at the native execution boundary; do not edit the frozen
pvm/Lib/cowboy_sdk/runner.py or any other frozen SDK file. Tests MUST cross
EXECUTION_CYCLE_LIMITS_ACTIVATION_HEIGHT with an old above-new-maximum job,
including a queued result and failure callback, and exercise both successful
completion within the cap and deterministic exhaustion. Also test
rejection/re-signing for an old signed
job first admitted after the height.
J2: block-start quarantine or halt
AtRUNNER_LIFECYCLE_QUARANTINE_ACTIVATION_HEIGHT, the following native
runner-maintenance paths use the same deterministic-data disposition. This
scope is concrete; it is not a catch-all around every BlockStart error.
This gate is per-network under CIP-50 and
lands at NOT_SCHEDULED on every network until scheduled.
For native session reconciliation, a deterministic fault inside the settlement
transition MUST still roll back and stall that reconcile queue, as before J2:
the transition writes shared rows and is outside the item-isolation boundary.
An absent expected queue entry or member row is shared-metadata damage and
MUST stall the queue; it MUST NOT be quarantined as an item.
A shared-metadata stall in the fair native-maintenance scheduler MUST persist
prefer_cleanup for the other queue, even when this block cannot fit another
attempt. Each successful retention transfer MUST atomically commit its marker,
FIFO-position advance and fairness preference. A failed fairness write MUST
roll back that transfer; an observation alone does not publish progress.
The height-selected fault classifier and
fair retention transition preserve these boundaries.
A deterministic bad item where the in-scope path permits item isolation MUST roll back incomplete
effects and retain its original obligation/evidence in place, with an
observation identifying the item/domain. Quarantine is not service completion,
terminal settlement or permission to drop a liability. Isolate/rotate an item
so healthy unrelated entries/domains can progress. A damaged shared clock,
cursor or queue metadata stalls only its affected domain/queue; do not infer
missing economic state. Typed actor-pause/key-count/byte-quota deferrals keep
their existing identities.
“Bounded” constrains per-turn work and storage, not time until repair:
- Use the existing
JOB_LIFECYCLE_BUCKETS_PER_DOMAIN_TURNlimit (baseline 3),JOB_LIFECYCLE_MAX_ENTRIESper bucket (1,024) and at most one attempt per selected entry in a turn. Retain the 64 KiB row ceiling; never move all damaged items into one growing row. - Prepay the selected item’s existing maximum before reads/work, including the gated session-reconcile maximum. Retain the lifecycle control/maintenance reserves and aggregate BlockStart budget; charged failed work is not refunded or retried in a tight loop. Ordinary item/retry allowances remain separately bounded (baseline 230/672 structural units).
- Retain each obligation once in its admitted storage; a repeated observation cannot append duplicate quarantine liabilities. A shared-metadata stall produces at most one bounded observation for that domain/turn. Do not allocate an unbounded side list or rescan all jobs to recover.
runner.lifecycle.quarantined or
runner.lifecycle.financial_stalled topics under J2; existing FeeRecord
observations are not retroactively re-encoded as events.
Across all these execution paths, a nondeterministic OS/PVM/infrastructure
fault MUST stop the node before a receipt is built. Never commit a
quarantine/success result for supervisor wall-clock expiry, worker death,
failed fork/reap, transport failure or an ambiguous store error. Only a
protocol-meter refusal attributable to this item’s own allowance is Data;
an aggregate-meter accounting disagreement still fails closed. Below J2
preserve existing classifications, bytes and observations exactly. Inject
deterministic faults and infrastructure faults separately and prove bounded
healthy-item progress versus absence of a receipt, respectively.
Conformance MUST also prove a persisted preference for the other queue after
a shared-metadata stall that exhausts the turn, atomic marker/frontier/preference
publication on retention, and rollback of the transfer when its fairness write
fails.
Existing anchors at core 734db73a7c712d0efa2d0fa16f17ca891d5a5879:
cycle limits,
LANE_*_CYCLES and the MAX_RESUME_CYCLES assertion;
historical budget validator,
callback.resume_budget.cycles;
route lane fitting;
Zygote supervisor,
ServeError and reap handling; and
lifecycle service,
data_fault, classify_item_result, dispose_entry_data_fault and
process_job_lifecycle_bounded;
BlockStart sequencing,
run_block_start_hooks and advance_epoch_sweep;
session scheduler,
process_session_reconciliation_after_lifecycle; and
native string operations,
replace, with
bytes operations,
replace / split, which motivate J1’s byte-based pricing.
Existing lifecycle data quarantine and
infrastructure propagation supply the baseline; J2 does not turn every
error into data.