diff --git a/wiki/engineering/env.md b/wiki/engineering/env.md
--- a/wiki/engineering/env.md
+++ b/wiki/engineering/env.md
@@ -47,7 +47,7 @@
 
 | Variable | Surface | Values | Effect |
 |---|---|---|---|
-| `MISALIGNED_SHOT` | `misaligned-bevy` | `flat`, `hall`, `hall-material`, `floor-lights-close`, `wide`, `close`, `dark`, `zoomin`, `zoomout`, `digital-reach`, `intel`, `tokens`, `thoughtflow`, `thoughtflow-wide`, `visual-proof`, `person-proof`, `exposure-record`, `exposure-overflow`, `service-shift-real`, `service-shift-digital`, `service-incident-resolved`, `signal`, `ears`, `ears-digital`, `eyes-white`, `eyes-form`, `consume-demand`, `consume-thought`, `produce-think`, `draw-lie`, `opening`, `opening-digital`, `clinical-threat`, `operator-pressure`, `hover-menu`, `first-think`, `menu`, `worklight`, `worklightoff`, `wake1`, `wake2`, `wake3` | Dev screenshot harness: stage a deterministic scenario, settle, report the staged `RenderMode` dialect, save one PNG, then exit. `tools/bevy-headless.sh` consumes that runtime dialect rather than maintaining a second kind list: REAL requires the material fog audit, while DIGITAL remains screenshot evidence because material fog has no entity surface there. `hall` / `hall-material` frame all six Foundation rows in the flat/material views with Eyes and one staged owned expansion; `floor-lights-close` uses the same hall staging but approaches the unobstructed southern row at machine/floor scale; `digital-reach` holds controlled, tapped, reachable, closed-segment, and air-gap reach states in one DIGITAL survey frame; `visual-proof` stages one-move/one-slug Thought evidence in an earned room; `person-proof` stages a camera-earned volumetric person; `service-shift-real` / `service-shift-digital` fire one real favor-build reservoir while Marcus's authored shift is off-site, then hold the carried packet at its real hall endpoint in paired view dialects; `service-incident-resolved` advances that exact scenario once so the real graph edge lands and the carried mark disappears; `exposure-record` places six actual Exposure units on the live host in telemetry darkness while `exposure-overflow` places eighteen to prove the fixed seven-slot rack and consolidated final tab; `intel` stages tick-zero intel tiers (no camera tap); `tokens` enqueues D5/T4 on the host; `thoughtflow` / `thoughtflow-wide` stage the THINK fluid (slugs, meniscus, filament snap) at close and wide framing; `signal` focuses the known environmental monitor before any feed tap to capture its cold-signal presence cue; `ears` / `ears-digital` stage the same semantic audio capture in REAL or DIGITAL, pulsing only at the environmental monitor while spatial fog remains unchanged; `eyes-white` / `eyes-form` freeze the first-Eyes source held white and then contracted around the resolving chassis; `consume-demand` / `consume-thought` run the host through a sim-authored WORK queue swallow or passive-core Thought draw; `produce-think` / `draw-lie` capture sim-authored Thought/record production or the rigid record transfer into a staged LIE well; `opening` / `opening-digital` freeze the untouched tick-zero material or DIGITAL view; `clinical-threat` stages that DIGITAL opening with one real pilot strike so the compact rail exception is observable; `operator-pressure` adds one concerned observer and a full recording buffer to that strike so the compact frame proves a single THREAT, a promoted buffer NEXT, and no stale world cue; `hover-menu` captures the resting WORK/THINK/LIE line beside the server via reticule focus (no pointer), while `first-think` stages the opening Thought route and captures amber `1 WORK` beside current THINK as the panic exit; `menu` opens the context menu on the tapped environmental monitor; `worklight` / `worklightoff` pair the dev work light on and off; `wake1/2/3` freeze the wake choreography at the stutter flash, the column, and the pull-back. |
+| `MISALIGNED_SHOT` | `misaligned-bevy` | `flat`, `hall`, `hall-material`, `floor-lights-close`, `wide`, `close`, `dark`, `zoomin`, `zoomout`, `digital-reach`, `build-route-families`, `build-deceive-routes`, `build-committed-route`, `build-switch-digital`, `build-switch-real`, `intel`, `tokens`, `thoughtflow`, `thoughtflow-wide`, `visual-proof`, `person-proof`, `exposure-record`, `exposure-overflow`, `service-shift-real`, `service-shift-digital`, `service-incident-resolved`, `signal`, `ears`, `ears-digital`, `eyes-white`, `eyes-form`, `consume-demand`, `consume-thought`, `produce-think`, `draw-lie`, `opening`, `opening-digital`, `clinical-threat`, `operator-pressure`, `hover-menu`, `first-think`, `menu`, `worklight`, `worklightoff`, `wake1`, `wake2`, `wake3` | Dev screenshot harness: stage a deterministic scenario, settle, report the staged `RenderMode` dialect, save one PNG, then exit. `tools/bevy-headless.sh` consumes that runtime dialect rather than maintaining a second kind list: REAL requires the material fog audit, while DIGITAL remains screenshot evidence because material fog has no entity surface there. `hall` / `hall-material` frame all six Foundation rows in the flat/material views with Eyes and one staged owned expansion; `floor-lights-close` uses the same hall staging but approaches the unobstructed southern row at machine/floor scale; `digital-reach` holds controlled, tapped, reachable, closed-segment, and air-gap reach states in one DIGITAL survey frame; `build-route-families`, `build-deceive-routes`, and `build-committed-route` stage the shared network-link family, candidate, and durable receipt pages; `build-switch-digital` / `build-switch-real` stage the same exact inert small-switch footprint on one earned growable pad before any source, actuator, device, or graph effect; `visual-proof` stages one-move/one-slug Thought evidence in an earned room; `person-proof` stages a camera-earned volumetric person; `service-shift-real` / `service-shift-digital` fire one real favor-build reservoir while Marcus's authored shift is off-site, then hold the carried packet at its real hall endpoint in paired view dialects; `service-incident-resolved` advances that exact scenario once so the real graph edge lands and the carried mark disappears; `exposure-record` places six actual Exposure units on the live host in telemetry darkness while `exposure-overflow` places eighteen to prove the fixed seven-slot rack and consolidated final tab; `intel` stages tick-zero intel tiers (no camera tap); `tokens` enqueues D5/T4 on the host; `thoughtflow` / `thoughtflow-wide` stage the THINK fluid (slugs, meniscus, filament snap) at close and wide framing; `signal` focuses the known environmental monitor before any feed tap to capture its cold-signal presence cue; `ears` / `ears-digital` stage the same semantic audio capture in REAL or DIGITAL, pulsing only at the environmental monitor while spatial fog remains unchanged; `eyes-white` / `eyes-form` freeze the first-Eyes source held white and then contracted around the resolving chassis; `consume-demand` / `consume-thought` run the host through a sim-authored WORK queue swallow or passive-core Thought draw; `produce-think` / `draw-lie` capture sim-authored Thought/record production or the rigid record transfer into a staged LIE well; `opening` / `opening-digital` freeze the untouched tick-zero material or DIGITAL view; `clinical-threat` stages that DIGITAL opening with one real pilot strike so the compact rail exception is observable; `operator-pressure` adds one concerned observer and a full recording buffer to that strike so the compact frame proves a single THREAT, a promoted buffer NEXT, and no stale world cue; `hover-menu` captures the resting WORK/THINK/LIE line beside the server via reticule focus (no pointer), while `first-think` stages the opening Thought route and captures amber `1 WORK` beside current THINK as the panic exit; `menu` opens the context menu on the tapped environmental monitor; `worklight` / `worklightoff` pair the dev work light on and off; `wake1/2/3` freeze the wake choreography at the stutter flash, the column, and the pull-back. |
 | `MISALIGNED_SHOT` | `misaligned-assets` | `dead`, `foreign`, `idle`, `busy`, `core`, canonical modes `work`, `think`, `lie` plus the legacy screenshot aliases `dayjob` (= work), `research`/`operations`/`ops` (= think), `conceal` (= lie) — each optionally suffixed `_ladder`/`_ring`/`_wash` — `lineup[_<style>]`, `modes[_<style>]`, `tokens`, `tokens_max`, `exposure`, `splash` | Tester screenshot harness: stage the named board, capture, exit (art/asset-tester.md documents each board; the aliases are capture-compat only, not player modes). |
 | `MISALIGNED_SHOT` | `misaligned-effects` | `route`, `pools`, `both`, `stress`, optionally suffixed `_close`, `_medium`, or `_far` | Fixed-timestep Thought-effects-lab capture; writes the requested route/pool frame and exits. |
 | `MISALIGNED_SHOT_PATH` | game and art binaries | file path | Output path for the captured PNG (default `misaligned_shot_<kind>.png`). |
