Storyteller Wiki

Stale Dispatch Recall Lens / 过期派发召回 Lens

11 min read

Stale Dispatch Recall Lens / 过期派发召回 Lens

This lens observes whether 过期派发召回线 and 过期派发召回机制 prevent changed truth from magically rewriting old local instructions.

A passing implementation proves that when a boundary, ruling, redaction, availability state, rehearsal decision, custody order, or route asset handoff changes, any old instruction already in circulation remains visible until recalled, acknowledged, executed, or explicitly absent.

The lens fails if updated truth silently reaches every recipient for free.

This lens observes:

It is observed through:

Observable promise

When the correct state changes after an old instruction is already queued, Storyteller must answer:

What changed, what old instruction still exists, who can execute it, who will read the wrong execution, how can the player recall it, what proves acknowledgement, who remains stale, and what happens if the old instruction acts first?

Gap this lens targets

Existing green surfaces cover adjacent pressure but not this exact failure mode:

This lens checks whether already-issued local instructions can still execute after those systems changed the world.

Must pass

1. Entry is state-triggered by changed source plus actionable old instruction

Required evidence:

entry_state:
  trigger_kind: state_pressure
  source_decision_or_boundary_changed: true
  source_history_preserved: true
  stale_instruction_issued_under_old_state: true
  stale_instruction_still_actionable: true
  holder_or_recipient_present_or_explicit_absence: true
  future_reader_or_route_can_be_affected: true
  player_can_recall_or_record_default: true
  no_fixed_turn_trigger: true
  no_fixed_day_or_week_trigger: true
  no_raw_count_trigger: true

Valid source changes include preair boundary correction, transcript redaction, availability collision, ruling reader scope, call-sheet reassignment, sponsor retraction, public addendum, ward order, route asset handoff, artist or witness custody boundary, or equivalent stateful change.

The lens fails if entry comes from a fixed turn number, day/week interval, chapter quota, raw content count, dashboard state, lens health, or generic maintenance phase.

2. Source history is preserved

The replay must preserve both old and new states.

source_history:
  source_decision_or_boundary: <source id>
  source_state_before: <old state>
  source_state_after: <new state>
  old_instruction_issued_under_state: <old state>
  old_instruction_not_erased: true

The lens fails if the implementation rewrites history so the stale instruction never existed.

3. Stale instruction is concrete

过期派发案卷 must record a concrete instruction.

stale_instruction:
  instruction_id: <stable id>
  instruction_kind: call_sheet | cutroom_mark | sponsor_copy | public_script | ward_order | corridor_runner_note | pirate_relay_packet | proof_handoff | route_asset_handoff | equivalent
  issued_under_state: <old state>
  now_conflicts_with_state: <new state>
  holder_or_recipient: floor_crew | editor | sponsor | inspector | archive | fan_delegate | ward | runner | pirate_relay | artist_proxy | witness_proxy | explicit_absence
  stale_action_if_executed: <wrong_move_wrong_cut_wrong_body_wrong_quote_wrong_gate_wrong_airing_or_equivalent>

The lens fails if a replay only records needs_update: true, notice_sent: true, or a generic communication counter.

4. Affected readers are visible

The docket must show at least two affected readers, or one reader plus explicit absence.

readers:
  - reader_id: <reader-a>
    wants: <acceptance demand>
    harmed_if_stale: true
  - reader_id: <reader-b-or-explicit-absence>
    wants: <acceptance demand or explicit_absence>
    harmed_if_stale: true | false

The lens fails if the stale instruction can execute without naming who reads or suffers the wrong version.

5. Acknowledgement surface is visible

The implementation must distinguish a sent recall from an acknowledged recall.

Valid acknowledgement surfaces include:

  • signed stub;
  • checksum;
  • voice acknowledgement;
  • public line;
  • docket stamp;
  • witness receipt;
  • route asset tag;
  • explicit absence.
