1020	/// Per queued event: drop any stray pre-event commands, OPEN the floor (operator
1021	/// input now buffers in `dispatch_input`), feed the binary the `{type:event}`,
1022	/// then drain `{key}`/`{text}`/`{delay_ms}` into `session.write_input` until
1023	/// `{commit}` — bounded by [`INJECT_COMMIT_DEADLINE`]. On commit: flush the
1024	/// buffered controller bytes AFTER the injected sequence and release the floor. On
1025	/// deadline-miss or binary death: flush+release anyway (operator input is never
1026	/// stranded), then FAULT — terminate the binary, set `faulted`, and exit (the
1027	/// session degrades to raw inject). The loop ends when `event_tx` is dropped
1028	/// (session teardown), reaping the child.
1029	///
1030	/// The atomic open→drain→commit→flush is the W1 coexistence mechanism: an injected
1031	/// sequence and the operator's live controller share one PTY without clobbering
1032	/// each other (REQ-HAZARD-INJECT-CONTROL-COEXIST), and the deadline FAULT path is
1033	/// the "never park forever" bound applied to injection.
1034	/// Bring up a translation binary at `path` for `endpoint_id`: spawn the
1035	/// stdin→stdout filter, send the identity `Init`, start the inject worker that
1036	/// owns the atomic PTY apply, and return the `Arc<Translation>`. A spawn failure
1037	/// FAILS CLOSED to raw inject (`None`, logged) — a missing binary must never cost
1038	/// the operator their agent. `input` is the session's EXISTING PTY input writer
1039	/// (reused; only the translation child is created). Extracted verbatim from
1040	/// `dispatch_spawn` so a live-update restart (`dispatch_adapter_apply`, W3d) can
1041	/// rebuild a session's translation child from the NEW binary without disturbing
1042	/// the PTY / output log / session (brain-parity).
1043	// [impl->REQ-MSG-IDLE-TRANSLATION-BINARY]
1044	// [impl->REQ-ADAPTER-LIVE-UPDATE]
1045	fn build_translation(
1046	    path: &str,
1047	    endpoint_id: &str,
1048	    input: &Arc<InputWriter>,
1049	) -> Option<Arc<Translation>> {
1050	    let (cmd_tx, cmd_rx) = channel::<KeyCmd>();
1051	    match TranslationChild::spawn(path, cmd_tx) {
1052	        Ok(child) => {
1053	            let child = Arc::new(child);
1054	            // First line: identity (content-free of any PTY bytes).
1055	            let _ = child.send(&ToBinary::Init {
1056	                endpoint_id: endpoint_id.to_string(),
1057	                node: spt_store::hostlabel::os_hostname().unwrap_or_default(),
1058	            });
1059	            let floor = Arc::new(Mutex::new(InjectFloor::default()));
1060	            let faulted = Arc::new(AtomicBool::new(false));
1061	            let (event_tx, event_rx) = channel::<String>();
1062	            let w_input = Arc::clone(input);
1063	            let w_child = Arc::clone(&child);
1064	            let w_floor = Arc::clone(&floor);
1065	            let w_faulted = Arc::clone(&faulted);
1066	            thread::spawn(move || {
1067	                run_inject_worker(w_input, w_child, w_floor, event_rx, cmd_rx, w_faulted);
1068	            });
1069	            Some(Arc::new(Translation {
1070	                floor,
1071	                event_tx,
1072	                child,
1073	                faulted,
1074	            }))
1075	        }
1076	        Err(e) => {
1077	            eprintln!("TRANSLATION_SPAWN_FAILED:{path}: {e} — degrading to raw inject");
1078	            None
1079	        }
1080	    }
1081	}
1082
1083	/// The resident translation binary path declared by the manifest at
1084	/// `<install_dir>/manifest.toml` (`[message-idle-translation-binary].path`), or
1085	/// `None` if there is no such manifest / declaration. Read fresh from disk so a
1086	/// live-update restart picks up a MOVED/renamed binary (verdict flag-5: never
1087	/// reuse the stale cached `SpawnReq.translation_binary`). (W3d)
1088	// [impl->REQ-ADAPTER-LIVE-UPDATE]
1089	fn read_translation_path(install_dir: &std::path::Path) -> Option<String> {
1090	    let s = std::fs::read_to_string(install_dir.join("manifest.toml")).ok()?;
1091	    let manifest = spt_runtime::Manifest::from_toml_str(&s).ok()?;
1092	    manifest
1093	        .message_idle_translation_binary
1094	        // F-019 / REQ-INSTALL-11: resolve the bare/relative shipped path against the
1095	        // install dir (same as the initial spawn in harnesshost) so the W3d
1096	        // live-update RESPAWN also runs the real binary — not a verbatim path that
1097	        // Command::new fails to find, silently degrading to raw inject.
1098	        // [impl->REQ-INSTALL-11]
1099	        .map(|b| spt_runtime::runtime::resolve_program_in_dir(&b.path, install_dir))
1100	}
1101
1102	// [impl->REQ-MSG-IDLE-TRANSLATION-BINARY]
1103	// [impl->REQ-HAZARD-INJECT-CONTROL-COEXIST]
1104	fn run_inject_worker(
1105	    input: Arc<InputWriter>,
1106	    child: Arc<TranslationChild>,
1107	    floor: Arc<Mutex<InjectFloor>>,
1108	    event_rx: Receiver<String>,
1109	    cmd_rx: Receiver<KeyCmd>,
1110	    faulted: Arc<AtomicBool>,
1111	) {
1112	    // `event_rx` blocks here; events queue → one sequence at a time.
1113	    for envelope in event_rx {
1114	        // A well-behaved filter only emits in response to an event, but drop any
1115	        // unsolicited commands left in the channel so they can't be mis-attributed
1116	        // to this event's sequence.
1117	        while cmd_rx.try_recv().is_ok() {}
1118
1119	        floor.lock().unwrap().open();
1120	        if child.send(&ToBinary::Event { envelope }).is_err() {
1121	            // stdin write failed → the binary is gone; release the floor + fault.
1122	            flush_inject_floor(&floor, &input);
1123	            fault_translation(&faulted, &child, "stdin write failed");
1124	            return;
1125	        }
1126
1127	        let deadline = Instant::now() + inject_commit_deadline();
1128	        let mut committed = false;
1129	        loop {
1130	            let now = Instant::now();
1131	            let remaining = deadline.saturating_duration_since(now);
1132	            if remaining.is_zero() {
1133	                break; // deadline → fault below
1134	            }
1135	            match cmd_rx.recv_timeout(remaining) {
1136	                Ok(KeyCmd::Key { key }) => {
1137	                    if let Some(bytes) = key_to_bytes(&key) {
1138	                        input.enqueue(bytes);
1139	                    }
1140	                }
1141	                Ok(KeyCmd::Text { text }) => {
1142	                    input.enqueue(text.into_bytes());
1143	                }
1144	                Ok(KeyCmd::Delay { delay_ms }) => {
1145	                    // Clamp the pause to the remaining deadline so a huge/hostile
1146	                    // delay can't park the floor past the bound.
1147	                    let want = Duration::from_millis(delay_ms);
1148	                    let cap = deadline.saturating_duration_since(Instant::now());
1149	                    thread::sleep(want.min(cap));
1150	                }
1151	                Ok(KeyCmd::Commit { .. }) => {
1152	                    committed = true;
1153	                    break;
1154	                }
1155	                // Deadline with no commit, OR the child's stdout closed (binary
1156	                // died): both end the sequence; `committed` stays false → fault.
1157	                Err(RecvTimeoutError::Timeout | RecvTimeoutError::Disconnected) => break,
1158	            }
1159	        }
1160
1161	        // Flush buffered controller input AFTER the injected bytes + release the
1162	        // floor — in EVERY exit path, so operator keystrokes are never stranded.
1163	        flush_inject_floor(&floor, &input);
1164
1165	        if !committed {
1166	            fault_translation(&faulted, &child, "no {commit} within INJECT_COMMIT_DEADLINE");
1167	            return;
1168	        }
1169	    }
1170	    // `event_tx` dropped → session teardown. Reap the child (no zombie).
1171	    child.terminate();
1172	}
1173
1174	/// FAULT a translation binary: mark the session degraded (so inbound delivery
1175	/// reverts to raw inject and `dispatch_input` stops pinging), log it, and reap the
1176	/// child. Never respawns — degrade-to-pass-through, never a dead operator.
1177	fn fault_translation(faulted: &AtomicBool, child: &TranslationChild, why: &str) {
1178	    faulted.store(true, Ordering::Relaxed);
1179	    eprintln!("TRANSLATION_FAULT: {why} — terminating binary, reverting to raw inject");
1180	    child.terminate();
1181	}
1182
1183	/// The broker process kernel. Owns the listening socket, the table of hosted
1184	/// sessions, and the broker-owned idempotency anchor (B5); holds no logic state
1185	/// (ADR-0004 §B). The [`EffectJournal`] is a §B resource — the durable
1186	/// recovery anchor a brain crash must not lose, so it lives in the broker, not
1187	/// the brain (Spike #6 constraint 1).
1188	pub struct Broker {
1189	    listener: LocalSocketTransport,
1190	    sessions: Arc<Mutex<HashMap<u64, HostedSession>>>,
1191	    next_id: AtomicU64,
1192	    log_cap_chunks: usize,
1193	    /// The exactly-once anchor for idempotent (`op_id`-carrying) effects.
1194	    journal: Arc<EffectJournal>,
1195	    /// The broker-owned net endpoint + live QUIC connections (D4a, ADR-0004 §B).
1196	    /// Empty when bound without a network host (net-disabled / most tests) OR
1197	    /// when net is still being brought up (REQ-DAEMON-9 boot-race self-heal):
1198	    /// a `OnceLock` so the background net-retry can ATTACH the host after bind
1199	    /// without a relock on the hot effect-dispatch read path (`.get()` is
1200	    /// lock-free). Settable exactly once — the first host wins.
1201	    net: std::sync::OnceLock<NetHost>,
1202	    /// The broker→supervisor planned-restart signal (ADR-0018 D3-3): a
1203	    /// `KIND_BRAIN_RESTART` handler raises it so the brain supervisor cycles the
1204	    /// child onto a freshly-swapped binary. Empty on a bare broker (a test broker
1205	    /// with no supervisor) — the verb is then accepted but unhonored. Set once by
1206	    /// `Daemon::run` after it spawns the supervisor.
1207	    brain_restart: std::sync::OnceLock<Arc<crate::brainproc::BrainRestart>>,
1208	}
1209
1210	/// The distinct `(endpoint, install_dir)` pairs whose session runs `adapter`,
1211	/// from per-session `(endpoint, adapter, install_dir)` rows. Sessions with no
1212	/// recorded install dir are dropped (a live update needs a target). Pure (no
1213	/// lock, no I/O) so the live-update endpoint-selection is unit-testable without
1214	/// constructing real `HostedSession`s. (W3a, ADR-0025)
1215	// [impl->REQ-ADAPTER-LIVE-UPDATE]
1216	fn select_endpoints_running_adapter(
1217	    rows: impl IntoIterator<Item = (String, String, Option<std::path::PathBuf>)>,
1218	    adapter: &str,
1219	) -> Vec<(String, std::path::PathBuf)> {
1220	    let mut out: Vec<(String, std::path::PathBuf)> = rows
1221	        .into_iter()
1222	        .filter_map(|(endpoint, adp, dir)| {
1223	            (adp == adapter).then_some(dir.map(|d| (endpoint, d)))?
1224	        })
1225	        .collect();
1226	    out.sort();
1227	    out.dedup();
1228	    out
1229	}