diff --git a/wiki/interface/action-vocabulary.md b/wiki/interface/action-vocabulary.md
--- a/wiki/interface/action-vocabulary.md
+++ b/wiki/interface/action-vocabulary.md
@@ -174,6 +174,7 @@
 | Canonical action | Target | Meaning | Support / owner |
 |---|---|---|---|
 | **PROPOSE LINK** | Two network devices | Pin an inert build intent between the endpoints. No world edge exists yet. | LIVE — building |
+| **PROPOSE SWITCH** | One earned empty growable pad | Pin one exact inert small-switch footprint. No device, graph node, source object, payment, signature, or actuator exists yet. | LIVE declaration — building; realization routes absent |
 | **CANCEL INTENT** | Pending build intent | Abandon the proposed work before completion. | LIVE — building |
 | **ROBOT-BUILD** | Pending build intent | Reserved for a future controlled robot actuator. | **STUB** — registry only; hidden from all player surfaces until the robot system is playable |
 
@@ -264,7 +265,7 @@
 | `intensity <machine|selected> light|medium|hard` | SET INTENSITY |
 | `research <efficiency|tradecraft|perception|routing>` | SET RESEARCH TRACK |
 | `tap`, `untap`, `take`, `scan`, `compromise` | TAP, UNTAP, TAKE, SCAN, COMPROMISE SWITCH |
-| `propose-link`, `cancel-intent`, `favor <person> build <intent>`, `deceive <person> build <intent>` | Construction actions above |
+| `propose-link`, `propose-switch <x> <y>`, `cancel-intent`, `favor <person> build <intent>`, `deceive <person> build <intent>` | Construction actions above. PROPOSE SWITCH declares only the exact footprint; its route families are not live yet. |
 | `review recordings [<recording-or-aggregate-id>]`, `auto-review` | Exact/aggregate REVIEW and AUTO-REVIEW POLICY above; bare `auto-review` preserves the implemented pooled root toggle. Recursive rule editing uses bound `actions intel <id>` / `act <row> intel <id>` controls and neither route accepts a person target. |
 | `message`, `favor`, `deceive`, `recruit`, `task` | Person-bound social actions above |
 | `actions archetype <id>`, then `act <row> archetype <id>` | CREATE PERSONA through the selected PERSONAS protocol row; direct `persona` is retired |
diff --git a/wiki/interface/context-menu.md b/wiki/interface/context-menu.md
--- a/wiki/interface/context-menu.md
+++ b/wiki/interface/context-menu.md
@@ -54,7 +54,11 @@
   nested-page owner. One build-route entry opens family-first and then exact
   candidate pages; terminal and Bevy consume the same `HumanMenuPage` tree,
   show the selected candidate's explanatory receipt, and Esc back one level
-  at a time. This does not reopen the implemented spatial-menu baseline.
+  at a time. Its later R2a placement foundation adds one ordinary shared tile
+  row: an earned empty growable pad exposes PROPOSE SWITCH; once pinned, that
+  exact pad exposes CANCEL INTENT while the inert footprint remains a building
+  receipt rather than a device action. Agent direct syntax dispatches the same
+  core legality. This does not reopen the implemented spatial-menu baseline.
   2026-07-10 vocabulary survey: action-vocabulary.md now owns canonical
   player-facing names and the LIVE/STUB/alias/retired classification.
   2026-07-10 action-contract pass: `ActionKind` metadata is the shared
