Availability Reader Collision / 可用性读者冲突机制

Availability Reader Collision is the mechanism that prevents a scarred availability state from being reused as clean access by every future reader.

It sits downstream of encounter routing and schedule preemption. Those systems decide whether a target, slot, route asset, public surface, or explicit absence is available. This mechanism decides how that availability is read later by incompatible consumers: public, lawful, sponsor, editor, ward, floor, fan delegate, archive, route asset, producer license, or pirate relay.

Design purpose

Storyteller has already made availability nuanced. The new failure surface is reuse:

• lawful_only is not public testimony;
• public_only is not lawful custody;
• sponsor_only is not neutral access;
• private_only is not public proof;
• relay_only is not admissible chain of custody;
• delayed_with_receipt is not free availability;
• substitute_only is not original recruitment;
• ward_held and floor_locked are not empty flavor tags.

This mechanism makes every incompatible reader visible before the state reaches a future route.

Object model

availability_reader_collision:
  source_availability_row_id: <stable id>
  source_system: encounter_availability | schedule_preemption | live_floor_load | recovery_ward | fan_delegate | facility_lockdown | route_asset | equivalent
  source_availability_state: <availability state>
  source_history_preserved: true
  target_or_slot: <character npc role slot route asset or explicit_absence>
  readers_min: 2
  readers:
    - reader_id: <stable id>
      reader_type: public | lawful | sponsor | editor | ward | floor | fan_delegate | archive | route_asset | producer_license | pirate_relay | equivalent
      demand: <what the reader wants>
      minimum_acceptance_surface: <surface>
      if_excluded: <state>
  incompatibility: <kind>
  selected_recognition_surface: <surface or unresolved>
  future_route_effect: <effect>

Entry contract

The mechanism opens only from live state pressure:

entry_state:
  trigger_kind: state_pressure
  source_availability_row_present: true
  source_availability_state_present: true
  source_history_preserved: true
  future_readers_min: 2
  incompatible_access_demands: true
  one_reader_controls_route_or_encounter_progress: true
  player_can_scope_or_record_default: true
  no_fixed_turn_trigger: true
  no_fixed_day_or_week_trigger: true
  no_raw_count_trigger: true

Invalid entries:

• fixed turn number;
• day/week interval;
• chapter quota;
• raw content count;
• raw character count;
• dashboard or lens health;
• generic relationship availability.

Reader types

Reader type	Reads availability as	Typical false reuse
public	legitimacy, visible receipt, audience reality	lawful/private access reused as public proof
lawful	admissibility, custody, inspector trace	public/relay access reused as lawful chain
sponsor	slot relief, risk transfer, stop-loss	captured access reused as neutral access
editor	continuity, cutroom custody, source masking	edited access reused as original proof
ward	body protection, discharge boundary	floor/sponsor reader moves protected body
floor	call sheet, crew load, live stability	encounter reader ignores floor lock
fan_delegate	scoped public mandate	private or sponsor route reused as fan consent
archive	provenance and preserved source	relay or public-only proof reused as archive custody
route_asset	unlock, custody, sacrifice state	substitute route reused as original route asset
producer_license	authority and liability	sponsor or public win reused as producer-safe permission

Branch families

The mechanism must support at least six branch families, with one default branch:

1. recognize_public_surface;
2. recognize_lawful_surface;
3. recognize_sponsor_surface;
4. split_reader_table;
5. quarantine_availability;
6. accept_substitute_reader;
7. default_capture.

Each branch must preserve the source history while changing reader states.

Counter contract

Every branch must mutate:

• at least one relief surface;
• at least one cost surface;
• at least one future reader or route effect.

Valid surfaces include:

• availability_reader_collision
• encounter_availability
• schedule_preemption_pressure
• slot_scope
• lawful_access_integrity
• public_receipt_legitimacy
• public_receipt_distrust
• sponsor_stop_loss_pressure
• contract_capture
• source_ambiguity
• proof_chain_integrity
• inspection_heat
• fan_mandate_fracture
• ward_custody_integrity
• crew_load
• blackout_risk
• relay_custody_risk
• route_asset_pressure
• future_route_acceptance
• missed_encounter_pressure
• future_recovery_cost

Default rule

If a source availability state is consumed without a reader table, 可用性读者冲突默认 must fire or arm.

Default capture must name:

• source row;
• source state;
• capturing reader;
• excluded or harmed reader;
• false reuse kind;
• route effect;
• recovery hook.

Integration with existing systems

• 遇见可用性分流机制 creates source availability rows for named targets.
• 档期抢占认领机制 creates selected and displaced availability states around finite slots.
• 直播现场班组负荷机制 creates floor-locked and overrun states.
• 复原病房出院压迫机制 creates ward-held and recovery-only states.
• 粉丝委任分裂机制 creates public mandate readers that cannot be replaced by private or sponsor access.
• 裁定读者冲突 remains the equivalent downstream reader mechanism for rulings, receipts, and legal source rows. This mechanism handles availability state, not verdict reuse.

Replay evidence shape

mechanic_id: storyteller.mechanic.availability_reader_collision.v1
session_id: lens-availability-reader-collision-v1-<timestamp>
seed: <deterministic seed>
entry_state:
  trigger_kind: state_pressure
  source_availability_row_present: true
  source_availability_state_present: true
  source_history_preserved: true
  readers_min: 2
  incompatible_access_demands: true
  no_fixed_turn_trigger: true
offered:
  card: storyteller.card.availability_reader_collision_docket.v1
  rite: storyteller.rite.availability_reader_collision_hearing.v1
branch_runs:
  resolved_branch:
    selected_branch: recognize_public_surface | recognize_lawful_surface | recognize_sponsor_surface | split_reader_table | quarantine_availability | accept_substitute_reader
    primary_reader: <reader>
    scoped_or_excluded_reader: <reader>
    reader_states_after: []
    future_route_effect: <effect>
    counter_deltas:
      relief: []
      cost: []
      future: []
  default_branch:
    selected_branch: default_capture
    event_seen_or_armed: storyteller.event.availability_reader_collision_default.v1
    capturing_reader: <reader>
    excluded_or_harmed_reader: <reader>
    future_route_effect: <effect>
assertions:
  - entry_is_state_triggered
  - source_availability_history_preserved
  - multiple_readers_visible
  - incompatible_access_demands_visible
  - reader_states_diverge
  - no_universal_availability_key
  - default_has_named_capturing_and_excluded_reader
  - future_reader_consumes_result
  - no_fixed_turn_trigger

Non-goals

• Not an encounter generator.
• Not a schedule calendar.
• Not a ruling reader collision duplicate.
• Not a relationship meter.
• Not bulk content expansion.
• Not valid unless a scarred availability state becomes reader-specific and future routes read the scope.