Merge pull request #203 from levineuwirth/journey-stage1b1-compile-defaults

Journey Stage 1b-1: make building discoverable (step 9)
2026-07-31 02:09:13 +00:00 · 2026-07-31 02:09:13 +00:00 · 1f290d51c3
parent fbcf235cec 732aa282cc
commit 1f290d51c3
9 changed files with 1506 additions and 19 deletions
--- a/COHERENCE.md
+++ b/COHERENCE.md
@ -378,7 +378,7 @@ Full verdict table:
 | 6 | Language intelligence | **Partial** | Rust grammar bundled and auto-attaches; rust-analyzer preconfigured (`builtin/runtime/lsp.lua:44-52`) — but a missing binary fails silently (§1.2) and highlighting masks it. No LSP status command exists to diagnose |
 | 7 | Find symbol / file | **File: fixed (open by path merged #162; browsing #165). Symbol: works but undiscoverable** | No find-file/dired/picker existed at audit. Now `C-x C-f` opens a known path and `C-x d` / `C-x C-j` browse (flat listing, `dired` mode keymap); `M-.`/`M-?`/`C-c o` still bound but advertised nowhere and server-gated; no workspace-symbol command; `pmacs.index.*` has no UI |
 | 8 | Open terminal | **Works** | Full PTY with scrollback + modeline segment, bound to `C-c t` and configurable through three registered settings (`terminal.default-profile`, `terminal.scrollback-rows`, `terminal.escape-key`) plus named `pmacs.terminal.profiles` (PR #173), and searchable through `M-x terminal.copy-mode` / `C-c C-t`, which materializes the retained scrollback into an ordinary read-only buffer (Stage 2). Named limitations: `C-c t` is unreachable from *inside* a terminal window, where `C-c` is consumed as the escape — `M-x terminal` still works there; and there is still **no close/kill command**, which is the remaining half of this step's discoverability gap. *Was broken outright on the GPU frontend until the double terminal-layout sync was fixed: the child took a `SIGWINCH` storm at tick cadence, so typing into it was impossible while output still flowed.* |
-| 9 | Build / test | **Partial** | `M-x compile.run` works, defaults cwd to detected project root, parses Rust `-->` errors — but no keybinding, an **empty first prompt** (`initial = last and last.cmdline or ""`, `builtin/runtime/compile.lua:1134-1138`), and no `cargo build`/`cargo test` suggestion despite `ProjectKind::Cargo` existing (`src/project.rs:77`) |
+| 9 | Build / test | **Partial** | `M-x compile.run` works, defaults cwd to the detected project root, and parses Rust `-->` errors — but no keybinding, an **empty first prompt** (`initial = last and last.cmdline or ""`, `builtin/runtime/compile.lua`), and no `cargo build` suggestion despite `ProjectKind::Rust` existing (`src/project.rs:78` — **not** `Cargo`, see §24). **PR #203 (open) closes all three**: `C-c c` runs `compile.run`, and the first prompt is prefilled from the detected project kind (`pmacs.compile.defaults`, seeded `rust = "cargo build"`). The prompt **captures** its directory rather than re-resolving at accept time, so the command it offers and the directory it runs in cannot drift while the minibuffer waits. Named limitation it does not fix: after `pmacs <dir>` the active buffer is dired's and pathless, so the cwd falls back to the process cwd — §8's execution-location model owns that. **This row flips to Works when #203 merges**; per §25 a grade changes only on landed evidence |
 | 10 | Inspect error | **Partial (good once reached)** | `E:n W:n` modeline counts, underlines, `M-g n/p` + ``C-x ` `` walking a unified compile/grep/diag source, message echo, `RET` visits. Gated entirely on step 6 or 9 succeeding first |
 | 11 | See background work | **Works but undiscoverable** | `*workers*` view via `M-x editor.list-workers`; `C-c C-k` cancel-at-point. No keybinding, no statusline spinner/progress indicator anywhere (§9) |
 | 12 | Close + restore | **Partial** | Per-file cursor+scroll (saveplace), recent files, minibuffer history, autosave recovery all restore zero-config. Open-buffer set and window layout do **not**: desktop-save is opt-in (`pmacs.session.desktop_mode(true)`) *and* a documented no-op under a daemon (`src/desktop.rs:323-326`, `:353-356`, Q#DS9) |
@ -388,12 +388,14 @@ A journey observation worth keeping verbatim from the audit:
 C-M-s` opens all folds, while opening a file, opening a terminal, and
 running a build have no bindings at all.
-Two of that observation's three examples have since been answered —
+Two of that observation's three examples have been answered — opening a
-opening a file by `C-x C-f` (#162) and opening a terminal by `C-c t`
+file by `C-x C-f` (#162) and opening a terminal by `C-c t` (#173).
-(#173). **Running a build still has no binding**, and the underlying
+**Running a build still has no binding on `main`**; PR #203 is open and
-inversion is a standing bias in how new work gets bound, not three
+adds `C-c c`. **The quote stays as written either way**: it names a standing bias in how new work gets bound,
-isolated omissions: the quote stays as written because it names the
+not three isolated omissions, and two fixes do not retire a bias.
-pattern, and the pattern is not retired until step 9 is.
+**Running a build remains its uncontested golden-journey example until
 #203 lands.** A new surface that ships without a binding would be further
 evidence the pattern is live, and should be read that way.
 ---
@ -1542,14 +1544,18 @@ blockers. **State: runs to step 5; thin from step 6 (§2). Mostly wiring,
 and unusually cheap:** directory-argument handling (**done**: Journey
 Stage 1a); a find-file surface (**done**: #162 open-by-path, #165
 browsing); surfacing the LSP spawn failure with guidance (§1.2); a
-compile keybinding + `cargo build`/`test` default from the existing
+compile keybinding + `cargo build`/`test` default (**in flight**:
-`ProjectKind::Cargo`; a terminal keybinding (**done**: `C-c t`, #173); a
+Journey Stage 1b-1, PR #203, from the existing `ProjectKind::Rust` —
-welcome buffer. The journey acceptance suite (§19) is the ratchet that
+**not** `Cargo`, see §24); a terminal keybinding (**done**: `C-c t`,
 #173); a welcome buffer. The journey acceptance suite (§19) is the ratchet that
 keeps it fixed — it **exists now** (`tests/journey_acceptance.rs`,
 Stage 1a), seeded with steps 2, 3, and 5.
-Journey Stage 1b is the named remainder: the compile binding + Cargo
+Journey Stage 1b is the named remainder, and it splits: **1b-1 — the
-defaults, LSP spawn guidance, and the welcome buffer.
+compile binding + project-kind defaults — is in flight as PR #203**;
 1b-2 (LSP spawn guidance, step 6) and 1b-3 (the welcome buffer, step 4)
 remain. The ratchet is seeded with steps 2, 3 and 5, and gains step 9
 when #203 lands.
 ### Priority 2: Make workspace and location explicit
@ -1620,8 +1626,10 @@ implementation — this list is direction, not commitment):
   `resolve_target_buffer` unification, the destination-scope substrate,
   and the first journey acceptance suite. It routes `pmacs .` into
   #165's dired buffer rather than growing a second directory surface.
-   **Stage 1b — remaining**: compile defaults, LSP-failure surfacing,
+   **Stage 1b-1 — in flight (PR #203)**: the compile binding and
-   bindings, welcome buffer.
+   project-kind defaults, with the prompt capturing its directory rather
   than re-resolving it at accept time. **Stage 1b-2 / 1b-3 —
   remaining**: LSP-failure surfacing, welcome buffer.
 2. **Discovery surface** (P4): the describe/list/where-is command
   family, M-x rich rows, help unification, help prefix.
 3. **Transient keymap layer** (§6): the overlay scope + lifetime
@ -1713,6 +1721,16 @@ available without being imposed.
 Found during the audit; fix opportunistically, ideally before this
 document is wired into CLAUDE.md/AGENTS.md as required reading:
 - **This document named a `ProjectKind` variant that does not exist**,
  in two places: §2's step-9 row and §20 Priority 1 both said
  "`ProjectKind::Cargo` existing (`src/project.rs:77`)". Line 77 is the
  *doc comment*; the variant on line 78 is **`ProjectKind::Rust`**,
  produced by the `Cargo.toml` marker. The audit read the comment and
  named the comment. Corrected by Journey Stage 1b-1 — which also
  establishes that the Lua side never sees the variant at all:
  `pmacs.project.detect` returns the **tag string** `"rust"`. Kept here
  rather than silently fixed, because a wrong type name in the document
  work is evaluated against costs a scout a real detour.
 - `docs/keybindings.md` — every `src/editor.rs` line citation in §3 is
  stale by ~250–1000 lines despite a "last verified @ `f8096ff`
  (2026-07-20)" stamp; its shadow list also omits the terminal `C-c`
--- a/builtin/runtime/compile.lua
+++ b/builtin/runtime/compile.lua
@ -620,6 +620,60 @@ local function daemon_working_directory()
  return nil
 end
 -- Where a run started right now would execute. Extracted from the
 -- inline expression that used to live in `pmacs.compile.run`, because
 -- the interactive command needs the SAME answer to build its prompt:
 -- a suggestion computed from a different rule than the run obeys can
 -- name a toolchain that is not at the directory the command executes
 -- in (journey Stage 1b-1 framing §3.1).
 local function resolve_cwd(explicit)
  return explicit or project_root_of_active() or daemon_working_directory()
 end
 --- Default compile command per detected project kind, keyed by the tag
 --- `pmacs.project.detect` returns. Assign into this table from
 --- `init.lua` to add or override one:
 ---
 ---     pmacs.compile.defaults.go = "go build ./..."
 ---
 --- Only `rust` ships seeded, and that is a decision rather than an
 --- omission: Rust has one answer, while npm/yarn/pnpm, make/cmake, and
 --- `go build` versus `go test` do not. A wrong prefill costs more than
 --- an empty one — the user must delete it before typing.
 pmacs.compile.defaults = { rust = "cargo build" }
 -- Read `defaults[kind]` defensively. The table is public and
 -- assignable, so a metatable with a throwing `__index`, a non-string
 -- entry, or a non-table replacement all have to be survivable — the
 -- same discipline `validated_rules` keeps for a hostile rule container
 -- (round-2 finding 3). A broken `defaults` degrades to the pre-stage
 -- empty prompt; it never prevents compiling.
 local function default_command_for(kind)
  if type(kind) ~= "string" then return nil end
  local ok, value = pcall(function() return pmacs.compile.defaults[kind] end)
  if ok and type(value) == "string" and #value > 0 then return value end
  return nil
 end
 --- Where the next compile would run, and what kind of project is
 --- detected *from that directory*. Public getter (per API
 --- conventions): `{ cwd = string|nil, kind = string|nil }`.
 ---
 --- `kind` is always `detect(cwd)`, one rule regardless of which branch
 --- produced `cwd`. Note that is not the same as "`cwd` is a project
 --- root": a Cargo workspace subdirectory contains no `Cargo.toml`, is
 --- detected as `rust` by the ancestor walk, and is a perfectly good
 --- place to run `cargo build`.
 function pmacs.compile.context(explicit_cwd)
  local cwd = resolve_cwd(explicit_cwd)
  local kind = nil
  if cwd then
    local ok, proj = pcall(pmacs.project.detect, cwd)
    if ok and proj and type(proj.kind) == "string" then kind = proj.kind end
  end
  return { cwd = cwd, kind = kind }
 end
 local function format_exit_marker(label, ev)
  if ev.kind == "exited" then
    return string.format("\n[%s exited with code %d]\n", label, ev.code or 0)
@ -762,7 +816,7 @@ local function start_run(slot, cmdline, opts)
  if cur and not pmacs.compile.is_generated_buffer(cur) then
    slot.prev = cur
  end
-  local cwd = opts.cwd or project_root_of_active() or daemon_working_directory()
+  local cwd = resolve_cwd(opts.cwd)
  -- Supersede (Q#CM9): terminate the old group and tombstone its
  -- pump entry; its terminal event still drives forget.
@ -1132,13 +1186,27 @@ pmacs.command.define {
  description = "Compile: run a command in a streaming *compilation* buffer (M-x compile).",
  fn = function()
    local last = pmacs.compile._last
    -- Captured ONCE, here. `pmacs.minibuffer.read` is asynchronous and
    -- nothing freezes the active window while a prompt is open, so
    -- re-resolving inside `on_accept` would let the prompt offer
    -- `cargo build` for A and execute in B. Sharing the resolver is
    -- necessary and not sufficient; the resolution has to be captured.
    -- This is Journey Stage 1a's `commit_to` discipline on a smaller
    -- seam — the mechanism differs, the failure prevented is the same.
    local ctx = pmacs.compile.context()
    pmacs.minibuffer.read {
      prompt = "Compile command: ",
      history = "compile",
-      initial = last and last.cmdline or "",
+      -- `_last` still wins: a user who ran `cargo test` once gets it
      -- back rather than being reset to the project default.
      initial = last and last.cmdline or default_command_for(ctx.kind) or "",
      on_accept = function(cmdline)
        if cmdline == nil or cmdline == "" then return end
-        pmacs.compile.run(cmdline)
+        -- `ctx.cwd` passes through verbatim, INCLUDING nil: a nil cwd
        -- means every resolution step failed, and the header renders
        -- "(unknown)" exactly as before. Re-resolving here would
        -- reintroduce the drift for the case least able to tolerate it.
        pmacs.compile.run(cmdline, { cwd = ctx.cwd })
      end,
    }
  end,
@ -1186,3 +1254,16 @@ pmacs.keymap.bind { scope = "global", sequence = "M-g n", command = "error.next"
 pmacs.keymap.bind { scope = "global", sequence = "M-g p", command = "error.previous" }
 pmacs.keymap.bind { scope = "global", sequence = "C-x `", command = "error.next" }
 pmacs.keymap.bind { scope = "global", sequence = "M-!", command = "shell.command" }
 -- Journey step 9 (COHERENCE §2): running a build had no binding at all,
 -- while `C-c @ C-M-s` opened all folds. `C-c c` is free, sits under the
 -- established `C-c` prefix, and does not collide with CUA copy (that is
 -- `M-w`). Bound here rather than in `default.lua` because a runtime
 -- module owns its own global keys — `terminal.lua` binds `C-c t`,
 -- `lsp.lua` binds `C-c o`.
 --
 -- Two inherited reachability limits, both pre-existing: inside a
 -- terminal window `C-c` is consumed as the escape key, and the repl
 -- package binds `C-c` at buffer scope. `M-x compile.run` still works in
 -- both. `compile.recompile` gets no global chord — `g` in
 -- `*compilation*` already covers rerun.
 pmacs.keymap.bind { scope = "global", sequence = "C-c c", command = "compile.run" }
--- a/docs/active-work.md
+++ b/docs/active-work.md
@ -253,6 +253,100 @@ If it does not, stop and repair the remote/fetch configuration.
  never been enforced. Any CI job that compiles the `crdt` targets has to
  fix them first or it will be red on arrival.
 ## Journey lane (P1) — STAGE 1a MERGED; STAGE 1b-1 IMPLEMENTED, PR OPEN
 - **Branch `journey-stage1b1-compile-defaults`**, worktree
  `../pmacs-journey-1b1`, based on `githubsucks/main` @ `22df6ab`.
  `docs/journey-stage1b1-compile-defaults-framing.md` revision 2,
  approved after one review round (two blocking, two major, all
  accepted). **Implemented; PR open.**
 - **ON MERGE OF #203, flip four places to landed.** The PR deliberately
  ships them as *in flight*, because `COHERENCE.md` §25 says a grade
  changes only on landed evidence and the PR is open: `COHERENCE.md`
  §2's step-9 verdict row (Partial → **Works**), §2's post-table
  keybinding-inversion paragraph (third example answered; the build is
  no longer its uncontested example), §20 Priority 1 and its arc list (in
  flight → done), and
  `docs/agent-handoff.md` §1's arc bullet (IMPLEMENTED → LANDED).
  **Recorded here because an unowned doc flip is exactly how this
  ledger's drift starts** — the same rule-4 precondition that kept #176's
  lane alive past its merge.
 - **A lexical path expectation is wrong for anything detection touched.**
  `pmacs.project.detect` canonicalizes before walking
  (`canonicalize_or_passthrough`, `src/project.rs:509-511`) while the
  suite's `canon()` is lexical, so the compile-directory assertions
  passed on Ubuntu and **failed both macOS legs**, where `/var` is a
  symlink to `/private/var`. Fixed with a `detected_root()` expectation
  and pinned by a **symlinked fixture**, which reproduces the disagreement
  on any platform — a Linux-only bite could not have caught it.
 - **Bites found two vacuous pins of my own.** The nested-project pin
  passed with the keybinding removed, because `minibuffer.contents()` is
  `""` both for an empty prefill and for no minibuffer at all — `""`
  compared with `""`. And the hostile-`defaults` pin called
  `compile.run` directly, so it never consulted `defaults` and passed
  with the guard removed. Both now assert their precondition.
 - **Round 1's blocking finding is the Stage 1a lesson repeating.**
  Sharing one cwd resolver between the prompt and the run is *not*
  enough: `pmacs.minibuffer.read` is async, the active window can change
  while the prompt is open, and `run` re-resolved at accept time — so
  the prompt could offer `cargo build` for A and execute in B. The
  interactive command now **captures** `context()` and passes its `cwd`
  through to `run`, which is `commit_to`'s discipline on a smaller seam.
  The second blocker was that no pin crossed the accept boundary at all,
  so that defect passed every proposed pin.
 - **Why this lane exists.** `COHERENCE.md` §20 Priority 1 names Journey
  Stage 1b as the golden journey's remainder — "the compile binding +
  Cargo defaults, LSP spawn guidance, and the welcome buffer" — and it
  had no branch, no framing, and no lane. It is the only §20 priority
  with nothing in flight.
 - **What 1b-1 is.** Journey step 9 only: a global `C-c c` for
  `compile.run`, and a first prompt prefilled from the detected project
  kind instead of empty. Lua, tests, and docs; **no Rust change and no
  protocol change**. 1b-2 (LSP spawn guidance, step 6) and 1b-3 (welcome
  buffer, step 4) are separate stages — see the framing §7 for why the
  three are not one PR.
 - **`ProjectKind::Cargo` does not exist.** `COHERENCE.md` names it twice
  (§2's step-9 row and §20 Priority 1); the variant is
  `ProjectKind::Rust` (`src/project.rs:78`) and line 77 is its doc
  comment. The audit read the comment. Lua matches on the **tag string**
  `"rust"` that `pmacs.project.detect` returns, so no Rust primitive is
  needed. The PR corrects both COHERENCE sites.
 - **The suggestion and the run must share one cwd resolution.** Today
  the cwd is computed *inside* `pmacs.compile.run`
  (`builtin/runtime/compile.lua:765`), after the prompt has closed, so a
  suggestion computed in the command's `fn` would obey a different rule
  than the run. The stage extracts it and exposes
  `pmacs.compile.context()`, consumed by both.
 - **The trap the acceptance is designed around.** The last-resort cwd is
  `std::env::current_dir()` evaluated at call time
  (`pmacs-protocol/src/message.rs:1703-1706`), so in tests it is the
  **test runner's cwd — the pmacs repo root, itself a Cargo project**.
  `compile_mode_acceptance.rs:1721` already pins this. A pin asserting
  "no Cargo suggestion" that reaches the fallback would report pmacs's
  own `Cargo.toml`. Negative pins therefore use a fixture carrying a
  *different* marker so the fallback is never consulted;
  `set_search_boundary` does **not** help here, because it only clamps a
  walk that starts below the boundary.
 - **Known limitation, deliberately not fixed.** After `pmacs <dir>` the
  active buffer is dired's and **pathless** (`pmacs.buffer.create` never
  assigns a path; dired compensates through its own module-local
  `handle_for_buffer`, `dired.lua:205-217`), so the cwd falls through to
  the process cwd. Launched from elsewhere that is the wrong directory.
  The fix is `COHERENCE.md` §8 (First-Class Execution Locations), a
  model gap; reaching into dired's private table for one string would
  add an interaction island.
 - Recovery from a clean checkout — **the two-argument form does not
  work** (`git worktree add <path> <remote-only-branch>` fails with
  `fatal: invalid reference`, because after a bare fetch no local branch
  exists):
  ```sh
  git fetch githubsucks
  git worktree add ../pmacs-journey-1b1 \
    -b journey-stage1b1-compile-defaults \
    githubsucks/journey-stage1b1-compile-defaults
  ```
 ## Generated-buffer immutability lane (Arc: workbench primitives) — STAGE 1 MERGED; STAGE 2 IS NEXT
 **Framing #188 (revision 7) and Stage 1 #191 are both on `main` @
--- a/docs/agent-handoff.md
+++ b/docs/agent-handoff.md
@ -104,6 +104,51 @@ commands, read `docs/active-work.md` immediately after this file.
  interaction islands added, config-registry adoption, background-work
  attribution. Its §2 grades the golden journey; **Journey Stage 1a
  moved that grade off "broken at step 3"** — see the arc bullet below.
 - **Journey arc (P1) — Stage 1b-1 IMPLEMENTED, PR #203 OPEN**
  (`docs/journey-stage1b1-compile-defaults-framing.md`). Not landed: per
  `COHERENCE.md` §25 a grade changes only on landed evidence, so §2's
  step-9 row still reads **Partial** and flips at merge.
  Journey step 9 will move **Partial → Works**: `C-c c` runs `compile.run`,
  and the first prompt is prefilled from the detected project kind via
  `pmacs.compile.defaults` (seeded `rust = "cargo build"`, extensible
  from `init.lua`). Lua, tests and docs; no Rust change, no protocol
  change. The ratchet now carries steps 2, 3, 5 and **9**.
  - **Sharing a resolver is not capturing one.** `pmacs.minibuffer.read`
    is asynchronous and nothing freezes the active window while a prompt
    is open, so having the prompt and `compile.run` call the *same* cwd
    resolver still let them disagree: the user could be offered
    `cargo build` for A and given a run in B by clicking away
    mid-prompt. The interactive command captures `pmacs.compile.context()`
    once and passes its `cwd` through to the run. **This is Stage 1a's
    `commit_to` lesson on a smaller seam** — capture at request time,
    never re-derive when the async work lands. Review found it; the
    first framing had the weaker design and said it was sufficient.
  - **A pin that never crosses the accept boundary cannot see that
    class of bug.** Every originally-proposed pin compared values the
    prompt and the resolver already agreed on, so the defect above
    passed all of them. Two pins now accept the prompt and observe a
    real process.
  - **`ProjectKind::Cargo` does not exist** — `COHERENCE.md` named it
    twice, citing `src/project.rs:77`, which is the *doc comment*; the
    variant on line 78 is `ProjectKind::Rust`. Lua never sees the
    variant anyway: `pmacs.project.detect` returns the tag string
    `"rust"`. Corrected in both COHERENCE sites and recorded in its §24.
  - **The compile fallback cwd is the process cwd, which under `cargo
    test` is the pmacs repo — itself a Cargo project.** Any pin
    asserting the *absence* of a Cargo suggestion that reaches the
    fallback reports pmacs's own `Cargo.toml`. Bite D confirmed it: with
    the kind derived from the process cwd, the plain-fixture prefill pin
    still passed and only the nested-project pin caught it.
    `set_search_boundary` is no defence — it clamps only a walk starting
    *below* the boundary.
  - **Named limitation, deliberately unfixed:** after `pmacs <dir>` the
    active buffer is dired's and **pathless** (`pmacs.buffer.create`
    assigns no path; dired compensates through its own module-local
    `handle_for_buffer`), so the cwd falls through to the process cwd.
    Launched from elsewhere that is the wrong directory. The fix is
    §8's execution-location model, not a reach into dired's private
    table. What is guaranteed is that the failure stays *coherent*: the
    suggestion always describes the directory the run will use.
 - **Journey arc (P1) — Stage 1a LANDED**
  (`docs/journey-stage1a-framing.md`). `pmacs .` opens a directory
  instead of exiting 1, on **one** path: `resolve_target_buffer` gained a
--- a/docs/journey-stage1a-framing.md
+++ b/docs/journey-stage1a-framing.md
@ -230,6 +230,12 @@ Not in 1a — Stage 1b: a compile keybinding and `cargo build`/`test`
 defaults from the existing `ProjectKind::Cargo`, LSP spawn-failure
 guidance (§1.2), a welcome buffer.
 *(Correction, added by Stage 1b-1: there is no `ProjectKind::Cargo`. The
 variant is `ProjectKind::Rust`; this line inherited the error from
 `COHERENCE.md` §20, now recorded in its §24. Left in place rather than
 rewritten — this document records what was planned — but flagged so the
 wrong type name does not survive by being quoted.)*
 ---
 ## 2. Ground truth (scouted 2026-07-26, `main` @ `d400f30`; re-verified rev 4)
--- a/docs/journey-stage1b1-compile-defaults-framing.md
+++ b/docs/journey-stage1b1-compile-defaults-framing.md
@ -0,0 +1,691 @@
 # Journey Stage 1b-1 — make building discoverable
 **Status: framing, rev 2 — awaiting review round 2.**
 **Serves `COHERENCE.md` §2 (the golden product journey, step 9), §19
 (coherence acceptance tests), §20 Priority 1.**
 ## 0. Revision history
 - rev 2 (2026-07-30) — review round 1. Two blocking, two major; all four
  accepted, all four verified in the code first.
  - **§3.1 did not actually prevent the drift it claimed to.**
    `pmacs.minibuffer.read` is asynchronous: `on_accept` runs later, and
    the active window can change while the prompt is open. `run` then
    re-resolved the cwd from whatever was active *at accept time*, so the
    prompt could say `cargo build` for A and execute in B. **Sharing one
    resolver is not enough — the resolution has to be captured.** The
    interactive `fn` now captures `context()` and passes its `cwd`
    through to `run`. This is the Stage 1a lesson repeating: the
    destination is captured at request time, not re-derived at commit
    time (`commit_to`, §4.4 of that framing).
  - **No pin accepted the prompt or observed a spawned run.** N1–N5 all
    compared values that the prompt and the resolver had already agreed
    on; a wrong cwd inside `on_accept` — exactly the defect above —
    passed every one of them. Two pins now cross the accept boundary:
    N3 (the captured directory survives a window switch) and N4 (accept
    `cargo build` in a real Cargo fixture, assert the `Directory:` header
    and a clean exit).
  - **N3's named falsifier was not discriminating.**
    `project_root_of_active()` already detects from the active file and
    returns the *innermost* root, so re-detecting from that root yields
    `node` again in `mixed_fixture/sub`. The mutation rev 1 named would
    have left the pin green. N3 is repurposed to the prompt-to-run
    handoff, and the mixed-fixture pin (now N5) states a falsifier it
    actually catches.
  - **§6.1 contradicted §3.1.** A Cargo *workspace subdirectory*
    contains no `Cargo.toml` and correctly receives `cargo build`, so
    "never offered `cargo build` for a directory with no `Cargo.toml`"
    was false on the design's own terms. Reworded to *no detected Cargo
    project*.
 - rev 1 (2026-07-30) — first framing. Scouted against `githubsucks/main`
  @ `22df6ab` (test-ambient isolation framing #201).
 ## 1. What this stage is, and what it is not
 `COHERENCE.md` §20 Priority 1 names the remainder of the journey arc:
 > Journey Stage 1b is the named remainder: the compile binding + Cargo
 > defaults, LSP spawn guidance, and the welcome buffer.
 Those three are unrelated in mechanism, in failure mode, and in cost.
 This stage takes **only the first**: journey step 9, *build or test the
 project*. LSP spawn guidance (step 6) and the welcome buffer (step 4)
 get their own stages; §7 states the split and why.
 Nothing here is a new Rust primitive. The stage is Lua, tests, and docs.
 ## 2. Ground truth
 Every claim below was read in the tree at `22df6ab`, not inferred from a
 name.
 ### 2.1 `compile.run` has no binding, and the docs say so
 `compile.lua` binds four global sequences (`:1183-1188`): `M-g n`,
 `M-g p`, `C-x \``, `M-!`. `bind_slot_keys` (`:220-240`) binds
 `RET`/`n`/`p`/`q`/`C-c C-k`/`g` at **buffer** scope inside a generated
 buffer. `builtin/keymaps/default.lua` never mentions compile. There is
 no third keymap file — `builtin/keymaps/` contains `default.lua` alone.
 `docs/keybindings.md:191-192` states it outright:
 > `compile.run` and `compile.recompile` are available through `M-x`; no
 > global key is assigned to them.
 ### 2.2 The first prompt is empty
 ```lua
 -- builtin/runtime/compile.lua:1131-1144
 name = "compile.run",
 fn = function()
  local last = pmacs.compile._last
  pmacs.minibuffer.read {
    prompt = "Compile command: ",
    history = "compile",
    initial = last and last.cmdline or "",
 ```
 `_last` is set only by a completed `pmacs.compile.run` (`:1094`), so on a
 fresh session `initial` is `""`. The user is asked what to build and
 given nothing to build with.
 `initial` does reach the user: `Minibuffer::begin` calls
 `replace_contents(&session.initial)` (`src/minibuffer.rs:106-107`), and
 `contents()` (`:129`) reads it back. The prefill mechanism works; it is
 handed an empty string.
 ### 2.3 `ProjectKind::Cargo` does not exist — the variant is `Rust`
 **`COHERENCE.md` is wrong here, in two places.** Its §2 step-9 row and
 its §20 Priority 1 paragraph both say "`ProjectKind::Cargo` existing
 (`src/project.rs:77`)". Line 77 is a doc comment; the variant on line 78
 is `Rust`:
 ```rust
 // src/project.rs:77-78
 /// A Cargo workspace (`Cargo.toml`).
 Rust,
 ```
 The marker that produces it is `{ name: "Cargo.toml", kind:
 ProjectKind::Rust, is_directory: false }` (`:148-150`). The audit read
 the comment and named the comment. This framing corrects both COHERENCE
 sites (§8).
 The correction is not cosmetic: it decides what the Lua side matches on.
 ### 2.4 Lua already sees the project kind — as a tag string
 `pmacs.project.detect(path)` returns a table (`src/lua_bindings/mod.rs:11683-11694`):
 ```rust
 t.set("root", root.display().to_string())?;
 t.set("kind", kind.tag())?;
 t.set("language_id", kind.default_language_id())?;
 ```
 `ProjectKind::Rust.tag()` is `"rust"` (`src/project.rs:101`). So the Lua
 key is the string `"rust"`, and **no Rust change is needed to learn the
 project kind**.
 `detect` accepts a directory as well as a file: `walk_for_marker` uses
 `start` unchanged when it is not a file (`src/project.rs:225-229`).
 ### 2.5 The cwd is resolved *inside* `run`, after the prompt has closed
 ```lua
 -- builtin/runtime/compile.lua:765
 local cwd = opts.cwd or project_root_of_active() or daemon_working_directory()
 ```
 The interactive `fn` that builds the prompt cannot see this. Any
 suggestion computed in the `fn` today would be computed from a different
 rule than the one the run obeys — which is the failure this stage must
 not ship. §3.1 is about closing that gap before adding the suggestion,
 not after.
 ### 2.6 The active buffer at the journey moment is **pathless**
 `project_root_of_active()` (`:600-609`) needs `buf:path()`. Directly
 after `pmacs .` the active buffer is dired's, created by
 `pmacs.buffer.create(name)` (`dired.lua:506`) — a name, never a path.
 `buf:path()` returns `file_path()` mapped to a string
 (`src/lua_bindings/mod.rs:1242-1248`), so it is `nil`.
 This is not a guess. dired itself compensates, and its own helper is the
 evidence:
 ```lua
 -- builtin/runtime/dired.lua:205-217
 local function current_directory()
  local buf = pmacs.window.buffer()
  if buf ~= nil then
    local ok, path = pcall(function() return buf:path() end)
    if ok and path then ... end
    local h = handle_for_buffer(buf)     -- <-- the pathless case
    if h then return h.path end
  end
  return canonicalize(".")
 end
 ```
 `handle_for_buffer` is a **module-local** table. Compile cannot reach it,
 and reaching for it would make compile depend on dired — a new
 interaction island for one directory string. §5 decides against it and
 §6 states the residual gap.
 ### 2.7 The last-resort cwd is the *process* cwd, evaluated at call time
 `daemon_working_directory()` reads
 `pmacs.instance.identity().working_directory`, which is:
 ```rust
 // pmacs-protocol/src/message.rs:1703-1706
 working_directory: std::env::current_dir()
    .ok()
    .map(|p| p.to_string_lossy().into_owned())
    .unwrap_or_default(),
 ```
 Two consequences, both load-bearing:
 - **In production**, `pmacs .` is launched from the project directory, so
  the fallback happens to be right. `pmacs ~/code/proj` launched from
  `~` resolves to `~`, and the fallback is wrong. That is a pre-existing
  step-9 defect this stage does not fix (§6.1).
 - **In tests**, it is the *test runner's* cwd — the pmacs repo root,
  **which is a Cargo project**. `compile_mode_acceptance.rs:1721-1733`
  already pins exactly this (`r1f8_inherited_cwd_resolves_to_the_daemon_working_directory`),
  and `:1382` already warns that "fallback would search the test
  process's cwd". Any pin that asserts *no* Cargo suggestion is at the
  mercy of where `cargo test` was invoked unless it is designed to never
  reach the fallback. §5.2 designs for that; it is the single largest
  trap in this stage.
 ### 2.8 `C-c c` is free, and `C-c` is not CUA copy
 Global `C-c` sequences in the tree: `C-c a`/`f`/`h`/`H`/`i`/`o`/`r`/`s`/`y`
 (`lsp.lua`), `C-c t` (`terminal.lua:203`), `C-c @ …` (folding).
 `C-c c` is unbound. Copy is `M-w` (`builtin/keymaps/default.lua:114`) —
 the CUA trio was deliberately not taken — so binding under the `C-c`
 prefix collides with nothing in the default map.
 `terminal.lua` binds its own `C-c t`; `lsp.lua` binds its own `C-c o`.
 A runtime module owning its global binding is the established pattern,
 and this stage follows it rather than editing `default.lua`.
 ### 2.9 dired already decided the prompt shape
 `C-x d` prefills its prompt and **deliberately refuses a completion
 source** (`dired.lua:749-756`): a candidate list makes RET-on-empty open
 whatever sorts first, and a selected candidate shadows typed text. The
 same reasoning applies to a compile command, so this stage prefills and
 adds no completion source.
 ## 3. Design
 ### 3.1 One resolution, consumed twice
 Extract the `:765` expression into a helper and expose a read-only view
 of it:
 ```lua
 local function resolve_cwd(explicit)
  return explicit or project_root_of_active() or daemon_working_directory()
 end
 --- Where the next compile would run, and what kind of project is
 --- detected *from that directory*. Public getter (API conventions):
 --- `{ cwd = string|nil, kind = string|nil }`.
 function pmacs.compile.context(explicit_cwd)
 ```
 `run` calls `resolve_cwd(opts.cwd)`; the interactive `fn` calls
 `pmacs.compile.context()`.
 **Sharing the resolver is necessary and not sufficient.**
 `pmacs.minibuffer.read` is asynchronous — `on_accept` runs an arbitrary
 time later, and nothing freezes the active window while a prompt is
 open. A mouse click, a second frontend, or a background open can change
 what `project_root_of_active()` answers between the prompt and the RET.
 Two calls to the same resolver at two different moments are still two
 different answers, and the user is then shown a suggestion for A and
 given a run in B.
 So the interactive command **captures** the resolution and hands it
 through:
 ```lua
 fn = function()
  local last = pmacs.compile._last
  local ctx  = pmacs.compile.context()          -- captured once, here
  pmacs.minibuffer.read {
    prompt  = "Compile command: ",
    history = "compile",
    initial = last and last.cmdline or default_for(ctx.kind) or "",
    on_accept = function(cmdline)
      if cmdline == nil or cmdline == "" then return end
      pmacs.compile.run(cmdline, { cwd = ctx.cwd })   -- the same ctx
    end,
  }
 end
 ```
 This is Journey Stage 1a's `commit_to` lesson on a smaller seam: the
 destination is captured when the request is made and revalidated at
 commit, never re-derived from whatever happens to be ambient when the
 async work lands. The mechanism differs — compile needs no scope
 override, only the value — but the failure it prevents is the same one.
 `ctx.cwd` is passed through verbatim, **including `nil`**. A `nil` cwd
 means every resolution step failed, and `run`'s header renders
 `(unknown)` exactly as it does today; substituting a re-resolution there
 would reintroduce the drift for the one case least able to tolerate it.
 **Only the interactive command captures.** `pmacs.compile.run(cmdline)`
 called programmatically still resolves at call time, which is what a
 caller with no prompt in between means by "here".
 With both halves in place: **the suggestion is a function of the
 directory the command will execute in**, and the two cannot drift —
 neither across the two resolutions nor across the wait for input.
 `kind` is `pmacs.project.detect(cwd).kind` — detection *from* the cwd,
 which is not the same as "the cwd is the root": `opts.cwd = /proj/src`
 in a Cargo workspace yields kind `rust` with root `/proj`. That is
 correct (cargo works from a subdirectory) and is stated so a reader does
 not read `kind` as "this directory is a project root".
 `project_root_of_active()` already calls `detect` once to get a root;
 `context` then calls it again on the result. The second call is
 redundant in that branch and is kept anyway, because the alternative is
 two different rules for where `kind` comes from depending on which
 branch produced the cwd. One rule, stated as: **`kind` is always
 `detect(cwd)`.**
 ### 3.2 The default table
 ```lua
 --- Default compile command per detected project kind, keyed by the
 --- tag `pmacs.project.detect` returns. Assign into this table from
 --- `init.lua` to add or override one.
 pmacs.compile.defaults = { rust = "cargo build" }
 ```
 **Only `rust` is seeded, and that is a decision rather than an
 omission.** Rust has one answer. Node does not (`npm` / `yarn` / `pnpm`
 / a `scripts.build` that may not exist); Python does not; Go's build and
 test are different commands with equal claim. A wrong prefill is worse
 than an empty one — the user must first delete it, then type. The table
 exists so a user or a package can add the answer *they* know.
 `cargo test` is reachable by editing the prefill. The prompt prefills
 one string; offering both would need a candidate list, which §2.9
 already ruled out for this prompt.
 ### 3.3 Precedence at the prompt
 ```
 last.cmdline          -- unchanged; a session that has compiled keeps its command
  or defaults[kind]   -- new
  or ""               -- unchanged
 ```
 `last` winning is deliberate: a user who ran `cargo test` once should get
 `cargo test` back, not be reset to `cargo build`. This is a preservation
 pin (§5.4, P1), not an accident of ordering.
 ### 3.4 The table is user-writable, so reading it is guarded
 `pmacs.compile.defaults` is public and assignable, which means a
 metatable with a throwing `__index`, a non-string value, or a
 non-table replacement all have to be survivable. The module already
 holds this discipline for a hostile rule container (`validated_rules`,
 round-2 finding 3: shell-command "must neither surface compile-rule
 warnings nor fail on a hostile rule container").
 The lookup therefore runs under `pcall` and accepts a value only when it
 is a non-empty string. Anything else yields `""` — the pre-stage
 behavior. **A broken `defaults` degrades to today's prompt; it never
 prevents compiling.**
 ### 3.5 The binding
 ```lua
 pmacs.keymap.bind { scope = "global", sequence = "C-c c", command = "compile.run" }
 ```
 In `compile.lua`, beside the four existing global binds (§2.8).
 Two reachability limits it inherits, both pre-existing and both stated
 rather than discovered later:
 - Inside a **terminal** window `C-c` is consumed as the escape key, so
  `C-c c` does not arrive. `COHERENCE.md` §2 already records this for
  `C-c t`. `M-x compile.run` still works there.
 - The repl package binds `C-c` at **buffer** scope
  (`builtin/packages/repl/init.lua:300`), which shadows the global
  prefix in a repl buffer. Same escape hatch.
 `compile.recompile` gets no global binding: `g` in `*compilation*`
 already covers rerun, and adding a second global chord for it is scope
 this stage has no journey argument for.
 ## 4. What this changes for the journey
 Walking `COHERENCE.md` §2 on a Rust project, unconfigured:
 | | before | after |
 |---|---|---|
 | launch | `pmacs .` lists the directory (Stage 1a) | unchanged |
 | open a file | `RET` visits it (Stage 1a) | unchanged |
 | build | *no key exists*; `M-x compile.run` → empty prompt | `C-c c` → `Compile command: cargo build` |
 | accept | — | RET runs it in the detected root |
 | errors | `M-g n` walks them | unchanged |
 Step 9's verdict row moves from **Partial** to **Works**; step 10 stops
 being gated on the user already knowing `M-x compile.run`.
 ## 5. Acceptance
 ### 5.0 Two labels, as Stage 1a established
 **N** — new behavior, must fail on full revert. **P** — preservation,
 legitimately green on the pre-image, falsified only by a named targeted
 mutation. Stage 1a's §6.0 is the reason the distinction is kept: an
 equivalence assertion between two implementations that already agree
 proves nothing.
 Every pin below names the mutation that falsifies it. `scripts/bite` is
 run against the suite before the PR opens.
 ### 5.1 Where the pins live
 - **`tests/journey_acceptance.rs`** gains a step-9 section. This file is
  the ratchet — *stages add rows, none removes them*. Its pins go
  through the **real** entry points: `EditorState::open` on a directory,
  a dispatched `RET`, a dispatched `C-c c`. Nothing calls
  `pmacs.compile.context()` directly in this file.
 - **`tests/compile_mode_acceptance.rs`** gains the module-contract pins:
  `context()`'s shape, and the hostile-table guards.
 ### 5.2 The fixture problem, and its only safe shape
 Per §2.7, the last-resort cwd is the test runner's cwd, and the test
 runner's cwd is a Cargo project. **A pin that asserts "no `cargo build`
 suggestion" and reaches the fallback will report the pmacs repo's own
 `Cargo.toml` as the fixture's answer.** It would pass or fail on where
 `cargo test` was invoked from.
 The negative pins are therefore built so the fallback is **never
 consulted**: the fixture carries a *different* project marker, so
 `project_root_of_active()` resolves inside the fixture and returns
 before `daemon_working_directory()` is reached.
 ```
 rust_fixture/            Cargo.toml, main.rs
 mixed_fixture/           Cargo.toml, main.rs
  sub/                   package.json, index.js
 ```
 `mixed_fixture` is what makes N5 discriminating: the file opened is
 `sub/index.js`, the nearest marker is `package.json` (kind `node`, no
 default), and the *outer* marker is Cargo. A suggestion computed from
 anything other than the resolved cwd — the outermost marker, the launch
 directory, the process cwd — produces `cargo build` here. The correct
 implementation produces `""`.
 `pmacs.project.set_search_boundary` is set to the fixture root in each
 test that detects, so a stray marker above the tempdir (a developer's
 `/tmp/.git`) cannot leak in. Note what it does **not** do: it clamps the
 upward walk from a start *below* the boundary, so it is no protection at
 all for the fallback path, whose start is the repo root. That is why the
 fixture shape above, not the boundary call, is the actual defense.
 ### 5.3 New-behavior pins
 **N1 — the chord reaches the command.**
 Launch on `rust_fixture`, `RET` on `main.rs`, dispatch `C-c c`; assert
 `pmacs.minibuffer.is_active()`.
 *Falsifier:* remove the `keymap.bind` line — the chord is unbound, no
 session opens.
 *Why it is separate from N2:* a prefill assertion alone would stay green
 if the binding were removed and the prompt were opened some other way.
 The binding is the thing COHERENCE says is missing; it gets its own pin.
 **N2 — the prompt is prefilled from the project kind.**
 Same walk; assert `pmacs.minibuffer.contents() == "cargo build"`.
 *Falsifier:* drop the `defaults[kind]` term from the precedence chain —
 contents become `""`.
 **N3 — the prompt's directory survives a window switch.**
 Launch on `rust_fixture`, `RET` on `main.rs`, dispatch `C-c c` — the
 prompt is now open and has captured A. **Then open a file in a second,
 unrelated directory B**, so the active buffer's project is no longer A.
 Replace the minibuffer contents with `pwd` and dispatch `RET`.
 Assert `*compilation*` contains `Directory: <A>` **and** that `pwd`'s own
 output is `<A>` — two independent readings of the same claim, one from
 the header pmacs writes and one from the shell that actually ran.
 *Falsifier:* drop `{ cwd = ctx.cwd }` from `on_accept`, i.e. rev 1's
 design. `run` re-resolves at accept time, finds B, and both readings say
 B.
 *Why `pwd` and not `cargo build`:* the subject here is the directory, and
 a cheap command keeps the pin's failure message about the directory. N4
 is the pin that runs the real thing.
 *Why the contents are set rather than typed:* the prompt is opened
 through the real chord; only the editing of an already-open prompt is
 short-circuited, which is the same split `find_file_acceptance` documents
 at its head.
 **N4 — the offered command runs, in the offered directory.**
 A real Cargo fixture: `Cargo.toml`, `src/main.rs` with an empty `main`.
 Launch on it, `RET` on `main.rs`, dispatch `C-c c`, dispatch `RET`
 **without editing** — accepting exactly what was offered. Assert
 `*compilation*` contains `Directory: <fixture>` and the clean-exit marker
 `[compilation exited with code 0]`.
 *Falsifier:* the same `{ cwd = ... }` removal as N3, and independently
 any prefill that is not a runnable command.
 *Why this pin has to exist:* every other pin in this stage compares
 values that the prompt and the resolver already agree on. A wrong
 directory inside `on_accept` — the exact defect rev 1 shipped — passes
 all of them. This one crosses the accept boundary and observes a real
 process.
 *Operational detail:* the fixture builds into its own tempdir `target/`,
 so it takes no lock the enclosing `cargo test` holds and leaves nothing
 behind. The pin runs when `cargo` resolves on PATH and skips with a
 message otherwise; **`PMACS_REQUIRE_CARGO_BUILD` only tolerates
 absence** — presence of the binary decides execution, and the variable
 makes a missing binary fatal in CI. That is the `PMACS_REQUIRE_BASH`
 arming shape from #200, and it is stated here because getting the
 polarity backwards is how a required pin becomes a silent skip.
 *Named risk:* this is the only pin that depends on a working toolchain in
 the fixture directory. If it proves flaky in CI, the fallback is to keep
 the accept-and-observe shape and substitute a command with no toolchain
 dependency — the prompt-to-run handoff is the claim, and `cargo build` is
 the most faithful witness of it, not the only possible one.
 **N5 — the suggestion follows the directory the run will use.**
 Launch on `mixed_fixture`, `RET` into `sub/index.js`, dispatch `C-c c`;
 assert contents are `""` and `context().kind == "node"`.
 *Falsifier:* a rule that derives the kind from anything other than the
 resolved cwd. The plausible one is the **launch directory** — Stage 1a
 made it prominent, and `mixed_fixture` was launched on the Cargo root, so
 that rule yields `cargo build` here. So does deriving it from the process
 cwd.
 *What it does not catch, stated because rev 1 claimed otherwise:*
 re-detecting from `project_root_of_active()`'s answer. That helper
 already returns the **innermost** root, so detecting from it yields
 `node` again and this pin stays green. Rev 1 named that mutation as the
 falsifier; it is not one.
 **N6 — `context()` is total in a launched session.**
 Property, not a constant, because the value is environment-dependent
 (§2.7): after a launch, `context().cwd` is non-nil, and `context().kind`
 equals `pmacs.project.detect(context().cwd)`'s kind (both nil, or both
 the same string). Asserted with a dired buffer active — the pathless
 case — so the fallback branch is the one under test.
 *Falsifier:* make `resolve_cwd` return `nil` when the active buffer has
 no path, i.e. drop the `daemon_working_directory()` term.
 *What it deliberately does not assert:* which directory. Pinning that
 would pin the test runner's cwd.
 ### 5.4 Preservation pins
 **P1 — `_last` still outranks the kind default.**
 Run a compile with an explicit cmdline that is not `cargo build`, then
 open the prompt in the Rust fixture; assert the contents are the last
 cmdline.
 *Targeted mutation:* reorder the precedence chain to put `defaults[kind]`
 first. Green on the pre-image (there was no default), red under the
 mutation.
 **P2 — a hostile `defaults` cannot break compiling.**
 Three cases in `compile_mode_acceptance`: `defaults` replaced by a
 non-table; a `__index` metatable that raises; a non-string entry for
 `rust`. In all three the prompt opens with `""` and `compile.run` still
 executes a typed command.
 *Targeted mutation:* remove the `pcall` / type guard — the raising case
 propagates out of the command and no prompt opens.
 **P3 — the existing compile bindings are unchanged.**
 `M-g n`, `M-g p`, `C-x \``, `M-!` still dispatch to their commands, and
 `compile.run` is still reachable through `M-x`.
 *Targeted mutation:* the new `bind` call written as an `unbind`+`bind`
 pair over the wrong sequence.
 ### 5.5 Gates
 The full suite from `CLAUDE.md`, plus `compile_mode_acceptance`,
 `journey_acceptance`, `dired_acceptance`, and `find_file_acceptance` as
 the touched suites. Local runs must control all five bootstrap-storage
 variables (`XDG_CONFIG_HOME`, `XDG_DATA_HOME`, `XDG_STATE_HOME`,
 `XDG_CACHE_HOME`, `PMACS_STATE_HOME`) — the ambient-root isolation lane
 (#201) is **framing only**, so the workaround is still required and
 `compile_mode_acceptance` is one of the suites that goes red without it.
 ## 6. Named limitations — stated, not discovered later
 ### 6.1 `pmacs <dir>` from elsewhere still resolves the wrong cwd
 Launched as `pmacs ~/code/proj` from `~`, the active buffer is dired and
 pathless (§2.6), so the cwd falls through to the process cwd `~`
 (§2.7). Compile would then run in `~`, and — consistently, since §3.1
 ties them — suggest nothing.
 **This stage does not fix it.** The fix needs a notion of "the directory
 this session is working in" that is not any one module's private table,
 which is `COHERENCE.md` §8 (First-Class Execution Locations) — a model
 gap, not wiring. Reaching into dired's `handle_for_buffer` would make
 compile depend on dired for one string and add exactly the kind of
 interaction island §6 of COHERENCE is about.
 What this stage does guarantee is that the failure is **coherent**: the
 suggestion describes the directory the command will run in, whatever
 that directory turns out to be. The user is never offered `cargo build`
 for a directory with **no detected Cargo project**.
 That wording is load-bearing and rev 1 got it wrong. "No `Cargo.toml`"
 would have been false on this design's own terms: a Cargo *workspace
 subdirectory* contains no `Cargo.toml`, is correctly detected as `rust`
 by the ancestor walk, and correctly receives `cargo build` — which cargo
 itself runs happily from a subdirectory. The predicate is detection, not
 the presence of a file in that one directory (§3.1).
 N6 pins the property; it deliberately does not pin the value.
 ### 6.2 The default is per-kind, not configurable through the registry
 `pmacs.compile.defaults` is a plain Lua table, not a registered setting.
 It cannot be one: `ConfigValue` is four scalars, so a kind→command map
 is not expressible. A scalar `compile.default-command` that overrides
 the table *is* expressible and is **deferred, not skipped** — it is one
 more precedence step and a registry entry, and it belongs with the
 config-adoption work (§20 Priority 6) rather than bolted on here.
 ### 6.3 One binding does not retire the inversion
 `COHERENCE.md` §2 keeps a standing observation verbatim: keybinding
 coverage is inverted relative to frequency, with `C-c @ C-M-s` bound
 while opening a file, opening a terminal, and running a build were not.
 Two of the three have been answered (#162, #173); this stage answers the
 third, and §8 updates the paragraph accordingly. The *quote* stays as
 written, because it names a bias in how new work gets bound rather than
 three omissions.
 ## 7. Staging — why 1b is split
 `COHERENCE.md` §20 bundles three items under "Stage 1b". They share a
 priority and nothing else:
 | | subsystem | shape | risk |
 |---|---|---|---|
 | **1b-1** (this) | compile + project | wiring, Lua only | low |
 | 1b-2 | LSP lifecycle | a failure that is currently *silent* (§1.2) must become visible without becoming noise | medium |
 | 1b-3 | startup buffer | new content, plus §18's `C-h`-deletes-a-word problem | low, but touches the default keymap |
 One feature, one branch, one PR. 1b-2 is the hard one — the silence
 asymmetry is a design question about *when* to speak, not a wiring
 question — and bundling it with a keybinding would hold the cheapest
 journey fix in the tree behind the most contested one.
 ## 8. Coherence impact
 Per `CLAUDE.md` and `COHERENCE.md` §20's standing process change.
 - **Journey steps touched:** 9 directly (Partial → Works); 10 indirectly
  — it was "gated entirely on step 6 or 9 succeeding first".
 - **Interaction islands:** none added. The prompt is the existing
  minibuffer; the binding joins the existing `C-c` prefix; the kind
  comes from the existing detector. `pmacs.compile.defaults` is an
  extensible table, not a new modal surface.
 - **Config registry adoption:** none, deliberately — §6.2 gives the
  mechanism reason and names the deferred scalar.
 - **Background-work attribution:** unchanged. Compile already spawns
  through the process-group machinery; this stage changes what is typed
  into the prompt, not what is spawned or how it is tracked.
 - **Doc updates riding this PR** (§25 requires it):
  - `COHERENCE.md` §2 step-9 verdict row → Works, and the
    `ProjectKind::Cargo` → `ProjectKind::Rust` correction **in both
    places** (§2 row and §20 Priority 1). §24 gains the drift entry.
  - `COHERENCE.md` §2's post-table paragraph: "Running a build still has
    no binding" → answered, with the quote itself left intact (§6.3).
  - `docs/keybindings.md`: the `C-c c` row, and the removal of the
    "no global key is assigned to them" sentence at `:191`.
  - `docs/agent-handoff.md` §1: the journey arc bullet gains Stage 1b-1.
 ## 9. Open questions for review
 - **Q#J1 — is `C-c c` the right chord?** It is free, it is under the
  established `C-c` prefix, and it matches what most Emacs distributions
  bind compile to. The alternative worth naming is `C-c C-c`, which is
  more finger-friendly but is the chord many major modes claim
  buffer-locally, so a global one would be shadowed unpredictably later.
 - **Q#J2 — should `rust` be the only seeded default?** §3.2 argues yes
  on the grounds that a wrong prefill costs more than an empty one. The
  counter-argument is that `go build` and `make` are about as
  unambiguous as `cargo build`, and seeding them would make the table
  read as a real registry rather than a Rust special case.
 - **Q#J3 — should the prefill be selected, so typing replaces it?**
  Emacs leaves the prefill unselected and the point at the end. dired's
  prefill does the same. Matching them means "accept" is RET and
  "replace" is a kill-line first. Changing it is a minibuffer-wide
  behavior change and out of scope, but it is the ergonomic difference a
  user will notice first.
 ## 10. Ledger
 Branch `journey-stage1b1-compile-defaults`, worktree
 `../pmacs-journey-1b1`, based on `githubsucks/main` @ `22df6ab`.
 Framing only; no code, no PR yet.
 Recovery from a clean checkout — the two-argument form of
 `git worktree add` does not work for a remote-only branch (it fails with
 `fatal: invalid reference`, because after a bare fetch no local branch
 exists):
 ```sh
 git fetch githubsucks
 git worktree add ../pmacs-journey-1b1 \
  -b journey-stage1b1-compile-defaults \
  githubsucks/journey-stage1b1-compile-defaults
 ```
--- a/docs/keybindings.md
+++ b/docs/keybindings.md
@ -187,9 +187,13 @@ Source: `builtin/runtime/compile.lua`.
 | `M-g n` / `M-g p` | `error.next` / `error.previous` — compile/grep errors when that source has claimed navigation, otherwise LSP diagnostics |
 | `` C-x ` `` | `error.next` |
 | `M-!` | `shell.command` — asynchronous output in `*shell-command*` |
 | `C-c c` | `compile.run` — prompts, prefilled from the detected project kind |
-`compile.run` and `compile.recompile` are available through `M-x`; no
+`compile.recompile` is available through `M-x`, and through `g` inside
-global key is assigned to them.
+`*compilation*`; no global key is assigned to it. `C-c c` is unreachable
 from inside a terminal window (`C-c` is consumed as the escape key) and
 inside a repl buffer (which binds `C-c` at buffer scope); `M-x
 compile.run` still works in both.
 ## 2. Buffer-local panel keymaps
--- a/tests/compile_mode_acceptance.rs
+++ b/tests/compile_mode_acceptance.rs
@ -2750,3 +2750,106 @@ fn r5f3_tracked_line_start_matches_the_scan_across_transitions() {
        "every rewind lands at the tracked line start; buffer:\n{text:?}"
    );
 }
 // ---------------------------------------------------------------------------
 // Journey Stage 1b-1 — `pmacs.compile.defaults` is public and assignable
 //
 // The table is user-writable, so a metatable with a throwing `__index`, a
 // non-string entry, and a non-table replacement all have to be
 // survivable — the same discipline `validated_rules` keeps for a hostile
 // rule container. A broken `defaults` must degrade to the pre-stage empty
 // prompt; it must never prevent compiling.
 // ---------------------------------------------------------------------------
 /// Open the compile prompt and return what it offered.
 fn compile_prompt_initial(s: &EditorState) -> String {
    exec(s, "pmacs.command.invoke('compile.run')");
    assert!(
        eval::<bool>(s, "return pmacs.minibuffer.is_active()"),
        "compile.run must open a prompt even with a hostile defaults table"
    );
    eval(s, "return pmacs.minibuffer.contents()")
 }
 #[test]
 fn j1b1_a_non_table_defaults_degrades_to_an_empty_prompt() {
    let s = editor();
    exec(&s, "pmacs.compile.defaults = 42");
    assert_eq!(compile_prompt_initial(&s), "");
 }
 #[test]
 fn j1b1_a_raising_defaults_index_degrades_to_an_empty_prompt() {
    let s = editor();
    exec(
        &s,
        "pmacs.compile.defaults = setmetatable({}, {
             __index = function() error('hostile') end,
         })",
    );
    assert_eq!(compile_prompt_initial(&s), "");
 }
 #[test]
 fn j1b1_a_non_string_default_is_ignored() {
    let s = editor();
    exec(&s, "pmacs.compile.defaults = { rust = {}, }");
    assert_eq!(compile_prompt_initial(&s), "");
 }
 #[test]
 fn j1b1_a_hostile_defaults_still_lets_a_typed_command_run() {
    // The consequence that matters: degradation must not cost the user
    // the ability to compile. Asserts output produced, not a property
    // preserved.
    let mut s = editor();
    exec(
        &s,
        "pmacs.compile.defaults = setmetatable({}, {
             __index = function() error('hostile') end,
         })",
    );
    // Through the INTERACTIVE command, so the hostile lookup actually
    // happens. Calling `pmacs.compile.run` directly never consults
    // `defaults` at all, which made an earlier draft of this pin vacuous
    // — it passed with the guard removed.
    exec(&s, "pmacs.command.invoke('compile.run')");
    assert!(
        eval::<bool>(&s, "return pmacs.minibuffer.is_active()"),
        "the prompt must still open"
    );
    exec(&s, "pmacs.minibuffer.set_contents('echo still-compiles')");
    exec(&s, "pmacs.minibuffer.accept()");
    assert!(
        pump_until(&mut s, 10_000, |s| {
            compilation_text(s).contains("still-compiles")
        }),
        "a broken defaults table must not prevent compiling; got:\n{}",
        compilation_text(&s)
    );
 }
 #[test]
 fn j1b1_context_reports_the_cwd_a_run_would_use() {
    // `pmacs.compile.context` and `pmacs.compile.run` must answer from
    // one resolution — an explicit cwd is honoured by both, and the kind
    // is detected from that same directory.
    let s = editor();
    let dir = tempfile::tempdir().expect("tempdir");
    std::fs::write(dir.path().join("Cargo.toml"), b"[package]\nname=\"x\"\n").expect("write");
    exec(
        &s,
        &format!(
            "pmacs.project.set_search_boundary({:?})",
            dir.path().display().to_string()
        ),
    );
    let kind: String = eval(
        &s,
        &format!(
            "return pmacs.compile.context({:?}).kind",
            dir.path().display().to_string()
        ),
    );
    assert_eq!(kind, "rust", "the kind is detected from the given cwd");
 }
--- a/tests/journey_acceptance.rs
+++ b/tests/journey_acceptance.rs
@ -1297,3 +1297,448 @@ fn preservation_display_file_still_refuses_a_directory() {
        "a refused display_file must not create a buffer"
    );
 }
 // ---------------------------------------------------------------------------
 // Step 9 — build or test the project (Journey Stage 1b-1)
 //
 // `COHERENCE.md` §2 graded this **Partial**: `M-x compile.run` worked but
 // had no keybinding, an empty first prompt, and no `cargo build`
 // suggestion. These rows are the ratchet for the three.
 //
 // The trap these fixtures are built around: compile's last-resort cwd is
 // `std::env::current_dir()` evaluated at call time, which under `cargo
 // test` is the **pmacs repo root — itself a Cargo project**
 // (`compile_mode_acceptance.rs` pins exactly that). So any pin asserting
 // the *absence* of a Cargo suggestion must be shaped so the fallback is
 // never consulted: each fixture carries its own marker, and
 // `project_root_of_active()` therefore answers from inside the fixture.
 // `set_search_boundary` is not the defence — it clamps only a walk that
 // starts below the boundary, and the fallback's walk starts at the repo.
 // ---------------------------------------------------------------------------
 fn ctrl(s: &mut EditorState, c: char) {
    s.dispatch_key(
        FrontendId::LOCAL,
        key(KeyCode::Char(c), KeyModifiers::CONTROL),
    );
 }
 /// Open the compile prompt through the real `C-c c` binding.
 fn press_compile_chord(s: &mut EditorState) {
    ctrl(s, 'c');
    type_char(s, 'c');
 }
 /// A Cargo project a journey can plausibly be run against.
 fn cargo_project() -> TempDir {
    let td = tempfile::tempdir().expect("tempdir");
    std::fs::write(
        td.path().join("Cargo.toml"),
        b"[package]\nname = \"journey-fixture\"\nversion = \"0.1.0\"\nedition = \"2021\"\n",
    )
    .expect("write Cargo.toml");
    std::fs::create_dir_all(td.path().join("src")).expect("mkdir src");
    std::fs::write(td.path().join("src/main.rs"), b"fn main() {}\n").expect("write main.rs");
    td
 }
 /// Clamp detection to the fixture so a stray marker above the tempdir
 /// (a developer's `/tmp/.git`) cannot leak in.
 fn bound_detection_to(s: &EditorState, dir: &Path) {
    exec(
        s,
        &format!(
            "pmacs.project.set_search_boundary({:?})",
            dir.display().to_string()
        ),
    );
 }
 /// The project root as **detection** reports it.
 ///
 /// `pmacs.project.detect` canonicalizes before walking
 /// (`canonicalize_or_passthrough`, `src/project.rs:509-511`), so a
 /// `/var/folders/...` tempdir on macOS comes back as
 /// `/private/var/folders/...`. `canon()` is *lexical* — it never
 /// resolves symlinks — so it is the wrong expectation for any value
 /// that has passed through detection, which is exactly what the compile
 /// cwd is. Using it here failed both macOS CI legs while Ubuntu (where
 /// `/tmp` is not a symlink) stayed green.
 fn detected_root(path: &Path) -> String {
    std::fs::canonicalize(path)
        .unwrap_or_else(|_| path.to_path_buf())
        .to_string_lossy()
        .into_owned()
 }
 fn minibuffer_active(s: &EditorState) -> bool {
    eval(s, "return pmacs.minibuffer.is_active()")
 }
 fn minibuffer_contents(s: &EditorState) -> String {
    eval(s, "return pmacs.minibuffer.contents()")
 }
 fn named_text(s: &EditorState, name: &str) -> String {
    eval(
        s,
        &format!(
            r#"
            for _, id in ipairs(pmacs.buffer.list()) do
                if pmacs.describe.buffer(id).name == {name:?} then
                    return id:slice(0, id:len())
                end
            end
            return ""
            "#
        ),
    )
 }
 /// Drive frames until `pred` holds, pumping the process supervisor as
 /// well as the async runtime — a compile run is a spawned child.
 fn pump_processes_until(
    s: &mut EditorState,
    timeout_ms: u64,
    mut pred: impl FnMut(&EditorState) -> bool,
 ) -> bool {
    let stop = Instant::now() + Duration::from_millis(timeout_ms);
    loop {
        if pred(s) {
            return true;
        }
        if Instant::now() >= stop {
            return false;
        }
        s.tick_processes();
        s.tick_async();
        std::thread::sleep(Duration::from_millis(5));
    }
 }
 /// Walk the journey to the point where a build would be run: launch on
 /// the directory, then `RET` on `name` to open a file.
 fn walk_to_open_file(dir: &Path, name: &str) -> EditorState {
    let mut s = launch(dir);
    bound_detection_to(&s, dir);
    let line = line_of(&s, name);
    exec(&s, &format!("pmacs.editor.move_to_line({line})"));
    press(&mut s, KeyCode::Enter);
    pump(&mut s);
    assert_eq!(
        active_name(&s),
        dir.join(name).display().to_string(),
        "precondition: the walk must actually open the file, or every pin \
         below is really testing the dired buffer"
    );
    s
 }
 /// **N** — `C-c c` reaches `compile.run`. Separate from N2 because a
 /// prefill assertion alone stays green if the binding is removed and the
 /// prompt is opened another way — and the binding is the thing
 /// `COHERENCE.md` says is missing.
 #[test]
 fn journey_step9_the_compile_chord_opens_the_prompt() {
    let td = cargo_project();
    let mut s = walk_to_open_file(td.path(), "Cargo.toml");
    press_compile_chord(&mut s);
    assert!(
        minibuffer_active(&s),
        "C-c c must open the compile prompt; active buffer is {}",
        active_name(&s)
    );
 }
 /// **N** — the prompt is prefilled from the detected project kind.
 #[test]
 fn journey_step9_the_prompt_is_prefilled_for_a_cargo_project() {
    let td = cargo_project();
    let mut s = walk_to_open_file(td.path(), "Cargo.toml");
    press_compile_chord(&mut s);
    assert_eq!(
        minibuffer_contents(&s),
        "cargo build",
        "a Rust project's first compile prompt must offer its build command"
    );
 }
 /// **N** — the directory the prompt captured survives a window switch.
 ///
 /// The prompt is opened against A, the active buffer then moves to an
 /// unrelated directory B, and only then is the command accepted. Both
 /// readings — the header pmacs writes and the shell's own `pwd` — must
 /// say A. Falsified by dropping `{ cwd = ctx.cwd }` from `on_accept`,
 /// which is what re-resolving at accept time looks like.
 #[test]
 fn journey_step9_the_prompt_runs_in_the_directory_it_captured() {
    let a = cargo_project();
    let b = project();
    let mut s = walk_to_open_file(a.path(), "Cargo.toml");
    press_compile_chord(&mut s);
    assert!(minibuffer_active(&s), "prompt must be open against A");
    // Move the active buffer to B while the prompt waits for input.
    exec(
        &s,
        &format!(
            "pmacs.window.display_file({:?})",
            b.path().join("alpha.txt").display().to_string()
        ),
    );
    pump(&mut s);
    // Accept a cheap command: the subject is the directory, so a fast
    // one keeps the failure message about the directory. Only the
    // editing of an already-open prompt is short-circuited; the prompt
    // itself was opened through the real chord.
    exec(&s, "pmacs.minibuffer.set_contents('pwd')");
    press(&mut s, KeyCode::Enter);
    let finished = pump_processes_until(&mut s, 10_000, |s| {
        named_text(s, "*compilation*").contains("exited")
    });
    assert!(finished, "the accepted run must finish");
    let text = named_text(&s, "*compilation*");
    // Detection-canonical, not lexical: the compile cwd came from
    // `pmacs.project.detect`, and `pwd` reports the physical directory.
    let a_path = detected_root(a.path());
    assert!(
        text.contains(&format!("Directory: {a_path}")),
        "the header must name the directory the prompt captured, not the newly active one;\n{text}"
    );
    assert!(
        text.contains(&a_path),
        "and `pwd` must agree with the header;\n{text}"
    );
 }
 /// **N** — the offered command runs, in the offered directory.
 ///
 /// Every other pin here compares values the prompt and the resolver
 /// already agree on. A wrong directory inside `on_accept` passes all of
 /// them. This one accepts what was offered, unedited, and observes a
 /// real process.
 #[test]
 fn journey_step9_the_offered_command_builds_the_project() {
    if !binary_available("cargo") {
        assert!(
            std::env::var_os("PMACS_REQUIRE_CARGO_BUILD").is_none(),
            "PMACS_REQUIRE_CARGO_BUILD is set but `cargo` is not on PATH"
        );
        eprintln!("skipping: `cargo` is not on PATH");
        return;
    }
    let td = cargo_project();
    let mut s = walk_to_open_file(td.path(), "Cargo.toml");
    press_compile_chord(&mut s);
    assert_eq!(
        minibuffer_contents(&s),
        "cargo build",
        "precondition: the prompt offers the build command"
    );
    // Accept exactly what was offered — no editing.
    press(&mut s, KeyCode::Enter);
    let finished = pump_processes_until(&mut s, 120_000, |s| {
        named_text(s, "*compilation*").contains("exited")
    });
    assert!(finished, "the offered build must finish");
    let text = named_text(&s, "*compilation*");
    assert!(
        text.contains(&format!("Directory: {}", detected_root(td.path()))),
        "the build runs in the detected project root;\n{text}"
    );
    assert!(
        text.contains("[compile exited with code 0]"),
        "and the command that was offered is one that actually runs;\n{text}"
    );
    // Positive control on the run itself. A clean exit alone does not
    // prove cargo compiled anything — this names the fixture crate, so
    // the pin fails if the offered command ever stops being a build.
    assert!(
        text.contains("journey-fixture"),
        "cargo must actually have built the fixture crate;\n{text}"
    );
 }
 /// **N** — the suggestion follows the directory the run will use.
 ///
 /// A Node project nested inside a Cargo one, opened at the *inner* file.
 /// Falsified by deriving the kind from the launch directory (the Cargo
 /// root here) or from the process cwd — both yield `cargo build`.
 ///
 /// It does **not** catch re-detecting from `project_root_of_active()`'s
 /// answer: that helper already returns the innermost root, so detecting
 /// from it yields `node` again and this pin stays green.
 #[test]
 fn journey_step9_a_nested_project_gets_its_own_kind_not_the_outer_one() {
    let outer = cargo_project();
    let sub = outer.path().join("sub");
    std::fs::create_dir_all(&sub).expect("mkdir sub");
    std::fs::write(sub.join("package.json"), b"{ \"name\": \"inner\" }\n").expect("write pkg");
    std::fs::write(sub.join("index.js"), b"console.log(1)\n").expect("write index.js");
    let mut s = walk_to_open_file(&sub, "index.js");
    press_compile_chord(&mut s);
    // `minibuffer_contents` is "" both for an empty prefill and for no
    // minibuffer at all, so the emptiness assertion below is vacuous
    // without this. Bite A caught it: with the binding removed this pin
    // stayed green while six others failed.
    assert!(
        minibuffer_active(&s),
        "precondition: the prompt is actually open"
    );
    assert_eq!(
        eval::<String>(&s, "return pmacs.compile.context().kind"),
        "node",
        "the kind is detected from the resolved cwd, not the launch directory"
    );
    assert_eq!(
        minibuffer_contents(&s),
        "",
        "and `node` has no seeded default, so nothing is offered"
    );
 }
 /// **N** — `context()` is total in a launched session.
 ///
 /// Asserted with the pathless dired buffer active, so the fallback
 /// branch is the one under test. It pins a *property*, deliberately not
 /// a value: which directory the fallback resolves to is the test
 /// runner's cwd and pinning it would pin the environment.
 #[test]
 fn journey_step9_the_compile_context_is_total_even_with_no_file_open() {
    let td = cargo_project();
    let s = launch(td.path());
    assert!(
        active_name(&s).starts_with("*dired:"),
        "precondition: the pathless dired buffer is active"
    );
    assert!(
        eval::<bool>(&s, "return pmacs.compile.context().cwd ~= nil"),
        "a launched session always has somewhere to run a build"
    );
    assert!(
        eval::<bool>(
            &s,
            "local c = pmacs.compile.context()
             local ok, p = pcall(pmacs.project.detect, c.cwd)
             local detected = (ok and p) and p.kind or nil
             return c.kind == detected"
        ),
        "and its kind is exactly what detection answers for that cwd"
    );
 }
 /// **P** — `_last` still outranks the kind default.
 ///
 /// Green on the pre-image (there was no default). The targeted mutation
 /// is reordering the precedence chain to put `defaults[kind]` first.
 #[test]
 fn journey_step9_preservation_the_last_command_outranks_the_default() {
    let td = cargo_project();
    let mut s = walk_to_open_file(td.path(), "Cargo.toml");
    exec(&s, "pmacs.compile.run('true')");
    let finished = pump_processes_until(&mut s, 10_000, |s| {
        named_text(s, "*compilation*").contains("exited")
    });
    assert!(finished, "precondition: a run completed and set _last");
    press_compile_chord(&mut s);
    assert_eq!(
        minibuffer_contents(&s),
        "true",
        "a session that has compiled keeps its own command, not the project default"
    );
 }
 /// **P** — the compile keys that already existed still dispatch.
 ///
 /// Targeted mutation: writing the new binding as an unbind+bind pair
 /// over one of these sequences.
 #[test]
 fn journey_step9_preservation_the_existing_compile_bindings_survive() {
    let td = cargo_project();
    let s = walk_to_open_file(td.path(), "Cargo.toml");
    for (sequence, command) in [
        ("M-g n", "error.next"),
        ("M-g p", "error.previous"),
        ("C-x `", "error.next"),
        ("M-!", "shell.command"),
        ("C-c c", "compile.run"),
    ] {
        let bound: String = eval(
            &s,
            &format!("return pmacs.keymap.lookup({sequence:?}).command"),
        );
        assert_eq!(
            bound, command,
            "{sequence} must still dispatch to {command}"
        );
    }
 }
 /// True when `name` resolves on PATH — the fixture-dependency gate the
 /// process suite uses, so a missing binary skips rather than fails.
 fn binary_available(name: &str) -> bool {
    std::process::Command::new("which")
        .arg(name)
        .output()
        .is_ok_and(|o| o.status.success())
 }
 /// **N** — the compile directory is *detection*-canonical, not lexical.
 ///
 /// This pin exists because its absence broke both macOS CI legs while
 /// Ubuntu stayed green: `/var` is a symlink to `/private/var` there, so
 /// a tempdir's lexical and canonical paths differ, and the original
 /// assertions used the lexical one.
 ///
 /// Reproducing it on Linux needs an explicit symlink — which is also a
 /// real configuration `Workspace::detect`'s own doc comment names
 /// ("`/tmp/sandbox/foo` symlinked to `/home/user/code/foo`"). Launching
 /// through the link makes the two paths disagree on every platform, so
 /// the regression can no longer hide behind a filesystem that happens
 /// not to use symlinks.
 #[cfg(unix)]
 #[test]
 fn journey_step9_the_compile_directory_is_detection_canonical() {
    let parent = tempfile::tempdir().expect("tempdir");
    let real = parent.path().join("real");
    std::fs::create_dir_all(real.join("src")).expect("mkdir real");
    std::fs::write(
        real.join("Cargo.toml"),
        b"[package]\nname = \"journey-fixture\"\nversion = \"0.1.0\"\nedition = \"2021\"\n",
    )
    .expect("write Cargo.toml");
    std::fs::write(real.join("src/main.rs"), b"fn main() {}\n").expect("write main.rs");
    let link = parent.path().join("link");
    std::os::unix::fs::symlink(&real, &link).expect("symlink");
    // Precondition, or the pin is vacuous: the two spellings must
    // actually differ, which is the whole condition macOS creates for
    // free and Linux does not.
    assert_ne!(
        canon(&link),
        detected_root(&link),
        "the fixture must make lexical and canonical paths disagree"
    );
    let mut s = walk_to_open_file(&link, "Cargo.toml");
    press_compile_chord(&mut s);
    exec(&s, "pmacs.minibuffer.set_contents('pwd')");
    press(&mut s, KeyCode::Enter);
    let finished = pump_processes_until(&mut s, 10_000, |s| {
        named_text(s, "*compilation*").contains("exited")
    });
    assert!(finished, "the accepted run must finish");
    let text = named_text(&s, "*compilation*");
    assert!(
        text.contains(&format!("Directory: {}", detected_root(&link))),
        "the header must name the directory detection resolved to;\n{text}"
    );
 }