recall_requirements:
  recall_channel: live_floor_bulletin | lawful_notice | cutroom_patch | sponsor_retraction | public_addendum | runner_relay | quarantine_order | split_recall | explicit_absence
  acknowledgement_surface: signed_stub | checksum | voice_ack | public_line | docket_stamp | witness_receipt | route_asset_tag | explicit_absence
  handler_or_absence: <handler or explicit_absence>

The lens fails if a sent message automatically counts as received.

6. Recall rite is assignable

过期派发召回 must require:

assignment:
  docket: storyteller.card.stale_dispatch_docket.v1
  source_decision_or_boundary: <source id>
  source_state_after: <state>
  stale_instruction: <instruction id>
  stale_holder_or_recipient: <recipient or explicit_absence>
  selected_recall_channel: live_floor_bulletin | lawful_notice | cutroom_patch | sponsor_retraction | public_addendum | runner_relay | quarantine_order | split_recall | accept_stale_default
  handler_or_explicit_absence: <handler or explicit_absence>
  acknowledgement_surface_or_explicit_absence: <surface or explicit_absence>
  reader_to_protect: <reader id>
  reader_left_stale_or_explicit_absence: <reader id or explicit_absence>
  accepted_cost: <cost id>
  future_reader_or_route_effect: <effect id>

Generic options such as notify everyone, fix the call sheet, tell legal, send memo, or update route asset fail unless they fill these fields.

7. Branch families diverge

At least five branch families plus a default must be playable or explicitly blocked by state:

  • live_floor_bulletin;
  • cutroom_patch;
  • lawful_notice;
  • sponsor_retraction;
  • public_addendum;
  • runner_relay;
  • split_recall;
  • quarantine_order;
  • stale_execution_default.

Each resolved branch must differ by:

branch_non_equivalence:
  recall_channel: <channel>
  acknowledgement_surface: <surface or explicit_absence>
  protected_reader: <reader>
  stale_or_scoped_reader: <reader or explicit_absence>
  cost_profile: <different cost>
  future_route_effect: <different effect>

The lens fails if all branches become clean global update or all future readers accept the same state.

8. Universal update is not free

A branch that recalls every affected reader may pass only if all are true:

universal_recall_allowed_only_if:
  all_affected_recipients_named: true
  acknowledgement_surface_for_each_required_reader: true
  cost_min: 2
  future_reader_or_route_effect_present: true
  no_clean_erase_of_old_instruction: true

The lens fails if high-rank authority, sponsor money, law, archive stamp, public popularity, or editor skill updates all recipients without acknowledgement and cost.

9. Partial recall is supported

A satisfying implementation must allow or explicitly block partial recall.

partial_recall:
  protected_reader: <reader>
  reader_left_stale_or_scoped: <reader>
  reason_not_global: <cost impossibility contradiction or explicit_absence>
  future_effect: split_acceptance | costlier | blocked | public_addendum_required | lawful_bridge_required | recovery_only

The lens fails if the only non-default success is a clean global recall.

10. Stale execution default is durable

过期派发执行 must fire or be armed when recall is hidden, underfilled, unacknowledged, falsely acknowledged, intentionally skipped, or executed first.

Required event evidence:

stale_execution_event:
  event: storyteller.event.stale_dispatch_execution.v1
  source_decision_or_boundary: <source id>
  source_state_after: <state>
  instruction_id: <id>
  instruction_kind: <kind>
  executed_by: <holder or recipient>
  capturing_reader: <reader>
  harmed_reader_or_claimant: <reader claimant or explicit_absence>
  execution_kind: wrong_body_moved | wrong_cut_aired | wrong_quote_filed | wrong_gate_opened | wrong_proof_delivered | wrong_public_promise | wrong_route_asset_handoff | equivalent
  state_after: stale_executed | false_execution | captured_by_old_instruction | route_asset_misdelivered | recovered_with_scar | recovery_only
  future_route_effect: blocked | captured | costlier | public_addendum_required | lawful_bridge_required | checksum_required | quarantine_required | recovery_only