/// Per queued event: drop any stray pre-event commands, OPEN the floor (operator
/// input now buffers in `dispatch_input`), feed the binary the `{type:event}`,
/// then drain `{key}`/`{text}`/`{delay_ms}` into `session.write_input` until
/// `{commit}` — bounded by [`INJECT_COMMIT_DEADLINE`]. On commit: flush the
/// buffered controller bytes AFTER the injected sequence and release the floor. On
/// deadline-miss or binary death: flush+release anyway (operator input is never
/// stranded), then FAULT — terminate the binary, set `faulted`, and exit (the
/// session degrades to raw inject). The loop ends when `event_tx` is dropped
/// (session teardown), reaping the child.
///
/// The atomic open→drain→commit→flush is the W1 coexistence mechanism: an injected
/// sequence and the operator's live controller share one PTY without clobbering
/// each other (REQ-HAZARD-INJECT-CONTROL-COEXIST), and the deadline FAULT path is
/// the "never park forever" bound applied to injection.
/// Bring up a translation binary at `path` for `endpoint_id`: spawn the
/// stdin→stdout filter, send the identity `Init`, start the inject worker that
/// owns the atomic PTY apply, and return the `Arc<Translation>`. A spawn failure
/// FAILS CLOSED to raw inject (`None`, logged) — a missing binary must never cost
/// the operator their agent. `input` is the session's EXISTING PTY input writer
/// (reused; only the translation child is created). Extracted verbatim from
/// `dispatch_spawn` so a live-update restart (`dispatch_adapter_apply`, W3d) can
/// rebuild a session's translation child from the NEW binary without disturbing
/// the PTY / output log / session (brain-parity).
// [impl->REQ-MSG-IDLE-TRANSLATION-BINARY]
// [impl->REQ-ADAPTER-LIVE-UPDATE]
fn build_translation(
    path: &str,
    endpoint_id: &str,
    input: &Arc<InputWriter>,
) -> Option<Arc<Translation>> {
    let (cmd_tx, cmd_rx) = channel::<KeyCmd>();
    match TranslationChild::spawn(path, cmd_tx) {
        Ok(child) => {
            let child = Arc::new(child);
            // First line: identity (content-free of any PTY bytes).
            let _ = child.send(&ToBinary::Init {
                endpoint_id: endpoint_id.to_string(),
                node: spt_store::hostlabel::os_hostname().unwrap_or_default(),
            });
            let floor = Arc::new(Mutex::new(InjectFloor::default()));
            let faulted = Arc::new(AtomicBool::new(false));
            let (event_tx, event_rx) = channel::<String>();
            let w_input = Arc::clone(input);
            let w_child = Arc::clone(&child);
            let w_floor = Arc::clone(&floor);
            let w_faulted = Arc::clone(&faulted);
            thread::spawn(move || {
                run_inject_worker(w_input, w_child, w_floor, event_rx, cmd_rx, w_faulted);
            });
            Some(Arc::new(Translation {
                floor,
                event_tx,
                child,
                faulted,
            }))
        }
        Err(e) => {
            eprintln!("TRANSLATION_SPAWN_FAILED:{path}: {e} — degrading to raw inject");
            None
        }
    }
}

