@junghanacs/entwurf 0.15.1 → 0.16.0

package/run.sh

@@ -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,17 @@ 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-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
@@ -235,7 +252,7 @@ Usage:
   ./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-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 +791,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 +1291,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() {
@@ -2891,6 +2948,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 +2959,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"
@@ -3146,12 +3213,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"
@@ -3257,8 +3333,15 @@ _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.3` 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. The bump itself stays a separate
+  # hard-cut lane (#87 thread / NEXT "Do not touch: Pi 0.84.4") — pinning the
+  # drift shut is how the verified 0.84.3 runtime stays OURS to hold. 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 \
@@ -3269,6 +3352,7 @@ _check_pack_install_impl() {
     "@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-telemetry@0.84.3" \
     "typebox@latest" \
     --ignore-workspace --ignore-scripts 2>&1) || {
     fail "[check-pack-install] pnpm add failed:"
@@ -3882,6 +3966,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]))
@@ -5317,6 +5471,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 +5599,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 +5632,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 +5776,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 +6106,102 @@ 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-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

package/scripts/check-entwurf-self-address.ts

@@ -155,6 +155,26 @@ function row(facts: SelfAddressabilityFacts): { replyable: boolean; socketState:
 	);
 }
 
+// meta-session / NONE rail: no inbound transport at all. Mailbox facts and a live probe
+// cannot buy replyability — there is nothing to land on. Distinct from the unsupplied
+// (undefined) domain row below, which stays fail-closed for a caller that forgot the axis.
+{
+	const noneFacts: SelfAddressabilityFacts = {
+		origin: "meta-session",
+		metaDeliveryDomain: "none",
+		recordBacked: true,
+		ownerAlive: true,
+		watchArmed: true,
+		probeAlive: true,
+	};
+	const noneRail = computeSelfAddressability(noneFacts);
+	ok("meta/none + all facts true → NOT replyable", noneRail.replyable === false);
+	ok(
+		"meta/none names the missing inbound rail (mailbox/probe facts cannot rescue it)",
+		noneRail.reason.includes("no inbound rail"),
+	);
+}
+
 // meta-session with NO rail declared: we cannot say how a reply would travel, so we do not
 // claim it would arrive. The domain is derived from nativePushSupported(backend) — a caller
 // that forgets it gets a refusal, not an optimistic guess.
@@ -246,6 +266,17 @@ ok(
 	/existsSync\s*\(/.test(piBody) && /controlSocketPathIn\s*\(\s*ENTWURF_DIR\s*,/.test(piBody),
 );
 
+const metaBuilder = functionBody("buildTrustedMetaSenderEnvelope");
+// FIRST of the two derivation claims so a binary-fallback mutant dies here, not at the seam pin.
+ok(
+	"buildTrustedMetaSenderEnvelope does not fall back every non-native-push backend to self-fetch [QK:SELFADDR-NO-FALLBACK-SELF-FETCH]",
+	!/\?\s*"native-push"\s*:\s*"self-fetch"/.test(metaBuilder),
+);
+ok(
+	"buildTrustedMetaSenderEnvelope derives self-fetch through resolveMailboxWakeModeCapability(identity), not a backend-name list [QK:SELFADDR-MAILBOX-WAKE-SEAM]",
+	/resolveMailboxWakeModeCapability\s*\(\s*identity\s*\)/.test(metaBuilder),
+);
+
 const selfRegion = toolRegion("entwurf_self");
 ok(
 	"entwurf_self existsSync-probes the pi socket (alive vs expected, no synthesized path lie)",

package/scripts/check-gate-qualification.ts

@@ -821,11 +821,14 @@ console.log(`\n[gate-qualification] self-test: ${passed} checks passed`);
 		"pack-install": 1,
 		"pi-package-ownership": 6,
 		"mux-resume-call": 12,
+		"omp-birth": 11,
+		"omp-fresh": 24,
+		"omp-receive": 11,
 		"probe-ordering": 1,
 		"release-gate": 12,
 		"resume-args": 6,
 		"resume-launch-identity": 6,
-		"self-address": 3,
+		"self-address": 5,
 		"setup-verdict": 10,
 		"source-install": 2,
 		"v2-surface": 7,