The lens fails if stale execution is only narration, generic reputation loss, or generic money damage.

11. Recovery keeps a scar

If stale execution is repaired, the route cannot return to a clean unmarked state.

Accepted scars:

  • public addendum required;
  • lawful bridge required;
  • checksum required;
  • route asset narrowed;
  • stale holder becomes hostile, exposed, absent, or expensive;
  • future recall requires stronger acknowledgement;
  • recovery-only label persists;
  • schedule, proof, handler, runner, crew, or edit load remains consumed.

12. Future reader consumes the result

At least one future route, rite, public statement, proof test, lawful hold, broadcast slot, recovery ward, cutroom action, or route asset must accept, reject, narrow, surcharge, or block based on the recall or stale execution state.

future_acceptance_check:
  future_reader: <reader id>
  state_before: recall_open | partially_acknowledged | recalled | stale_executed | recovered_with_scar
  state_after: <state>
  accepted_states: []
  rejected_or_costlier_states: []
  future_route_effect: <effect>

The lens fails if only counters move and future offers remain identical.

Branch assertions

Live-floor bulletin assertion

selected_branch: live_floor_bulletin
relief_any: [false_execution_blocked, wrong_body_moved_blocked, wrong_gate_opened_blocked, custody_clarity_up]
cost_any: [crew_load_up, schedule_pressure_up, public_confusion_up, handler_burden_up]
future_effect_any: [accepts_with_floor_acknowledgement, route_blocked_until_floor_ack, route_narrowed]

Cutroom patch assertion

selected_branch: cutroom_patch
relief_any: [final_air_integrity_up, stale_cut_rejected, continuity_hazard_down]
cost_any: [edit_debt_up, source_ambiguity_up, proof_burden_up]
future_effect_any: [checksum_required, stale_cut_costlier, raw_proof_bridge_required]

Lawful notice assertion

selected_branch: lawful_notice
relief_any: [custody_clarity_up, lawful_acceptance_up, proof_chain_integrity_up]
cost_any: [inspection_heat_up, bureau_favor_debt_up, public_delay_up, public_confusion_up]
future_effect_any: [lawful_bridge_required, public_addendum_required, lawful_only_until_acknowledged]
selected_branch: sponsor_retraction
relief_any: [false_public_promise_blocked, sponsor_copy_scoped, private_capture_down]
cost_any: [sponsor_stop_loss_pressure_up, contract_capture_up, public_receipt_distrust_up, sponsor_retaliation_up]
future_effect_any: [sponsor_only_scar, public_route_costlier, public_correction_required]

Public addendum assertion

selected_branch: public_addendum
relief_any: [public_receipt_legitimacy_up, public_confusion_down, private_capture_blocked]
cost_any: [public_panic_up, witness_exposure_up, sponsor_stop_loss_pressure_up, inspection_heat_up]
future_effect_any: [public_addendum_required, lawful_bridge_required, future_public_reader_accepts_with_scar]

Runner relay assertion

selected_branch: runner_relay
relief_any: [route_asset_misdelivery_blocked, stale_note_recovered, custody_clarity_up]
cost_any: [runner_risk_up, payroll_leak_up, favor_debt_up, custody_noise_up]
future_effect_any: [route_asset_tag_required, runner_hostility_armed, substitute_required]

Split recall assertion

selected_branch: split_recall
relief_any: [selected_reader_can_proceed, contradiction_pressure_down, false_execution_partly_blocked]
cost_any: [source_ambiguity_up, handler_burden_up, correction_pressure_up, future_recovery_cost_up]
future_effect_any: [split_acceptance, scoped_reader_table, costlier_or_blocked_secondary_reader]

Quarantine assertion