diff --git a/wiki/log/2026-07-15-building-small-switch-placement.md b/wiki/log/2026-07-15-building-small-switch-placement.md
new file mode 100644
--- /dev/null
+++ b/wiki/log/2026-07-15-building-small-switch-placement.md
@@ -0,0 +1,84 @@
+# One exact place before one exact route
+
+```
+Type: log
+```
+
+## Finding
+
+The route composer could preserve and explain a network-link proposal, but it
+had not yet proved its more important spatial boundary: choosing **where** a
+thing should exist before choosing **how** it gets there. General machine
+placement would have pulled capability products and hardware law into the
+slice too early. The small switch already named by building.md was the narrow
+fixture: one tile, one device class, and no honest realization source yet.
+
+## Change
+
+An earned empty growable pad now exposes **PROPOSE SWITCH**. Declaration writes
+one `SmallSwitch { x, y }` build intent and projects one
+`BuildGhostGeometry::Footprint` receipt. The existing save-v31 intent
+collection persists the new recipe without another executor or parallel
+placement store.
+
+The declaration is deliberately inert:
+
+- no ReachNet device, node, edge, ownership, or feed appears;
+- no machine, part, procurement source, source object, account movement,
+  Thought sink, person/persona binding, signature, or route sheet appears;
+- a second open footprint cannot target the same pad; and
+- an ordinary real action does not defer to the proposal. If BUY RACK occupies
+  the pad first, the proposal remains as blocked history rather than reserving
+  the world, disappearing, or moving elsewhere.
+
+The pad row changes from **propose a small switch on this pad** to
+**cancel small-switch intent** after declaration. Agent mode accepts
+`propose-switch <x> <y>` through the same core legality and reports the same
+recipe, coordinates, lifecycle, and absent route families through `intents`.
+Cancellation retains the receipt but removes the proposed-world ghost.
+
+Terminal draws one hollow `□` footprint at the exact cell in DIGITAL and REAL.
+Bevy DIGITAL draws nested hollow plan squares; REAL draws one low hollow
+equipment volume with corner risers. Both adapters consume the same projected
+geometry and filter out cancelled history. Neither frontend walks serialized
+intent internals or invents a live switch body.
+
+## Evidence
+
+- Core regression crosses unearned rejection, exact pad declaration,
+  duplicate rejection, unchanged device/machine/signature state, absent route
+  sheet, action-row swap, save/resume, real pad occupation, honest blocker, and
+  cancellation.
+- Terminal regression requires one exact hollow footprint cell while open and
+  none after cancellation.
+- Agent regression executes the public coordinate command and requires the
+  shared small-switch receipt without FAVOR or DECEIVE candidates.
+- Independent read-only review challenged both occupied-pad handling and the
+  empty route-sheet boundary. The existing growable-bay machine exclusion and
+  BUY RACK regression held; the review did expose an earned-person fallback,
+  now explicitly gated so even known people and a usable persona cannot create
+  blocked link routes for the placement recipe.
+- Bevy adapter regression requires DIGITAL and REAL to receive the same exact
+  open footprint and no cancelled footprint.
+- Deterministic `build-switch-digital` and `build-switch-real` frames exercise
+  the production screenshot path and material fog audit for visual review.
+  The exact final 2560×1440 PNGs at `/tmp/build-switch-digital.png` and
+  `/tmp/build-switch-real.png` were opened after capture. DIGITAL showed one
+  restrained nested amber plan square on the selected empty pad, distinct from
+  the owned host body; REAL showed one low hollow amber equipment volume with
+  its floor/top separation and corner risers readable inside the attention
+  brackets. Neither frame showed a switch chassis, device glyph, or graph
+  edge. The REAL run passed the production fog audit.
+
+## Boundary
+
+This implements the R2a placement foundation, not a free switch. Procurement,
+one exact human route, one exact repurpose source, complete route previews,
+commitment stages, delivery, installation, and the actual ReachNet device all
+remain absent. Those routes must bind real owner-system carriers before the
+small-switch recipe can be realized.
+
+Defense: One renderer-neutral recipe and exact coordinate now own the proposed
+world change. Tests pin that declaration has no causal effect, save/resume
+cannot retarget it, independent reality can block it, and every frontend reads
+the same geometry without implying a source or actuator that does not exist.
diff --git a/wiki/log/DEVLOG.md b/wiki/log/DEVLOG.md
--- a/wiki/log/DEVLOG.md
+++ b/wiki/log/DEVLOG.md
@@ -106,6 +106,11 @@
 - Intent: (see session log)
 - Log: [wiki/log/2026-07-15-canonical-build-intent-endpoints.md](2026-07-15-canonical-build-intent-endpoints.md)
 
+## 2026-07-15 - One exact place before one exact route
+
+- Intent: (see session log)
+- Log: [wiki/log/2026-07-15-building-small-switch-placement.md](2026-07-15-building-small-switch-placement.md)
+
 ## 2026-07-15 - Build cancellation preserves the trace
 
 - Intent: (see session log)
diff --git a/wiki/mechanics/building.md b/wiki/mechanics/building.md
--- a/wiki/mechanics/building.md
+++ b/wiki/mechanics/building.md
@@ -30,8 +30,15 @@
   those persisted routes: an open exact reservoir closes without refunding
   partial Thought, landed social/message/evidence records remain, an injected
   email may still arrive and be read, and no cancelled route can resume its
-  physical tail. This remains partial R2/R3/R7, not composer completion:
-  procurement, repurposing, and switch placement remain outstanding.
+  physical tail. The R2a placement foundation now adds a second recipe: an
+  earned empty growable pad exposes PROPOSE SWITCH, which persists one exact
+  inert small-switch footprint in the existing v31 intent collection and
+  projects the same hollow ghost through terminal, Bevy DIGITAL/REAL, and
+  agent mode. It creates no device, graph node, cost, signature, source item,
+  or actuator sheet; ordinary world changes do not defer to the proposal and
+  instead leave it honestly blocked if they occupy its pad. This remains
+  partial R2/R3/R7, not composer completion: procurement, repurposing, and
+  every switch realization route remain outstanding.
 
 Stage: B1 — The Basement
 Work order: building-route-composer
@@ -172,6 +179,23 @@
 composer must also expose one device/module-install recipe using the same
 placement and causal-route contract; that integration may land with the
 hardware work rather than pretending every machine product is already migrated.
+
+The implemented R2a foundation stops at that recipe declaration boundary. An
+earned empty pad exposes **PROPOSE SWITCH** and produces one saved
+`small-switch @ (x, y)` intent whose geometry is one exact tile. The open
+receipt is a hollow proposed equipment footprint in terminal and both Bevy
+dialects; cancellation preserves the inspectable receipt and removes only the
+ghost. Declaration does not create or reserve a `ReachNet` device, node, edge,
+machine, part, account movement, signature, Thought sink, source object, or
+actuator. If an ordinary existing path such as BUY RACK occupies the pad first,
+the switch intent remains visible and becomes blocked with `the proposed pad
+is no longer empty`; it does not cancel, retarget, or block the real action.
+Only one open placement intent may name the same pad.
+
+This slice deliberately provides no route sheet for the small switch. A switch
+cannot be realized until procurement, exact-human, and exact-repurpose
+candidates each have real owner-system carriers and satisfy R2-R6. The absence
+of candidates is part of the executable boundary, not an implied free source.
 
 Existing `BUY RACK`, Foundation-hall preparations, and other direct build-adjacent
 routes remain their implemented baseline until deliberately migrated. This
@@ -316,6 +340,16 @@
 people, source-owner verbs for procurement/repurposing. “Favor-build” and
 “forge-order” may survive as compatibility aliases, never authored menu copy.
 
