@junghanacs/entwurf 0.14.2 → 0.15.1

package/docs/setup-clean-host.md

@@ -9,10 +9,12 @@ only on Linux because its strict live-owner join uses `/proc`.
 | Component | Requirement | Needed for |
 |---|---|---|
 | Node | **`>=24.0.0`** | package and bridge runtime |
-| npm | bundled with Node | package installation |
-| entwurf | `@junghanacs/entwurf` | all lanes |
-| pi | optional, `@earendil-works/pi-coding-agent >=0.84.2 <0.85` | ACP provider, control sockets |
+| npm/pnpm | npm is bundled with Node; pnpm is required for source setup | package or source installation |
+| Python 3 | required by `setup`/`install` (project-path normalization + settings writers); `--help`/`check-bridge` stay Python-free | pi/Claude/agy/Copilot wiring writers |
+| entwurf | global/project-local `@junghanacs/entwurf`, or a source checkout | operator command and garden capability |
+| pi | optional-by-presence, `>=0.84.3 <0.85` — absent is an explicit setup SKIP, below-floor is a named FAIL | ACP provider, control sockets |
 | Claude Code | optional, **`>=2.1.217`** — the exec-form hook floor | Claude ACP auth/runtime and mailbox-backed native citizen |
+| GitHub Copilot CLI | optional-by-presence, operator-installed and authenticated — absent is an explicit setup SKIP; detected composes all four units (birth/MCP/receiver/footer) | self-fetch citizen and visible fresh |
 | Antigravity `agy` | optional, operator-installed and authenticated | native-push citizen |
 | Cortex Code | optional, operator-installed and authenticated | Cortex ACP backend |
 
@@ -51,12 +53,62 @@ npx entwurf check-bridge
 `check-bridge` is auth-free. It proves the installed prebuilt MCP server boots and
 lists the seven garden tools; it does not prove a backend model turn or native hook.
 
