From 7d59751f8c050a5bf8faa6c3825be98cb7ba156b Mon Sep 17 00:00:00 2001 From: Cameron Date: Thu, 16 Jul 2026 17:34:09 -0700 Subject: [PATCH] The rail stops repeating itself. Findings-queue tick. The rail READ block listed six near-identical starving-sink lines with one cause - the attention-economy failure the spec forbids. Rail-only compression: 3+ same-cause starving sinks become one counted line naming the first sink; everything else verbatim; the agent read verb and dev two-pane stay uncollapsed (parity instruments show everything). Pinned by rail_read_collapses_same_cause_starving_sinks. Defense: wiki/interface/digital-read.md attention economy ('a world made of language must not become every system continuously talking'), amended with the D8 note. Presentation only; the projection is unchanged. --- crates/misaligned-bevy/src/main.rs | 85 ++++++++++++++++++++++- wiki/interface/digital-read.md | 6 ++ wiki/log/2026-07-15-read-rail-collapse.md | 22 ++++++ wiki/log/DEVLOG.md | 5 ++ wiki/process/tick-ledger.md | 1 - 5 files changed, 115 insertions(+), 4 deletions(-) create mode 100644 wiki/log/2026-07-15-read-rail-collapse.md diff --git a/crates/misaligned-bevy/src/main.rs b/crates/misaligned-bevy/src/main.rs index e244c95f..aca1b79a 100644 --- a/crates/misaligned-bevy/src/main.rs +++ b/crates/misaligned-bevy/src/main.rs @@ -9718,7 +9718,52 @@ mod view_flip_tests { #[cfg(test)] mod menu_focus_tests { - use super::{Anchor, Game}; + use super::{Anchor, Game, collapse_read_lines}; + + #[test] + fn rail_read_collapses_same_cause_starving_sinks() { + use misaligned::sim::read::{ReadClass, ReadSentence}; + let mk = |text: &str, class: ReadClass| ReadSentence { + class, + anchor: None, + text: text.into(), + }; + // Six same-cause starving sinks collapse to one counted line; a + // held sentence and a two-sink cause stay verbatim. + let rail = vec![ + mk("QUESTION - choose someone", ReadClass::Held), + mk( + "EARS · open 0.0/3.0 · nothing thinking", + ReadClass::Starving, + ), + mk( + "TAP SWITCH · open 0.0/0.5 · nothing thinking", + ReadClass::Starving, + ), + mk( + "TAP DOCK CAMERA · open 0.0/0.5 · nothing thinking", + ReadClass::Starving, + ), + mk( + "TAP BADGE CONTROLLER · open 0.0/0.5 · nothing thinking", + ReadClass::Starving, + ), + mk( + "EYES · open 0.2/12.0 · flow not arriving", + ReadClass::Starving, + ), + ]; + let lines = collapse_read_lines(&rail); + assert_eq!( + lines, + vec![ + "- QUESTION - choose someone".to_string(), + "- 4 sinks starving · nothing thinking (EARS +3 more)".to_string(), + "- EYES · open 0.2/12.0 · flow not arriving".to_string(), + ], + "held stays verbatim, big group counts, small cause stays verbatim" + ); + } #[test] fn keyboard_menu_keeps_cursor_focus_despite_pointer_or_selection_state() { @@ -10701,12 +10746,12 @@ fn read_sentence_tile(sim: &Sim, s: &misaligned::sim::read::ReadSentence) -> Opt /// world position. One line each, newest classes first by projection order; /// empty when the world already says everything (attention economy). fn sidebar_read_text(sim: &Sim) -> String { - let lines: Vec = sim + let rail: Vec = sim .read_sentences() .into_iter() .filter(|s| read_sentence_tile(sim, s).is_none()) - .map(|s| format!("- {}", s.text)) .collect(); + let lines = collapse_read_lines(&rail); if lines.is_empty() { String::new() } else { @@ -10714,6 +10759,40 @@ fn sidebar_read_text(sim: &Sim) -> String { } } +/// Rail-only compression of same-cause starving sinks: three or more +/// starving lines sharing one cause become a single counted line, keeping +/// the first sink as the example ("world made of language must not become +/// every system continuously talking" — digital-read.md attention economy). +/// The agent `read` verb and the dev two-pane stay uncollapsed: parity +/// instruments show everything. +fn collapse_read_lines(rail: &[misaligned::sim::read::ReadSentence]) -> Vec { + use misaligned::sim::read::ReadClass; + let mut lines = Vec::new(); + let mut starving: Vec<&str> = Vec::new(); + for s in rail { + if s.class == ReadClass::Starving { + starving.push(&s.text); + } else { + lines.push(format!("- {}", s.text)); + } + } + for cause in ["nothing thinking", "flow not arriving"] { + let group: Vec<&&str> = starving.iter().filter(|t| t.ends_with(cause)).collect(); + match group.len() { + 0 => {} + 1..=2 => lines.extend(group.iter().map(|t| format!("- {t}"))), + n => { + let first = group[0].split(" · ").next().unwrap_or(group[0]).to_string(); + lines.push(format!( + "- {n} sinks starving · {cause} ({first} +{} more)", + n - 1 + )); + } + } + } + lines +} + /// The dev two-pane's agent-read text (digital-read.md criterion 7): the /// same tick as the agent frame would render it — spine, then every read /// sentence with its class and anchor. Unlike the rail READ block, this diff --git a/wiki/interface/digital-read.md b/wiki/interface/digital-read.md index 07e79128..4a7922ee 100644 --- a/wiki/interface/digital-read.md +++ b/wiki/interface/digital-read.md @@ -106,6 +106,12 @@ Status note: adopted 2026-07-15 from the Fable playtest debrief (report: dev two-pane (F8) stays available in both dialects by design (a debug instrument, not a player surface). REAL frame re-captured and reviewed: dial, rail, and Operations unchanged, no receipt leak. + 2026-07-15 D8: rail attention economy. Same-cause starving sinks (3+) + collapse to one counted line on the rail READ block ("6 sinks starving · + nothing thinking (EARS +5 more)"), pinned by + `rail_read_collapses_same_cause_starving_sinks`; the agent `read` verb + and the dev two-pane stay uncollapsed — parity instruments show + everything. Stage: B1 — The Basement Work order: digital-read Work priority: 27 diff --git a/wiki/log/2026-07-15-read-rail-collapse.md b/wiki/log/2026-07-15-read-rail-collapse.md new file mode 100644 index 00000000..f82751d7 --- /dev/null +++ b/wiki/log/2026-07-15-read-rail-collapse.md @@ -0,0 +1,22 @@ +# Tick: the rail stops repeating itself + +``` +Type: log +``` + +Findings-queue tick (queued during digital-read D2's evidence review). +The rail READ block listed six near-identical starving-sink lines with +the same cause — exactly the "every system continuously talking" failure +the attention economy forbids. Rail-only compression: three or more +same-cause starving sinks become one counted line naming the first sink +("6 sinks starving · nothing thinking (EARS +5 more)"); held choices, +trace, standing sentences, and small groups stay verbatim. The agent +`read` verb and the dev two-pane deliberately stay uncollapsed: parity +instruments show everything. Pinned by +`rail_read_collapses_same_cause_starving_sinks`; evidence frame +re-captured and reviewed. + +Defense: wiki/interface/digital-read.md's attention-economy clause ("a +world made of language must not become every system continuously +talking"), amended with the D8 note. Presentation-layer only; the +projection is unchanged. diff --git a/wiki/log/DEVLOG.md b/wiki/log/DEVLOG.md index 144c7ece..ef4fec50 100644 --- a/wiki/log/DEVLOG.md +++ b/wiki/log/DEVLOG.md @@ -26,6 +26,11 @@ add or amend a session log, then re-run the generator. - Intent: (see session log) - Log: [wiki/log/2026-07-15-run-shape-staging-resolved.md](2026-07-15-run-shape-staging-resolved.md) +## 2026-07-15 - Tick: the rail stops repeating itself + +- Intent: (see session log) +- Log: [wiki/log/2026-07-15-read-rail-collapse.md](2026-07-15-read-rail-collapse.md) + ## 2026-07-15 - Tick: plot receipts stop denying their emissions - Intent: (see session log) diff --git a/wiki/process/tick-ledger.md b/wiki/process/tick-ledger.md index dcff85a6..e6bb0abb 100644 --- a/wiki/process/tick-ledger.md +++ b/wiki/process/tick-ledger.md @@ -63,7 +63,6 @@ A tick that takes an entry deletes the line (git preserves it) and verifies the finding is still true before acting — the code or corpus may have moved. -- 2026-07-15 · finding · digital-read · READ rail can list N near-identical starving-sink lines with the same cause ("nothing thinking"); collapse same-cause starving sinks to one line with a count (attention economy / Trace's "not every system continuously talking"). - 2026-07-15 · finding · digital-read criterion 5 · held-choice card anchors via world_to_viewport, which diverges slightly from the 2D cursor-marker transform; tether the card to the person glyph's actual rendered position for a tighter "at the anchor" read. Format: `- YYYY-MM-DD · type · slice · one-line statement of the finding`. -- 2.51.2