From 329b7d6cd046cfb473f26c20f971db511b062086 Mon Sep 17 00:00:00 2001 From: Cameron Date: Thu, 9 Jul 2026 21:12:42 -0700 Subject: [PATCH] Decide exposure: particulate residue with footprint trails MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Exposure is crimson contamination dust, never a liquid: machines shed motes that settle into a stippled drift of fine angular flecks outside the amber claim ring (density and spread carry the amount; whisper emissive — it absorbs light). Carriers deposit fading stippled footprint trails along their walking paths (new decided mechanic, sim+save scoped with people-tokens #35); the person dosimeter is speckle density climbing the silhouette. New law bullet: blood is liquid, exposure is dust — the two crimson materials never share a form, so overt-phase blood keeps its image untouched. Issue #1 closed both halves, labeled decision-made. Art: deterministic golden-angle drift + trail demo in the shared chassis library (tester V/B keys, exposure shot kind); the game wires each owned machine's live exposure queue to its drift. Defense: crimson keeps its single meaning (consequence) while the liquid/granular form channel separates suspicion from literal blood in the same frame — one meaning per color, information never by hue alone, and the overt phase's loudest image is preserved by law. Paused geometry still carries amount; the drift is deterministic (no RNG, no wall clock). Amended into art/visual-identity.md, mechanics/machine-work.md, and mechanics/people-tokens.md in this commit; the trail mechanic is captured as spec, not implemented ahead of its system. --- src/bin/assets/mod.rs | 66 ++++++++++--- src/bin/assets/palette.rs | 2 + src/bin/assets/rack.rs | 126 +++++++++++++++++++++++- src/bin/bevy.rs | 17 ++-- wiki/art/visual-identity.md | 7 ++ wiki/log/2026-07-09-exposure-residue.md | 59 +++++++++++ wiki/log/DEVLOG.md | 15 +++ wiki/log/decisions/2026-07-09.md | 19 ++++ wiki/mechanics/machine-work.md | 41 +++++--- wiki/mechanics/people-tokens.md | 46 ++++++--- wiki/process/ROADMAP.md | 12 ++- 11 files changed, 355 insertions(+), 55 deletions(-) create mode 100644 wiki/log/2026-07-09-exposure-residue.md diff --git a/src/bin/assets/mod.rs b/src/bin/assets/mod.rs index 30f742cb..f17019a7 100644 --- a/src/bin/assets/mod.rs +++ b/src/bin/assets/mod.rs @@ -20,7 +20,8 @@ use bevy::window::{CursorGrabMode, CursorOptions, WindowResolution}; use palette::{GUNMETAL, NEAR_BLACK, PORCELAIN}; use rack::{ - Blink, ClaimStyle, RackMode, RackRoot, RackState, spawn_server_rack, spawn_token_anchors, + Blink, ClaimStyle, RackMode, RackRoot, RackState, spawn_exposure_trail, spawn_server_rack, + spawn_token_anchors, }; /// Work-token load staged on the single rack (machine-work.md anchors): @@ -30,11 +31,23 @@ use rack::{ struct TokenLoad { demand: usize, knowledge: f32, + exposure: f32, + /// Footprint-trail demo (prints walking away from the machine). + trail: bool, } impl TokenLoad { const DEMAND_STEPS: [usize; 4] = [0, 2, 5, 9]; const KNOWLEDGE_STEPS: [f32; 5] = [0.0, 1.0, 2.0, 4.0, 8.0]; + const EXPOSURE_STEPS: [f32; 4] = [0.0, 1.0, 3.0, 8.0]; + + fn next_exposure(&mut self) { + let i = Self::EXPOSURE_STEPS + .iter() + .position(|&x| x == self.exposure) + .unwrap_or(0); + self.exposure = Self::EXPOSURE_STEPS[(i + 1) % Self::EXPOSURE_STEPS.len()]; + } fn next_demand(&mut self) { let i = Self::DEMAND_STEPS @@ -94,18 +107,28 @@ fn scene_from_shot(kind: &str) -> (ViewMode, RackState, RackMode, ClaimStyle, To ); } // Token-anchor evidence: an owned-busy day-job rack under a mid or - // overflow work load (machine-work.md docket + ivory mercury). - if kind == "tokens" || kind == "tokens_max" { - let load = if kind == "tokens_max" { - TokenLoad { + // overflow work load (machine-work.md cubes + ivory mercury + + // exposure drift), or the exposure board (drift + footprint trail). + if kind == "tokens" || kind == "tokens_max" || kind == "exposure" { + let load = match kind { + "tokens_max" => TokenLoad { demand: 9, knowledge: 8.0, - } - } else { - TokenLoad { + exposure: 8.0, + trail: false, + }, + "exposure" => TokenLoad { + demand: 0, + knowledge: 0.0, + exposure: 6.0, + trail: true, + }, + _ => TokenLoad { demand: 5, knowledge: 4.0, - } + exposure: 3.0, + trail: false, + }, }; return ( ViewMode::Single, @@ -390,11 +413,13 @@ fn hud_string( ) -> String { let line2 = match view { ViewMode::Single => format!( - "state: {} (1 dead 2 foreign 3 idle 4 busy 5 core) mode: {} (M cycles)\ntokens: D{} K{:.0} (T demand U knowledge)", + "state: {} (1 dead 2 foreign 3 idle 4 busy 5 core) mode: {} (M cycles)\ntokens: D{} K{:.0} !{:.0}{} (T demand U knowledge V exposure B trail)", state.label(), rack_mode.label(), tokens.demand, - tokens.knowledge + tokens.knowledge, + tokens.exposure, + if tokens.trail { " +trail" } else { "" } ), ViewMode::Lineup => { "lineup: dead | foreign | idle | busy | core (left to right)".to_string() @@ -474,6 +499,12 @@ fn handle_state_keys( if kb.just_pressed(KeyCode::KeyU) { tokens.next_knowledge(); } + if kb.just_pressed(KeyCode::KeyV) { + tokens.next_exposure(); + } + if kb.just_pressed(KeyCode::KeyB) { + tokens.trail = !tokens.trail; + } if kb.just_pressed(KeyCode::KeyL) { *mode = match *mode { ViewMode::Lineup => ViewMode::Single, @@ -615,13 +646,24 @@ fn rebuild_scene( Vec3::ZERO, Some(pedestal), ); - if tokens.demand > 0 || tokens.knowledge > 0.0 { + if tokens.demand > 0 || tokens.knowledge > 0.0 || tokens.exposure > 0.0 { spawn_token_anchors( &mut commands, &mut meshes, &mut materials, tokens.demand, tokens.knowledge, + tokens.exposure, + Vec3::ZERO, + Some(pedestal), + ); + } + if tokens.trail { + spawn_exposure_trail( + &mut commands, + &mut meshes, + &mut materials, + 7, Vec3::ZERO, Some(pedestal), ); diff --git a/src/bin/assets/palette.rs b/src/bin/assets/palette.rs index c69aae0a..7580c3f6 100644 --- a/src/bin/assets/palette.rs +++ b/src/bin/assets/palette.rs @@ -21,6 +21,8 @@ pub const GUNMETAL: Color = Color::srgb(0.33, 0.35, 0.38); pub const GUNMETAL_DARK: Color = Color::srgb(0.19, 0.20, 0.215); /// Near-black — rock mass and sensor darkness. pub const NEAR_BLACK: Color = Color::srgb(0.045, 0.047, 0.053); +/// Blood crimson — gore and security information ONLY. +pub const CRIMSON: Color = Color::srgb(0.84, 0.15, 0.15); /// Sterile amber — machine presence and selection ONLY. pub const AMBER: Color = Color::srgb(1.0, 0.69, 0.0); /// Dim amber — dormant/known machine presence. diff --git a/src/bin/assets/rack.rs b/src/bin/assets/rack.rs index bfbe677a..bc7da55b 100644 --- a/src/bin/assets/rack.rs +++ b/src/bin/assets/rack.rs @@ -19,7 +19,7 @@ use bevy::prelude::*; -use crate::palette::{AMBER, AMBER_DIM, BONE, GUNMETAL_DARK, NEAR_BLACK, SIGNAL, scaled}; +use crate::palette::{AMBER, AMBER_DIM, BONE, CRIMSON, GUNMETAL_DARK, NEAR_BLACK, SIGNAL, scaled}; /// Visual state for the rack under test — the power x ownership x load /// x core space collapsed to its five distinct readings. @@ -744,15 +744,22 @@ const CUBE_MAX: usize = 8; /// self-glow; discrete viscous slugs while low, a taut suspended pool /// as volume grows — queue amount is pool volume). Exposure is /// deliberately absent: its surface treatment is HOLD under Tangled -/// issue #1. A paused frame carries amount through geometry alone; -/// animation, when it arrives, will carry rate. Returns the anchor -/// root (a `RackRoot`, so viewers rebuild it with the chassis). +/// issue #1... now DECIDED 2026-07-09: exposure is crimson +/// **particulate residue** — motes settled into a stippled drift of +/// fine angular flecks outside the claim ring, density and spread as +/// the amount, absorbing light rather than emitting it (blood's +/// liquid form is reserved for actual violence). A paused frame +/// carries amount through geometry alone; animation, when it +/// arrives, will carry rate. Returns the anchor root (a `RackRoot`, +/// so viewers rebuild it with the chassis). +#[allow(clippy::too_many_arguments)] pub fn spawn_token_anchors( commands: &mut Commands, meshes: &mut Assets, materials: &mut Assets, demand: usize, knowledge: f32, + exposure: f32, origin: Vec3, parent: Option, ) -> Entity { @@ -761,7 +768,9 @@ pub fn spawn_token_anchors( RackRoot, Transform::from_translation(origin), Visibility::default(), - Name::new(format!("token_anchors_d{demand}_k{knowledge:.1}")), + Name::new(format!( + "token_anchors_d{demand}_k{knowledge:.1}_x{exposure:.1}" + )), )); if let Some(p) = parent { e.insert(ChildOf(p)); @@ -880,9 +889,116 @@ pub fn spawn_token_anchors( )); } } + + // Exposure: the stippled drift — contamination dust settled on the + // floor OUTSIDE the amber claim ring. Density and spread carry the + // amount; the flecks are fine and angular (the clinical contour + // survives at the micro scale) and barely emit — the one material + // in the world that absorbs light instead of shedding it. + if exposure > 0.05 { + spawn_exposure_drift(commands, meshes, materials, exposure, root); + } + root +} + +/// The exposure drift: deterministic golden-angle scatter of angular +/// crimson flecks in an annulus outside the claim ring. No RNG — the +/// pattern is a pure function of the amount, so rebuilds are stable. +fn spawn_exposure_drift( + commands: &mut Commands, + meshes: &mut Assets, + materials: &mut Assets, + exposure: f32, + root: Entity, +) { + let fleck = materials.add(exposure_fleck_material()); + let n = ((exposure * 16.0).ceil() as usize).min(140); + let r0 = 0.52; + let r1 = r0 + 0.16 * exposure.sqrt(); + for i in 0..n { + let theta = i as f32 * 2.399_963; // golden angle + let frac = (i as f32 * 0.618_034) % 1.0; + let r = r0 + (r1 - r0) * frac.sqrt(); + let (sx, sz) = (theta.cos(), theta.sin() * 0.85); + let s = if i % 3 == 0 { 0.030 } else { 0.018 }; + commands.spawn(( + Mesh3d(meshes.add(Cuboid::new(s, 0.008, s * 0.8))), + MeshMaterial3d(fleck.clone()), + Transform::from_translation(Vec3::new(r * sx, 0.006, r * sz)) + .with_rotation(Quat::from_rotation_y(i as f32 * 1.7)), + ChildOf(root), + )); + } +} + +/// Fading stippled footprints — the trail a heat carrier leaves as +/// contamination sheds along their walking path (people-tokens.md, +/// decided 2026-07-09). Tester demo of the visual grammar: the sim's +/// trail state implements with people-tokens (#35). Prints alternate +/// feet along a gentle S-path away from the machine and fade with +/// distance. Returns the trail root (a `RackRoot` for rebuilds). +pub fn spawn_exposure_trail( + commands: &mut Commands, + meshes: &mut Assets, + materials: &mut Assets, + prints: usize, + origin: Vec3, + parent: Option, +) -> Entity { + let root = { + let mut e = commands.spawn(( + RackRoot, + Transform::from_translation(origin), + Visibility::default(), + Name::new(format!("exposure_trail_{prints}")), + )); + if let Some(p) = parent { + e.insert(ChildOf(p)); + } + e.id() + }; + let fleck = materials.add(exposure_fleck_material()); + for p in 0..prints { + let t = p as f32; + let along = 0.62 + 0.30 * t; + let sway = 0.14 * (t * 0.9).sin(); + let foot = if p % 2 == 0 { 0.075 } else { -0.075 }; + // Each print is a tight cluster of flecks; count and size fade + // with distance from the pickup. + let flecks = (4usize).saturating_sub(p / 2).max(1); + let scale = 0.92f32.powi(p as i32); + for f in 0..flecks { + let a = f as f32 * 2.399_963 + t * 0.7; + let rr = 0.012 + 0.024 * ((f as f32 * 0.618_034) % 1.0); + let s = 0.020 * scale; + commands.spawn(( + Mesh3d(meshes.add(Cuboid::new(s, 0.008, s * 0.8))), + MeshMaterial3d(fleck.clone()), + Transform::from_translation(Vec3::new( + along + rr * a.cos(), + 0.006, + sway + foot + rr * a.sin(), + )) + .with_rotation(Quat::from_rotation_y(a * 2.3)), + ChildOf(root), + )); + } + } root } +/// Exposure's material: dark saturated crimson with a whisper of +/// emissive — enough to read in sensor darkness, never a lamp. +fn exposure_fleck_material() -> StandardMaterial { + StandardMaterial { + base_color: scaled(CRIMSON, 0.90), + emissive: CRIMSON.to_linear() * 0.18, + perceptual_roughness: 0.60, + metallic: 0.05, + ..default() + } +} + // ─── The material law, pinned ──────────────────────────────────────────────── #[cfg(test)] diff --git a/src/bin/bevy.rs b/src/bin/bevy.rs index 4029fc3e..284db815 100644 --- a/src/bin/bevy.rs +++ b/src/bin/bevy.rs @@ -1390,6 +1390,8 @@ struct ChassisVisual { /// Knowledge queue quantized to half-units for change detection; /// the mercury volume renders demand / 2.0. knowledge: u8, + /// Exposure queue quantized to half-units; the drift renders / 2.0. + exposure: u8, } /// Root marker for one spawned chassis hierarchy. @@ -1450,7 +1452,7 @@ fn chassis_visual(game: &Game, x: i32, y: i32, tile: TileType) -> ChassisVisual ChassisTier::Absent }; - let (state, mode, load, demand, knowledge) = match machine { + let (state, mode, load, demand, knowledge, exposure) = match machine { Some(m) => { let queues = game .sim @@ -1462,10 +1464,11 @@ fn chassis_visual(game: &Game, x: i32, y: i32, tile: TileType) -> ChassisVisual + queues.get(TokenFamily::Knowledge)) .ceil() as u8; // Token anchors (machine-work.md): demand as countable - // information cubes, knowledge as mercury volume. Exposure - // has no world art yet (HOLD, Tangled issue #1). + // information cubes, knowledge as mercury volume, exposure + // as the stippled drift (decided 2026-07-09). let demand = (queues.get(TokenFamily::Demand).ceil() as u8).min(9); let knowledge = ((queues.get(TokenFamily::Knowledge) * 2.0).ceil() as u8).min(16); + let exposure = ((queues.get(TokenFamily::Exposure) * 2.0).ceil() as u8).min(16); let mode = rack_mode_of(game.sim.work_grid.mode(m.id)); let state = if m.id == game.sim.core.host_machine { RackState::Core @@ -1478,7 +1481,7 @@ fn chassis_visual(game: &Game, x: i32, y: i32, tile: TileType) -> ChassisVisual } else { RackState::Idle }; - (state, mode, load, demand, knowledge) + (state, mode, load, demand, knowledge, exposure) } None => { // Not your machine. A device you control is owned @@ -1491,7 +1494,7 @@ fn chassis_visual(game: &Game, x: i32, y: i32, tile: TileType) -> ChassisVisual } else { RackState::Dead }; - (state, RackMode::DayJob, 0, 0, 0) + (state, RackMode::DayJob, 0, 0, 0, 0) } }; ChassisVisual { @@ -1502,6 +1505,7 @@ fn chassis_visual(game: &Game, x: i32, y: i32, tile: TileType) -> ChassisVisual load: load.min(9), demand, knowledge, + exposure, } } @@ -1650,13 +1654,14 @@ fn spawn_chassis( // the same envelope as the tester. Exposure has no world art yet // (HOLD, Tangled issue #1); the flat sensorium's D/!/K text markers // remain the exact-count read. - if !v.switch && v.state.owned() && (v.demand > 0 || v.knowledge > 0) { + if !v.switch && v.state.owned() && (v.demand > 0 || v.knowledge > 0 || v.exposure > 0) { spawn_token_anchors( commands, meshes, materials, v.demand as usize, v.knowledge as f32 / 2.0, + v.exposure as f32 / 2.0, Vec3::ZERO, Some(e), ); diff --git a/wiki/art/visual-identity.md b/wiki/art/visual-identity.md index 43b86fd2..6fd48b53 100644 --- a/wiki/art/visual-identity.md +++ b/wiki/art/visual-identity.md @@ -22,6 +22,13 @@ sharpened version of Evil Genius's science-base fantasy: crimson marks attention and threat; in overt play, it can become literal blood on porcelain. It is never decorative, never a general accent, and never spent on ordinary UI chrome. +- **Blood is liquid; exposure is dust (adopted 2026-07-09).** The two + crimson materials never share a form. Exposure renders as granular + particulate residue — contamination that settles, tracks, and smears, + fallout rather than gore — and is never a smooth liquid. Pooled liquid + crimson is reserved for literal blood, so that when violence arrives its + image is untouched: in a frame containing both, silhouette and texture + (stipple versus smooth pool) separate them without a second hue. - **Sterile amber is my machine footprint.** Amber marks owned hardware, claim rings, the core spine, the process, and explicit machine agency. Cold signal marks neutral power, screens, or live feeds where a frontend diff --git a/wiki/log/2026-07-09-exposure-residue.md b/wiki/log/2026-07-09-exposure-residue.md new file mode 100644 index 00000000..1a43f115 --- /dev/null +++ b/wiki/log/2026-07-09-exposure-residue.md @@ -0,0 +1,59 @@ +# 2026-07-09 — Exposure decided: particulate residue + footprint trails + +``` +Type: log +``` + +## Intent + +Design session (this chat): Cameron rejected the blood-pool direction +for exposure — a liquid crimson pool would collide with literal blood, +reserved for overt-phase violence — and affirmed particulate residue +with footprint trails ("Sure, why don't we try that"). + +## Decided + +- **Exposure is dust, blood is liquid** (new law bullet, + art/visual-identity.md): the two crimson materials never share a + form. Exposure = granular contamination — fallout, not gore; pooled + liquid crimson is reserved for literal blood. +- **The drift**: machines shed crimson motes settling into a stippled + field of fine angular flecks outside the amber claim ring; density + and spread = amount; it absorbs light (whisper emissive) rather than + glowing. +- **Footprint trails (new mechanic)**: carriers deposit fading + stippled prints along their walking paths — contamination diffuses + on routes, trackable both ways. Sim+save work scoped with + people-tokens (#35); deposit rate/decay/pickup [TUNE], second-order + re-transfer [OPEN]. +- **Person dosimeter**: speckle density climbing the silhouette; + bracket and liquid column both rejected. +- Tangled issue #1 fully closed (answer recorded in the issue body, + label flipped to decision-made). + +## Changed + +- Law: art/visual-identity.md ("Blood is liquid; exposure is dust"). +- Specs: machine-work.md (exposure family bullet DECIDED, status note, + open questions); people-tokens.md (speckle dosimeter, trail + mechanic, criteria 4/4b, open questions). +- Ledger: wiki/log/decisions/2026-07-09.md; ROADMAP #33/#35. +- Art (shared chassis library): `spawn_token_anchors` gains exposure — + deterministic golden-angle drift (no RNG; stable rebuilds); + `spawn_exposure_trail` renders the print-trail grammar; tester `V` + cycles exposure, `B` toggles the trail demo; shot kinds `exposure` + (drift + trail board) and `tokens`/`tokens_max` now include the + drift. The game passes each owned machine's live exposure queue to + the drift; in-game trails wait on the sim mechanic (#35). + +## Observed + +`MISALIGNED_SHOT=exposure`: the drift encircles the amber ring without +touching it (the levee read) and the trail fades away over seven +prints. `tokens_max`: all three families in one frame — rigid teal +cubes, ivory mercury, crimson stipple — unmistakably three materials, +and nothing reads as blood. + +## Checks + +`./tools/check.sh` (full gate — Rust/Bevy change). diff --git a/wiki/log/DEVLOG.md b/wiki/log/DEVLOG.md index 413ef357..20d4d342 100644 --- a/wiki/log/DEVLOG.md +++ b/wiki/log/DEVLOG.md @@ -5,6 +5,20 @@ Type: log ``` Reverse chronological implementation notes. Keep this factual: what changed, why, checks, and spec impact. +## 2026-07-09 - Exposure decided: particulate residue + footprint trails + +- Intent: close the exposure half of issue #1 — Cameron rejected the + blood-pool (blood's image is reserved) and affirmed contamination + dust with footprint trails. +- Changed: law bullet "Blood is liquid; exposure is dust" + (art/visual-identity.md); machine-work + people-tokens amended + (drift, speckle dosimeter, trail mechanic scoped to #35); decisions + ledger; ROADMAP; issue #1 closed and labeled decision-made; drift + + trail art in the shared chassis library (tester V/B keys, `exposure` + shot kind; game drift wired to live exposure queues). +- Checks: full ./tools/check.sh; exposure/tokens_max captures. +- Log: wiki/log/2026-07-09-exposure-residue.md. + ## 2026-07-09 - Design corpus hardening - Intent: make the wiki-as-spec authority model followable and resistant to @@ -20,6 +34,7 @@ Reverse chronological implementation notes. Keep this factual: what changed, why losslessness audit. - Log: wiki/log/2026-07-09-corpus-hardening.md. + ## 2026-07-09 - Token anchors wired into the game render - Intent: complete the integration — demand cubes and knowledge mercury diff --git a/wiki/log/decisions/2026-07-09.md b/wiki/log/decisions/2026-07-09.md index 2fc39771..5c4dbeec 100644 --- a/wiki/log/decisions/2026-07-09.md +++ b/wiki/log/decisions/2026-07-09.md @@ -213,3 +213,22 @@ Type: log hidden page roles, and duplicated binding instructions in tool-specific entry points. The tradeoff is stricter metadata in exchange for authority that can be followed and audited mechanically. +- **2026-07-09 — Exposure is dust, blood is liquid (issue #1 fully closed).** + Cameron rejected the blood-pool direction for exposure because a liquid + crimson pool would collide with literal blood, whose image the identity + reserves for overt-phase violence — exposure must feel like something else. + Decided: exposure is crimson **particulate residue** — fallout, not gore. + Working machines shed faint motes that settle into a stippled drift of fine + angular flecks outside the amber claim ring (density and spread = amount); + it absorbs light rather than emitting it; concealment wells read as a + vacuum draw; Office filings are collected residue solidified into a record. + With the material came a mechanic: carriers deposit **fading stippled + footprint trails** along their walking paths, so contamination diffuses on + people's routes and trails track both ways — inspectors can follow heat to + a machine, and the player can watch a hot worker smear it through the + building. The person dosimeter is speckle density climbing the silhouette + (bracket and liquid column both rejected). New law bullet: "Blood is + liquid; exposure is dust" — the two crimson materials never share a form. + Amended into art/visual-identity.md, mechanics/machine-work.md, and + mechanics/people-tokens.md; trail deposit is sim work scoped with + people-tokens (#35). diff --git a/wiki/mechanics/machine-work.md b/wiki/mechanics/machine-work.md index b4bfacee..147756a4 100644 --- a/wiki/mechanics/machine-work.md +++ b/wiki/mechanics/machine-work.md @@ -21,8 +21,9 @@ Status note: design session 2026-07-08 (Cameron riff, synthesized). token art is the rejected world read). `MISALIGNED_SHOT=tokens` stages game evidence via the queue API. Route/in-flight quanta and consumption animation remain pending. - Exposure's surface treatment remains OPEN under issue #1 — Cameron is - reconsidering the exposure mechanic itself before the material call. + Exposure DECIDED 2026-07-09 (issue #1 fully closed): crimson particulate + residue — motes, drift, footprint trails; never liquid (blood's form is + reserved). Trail deposit is a new mechanic scoped with people-tokens (#35). People as token carriers is specced separately in mechanics/people-tokens.md (DRAFT). Implementation 2026-07-08..09: `src/work_grid.rs` + `Sim`/save own the @@ -303,17 +304,25 @@ that can ride wires; exposure is contamination that cannot. The family kit is: (copied the hero's palette but missed its smooth, softly modeled material), a continuous ribbon (reads as a live signal rather than stored knowledge), and a pearl train (reads as collectible coins). -- **Exposure remains a stain; exact surface treatment is REOPENED [OPEN — - issue #1].** Its physics and carrier roles remain decided: it pools at the - floor/base outside the amber ownership ring, is pulled by concealment wells, - transfers onto people as attention, and materializes at the Office as - filings; report transit is a message, never red cargo on a network wire. The - open visual call is whether the original angular contour remains, or the - hero's smooth blood-pool silhouette becomes the family material and the - person dosimeter becomes a slick liquid column rather than a hard bracket. - Cameron deferred this half on 2026-07-09: he wants to reconsider the - exposure mechanic itself before binding a material, so final exposure and - attention art hold until the mechanic firms. +- **Exposure is particulate residue (DECIDED 2026-07-09, issue #1 closed):** + contamination dust, never a liquid — fallout, not gore (the liquid pool is + reserved for literal blood; see art/visual-identity.md, "Blood is liquid; + exposure is dust"). Working machines shed faint crimson motes that settle + into a **stippled drift** of fine angular flecks at the floor/base outside + the amber ownership ring; density and spread are the amount, so a paused + frame carries the read. It absorbs light rather than emitting it — the one + near-unlit material in a world of signals. Its physics and carrier roles + stand: pulled by concealment wells (a vacuum draw on the dust), transfers + onto people as attention, and materializes at the Office as filings + (collected residue solidified into a record); report transit is a message, + never red cargo on a network wire. NEW (decided with the material): carried + heat also **deposits fading stippled footprints** along a carrier's walking + path — contamination diffuses through the building on people's routes, and + trails are trackable both ways (an inspector can follow a hot trail to your + machine; you can watch a contaminated worker smear your heat through rooms + you do not control). Deposit rate, print decay, and pickup fraction are + [TUNE] with teeth; the trail mechanic itself is sim work scoped with + people-tokens.md (#35). All three anchors can be present at once. The current Bevy and terminal rule that selects one `D` / `!` / `K` label by priority is staging, not the target: @@ -339,7 +348,11 @@ the only rate/amount cue. ## Open questions — [OPEN] -- **Tangled issue #1 — exposure surface treatment:** keep the angular +- (Resolved 2026-07-09: exposure surface treatment — crimson particulate + residue with footprint trails; issue #1 fully closed. The angular instinct + survives at the fleck scale; the blood-pool silhouette is reserved for + literal blood.) +- **[historical] Tangled issue #1 — exposure surface treatment:** keep the angular clinical contour, or adopt the hero's smooth blood-pool / liquid-column treatment? Deferred 2026-07-09: Cameron wants to reconsider the exposure mechanic itself before the material call. (The knowledge half is DECIDED: diff --git a/wiki/mechanics/people-tokens.md b/wiki/mechanics/people-tokens.md index 1d0775e1..5d1fd5bc 100644 --- a/wiki/mechanics/people-tokens.md +++ b/wiki/mechanics/people-tokens.md @@ -12,11 +12,12 @@ Status note: design session 2026-07-08 (Cameron riff, part three, influence token — trust from useful work, deceit strips crimson); gauntlets, trust-as-logistics couriers, and Assurance inspections added as decided directions. Cameron affirmed the attention geometry - 2026-07-09: a crimson dosimeter bracket fills upward beside the silhouette; - the amber asset mark is independent, so a hot asset shows both. Later that - day the bracket's hard/angular material treatment was REOPENED with the - hero-material pass (Tangled issue #1); the independent geometry channel - remains required. + 2026-07-09: attention fills upward beside the silhouette; the amber asset + mark is independent, so a hot asset shows both. The material call closed + the same day (issue #1): exposure is particulate residue, so the dosimeter + is speckle density climbing the silhouette (bracket and liquid column + rejected), and carriers deposit fading footprint trails — a new decided + mechanic scoped to this spec's implementation. Firms after machine-work.md; do not implement ahead of it. Stage: B1 — The Basement Design: @@ -124,17 +125,32 @@ Decided 2026-07-09: attention gets an independent crimson geometry channel beside the silhouette; it fills from feet to head without painting the body red (which would read as injury or blood). The amber asset mark is an independent underfoot claim ring, so an asset can still become hot: ownership and exposure -never overwrite one another. **Exact treatment REOPENED [OPEN — Tangled issue -#1]:** retain the thin hard dosimeter bracket, or inherit the hero's liquid -softness as a slim glassy column with a rounded crimson meniscus. See the -material study in -[machine-work.md](machine-work.md#token-visual-grammar--partly-reopened-2026-07-09). +never overwrite one another. **Treatment DECIDED later the same day (issue #1 +closed): speckle density.** Exposure is particulate residue everywhere +(machine-work.md; art/visual-identity.md "Blood is liquid; exposure is dust"), +so a carrier's dosimeter is dust on the silhouette: crimson speckle climbing +from the feet, density and height laddering with carried attention — a lightly +dusted passerby versus someone crusted to the shoulders. Both the hard bracket +and the liquid column are rejected (the bracket reads as UI chrome; the liquid +column collides with blood's reserved form). + +**Footprint trails (NEW, decided 2026-07-09 with the material):** a carrier +does not only hold heat — they shed it, depositing fading stippled footprints +along their walking path. Contamination diffuses through the building on +people's routes; trails read both ways (an inspector follows a hot trail back +to the machine; the player watches a contaminated worker smear heat through +uncontrolled rooms). Deposit rate, print decay, pickup fraction, and whether +deposited prints re-transfer to other walkers are [TUNE]/[OPEN] below; the +trail is sim+save work implemented with this spec, not ahead of it. ## Open questions — [OPEN] - Whether attention decays on a person or only transfers onward (to the Assurance Office aggregate — detection.md). - Pickup mechanics: proximity radius vs same-room vs interaction. +- Footprint trails: whether deposited prints re-transfer to other + walkers (second-order spread), and whether trail deposit reduces the + carrier's own load (shedding) or only copies a decaying marker. - Whether staff dropping work are visible from the start (they enter seen space; presumably yes via existing senses). - Inspection triggers and cadence (filings thresholds in @@ -159,10 +175,12 @@ if wear alone does not hold. against detection.md's suspicion) — no parallel influence token or trust counter. 4. The person visual read distinguishes unaware / rising-attention / asset in - a grayscale screenshot and in the terminal: the selected independent - crimson attention geometry fills from feet to head, while an amber underfoot - asset mark can coexist with it on a hot asset. **BLOCKED on issue #1:** hard - bracket versus slick liquid column. + a grayscale screenshot and in the terminal: crimson speckle density climbs + the silhouette from the feet (dust, never a painted-red body), while an + amber underfoot asset mark can coexist with it on a hot asset. +4b. Footprint trails: a carrier deposits fading stippled prints along their + path; a trail is followable in both frontends, and its prints decay on a + [TUNE] clock. 5. A gauntlet designation on an end-user computer strips measurable exposure from a person who uses it, without creating or routing an influence token. 6. Every rate/threshold lives in sim-mechanics.md as [TUNE] actuals. diff --git a/wiki/process/ROADMAP.md b/wiki/process/ROADMAP.md index 2771467a..4c6a645c 100644 --- a/wiki/process/ROADMAP.md +++ b/wiki/process/ROADMAP.md @@ -534,9 +534,11 @@ is retired — flat materials, Pixel Lab scrubbed.) every owned rack, from live queue depths; flat D/!/K glyphs stay flat-mode-only; sessions log/2026-07-09-token-anchors-tester.md and log/2026-07-09-tokens-in-game.md). In-flight quanta + consumption - animation ride behind it. Exposure's surface treatment stays HOLD under - Tangled issue #1 — Cameron is reconsidering the exposure mechanic itself - before the material call. Fixed anchors, demand docket, + animation ride behind it. Exposure DECIDED 2026-07-09 (issue #1 fully + closed): crimson particulate residue — motes, stippled drift outside the + ring, footprint trails on carriers; never liquid (blood's form is + reserved). Drift art may proceed; the trail mechanic is sim+save scoped + with #35. Fixed anchors, demand docket, simultaneous queues, paused/grayscale read, and the terminal mixed marker remain decided and may be prototyped frontend-only without taking the sim+save conflict slot. Decide whether Schemes becomes its own mode or stays @@ -564,7 +566,9 @@ is retired — flat materials, Pixel Lab scrubbed.) concealment keeps people gray; trust accrues from useful work; deceit and gauntlets strip crimson rather than routing a separate influence token; attention uses an independent crimson geometry channel beside the silhouette; - hard bracket versus slick liquid column is open under Tangled issue #1. + the dosimeter is DECIDED 2026-07-09 (issue #1 closed): speckle density + climbing the silhouette, plus fading footprint trails deposited along the + carrier's path (a new decided mechanic implemented with this spec). - **HOLD:** extends #33's token economy and re-expresses detection.md/social.md — the machine-work mechanics must firm first. The token taxonomy, social verb direction, and carrier visual language are now -- 2.51.2