Broadcast Contract Readback / 播出合约回读机制

Broadcast Contract Readback is the mechanism that makes later routes consume the scoped state created by 播出档期合约机制.

The original contract mechanism asks whether a slot may be bound, narrowed, split, transferred, escrowed, cancelled, folded, or breached. Readback asks the next question: when another desk later wants to reuse that result, does the old reader scope still match the new reader?

Design promise

A passed slot contract is not a universal license. Every later reuse must either:

1. read the prior contract row and stay inside its scope;
2. add a reader-specific boundary, addendum, or proof bridge;
3. split readers and preserve contradiction;
4. rehear proof because the anchor does not travel;
5. unwind claimant or sponsor capture;
6. escrow, block, or convert to recovery-only;
7. default into durable scope-readback failure.

Entry rule

Open this mechanism only from state pressure:

entry_requires_all:
  prior_contract_row_or_explicit_absence_present: true
  prior_resolution_state_present: true
  current_reuse_request_present: true
  current_reader_present: true
  scope_delta_present: true
  future_route_or_reader_effect_possible: true
  no_fixed_turn_trigger: true
  no_fixed_day_or_week_trigger: true
  no_raw_count_trigger: true
  no_dashboard_or_lens_health_trigger: true

Valid pressure sources include public recap reuse, lawful archive filing, sponsor package release, correction-slot citation, route asset bridge, memorial replay, edit checksum citation, emergency patch, black-screen reopening, or broadcast-reality acceptance check.

State schema

broadcast_contract_readback_state:
  prior_contract_row: <slot contract id or explicit_absence>
  prior_resolution_state: bound_with_scope | narrowed_reader | split_rights | transferred | sponsor_sold | escrowed | cancelled_with_scar | breached | black_screen_fold | recovery_only | equivalent
  original_bound_reader: <reader or explicit_absence>
  original_excluded_or_harmed_reader: <reader or explicit_absence>
  original_proof_or_custody_anchor: <anchor or explicit_absence>
  current_reuse_request: <reuse>
  current_reader: <reader>
  scope_delta: inside_scope | narrower_than_scope | reader_mismatch | proof_mismatch | excluded_reader_returns | transferred_claimant_uses | escrow_spent_early | breached_row_reused | blackout_fold_reopened | recovery_only_attempt | equivalent
  readback_state: pending | accepted_inside_scope | accepted_with_addendum | split_required | proof_rehearing_required | claimant_unwind_required | escrow_required | blocked | default_armed | equivalent
  future_route_effect: accepted_with_scope | costlier | split_canon | contradiction_pending | sponsor_only | lawful_only | public_only | blocked | hostile | recovery_only | equivalent

Observed surfaces

The mechanism is observed through:

• 播出合约回读案卷;
• 播出合约回读审计;
• 范围回读默认.

Branch families

Branch	When used	Relief	Cost	Future effect
Read inside scope	current reader/use matches old scope	route remains legible	boundary remains visible	accepted with scope
Add boundary and reuse	nearby reader can accept with addendum	route unblocks	archive, sponsor, public, or lawful cost	costlier / reader-limited
Split readers	old and new readers conflict	both readers remain playable	contradiction and handler burden	split-canon / contradiction-pending
Rehear proof	anchor does not travel	false proof blocked	delay and proof debt	blocked until proof / recovery-only until hearing
Unwind claimant capture	transferred or sponsor-sold row blocks reuse	capture becomes explicit	debt, resentment, sponsor heat	captured / sponsor-only / recovery-only
Escrow, block, recover	row is escrowed, breached, folded, or recovery-only	unsafe reuse blocked	delay, black-screen, future recovery cost	blocked / hostile / recovery-only
Default	player spends mismatch as clean	no valid relief	hostile memory and drift	captured / contradiction-pending / recovery-only

Required cost rule

Any successful readback must leave one finite cost or boundary:

• boundary note;
• lawful addendum;
• public footnote;
• sponsor release record;
• proof rehearing;
• split reader term;
• claimant unwind debt;
• route delay;
• recovery hook;
• blackout scar.

Failure states

Implementation fails this mechanism if:

• a bound contract is later treated as clean universal authority;
• public-only proof becomes lawful proof without addendum;
• sponsor-only slot becomes public memory without capture or release;
• split rights become one cleaned route;
• escrowed authority is spent early;
• black-screen fold reopens without audience scar;
• recovery-only row clears a route without recovery;
• proof/custody anchor silently travels to a new reader;
• excluded reader disappears from later reuse;
• entry uses fixed turn count, day/week interval, raw content count, dashboard state, or lens health.

Replay evidence shape

mechanic_id: storyteller.mechanic.broadcast_contract_readback.v1
session_id: lens-broadcast-contract-readback-v1-<timestamp>
seed: <deterministic-seed>
entry_state:
  trigger_kind: state_pressure
  prior_contract_row_or_explicit_absence_present: true
  prior_resolution_state_present: true
  current_reuse_request_present: true
  current_reader_present: true
  scope_delta_present: true
  no_fixed_turn_trigger: true
active_objects:
  docket: storyteller.card.broadcast_contract_readback_docket.v1
  rite: storyteller.rite.broadcast_contract_readback_audit.v1
branch_result:
  selected_response: read_inside_scope | add_boundary_and_reuse | split_readers | rehear_proof | unwind_claimant_capture | escrow_block_or_recover | default
  readback_state_after: <state>
  future_route_effect: <effect>
  counter_deltas:
    relief: []
    cost: []
    future: []
assertions:
  - later_reader_consumes_prior_contract_state
  - scope_delta_is_visible
  - excluded_reader_persists
  - proof_anchor_does_not_travel_silently
  - branch_outcomes_diverge
  - success_has_cost
  - default_is_durable

Non-goals

• Not a report-generation rule.
• Not a governance check.
• Not a timer.
• Not a new universal license.
• Not a replacement for broadcast-slot binding; it is the follow-on readback surface that prevents shallow green contract evidence.