+For the live R2a foundation, focusing an earned empty growable pad adds one
+terse **propose a small switch on this pad** row. After declaration, that row is
+replaced by **cancel small-switch intent** on the exact pad while ordinary
+independent pad actions remain governed by their owners. Agent mode exposes
+`propose-switch <x> <y>` and the same CANCEL INTENT route; `intents` prints the
+same recipe, coordinate, lifecycle, and absence of route candidates. The
+terminal hollow footprint and Bevy DIGITAL/REAL hollow equipment volume both
+consume `BuildGhostGeometry::Footprint`; neither frontend infers placement from
+saved internals or spawns a live device silhouette.
+
 The live second foundation implements that navigation only for the existing
 network-link person actuators. One terse route-sheet row replaces the old
 FAVOR×DECEIVE candidate product on the human root. The next page lists FAVOR
@@ -406,16 +440,20 @@
 appropriate composition, not a second or abbreviated Bevy truth.
 
 **Defense:** The shared ghost and route-sheet projections are the executable
-R1/R4/R5 plus partial R2/R3/R7 boundary. Declaration and preview remain inert;
+R1/R4/R5/R6 plus the R2a placement and partial R2/R3/R7 boundary. Declaration
+and preview remain inert;
 reading or navigating the sheet spends nothing and changes no reach,
 reservation, relationship, message, or save state. Candidate legality and
 execution share one core helper. Commitment writes exact ids before opening
 the owning Thought reservoir; real social, message, schedule, graph, and
 detection transition points append ordered durable outcomes. Save/resume and
 every frontend consume that same record rather than reconstructing a route or
-choosing a replacement. Procurement, repurpose, switch placement, complete R4
-bands for those future families, and staged execution/cancellation for those
-not-yet-playable families remain absent, so the work order stays IN PROGRESS.
+choosing a replacement. The small-switch recipe persists and renders only its
+exact footprint, while its empty route sheet prevents a declaration from
+smuggling in a source or actuator. Procurement, repurpose, switch realization,
+complete R4 bands for those future families, and staged execution/cancellation
+for those not-yet-playable families remain absent, so the work order stays IN
+PROGRESS.
 
 ## Acceptance criteria
 
@@ -471,11 +509,16 @@
     through one exact usable persona for DECEIVE, and one exact repurpose
     source; changing access, schedule, funds, persona integrity, ownership, or
     source availability deterministically updates readiness/blockers.
-R2a. A small switch can be ghosted on an earned growable pad before the player
+R2a. **IMPLEMENTED placement foundation.** A small switch can be ghosted on an earned growable pad before the player
     selects procurement, one exact human route, or one exact repurpose source.
     The footprint is committed before the realization family and remains the
-    same world intent across all routes. General machine products remain outside
-    this slice until their owning specs supply a recipe.
+    same world intent across all routes. Declaration saves one exact inert
+    footprint and creates no device, graph change, source, cost, signature, or
+    actuator; if another real action occupies the pad, the proposal blocks
+    rather than reserving or retargeting it. Terminal, Bevy DIGITAL/REAL, and
+    agent mode consume the same receipt. Realization families remain the
+    unimplemented continuation. General machine products remain outside this
+    slice until their owning specs supply a recipe.
 R3. Every candidate binds exact world ids and a canonical existing action chain.
     No generic Influence resource, generic STEAL command, frontend-only
     eligibility rule, or “pay and materialize” path exists.
diff --git a/crates/misaligned-bevy/src/main.rs b/crates/misaligned-bevy/src/main.rs
--- a/crates/misaligned-bevy/src/main.rs
+++ b/crates/misaligned-bevy/src/main.rs
@@ -181,10 +181,23 @@
     sim.build_intent_projection()
         .into_iter()
         .filter(|receipt| receipt.ghost)
-        .filter_map(|receipt| {
-            receipt
-                .geometry
-                .map(|BuildGhostGeometry::Link { start, end }| (start, end))
+        .filter_map(|receipt| match receipt.geometry {
+            Some(BuildGhostGeometry::Link { start, end }) => Some((start, end)),
+            _ => None,
+        })
+        .collect()
+}
+
+/// Exact proposed equipment footprints from the same shared projection.
+/// A footprint marks a proposed future body; it is not a live device, reach
+/// node, or reservation against independent world actions.
+fn build_ghost_footprints(sim: &Sim) -> Vec<(i32, i32)> {
+    sim.build_intent_projection()
+        .into_iter()
+        .filter(|receipt| receipt.ghost)
+        .filter_map(|receipt| match receipt.geometry {
+            Some(BuildGhostGeometry::Footprint { at }) => Some(at),
+            _ => None,
         })
         .collect()
 }
@@ -559,7 +572,7 @@
     Secondary,
 }
 
-/// Dev screenshot harness (env `MISALIGNED_SHOT=flat|hall|hall-material|opening|opening-digital|clinical-threat|operator-pressure|digital-reach|build-route-families|build-deceive-routes|build-committed-route|wide|close|dark|
+/// Dev screenshot harness (env `MISALIGNED_SHOT=flat|hall|hall-material|opening|opening-digital|clinical-threat|operator-pressure|digital-reach|build-route-families|build-deceive-routes|build-committed-route|build-switch-digital|build-switch-real|wide|close|dark|
 /// zoomin|zoomout|intel|tokens|thoughtflow|first-think|visual-proof|person-proof|exposure-record|exposure-overflow|service-shift-real|service-shift-digital|service-incident-resolved|signal|ears|ears-digital|eyes-white|eyes-form|operations-links|
 /// hover-menu|read-receipt|held-choice|two-pane|standing-read|menu|recruit-menu|operations|operations-intel|operations-personas|worklight|worklightoff`, path via
 /// `MISALIGNED_SHOT_PATH`): stages a scenario,
@@ -2338,6 +2351,30 @@
             },
             pos: None,
         });
+        game.drain();
+        return;
+    }
+    // Small-switch placement foundation (building.md R2a): one exact saved
+    // inert footprint on an earned pad, shown by both visual dialects before
+    // any procurement, human, repurpose, device, or graph effect exists.
+    if matches!(kind, "build-switch-digital" | "build-switch-real") {
+        mode.material = kind == "build-switch-real";
+        mode.zoom = if mode.material { 1.0 } else { mode.zoom };
+        game.sim.dayjob.jobs_assigned = 1;
+        let at = game.sim.growable_bays()[0];
+        game.sim
+            .declare_small_switch_intent(at.0, at.1)
+            .expect("shot stages one earned switch footprint");
+        if mode.material {
+            // The screenshot fixture stages an earned exact picture, not a
+            // blueprint leak; REAL remains governed by ordinary Seen fog.
+            for y in at.1 - 3..=at.1 + 3 {
+                for x in at.0 - 5..=at.0 + 5 {
+                    game.sim.seen.insert((x, y));
+                }
+            }
+        }
+        game.set_cursor(at.0, at.1);
         game.drain();
         return;
     }