/// The resident translation binary path declared by the manifest at
/// `<install_dir>/manifest.toml` (`[message-idle-translation-binary].path`), or
/// `None` if there is no such manifest / declaration. Read fresh from disk so a
/// live-update restart picks up a MOVED/renamed binary (verdict flag-5: never
/// reuse the stale cached `SpawnReq.translation_binary`). (W3d)
// [impl->REQ-ADAPTER-LIVE-UPDATE]
fn read_translation_path(install_dir: &std::path::Path) -> Option<String> {
    let s = std::fs::read_to_string(install_dir.join("manifest.toml")).ok()?;
    let manifest = spt_runtime::Manifest::from_toml_str(&s).ok()?;
    manifest
        .message_idle_translation_binary
        // F-019 / REQ-INSTALL-11: resolve the bare/relative shipped path against the
        // install dir (same as the initial spawn in harnesshost) so the W3d
        // live-update RESPAWN also runs the real binary — not a verbatim path that
        // Command::new fails to find, silently degrading to raw inject.
        // [impl->REQ-INSTALL-11]
        .map(|b| spt_runtime::runtime::resolve_program_in_dir(&b.path, install_dir))
}

// [impl->REQ-MSG-IDLE-TRANSLATION-BINARY]
// [impl->REQ-HAZARD-INJECT-CONTROL-COEXIST]
fn run_inject_worker(
    input: Arc<InputWriter>,
    child: Arc<TranslationChild>,
    floor: Arc<Mutex<InjectFloor>>,
    event_rx: Receiver<String>,
    cmd_rx: Receiver<KeyCmd>,
    faulted: Arc<AtomicBool>,
) {
    // `event_rx` blocks here; events queue → one sequence at a time.
    for envelope in event_rx {
        // A well-behaved filter only emits in response to an event, but drop any
        // unsolicited commands left in the channel so they can't be mis-attributed
        // to this event's sequence.
        while cmd_rx.try_recv().is_ok() {}

        floor.lock().unwrap().open();
        if child.send(&ToBinary::Event { envelope }).is_err() {
            // stdin write failed → the binary is gone; release the floor + fault.
            flush_inject_floor(&floor, &input);
            fault_translation(&faulted, &child, "stdin write failed");
            return;
        }

        let deadline = Instant::now() + inject_commit_deadline();
        let mut committed = false;
        loop {
            let now = Instant::now();
            let remaining = deadline.saturating_duration_since(now);
            if remaining.is_zero() {
                break; // deadline → fault below
            }
            match cmd_rx.recv_timeout(remaining) {
                Ok(KeyCmd::Key { key }) => {
                    if let Some(bytes) = key_to_bytes(&key) {
                        input.enqueue(bytes);
                    }
                }
                Ok(KeyCmd::Text { text }) => {
                    input.enqueue(text.into_bytes());
                }
                Ok(KeyCmd::Delay { delay_ms }) => {
                    // Clamp the pause to the remaining deadline so a huge/hostile
                    // delay can't park the floor past the bound.
                    let want = Duration::from_millis(delay_ms);
                    let cap = deadline.saturating_duration_since(Instant::now());
                    thread::sleep(want.min(cap));
                }
                Ok(KeyCmd::Commit { .. }) => {
                    committed = true;
                    break;
                }
                // Deadline with no commit, OR the child's stdout closed (binary
                // died): both end the sequence; `committed` stays false → fault.
                Err(RecvTimeoutError::Timeout | RecvTimeoutError::Disconnected) => break,
            }
        }

        // Flush buffered controller input AFTER the injected bytes + release the
        // floor — in EVERY exit path, so operator keystrokes are never stranded.
        flush_inject_floor(&floor, &input);

        if !committed {
            fault_translation(&faulted, &child, "no {commit} within INJECT_COMMIT_DEADLINE");
            return;
        }
    }
    // `event_tx` dropped → session teardown. Reap the child (no zombie).
    child.terminate();
}

