Skip to main content
Status: Draft for Internal Review
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.
This specification defines the verifiable, asynchronous off-chain compute framework: Fisher-Yates VRF runner selection, adaptive committee sizing, stake · sqrt(reputation) VRF weighting with EMA reputation (14-day half-life), commit-reveal aggregation with eligibility-threshold aggregator selection, non-reveal classification with CrashAttestation exemption, the JobType::Custom extension pattern, agent-job validation (per-job loop-budget caps and path-traversal rejection, §3.1), an explicit slash-distribution schema (defaulting to 100% burn per WP §8.4 C7), SemanticSimilarity embedding-model pinning, and Entitlement-based Runner Pool access control.

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:
  1. Run Python-based AI model inferences or heavy computations off-chain.
  2. Use an asynchronous, deferred transaction model to prevent network congestion from off-chain interactions.
  3. Use a stake-weighted VRF-based system to eliminate centralized schedulers and allow anyone to verify task assignments.
  4. Require task and result schemas to reduce ambiguity and ensure Runners can reliably execute and be verified.
  5. 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:
0x0006 is allocated to DUAL_BASEFEE (CIP-3). The post-2026-04 address space extends through 0x13 and includes a virtual entry at 0x1D; 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 a result_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).
For an 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 a JobSpec: 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 submitted JobSpec 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 to M_max (§5.1); for None/EconomicBond it 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 from MAX_RETRIES (default 3) in §6.3 (Timeout-based re-selection), which counts runner-selection retry rounds before a job is marked Failed. 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 is 0x0000...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):
  1. The runner has HealthStatus::Healthy, with a heartbeat received within heartbeat_timeout_blocks.
  2. The runner has reputation ≥ 50, using the EMA-updated reputation defined in §6.1.
  3. The runner supports the required JobType and, for Llm/Agent jobs, the requested model (see Model advertisement below)
  4. If tee_required, the runner must declare TEE support (attestation verified by TEE Verifier 0x05). Interim: while the binding gate is dormant, selection falls back to the runner’s declared tee_support when no measurement binding exists; an existing binding’s status, expiry and TEE type are checked.
  5. The estimated cost is ≤ job_spec.max_price.
  6. The runner has active_jobs < max_concurrent_jobs before D, or for a runner with no class fields; D slot classes apply after its height to a runner advertising them.
  7. For the optional Entitlement filter, if required_runner_pool = Some(pool_id), the Entitlement Registry (0x07) must confirm that the runner holds an Entitlement with Scope::RunnerPool(pool_id) and Action::RunnerJoinPool(pool_id) that is direct (parent_id = None), has not expired, and has not exceeded its max_uses (see §7.3). When the pool filter leaves fewer eligible Runners than the job needs, selection fails with InsufficientRunners (1607).
Model advertisement uses a runner’s capabilities, which carry 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 at RUNNER_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 population N_active and the Herfindahl-Hirschman Index HHI of effective stake:
Parameters (Tier-0 tunable, stored at 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 verified commonware 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 block S (no added latency), using the parent beacon R_{S-1} (notation below), known before executing S. Immediate mode trades proposer-inclusion neutrality for zero added latency (see Security Considerations).
  • M > 1: commit-then-reveal. JobSubmit binds the job in block S; the committee is selected later from the verified seed of the absolute future round r_seed = advance_round(r_submit, K), where r_submit = Round(epoch, view) is the round in which block S was proposed and K = SELECTION_SEED_DELAY_VIEWS (value set in CIP-11 §13). commonware produces 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-roll r_seed.
For a block 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):
For 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)
Parameters: 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^1 rewards 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.
Fisher-Yates Shuffle:
Properties:
  • 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 + same candidates always produces the same result (determinism)
  • Any node can independently verify the selection (verifiability)