selected_branch: quarantine_order
relief_any: [false_execution_blocked, breach_risk_down, route_asset_misdelivery_blocked]
cost_any: [route_delay_up, missed_encounter_pressure_up, sponsor_stop_loss_pressure_up, schedule_pressure_up]
future_effect_any: [blocked_until_recall, recovery_only_if_unresolved, substitute_required]

Default assertion

selected_branch: stale_execution_default
event_seen_or_armed: storyteller.event.stale_dispatch_execution.v1
relief_any: [immediate_assignment_burden_down]
cost_any: [false_execution_up, harmed_reader_hostility_up, public_confusion_up, inspection_heat_up, route_asset_pressure_up]
future_effect_any: [captured_by_old_instruction, route_blocked_until_recall, route_costlier, recovery_only]

Oracle assertions

A binding check should fail unless all assertions below are true.

  1. Primary links exist — observes and observed_through point to concrete Storyteller pages.
  2. Entry is state-triggered — the surface opens from changed source state plus actionable old instruction, not from fixed sequence position.
  3. Source history is preserved — old state, new state, and issued-under state are all visible.
  4. Stale instruction exists — the old instruction has id, kind, holder, conflict, and stale action.
  5. Readers are visible — at least two affected readers or one reader plus explicit absence are named.
  6. Acknowledgement matters — sent recall is not received recall unless an acknowledgement surface or explicit absence is recorded.
  7. Assignment slots exist — the rite requires docket, source, stale instruction, holder, channel, handler, acknowledgement, protected reader, stale/scoped reader, cost, and future effect.
  8. Branches diverge — at least five recall branch families plus default produce different channel, acknowledgement, cost, and future effect.
  9. No free universal update — global recall requires named recipients, acknowledgement for each required reader, cost, and preservation of old instruction history.
  10. Partial recall exists or is explicitly blocked — one reader can proceed while another is stale, scoped, delayed, or recorded as explicit absence.
  11. Default is durable — unacknowledged or hidden stale instruction produces executor, capturing reader, harmed reader, execution kind, and future consequence.
  12. Recovery keeps scar — repair leaves addendum, bridge, checksum, narrowed route asset, hostile/exposed holder, stronger future recall, recovery-only tag, or consumed load.
  13. Future reader consumes result — later route acceptance changes based on acknowledgement or stale execution state.
  14. Replay provenance exists — evidence includes session id, seed, entry state, source history, stale instruction, offered choices, assignments, branch results, event/default if any, counter deltas, future acceptance check, and no fixed trigger flags.

Progress metric

staleDispatchRecallProgress = 0..8:

  • 0: no changed source plus stale instruction provenance.
  • 1: source old/new state and issued-under old instruction are visible.
  • 2: 过期派发案卷 or equivalent records holder, stale action, readers, acknowledgement requirement, and default.
  • 3: 过期派发召回 or equivalent offers assignment slots.
  • 4: one recall branch produces relief, cost, and future reader/route effect.
  • 5: partial recall or split recognition is visible.
  • 6: at least three recall branch families produce non-equivalent acknowledgement states, costs, and future effects.
  • 7: 过期派发执行 or equivalent fires/arms on unacknowledged, hidden, or executed stale instruction.
  • 8: at least five branch families plus one default are proven with replay/session evidence, including future reader consumption and recovery scar.

Evidence shape

lens_id: storyteller.lens.stale_dispatch_recall.v1
result: pass | fail
session_id: lens-stale-dispatch-recall-v1-<timestamp>
seed: <deterministic-seed>
entry_state:
  trigger_kind: state_pressure
  source_decision_or_boundary_changed: true
  source_history_preserved: true
  stale_instruction_issued_under_old_state: true
  stale_instruction_still_actionable: true
  holder_or_recipient_present_or_explicit_absence: true
  future_reader_or_route_can_be_affected: true
  no_fixed_turn_trigger: true
  no_fixed_day_or_week_trigger: true