/// FAULT a translation binary: mark the session degraded (so inbound delivery
/// reverts to raw inject and `dispatch_input` stops pinging), log it, and reap the
/// child. Never respawns — degrade-to-pass-through, never a dead operator.
fn fault_translation(faulted: &AtomicBool, child: &TranslationChild, why: &str) {
    faulted.store(true, Ordering::Relaxed);
    eprintln!("TRANSLATION_FAULT: {why} — terminating binary, reverting to raw inject");
    child.terminate();
}

/// The broker process kernel. Owns the listening socket, the table of hosted
/// sessions, and the broker-owned idempotency anchor (B5); holds no logic state
/// (ADR-0004 §B). The [`EffectJournal`] is a §B resource — the durable
/// recovery anchor a brain crash must not lose, so it lives in the broker, not
/// the brain (Spike #6 constraint 1).
pub struct Broker {
    listener: LocalSocketTransport,
    sessions: Arc<Mutex<HashMap<u64, HostedSession>>>,
    next_id: AtomicU64,
    log_cap_chunks: usize,
    /// The exactly-once anchor for idempotent (`op_id`-carrying) effects.
    journal: Arc<EffectJournal>,
    /// The broker-owned net endpoint + live QUIC connections (D4a, ADR-0004 §B).
    /// Empty when bound without a network host (net-disabled / most tests) OR
    /// when net is still being brought up (REQ-DAEMON-9 boot-race self-heal):
    /// a `OnceLock` so the background net-retry can ATTACH the host after bind
    /// without a relock on the hot effect-dispatch read path (`.get()` is
    /// lock-free). Settable exactly once — the first host wins.
    net: std::sync::OnceLock<NetHost>,
    /// The broker→supervisor planned-restart signal (ADR-0018 D3-3): a
    /// `KIND_BRAIN_RESTART` handler raises it so the brain supervisor cycles the
    /// child onto a freshly-swapped binary. Empty on a bare broker (a test broker
    /// with no supervisor) — the verb is then accepted but unhonored. Set once by
    /// `Daemon::run` after it spawns the supervisor.
    brain_restart: std::sync::OnceLock<Arc<crate::brainproc::BrainRestart>>,
}

