@junghanacs/entwurf 0.15.1 → 0.16.1

package/run.sh

@@ -119,7 +119,7 @@ run_vitest() {
 usage() {
   cat <<'EOF'
 Usage:
-  ./run.sh setup [project-dir]        # ONE presence-driven composition (#86): mode-first (source bootstrap only on a checkout), then per-component PASS/SKIP/FAIL for pi (presence+floor)/claude/agy/copilot (all four units: birth→MCP→receiver→footer, independently) + stable dev bins + v2 install smoke; absent harness = zero-state SKIP, detected-incomplete = named FAIL + nonzero exit. Never installs a harness or touches credentials
+  ./run.sh setup [project-dir]        # ONE presence-driven composition (#86): mode-first (source bootstrap only on a checkout), then per-component PASS/SKIP/FAIL for pi (presence+floor)/claude/agy/copilot (all four units: birth→MCP→receiver→footer, independently)/omp (four units: birth→MCP→tools.xdev setting→receiver, independently) + stable dev bins + v2 install smoke; absent harness = zero-state SKIP, detected-incomplete = named FAIL + nonzero exit. Never installs a harness or touches credentials
   ./run.sh release-gate [project-dir] [--cut] [--allow-skip-gemini]  # SINGLE release gate: full static (pnpm run check:full) + the v2-native live gates (v2 matrix-live, check-bridge, doctor-pi-provider, RGG) + the ACP plugin acceptance floor (12 LIVE smokes: socket-citizen/raw-turn/overlay/provider/session-reuse/carrier-augment/memory-containment/rgg/mcp/skill/bundled-mcp/v2-send) + the one surviving axis the aggregate used to omit silently (claude-native-resume; Cortex stays a documented on-demand direct call) + the cross-harness delivery chain (smoke-entwurf-chain-live). TWO-TIER summary: MUST (release-blocking, owns the exit code — "green" applies here) + BEHAVIOR (advisory, non-blocking: RGG positives model-in-loop turn). STEP OUTCOME protocol: every step is INVOKED and reports its own PASS / SKIP (exit 97, a prerequisite it does not have) / FAIL — a skip is never counted as a pass. Without --cut this is the unattended diagnostic (SKIPs reported, exit 0). WITH --cut it is read as release acceptance and ANY MUST SKIP is red, which is what makes "a CUT needs LIVE=1, SKIP=0" executable instead of prose. --allow-skip-gemini accepted-but-ignored (back-compat). final cut authorization is GLG's.
   ./run.sh check-bridge               # entwurf-bridge direct MCP smoke + protocol/negative-path test.sh (live substrate = v2 live smokes)
   ./run.sh check-entwurf-bridge-boot # deterministic gate (5d-5-pre, G1a/G1b/G1e/G1f, IN pnpm run check:full): boot start.sh under strip-types + assert v2 fence graph loads + entwurf_v2 and entwurf_resume_call registered/schema + the tools/list surface is EXACTLY the seven shipped garden verbs; tools/list only, no auth/side-effect
@@ -131,10 +131,13 @@ Usage:
   ./run.sh check-meta-v3-record        # deterministic gate: the ONE live record schema (v3) — canonical serialize/round-trip/mint, foreign-generation rejections name fresh-cut with the actual version value, strict keyset, no API
   ./run.sh check-mailbox-receipt-state # deterministic gate (0.11 Stage 0 step 3B): mailbox receipt state schema + store (stamp→persist→read-back) in a temp mailbox, strict keyset, no API
   ./run.sh check-copilot-birth-hook   # #82 gate: drives the real Copilot assembler into a temp dir, fires the baked launcher with NO ARGV (the way Copilot's `exec`-string schema forces), and requires a backend:"copilot" v3 record + attach + peer row + a SENDER marker the resolver joins back to that record, and still zero mailbox/receiver marker (who-sent needs a shared parent; a receiver needs a doorbell this backend has not got). Hermetic; no Copilot, no model turn
+  ./run.sh check-omp-birth-hook       # #87 gate: drives the real OMP assembler into a temp dir, imports the ASSEMBLED index.ts into a MOCK omp host and fires session_start/session_switch. tui mints one backend:"omp" record + a sender marker keyed to the host's OWN pid (the one-process join) + the garden id on the status line; print/rpc/json mint NOTHING (hasUI is true on the rpc rows, as in the vendor); switch attaches on the same native id and mints the replacement on a new one; the CERTIFIED receiver reader still finds no marker. Also the four-root joint binding: extension and omp-labeled bridge child resolve the same sessions/mailbox/senders/receivers bundle against test-built literals (never the production resolver as its own oracle), under a poisoned PI_CODING_AGENT_DIR and under four distinct ENTWURF_META_* overrides; the override grammar is absolute-or-~ and both halves plus the doctor refuse anything else by name; and a drifted provenance label selects no root policy at all. Hermetic; no omp, no model turn
   ./run.sh check-copilot-receive-arm  # #82 RAIL 5 gate: the REAL receiver installer + the REAL extension.mjs forked with a stubbed SDK. Arms only after birth, marker owned by the WATCHER pid, self-fetch dispatch answer, doorbell carries the garden id and NOT the body, id-drift/foreign-parent refusals. Hermetic; no Copilot, no model turn
   ./run.sh check-copilot-launch       # #82 RAIL 7 gate: the MANAGED launch `entwurf copilot`, driven through its public address against a FAKE VENDOR on a sandbox PATH. Receiver precondition refusals, EXTENSIONS token + operator token preservation, injected defaults before the `--` terminator, byte-identical argv, the 11 explicit permission/surface policy overrides that suppress `--yolo`, exec (not fork) pid identity, exit passthrough, recursion refusal. Hermetic; no Copilot, no model turn
   ./run.sh check-copilot-statusline   # #82 Copilot custom-footer renderer. session_id → ready/?/gid + rail `cop`; exit 0. IN pnpm check. No Copilot, no model turn
   ./run.sh check-entwurf-capabilities  # deterministic gate (0.11 Stage 0 step 3C): backend capability registry (pi/entwurf-capabilities.json) — coverage==META_CITIZEN_BACKENDS + agrees with live META_BACKEND_DESCRIPTORS + strict keyset, no API
+  ./run.sh check-omp-fresh-preflight   # #87 C: the OMP fresh preflight reproduces omp_agent_dir and the tools.xdev read in TS (it runs from two emit depths and cannot call a sibling script). This drives the SHIPPED shell/python leaves over the same inputs — refusals included — and requires the TS half to agree, so the reproduction cannot silently drift from the installer's own oracle
+  ./run.sh check-harness-admission-parity  # #87 C: the EDGE the two closed parity loops never had. Every citizen backend is fresh-openable or a declared pre-#82 legacy admission whose exception a reader finds in DELIVERY.md — so a post-contract harness that mints records but cannot be opened by entwurf_fresh_call blocks the release package instead of only carrying an `unsupported` note (docs/adding-a-harness.md step 9)
   ./run.sh check-capability-bundle-reach # deterministic gate (IN pnpm check): re-ask EVERY shipped copy of meta-session (source + bridge bundle emit) whether metaCapabilitiesFilePath() reaches the registry — the artifact-depth check the source-path gates cannot make; needs a built dist, missing dist FAILS
   ./run.sh smoke-pi-attach            # deterministic gate (#50 C2 checkpoint + C3 ACP tail): a pi session attaches as a V3 meta-record citizen (backend:"pi"), the gardenId is the RECORD's not pi's session id, the control socket is keyed on it, a re-open ATTACHES to the same address (never a second mint), the BUILT DIST ENTRY driven over MCP stdio lists the citizen + delivers entwurf_v2 to that socket with an RPC ack, and the ACP identity chain lands a send AS the host record (enrichMcpServersWithEnvelope env → bridge sender = host gardenId). mkdtemp-isolated; the live store is never read
   ./run.sh check-bridge-delivery      # deterministic gate (IN pnpm run check:full): demo scene 3 recovered — seed strict meta-sender + armed receiver citizens in an isolated temp world, scrub ambient pi/sender carriers, drive the BUILT DIST ENTRY over MCP stdio through a real tools/call entwurf_v2, assert the .msg landed under the seeded sender + doorbell poked. DELIVERS through the artifact, not from source. ENTWURF_DELIVERY_SUBJECT=<launcher> replays the same scene against another consumer artifact (check-pack-install passes the npm-installed bin). No model/network/cost; stale or missing dist FAILS
@@ -184,6 +187,8 @@ Usage:
   ./run.sh smoke-agy-install-state    # agy MCP + exact permission ownership regression: isolated HOME+XDG, adopt/state/inverse, symlink refuse, truthful setup outcomes. Offline/deterministic
   ./run.sh smoke-setup-verdict        # #86 C1+C3b aggregate setup verdict fixture: all-absent SKIP/green, pi presence+floor, detected-FAIL nonzero, copilot four-unit composition (present=independent PASS/FAIL rows, absent=zero-state SKIP), installed-mode named branch, credential store untouched. Offline/deterministic
   ./run.sh check-agy-permission-matrix # AGY permission CONTRACT SPACE as a literal table (55 cells): parser-state × operation × settings × ownership × precedence with stated exclusion rules; expectations are hand-written literals, never read from the SUT. Offline/deterministic (deps: python3)
+  ./run.sh smoke-omp-fresh-live        # #87 bundle C acceptance, RELEASE MUST: omp opened as ONE visible fresh sibling through the PUBLIC entwurf_fresh_call surface (never raw tmux), exact nonce callback -> garden id from the SENDER ENVELOPE -> record/backend identity -> addressed receive -> lastReadAt -> the drain visible in that same native session's own transcript. Needs LIVE=1 and spends real model turns. Self-deciding: omp outside FRESH_CALL_BACKENDS or without a mailbox rail is a protocol SKIP, which --cut reads as RED
+  ./run.sh smoke-omp-receive-live      # #87 bundle B acceptance: another harness wakes an ALREADY-OPEN omp citizen, which reads its inbox and answers in the same session. Decides its own outcome from the capability registry — omp without a drainable mailbox is a protocol SKIP (no receiver unit exists to arm), which an unattended release-gate reports and `--cut` reads as RED; a registry that claims a receive rail with no acceptance body here is a FAIL
   ./run.sh smoke-entwurf-chain-live    # LIVE cross-harness delivery chain: native Claude Code -> pi GPT -> pi ACP Sonnet -> mailbox terminus, proving sender identity/replyable at every hop and a real read receipt at the end. Prerequisites (claude on PATH, pi credentials per backend) report protocol SKIP, never a pass
   ./run.sh check-release-gate-outcomes  # release-gate STEP OUTCOME protocol (P1): one skip exit code shared by the shell + TS halves, classifier never rounds a skip up to a pass, `--cut` refuses a MUST SKIP while a bare diagnostic stays exit 0, no LIVE smoke keeps the old exit-0 skip shape, and both real skip surfaces are INVOKED and observed to propagate the code
   ./run.sh check-gate-qualification    # kill-proof qualification (the gate-of-gates): runner self-test (classifier truth table + synthetic negatives incl. wrong-reason/hang/control-red/impurity) + committed mutant manifests (scripts/mutants/*.json) run in an isolated snapshot repo under control→mutant→restore→control; the real checkout is never written. Evidence = claim IDs + killed mutant IDs, never assertion counts
@@ -192,6 +197,7 @@ Usage:
   ./run.sh smoke-agy-statusline-state # agy ambient garden-id statusLine install/doctor/inverse regression. Offline/deterministic
   ./run.sh smoke-copilot-statusline-state # Copilot custom-footer install/doctor/inverse regression. Offline/deterministic
   ./run.sh smoke-copilot-mcp-state       # Copilot MCP install/doctor/inverse regression. Offline/deterministic
+  ./run.sh smoke-omp-bridge-state        # OMP birth-extension install/doctor/inverse regression: placement, stale-writer detection, honest inverse, no-state refusal (structurally VALID as well as foreign), symlink refusal, ambiguous-agent-dir refusal (ledger M6), and a poisoned PI_CODING_AGENT_DIR that attracts no artifact. Fully sandboxed HOME/PI/XDG. Offline/deterministic
   ./run.sh smoke-agy-hooks-state      # agy PreInvocation birth/sender hook install/doctor/inverse + direct stdin→meta-record regression. Offline/deterministic
   ./run.sh smoke-user-scope-citizen   # 0.12.6 install-boundary: pi packages[] registration SSOT (register-pi-package.py) — idempotent + preserves unrelated + remove symmetry + fails loud, and the #86 C2 explicit ownership cells (project scope still normalizes ITS OWN stale entries; user scope refuses other owners and only takeover-user-scope moves the shared entry). Offline/hermetic (deps: bash+python3)
   ./run.sh smoke-meta-prune           # 1.0.0 meta-bridge Phase 4: listing-only store janitor regression gate — classify keep/orphan/stale/ambiguous, delete nothing. Offline/deterministic (deps: bash+node)
@@ -212,6 +218,19 @@ Usage:
   ./run.sh install-copilot-mcp        # #82 RAIL 5: register ONE entwurf-bridge server in ~/.copilot/mcp-config.json (adopt / create / REFUSE symlink), type:local, install-state under $XDG_DATA_HOME/entwurf/copilot-mcp/
   ./run.sh uninstall-copilot-mcp      # honest inverse of install-copilot-mcp from install-state
   ./run.sh doctor-copilot-mcp         # static ownership/config/boot doctor; RED only when install-state exists
+  ./run.sh install-omp-config         # #87 follow-on: write the ONE operator setting omp's tool hand requires — `tools.xdev: false` in <omp agent dir>/config.yml. Owns exactly the line(s) it adds (recorded in install-state), refuses a symlinked config, refuses a config it cannot parse, and refuses an EXPLICIT operator `xdev: true` by name rather than overwriting a decision. Without it the vendor default wraps every MCP tool behind `xd://` and the doorbell announces a tool the model cannot call
+  ./run.sh uninstall-omp-config       # honest inverse from install-state: takes back exactly the recorded line(s), removes the file only when entwurf created it, REFUSES when the config changed since install
+  ./run.sh install-omp-bridge         # #87: install the OMP BIRTH extension into <omp agent dir>/extensions/entwurf-meta-omp (index.ts|js + lib + capability registry). No launcher and no bake — an omp hook is an in-process extension. Refuses when an inherited PI_CODING_AGENT_DIR/PI_CONFIG_DIR/PI_PROFILE makes the target agent dir ambiguous (ledger M6), and refuses ANY pre-existing artifact at the unit path that entwurf holds no ownership state for — a shape is not a proof of ownership
+  ./run.sh uninstall-omp-bridge       # honest inverse from install-state (exact unit dir + recorded entry; no-state host REFUSES; state deleted LAST). Records already minted are preserved
+  ./run.sh doctor-omp-bridge          # #87: runtime axis (importable unit, writer/registry parity, mint vs sender-marker errors on SEPARATE axes, scope-fence receipts, a root-grammar preflight that goes RED on a relative ENTWURF_META_* override instead of reporting on some other directory, CERTIFIED omp record count via meta-facts under the omp root policy — never a text grep, live omp processes carrying inherited PI_SESSION_ID/PI_AGENT_ID) + ownership axis. PI_CODING_AGENT_DIR is the vendor's own agent dir here and is reported as ignored, never as contamination. Zero records = NOT-YET, never red
+  ./run.sh install-omp-receive        # #87 bundle B: install the OMP RECEIVER extension into <omp agent dir>/extensions/entwurf-receive-omp. Own unit, own install-state, own doctor, own inverse. It joins the citizen BIRTH minted in the same process (sender marker for this pid + V3 record + the vendor's current session id, all three or refuse), holds an fs.watch on that citizen's mailbox signal, and rings an ANNOUNCE-ONLY doorbell via pi.sendUserMessage. It never assumes it loads after birth: extension handlers run in directory-name order and a before-sorting unit was MEASURED to see no marker, so the arm retries on a bounded ctx.setInterval cancelled with ctx.clearTimer (the vendor exposes no clearInterval)
+  ./run.sh uninstall-omp-receive      # honest inverse from install-state; records and sender identity untouched. A session that ALREADY armed keeps its marker until its process exits
+  ./run.sh doctor-omp-receive         # runtime axis (importable unit, writer parity, arm failures and doorbell failures on SEPARATE axes, who is armed RIGHT NOW through the production marker reader) + ownership axis. Zero armed receivers = NOT-YET, never red. Reports a marker for exactly what a marker proves — a live owner reached the arm emit — and never upgrades that into "a wake will happen"
+  ./run.sh omp-receive-facts          # read-only JSON projection of the omp receive rail: every receiver marker through readMetaReceiverMarker in BOTH readings (live / as-written) plus mailbox counts. The shared oracle so no consumer answers "is a doorbell held?" from a filename
+  ./run.sh install-omp-mcp            # #87 step 5: write ONE omp-native entwurf-bridge server into <omp agent dir>/mcp.json with env ENTWURF_BRIDGE_EXTERNAL_AGENT_ID=external-mcp/omp. The server key is a PINNED LITERAL, byte-identical to the Claude import's — same-key first-wins at native=100 > claude=80 is what SHADOWS the import (never disabledServers, which kills both). Adopt / create / REFUSE symlink, preimage recorded
+  ./run.sh uninstall-omp-mcp          # honest inverse from install-state (restores the preimage, or removes a file we created); the Claude import becomes effective again
+  ./run.sh doctor-omp-mcp             # ownership + config + boot doctor, plus the EFFECTIVE-source read (native-wins / native-invalid / import-wins / both-suppressed) — a configuration read, never a runtime receipt. Runtime validity and ownership are SEPARATE axes: foreign provenance, a disabledServers denylist, and a malformed entry under our key are each RED even with no install-state. tools.xdev is a RUNTIME cell: absent file/key applies the vendor default (true, no inline allowlist) and is RED while the native hand is the effective source; xdev false is ok; a covering xdevInlineDevices glob is ok-with-note
+  ./run.sh smoke-omp-mcp-state        # OMP MCP install/doctor/inverse regression incl. shadowing, the denylist refusal, target confinement + retarget refusal, and a malformed entry going RED with zero install-state. Fully sandboxed HOME/PI/XDG. Offline/deterministic
   ./run.sh install-copilot-receive    # #82 RAIL 5: install the RECEIVER extension (user scope ~/.copilot/extensions/entwurf-receive). Owns the artifact and CHECKS the launch flag; it never sets one (a launch does — see `./run.sh copilot`). Arms per session after birth
   ./run.sh uninstall-copilot-receive  # honest inverse from install-state; never removes a unit it did not install
   ./run.sh doctor-copilot-receive     # artifact + digest, COPILOT_CLI_ENABLED_FEATURE_FLAGS on the LIVE copilot processes (the silent failure), live receiver markers via the production reader, receiver log. RED only when install-state exists
@@ -233,9 +252,9 @@ Usage:
   ./run.sh check-dep-versions         # local deterministic check that the pi pin agrees across package.json (devDeps + peer range), run.sh (peer-install pins), and the baseline docs (AGENTS/README/ROADMAP/setup-clean-host/demo)
   ./run.sh check-node-floor-coherence # binds the Node floor (24+, single axis) across engines.node, run.sh setup preflight, meta-bridge install/doctor judgment logic, clean-host docs, the bridge launcher header, and the CI runner node-version — engines.node is the SSOT, everything else is derived; sweeps tracked contract text for an unregistered declaration
   ./run.sh check-pack                 # publish gate (dry-run): npm pack --dry-run + tarball invariants (runtime-critical present, dev residue absent)
-  ./run.sh check-pack-pin-matcher     # pure self-test of check-pack-install's pin-leak matcher against synthetic .pnpm lookalikes (version boundary: @0.84.30 must leak, @0.84.3 bare/peer-hash must pass); snapshot-safe qualification oracle, also run first inside check-pack-install
+  ./run.sh check-pack-pin-matcher     # pure self-test of check-pack-install's pin-leak matcher against synthetic .pnpm lookalikes (version boundary: @0.84.40 must leak, @0.84.4 bare/peer-hash must pass); snapshot-safe qualification oracle, also run first inside check-pack-install
   ./run.sh check-fresh-cut-gate       # SOURCE cell of the generation-boundary proof (IN pnpm run check:full): drives real install/setup/fresh-cut in a sandbox; certification refusal is pre-write, quiescence is fail-closed, archives preserve bytes, and the #54 exit matrix distinguishes complete / no-move / usage / incomplete transition / complete-with-cleanup-residue. No model/network/cost
-  ./run.sh check-pack-install         # heavy publish gate (prepublishOnly): actual npm pack + tar -tf + fresh-temp install smoke with the pinned pi peers (pins derived from the package.json devDep; check-dep-versions binds them) + the npm-installed bridge BOOTS (tools/list) and DELIVERS (tools/call entwurf_v2 → .msg lands) + the installed all-absent and copilot-present (four-unit fake-vendor) `entwurf setup` rows + the INSTALLED generation lifecycle on a seeded previous-generation host (REFUSE before activation writes / zero Claude invocations → installed fresh-cut archives + opens empty → install-meta-bridge PASSES)
+  ./run.sh check-pack-install         # heavy publish gate (prepublishOnly): actual npm pack + tar -tf + fresh-temp install smoke with the pinned pi peers (pins derived from the package.json devDep; check-dep-versions binds them) + the npm-installed bridge BOOTS (tools/list) and DELIVERS (tools/call entwurf_v2 → .msg lands) + the installed all-absent and copilot-present (four-unit fake-vendor) `entwurf setup` rows + the INSTALLED generation lifecycle on a seeded previous-generation host (REFUSE before activation writes / zero Claude invocations → installed fresh-cut archives + opens empty → install-meta-bridge PASSES) + the INSTALLED-PACKAGE branch of the Copilot and OMP birth installers actually RUN (compiled entry selected, no raw .ts, and a real birth edge mints a citizen — the half a required-artifact list can never stand in for)
   ./run.sh check-install-container    # 0.12.8 (#51 C): Linux artifact-CONSUMER gate — one candidate .tgz handed read-only to a checkout-invisible node:<engines-major>-bookworm cell. Default packs once to temp; ENTWURF_CANDIDATE_TGZ=/absolute/preserved.tgz consumes those exact bytes with no re-pack and prints canonical path+sha256 for release. Non-root global PATH install, frozen package, MCP tools/list, fake-Claude install-meta-bridge, path+sha256 fence, strict doctor, and the GENERATION host-state matrix (clean / v3-only store bytes unchanged / previous-generation REFUSE→fresh-cut→retry PASS) seeded inline. Docker missing = honest SKIP; ENTWURF_REQUIRE_DOCKER=1 makes that RED (required CI)
   ./run.sh install [project-dir]      # INTERNAL part of `setup` (project .pi/settings.json wiring) + npm-consumer entry — prefer `setup`, don't call directly for dev
   ./run.sh remove [project-dir]       # remove entwurf entries from project .pi/settings.json (project scope only; global user-scope citizen left intact)
@@ -774,6 +793,42 @@ check_entwurf_capabilities() {
   run_ts scripts/check-entwurf-capabilities.ts
 }
 
+smoke_omp_fresh_live() {
+  # #87 Bundle C acceptance, RELEASE MUST. Opens omp as ONE visible fresh sibling through
+  # the PUBLIC entwurf_fresh_call surface in a private tmux server, correlates the exact
+  # nonce callback to a garden id from the SENDER ENVELOPE, then delivers an addressed
+  # message the sibling drains in that same native session. Decides its own outcome: omp
+  # absent from FRESH_CALL_BACKENDS or without a mailbox rail is a protocol SKIP, LIVE!=1
+  # is a protocol SKIP, and once the composition offers the backend every missing
+  # prerequisite is a FAIL. Writes into the REAL meta roots — the extensions run inside the
+  # launched omp process and no env carrier on the fresh argv could fence them.
+  run_ts scripts/smoke-omp-fresh-live.ts
+}
+
+check_omp_fresh_preflight() {
+  # #87 Bundle C. The OMP fresh preflight REPRODUCES two resolvers that already exist
+  # in this repo in another language — omp_agent_dir (scripts/omp-bridge-oracle.sh) and
+  # the tools.xdev half of scripts/omp-tool-surface.py — because the preflight runs from
+  # two different emit depths and cannot resolve a sibling script by relative path. A
+  # reproduction nothing compares is a divergence with a date on it, so this drives the
+  # SHIPPED shell and python leaves and requires the TS half to agree, refusals included.
+  # Never asks the resolver under test to confirm itself. Fixtures only; never reads ~/.omp.
+  run_ts scripts/check-omp-fresh-preflight.ts
+}
+
+check_harness_admission_parity() {
+  # #87 Bundle C. The EDGE between two parity loops that were each closed and had
+  # nothing between them: check-entwurf-capabilities held registry ==
+  # META_CITIZEN_BACKENDS, the fresh-call surfaces contract held surfaces ==
+  # FRESH_CALL_BACKENDS, and no file read both constants. So a harness could be a
+  # full D6 citizen that entwurf_fresh_call cannot open, with every gate green and
+  # only prose saying it was not supported — which is how an `unsupported` label
+  # started reading as a partial-release permit. Asserts every citizen backend is
+  # either fresh-openable or a DECLARED pre-#82 legacy admission whose exception a
+  # reader can find in DELIVERY.md, both directions, no third state. Pure parse.
+  run_ts scripts/check-harness-admission-parity.ts
+}
+
 check_capability_bundle_reach() {
   # The gate check-entwurf-capabilities structurally cannot be. That gate imports
   # metaCapabilitiesFilePath() from ../pi-extensions/lib/ — the one location where
@@ -1238,7 +1293,11 @@ check_mux_fresh_call() {
   # copilot-fresh-preflight rides here rather than in its own gate: it exists only as
   # freshCall's pre-mutation branch (#82 RAIL 9), and splitting it would let the two halves
   # of one refusal be certified in different runs.
-  run_vitest test/mux-fresh-call.test.ts test/copilot-fresh-preflight.test.ts test/fresh-call-surfaces.contract.test.ts test/fresh-call-provider.contract.test.ts
+  # omp-fresh-bootstrap.contract rides here for the same reason and one more: it is the ONLY
+  # place the launcher's payload and the installed birth extension's decoder are read together.
+  # They ship in different directories and cannot import each other (#87 Bundle C), so this
+  # lane is what keeps a deliberate duplication from becoming drift.
+  run_vitest test/mux-fresh-call.test.ts test/copilot-fresh-preflight.test.ts test/fresh-call-surfaces.contract.test.ts test/fresh-call-provider.contract.test.ts test/omp-fresh-bootstrap.contract.test.ts
 }
 
 smoke_mux_fresh_call_live() {
@@ -1768,13 +1827,13 @@ assert.equal(peerTui, piAi,
 // floor tracks the devDep pin so a consumer can't install against a pi lacking
 // the public trust exports the bridge imports at the pinned minor, AND an upper
 // bound at the next minor stops a fresh install from silently pulling a future
-// pi (past the declared ceiling — 0.85+ at the current 0.84.3 pin) whose
+// pi (past the declared ceiling — 0.85+ at the current 0.84.4 pin) whose
 // internal export surface has drifted from the one we typecheck against.
 // pi moves its public surface every minor (the 0.79→0.80 getModels→provider-
 // factory churn is exactly this), so an open `>=` floor is exactly how the next
 // installer re-acquires the drift. The floor is also the HARD MINIMUM a consumer
-// install resolves: at `>=0.84.3` an existing 0.83.x host is upgraded, not kept.
-// Expected shape: `>=<devDep> <0.<minor+1>` (e.g. `>=0.84.3 <0.85`).
+// install resolves: at `>=0.84.4` an existing 0.84.3 host is upgraded, not kept.
+// Expected shape: `>=<devDep> <0.<minor+1>` (e.g. `>=0.84.4 <0.85`).
 const [piMaj, piMin] = piAi.split('.').map(Number);
 assert.equal(piMaj, 0,
   `pi pin major must stay 0 for the next-minor ceiling rule (got ${piAi}); revisit check-dep-versions when pi reaches 1.x`);
@@ -2672,6 +2731,17 @@ check_acp_prompt_lifecycle() {
   run_ts scripts/check-acp-prompt-lifecycle.ts
 }
 
+check_acp_launch_namespace() {
+  # #72: the Claude ACP child must launch under a name entwurf OWNS. A janitor
+  # installed on the host for ANOTHER harness selects the vendor process name
+  # `claude-agent-acp` by argv substring and SIGTERMs it by age; entwurf retains
+  # its child across turns, so its age is the session's. This gate holds the
+  # name split, holds the launcher transparent (the vendor still answers
+  # --version through it), and keeps an explicit operator override verbatim.
+  section "ACP launch namespace (#72 — no vendor process name in our argv)"
+  run_ts scripts/check-acp-launch-namespace.ts
+}
+
 check_acp_stream_hooks() {
   # Deterministic gate for the pi 0.84 streamSimple hook contract on the ACP rail
   # (#63; upstream pi-mono #7372 → doc-only #7576). before_provider_request
@@ -2891,6 +2961,9 @@ check_pack() {
     # #65 — the owner-normalized store projection consumers call INSTEAD of
     # parsing the store; installed hosts are exactly where those consumers live.
     "mcp/entwurf-bridge/dist/scripts/meta-facts.js"
+    # #87 Bundle B — omp-receive-doctor drives this operator projection through
+    # run.sh, so installed node_modules must have the compiled twin too.
+    "mcp/entwurf-bridge/dist/scripts/omp-receive-facts.js"
     # 0.12.5 — the node_modules-safe plugin hook + its lib. install-meta-bridge copies
     # these compiled JS into the assembled plugin when installed (raw .ts can't
     # strip-types under node_modules). meta-session.js is shared with the store-doctor
@@ -2899,6 +2972,13 @@ check_pack() {
     # #82 — the Copilot birth entry's compiled closure, for the same node_modules
     # strip-types refusal that forces the Claude one.
     "mcp/entwurf-bridge/dist/pi-extensions/meta-bridge-hook-copilot.js"
+    # #87 — the OMP birth entry's compiled closure. install-omp-bridge SELECTS this path
+    # under node_modules, and docs/setup-clean-host.md tells operators to run that installer,
+    # so its absence is not a degraded path: the installed installer dies at its own artifact
+    # check before assembling anything. The unit skeleton's package.json below is the other
+    # half — the installer copies it, and `pi/` ships per-FILE.
+    "mcp/entwurf-bridge/dist/pi-extensions/meta-bridge-omp.js"
+    "pi/meta-bridge-omp/entwurf-meta-omp/package.json"
     "mcp/entwurf-bridge/dist/pi-extensions/lib/meta-session.js"
     "scripts/postinstall-chmod.cjs"
     "pi/entwurf-capabilities.json"
@@ -3000,15 +3080,15 @@ check_pack() {
 # The pin-leak filter for the install tree's .pnpm listing, shared by the real scan and its
 # self-test below. The version BOUNDARY is load-bearing: a pnpm .pnpm entry is
 # `<name>@<version>` followed by either `_<peer-hash>` or end-of-name (measured pnpm 11.20.0
-# on this tree), so an unbounded substring match would bless a lookalike such as `@0.84.30`
+# on this tree), so an unbounded substring match would bless a lookalike such as `@0.84.40`
 # while announcing the pinned floor — a false-green oracle (found by independent review,
 # 2026-08-25).
 pack_install_leaked_pi() {
-  grep '^@earendil-works+pi-' | grep -Ev '@0\.84\.3(_|$)' || true
+  grep '^@earendil-works+pi-' | grep -Ev '@0\.84\.4(_|$)' || true
 }
 
 # Matcher self-test on SYNTHETIC lookalikes: a healthy install tree cannot exercise the
-# false-green shape (it contains no 0.84.30), so the oracle is proven against a fixture
+# false-green shape (it contains no 0.84.40), so the oracle is proven against a fixture
 # listing. Expected: the two lookalikes leak, the pinned version passes bare and with a
 # peer-hash suffix. Exposed as its own snapshot-safe subcommand because the heavy
 # check-pack-install cannot run inside the qualification snapshot (no install environment),
@@ -3017,13 +3097,13 @@ pack_install_leaked_pi() {
 check_pack_pin_matcher() {
   local matcher_probe
   matcher_probe=$(printf '%s\n' \
-    '@earendil-works+pi-ai@0.84.3' \
-    '@earendil-works+pi-ai@0.84.3_@modelcontextprotocol+sdk@1.29.0_zod@4.3.6' \
-    '@earendil-works+pi-ai@0.84.30' \
-    '@earendil-works+pi-agent-core@0.84.2' | pack_install_leaked_pi)
-  if [ "$matcher_probe" != '@earendil-works+pi-ai@0.84.30
-@earendil-works+pi-agent-core@0.84.2' ]; then
-    fail "[QK:PACK-INSTALL-PIN-MATCHER-BOUNDED] the pin-leak matcher must flag the 0.84.30/0.84.2 lookalikes and pass 0.84.3 bare or with a peer-hash — got: ${matcher_probe:-<nothing leaked>}"
+    '@earendil-works+pi-ai@0.84.4' \
+    '@earendil-works+pi-ai@0.84.4_@modelcontextprotocol+sdk@1.29.0_zod@4.3.6' \
+    '@earendil-works+pi-ai@0.84.40' \
+    '@earendil-works+pi-agent-core@0.84.3' | pack_install_leaked_pi)
+  if [ "$matcher_probe" != '@earendil-works+pi-ai@0.84.40
+@earendil-works+pi-agent-core@0.84.3' ]; then
+    fail "[QK:PACK-INSTALL-PIN-MATCHER-BOUNDED] the pin-leak matcher must flag the 0.84.40/0.84.3 lookalikes and pass 0.84.4 bare or with a peer-hash — got: ${matcher_probe:-<nothing leaked>}"
     return 1
   fi
   echo "[check-pack-pin-matcher] ok — the pin-leak matcher is version-bounded (lookalikes leak, pinned version passes bare and with a peer-hash)"
@@ -3146,12 +3226,21 @@ _check_pack_install_impl() {
     "mcp/entwurf-bridge/dist/scripts/meta-bridge-fresh-cut.js"
     # #65 — the owner-normalized store projection (see check-pack).
     "mcp/entwurf-bridge/dist/scripts/meta-facts.js"
+    # #87 Bundle B — omp-receive-doctor reaches this through the installed dispatcher.
+    "mcp/entwurf-bridge/dist/scripts/omp-receive-facts.js"
     # 0.12.5 — node_modules-safe plugin hook + lib (see check-pack). The installed
     # hook regression below runs exactly this compiled JS from under node_modules.
     "mcp/entwurf-bridge/dist/pi-extensions/meta-bridge-hook.js"
     # #82 — the Copilot birth entry's compiled closure, for the same node_modules
     # strip-types refusal that forces the Claude one.
     "mcp/entwurf-bridge/dist/pi-extensions/meta-bridge-hook-copilot.js"
+    # #87 — the OMP birth entry's compiled closure. install-omp-bridge SELECTS this path
+    # under node_modules, and docs/setup-clean-host.md tells operators to run that installer,
+    # so its absence is not a degraded path: the installed installer dies at its own artifact
+    # check before assembling anything. The unit skeleton's package.json below is the other
+    # half — the installer copies it, and `pi/` ships per-FILE.
+    "mcp/entwurf-bridge/dist/pi-extensions/meta-bridge-omp.js"
+    "pi/meta-bridge-omp/entwurf-meta-omp/package.json"
     "mcp/entwurf-bridge/dist/pi-extensions/lib/meta-session.js"
     "scripts/postinstall-chmod.cjs"
     "pi/entwurf-capabilities.json"
@@ -3244,7 +3333,7 @@ _check_pack_install_impl() {
   printf '%s\n' '{ "name": "entwurf-install-smoke", "version": "0.0.0", "private": true }' > "$tmp/package.json"
 
   # pi-agent-core is pinned even though we never import it: pi-coding-agent depends
-  # on it by CARET (`^0.84.3`), so with no lockfile in this fresh temp project it
+  # on it by CARET (`^0.84.x`), so with no lockfile in this fresh temp project it
   # floats to whatever pi published last — and that newer core then drags a NESTED
   # pi-ai of its own. Measured 2026-07-21: pinning only the three we import left
   # pi-agent-core@0.80.10 + pi-ai@0.80.10 in the tree while the gate still announced
@@ -3257,18 +3346,26 @@ _check_pack_install_impl() {
   # {pi-agent-core, pi-ai, pi-tui} at 0.83.0 to {pi-agent-core, pi-ai, pi-client,
   # pi-protocol, pi-tui}, so pi-client and pi-protocol are pinned here for the
   # first time. Unpinned they would float exactly like pi-agent-core did in the
-  # 2026-07-21 incident above. (pi-telemetry arrives transitively, not as a
-  # direct caret; the leak assertion below covers it and every other pi package.)
+  # 2026-07-21 incident above. pi-telemetry joined the explicit pin list on
+  # 2026-08-31: it arrives transitively (pi-agent-core and pi-ai both carry
+  # `^0.84.x` carets on it), and upstream's 0.84.4 patch publish (2026-08-28
+  # 22:04Z) floated that caret in this lockfile-less temp install, turning CI
+  # red through the leak assertion below. That explicit pin is what held the
+  # line until the bump lane ran; the verified floor is 0.84.4 as of
+  # 2026-09-01, and the pin moved WITH it rather than being retired. The leak
+  # assertion below still covers every other pi package, including any package
+  # a future pi bump adds to the closure.
   echo "[check-pack-install] pnpm add into $tmp (with 0.84.x peers + typebox)"
   local install_log
   install_log=$(cd "$tmp" && pnpm add \
     "$tgz_path" \
-    "@earendil-works/pi-ai@0.84.3" \
-    "@earendil-works/pi-coding-agent@0.84.3" \
-    "@earendil-works/pi-tui@0.84.3" \
-    "@earendil-works/pi-agent-core@0.84.3" \
-    "@earendil-works/pi-client@0.84.3" \
-    "@earendil-works/pi-protocol@0.84.3" \
+    "@earendil-works/pi-ai@0.84.4" \
+    "@earendil-works/pi-coding-agent@0.84.4" \
+    "@earendil-works/pi-tui@0.84.4" \
+    "@earendil-works/pi-agent-core@0.84.4" \
+    "@earendil-works/pi-client@0.84.4" \
+    "@earendil-works/pi-protocol@0.84.4" \
+    "@earendil-works/pi-telemetry@0.84.4" \
     "typebox@latest" \
     --ignore-workspace --ignore-scripts 2>&1) || {
     fail "[check-pack-install] pnpm add failed:"
@@ -3278,17 +3375,17 @@ _check_pack_install_impl() {
 
   # A pin is a wish until the resolved tree is read back. Assert it: EVERY
   # @earendil-works pi package present — direct or transitive, top level or nested —
-  # must be the pinned 0.84.3. Anything else means an unpinned caret floated and the
+  # must be the pinned 0.84.4. Anything else means an unpinned caret floated and the
   # rest of this gate would be exercising a runtime nobody verified, while still
-  # printing "pinned pi 0.84.3". Fail loud instead of proving the wrong floor.
+  # printing "pinned pi 0.84.4". Fail loud instead of proving the wrong floor.
   local leaked_pi
   leaked_pi=$(ls "$tmp/node_modules/.pnpm" 2>/dev/null | pack_install_leaked_pi)
   if [ -n "$leaked_pi" ]; then
-    fail "[check-pack-install] UNVERIFIED pi runtime resolved into the install tree (expected only 0.84.3):"
+    fail "[check-pack-install] UNVERIFIED pi runtime resolved into the install tree (expected only 0.84.4):"
     printf '%s\n' "$leaked_pi" | sed 's/^/    /' >&2
     return 1
   fi
-  echo "[check-pack-install] pi runtime tree pin verified: every @earendil-works pi package is 0.84.3"
+  echo "[check-pack-install] pi runtime tree pin verified: every @earendil-works pi package is 0.84.4"
 
   # Resolve the installed package.json and confirm pi.extensions
   # arrived intact. If pi.extensions is empty or missing, the
@@ -3882,6 +3979,76 @@ SH
   fi
   rm -rf "$cop_store"
   echo "[check-pack-install] installed Copilot birth unit assembles its compiled branch and mints a citizen from a no-argv launch"
+
+  # --- #87: the OMP birth unit's INSTALLED-PACKAGE branch ---------------------
+  # Same shape and same reason as the Copilot cell above, and it is here because the gap it
+  # closes was REAL, not theoretical: the compiled entry this installer selects under
+  # node_modules was in no emit include and no artifact list, so `entwurf install-omp-bridge`
+  # — which docs/setup-clean-host.md tells operators to run — died at its own artifact check
+  # on every installed host while every gate stayed green (Terra amendment review, #87 A1).
+  # The list entries above make that artifact's ABSENCE loud; this RUNS it, which is the half
+  # Hard Rule 11 says a list can never stand in for.
+  #
+  # No omp binary is faked into doing anything: the installer only asks whether one is on
+  # PATH (entwurf never installs a harness), and the unit is a module the vendor imports, not
+  # a process we launch — so the exercise imports the placed artifact the way omp does.
+  local omp_agent="$npm_tmp/omp-agent" omp_home="$npm_tmp/omp-home" omp_bin="$npm_tmp/omp-bin" omp_log
+  mkdir -p "$omp_agent" "$omp_home" "$omp_bin"
+  printf '#!/usr/bin/env bash\nexit 0\n' > "$omp_bin/omp"
+  chmod +x "$omp_bin/omp"
+  if ! omp_log=$(HOME="$omp_home" XDG_DATA_HOME="$omp_home/.local/share" ENTWURF_OMP_AGENT_DIR="$omp_agent" PATH="$omp_bin:$npmroot/node_modules/.bin:$PATH" "$npm_pkg/run.sh" install-omp-bridge 2>&1); then
+    fail "[check-pack-install] installed install-omp-bridge failed:"
+    echo "$omp_log" | tail -20 | sed 's/^/    /' >&2
+    return 1
+  fi
+  local omp_unit="$omp_agent/extensions/entwurf-meta-omp"
+  # Branch SELECTION, pinned exactly as the Copilot cell pins its own: an installed package
+  # must place the compiled entry and NO raw .ts, or the fire below could pass on a layout
+  # that silently chose the dev-clone branch.
+  if [ ! -f "$omp_unit/index.js" ] || [ -f "$omp_unit/index.ts" ]; then
+    fail "[check-pack-install] installed install-omp-bridge did not select the compiled branch (want index.js, no raw .ts) in $omp_unit"
+    ls -l "$omp_unit" 2>/dev/null | sed 's/^/    /' >&2 || true
+    return 1
+  fi
+  if [ ! -f "$omp_unit/lib/meta-session.js" ] || [ ! -f "$omp_unit/entwurf-capabilities.json" ] || [ ! -f "$omp_unit/package.json" ]; then
+    fail "[check-pack-install] installed omp unit is incomplete (want lib/meta-session.js + entwurf-capabilities.json + package.json) in $omp_unit"
+    return 1
+  fi
+  # Fired the way omp fires it: import the module, call the exported factory with a mock
+  # ExtensionAPI, and hand the tui host context to the birth edge.
+  local omp_fire
+  if ! omp_fire=$(OMP_UNIT="$omp_unit" HOME="$omp_home" node --input-type=module <<'JS' 2>&1
+const mod = await import(process.env.OMP_UNIT + "/index.js");
+const handlers = [];
+(mod.default ?? mod)({ on: (event, handler) => { if (event === "session_start") handlers.push(handler); } });
+const ctx = {
+  mode: "tui",
+  cwd: "/tmp",
+  ui: { setStatus: () => {} },
+  sessionManager: { getSessionId: () => "pack-omp-probe", getCwd: () => "/tmp", getSessionFile: () => null },
+};
+for (const handler of handlers) await handler({ type: "session_start" }, ctx);
+process.stdout.write("fired " + handlers.length + "\n");
+JS
+  ); then
+    fail "[check-pack-install] the installed omp unit failed to import/run from its placed location: $(printf '%s' "$omp_fire" | tr '\n' ' ' | cut -c1-300)"
+    return 1
+  fi
+  # Counted through the OWNER's certified projection, not a grep — and through the INSTALLED
+  # bin, so this also proves dist/scripts/meta-facts.js is reachable from a consumer. `env -u
+  # PI_CODING_AGENT_DIR` is the omp root policy: for backend omp that variable is the vendor's
+  # own agent dir and never a garden root (#87 B1).
+  local omp_citizens
+  omp_citizens=$(env -u PI_CODING_AGENT_DIR HOME="$omp_home" "$npm_pkg/run.sh" meta-facts 2>&1 | python3 -c '
+import json, sys
+facts = json.load(sys.stdin)
+print(sum(1 for c in (facts.get("citizens") or []) if c.get("backend") == "omp"))
+' 2>/dev/null) || omp_citizens=""
+  if [ "$omp_citizens" != "1" ]; then
+    fail "[check-pack-install] the installed omp unit did not mint exactly one CERTIFIED omp citizen (found ${omp_citizens:-<unreadable>}); log: $(tail -1 "$omp_home/.pi/agent/meta-bridge-hook.log" 2>/dev/null)"
+    return 1
+  fi
+  echo "[check-pack-install] installed OMP birth unit places its compiled branch and mints a certified citizen from a tui birth edge"
   python3 - "$mb_cfg/settings.json" "$mb_home/.claude.json" "$stable_asm" <<'PY'
 import json, sys
 settings = json.load(open(sys.argv[1]))
@@ -4829,6 +4996,52 @@ setup_all() {
     fi
   fi
 
+  # ── omp (oh-my-pi) ── presence-driven composition, same shape as copilot. OMP
+  # was admitted as a garden citizen in v0.16.0 with installers, doctors and
+  # inverses for every unit — but it was never composed HERE, so the one-command
+  # surface left the fifth backend to a hand-run verb list and the operator setting
+  # to a documentation step. That gap is what `docs/adding-a-harness.md` step 10
+  # now closes for every future harness: an onboarding is not finished until setup
+  # composes it. Four units, each independent: birth (who the citizen is) → MCP
+  # hand (what it can call) → the tools.xdev operator setting (whether those calls
+  # are REACHABLE) → receiver (whether a reply can land). OMP_BIN pins the PROBE
+  # for hermetic gates; the unit scripts address `omp` on PATH.
+  local omp_rc
+  if ! command -v "${OMP_BIN:-omp}" >/dev/null 2>&1; then
+    setup_result omp SKIP "omp not on PATH — zero OMP wiring written"
+  else
+    section "omp units (native harness detected: oh-my-pi)"
+    omp_rc=0; (cd "$REPO_DIR" && bash scripts/omp-bridge-install.sh) || omp_rc=$?
+    if [ "$omp_rc" -eq 0 ]; then
+      setup_result omp-birth PASS "birth extension installed — verify: ./run.sh doctor-omp-bridge"
+    else
+      setup_result omp-birth FAIL "detected omp, but the birth extension install did not complete (see above) — repair, then re-run setup"
+    fi
+    omp_rc=0; (cd "$REPO_DIR" && bash scripts/omp-mcp-bridge.sh install) || omp_rc=$?
+    if [ "$omp_rc" -eq 0 ]; then
+      setup_result omp-mcp PASS "MCP server registered — verify: ./run.sh doctor-omp-mcp"
+    else
+      setup_result omp-mcp FAIL "detected omp, but the MCP registration did not complete (see above) — repair, then re-run setup"
+    fi
+    # The operator setting is a component of its own because its FAIL is a real
+    # disagreement, not a broken install: an explicit `tools.xdev: true` is the
+    # operator's decision and the writer refuses it by name. Naming that as a
+    # component FAIL puts the choice in front of the operator instead of silently
+    # shipping a citizen whose tools nobody can call.
+    omp_rc=0; (cd "$REPO_DIR" && bash scripts/omp-config-xdev.sh install) || omp_rc=$?
+    if [ "$omp_rc" -eq 0 ]; then
+      setup_result omp-config PASS "tools.xdev: false written — verify: ./run.sh doctor-omp-mcp"
+    else
+      setup_result omp-config FAIL "detected omp, but the tools.xdev operator setting did not land (see above) — resolve it, then re-run setup"
+    fi
+    omp_rc=0; (cd "$REPO_DIR" && bash scripts/omp-receive-install.sh) || omp_rc=$?
+    if [ "$omp_rc" -eq 0 ]; then
+      setup_result omp-receive PASS "receiver extension installed — verify: ./run.sh doctor-omp-receive"
+    else
+      setup_result omp-receive FAIL "detected omp, but the receiver extension install did not complete (see above) — repair, then re-run setup"
+    fi
+  fi
+
   # ── core bridge boundary ── deterministic preflight lives in `pnpm run
   # check:full`; live substrate acceptance lives in `LIVE=1 ./run.sh
   # release-gate <scratch> --cut`. Setup is the install path, so it verifies the
@@ -4849,7 +5062,7 @@ setup_all() {
   local entry rest s_name s_verdict s_fails=""
   for entry in "${SETUP_RESULTS[@]}"; do
     s_name="${entry%%|*}"; rest="${entry#*|}"; s_verdict="${rest%%|*}"
-    printf '  %-14s %-4s %s\n' "$s_name" "$s_verdict" "${rest#*|}"
+    printf '  %-18s %-4s %s\n' "$s_name" "$s_verdict" "${rest#*|}"
     if [ "$s_verdict" = "FAIL" ]; then s_fails="$s_fails $s_name"; fi
   done
   echo ""
@@ -5317,6 +5530,21 @@ release_gate() {
   run_live_step "smoke-claude-native-resume-live (native Claude Code resume + meta-bridge neutrality)" gate bash "$self" smoke-claude-native-resume-live
   run_live_step "smoke-entwurf-chain-live (P3: Claude Code -> pi GPT -> pi ACP Sonnet -> mailbox, identity + receipt)" gate bash "$self" smoke-entwurf-chain-live
   run_live_step "smoke-mux-lifecycle-live (mux public-harness lifecycle: fresh -> send -> dormant -> same-id visible resume -> recall)" gate bash "$self" smoke-mux-lifecycle-live
+  # #87 bundle B: MUST, and since bundle B moved omp's wakeMode to self-fetch this is a
+  # REAL demand under LIVE=1, not a standing SKIP — it reads the registry, so an honest
+  # SKIP now only ever names a missing prerequisite, and a registry claiming a receive
+  # rail with no acceptance body here is a FAIL.
+  run_live_step "smoke-omp-receive-live (#87 bundle B: other harness -> open omp citizen, addressed receive + roundtrip)" gate bash "$self" smoke-omp-receive-live
+  # #87 bundle C: the step 9 clause 7 receipt, wired as a MUST rather than left to an
+  # operator's memory. A schema is not a product — omp's bootstrap-payload submission
+  # PARSES correctly, and parsing is exactly what pi got right while submitting no message
+  # at all, so a release whose fresh_call(omp) opens a window that never runs its turn
+  # would pass every deterministic gate here. That is not hypothetical for this backend:
+  # the retired positional candidate parsed perfectly and still answered `ACK` with zero
+  # tool calls, because the turn began before the callback tool existed. New contract,
+  # applied from omp onward; it does not retroactively redesign Copilot's operator-metered
+  # exclusion.
+  run_live_step "smoke-omp-fresh-live (#87 bundle C: entwurf_fresh_call opens omp, exact nonce callback, addressed receive)" gate bash "$self" smoke-omp-fresh-live
 
   # 4. BEHAVIOR lane (advisory, non-blocking). Model-in-loop gates that probe
   #     whether the model AUTONOMOUSLY drives the MCP entwurf surface. These never
@@ -5430,6 +5658,15 @@ case "$cmd" in
   check-entwurf-capabilities)
     check_entwurf_capabilities
     ;;
+  check-harness-admission-parity)
+    check_harness_admission_parity
+    ;;
+  check-omp-fresh-preflight)
+    check_omp_fresh_preflight
+    ;;
+  smoke-omp-fresh-live)
+    smoke_omp_fresh_live
+    ;;
   check-capability-bundle-reach)
     check_capability_bundle_reach
     ;;
@@ -5454,6 +5691,18 @@ case "$cmd" in
   check-copilot-birth-hook)
     check_copilot_birth_hook
     ;;
+  check-omp-birth-hook)
+    # #87 gate: the OMP BIRTH path without omp. Drives the real assembler into a temp dir,
+    # then imports the ASSEMBLED index.ts into a mock omp host (mock ExtensionAPI + mock
+    # ExtensionContext) and fires the two birth edges. Requires: a backend:"omp" v3 record
+    # only under mode "tui"; NOTHING under print/rpc/json (a task subagent is not a citizen,
+    # and hasUI is deliberately true on the rpc rows because it is true in the vendor too);
+    # session_switch attaching on the same native id and minting the replacement on a new
+    # one; a sender marker keyed to the HOST process's OWN pid (never its parent — the
+    # one-process join) that the production resolver joins back to the record; the garden id
+    # on the status line; and still zero mailbox/receiver marker. Hermetic; no omp, no model turn
+    run_ts scripts/check-omp-birth-hook.ts
+    ;;
   check-copilot-statusline)
     check_copilot_statusline
     ;;
@@ -5586,6 +5835,12 @@ case "$cmd" in
   smoke-acp-bundled-mcp-live)
     smoke_acp_bundled_mcp_live
     ;;
+  smoke-omp-receive-live)
+    # #87 bundle B — the acceptance that makes omp's one-way garden executable.
+    # Reads the capability registry and reports its own PASS/SKIP/FAIL; see the
+    # header of the script for the three branches.
+    run_ts scripts/smoke-omp-receive-live.ts
+    ;;
   smoke-entwurf-chain-live)
     # P3 — the cross-harness delivery CHAIN on real authenticated rails:
     # native Claude Code -> pi GPT -> pi ACP Claude Sonnet -> mailbox terminus,
@@ -5910,6 +6165,116 @@ case "$cmd" in
   smoke-copilot-mcp-state)
     (cd "$REPO_DIR" && bash scripts/smoke-copilot-mcp-state.sh)
     ;;
+  smoke-omp-bridge-state)
+    (cd "$REPO_DIR" && bash scripts/smoke-omp-bridge-state.sh)
+    ;;
+  install-omp-mcp)
+    (cd "$REPO_DIR" && bash scripts/omp-mcp-bridge.sh install "$@")
+    ;;
+  uninstall-omp-mcp)
+    (cd "$REPO_DIR" && bash scripts/omp-mcp-bridge.sh uninstall "$@")
+    ;;
+  doctor-omp-mcp)
+    (cd "$REPO_DIR" && bash scripts/omp-mcp-bridge.sh doctor "$@")
+    ;;
+  smoke-omp-mcp-state)
+    (cd "$REPO_DIR" && bash scripts/smoke-omp-mcp-state.sh)
+    ;;
+  install-omp-config)
+    # #87 follow-on: the ONE operator setting omp's tool hand requires (`tools.xdev: false`).
+    # A separate unit from install-omp-mcp because it answers a different question — the MCP
+    # hand registers the server, this decides whether the registered tools are REACHABLE. It
+    # owns exactly the line it adds and refuses an explicit operator `xdev: true` by name.
+    shift || true
+    (cd "$REPO_DIR" && bash scripts/omp-config-xdev.sh install "$@")
+    ;;
+  uninstall-omp-config)
+    # honest inverse from install-state: takes back exactly the recorded line(s), removes the
+    # file only when entwurf created it, and REFUSES when the config changed since install.
+    shift || true
+    (cd "$REPO_DIR" && bash scripts/omp-config-xdev.sh uninstall "$@")
+    ;;
+  install-omp-bridge)
+    # #87: the OMP BIRTH install. Not a mode of the Claude or Copilot installer, and for a
+    # structural reason rather than a stylistic one: an omp "hook" IS an in-process
+    # extension, so there is no launcher to bake a node path into and no hook manifest to
+    # declare events in — the vendor imports the module itself. What this owns is one
+    # directory under the omp agent dir; the MCP hand is install-omp-mcp.
+    shift || true
+    (cd "$REPO_DIR" && bash scripts/omp-bridge-install.sh "$@")
+    ;;
+  uninstall-omp-bridge)
+    # The package-owned inverse: the ownership state is the sole removal authority (exact
+    # unit dir, recorded entry name, recorded assembly), a no-state host REFUSES instead of
+    # cleaning up what it cannot prove is ours, and the state is deleted LAST.
+    shift || true
+    (cd "$REPO_DIR" && bash scripts/omp-bridge-uninstall.sh "$@")
+    ;;
+  doctor-omp-bridge)
+    # #87: the fail-loud surface for the OMP unit. Red is a unit omp cannot import, a STALE
+    # deployed writer, an unrecovered mint ERROR, a failed sender-marker write, or a live omp
+    # process carrying inherited PI_SESSION_ID/PI_AGENT_ID. "Installed with zero records" is
+    # NOT-YET, not red.
+    shift || true
+    (cd "$REPO_DIR" && bash scripts/omp-bridge-doctor.sh "$@")
+    ;;
+  install-omp-receive)
+    # #87 bundle B: install the OMP RECEIVER extension into
+    # <omp agent dir>/extensions/entwurf-receive-omp. Its own unit, install-state, doctor and
+    # inverse — birth says who sends, this says a reply can land, and neither grants the other.
+    # Same ownership discipline as the birth installer: no adoption of an artifact entwurf holds
+    # no state for, no writing through a symlink, refusal when the agent dir is ambiguous.
+    shift || true
+    (cd "$REPO_DIR" && bash scripts/omp-receive-install.sh "$@")
+    ;;
+  uninstall-omp-receive)
+    # honest inverse from install-state (exact unit dir + recorded entry; no-state host REFUSES;
+    # state deleted LAST). Records, sender identity and any ALREADY-armed live session are
+    # untouched — an omp TUI that armed before this ran stays addressable until it exits.
+    shift || true
+    (cd "$REPO_DIR" && bash scripts/omp-receive-uninstall.sh "$@")
+    ;;
+  doctor-omp-receive)
+    # #87 bundle B: runtime axis (importable unit, writer parity, arm vs doorbell failures on
+    # SEPARATE axes, and WHO IS ARMED right now read through the PRODUCTION marker reader via
+    # omp-receive-facts — never a filename) + ownership axis. Zero armed receivers is NOT-YET.
+    # It reports a marker for exactly what a marker proves: a live owner reached the arm emit.
+    # It never claims the vendor's watch is still registered — see the header.
+    shift || true
+    (cd "$REPO_DIR" && bash scripts/omp-receive-doctor.sh "$@")
+    ;;
+  smoke-omp-receive-state)
+    # #87 bundle B: OMP RECEIVER install/doctor/inverse regression — placement, stale-writer
+    # detection, honest inverse, no-state refusal (structurally VALID as well as foreign),
+    # symlink refusal, ambiguous-agent-dir refusal, a poisoned PI_CODING_AGENT_DIR that
+    # attracts no artifact, plus the two this surface owns: installing a doorbell ARMS
+    # NOTHING, and a host with no birth unit is a green doctor with a NAMED dependency note
+    # rather than a red one. Fully sandboxed HOME/PI/XDG. Offline/deterministic
+    shift || true
+    (cd "$REPO_DIR" && bash scripts/smoke-omp-receive-state.sh "$@")
+    ;;
+  check-omp-receive-arm)
+    # #87 bundle B gate: drives the REAL receive assembler into a temp dir, imports the
+    # ASSEMBLED index.ts into a MOCK omp host and proves everything on entwurf's side of the
+    # vendor boundary — the tui-only scope fence, deferral before birth and the BOUNDED retry
+    # that arms once the sender marker appears, the refusal to start a timer this build cannot
+    # cancel, the refusal to arm when the wake surface is missing, id-drift refusal, the /new
+    # unarm that the start-key guard structurally cannot catch, no-watch-no-marker ordering,
+    # an announce-only doorbell that never carries the body, a vanished signal giving the
+    # marker back, and an identity-guarded teardown. Hermetic; no omp, no model turn. What it
+    # deliberately cannot prove — that the vendor really wakes an idle host — is
+    # smoke-omp-receive-live's job, and neither receipt substitutes for the other
+    shift || true
+    run_ts scripts/check-omp-receive-arm.ts "$@"
+    ;;
+  omp-receive-facts)
+    # #87 bundle B: read-only JSON projection of the omp receive rail — every receiver marker
+    # read through readMetaReceiverMarker in BOTH readings (live / as-written), plus the mailbox
+    # counts behind each. The shared oracle for doctor-omp-receive, the state smoke and the LIVE
+    # acceptance, so none of them answers "is a doorbell held?" from a filename.
+    shift || true
+    run_ts scripts/omp-receive-facts.ts "$@"
+    ;;
   copilot)
     # #82 RAIL 7: the managed launch. `exec` and NO subshell/cd on purpose — the vendor
     # must inherit this terminal exactly: the caller's cwd, this pid, this tty, and its own
@@ -6161,6 +6526,9 @@ case "$cmd" in
   check-acp-prompt-lifecycle)
     check_acp_prompt_lifecycle
     ;;
+  check-acp-launch-namespace)
+    check_acp_launch_namespace
+    ;;
   check-acp-stream-hooks)
     check_acp_stream_hooks
     ;;