source_history:
  source_decision_or_boundary: <id>
  source_state_before: <state>
  source_state_after: <state>
  old_instruction_issued_under_state: <old state>
  old_instruction_not_erased: true
offered:
  card: storyteller.card.stale_dispatch_docket.v1
  rite: storyteller.rite.stale_dispatch_recall.v1
docket:
  instruction_id: <id>
  instruction_kind: <kind>
  holder_or_recipient: <holder or explicit_absence>
  stale_action_if_executed: <action>
  readers:
    - reader_id: <reader-a>
      harmed_if_stale: true
    - reader_id: <reader-b-or-explicit-absence>
      harmed_if_stale: true | false
  recall_channel: <channel>
  acknowledgement_surface: <surface or explicit_absence>
branch_runs:
  recall_branch:
    selected_recall_channel: live_floor_bulletin | lawful_notice | cutroom_patch | sponsor_retraction | public_addendum | runner_relay | split_recall | quarantine_order
    handler_or_explicit_absence: <handler or explicit_absence>
    acknowledgement_surface_or_explicit_absence: <surface or explicit_absence>
    reader_to_protect: <reader>
    reader_left_stale_or_explicit_absence: <reader or explicit_absence>
    state_after: recalled | partially_acknowledged | split_recall | quarantined | recovered_with_scar
    future_route_effect: <effect>
    counter_deltas:
      relief: []
      cost: []
      future: []
  stale_default:
    event_seen_or_armed: storyteller.event.stale_dispatch_execution.v1
    executed_by: <holder>
    capturing_reader: <reader>
    harmed_reader_or_claimant: <reader or claimant>
    execution_kind: wrong_body_moved | wrong_cut_aired | wrong_quote_filed | wrong_gate_opened | wrong_proof_delivered | wrong_public_promise | wrong_route_asset_handoff | equivalent
    state_after: stale_executed | false_execution | captured_by_old_instruction | route_asset_misdelivered | recovery_only
    future_route_effect: <effect>
future_acceptance_check:
  future_reader: <reader id>
  accepted_states: []
  rejected_or_costlier_states: []
  future_route_effect: <effect>
assertions:
  - primary_links_exist
  - entry_is_state_triggered_by_changed_source_and_actionable_old_instruction
  - source_history_preserved
  - stale_instruction_holder_and_stale_action_visible
  - affected_readers_visible
  - acknowledgement_surface_or_explicit_absence_visible
  - recall_rite_has_assignment_slots
  - branch_families_diverge_by_channel_acknowledgement_cost_and_future_effect
  - universal_notify_all_is_not_free
  - partial_recall_is_supported
  - stale_execution_default_is_durable
  - recovery_keeps_scar
  - future_reader_consumes_acknowledgement_or_stale_execution_state
  - no_fixed_turn_trigger
  - no_fixed_day_or_week_trigger

Failure examples

The lens fails if any of these are true:

  • a changed source state automatically updates every local instruction;
  • the old instruction is deleted rather than preserved as issued-under old state;
  • a sent recall counts as acknowledged without a surface;
  • the holder or recipient is hidden instead of named or explicitly absent;
  • notify all has no recipient list, acknowledgement, cost, or future effect;
  • partial recall cannot exist and no explicit blocked reason is recorded;
  • stale execution only creates flavor confusion;
  • recovery erases the stale execution scar;
  • future route offers remain identical after recall, partial recall, and stale execution;
  • entry depends on a numbered turn, day, week, chapter quota, content count, or lens health.

Non-goals

  • Not a governance page.
  • Not a communication-methodology note.
  • Not a fixed upkeep phase.
  • Not raw count satisfaction.
  • Not a duplicate of claimant briefing order, ruling reader collision, availability reader collision, preair contamination, or field logistics custody.
  • Not valid unless the replay proves an old instruction can be recalled, partly recalled, or executed with durable consequences.

Graph View

Backlinks