/// The distinct `(endpoint, install_dir)` pairs whose session runs `adapter`,
/// from per-session `(endpoint, adapter, install_dir)` rows. Sessions with no
/// recorded install dir are dropped (a live update needs a target). Pure (no
/// lock, no I/O) so the live-update endpoint-selection is unit-testable without
/// constructing real `HostedSession`s. (W3a, ADR-0025)
// [impl->REQ-ADAPTER-LIVE-UPDATE]
fn select_endpoints_running_adapter(
    rows: impl IntoIterator<Item = (String, String, Option<std::path::PathBuf>)>,
    adapter: &str,
) -> Vec<(String, std::path::PathBuf)> {
    let mut out: Vec<(String, std::path::PathBuf)> = rows
        .into_iter()
        .filter_map(|(endpoint, adp, dir)| {
            (adp == adapter).then_some(dir.map(|d| (endpoint, d)))?
        })
        .collect();
    out.sort();
    out.dedup();
    out
}


63:title = "spt-store::BranchStore (git branch as versioned KV; commit=checkpoint/tip=resume, atomic multi-key, merge-native sync) is the substrate for coarse/durable/audited state (context, registry snapshot+distribution, daemon checkpoint); hot paths (B5 fsync journal) + indexed queries (SQLite spool) excluded (ADR-0011)"
264:[Omitted long matching line]
292:title = "Local message delivery: TCP-first to a registered address, spool fallback when offline; id->address via registry (stale-clean first); reply routing (__REPLY_TO__)"
300:title = "Ready-agent lifecycle: register perch (info.json + listener + registry address) on ready, drain spooled backlog on startup, clean teardown"
308:[Omitted long matching line]
327:[Omitted long matching line]
395:title = "Notification primitive: per-subnet replicated spool, seen/dismissed, resurface-at-boundary, subsumes update+consent prompts"
492:[Omitted long matching line]
549:[Omitted long matching line]
558:[Omitted long matching line]
565:id = "REQ-SEND-SPT-HOSTED"
566:[Omitted long matching line]
567:[Omitted long matching line]
578:[Omitted long matching line]
623:[Omitted long matching line]
745:title = "Deferred spool rows excluded from the event-stream drain (1.4)"
746:required_stages = ["impl", "unit"]  # activated M0: spt-store spool drain_non_deferred (T9)
807:title = "Stale registry entries degrade to fallback, never hard-fail (4.3)"
811:title = "Concurrent SQLite openers (registry/spool) must not fail with 'database is locked' (4.7)"
824:required_stages = ["impl", "unit"]  # activated M0: spt-store spool deferred rows (T9)
828:required_stages = ["impl", "unit"]  # activated M1 T2: delivery is TCP xor spool, never both
852:required_stages = ["impl", "unit"]  # activated M1 T3: soft_cleanup removes ready marker only, preserves spool + info.json
931:[Omitted long matching line]
941:[Omitted long matching line]
974:[Omitted long matching line]
985:title = "Shell hosting machinery: shell perch under the owner (type/owner/adapter_name/status/alias), broker-launched binary + api bind local-link handshake, the three channels (command durable, text+file durable + progress-queryable, sensory REST-only never spooled + dropped-unless-owner-live), owner exclusivity (CONTEXT Shell model)"
1026:[Omitted long matching line]
1054:required_stages = ["impl", "unit"]  # activated M8-D4: spt_store::peeraddrs::PeerAddrStore (atomic JSON map, corrupt-degrades-empty) + the pump's seeded dial order in ensure_conn (cached addr → dial → id-only fallback; observed remote addr written back from the dial reply) + ceremony writers in pairhost (joiner + responder, from the live conn's paths). unit = store roundtrip/corrupt + dial-plan order + observed-addr capture. Rig convergence timing = acceptance 6
1114:[Omitted long matching line]
1139:[Omitted long matching line]
1140:[Omitted long matching line]
1143:[Omitted long matching line]
1148:required_stages = ["doc", "impl", "unit", "int"]  # M11-W1 closed: doc = CONTEXT §per-capability approval gates; impl = linkhost::act_gate_decide / drive_shell gate + cli::escalate_act; unit = per_capability_act_gate_blocks_until_class_scoped_grant + run_action_refuses_gated_op_without_spooling; int = shell_actgate_e2e (class-scoped grant flips the command through the real binary)
1242:id = "REQ-MSG-IDLE-TRANSLATION-BINARY"
1243:[Omitted long matching line]
1244:[Omitted long matching line]
1285:[Omitted long matching line]
1321:[Omitted long matching line]


Existing REQ is `REQ-MSG-IDLE-TRANSLATION-BINARY` (line 1242). Read its full entry — the spool contract likely extends it (or doyle minted a sibling in the missing tail).