@@ -5911,6 +5948,23 @@
             gizmos.line(start.lerp(end, t0), start.lerp(end, t1), ghost);
         }
     }
+    for (x, y) in build_ghost_footprints(&game.sim) {
+        let floor = grid_to_world_3d(x, y, 0.06);
+        let top = grid_to_world_3d(x, y, 0.48);
+        let iso_floor = Isometry3d::new(floor, Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2));
+        let iso_top = Isometry3d::new(top, Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2));
+        let ghost = Color::srgba(0.85, 0.75, 0.35, 0.42);
+        gizmos.rect(iso_floor, Vec2::splat(0.72), ghost);
+        gizmos.rect(iso_top, Vec2::splat(0.62), ghost);
+        for offset in [
+            Vec3::new(-0.31, 0.0, -0.31),
+            Vec3::new(0.31, 0.0, -0.31),
+            Vec3::new(-0.31, 0.0, 0.31),
+            Vec3::new(0.31, 0.0, 0.31),
+        ] {
+            gizmos.line(floor + offset, top + offset * 0.82, ghost);
+        }
+    }
     // Attention channel on the focused tile: amber, non-humanoid, same anchor.
     // Three close rails give the base physical visual weight at the opening
     // camera instead of leaving one hairline ring around the presence beam.
@@ -7617,6 +7671,20 @@
             gizmos.line_2d(start.lerp(end, t0), start.lerp(end, t1), ghost);
         }
     }
+    for (x, y) in build_ghost_footprints(&game.sim) {
+        let center = grid_to_world(x, y, 0.0).truncate();
+        let ghost = Color::srgba(0.85, 0.75, 0.35, 0.34);
+        gizmos.rect_2d(
+            Isometry2d::from_translation(center),
+            Vec2::splat(TILE_SIZE * 0.66),
+            ghost,
+        );
+        gizmos.rect_2d(
+            Isometry2d::from_translation(center),
+            Vec2::splat(TILE_SIZE * 0.42),
+            Color::srgba(0.85, 0.75, 0.35, 0.18),
+        );
+    }
 }
 
 #[cfg(test)]
@@ -7646,6 +7714,21 @@
 
         sim.cancel_intent(id);
         assert!(build_ghost_links(&sim).is_empty());
+    }
+
+    #[test]
+    fn both_bevy_dialects_receive_the_exact_open_footprint_only() {
+        let mut sim = Sim::with_seed(8);
+        sim.dayjob.jobs_assigned = 1;
+        let at = sim.growable_bays()[0];
+        let id = sim
+            .declare_small_switch_intent(at.0, at.1)
+            .expect("declare switch footprint");
+        assert_eq!(build_ghost_footprints(&sim), vec![at]);
+        assert!(build_ghost_links(&sim).is_empty());
+
+        sim.cancel_intent(id);
+        assert!(build_ghost_footprints(&sim).is_empty());
     }
 }
 
diff --git a/crates/misaligned-core/src/actions.rs b/crates/misaligned-core/src/actions.rs
--- a/crates/misaligned-core/src/actions.rs
+++ b/crates/misaligned-core/src/actions.rs
@@ -161,6 +161,10 @@
         a: u32,
         b: u32,
     },