+Neither npm form installs a harness runtime. `pi`, Claude Code, Copilot CLI, agy, Cortex and their
+authentication remain operator-owned optional prerequisites for the integrations that use them;
+all may be absent on an Entwurf-only host. A source checkout's pinned Pi development packages are
+for building and testing this repo, not a transitive product installation promise.
+
+Maintainers using a source checkout do not install a second global entwurf package. Full source
+setup currently requires Node 24, pnpm, and Python 3 on PATH; every harness — including pi — is
+optional-by-presence (absent → explicit SKIP, detected but below the supported floor → named FAIL
+with a nonzero setup result):
+
+```bash
+git clone https://github.com/junghan0611/entwurf ~/repos/gh/entwurf
+cd ~/repos/gh/entwurf
+./run.sh setup /path/to/consumer-project
+```
+
+This owns `~/.local/bin/entwurf` as a symlink to that checkout's `run.sh` and fails if the
+link is foreign, outside PATH, or shadowed by another command. It detects and wires
+pi/Claude/agy/Copilot by presence and prints a computed per-component PASS/SKIP/FAIL summary — a
+detected harness that cannot be completed makes setup exit nonzero. A detected `copilot`
+composes all four native units (birth → MCP → receiver → visible footer) with independent
+per-unit verdicts (#86 C3b); §4 keeps the explicit per-unit install/doctor/inverse surfaces for
+repair.
+
+### 1.1 User-scope ownership (one shared registration, one recorded owner)
+
+The GLOBAL pi user-scope registration (`~/.pi/agent/settings.json` `packages[]` plus the
+`entwurfProvider.mcpServers.entwurf-bridge` key) is ONE shared entry across every install root, and
+it carries a recorded owner: `packageRoot` in `$XDG_DATA_HOME/entwurf/pi-package/install-state.json`
+and `installerRoot` in the provider install-state. Normal `install`/`setup` from a different root —
+whether the recorded owner is live or missing — refuses with zero settings bytes written; the only
+writer that moves the shared entry is the operator-explicit `entwurf takeover-user-scope`
+(old→new reported). Every user-scope operation is ATOMIC across the two halves: both ownership
+preflights run read-only first, so a refusal on either side leaves the other byte-identical. A
+takeover over an operator's own provider override is a SPLIT verdict — the package owner moves,
+the override is preserved and stays unowned (its stale ownership state is cleared), never a false
+"both owned". A LEGACY provider state (no `installerRoot`) accepts no inverse: run `setup`/`install`
+from the owning root first (named adoption), then remove. Both install-states also bind the exact
+settings file they manage (`managedSettingsPath`): pointing an operation at a different, symlinked
+or unparseable file refuses with zero writes before either half proceeds, and the owned/orphan
+inverse removes only the recorded owner's exact `packages[]` entry (0 or 2+ exact entries refuse).
+`entwurf doctor-pi-package` names the package-side verdict including the
+packageRoot↔installerRoot coupling mismatch and a package/provider managed-path mismatch.
+
+| Root shape | Package root written | Stable commands from | Project write | User write | Takeover trigger | Inverse | Stale/moved verdict |
+|---|---|---|---|---|---|---|---|
+| source checkout | the checkout dir | `dev-bin` symlinks (`setup`) | `<project>/.pi/settings.json` | shared entry + owner state | `takeover-user-scope` from the new checkout | `remove` (project) / `remove-user-scope` (global, same-owner-only) | `doctor-pi-package` → `missing-owner`; normal install still refuses |
+| global npm (`npm i -g`) | the global `node_modules/@junghanacs/entwurf` | npm bin linking | same | same shared entry | same explicit action | same; a LIVE foreign owner always refuses | same |
+| project-local npm | that project's `node_modules/@junghanacs/entwurf` | `node_modules/.bin` | same | same shared entry | same explicit action | same | same; a deleted root becomes the aligned `remove-user-scope` orphan cleanup (entry + package state + provider installerRoot must all name that missing root) |
+
 ## 2. Optional pi adapter / ACP plugin
 
 Install the exact release floor, then wire the project:
 
 ```bash
-npm install -g @earendil-works/pi-coding-agent@0.84.2
+npm install -g @earendil-works/pi-coding-agent@0.84.3
 pi --version
 
 cd ~/entwurf-smoke
@@ -64,7 +116,7 @@ entwurf install .
 pi -e "$(npm root -g)/@junghanacs/entwurf" --list-models entwurf
 ```
 
-The supported range is `>=0.84.2 <0.85`. It is a hard minimum: installing this
+The supported range is `>=0.84.3 <0.85`. It is a hard minimum: installing this
 release onto a 0.83.x pi host upgrades the runtime rather than keeping the older
 minor. A host using only the external MCP bridge can skip pi until it needs a
 control socket; no delivery rail launches a pi process.
@@ -109,7 +161,31 @@ New macOS wiring is refused because the live join is not instrumented there. Dar
 uninstall remains available for cleaning an older managed install; this is an evidence
 boundary, not a permanent impossibility claim.
 
-## 4. Optional Antigravity native citizen
+## 4. Optional GitHub Copilot CLI native citizen
+
+Copilot has four independently owned surfaces. `setup` composes all four when `copilot` is on
+PATH (#86 C3b); the commands below are the per-unit repair, doctor, and inverse surfaces. All
+four must be green for supported visible fresh; a manual citizen may omit the footer, but fresh
+refuses before opening a window when any required surface is absent.
+
+```bash
+entwurf install-copilot-bridge
+entwurf install-copilot-mcp
+entwurf install-copilot-receive
+entwurf install-copilot-statusline
+
+entwurf doctor-copilot-bridge
+entwurf doctor-copilot-mcp
+entwurf doctor-copilot-receive
+entwurf doctor-copilot-statusline
+```
+
+Launch the supported invocation with `entwurf copilot`, not bare `copilot`. It enables extension
+scanning for that process, checks the receiver, removes inherited pi identity carriers, and owns
+the model/permission defaults. Birth occurs on the first prompt. `entwurf_fresh_call` uses this
+same managed invocation and requires the birth, MCP, receiver, and visible-identity preflight.
+
+## 5. Optional Antigravity native citizen
 
 Install the three independently owned surfaces:
 
@@ -134,7 +210,7 @@ Real native-push acceptance needs an already-running conversation:
 LIVE=1 AGY_CONVERSATION_ID=<id> entwurf smoke-agy-native-push-live
 ```
 
-## 5. Optional ACP backend turns
+## 6. Optional ACP backend turns
 
 Claude uses the operator's existing local Claude authentication:
 
@@ -153,25 +229,34 @@ LIVE=1 ENTWURF_ACP_CORTEX_CONNECTION=<conn> \
 The aggregate release gate is Claude-backed and does not run Cortex automatically.
 Its silence is not a Cortex PASS.
 
-## 6. Upgrade and repair
+## 7. Upgrade and repair
 
 After upgrading the package, rerun the managed installers for every native harness
 in use and restart their existing processes. Native plugin caches are not live-reload
 safe across launch-contract changes.
 
 If install or doctor reports an unreadable/old active citizen generation, do not edit
-records by hand:
+records by hand. Close pi, Claude, Copilot, and agy sessions first, run
+`entwurf meta-bridge-fresh-cut`, and read its exit status before any install. Then choose the
+installation mode you actually own:
 
 ```bash
-# close pi, Claude, and agy sessions first
-entwurf meta-bridge-fresh-cut
-entwurf setup ~/entwurf-smoke
+# npm package consumer
+entwurf install ~/entwurf-smoke
+entwurf install-meta-bridge
+# `entwurf setup` re-composes the four Copilot units when `copilot` is on PATH
+
+# source maintainer — from the checkout
+./run.sh setup ~/entwurf-smoke
 ```
 
-Read the cut's exit status before chaining setup. The complete quiescence, archive,
-and exit-code contract is [fresh-cut-policy.md](./fresh-cut-policy.md).
+The package-installed `entwurf setup` is the same consumer command in installed mode: it names
+that mode first, never runs npm/pnpm inside `node_modules` (the frozen pnpm bootstrap is
+source-checkout-only), and composes the detected harnesses with the same per-component
+PASS/SKIP/FAIL summary. The complete quiescence, archive, and exit-code contract is
+[fresh-cut-policy.md](./fresh-cut-policy.md).
 
-## 7. Release acceptance versus host acceptance
+## 8. Release acceptance versus host acceptance
 
 - `entwurf check-bridge`: installed MCP bytes boot; no backend auth.
 - `pnpm check` / `pnpm run check:full`: tiered source deterministic floors (everyday
@@ -190,12 +275,27 @@ Run only the surfaces this host owns:
 
 ```bash
 entwurf uninstall-meta-bridge
+entwurf uninstall-copilot-statusline
+entwurf uninstall-copilot-receive
+entwurf uninstall-copilot-mcp
+entwurf uninstall-copilot-bridge
 entwurf uninstall-agy-hooks
 entwurf uninstall-agy-statusline
 entwurf uninstall-agy-bridge
-entwurf uninstall ~/entwurf-smoke
+entwurf remove ~/entwurf-smoke
+# only when no other project uses the shared user-scope pi registration:
+entwurf remove-user-scope
 npm uninstall -g @junghanacs/entwurf
 ```
 
-Each managed surface has an honest inverse and preserves unrelated native-harness
-configuration.
+The package `uninstall-*`/`remove` surfaces preserve unrelated native-harness configuration.
+Copilot birth now has a package-owned inverse: `uninstall-copilot-bridge` removes exactly what
+its install-state (`$XDG_DATA_HOME/entwurf/copilot-bridge/install-state.json`) records — the
+qualified plugin, the local marketplace registration when it is owned and still at the recorded
+path, and the recorded assembly — never with `--force`, never a bare plugin name that could
+match somebody else's unit, and never the stale Claude unit. The complete ownership preflight
+runs read-only before the first vendor write, so a marketplace under our name at another path,
+a registration the state does not own, or a failing vendor list (UNKNOWN, never absence)
+refuses the whole inverse with zero writes; the state is deleted last, so a partial failure
+keeps a rerun-repair authority.
+A legacy no-state installation is adopted by re-running `install-copilot-bridge` first.

package/mcp/entwurf-bridge/dist/mcp/entwurf-bridge/src/index.js

@@ -562,22 +562,24 @@ server.tool("entwurf_register_native", "Register an ALREADY-RUNNING native conve
 // its own garden id, a fresh cell answered with its uuidv7 `PI_SESSION_ID` value read out of the
 // environment by an MCP server it had spawned itself — confidently, and wrong. A sibling launched
 // against that answer would call home to a garden id nobody holds.
-server.tool("entwurf_fresh_call", "Open ONE fresh visible sibling in the operator's own tmux session and hand it a first task. Two fixed " +
-    "backends only: pi, claude-code. The sibling's FIRST action is a callback to you carrying a nonce, and the " +
+server.tool("entwurf_fresh_call", "Open ONE fresh visible sibling in the operator's own tmux session and hand it a first task. Three fixed " +
+    "backends only: pi, claude-code, copilot. The sibling's FIRST action is a callback to you carrying a nonce, and the " +
     "sender envelope of that callback is its garden id — that is how you learn the address of something that " +
     "did not exist a moment ago. This returns a LAUNCH receipt (tmux window/pane plus that nonce) and nothing " +
     "else: it does NOT mean the runtime started, the first turn ran, or the task was delivered. Nothing polls " +
     "for the callback; if it never arrives the window is visible and can be read directly. For EXISTING " +
     "citizens use entwurf_v2 — this tool only creates, and entwurf_peers only reports. Model is REQUIRED and " +
-    "is passed to the chosen runtime CLI (`provider/model` for pi; model id/alias for Claude Code). An optional " +
+    "is passed to the chosen runtime CLI (`provider/model` for pi; model id/alias for Claude Code; a model name " +
+    "or `auto` for copilot). A copilot launch goes through entwurf's own managed invocation and is refused " +
+    "BEFORE any window opens if this host lacks the Copilot birth, MCP, receiver or visible-footer units. An optional " +
     "cwd starts the sibling in ONE literal absolute existing directory (cross-repo fresh) — never pick resume " +
     "for a dormant record's cwd; resume is continuity-only. Omitted/empty cwd means the caller's own directory. " +
     "There are no arbitrary command/env knobs. Do not put secrets in the task — model and task argv are visible to " +
     "same-user processes on this host. Requires that this agent itself runs " +
     "inside tmux: without a pane anchor there is no session to open a sibling beside.", {
     backend: z
-        .enum(["pi", "claude-code"])
-        .describe("Which fixed runtime to open. Only these two; there is no arbitrary command."),
+        .enum(["pi", "claude-code", "copilot"])
+        .describe("Which fixed runtime to open. Only these three; there is no arbitrary command."),
     model: z
         .string()
         .min(1)
@@ -591,7 +593,7 @@ server.tool("entwurf_fresh_call", "Open ONE fresh visible sibling in the operato
         // as an unused suppression while the escape goes back to being fixable.
         // biome-ignore lint/complexity/noUselessEscapeInRegex: emitted to a Rust regex validator, see above
         .regex(/^[A-Za-z0-9][A-Za-z0-9._/:\[\]-]*$/)
-        .describe("Required runtime model: canonical provider/model for pi, or a Claude Code model id/alias."),
+        .describe("Required runtime model: canonical provider/model for pi, a Claude Code model id/alias, or a Copilot model name (or auto)."),
     task: z
         .string()
         .min(1)

package/mcp/entwurf-bridge/dist/pi-extensions/entwurf-capabilities.json

@@ -4,6 +4,7 @@
 		"claude-code": { "wakeMode": "self-fetch", "deliveryLevel": "D6", "nativeIdLabel": "sessionId" },
 		"antigravity": { "wakeMode": "direct-inject", "deliveryLevel": "D6", "nativeIdLabel": "conversationId" },
 		"codex": { "wakeMode": "direct-inject", "deliveryLevel": "D6", "nativeIdLabel": "threadId" },
+		"copilot": { "wakeMode": "self-fetch", "deliveryLevel": "D6", "nativeIdLabel": "sessionId" },
 		"pi": { "wakeMode": "direct-inject", "deliveryLevel": "D6", "nativeIdLabel": "sessionId" }
 	}
 }

package/mcp/entwurf-bridge/dist/pi-extensions/lib/copilot-fresh-preflight.js

@@ -0,0 +1,253 @@
+/**
+ * copilot-fresh-preflight — the pre-mutation capability check a Copilot fresh call needs
+ * (#82 RAIL 9, `docs/adding-a-harness.md` step 9 clauses 3 and 4).
+ *
+ * ── Why this is a leaf and not a doctor ──
+ *
+ * A doctor answers "is this host correctly wired?" and is allowed to be slow, to spawn the
+ * vendor CLI, and to read live processes. This is not that. It answers ONE narrower question
+ * at ONE moment: *before* `mux-fresh-call` mutates the operator's tmux session, are the four
+ * things the fresh contract requires actually in place on this filesystem?
+ *
+ *   birth            — without the birth plugin the session mints no record, so the callback
+ *                      would carry no garden id and the sibling never becomes addressable.
+ *   MCP hand         — without the bridge server the callback tool does not exist in that
+ *                      session, and the first turn has nothing to call.
+ *   receive          — without the receiver unit the sibling can be launched and can call
+ *                      home, and then nothing can ever be delivered TO it.
+ *   visible identity — without the custom footer the citizen has a garden id nobody can see,
+ *                      which step 4 refuses to call lifecycle parity.
+ *
+ * ── Ordering is the whole point ──
+ *
+ * `scripts/copilot-launch.sh` already fails closed on the receiver, and that check is kept as
+ * it is: it guards every manual `entwurf copilot`, whose accepted contract stays receive-only.
+ * But a launcher runs INSIDE the window tmux just made, so its refusal leaves a dead window
+ * behind and the caller reads a launch receipt for a sibling that never was. `mux-fresh-call`'s
+ * rule is that nothing above the single mutation may leave a window behind, so the fresh lane
+ * decides the same facts one layer earlier. The overlap on the receiver axis is deliberate and
+ * each side names the other; the other three axes are the FRESH lane's requirement only.
+ *
+ * ── What this deliberately does NOT claim ──
+ *
+ * Ownership/configuration truth only: entwurf's units are installed and the settings the
+ * vendor will read say what they must say. It does NOT prove the Copilot CLI loaded the
+ * plugin, connected the MCP server, scanned the extension, or rendered a garden id in its
+ * footer — that is runtime truth, and it belongs to `doctor-copilot-*` (which may spawn the
+ * vendor) and to the step 9 clause 7 LIVE receipt. A green preflight is a statement about this
+ * filesystem, not a prediction about the next process.
+ *
+ * Every predicate below MIRRORS the shipped adapter that owns that file, deliberately
+ * including its environment seams — a preflight that resolved a path its own installer never
+ * writes would refuse a correctly installed host and send the operator hunting.
+ *
+ * No vendor spawn, no network, no await, no mutation.
+ */
+import { accessSync, constants, existsSync, lstatSync, readFileSync, statSync } from "node:fs";
+import * as path from "node:path";
+const BIRTH_PLUGIN = "entwurf-meta-receive-copilot";
+const RECEIVE_UNIT = "entwurf-receive";
+const MCP_SERVER_KEY = "entwurf-bridge";
+/** Same default and same env seam as `scripts/copilot-statusline-bridge.sh`. */
+const DEFAULT_STATUSLINE_COMMAND = "entwurf-copilot-statusline";
+function dataHome(env) {
+    const xdg = env.XDG_DATA_HOME;
+    if (typeof xdg === "string" && xdg.length > 0)
+        return xdg;
+    const home = env.HOME;
+    if (typeof home === "string" && home.length > 0)
+        return path.join(home, ".local", "share");
+    return null;
+}
+/** A JSON object or nothing. Failure to read, parse, or find an object is the SAME answer
+ * here — absent — because the caller's next move is identical in all of them: run the
+ * installer. Telling a corrupt state file apart from a missing one is the doctor's job. */
+function readJsonObject(file) {
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        // Bounded environment probing, Hard Rule 15's stated exception.
+        return null;
+    }
+}
+function isDir(p) {
+    try {
+        return statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function isSymlink(p) {
+    try {
+        return lstatSync(p).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+/** Same DEST the managed launcher will arm from (`scripts/copilot-launch.sh`).
+ * `COPILOT_EXTENSIONS_DIR` wins; otherwise `$HOME/.copilot/extensions/<unit>`.
+ * String equality, not realpath: the launcher compares with `[ = ]`. */
+function receiveDest(env) {
+    const override = env.COPILOT_EXTENSIONS_DIR;
+    if (typeof override === "string" && override.length > 0) {
+        return path.join(override, RECEIVE_UNIT);
+    }
+    const home = env.HOME;
+    if (typeof home !== "string" || home.length === 0)
+        return null;
+    return path.join(home, ".copilot", "extensions", RECEIVE_UNIT);
+}
+function isExecutableFile(p) {
+    try {
+        // `X_OK` for THIS user, which is what `command -v` answers and what Copilot will need.
+        // A mode-bit test would call a root-owned 0700 binary executable for everyone.
+        accessSync(p, constants.X_OK);
+        return statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The statusline command as the shipped adapter resolves it: a value containing a separator is
+ * a path and must be executable; a bare name is looked up on PATH. This is a small local
+ * search rather than `mux-launch`'s resolver because the import fence keeps `mux-launch` to
+ * exactly two importers — a third would be a decision, and this leaf does not need one.
+ */
+function commandResolvable(command, env) {
+    if (command.includes("/"))
+        return isExecutableFile(command);
+    const raw = env.PATH;
+    if (typeof raw !== "string" || raw.length === 0)
+        return false;
+    for (const dir of raw.split(path.delimiter)) {
+        if (dir.length === 0)
+            continue;
+        if (isExecutableFile(path.join(dir, command)))
+            return true;
+    }
+    return false;
+}
+/**
+ * The visible-identity axis, step 9 clause 4. The subject is the EFFECTIVE settings the vendor
+ * will read, not entwurf's ownership record: a host can carry a correct footer configuration
+ * with no install-state (measured on the acceptance host, 2026-08-24 — `doctor-copilot-statusline`
+ * reported `settings: configured (resolvable)` / `state: absent` / rc=0), and refusing that host
+ * would be refusing a working visible identity because of a missing receipt.
+ *
+ * The install-state, when present, is checked for the ONE thing it can still contradict: that
+ * it manages the very file Copilot reads. A state pointing somewhere else means two settings
+ * files disagree about who owns the footer, and which one wins is not decidable from here.
+ */
+function visibleIdentityMissing(env, data) {
+    const command = env.COPILOT_STATUSLINE_COMMAND || DEFAULT_STATUSLINE_COMMAND;
+    const configured = env.COPILOT_SETTINGS_CONFIG;
+    let settingsPath;
+    if (typeof configured === "string" && configured.length > 0) {
+        settingsPath = configured;
+    }
+    else {
+        const home = env.HOME;
+        if (typeof home !== "string" || home.length === 0)
+            return true;
+        settingsPath = path.join(home, ".copilot", "settings.json");
+    }
+    // A symlinked settings file is somebody else's SSOT; the adapter refuses to touch it and
+    // this refuses to certify it.
+    if (isSymlink(settingsPath))
+        return true;
+    const settings = readJsonObject(settingsPath);
+    if (settings === null)
+        return true;
+    const statusLine = settings.statusLine;
+    if (typeof statusLine !== "object" || statusLine === null || Array.isArray(statusLine))
+        return true;
+    if (statusLine.command !== command)
+        return true;
+    const footer = settings.footer;
+    if (typeof footer !== "object" || footer === null || Array.isArray(footer))
+        return true;
+    // `showCustom` must be exactly true. A truthy string would render nothing.
+    if (footer.showCustom !== true)
+        return true;
+    if (!commandResolvable(command, env))
+        return true;
+    const state = readJsonObject(path.join(data, "entwurf", "copilot-statusline", "install-state.json"));
+    if (state === null)
+        return false; // absent state is not drift — see the doc comment above
+    const managed = state.managedSettingsPath;
+    if (typeof managed !== "string" || !path.isAbsolute(managed))
+        return true;
+    return path.resolve(managed) !== path.resolve(settingsPath);
+}
+/**
+ * Answer for ONE fresh Copilot launch. `null` means every required capability is in place on
+ * this filesystem; anything else is the first missing one, in the order the fresh contract
+ * consumes them: be born, hold the hand, be reachable, be visible.
+ */
+export function copilotFreshPreflight(env = process.env) {
+    const data = dataHome(env);
+    // With no HOME and no XDG_DATA_HOME there is no place any of these could be installed.
+    // Report the FIRST capability rather than inventing a fifth reason for "no home".
+    if (data === null)
+        return "copilot-birth-unit-missing";
+    // 1. Birth. The assembly is what the installer bakes and what the birth doctor certifies
+    // statically; `hooks.json` is what makes it a hook unit rather than a directory. There is
+    // no install-state for this unit — the artifact IS its ownership record.
+    const birthUnit = path.join(data, "entwurf", "meta-bridge-copilot", ".assembled", BIRTH_PLUGIN);
+    if (!isDir(birthUnit) || !existsSync(path.join(birthUnit, "hooks", "hooks.json"))) {
+        return "copilot-birth-unit-missing";
+    }
+    // 2. MCP hand. The install-state names the config it owns, so the config path is READ from
+    // ownership truth rather than re-derived — a preflight that guessed would refuse a
+    // correctly installed host whose config lives somewhere else.
+    const mcpState = readJsonObject(path.join(data, "entwurf", "copilot-mcp", "install-state.json"));
+    if (mcpState === null || mcpState.serverKey !== MCP_SERVER_KEY)
+        return "copilot-mcp-hand-missing";
+    const managedConfigPath = mcpState.managedConfigPath;
+    if (typeof managedConfigPath !== "string" || !path.isAbsolute(managedConfigPath))
+        return "copilot-mcp-hand-missing";
+    const servers = readJsonObject(managedConfigPath)?.mcpServers;
+    if (typeof servers !== "object" || servers === null || Array.isArray(servers))
+        return "copilot-mcp-hand-missing";
+    // The state can be current while the config drifted (hand-edited, restored from a backup,
+    // replaced by another tool). The server key present in the file the CLI actually reads is
+    // the fact the first turn depends on.
+    if (!Object.hasOwn(servers, MCP_SERVER_KEY))
+        return "copilot-mcp-hand-missing";
+    // 3. Receive. The same facts `scripts/copilot-launch.sh` checks — unit name, recorded
+    // path, DEST equality against this env's extensions root, then the entry file.
+    const recvState = readJsonObject(path.join(data, "entwurf", "copilot-receive", "install-state.json"));
+    if (recvState === null || recvState.unit !== RECEIVE_UNIT)
+        return "copilot-receive-unit-missing";
+    const recvPath = recvState.path;
+    if (typeof recvPath !== "string" || !path.isAbsolute(recvPath))
+        return "copilot-receive-unit-missing";
+    // Mirror the launcher's path-mismatch predicate PRE-MUTATION. A state that names a
+    // real unit in a different extensions root than this env will scan still opens a
+    // window today if we only check that the files exist — then `entwurf copilot`
+    // refuses inside it and the caller holds a launch receipt for a dead sibling.
+    const dest = receiveDest(env);
+    if (dest === null || recvPath !== dest)
+        return "copilot-receive-unit-missing";
+    if (!isDir(recvPath) || !existsSync(path.join(recvPath, "extension.mjs")))
+        return "copilot-receive-unit-missing";
+    // 4. Visible identity.
+    if (visibleIdentityMissing(env, data))
+        return "copilot-visible-identity-missing";
+    return null;
+}
+/** Repair text, one line per reason. A reason a caller cannot act on is a reason they will
+ * guess about — each names the exact command that installs the missing capability. */
+export const COPILOT_PREFLIGHT_HINT = {
+    "copilot-birth-unit-missing": "the Copilot BIRTH plugin is not installed here, so the sibling would mint no record and its callback would carry no garden id — run: entwurf install-copilot-bridge",
+    "copilot-mcp-hand-missing": "the entwurf-bridge MCP server is not registered in the Copilot config this host owns, so the callback tool would not exist in that session — run: entwurf install-copilot-mcp",
+    "copilot-receive-unit-missing": "the Copilot RECEIVER extension is not installed here, so the sibling could call home but nothing could ever be delivered to it — run: entwurf install-copilot-receive",
+    "copilot-visible-identity-missing": "Copilot's custom footer is not configured to entwurf's resolvable statusline command (or an install-state manages a different settings file), so the sibling's garden id would be visible nowhere — run: entwurf doctor-copilot-statusline, then entwurf install-copilot-statusline",
+};

package/mcp/entwurf-bridge/dist/pi-extensions/lib/meta-sender-identity.js

@@ -37,8 +37,16 @@
  */
 import { isPlausibleOwnerPid, metaRecordExistsByGardenId, parentPid, readMetaIdentityByGardenId, readMetaSenderMarker, } from "./meta-session.js";
 import { resolveNativePushAdapter } from "./native-push/adapter.js";
-/** Every native backend that mints a garden-id from its own hook and writes a sender marker. */
-export const META_SENDER_BACKENDS = ["claude-code", "antigravity"];
+/** Every native backend that mints a garden-id from its own hook and writes a sender marker.
+ *
+ * WRITER AND READER OPEN TOGETHER OR NOT AT ALL. A backend listed here whose hook writes no
+ * marker costs one wasted directory read; a backend whose hook writes a marker but is absent
+ * here is INVISIBLE — the bridge holds the owner pid, never looks in that directory, and the
+ * citizen's sends are refused as anonymous for a reason nothing in the log names. That was
+ * exactly the #46 defect on agy, and copilot joined the list only once its own hook wrote one
+ * (#82 RAIL 5b). Membership says a marker may EXIST, never that a reply can land: the reply
+ * rail is chosen from `nativePushSupported` at the bridge, not from this list. */
+export const META_SENDER_BACKENDS = ["claude-code", "antigravity", "copilot"];
 /**
  * Two live native sessions claim this MCP process as their own. We can SEE both identities but
  * cannot say which one is calling, so we send under neither. Choosing by lookup order, backend