On-chain verification (in Result Verifier and Job Dispatcher):
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
Score function (Tier-0 tunable): 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 integer ema_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:
Here 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 against submitted_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.
A runner that legitimately crashes between commit and reveal self-attests via the SubmitCrashAttestation system instruction (opcode 97). There is no free-standing signed CrashAttestation struct on the wire. The instruction carries only:
The runner identity is 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).
For an HTTP committee job with three runners, threshold two, a 30-block timeout and a 60-block reveal window, a runner that commits at block 1 is still in-window when its assignment closes at block 30 (its reveal deadline is 61). The M=1 EconomicBond 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:
  1. Selected runners have timeout_blocks to submit their result commitment.
  2. 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
  3. After MAX_RETRIES (default: 3) consecutive failures, the job transitions to Failed and the persistent non-responders receive an additional reputation hit
  4. After SLASH_THRESHOLD consecutive slashes, a stake slash is triggered per §11
A runner that does not execute the job times out and loses reputation via the §6.1 EMA. Runners are incentivized to either execute or proactively avoid accepting jobs they cannot execute (by not heartbeating for job types they lack). There is no 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.
  1. A job that fails on a terminal path carries one of four reasons:
    • retries_exhausted: the job was re-selected MAX_RETRIES times (§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 Pending job 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.
    • pending_key_delivery_timeout: a PendingKeyDelivery job reached its expiry.
    • private_attachment_timeout: an assigned job whose runner held private issued attachments timed out. It can’t be retried (§6.2).
    The escrow is refunded as before.
  2. Failure delivery applies to a job whose callback.handler is non-empty and that is not a route invocation. A callback is always self-addressed: callback.actor is the submitter.
  3. The callback receives the chain’s JobFailure under a top-level failure key of the callback payload, in place of result (continuation shape) or data (legacy shape). The body has exactly the keys:
    • kind: "failure";
    • v: 1;
    • job_id: 0x and 64 lowercase hex digits;
    • reason;
    • attempts: the job’s retry count.
    A runner’s result only ever appears under result or data, so a failure at a callback is always chain-authored. A runner result shaped like a JobFailure is an ordinary result.
  4. In the same state transition as the Failed status and the refund, the Job Dispatcher MUST append (job_id, reason, attempts) to a FIFO queue of at most JOB_FAILURE_DELIVERY_MAX_QUEUE (4,096) rows.
  5. 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_BLOCKS service 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.
  6. 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.
  7. 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.
    The job keeps its refund, and the node logs the drop.
  8. While the Council has paused the Job Dispatcher, the queue MUST be neither drained nor modified.
  9. Actor view (cowboy_sdk).
    • An await inside a try that catches the failure raises JobFailed(reason, job_id, attempts) (E1621). For a generated off-chain proxy it raises OffchainError("unavailable: <reason>").
      • The try must name the error its await raises: OffchainError around a generated off-chain proxy (a module-level function the off-chain build exports), and JobFailed around any other await, imported at module level from cowboy_sdk and not rebound. A tuple of both is accepted. A try that names only the other error is refused at compile time.
      • Only a generated proxy’s result decoder sees the failure. Any other callee raises JobFailed without calling its decoder.
    • 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.continuation method, 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.

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:
Each Entitlement record covers one (Scope, Action) pair. Granting multiple actions requires multiple Grant calls. This keeps revocation granular: revoking one action does not affect others.
A direct grant (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)
Wire tags 33–35, formerly 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 by pool_id: Vec<u8>. Membership is represented as an Entitlement:
Grant flow:
A pool id names its owner, so no account can grant membership in another’s pool. An id beginning with 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):
The check passes if at least one non-expired, non-exhausted, direct (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
  1. If the Entitlement Registry Actor does not exist, all checks return false (no runner is admitted via pool filter). Jobs with required_runner_pool = None are unaffected.
  2. Token owner == caller checks remain the first-priority gate; Entitlement provides an additional delegation path, not a replacement.
  3. 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.
Participants:
  • All M selected runners execute the job independently.
  • The aggregator is selected from the committee per §8.1 and coordinates submission.
Submission flow:
Safety properties:
  • 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 distinct aggregator_timeout_blocks constant in code. AggregatorConfig carries only {eligibility_percentile, bonus_bps}; the fallback is gated by the per-job timeout_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:
The election considers only runners with a stored submission, so a runner that committed but never revealed never enters the pool. The 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
Paid from the runner share (89% of gross under WP §8.4), i.e. the bonus does not change the burn / treasury split. Conceptually: 89% runner share splits into (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:
The 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:
The value is a model identifier resolvable via the existing model registry (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_model is changed by UpdateSemanticSimilarityModel, 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.
SemanticSimilarity verification MUST use the canonical embedding model defined above; an undefined or unresolvable model is not a valid settlement input. Missing or malformed embeddings, including zero or non-finite squared norms, and self-reported model mismatches are operational failures: reputation penalty, no payment or ancillary reward, unchanged stake. A self-report is not TEE proof of wrong-model execution. Valid embeddings outside the winning threshold cluster remain quorum dissent and are slashed.

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:
  1. Build the verifier as a deterministic executor binary using Rust with a reproducible build.
  2. Hash the binary with BLAKE3.
  3. Pin the hash via governance: write a record at GOVERNANCE_SYSTEM_ACTOR=0x09 keyed system:executor_registry:<name>.
  4. Issue jobs as JobType::Custom { executor_hash: PINNED_HASH, params: <serialized job-specific params> }.
  5. Runners that have whitelisted the executor execute the job. Verification proceeds via the standard VerifierCheck chain using the supported checks in §9.1.
This avoids fragmenting 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 recorded Slashable 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.
Stored at 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 as max(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 adjust MIN_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.
Decision Register item #4 status: HOLD on CBY-denominated. Re-evaluation triggers: (a) availability of a battle-tested oracle module (e.g., a CIP-31-style oracle parameter spec), or (b) sustained USD floor drift outside the target band beyond what Tier-0 cadence can address.

13. Randomness Source

The selection seed IKM is the commonware 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.125 damps 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 = 50 default 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), whether r^0.5 or r^0.4 better 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=5 committee 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_max bound 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. For M > 1 the commit-then-reveal path closes proposer selection bias; M == 1 retains the bounded inclusion-timing residual described in Security Considerations.
  • Timeout re-selection avoids skip_task because skip_task creates 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 JobType discriminant for every new built-in verifier fragments the type space. The existing JobType::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 UpdateSemanticSimilarityModel payload; 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 claims 0x01 (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_at or 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 for M > 1 committees: 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. For M == 1, two residuals remain: the submitter may know the parent beacon before submitting, and the proposer of the including block, who sees the pending JobSubmit and 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 dispatches M > 1 whenever N_active permits; §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_callbacks counter 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. EntitlementGrant consumes 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_until set 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

At EXECUTION_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.
For dict and set operations, J1m preserves the base lookup/writer behavior, callback results and table layout while adding charges (dict/set metering scope). Dict/set reentrancy safety is a separate fix; J1m does not repair those base faults (reentrancy scope). Cheap argument validation, including type, sign, range and overflow checks, MUST precede prepayment so existing exception types and messages are preserved. Length hints MUST NOT determine a prepayment: charge as items are produced, and retain identity fast paths. An operation that cannot prepay its bound deterministically exhausts Cycles before doing that work. A failed charge MUST always propagate; a native exception handler MUST NOT swallow it and continue the operation. Every newly priced builtin MUST have an explicit deterministic work formula and before/at/after vectors for the sized-builtin gate. Below that gate, preserve all old charges, observations and work byte for byte; do not build the regex meter or count code points for it. Implement gated pricing in native VM code, never by editing the frozen SDK. New metering observations are themselves height-gated. The cycle-limit values are final only together with this pricing and its worst-case string/bytes benchmarks. The block-time invariant is that a worst-case frame consuming an entire permitted lane on the slowest supported validator finishes well inside both the Zygote reap deadline and the proposal budget. Bench signed transactions, resumes, timers and event fires separately; a transaction-only admission check cannot bound the other three. For every such frame:
Both headrooms MUST be positive and reported with the benchmark’s workloads, hardware and measured times. A values-only calibration MUST keep both 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

At RUNNER_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_TURN limit (baseline 3), JOB_LIFECYCLE_MAX_ENTRIES per 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.
A persistently corrupt item may remain quarantined indefinitely until an explicit repair; this does not promise a finite financial-drain time. The existing cursor/rotation state is durable. Added receipt events, if any, use only the allocated 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.