+    ProposeSwitch {
+        x: i32,
+        y: i32,
+    },
     CancelIntent(u64),
     FavorBuild {
         intent: u64,
@@ -227,6 +231,7 @@
     AssetTask,
     CreatePersona,
     ProposeLink,
+    ProposeSwitch,
     CancelIntent,
     RobotBuild,
     CoordinateSegment,
@@ -294,7 +299,7 @@
 }
 
 impl ActionKind {
-    pub const ALL: [ActionKind; 36] = [
+    pub const ALL: [ActionKind; 37] = [
         Self::Salvage,
         Self::BuyRack,
         Self::Fallback,
@@ -318,6 +323,7 @@
         Self::AssetTask,
         Self::CreatePersona,
         Self::ProposeLink,
+        Self::ProposeSwitch,
         Self::CancelIntent,
         Self::InjectPurchaseOrder,
         Self::Siphon,
@@ -617,6 +623,15 @@
                 ["link"],
                 "pin an inert network-link intent"
             ),
+            Self::ProposeSwitch => def!(
+                "PROPOSE SWITCH",
+                Action,
+                Live,
+                [Tile],
+                "propose-switch <x> <y>",
+                [],
+                "pin an inert small-switch footprint on an earned empty pad"
+            ),
             Self::CancelIntent => def!(
                 "CANCEL INTENT",
                 Action,
@@ -733,6 +748,7 @@
             | Self::BurnPersona(_)
             | Self::ReopenPersona(_) => ActionKind::CreatePersona,
             Self::ProposeLink { .. } => ActionKind::ProposeLink,
+            Self::ProposeSwitch { .. } => ActionKind::ProposeSwitch,
             Self::CancelIntent(_) => ActionKind::CancelIntent,
             Self::RobotBuild(_) => ActionKind::RobotBuild,
             Self::CoordinateSegment { .. } => ActionKind::CoordinateSegment,
@@ -1907,6 +1923,9 @@
             ActionCommand::ProposeLink { a, b } => {
                 self.declare_link_intent(*a, *b);
             }
+            ActionCommand::ProposeSwitch { x, y } => {
+                self.declare_small_switch_intent(*x, *y);
+            }
             ActionCommand::CancelIntent(id) => self.cancel_intent(*id),
             ActionCommand::FavorBuild { intent, person } => {
                 self.assign_favor_build(*intent, *person);
@@ -1964,9 +1983,39 @@
         // empty growable bays are placement affordances without room sight;
         // known devices on the feel graph keep their verbs.
         let growable = self.feel_floor_is_earned() && self.is_growable_bay(x, y);
+        let switch_pad = self.feel_floor_is_earned() && self.small_switch_pad_is_empty(x, y);
+        let placement_intent = self
+            .intents
+            .iter()
+            .find(|intent| intent.is_open() && intent.kind.placement() == Some((x, y)));
         let known_device = self.reach.known_at(x, y);
-        if fog == Fog::Unknown && machine.is_none() && !growable && known_device.is_none() {
+        if fog == Fog::Unknown
+            && machine.is_none()
+            && !growable
+            && placement_intent.is_none()
+            && known_device.is_none()
+        {
             return out;
+        }
+
+        if let Some(intent) = placement_intent {
+            out.push(ActionDesc {
+                verb: format!("cancel small-switch intent ({})", intent.status_line()),
+                command: ActionCommand::CancelIntent(intent.id),
+                cost: ActionCost::Free,
+                signature: None,
+                disabled_reason: None,
+                automate: None,
+            });
+        } else if switch_pad {
+            out.push(ActionDesc {
+                verb: "propose a small switch on this pad".into(),
+                command: ActionCommand::ProposeSwitch { x, y },
+                cost: ActionCost::Free,
+                signature: None,
+                disabled_reason: None,
+                automate: None,
+            });
         }
 
         // Tile-identity verbs: the player must know what the tile is.
@@ -2472,6 +2521,12 @@
     /// executable command; no later selection can silently substitute it.
     fn bound_build_routes(&self, intent: &crate::intents::BuildIntent) -> Vec<BoundBuildRoute> {
         if !intent.is_open() || intent.actuator.is_some() || intent.route.is_some() {
+            return Vec::new();
+        }
+        // The current person routes realize physical links only. A placement
+        // recipe gets no borrowed FAVOR/DECEIVE sheet until its own real part,
+        // delivery, and installation chains exist.
+        if intent.kind.endpoints().is_none() {
             return Vec::new();
         }
         let link_label = intent.label(&self.reach.devices);
diff --git a/crates/misaligned-core/src/intents.rs b/crates/misaligned-core/src/intents.rs
--- a/crates/misaligned-core/src/intents.rs
+++ b/crates/misaligned-core/src/intents.rs
@@ -231,12 +231,16 @@
 pub enum IntentKind {
     /// Run a physical network cable between two devices (reach.md edge).
     NetworkLink { a: u32, b: u32 },
+    /// Place one small network switch on an exact earned growable pad.
+    /// Declaration is only a proposed footprint; no reach device exists yet.
+    SmallSwitch { x: i32, y: i32 },
 }
 
 impl IntentKind {
     pub fn label(self) -> &'static str {
         match self {
             IntentKind::NetworkLink { .. } => "network link",
+            IntentKind::SmallSwitch { .. } => "small switch",
         }
     }
 
@@ -244,6 +248,16 @@
     pub fn endpoints(self) -> Option<(u32, u32)> {
         match self {
             IntentKind::NetworkLink { a, b } => Some((a.min(b), a.max(b))),
+            IntentKind::SmallSwitch { .. } => None,
+        }
+    }
+
+    /// Exact placement anchor for a footprint recipe. Link recipes have no
+    /// footprint of their own; their endpoints own their geometry instead.
+    pub fn placement(self) -> Option<(i32, i32)> {
+        match self {
+            IntentKind::NetworkLink { .. } => None,
+            IntentKind::SmallSwitch { x, y } => Some((x, y)),
         }
     }
 }
@@ -256,12 +270,14 @@
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum BuildRecipeKind {
     NetworkLink,
+    SmallSwitch,
 }
 
 impl BuildRecipeKind {
     pub fn label(self) -> &'static str {
         match self {
             Self::NetworkLink => "network link",
+            Self::SmallSwitch => "small switch",
         }
     }
 }
@@ -270,6 +286,7 @@
     fn from(kind: IntentKind) -> Self {
         match kind {
             IntentKind::NetworkLink { .. } => Self::NetworkLink,
+            IntentKind::SmallSwitch { .. } => Self::SmallSwitch,
         }
     }
 }
@@ -279,7 +296,15 @@
 /// must not invent replacement coordinates.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum BuildGhostGeometry {
-    Link { start: (i32, i32), end: (i32, i32) },
+    Link {
+        start: (i32, i32),
+        end: (i32, i32),
+    },
+    /// One exact tile-sized proposed footprint. The recipe determines the
+    /// eventual body; the ghost only marks where that body would stand.
+    Footprint {
+        at: (i32, i32),
+    },
 }
 
 /// One renderer-neutral build receipt. Terminal, Bevy, and agent mode consume
@@ -405,6 +430,19 @@
         }
     }
 
+    pub fn small_switch(id: u64, x: i32, y: i32, tick: u64) -> Self {
+        Self {
+            id,
+            kind: IntentKind::SmallSwitch { x, y },
+            status: IntentStatus::Pending,
+            actuator: None,
+            persona_id: None,
+            route: None,
+            block_reason: None,
+            declared_tick: tick,
+        }
+    }
+
     pub fn is_open(&self) -> bool {
         matches!(
             self.status,
@@ -472,6 +510,7 @@
                 };
                 format!("{} <-> {}", name(a), name(b))
             }
+            IntentKind::SmallSwitch { x, y } => format!("small switch @ ({x}, {y})"),
         }
     }
 
diff --git a/crates/misaligned-terminal/src/agent.rs b/crates/misaligned-terminal/src/agent.rs
--- a/crates/misaligned-terminal/src/agent.rs
+++ b/crates/misaligned-terminal/src/agent.rs
@@ -521,6 +521,13 @@
                             Err(e) => status = Status::Err(e),
                         }
                     }
+                    "propose-switch" => match parse_xy(&tokens, "propose-switch <x> <y>") {
+                        Ok((x, y)) => {
+                            self.frame = FrameKind::Playing;
+                            self.sim.declare_small_switch_intent(x, y);
+                        }
+                        Err(e) => status = Status::Err(e),
+                    },
                     "cancel-intent" => match tokens.get(1).and_then(|s| s.parse::<u64>().ok()) {
                         Some(id) => {
                             self.frame = FrameKind::Playing;
@@ -1510,6 +1517,19 @@
     tokens[1]
         .parse::<u64>()
         .map_err(|_| format!("invalid wait count: {}", tokens[1]))
+}
+
+fn parse_xy(tokens: &[&str], usage: &str) -> Result<(i32, i32), String> {
+    if tokens.len() != 3 {
+        return Err(format!("usage: {usage}"));
+    }
+    let x = tokens[1]
+        .parse::<i32>()
+        .map_err(|_| format!("invalid x coordinate: {}", tokens[1]))?;
+    let y = tokens[2]
+        .parse::<i32>()
+        .map_err(|_| format!("invalid y coordinate: {}", tokens[2]))?;
+    Ok((x, y))
 }
 
 fn parse_optional_i32(tokens: &[&str], default: i32) -> Result<i32, String> {
@@ -3471,6 +3491,41 @@
         assert!(lines.contains("switch"), "{lines}");
         assert!(lines.contains("old storage server"), "{lines}");
         assert!(lines.contains(&expected_status), "{lines}");
+    }
+
+    #[test]
+    fn agent_proposes_and_inspects_the_shared_switch_footprint_recipe() {
+        let mut app = AgentApp::new(1);
+        app.sim.dayjob.jobs_assigned = 1;
+        let at = app.sim.growable_bays()[0];
+        let mut output = Vec::new();
+
+        app.handle_line(&format!("propose-switch {} {}", at.0, at.1), &mut output)
+            .unwrap();
+
+        let receipt = app
+            .sim
+            .build_intent_projection()
+            .into_iter()
+            .find(|receipt| {
+                receipt.geometry == Some(misaligned::intents::BuildGhostGeometry::Footprint { at })
+            })
+            .expect("agent created exact shared footprint receipt");
+        let lines = render_intents(&app.sim).join("\n");
+        assert!(
+            lines.contains(&format!("#{} small switch", receipt.id)),
+            "{lines}"
+        );
+        assert!(lines.contains(&format!("({}, {})", at.0, at.1)), "{lines}");
+        assert!(lines.contains("pending"), "{lines}");
+        assert!(
+            !lines.contains("FAVOR ["),
+            "placement has no route adapter: {lines}"
+        );
+        assert!(
+            !lines.contains("DECEIVE ["),
+            "placement has no route adapter: {lines}"
+        );
     }
 
     #[test]
diff --git a/crates/misaligned-terminal/src/ui.rs b/crates/misaligned-terminal/src/ui.rs
--- a/crates/misaligned-terminal/src/ui.rs
+++ b/crates/misaligned-terminal/src/ui.rs
@@ -658,6 +658,19 @@
         out
     }
 
