@junghanacs/entwurf 0.12.4 → 0.12.6

package/CHANGELOG.md

@@ -4,6 +4,42 @@ All notable changes to this project will be documented here. Format follows [Kee
 
 ## Unreleased
 
+## 0.12.6 — 2026-07-03
+
+### Fixed
+
+- **Claude Code meta-bridge live marketplace sources now live outside the checkout for dev and npm installs alike.** Development clones and installed packages both assemble the plugin bundle under `$XDG_DATA_HOME/entwurf/meta-bridge/.assembled`; the checkout or `node_modules` tree is now only the source origin. This removes the class where `pnpm check`, `git clean -xfd`, or a repo-local uninstall smoke could delete a user-scope Claude marketplace source and leave new Claude Code sessions at statusline `?`. The installer still chooses `.ts` vs compiled `.js` hook artifacts by source origin, but the live registration path is the same XDG artifact lane.
+- **Meta-bridge uninstall now uses the recorded live-artifact path and fails before side effects when the state is corrupt.** The install state's `assembledMarketplacePath` is the SSOT for uninstall, doctor, and state checks. Uninstall validates the full `…/entwurf/meta-bridge/.assembled` suffix before removing Claude plugin/MCP registrations or deleting state, so malformed paths such as `/` or `…/entwurf/meta-bridge/not-assembled` fail loud with zero Claude side effects and leave state/artifacts intact. `state.py check` also rejects missing, empty, or malformed recorded paths even when settings agree with the corruption.
+- **User-scope pi package registration is now part of setup.** `./run.sh setup` registers `entwurf` in user-scope pi settings so `--entwurf-control` and the provider surface load from foreign cwd sessions, not only from a project-local `.pi/settings.json`. A hermetic `smoke-user-scope-citizen` covers idempotency, stale normalization, remove symmetry, unrelated-key preservation, and corrupt-shape fail-loud behavior.
+
+### Changed
+
+- **The install toolchain is now aligned to one pnpm 11 lane and one setup surface.** The repo dropped the obsolete `packageManager` pin and `.npmrc`, moved pnpm policy to `pnpm-workspace.yaml`, updated CI to pnpm 11.9, and treats `./run.sh setup` as the single local install path instead of a split `pi install` flow.
+- **The next delivery lane is pinned before implementation.** `NEXT.md` now records the agy/Antigravity delivery adapter constraints: direct-inject/native-push is separate from pi's control-socket liveness domain, registration is explicit, receiver markers are not reused for native-push replyability, and install/doctor/uninstall must inherit the source-origin/live-artifact boundary proven by this release.
+- **The future fresh-spawn lane stays mux-visible by default.** The mux driver plan now keeps minting and mux transport separate, treats tmux/zmx as drivers behind a leaf interface, and keeps fresh pi-native GPT launch visible instead of reviving hidden background one-shots as the default.
+
+### Verification
+
+- `pnpm check` passed on 2026-07-03 after the XDG live-artifact move, recorded-path uninstall hardening, user-scope citizen smoke, pnpm 11 setup cleanup, and NEXT lane updates.
+- `./run.sh smoke-meta-install-state` passed with the new direct install→XDG proof, recorded-path mismatch case, corrupt basename/missing-field fail-loud cases, and checkout-internal `.assembled` boundary fingerprint.
+- `./run.sh doctor-meta-bridge` passed on 2026-07-03 with source/assembled/installed writer parity all v2 and the assembled bundle under `$XDG_DATA_HOME/entwurf/meta-bridge/.assembled`.
+- `./run.sh check-pack-install` passed on 2026-07-03, proving the npm consumer path keeps the stable XDG marketplace source and user-scope pi citizen registration.
+- `LIVE=1 ./run.sh release-gate /tmp/psa-release-gate-0.12.6.ddCcmz` passed on 2026-07-03; log `/tmp/pi-tmux-entwurf-release-gate-0126.log`; summary `MUST: PASS=17 FAIL=0 SKIP=0`, advisory `BEHAVIOR: PASS=0 FAIL=1` (`smoke-resident-garden-guard` positive `/gnew T3` model-in-loop identity turn; non-blocking).
+
+## 0.12.5 — 2026-07-01
+
+### Fixed
+
+- **The plugin hook now runs as compiled JS when installed — the strip-types class is closed for good.** The SessionStart/UserPromptSubmit hook ran as a raw `meta-bridge-hook.ts`. When the marketplace source sits below `node_modules` (a global npm/pnpm install), Claude executes that `.ts` directly and Node refuses strip-types there (`ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`), so every session failed. The hook was the last `.ts`-at-runtime surface; `build-bridge` now emits `dist/pi-extensions/meta-bridge-hook.js` and the installer copies that compiled closure (dev clones still run the `.ts` for transparent editing), mirroring the same installed-vs-dev split `start.sh` (0.12.1) and the store-doctor (0.12.4) already use. `check-pack-install` now runs the installed compiled hook **from under `node_modules` with plain `node`** and proves a raw `.ts` at the same location is refused — the exact fence that broke real hosts is a green regression. The doctor's writer-version parity compares `meta-session.<js|ts>` by install mode so a compiled bundle no longer false-STALEs against the `.ts` source.
+- **Installed meta-bridge paths are now stable across package upgrades.** The installed statusline uses a new `entwurf-statusline` bin shim (matching the existing `entwurf-bridge` MCP shim), and installed meta-bridge marketplace assemblies move out of versioned pnpm store paths into a version-stable operator data directory. Package upgrades still require `entwurf install-meta-bridge` to refresh the Claude plugin bundle/cache, but old-store dead links no longer strand `statusLine` or marketplace source paths. The doctor now also executes the cached SessionStart hook once in an isolated temp agent dir, catching stale plugin-cache / hook-syntax failures before the next real Claude Code session.
+
+### Verification
+
+- Oracle and local review both reproduced the installed hook fence: compiled `meta-bridge-hook.js` runs from under `node_modules` with plain `node`, while the raw `.ts` at the same location fails specifically with `ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`.
+- `./run.sh check-pack` and `./run.sh check-pack-install` passed on 2026-07-01 with the hook-JS tarball requirements, baked `hooks.json` `.js` assertion, and raw-`.ts` fence reproduction.
+- `pnpm check` passed on 2026-07-01 after the hook-JS + stable installed-path changes.
+- `./run.sh install-meta-bridge && ./run.sh doctor-meta-bridge` passed from the development clone after re-materializing the gitignored `.assembled` bundle.
+
 ## 0.12.4 — 2026-07-01
 
 ### Fixed

package/README.md

@@ -80,10 +80,11 @@ A few words that look unusual for a coding tool.
 adapter that hosts the ACP plugin and live control-socket surface, but the base
 install is **not** `pi install npm:...` anymore.
 
-The package exposes two bins:
+The package exposes three bins:
 
 - `entwurf` → `run.sh` (installer, checks, meta-bridge doctor/install)
 - `entwurf-bridge` → the MCP stdio launcher (`mcp/entwurf-bridge/start.sh`)
+- `entwurf-statusline` → the Claude Code statusline renderer (`scripts/meta-bridge-statusline.sh`); a stable bin shim so a package upgrade tracks the current version without rewriting Claude settings
 
 The bridge does not provide Claude credentials, tokens, or subscription access,
 and does not bypass any backend auth. Whatever the operator's local `claude` /
@@ -187,6 +188,13 @@ raw `.ts` helpers under `node_modules`. If the doctor reports
 `ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`, reinstall a current package before
 trusting the floor result.
 
+After upgrading a globally installed package, run `entwurf install-meta-bridge`
+again before trusting native Claude Code sessions. The installed statusline and
+MCP entries use stable bin shims, and the marketplace source uses a version-stable
+operator data dir, but the Claude plugin bundle/cache still has to be
+re-materialized for the new package writer. Existing Claude Code sessions should
+be restarted after reinstall.
+
 For manual configuration, [`pi/settings.reference.json`](./pi/settings.reference.json)
 shows the pi adapter settings shape, and the external-host examples below show
 plain MCP registrations.

package/VERIFY.md

@@ -88,46 +88,36 @@ The goal is not merely "invoke Claude Code." We want:
 
 ## 1. Setup
 
-entwurf supports two install paths; both end in the same runtime state (a valid `.pi/settings.json` with `entwurfProvider.mcpServers` wired) and differ only in who owns the checkout.
+**One install command to remember: `./run.sh setup <project>`.** It is idempotent — re-run the exact same command whenever anything looks wrong. There is no second install surface to juggle: from a clone `setup` runs the whole floor in order.
 
-| Path | Who | Shape |
-|------|-----|-------|
-| **A — Consumer** | end-user of pi | `pi install git:…` + one `run.sh install .` |
-| **B — Developer** | contributor / first user | `git clone …` + `pi install ./` + `run.sh install …` |
-
-### 1.1 Path A — consumer install
+1. `pnpm install` — bundles pi (a dev/peer dependency; no separate `pi install` step) and builds the bridge
+2. project wiring → `<project>/.pi/settings.json` `entwurfProvider.mcpServers.entwurf-bridge`
+3. meta-bridge global plugin — only when a native harness (`claude`) is on PATH; a pi-only host skips it cleanly
+4. `entwurf-bridge` install smoke (`validate_entwurf_bridge`)
 
 ```bash
-pi install git:github.com/junghan0611/entwurf          # pi auto-clones + installs deps
-cd /path/to/consumer-project
-~/.pi/agent/git/github.com/junghan0611/entwurf/run.sh install .   # wire bundled mcpServers
-pi --list-models entwurf                               # curated model surface
-pi --provider entwurf --model claude-sonnet-5 -p "reply with ok only"   # one-turn smoke
+git clone https://github.com/junghan0611/entwurf /path/to/entwurf && cd $_
+./run.sh setup /path/to/consumer-project
+# re-run the SAME command any time to repair a broken install
 ```
 
-Expected: the package appears under pi's `User packages`; `install .` logs `added entwurfProvider.mcpServers.entwurf-bridge` + `updated <project>/.pi/settings.json`; the smoke returns a one-word reply (full bootstrap → ACP session → bridge → clean shutdown). Note: `~/.pi/agent/git/.../entwurf` is pi-managed — do not edit it (a `pi update` overwrites). Step 2 is still required after `pi install git:…`.
+Expected tail: `DONE: entwurf setup (pi package + meta-bridge + v2 install smoke) green.` On a host with `claude`, verify the native wiring with `./run.sh doctor-meta-bridge`.
+
+The wiring / meta-bridge / smoke steps are internal building blocks of `setup` (`install_local_package`, `scripts/meta-bridge-install.sh`, `validate_entwurf_bridge`) — call `setup`, never the parts. Consumers who `npm install @junghanacs/entwurf` get the obvious npm surface; that path is not the developer concern here.
 
-### 1.2 Path B — developer install
+### 1.1 Variables (optional)
 
 ```bash
-git clone https://github.com/junghan0611/entwurf /path/to/entwurf && cd $_
-pnpm install                                   # pnpm is the pinned packageManager
-pi install ./
-./run.sh install /path/to/consumer-project
-pnpm check                                     # full deterministic floor
-pi --provider entwurf --model claude-sonnet-5 -p "reply with ok only"
-LIVE=1 ./run.sh release-gate /path/to/consumer-project
+export REPO_DIR=/path/to/entwurf
+export PROJECT_DIR=/path/to/consumer-project
+cd "$REPO_DIR" && ./run.sh setup "$PROJECT_DIR"
 ```
 
-`install` is idempotent; user-authored `mcpServers.<name>` overrides survive a re-run (`preserved (user override: …)`). `run.sh remove <dir>` deletes only entries whose command matches the repo-authored launcher.
-
-### 1.3 Setup shortcut + variables
+### 1.2 Live acceptance (optional)
 
 ```bash
-export REPO_DIR=...        # Path A: $HOME/.pi/agent/git/github.com/junghan0611/entwurf ; Path B: your clone
-export PROJECT_DIR=/path/to/consumer-project
-export CACHE_DIR=$HOME/.pi/agent/cache/entwurf/sessions
-cd "$REPO_DIR" && ./run.sh setup "$PROJECT_DIR"
+LIVE=1 ./run.sh release-gate /path/to/consumer-project
+pi --provider entwurf --model claude-sonnet-5 -p "reply with ok only"   # one-turn smoke
 ```
 
 `setup` runs `pnpm install` + `install` + meta-bridge (native harness) + the v2 install smoke; a green `setup` implies the settings.json wiring and install surface are healthy. The full live floor is still `LIVE=1 ./run.sh release-gate`.

package/docs/setup-clean-host.md

@@ -4,11 +4,11 @@ End-to-end install of **entwurf** on a host with only `git` available — no
 node, no npm package, no pi binary, no dotfiles. The point is to validate the
 public install surface as an outside user would experience it.
 
-> **Scope.** This is the entwurf 0.12.4 install recipe. The base package install
+> **Scope.** This is the entwurf 0.12.5 install recipe. The base package install
 > is **neutral npm**, not `pi install npm:...`. Pi is an optional adapter lane for
-> the ACP provider / control-socket runtime. The 0.12.4 floor fix is explicitly
+> the ACP provider / control-socket runtime. The 0.12.5 floor fix is explicitly
 > covered here: installed packages under `node_modules` must not run raw `.ts`
-> doctor helpers through Node strip-types.
+> bridge, doctor, or plugin-hook helpers through Node strip-types.
 
 `entwurf` is a garden-citizen dispatch substrate and meta-bridge. It does not
 provide, copy, or mediate backend credentials — it lets the official backend CLI
@@ -31,7 +31,7 @@ ssh cleanhost 'uname -a; whoami; which git node npm pi claude 2>/dev/null'
 |---|---|---|
 | Node | **24** recommended; `>=22.6.0` minimum | `engines.node` (Node strip-types / ESM runtime) |
 | npm | bundled with Node 24 | public package install path |
-| entwurf | `@junghanacs/entwurf` | neutral npm package; exposes `entwurf` and `entwurf-bridge` bins |
+| entwurf | `@junghanacs/entwurf` | neutral npm package; exposes `entwurf`, `entwurf-bridge`, and `entwurf-statusline` bins |
 | pi binary | **optional**, `@earendil-works/pi-coding-agent >=0.80.3 <0.81` | needed only for the pi adapter / ACP provider / spawn-bg resume lane |
 
 ## Stage 0 — Node 24 via nvm
@@ -64,6 +64,7 @@ npm install -g @junghanacs/entwurf
 
 which entwurf
 which entwurf-bridge
+which entwurf-statusline
 entwurf --help | head -5
 ```
 
@@ -77,8 +78,11 @@ Prove the installed MCP server answers `tools/list` from inside `node_modules`.
 This is the first `node_modules` strip-types regression fixed in 0.12.0: Node
 refuses `--experimental-strip-types` for `.ts` under `node_modules`, so the
 installed package must boot the prebuilt JS under `mcp/entwurf-bridge/dist/`.
-The 0.12.4 doctor fix below applies the same installed-vs-dev split to
-`doctor-meta-bridge` helper checks.
+The same installed-vs-dev split then closes the other two `.ts`-at-runtime
+surfaces on that same fence: the `doctor-meta-bridge` store-scan helper (0.12.4)
+and the plugin `SessionStart`/`UserPromptSubmit` hook (0.12.5, runs the compiled
+`dist/pi-extensions/meta-bridge-hook.js` when installed). Installed packages run
+tsc-emitted JS on every one of these; dev clones keep the `.ts` source.
 
 ```bash
 node --input-type=module <<'JS'
@@ -146,17 +150,29 @@ entwurf doctor-meta-bridge
 ```
 
 On an installed package (`.../node_modules/@junghanacs/entwurf`), the doctor must
-not try to strip-types-run raw `.ts` helpers. In the output, check for these two
-0.12.4 floor-regression signals:
+not try to strip-types-run raw `.ts` helpers or hooks. In the output, check for
+these 0.12.5 floor-regression signals:
 
 ```text
+ok    cached SessionStart hook executes cleanly in an isolated temp agent dir
 ok    full store scan: no corrupt records, duplicate nativeSessionId, body/filename drift, or backend↔wakeMode contradiction
 ok    check-entwurf-v2-surface: shipped surface source present; exhaustive source-shape gate is a repo/release invariant (not run under node_modules)
 ```
 
-If either section reports `ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`, the host
-is still running a pre-0.12.4 package or a broken tarball. Reinstall the current
-package and re-run `entwurf install-meta-bridge && entwurf doctor-meta-bridge`.
+If any of those sections reports `ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`,
+the host is still running a pre-0.12.5 package or a broken tarball. Reinstall the
+current package and re-run `entwurf install-meta-bridge && entwurf doctor-meta-bridge`.
+
+Upgrade invariant: every global npm/pnpm package upgrade must be followed by
+`entwurf install-meta-bridge` from that same installed binary and then
+`entwurf doctor-meta-bridge`. Installed statusline/MCP entries use stable bin
+shims and the marketplace source lives in a version-stable operator data dir, but
+package managers still do not re-materialize Claude's plugin bundle/cache. If a
+dev checkout's `./run.sh doctor-meta-bridge` expects repo-owned paths while the
+global install intentionally owns the meta-bridge (or the reverse), that is an
+ownership mismatch — run the doctor from the surface that intentionally owns the
+install, or reinstall from the other surface. Restart already-open Claude Code
+sessions after changing the meta-bridge install.
 
 A plain external MCP host can call tools but is non-replyable. A garden-native
 meta-session has a garden id, a mailbox, and a trusted sender marker; it can call

package/mcp/entwurf-bridge/dist/pi-extensions/meta-bridge-hook.js

@@ -0,0 +1,218 @@
+/**
+ * meta-bridge-hook — the Claude Code native-session entry shell (1.0.0 step 4).
+ *
+ * THE load-bearing hook. Shipped inside a plugin bundle whose `hooks/hooks.json`
+ * wires it to `SessionStart` (and `CwdChanged` / `UserPromptSubmit`). Because a
+ * plugin's hooks load at STARTUP (a bare skill's load only on invocation, after
+ * SessionStart has passed), this fires on every native Claude Code open and makes
+ * that session a garden citizen WITHOUT any pi JSONL of its own:
+ *
+ *   stdin {session_id, transcript_path, cwd}  (Claude hook envelope)
+ *     -> upsertMetaSession(claude-code)        idempotent create/attach the record
+ *        -> gardenId                           the session's garden address
+ *     -> arm watchPath <mailbox>/<gardenId>/inbox.signal   idle-wake doorbell
+ *     -> stdout hookSpecificOutput.watchPaths  (SessionStart / CwdChanged only)
+ *
+ * The record is keyed/looked-up by `native_session_id` (THE authority,
+ * scanByNativeId); the idle-wake mailbox is keyed by GARDEN id — that is the
+ * whole point of the meta-bridge over the raw per-session prototype: one garden
+ * address a sender can target, decoupled from the backend's native id grammar.
+ *
+ * FAILURE POLICY (decided, see NEXT.md step 4): the runtime hook is
+ * BEST-EFFORT + LOG. It never screams into the user's terminal and never blocks
+ * startup — on any error it appends a line to `<pi-agent-dir>/meta-bridge-hook.log`
+ * and emits an empty `{}` (no arm). The fail-LOUD surface is the doctor
+ * (step 5), which reads that log + the meta-record dir to catch a silent miss.
+ *
+ * watchPaths can be emitted only from SessionStart / CwdChanged / FileChanged, so
+ * a UserPromptSubmit fire does a degraded RECORD backfill (upsert) but cannot
+ * re-arm the idle watch — the record's address is restored, the wake is not.
+ *
+ * Run (dev clone): `<node> --experimental-strip-types <plugin-root>/meta-bridge-hook.ts`.
+ * Run (installed):  `<node> <plugin-root>/meta-bridge-hook.js` — the tsc-emitted
+ * closure (build-bridge → dist), because Node REFUSES strip-types on a `.ts` below
+ * node_modules (ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING). The installer picks
+ * the artifact by layout (0.12.5), mirroring start.sh / store-doctor.
+ * Imports `./lib/meta-session.ts` (+ `./lib/session-id.js`); `rewriteRelativeImportExtensions`
+ * rewrites that to `./lib/meta-session.js` in the emitted closure. The installer
+ * copies the lib dir alongside this file so `${CLAUDE_PLUGIN_ROOT}` self-locates it.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { defaultMetaMailboxDir, defaultMetaSessionsDir, upsertMetaSession, writeMetaReceiverMarker, writeMetaSenderMarker, } from "./lib/meta-session.js";
+function logLine(level, message) {
+    try {
+        // dirname(meta-sessions) == the pi agent dir — no extra resolver export needed.
+        const file = path.join(path.dirname(defaultMetaSessionsDir()), "meta-bridge-hook.log");
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.appendFileSync(file, `${new Date().toISOString()} ${level} ${message}\n`);
+    }
+    catch {
+        /* logging is best-effort; a broken log must not break the session */
+    }
+}
+/** Emit a hook response on stdout and exit 0. `{}` means "did nothing, do not block startup". */
+function emit(payload) {
+    process.stdout.write(`${JSON.stringify(payload)}\n`);
+    process.exit(0);
+}
+/**
+ * Map the hook event to a receiver-marker arm provenance. ONLY the genuinely
+ * arm-capable events map; any other (a future/unknown hook event) returns null so we
+ * never mint an "active receiver" presence we cannot back — fail-closed, not an
+ * optimistic session-start. UserPromptSubmit never reaches here (it early-returns
+ * before the arm block).
+ */
+function armProvenanceFor(eventName) {
+    if (eventName === "SessionStart")
+        return "session-start";
+    if (eventName === "CwdChanged")
+        return "cwd-changed";
+    if (eventName === "FileChanged")
+        return "file-changed";
+    return null;
+}
+function main() {
+    let raw;
+    try {
+        raw = fs.readFileSync(0, "utf8"); // fd 0 = stdin (the Claude hook envelope)
+    }
+    catch (err) {
+        logLine("ERROR", `stdin read failed: ${err instanceof Error ? err.message : String(err)}`);
+        emit({});
+    }
+    let env;
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null)
+            throw new Error("envelope is not an object");
+        env = parsed;
+    }
+    catch (err) {
+        logLine("ERROR", `envelope parse failed: ${err instanceof Error ? err.message : String(err)}`);
+        emit({});
+    }
+    const sessionId = typeof env.session_id === "string" ? env.session_id : "";
+    const transcriptPath = typeof env.transcript_path === "string" ? env.transcript_path : "";
+    // cwd: prefer the envelope's, fall back to the process cwd (the hook runs in the session's cwd).
+    const cwd = typeof env.cwd === "string" && env.cwd.length > 0 ? env.cwd : process.cwd();
+    const modelEnvelope = env.model;
+    const model = typeof modelEnvelope === "object" &&
+        modelEnvelope !== null &&
+        typeof modelEnvelope.id === "string"
+        ? modelEnvelope.id
+        : typeof env.model_id === "string"
+            ? env.model_id
+            : undefined;
+    const eventName = typeof env.hook_event_name === "string" ? env.hook_event_name : "SessionStart";
+    if (!sessionId || !transcriptPath) {
+        // A degraded envelope: cannot mint an honest reference record. Log + no-op
+        // rather than write a half-record or guess a transcript path. LEVEL depends
+        // on the event: a degraded SessionStart / CwdChanged means the session FAILED
+        // to become (or refresh) a garden citizen — that is the silent registration
+        // miss the doctor must catch (blocker #2), so ERROR. UserPromptSubmit only
+        // ever does a best-effort record backfill, so a degraded one is just WARN.
+        const degradedLevel = eventName === "UserPromptSubmit" ? "WARN" : "ERROR";
+        logLine(degradedLevel, `degraded envelope (event=${eventName}, session_id=${sessionId ? "set" : "MISSING"}, transcript_path=${transcriptPath ? "set" : "MISSING"})`);
+        emit({});
+    }
+    let gardenId;
+    try {
+        const result = upsertMetaSession({
+            input: { backend: "claude-code", nativeSessionId: sessionId, transcriptPath, cwd, model },
+            onSkip: (filename, e) => logLine("WARN", `scan skipped ${filename}: ${e.message}`),
+        });
+        gardenId = result.record.gardenId;
+        logLine("INFO", `${result.action} record ${path.basename(result.path)} (event=${eventName}, native=${sessionId})`);
+    }
+    catch (err) {
+        // Best-effort: a broken record store must surface via the doctor, not by
+        // breaking the user's session open. Log and continue with no arm. This is
+        // the silent-registration-miss (blocker #2): the session opened fine but is
+        // NOT a garden citizen — the doctor catches it via this ERROR line.
+        logLine("ERROR", `upsert failed (event=${eventName}, native=${sessionId}): ${err instanceof Error ? err.message : String(err)}`);
+        emit({});
+    }
+    // Sender marker, keyed by the shared Claude Code parent pid: the user-scope
+    // MCP child (same parent) reads it at entwurf_v2 send time to promote this
+    // session from anonymous external-mcp to a REPLYABLE meta-session sender —
+    // process ancestry, not cwd inference (same repo + multiple sessions would be
+    // ambiguous). Best-effort: a failed marker only costs reply-addressability
+    // (WARN), it does not break the session or the receiver path.
+    //
+    // SE-1/SE-2 (dual-owner fix): write ONLY for the direct parent (process.ppid =
+    // the Claude CLI that ran this hook, verified the native tree is direct — the
+    // plugin host is not in between). The old code ALSO wrote a marker for the
+    // grandparent. That grandparent is the login shell (e.g. bash under ghostty/i3),
+    // which OUTLIVES the Claude session: when Claude exits, the grandparent marker's
+    // ownerStartKey still matches a live pid, so it passes readMetaSenderMarker's
+    // reuse guard and the dead session keeps looking like a live, replyable receiver
+    // — a false-positive "active receiver" leak. The owner must be the watchPaths
+    // subscriber (the Claude CLI), nothing higher. If a stray topology means the MCP
+    // child's shared ancestor is not process.ppid, that resolves to "no marker"
+    // (fail-closed, honest) rather than a wrong-but-live grandparent identity.
+    const ownerPid = process.ppid;
+    if (typeof ownerPid === "number" && ownerPid > 0) {
+        try {
+            writeMetaSenderMarker({ backend: "claude-code", gardenId, nativeSessionId: sessionId, cwd, ownerPid });
+            logLine("INFO", `sender marker ${ownerPid} -> ${gardenId} (event=${eventName})`);
+        }
+        catch (err) {
+            logLine("WARN", `sender marker write failed (event=${eventName}, pid=${ownerPid}, garden=${gardenId}): ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // watchPaths is emittable only from SessionStart / CwdChanged / FileChanged.
+    // UserPromptSubmit reaches here only to backfill the record above; it must NOT
+    // claim to arm a watch it cannot (decided).
+    if (eventName === "UserPromptSubmit") {
+        emit({});
+    }
+    try {
+        const mailbox = path.join(defaultMetaMailboxDir(), gardenId);
+        fs.mkdirSync(mailbox, { recursive: true });
+        const signal = path.join(mailbox, "inbox.signal");
+        if (!fs.existsSync(signal))
+            fs.writeFileSync(signal, "", { mode: 0o600 });
+        logLine("INFO", `armed watch ${signal}`);
+        // Receiver presence marker (SE-2): written on the arm-capable hook path that
+        // emits watchPaths, keyed by garden id with the watch owner pid (= the Claude
+        // CLI, process.ppid — same single owner as the sender marker, never the
+        // grandparent). It records that a LIVE owner reached the watch-arm emit; it is
+        // not proof the host ack'd the watch registration. This is what lets a sender
+        // tell a live receiver from a terminated one whose record still lingers.
+        // Best-effort: a failed/skipped marker only costs deliverability detection
+        // (WARN), it does not break the arm. An unknown event maps to null provenance →
+        // no marker (fail-closed: never claim an active receiver we cannot back).
+        const ownerPid = process.ppid;
+        const armProvenance = armProvenanceFor(eventName);
+        if (armProvenance === null) {
+            logLine("WARN", `receiver marker skipped — non-arm event ${eventName} (garden=${gardenId})`);
+        }
+        else if (typeof ownerPid === "number" && ownerPid > 0) {
+            try {
+                writeMetaReceiverMarker({
+                    gardenId,
+                    backend: "claude-code",
+                    nativeSessionId: sessionId,
+                    ownerPid,
+                    armProvenance,
+                });
+                logLine("INFO", `receiver marker ${gardenId} owner=${ownerPid} arm=${eventName}`);
+            }
+            catch (err) {
+                logLine("WARN", `receiver marker write failed (event=${eventName}, garden=${gardenId}): ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        emit({
+            hookSpecificOutput: {
+                hookEventName: eventName,
+                watchPaths: [signal],
+            },
+        });
+    }
+    catch (err) {
+        logLine("ERROR", `arm failed (event=${eventName}, garden=${gardenId}): ${err instanceof Error ? err.message : String(err)}`);
+        emit({}); // record landed; only the arm failed — the doctor will flag the missing watch.
+    }
+}
+main();

package/mcp/entwurf-bridge/tsconfig.build.json

@@ -46,5 +46,22 @@
 	// emits here, so it adds ONE leaf JS (dist/scripts/meta-bridge-store-doctor.js)
 	// and ZERO new deps. It is NOT in index.ts's boot closure, so
 	// check-entwurf-bridge-pi-free (which walks the index eager closure) is unaffected.
-	"include": ["./src/index.ts", "../../protocol.js", "../../scripts/meta-bridge-store-doctor.ts"]
+	//
+	// WHY meta-bridge-hook rides THIS build (0.12.5): the SessionStart/UserPromptSubmit
+	// plugin hook ran as raw `.ts` (`node ${CLAUDE_PLUGIN_ROOT}/meta-bridge-hook.ts`).
+	// Under an installed marketplace source below node_modules that is
+	// ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING — the SAME strip-types fence
+	// start.sh (0.12.1) and the store-doctor (0.12.4) already cross by shipping JS.
+	// The hook was the last `.ts`-at-runtime surface; emitting it here closes that
+	// class for good (installer copies the dist JS when installed, keeps `.ts` for a
+	// dev clone). Its only repo import is meta-session.ts, ALREADY emitted for the
+	// store-doctor, so this adds ONE leaf JS (dist/pi-extensions/meta-bridge-hook.js)
+	// and ZERO new deps. It is a plugin hook, never in index.ts's boot closure, so
+	// check-entwurf-bridge-pi-free is unaffected.
+	"include": [
+		"./src/index.ts",
+		"../../protocol.js",
+		"../../scripts/meta-bridge-store-doctor.ts",
+		"../../pi-extensions/meta-bridge-hook.ts"
+	]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@junghanacs/entwurf",
-	"version": "0.12.4",
+	"version": "0.12.6",
 	"description": "Garden-citizen dispatch substrate and meta-bridge for Claude Code, Codex, Antigravity, and pi harnesses.",
 	"license": "MIT",
 	"author": {
@@ -65,7 +65,6 @@
 	"engines": {
 		"node": ">=22.6.0"
 	},
-	"packageManager": "pnpm@10.33.0",
 	"dependencies": {
 		"@agentclientprotocol/claude-agent-acp": "0.54.1",
 		"@agentclientprotocol/sdk": "1.1.0",
@@ -120,7 +119,7 @@
 		"format": "biome check --write .",
 		"check-meta-manifest-schema": "./run.sh check-meta-manifest-schema",
 		"check-package-source-routing": "./run.sh check-package-source-routing",
-		"check": "pnpm lint && pnpm typecheck && ./run.sh check-shell-quote && ./run.sh check-entwurf-session-identity && ./run.sh check-meta-session && ./run.sh check-meta-record-v2 && ./run.sh check-mailbox-receipt-state && ./run.sh check-entwurf-capabilities && ./run.sh check-meta-dual-read && ./run.sh check-meta-mailbox-state-write && ./run.sh check-meta-receiver-marker && ./run.sh check-meta-migration && ./run.sh check-meta-dual-consumers && ./run.sh check-meta-capability-source && ./run.sh check-socket-probe && ./run.sh smoke-meta-honesty && ./run.sh smoke-meta-install-state && ./run.sh smoke-meta-prune && ./run.sh smoke-meta-keyset-guard && ./run.sh check-meta-manifest-schema && ./run.sh check-package-source-routing && ./run.sh check-model-lock && ./run.sh check-dep-versions && ./run.sh check-install-preflight && ./run.sh check-pi-import-surface && ./run.sh check-env-namespace && ./run.sh check-pi-runtime-version && ./run.sh check-pi-preflight && ./run.sh check-project-trust-handler && ./run.sh check-entwurf-v2-contract && ./run.sh check-entwurf-v2-lock && ./run.sh check-entwurf-v2-decider && ./run.sh check-entwurf-v2-matrix && ./run.sh check-entwurf-v2-release && ./run.sh check-entwurf-v2-send && ./run.sh check-entwurf-v2-send-fallback && ./run.sh check-entwurf-v2-mailbox && ./run.sh check-entwurf-v2-runner && ./run.sh check-entwurf-control-rpc && ./run.sh check-entwurf-v2-production && ./run.sh check-entwurf-v2-surface && ./run.sh check-entwurf-bridge-boot && ./run.sh check-entwurf-bridge-pi-free && ./run.sh check-entwurf-v2-spawn && ./run.sh check-entwurf-resume-args && ./run.sh check-entwurf-v2-spawn-production && ./run.sh check-entwurf-facts && ./run.sh check-socket-discovery && ./run.sh check-meta-listing && ./run.sh check-entwurf-fact-provider && ./run.sh check-entwurf-peers-surface && ./run.sh check-entwurf-self-address && ./run.sh check-entwurf-deliverability && ./run.sh check-entwurf-mailbox-guard && ./run.sh check-auth-boundary && ./run.sh check-acp-provider-surface && ./run.sh check-acp-sdk-surface && ./run.sh check-acp-overlay && ./run.sh check-acp-tool-surface && ./run.sh check-acp-event-mapper && ./run.sh check-acp-prompt-builder && ./run.sh check-acp-config && ./run.sh check-acp-session-store && ./run.sh check-acp-backend-preflight && ./run.sh check-acp-session-reuse && ./run.sh check-acp-carrier-augment && ./run.sh check-pack"
+		"check": "pnpm lint && pnpm typecheck && ./run.sh check-shell-quote && ./run.sh check-entwurf-session-identity && ./run.sh check-meta-session && ./run.sh check-meta-record-v2 && ./run.sh check-mailbox-receipt-state && ./run.sh check-entwurf-capabilities && ./run.sh check-meta-dual-read && ./run.sh check-meta-mailbox-state-write && ./run.sh check-meta-receiver-marker && ./run.sh check-meta-migration && ./run.sh check-meta-dual-consumers && ./run.sh check-meta-capability-source && ./run.sh check-socket-probe && ./run.sh smoke-meta-honesty && ./run.sh smoke-meta-install-state && ./run.sh smoke-user-scope-citizen && ./run.sh smoke-meta-prune && ./run.sh smoke-meta-keyset-guard && ./run.sh check-meta-manifest-schema && ./run.sh check-package-source-routing && ./run.sh check-model-lock && ./run.sh check-dep-versions && ./run.sh check-install-preflight && ./run.sh check-pi-import-surface && ./run.sh check-env-namespace && ./run.sh check-pi-runtime-version && ./run.sh check-pi-preflight && ./run.sh check-project-trust-handler && ./run.sh check-entwurf-v2-contract && ./run.sh check-entwurf-v2-lock && ./run.sh check-entwurf-v2-decider && ./run.sh check-entwurf-v2-matrix && ./run.sh check-entwurf-v2-release && ./run.sh check-entwurf-v2-send && ./run.sh check-entwurf-v2-send-fallback && ./run.sh check-entwurf-v2-mailbox && ./run.sh check-entwurf-v2-runner && ./run.sh check-entwurf-control-rpc && ./run.sh check-entwurf-v2-production && ./run.sh check-entwurf-v2-surface && ./run.sh check-entwurf-bridge-boot && ./run.sh check-entwurf-bridge-pi-free && ./run.sh check-entwurf-v2-spawn && ./run.sh check-entwurf-resume-args && ./run.sh check-entwurf-v2-spawn-production && ./run.sh check-entwurf-facts && ./run.sh check-socket-discovery && ./run.sh check-meta-listing && ./run.sh check-entwurf-fact-provider && ./run.sh check-entwurf-peers-surface && ./run.sh check-entwurf-self-address && ./run.sh check-entwurf-deliverability && ./run.sh check-entwurf-mailbox-guard && ./run.sh check-auth-boundary && ./run.sh check-acp-provider-surface && ./run.sh check-acp-sdk-surface && ./run.sh check-acp-overlay && ./run.sh check-acp-tool-surface && ./run.sh check-acp-event-mapper && ./run.sh check-acp-prompt-builder && ./run.sh check-acp-config && ./run.sh check-acp-session-store && ./run.sh check-acp-backend-preflight && ./run.sh check-acp-session-reuse && ./run.sh check-acp-carrier-augment && ./run.sh check-pack"
 	},
 	"pi": {
 		"extensions": [
@@ -132,7 +131,8 @@
 	},
 	"bin": {
 		"entwurf": "./run.sh",
-		"entwurf-bridge": "./mcp/entwurf-bridge/start.sh"
+		"entwurf-bridge": "./mcp/entwurf-bridge/start.sh",
+		"entwurf-statusline": "./scripts/meta-bridge-statusline.sh"
 	},
 	"peerDependenciesMeta": {
 		"@earendil-works/pi-ai": {

package/pi/meta-bridge/entwurf-meta-receive/hooks/hooks.json

@@ -6,7 +6,7 @@
 				"hooks": [
 					{
 						"type": "command",
-						"command": "__NODE_BIN__ ${CLAUDE_PLUGIN_ROOT}/meta-bridge-hook.ts"
+						"command": "__NODE_BIN__ ${CLAUDE_PLUGIN_ROOT}/__HOOK_ENTRY__"
 					}
 				]
 			}
@@ -17,7 +17,7 @@
 				"hooks": [
 					{
 						"type": "command",
-						"command": "__NODE_BIN__ ${CLAUDE_PLUGIN_ROOT}/meta-bridge-hook.ts"
+						"command": "__NODE_BIN__ ${CLAUDE_PLUGIN_ROOT}/__HOOK_ENTRY__"
 					}
 				]
 			}
@@ -28,7 +28,7 @@
 				"hooks": [
 					{
 						"type": "command",
-						"command": "__NODE_BIN__ ${CLAUDE_PLUGIN_ROOT}/meta-bridge-hook.ts"
+						"command": "__NODE_BIN__ ${CLAUDE_PLUGIN_ROOT}/__HOOK_ENTRY__"
 					}
 				]
 			}

package/pi-extensions/meta-bridge-hook.ts

@@ -28,9 +28,14 @@
  * a UserPromptSubmit fire does a degraded RECORD backfill (upsert) but cannot
  * re-arm the idle watch — the record's address is restored, the wake is not.
  *
- * Run: `<node> --experimental-strip-types <plugin-root>/meta-bridge-hook.ts`.
- * Imports `./lib/meta-session.ts` (+ `./lib/session-id.js`); the installer copies
- * that lib dir alongside this file so `${CLAUDE_PLUGIN_ROOT}` self-locates it.
+ * Run (dev clone): `<node> --experimental-strip-types <plugin-root>/meta-bridge-hook.ts`.
+ * Run (installed):  `<node> <plugin-root>/meta-bridge-hook.js` — the tsc-emitted
+ * closure (build-bridge → dist), because Node REFUSES strip-types on a `.ts` below
+ * node_modules (ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING). The installer picks
+ * the artifact by layout (0.12.5), mirroring start.sh / store-doctor.
+ * Imports `./lib/meta-session.ts` (+ `./lib/session-id.js`); `rewriteRelativeImportExtensions`
+ * rewrites that to `./lib/meta-session.js` in the emitted closure. The installer
+ * copies the lib dir alongside this file so `${CLAUDE_PLUGIN_ROOT}` self-locates it.
  */
 
 import * as fs from "node:fs";