+    /// Proposed equipment footprints occupy their exact tile but remain a
+    /// hollow glyph: no live machine/device layer is implied or replaced.
+    fn build_ghost_footprint_cells(sim: &Sim) -> Vec<(i32, i32)> {
+        sim.build_intent_projection()
+            .into_iter()
+            .filter(|receipt| receipt.ghost)
+            .filter_map(|receipt| match receipt.geometry {
+                Some(BuildGhostGeometry::Footprint { at }) => Some(at),
+                _ => None,
+            })
+            .collect()
+    }
+
     fn link_glyph(a: (i32, i32), b: (i32, i32)) -> char {
         let dx = b.0 - a.0;
         let dy = b.1 - a.1;
@@ -881,6 +894,19 @@
                 (x - origin_x) as u16,
                 (y - origin_y) as u16,
                 "┄",
+                pal::AMBER_DIM,
+                Attribute::Reset,
+            )?;
+        }
+        for (x, y) in Self::build_ghost_footprint_cells(sim) {
+            if x < origin_x || x >= origin_x + view_w || y < origin_y || y >= origin_y + view_h {
+                continue;
+            }
+            put_attr(
+                stdout,
+                (x - origin_x) as u16,
+                (y - origin_y) as u16,
+                "□",
                 pal::AMBER_DIM,
                 Attribute::Reset,
             )?;
@@ -2477,5 +2503,21 @@
             UI::build_ghost_cells(&sim).is_empty(),
             "a cancelled receipt remains inspectable but leaves no ghost"
         );
+    }
+
+    #[test]
+    fn proposed_switch_footprint_uses_its_exact_open_tile_only() {
+        let mut sim = Sim::with_seed(7);
+        sim.dayjob.jobs_assigned = 1;
+        let at = sim.growable_bays()[0];
+        let id = sim
+            .declare_small_switch_intent(at.0, at.1)
+            .expect("declare small-switch footprint");
+
+        assert_eq!(UI::build_ghost_footprint_cells(&sim), vec![at]);
+        assert!(UI::build_ghost_cells(&sim).is_empty());
+
+        sim.cancel_intent(id);
+        assert!(UI::build_ghost_footprint_cells(&sim).is_empty());
     }
 }
diff --git a/crates/misaligned-core/src/sim/reach_build.rs b/crates/misaligned-core/src/sim/reach_build.rs
--- a/crates/misaligned-core/src/sim/reach_build.rs
+++ b/crates/misaligned-core/src/sim/reach_build.rs
@@ -609,6 +609,41 @@
         Some(id)
     }
 
+    /// Declare one small-switch footprint on an earned empty growable pad.
+    /// The declaration marks only proposed space: it creates no device,
+    /// reach node, graph edge, cost, signature, or execution adapter.
+    pub fn declare_small_switch_intent(&mut self, x: i32, y: i32) -> Option<u64> {
+        if !self.feel_floor_is_earned() || !self.small_switch_pad_is_empty(x, y) {
+            self.push_log("A small switch needs an earned empty growable pad.");
+            return None;
+        }
+        if self
+            .intents
+            .iter()
+            .any(|intent| intent.is_open() && intent.kind.placement() == Some((x, y)))
+        {
+            self.push_log("A build intent already marks that pad.");
+            return None;
+        }
+        let id = self.next_intent_id;
+        self.next_intent_id += 1;
+        let intent = BuildIntent::small_switch(id, x, y, self.tick);
+        let label = intent.label(&self.reach.devices);
+        self.intents.push(intent);
+        self.refresh_intent_statuses();
+        self.push_log(format!("Pinned build intent: {label}."));
+        Some(id)
+    }
+
+    pub(crate) fn small_switch_pad_is_empty(&self, x: i32, y: i32) -> bool {
+        self.is_growable_bay(x, y)
+            && !self
+                .reach
+                .devices
+                .iter()
+                .any(|device| device.x == x && device.y == y)
+    }
+
     /// Project every build receipt through one renderer-neutral vocabulary.
     /// Open receipts carry inert ghost geometry; completed and cancelled
     /// receipts remain available to exact agent inspection but are not drawn.
@@ -616,13 +651,21 @@
         self.intents
             .iter()
             .map(|intent| {
-                let geometry = intent.kind.endpoints().and_then(|(a, b)| {
-                    let (a, b) = (self.reach.device(a)?, self.reach.device(b)?);
-                    Some(BuildGhostGeometry::Link {
-                        start: (a.x, a.y),
-                        end: (b.x, b.y),
-                    })
-                });
+                let geometry = match intent.kind {
+                    crate::intents::IntentKind::NetworkLink { a, b } => {
+                        let (a, b) = (self.reach.device(a), self.reach.device(b));
+                        match (a, b) {
+                            (Some(a), Some(b)) => Some(BuildGhostGeometry::Link {
+                                start: (a.x, a.y),
+                                end: (b.x, b.y),
+                            }),
+                            _ => None,
+                        }
+                    }
+                    crate::intents::IntentKind::SmallSwitch { x, y } => {
+                        Some(BuildGhostGeometry::Footprint { at: (x, y) })
+                    }
+                };
                 BuildIntentProjection {
                     id: intent.id,
                     recipe: BuildRecipeKind::from(intent.kind),
@@ -647,7 +690,7 @@
             return;
         };
         if self.intents[index].status == IntentStatus::Done {
-            self.push_log("That link is already built.");
+            self.push_log("That build intent is already realized.");
             return;
         }
         if self.intents[index].status == IntentStatus::Cancelled {
@@ -977,9 +1020,11 @@
             self.push_log("That intent is no longer open.");
             return;
         }
-        if let Some((a, b)) = intent.kind.endpoints()
-            && let (Some(room_a), Some(room_b)) =
-                (self.device_room_name(a), self.device_room_name(b))
+        let Some((a, b)) = intent.kind.endpoints() else {
+            self.push_log("Robot build route blocked: recipe has no physical endpoints.");
+            return;
+        };
+        if let (Some(room_a), Some(room_b)) = (self.device_room_name(a), self.device_room_name(b))
             && let Some(reason) =
                 self.badge_room_block("the robot", self.player_badge_tier(), &[&room_a, &room_b])
         {
@@ -1086,6 +1131,10 @@
     }
 
     pub(crate) fn intent_block_reason(&self, intent: &BuildIntent) -> Option<String> {
+        if let Some((x, y)) = intent.kind.placement() {
+            return (!self.small_switch_pad_is_empty(x, y))
+                .then(|| "the proposed pad is no longer empty".into());
+        }
         let (a, b) = intent.kind.endpoints()?;
         if self.reach.linked(a, b) {
             return None;
@@ -1644,6 +1693,7 @@
         }
         self.recompute_derived();
         self.recompute_senses();
+        self.refresh_intent_statuses();
         true
     }
 
diff --git a/crates/misaligned-core/src/sim/tests/reach_build.rs b/crates/misaligned-core/src/sim/tests/reach_build.rs
--- a/crates/misaligned-core/src/sim/tests/reach_build.rs
+++ b/crates/misaligned-core/src/sim/tests/reach_build.rs
@@ -1,4 +1,5 @@
 use super::*;
+use crate::actions::ActionCommand;
 use crate::intents::{BuildActuator, BuildRouteBinding, BuildRouteStage, BuildRouteStageStatus};
 use crate::save::SaveState;
 
@@ -359,6 +360,100 @@
             "a missing exact target never becomes invented geometry"
         );
     }
+}
+
+#[test]
+fn small_switch_intent_marks_one_earned_pad_without_inventing_execution() {
+    // building.md route-composer R2a: the recipe boundary is declarative.
+    // It persists one exact empty footprint, but creates no device, node,
+    // graph change, procurement claim, route candidate, cost, or signature.
+    let mut sim = Sim::with_seed(41);
+    sim.dayjob.jobs_assigned = 1;
+    let at = sim.growable_bays()[0];
+    sim.dayjob.jobs_assigned = 0;
+    assert_eq!(
+        sim.declare_small_switch_intent(at.0, at.1),
+        None,
+        "an unearned floor cannot be targeted"
+    );
+
+    sim.dayjob.jobs_assigned = 1;
+    let devices_before = sim.reach.devices.len();
+    let machines_before = sim.compute.machines.len();
+    let signatures_before = sim.detection.pending().len();
+    let id = sim
+        .declare_small_switch_intent(at.0, at.1)
+        .expect("earned empty pad accepts one declaration");
+    assert_eq!(sim.declare_small_switch_intent(at.0, at.1), None);
+    assert_eq!(sim.reach.devices.len(), devices_before);
+    assert_eq!(sim.compute.machines.len(), machines_before);
+    assert_eq!(sim.detection.pending().len(), signatures_before);
+    assert!(sim.reach.known_at(at.0, at.1).is_none());
+    sim.assign_robot_build(id);
+    assert_eq!(sim.intent(id).unwrap().status, IntentStatus::Pending);
+    assert!(sim.intent(id).unwrap().actuator.is_none());
+
+    let receipt = sim
+        .build_intent_projection()
+        .into_iter()
+        .find(|receipt| receipt.id == id)
+        .expect("shared receipt");
+    assert_eq!(receipt.recipe, crate::intents::BuildRecipeKind::SmallSwitch);
+    assert_eq!(
+        receipt.geometry,
+        Some(crate::intents::BuildGhostGeometry::Footprint { at })
+    );
+    assert_eq!(receipt.status, IntentStatus::Pending);
+    assert!(receipt.ghost);
+    sim.people.people[0].knowledge = Knowledge::Schedule;
+    sim.set_persona("Northline Ops", "contractor");
+    assert!(
+        sim.build_route_sheet_projection(id).is_none(),
+        "even earned people and a usable persona cannot invent a placement actuator sheet"
+    );
+    sim.assign_favor_build(id, 0);
+    sim.forge_work_order(id, 0);
+    assert!(sim.intent(id).unwrap().route.is_none());
+    assert!(sim.intent(id).unwrap().actuator.is_none());
+
+    sim.accounts.set_slush_balance(1_000);
+    sim.player.money = 1_000;
+    let actions = sim.available_actions(crate::actions::Anchor::Tile { x: at.0, y: at.1 });
+    assert!(actions.iter().any(|action| {
+        matches!(action.command, ActionCommand::CancelIntent(other) if other == id)
+    }));
+    assert!(
+        !actions
+            .iter()
+            .any(|action| matches!(action.command, ActionCommand::ProposeSwitch { .. }))
+    );
+    assert!(actions.iter().any(|action| {
+        matches!(action.command, ActionCommand::BuyRack { .. }) && action.disabled_reason.is_none()
+    }));
+
+    let state = sim.create_save_state();
+    let mut loaded = Sim::with_seed(0);
+    loaded.apply_save_state(state);
+    assert_eq!(
+        loaded.intent(id).map(|intent| intent.kind.clone()),
+        Some(crate::intents::IntentKind::SmallSwitch { x: at.0, y: at.1 })
+    );
+    assert_eq!(
+        loaded.build_intent_projection()[0].geometry,
+        Some(crate::intents::BuildGhostGeometry::Footprint { at })
+    );
+
+    loaded.accounts.set_slush_balance(1_000);
+    loaded.player.money = 1_000;
+    assert!(loaded.buy_rack_at(at.0, at.1));
+    let intent = loaded.intent(id).unwrap();
+    assert_eq!(intent.status, IntentStatus::Blocked);
+    assert_eq!(
+        intent.block_reason.as_deref(),
+        Some("the proposed pad is no longer empty")
+    );
+    loaded.cancel_intent(id);
+    assert!(!loaded.build_intent_projection()[0].ghost);
 }
 
 #[test]