@samuelho-dev/coordinator 0.3.0-beta.2 → 0.3.0-beta.4

package/README.md

@@ -6,14 +6,14 @@ Read-only inspection of existing Pi, OMP, Claude Code, Codex CLI and Hermes sess
 
 There are two parts: **one inspector service**, plus **native integrations on each host**. Configuration/Helm values describe desired settings; activation and service startup are explicit commands. Building and artifact generation do not deploy, activate or hot-reload anything. CI/release workflows produce artifacts, not host installations.
 
-The API and standalone CLI use Node >=22.19; no additional runtime is required. Build a stable, reviewed package checkout using pnpm 11.9.0:
+The API and setup CLI require Node >=22.19. Install the version-pinned release:
 
 ```sh
-pnpm install --frozen-lockfile
-pnpm build
-export PACKAGE_ROOT="$PWD"
+npm install --global @samuelho-dev/coordinator@0.3.0-beta.4
 ```
 
+For source development only, use a reviewed checkout with `pnpm install --frozen-lockfile && pnpm build` (pnpm 11.9.0). `coordinator-install --source` deliberately activates that exact local package; never source-link a native package manager's own `node_modules` directory.
+
 The [esbuild build](scripts/build.ts) keeps Pi dependencies external and bundles OMP dependencies to avoid compatibility-loader traversal. Native host APIs stay external; OMP uses [Bun's native CommonJS support](https://bun.com/docs/runtime/module-resolution#module-systems), not an injected shim. Rebuild and restart OMP after source updates.
 
 For Kubernetes, follow the [chart operator guide](deploy/helm/coordinator/README.md): provide an existing Secret, verified image digest and matching source SHA. The chart creates an inspector Deployment/internal Service, not native plugins, TLS routing, a database or runners. Operators own rollout and supervision. Existing broker state requires the guide's preservation/migration procedure; the plugin does not migrate or delete it.
@@ -24,51 +24,36 @@ For Kubernetes, follow the [chart operator guide](deploy/helm/coordinator/README
 
 Provision owner-scoped bearer keys. The server stores SHA-256 hashes, not raw tokens; every principal contains only `id`, `owner` and `tokenHash`. A key authorizes reads and publishing across that owner's fleet, not one physical device. Same-owner keys can announce multiple installations; installation IDs are labels, not device authentication. Anyone holding an owner key can publish under any of that owner's machine labels. Revoking a shared key revokes every holder; there is no separate read-only or health-token role.
 
-Generate a key in a **new** private directory from the installed package checkout; this prints only its hash:
+Bootstrap a new API with one owner key:
 
 ```sh
-export PRIVATE="$HOME/.config/coordinator-inspector-private"
-(
-  set -eu
-  cd "$PACKAGE_ROOT"
-  node --input-type=module <<'JS'
-import { Config, Console, Crypto, Effect, FileSystem } from 'effect';
-import { Hex } from 'effect/encoding';
-import { NodeRuntime, NodeServices } from '@effect/platform-node';
-NodeRuntime.runMain(Effect.gen(function* () {
-  const fs = yield* FileSystem.FileSystem;
-  const crypto = yield* Crypto.Crypto;
-  const directory = yield* Config.String('PRIVATE');
-  yield* fs.makeDirectory(directory, { mode: 0o700 });
-  yield* fs.chmod(directory, 0o700);
-  const token = Hex.encode(yield* crypto.randomBytes(32));
-  const file = `${directory}/owner.token`;
-  yield* fs.writeFileString(file, token, { mode: 0o600, flag: 'wx' });
-  yield* fs.chmod(file, 0o600);
-  yield* Console.log(Hex.encode(yield* crypto.digest('SHA-256', new TextEncoder().encode(token))));
-}).pipe(Effect.provide(NodeServices.layer)));
-JS
-)
+PRIVATE="${XDG_CONFIG_HOME:-$HOME/.config}/coordinator/server"
+coordinator init --directory "$PRIVATE" --owner operator
+COORDINATOR_CONFIG="$PRIVATE/server.json" coordinator inspector
 ```
 
-Create `server.json` as **0600** in that **0700** directory, substituting the hash:
+`init` generates a random 32-byte bearer in `owner.token` and its SHA-256 principal in `server.json`, with directory0700/files0600. It prints paths and the start command, never the bearer. Existing files, unsafe ownership/permissions and symlinks are rejected; partial writes are removed. Defaults are loopback `127.0.0.1:8787`; `--listen-host` and `--port` select another bind address. No database is required.
 
-```json
-{
-  "host": "127.0.0.1", "port": 8787,
-  "principals": [{ "id": "operator-key", "owner": "operator", "tokenHash": "REPLACE_WITH_TOKEN_SHA256" }]
-}
+Run the API under your normal process supervisor. Remote clients require operator-provided HTTPS with ordinary certificate verification; only loopback permits HTTP. For Kubernetes, bootstrap with `--listen-host 0.0.0.0`, provision the existing Secret from `server.json` and `owner.token` as described in the chart guide, and deploy the verified image/chart. Do not publish the token or expose an unauthenticated HTTP service.
+
+`COORDINATOR_CONFIG` selects server configuration, not client credentials. Initialization does not start a service, provision TLS or replace an existing server configuration.
+
+### Native-owner/client setup
+
+Configure a native client interactively:
+
+```sh
+coordinator connect
 ```
 
-Start a local inspector in the foreground:
+This prompts for the endpoint and a masked owner credential, performs an authenticated API read, and only then saves the private client configuration. It does not create machine identity or change native settings. For private-file provisioning:
 
 ```sh
-COORDINATOR_CONFIG="$PRIVATE/server.json" node dist/src/main.js inspector
+coordinator connect --endpoint https://inspector.example.net --token-file /absolute/private/owner.token
 ```
 
-`COORDINATOR_CONFIG` selects server configuration, not client credentials. Authentication is mandatory: no anonymous fallback. HTTPS with ordinary certificate verification is required except on loopback.
+`--config` chooses a new client file; otherwise the shared default location below is used. Existing files are never overwritten. `COORDINATOR_API_TOKEN` may supply the credential instead of the prompt, but credentials are never accepted as argv. Environment URL/token overrides still take precedence after setup.
 
-### Native-owner/client setup
 
 Clients need only `inspectorUrl` and `apiToken`, supplied through private JSON or `COORDINATOR_API_URL` / `COORDINATOR_API_TOKEN`. The environment overrides corresponding file fields. Have the native owner's secret manager inject the token into the environment of the native host, reader bridge and separately supervised connector; never put raw keys in Git, argv, generated native MCP configuration or logs:
 
@@ -97,8 +82,9 @@ Run as the nonroot native user with the endpoint and credentials provisioned as
 
 ```sh
 TARGET=omp
-pnpm install:host --target "$TARGET" --destination "$PRIVATE/$TARGET-host" --dry-run
-pnpm install:host --target "$TARGET" --destination "$PRIVATE/$TARGET-host"
+PRIVATE="${XDG_CONFIG_HOME:-$HOME/.config}/coordinator"
+coordinator-install --target "$TARGET" --destination "$PRIVATE/$TARGET-host" --dry-run
+coordinator-install --target "$TARGET" --destination "$PRIVATE/$TARGET-host"
 ```
 
 `--config "$PRIVATE/inspector.json"` is optional. An explicit flag or `COORDINATOR_CONNECTOR_CONFIG` selection is retained as a literal private-file pointer, never the raw token. Without either, clients look up `$XDG_CONFIG_HOME/coordinator/inspector.json` or `~/.config/coordinator/inspector.json` at runtime; the installer does not freeze that file's current endpoint into launchers or hooks. File-backed endpoint/credential changes take effect after ordinary process restart. Keep the same configuration environment available to the native host, hooks and separately supervised connector:
@@ -114,13 +100,13 @@ The installer validates prerequisites and creates launchers/config fragments. `-
 
 | Target | Activation | Presence publisher |
 | --- | --- | --- |
-| OMP | `omp plugin link "$PACKAGE_ROOT"`; merge only the generated `mcp.json` coordinator entry into native MCP settings. | In-session extension. |
-| Pi | `pi install "$PACKAGE_ROOT"`; directly registers `coordinator_session_list` / `coordinator_session_inspect`, without an MCP bridge. | In-session extension. |
+| OMP | `omp plugin install @samuelho-dev/coordinator@0.3.0-beta.4`; merge only the generated `mcp.json` coordinator entry into native MCP settings. `/coordinator list` needs no MCP registration. | In-session extension. |
+| Pi | `pi install npm:@samuelho-dev/coordinator@0.3.0-beta.4`; directly registers `coordinator_session_list` / `coordinator_session_inspect`, without an MCP bridge. | In-session extension. |
 | Claude Code | `claude --plugin-dir "$PRIVATE/claude-host"`; approve generated hooks/MCP tools; preserve existing status-line configuration. | Separate `connector.sh`. |
 | Codex CLI | Merge generated `hooks/hooks.json` and coordinator `mcp.toml`; trust only Coordinator's handlers in native `/hooks`. | Separate `connector.sh`. |
 | Hermes | Merge generated hook entries and `mcp_servers.coordinator` from `mcp.yaml` into the selected profile; no Python plugin installation. | Separate `connector.sh`. |
 
-Generated directories contain configuration, not a copy of the package. Pi/OMP load `dist/plugins/{pi,omp}.js`; MCP/connector launchers reference the build's absolute paths. Keep that package available. Updates require a reviewed build/relink, deliberate native reload/new session, and restart of affected reader bridges/external connectors—not merely editing configuration. Environment or config-token changes require process reload; private token files are reread for rotation/recovery. Staged server Secret changes require a controlled inspector restart.
+Generated directories contain configuration, not a package copy. Launchers reference the installed package's absolute paths, so keep that package available. Updates use explicit native package installs, followed by deliberate native reload/new sessions and restart of affected reader bridges/external connectors. Already-open sessions retain loaded code. Updating configuration alone does not update the plugin. Private token files are reread for rotation/recovery; environment or config-token changes require process reload. Staged server Secret changes require a controlled inspector restart.
 
 `mcp.sh` is the stdio reader bridge; `connector.sh` publishes external hook metadata. The latter's equivalent foreground command is:
 
@@ -130,6 +116,16 @@ COORDINATOR_CONNECTOR_CONFIG="$PRIVATE/inspector.json" node dist/src/main.js con
 
 Hook/status-line/notification capture is local and can initialize identity/cache on first use while offline, without a token; it is not an offline delivery queue. Network publishing still needs credentials and a running publisher. Metadata cache is bounded to 1024 observations and 64 KiB per file, normally expires after 120 s, and may retain Hermes observations while the attributed host remains live. No transcripts are collected.
 
+### Native session commands and Rex
+
+Pi/OMP register `/coordinator list`. It follows every API page visible to the owner key and returns pretty JSON (`{ "sessions": [...] }`) using Effect's JSON formatter, with native JSON syntax highlighting in the terminal. Each session preserves full native session/agent IDs, machine names/installation IDs, harness and all reported metadata: model/provider, workspace, activity, connection liveness, process identity and Rex association. Missing metadata is omitted; an empty listing returns `{ "sessions": [] }`. It reads the API directly, with no model turn, per-session resource sampling or separate MCP registration.
+
+Session JSON is Coordinator's fleet model, not an OSC wire payload. `rex` preserves `REX_SERVER` as `serverAddress` and the actual full `REX_SESSION`/`REX_BLOCK` IDs; these are separate from native agent IDs. Optional `programStatus` uses [Rex Program Status Protocol](https://www.superlogical.com/rex/docs/build/program-status) semantics: idle/working/done/error, or blocked with permission/question/auth kind. Agent `kind` remains separate. Tool/API waits are working; unknown outcomes are omitted, not inferred from disconnects or generic stops. API connection leases do not expire terminal status records.
+
+Stock OMP 18.12.6 already owns OSC7501 through `terminal.programStatus`; Coordinator does not duplicate, override or patch that reporter. Pi's terminal-only adapter uses a private scoped record, full replacements and change-only reporting; no controls are written to RPC/JSON/print output. Pi user prompts are blocked/question; completion waits for native final settlement, not an intermediate loop end. Claude hooks supply explicit permission/question/completion/failure states; unavailable native UI-only reasons are not guessed. Prompt/error text is never copied into status reports.
+
+Deploy the matching API **before** upgrading clients. Strict schemas reject new fields on older APIs, and older readers cannot decode new presence fields. Coordinate native reloads; preserve existing credentials and installation identity.
+
 ## Coordinated migration
 
 This is a clean schema cutover, with no legacy aliases or compatibility shims. Before a separately approved rollout, coordinate the server and all native owners: provision fresh owner keys privately, replace server principals with `{ id, owner, tokenHash }`, update the chart's `health.token` to match an owner key, and replace client files with endpoint/credential fields only. Remove manual `machineId`/`stateDirectory` settings, regenerate affected installer artifacts, then deliberately restart the inspector and affected native hosts/bridges/connectors. Preserve the automatically created local identity on subsequent upgrades. Old server/client configuration is rejected; do not mix releases expecting the old machine-bound schema. These instructions do not perform a live rollout or rotate live keys.
@@ -137,17 +133,23 @@ This is a clean schema cutover, with no legacy aliases or compatibility shims. B
 
 ## Plugin publication
 
-The npm candidate is `@samuelho-dev/coordinator@0.3.0-beta.2`; publication requires the exact-source CI-accepted tarball and owner authorization. The [npm workflow](.github/workflows/npm-release.yaml) promotes that accepted artifact; [first-publication authentication and trust setup](#first-npm-publication) remain operator prerequisites. The existing [release workflow](.github/workflows/release.yaml) publishes server/chart/GitHub artifacts, not native marketplace listings. Generated per-machine configuration is not a portable marketplace package.
+The version-pinned beta is `@samuelho-dev/coordinator@0.3.0-beta.4`. The [npm workflow](.github/workflows/npm-release.yaml) promotes the exact-source CI-accepted tarball with owner authorization; [first-publication authentication and trust setup](#first-npm-publication) are prerequisites for a new publisher. The existing [release workflow](.github/workflows/release.yaml) publishes server/chart/GitHub artifacts, not native marketplace listings. Generated per-machine configuration is not a portable marketplace package.
 
-Once published, use your native package manager, then follow [configuration](#configuration) and [native host setup](#native-host-setup):
+For a version-pinned install, use your native package manager, then follow [configuration](#configuration) and [native host setup](#native-host-setup):
 
 ```sh
-omp plugin install @samuelho-dev/coordinator@0.3.0-beta.2
-pi install npm:@samuelho-dev/coordinator@0.3.0-beta.2
+omp plugin install @samuelho-dev/coordinator@0.3.0-beta.4
+pi install npm:@samuelho-dev/coordinator@0.3.0-beta.4
 ```
 
+Stock OMP 18.12.6 does not automatically update npm plugins. Until upstream fixes its channel handling and dry-run behavior, use explicit versioned installs for updates; avoid `omp plugin upgrade` and `upgrade --dry-run` for beta releases.
+
 `0.3.0-beta.2` fixes clean-install startup failures by pinning `effect`, `@effect/platform-node` and `@effect/platform-node-shared` together at 4.0.3 in the published dependencies. Checkout-only pnpm overrides do not constrain npm/OMP consumers; leaving the shared package floating can select an incompatible release (`effect/Path` missing `make`). Keep these three pins aligned when upgrading.
 
+`0.3.0-beta.3` adds native `/coordinator list`, secure self-host bootstrap/authenticated client setup, and Rex references/status normalization without an OMP fork. Runtime dependency pins are unchanged.
+
+`0.3.0-beta.4` fixes `/coordinator list` output: Effect-formatted, indented JSON with native syntax highlighting instead of hand-built text and literal fences. Native UI imports are static and selected at build time; the renderer registers once at startup. The session wire format and runtime dependencies are unchanged, so the existing beta.3 API needs no redeployment.
+
 | Host | Publication route |
 | --- | --- |
 | [OMP](https://github.com/can1357/oh-my-pi/blob/main/docs/marketplace.md) | Publish a Git-backed `.omp-plugin/marketplace.json` catalog and runnable plugin tree with `package.json` `omp.extensions`. Claude-compatible `.claude-plugin/marketplace.json` is a fallback. npm catalog sources are not supported; ordinary `omp plugin install PACKAGE` is a separate npm route. |
@@ -178,7 +180,7 @@ Release gaps and constraints:
 - **Startup:** generated integrations do not await the inspector during activation. Pi/OMP publish in the background; Claude/Codex/Hermes hooks capture locally; the local stdio bridge initializes and lists tools without a remote handshake. Explicit inspection/`coordinate` requests may await a bounded remote reply. Local configuration, filesystem and native loading still run during initialization.
 - **State/lifetime:** the owner-isolated registry is in memory; restart loses discovery until reannouncement, never native sessions. A Pi/OMP plugin owns one Effect managed runtime; presence/poll failures cancel their peer and shutdown disposes its fibers without killing the host. Closing the stdio reader's stdin ends its scope and cancels pending HTTP reads. Failed startup/terminated connectors can restart on a later native event.
 - **Effect composition:** `NodeServices.layer` provides filesystem/path/crypto/process/stdio services; `Host.layer` provides host facts. `Mcp.layer` privately supplies its HTTP client. The CLI scope owns the inspector/server; one Pi/OMP `ManagedRuntime` owns plugin fibers/layers through shutdown. CLI-only stdin closes on completion; plugin stdin remains host-owned. Layer construction, provisioning and sharing follow the [v4 layer contract](https://effect.website/docs/v4/api/effect/Layer).
-- **Node bindings:** [`platform.ts`](src/platform.ts) confines native host facts and CLI-owned stdin alongside the server factory required by [`NodeHttpServer.layerServer`](https://effect.website/docs/v4/api/platform-node/NodeHttpServer#layerServer) and constant-time comparison absent from [`Crypto`](https://effect.website/docs/v4/api/effect/Crypto#Crypto-interface). Filesystem checks use `FileSystem`; execute permission uses Effect's scoped process service running `/bin/test -x`, never the selected runtime. Native SDK callbacks remain foreign interop boundaries.
+- **Node bindings:** [`platform.ts`](src/platform.ts) confines host facts, CLI-owned stdin, server composition and constant-time digest comparison. Runtime private readers use Effect `FileSystem`; setup's exclusive private-file transaction uses Node opened descriptors and no-follow flags. Native SDK callbacks remain foreign interop boundaries.
 - **OMP shortcut:** a leading `coordinate` enriches the current input with fleet presence and an inspection cue. It does not contact other sessions with prompts.
 
 | Timing/bound | Value |
@@ -208,6 +210,8 @@ CPU/RSS sampling runs only on inspection, over approximately 200 ms. PID plus OS
 | [mcp.ts](src/mcp.ts) | `Mcp` service: bounded HTTP/MCP transport and stdio reader. |
 | [native.ts](src/native.ts) | Private files/cache, native projections and connector policy. |
 | [plugin.ts](src/plugin.ts) | Pi/OMP hooks, observers, tools and runtime ownership. |
+| [rex.ts](src/rex.ts) | Native Rex environment association and Pi-only scoped OSC reporting. |
+| [setup.ts](src/setup.ts) | Private self-host initialization, masked client prompts and authenticated configuration creation. |
 | [resources.ts](src/resources.ts) | Linux/macOS process identity and on-demand sampling. |
 | [platform.ts](src/platform.ts) | Effect Node platform composition, scoped CLI stdin, and host/crypto/executable bindings. |
 | [main.ts](src/main.ts) | CLI entrypoints and layer composition. |

package/THIRD_PARTY_NOTICES.md

@@ -17,10 +17,12 @@ The implemented inspector cutover changes the shipped runtime, not the completen
 
 The current Dockerfile does **not** download/copy standalone OMP or collect OMP notices into `/usr/local/share/coordinator/third-party/`; it adds no PostgreSQL client/backup tooling or application database. `tsx`, `undici` and `ws` are no longer direct runtime dependencies. Their absence from the direct manifest is not proof of absence from every transitive package or base-image byte. No Pi/OMP/native binary closure is asserted to be shipped by the current inspector image.
 
-## npm plugin bundle notices — candidate 0.3.0-beta.2
+## npm plugin bundle notices — candidate 0.3.0-beta.3
 
 The OMP extension embeds runtime dependencies to support its native compatibility loader; Pi keeps those dependencies external. Native Pi/OMP SDK implementations are not part of this inventory. The entries below were traced in the existing emitted OMP artifact and matching package distributions. Reconcile them against the newly built, accepted tarball before publication; this source review is not a completed image, history, or legal certification.
 
+`0.3.0-beta.3` keeps the `0.3.0-beta.2` runtime dependency pins; bootstrap uses Node built-ins and the already-declared Effect CLI. No native host binary or SDK implementation is added to the published package.
+
 | Embedded component | Version | Matching notice source |
 | --- | --- | --- |
 | `effect`, `@effect/platform-node`, `@effect/platform-node-shared` | 4.0.3 | Matching installed `LICENSE` files; [Effect package](https://registry.npmjs.org/effect/4.0.3) |

package/dist/plugins/omp.js

@@ -39214,6 +39214,13 @@ var ProcessIdentity = Schema_exports.Struct({
   ownership: Schema_exports.Literals(["owned", "shared", "unknown"])
 });
 var NativeWorkState = Schema_exports.Struct({ id: Id, state: Schema_exports.Literals(["pending", "active", "completed", "cancelled", "unknown"]) });
+var RexText = Schema_exports.String.check(Schema_exports.isMinLength(1), Schema_exports.isMaxLength(4096), Schema_exports.makeFilter(
+  (value5) => /[\u0000-\u001f\u007f-\u009f]/u.test(value5) ? "Control characters are forbidden" : void 0
+));
+var ProgramStatus = Schema_exports.Union([
+  Schema_exports.Struct({ state: Schema_exports.Literals(["idle", "working", "done", "error"]) }),
+  Schema_exports.Struct({ state: Schema_exports.Literal("blocked"), kind: Schema_exports.Literals(["permission", "question", "auth"]) })
+]);
 var SessionPresence = Schema_exports.Struct({
   ref: SessionRef,
   observedAt: Timestamp,
@@ -39234,7 +39241,8 @@ var SessionPresence = Schema_exports.Struct({
   agent: Schema_exports.optional(Id),
   cwd: Schema_exports.optional(Path3),
   repository: Schema_exports.optional(Path3),
-  rex: Schema_exports.optional(Schema_exports.Struct({ serverId: Schema_exports.optional(Id), blockId: Schema_exports.optional(Id), sessionId: Schema_exports.optional(Id), windowId: Schema_exports.optional(Id), paneId: Schema_exports.optional(Id), terminalId: Schema_exports.optional(Id) })),
+  rex: Schema_exports.optional(Schema_exports.Struct({ serverAddress: Schema_exports.optional(RexText), blockId: Schema_exports.optional(RexText), sessionId: Schema_exports.optional(RexText) })),
+  programStatus: Schema_exports.optional(ProgramStatus),
   processes: Schema_exports.optional(bounded3(ProcessIdentity, 128)),
   activity: Schema_exports.optional(Schema_exports.Struct({
     state: Schema_exports.Literals(["idle", "working", "waiting", "stopped", "unknown"]),
@@ -72016,6 +72024,40 @@ var observeResources = (roots) => Effect_exports.gen(function* () {
   };
 });
 
+// src/rex.ts
+import { randomUUID } from "node:crypto";
+var readRexContext = Effect_exports.gen(function* () {
+  const serverAddress = yield* Config_exports.String("REX_SERVER").pipe(Config_exports.withDefault(""));
+  const sessionId = yield* Config_exports.String("REX_SESSION").pipe(Config_exports.withDefault(""));
+  const blockId = yield* Config_exports.String("REX_BLOCK").pipe(Config_exports.withDefault(""));
+  return serverAddress || sessionId || blockId ? {
+    ...serverAddress ? { serverAddress } : {},
+    ...sessionId ? { sessionId } : {},
+    ...blockId ? { blockId } : {}
+  } : void 0;
+});
+var rexSequence = (id2, status) => {
+  if (id2.length > 128 || id2.split("/").length > 8 || !/^[A-Za-z0-9_.+-]{1,32}(?:\/[A-Za-z0-9_.+-]{1,32})*$/u.test(id2)) return "";
+  return `\x1B]7501;id=${id2}:state=${status?.state ?? "clear"}:app=coordinator:title=Q29vcmRpbmF0b3I=${status?.state === "blocked" ? `:kind=${status.kind}` : ""}\x1B\\`;
+};
+var createRexReporter = (write2) => {
+  const id2 = `coordinator/${randomUUID().replaceAll("-", "")}`;
+  let previous;
+  return {
+    update: (status, terminal) => {
+      if (!terminal) return;
+      const sequence = rexSequence(id2, status);
+      if (previous === sequence || previous === void 0 && status === void 0) return;
+      write2(sequence);
+      previous = sequence;
+    },
+    close: (terminal) => {
+      if (terminal && previous !== void 0 && !/:state=(?:done|error):/u.test(previous)) write2(rexSequence(id2, void 0));
+      previous = void 0;
+    }
+  };
+};
+
 // src/native.ts
 var NativeError = class extends Data_exports.TaggedError("NativeError") {
 };
@@ -72285,6 +72327,8 @@ var Cache = Schema_exports.Struct({ version: Schema_exports.Literal(2), kind: Sc
 var ClaudeRoster = Schema_exports.Array(Schema_exports.Struct({ sessionId: Schema_exports.optional(Id2), id: Schema_exports.optional(Id2), pid: Schema_exports.optional(Schema_exports.Int), cwd: Schema_exports.optional(Schema_exports.String), kind: Schema_exports.optional(Id2), status: Schema_exports.optional(Schema_exports.Literals(["busy", "waiting", "idle"])), waitingFor: Schema_exports.optional(Schema_exports.String) })).check(Schema_exports.isMaxLength(256));
 
 // src/plugin.ts
+import { highlightCode } from "@oh-my-pi/pi-coding-agent";
+import { Text } from "@oh-my-pi/pi-tui";
 var provenance = (source, scope3, scopeDescription, observedAt, nativeUpdatedAt = null) => ({
   source,
   scope: scope3,
@@ -72300,8 +72344,10 @@ var provenance = (source, scope3, scopeDescription, observedAt, nativeUpdatedAt
 var createNativeObserver = (harness, machineId, processes = []) => Effect_exports.gen(function* () {
   const host = yield* Host2;
   const clock = yield* Clock_exports.Clock;
-  const rexSession = yield* Config_exports.String("REX_SESSION").pipe(Config_exports.withDefault(""));
-  const rexBlock = yield* Config_exports.String("REX_BLOCK").pipe(Config_exports.withDefault(""));
+  const rex = yield* readRexContext;
+  let programStatus;
+  let userPrompt;
+  let stopReason;
   let current;
   let identity2;
   let lastActivityAt;
@@ -72313,6 +72359,9 @@ var createNativeObserver = (harness, machineId, processes = []) => Effect_export
     const key = JSON.stringify([ctx.sessionManager.getSessionId(), harness === "omp" ? ctx.agent?.id : void 0]);
     if (identity2 !== key) {
       latest = void 0;
+      programStatus = void 0;
+      userPrompt = void 0;
+      stopReason = void 0;
       activeTools.clear();
       identity2 = key;
     }
@@ -72321,6 +72370,24 @@ var createNativeObserver = (harness, machineId, processes = []) => Effect_export
     if (event?.type === "tool_execution_start" && event.toolCallId && event.toolName) activeTools.set(event.toolCallId, event.toolName);
     if (event?.type === "tool_execution_end" && event.toolCallId) activeTools.delete(event.toolCallId);
     if (event?.type === "agent_end") activeTools.clear();
+    if (event?.type === "agent_start") {
+      programStatus = { state: "working" };
+      stopReason = void 0;
+    }
+    if (event?.type === "turn_start") {
+      programStatus = { state: "working" };
+      stopReason = void 0;
+    }
+    if (event?.type === "tool_execution_start") programStatus = { state: "working" };
+    if (event?.message?.role === "assistant" && event.message.stopReason) stopReason = event.message.stopReason;
+    if (event?.type === "agent_end") stopReason = event.messages?.findLast((message2) => message2.role === "assistant")?.stopReason ?? stopReason;
+    if (harness === "pi" && event?.type === "agent_before_settle") stopReason = event.outcome === "completed" ? "stop" : event.outcome;
+    if (event?.type === "agent_settled" || harness !== "pi" && event?.type === "agent_end") {
+      programStatus = event.willContinue ? { state: "working" } : stopReason === "aborted" ? { state: "idle" } : stopReason === "error" ? { state: "error" } : stopReason === "stop" || stopReason === "length" ? { state: "done" } : void 0;
+    } else if (event?.type === "agent_end") programStatus = { state: "working" };
+    if (harness === "pi" && event?.type === "ui_prompt_start") userPrompt = { state: "blocked", kind: "question" };
+    if (harness === "pi" && event?.type === "ui_prompt_end") userPrompt = void 0;
+    if ((event === void 0 || event.type === "session_start" || event.type === "session_switch") && programStatus === void 0) programStatus = { state: ctx.isIdle() ? "idle" : "working" };
     const message = event?.message;
     if (message?.role === "assistant" && message.usage) {
       const u = message.usage;
@@ -72340,6 +72407,7 @@ var createNativeObserver = (harness, machineId, processes = []) => Effect_export
   const presence = (now2 = clock.currentTimeMillisUnsafe()) => {
     if (!current) return void 0;
     const currentToolName = activeTools.values().next().value;
+    const status = userPrompt ?? programStatus;
     return {
       ref: { machineId, harness, nativeSessionId: current.sessionManager.getSessionId(), ...harness === "omp" && current.agent?.id ? { nativeAgentId: current.agent.id } : {} },
       observedAt: now2,
@@ -72348,13 +72416,15 @@ var createNativeObserver = (harness, machineId, processes = []) => Effect_export
       processes,
       machineName,
       ...os ? { os } : {},
-      ...rexSession || rexBlock ? { rex: { ...rexSession ? { sessionId: rexSession } : {}, ...rexBlock ? { blockId: rexBlock } : {} } } : {},
+      ...rex ? { rex } : {},
+      ...status ? { programStatus: status } : {},
       ...current.model ? { provider: current.model.provider, model: current.model.id } : {},
       ...current.agent ? { kind: current.agent.kind, ...current.agent.name ? { agent: current.agent.name } : {} } : {},
       activity: {
-        state: current.isIdle() ? "idle" : "working",
+        state: userPrompt ? "waiting" : current.isIdle() ? "idle" : "working",
         streaming: !current.isIdle(),
-        ...currentToolName === void 0 ? {} : { currentToolName, wait: "tool" }
+        ...currentToolName === void 0 ? {} : { currentToolName },
+        ...userPrompt ? { wait: "user" } : currentToolName === void 0 ? {} : { wait: "tool" }
       }
     };
   };
@@ -72458,6 +72528,9 @@ var createNativeObserver = (harness, machineId, processes = []) => Effect_export
     current = void 0;
     identity2 = void 0;
     latest = void 0;
+    programStatus = void 0;
+    userPrompt = void 0;
+    stopReason = void 0;
     lastActivityAt = void 0;
     activeTools.clear();
   } };
@@ -72486,6 +72559,53 @@ function plugin(host) {
   let observer;
   let starting;
   let stopped = false;
+  const rexReporter = harness === "pi" ? createRexReporter((sequence) => process.stdout.write(sequence)) : void 0;
+  let terminal = false;
+  host.registerMessageRenderer("coordinator-list", (message) => {
+    if (typeof message.content !== "string") return void 0;
+    return new Text(message.details === void 0 ? message.content : highlightCode(message.content, "json").join("\n"), 0, 0);
+  });
+  host.registerCommand("coordinator", {
+    description: "List visible sessions, their machines, and native metadata",
+    handler: async (args2) => {
+      if (args2.trim() !== "list") {
+        host.sendMessage({ customType: "coordinator-list", content: "Usage: /coordinator list", display: true }, { triggerTurn: false });
+        return;
+      }
+      const exit3 = await runtime2.runPromiseExit(Effect_exports.gen(function* () {
+        const activeConfig = config2 ?? (yield* loadConnectorConfig());
+        if (!activeConfig) return yield* new NativeError({ operation: "Connector configuration required" });
+        const token = yield* readConnectorToken(activeConfig);
+        const mcp = yield* Mcp;
+        const sessions = [];
+        let cursor;
+        do {
+          const page = yield* mcp.call(activeConfig.inspectorUrl, token, InspectionTools.list, { limit: 100, ...cursor === void 0 ? {} : { cursor } });
+          for (const session of page.sessions) sessions.push(session);
+          cursor = page.nextCursor ?? void 0;
+        } while (cursor !== void 0);
+        return sessions;
+      }));
+      if (stopped) return;
+      if (exit3._tag === "Failure") {
+        const error3 = Cause_exports.findErrorOption(exit3.cause);
+        const reason = error3._tag === "Some" ? error3.value._tag === "HttpError" ? `HTTP ${error3.value.status}` : error3.value._tag : "unexpected failure";
+        host.sendMessage({
+          customType: "coordinator-list",
+          content: `Coordinator list unavailable (${reason}). Check inspectorUrl, your access token, and API reachability.`,
+          display: true
+        }, { triggerTurn: false });
+        return;
+      }
+      const result5 = { sessions: exit3.value };
+      host.sendMessage({
+        customType: "coordinator-list",
+        content: Formatter_exports.formatJson(result5, { space: 2 }),
+        display: true,
+        details: result5
+      }, { triggerTurn: false });
+    }
+  });
   if (harness === "pi") {
     const register2 = (descriptor) => {
       const document = Schema_exports.toJsonSchemaDocument(Schema_exports.toCodecJson(descriptor.input), { onExcessProperty: "error" });
@@ -72540,6 +72660,8 @@ function plugin(host) {
     const processIdentity = yield* identifyProcess(host2.pid);
     observer = yield* createNativeObserver(harness, nativeConfig.machineId, processIdentity.status === "available" ? [{ pid: host2.pid, startIdentity: processIdentity.startTime, ownership: harness === "omp" ? "shared" : "owned" }] : []);
     observer.update(ctx);
+    terminal = ctx.mode === "tui" && ctx.hasUI && process.stdout.isTTY === true;
+    rexReporter?.update(observer.presence()?.programStatus, terminal);
     if (harness === "omp" && ctx.hasUI && ctx.mode === "tui") yield* registerCoordinateKeyword;
     runtime2.runFork(connectNative(nativeConfig, {
       presence: () => Effect_exports.sync(() => {
@@ -72571,16 +72693,23 @@ function plugin(host) {
     }
   });
   const events = ["session_start", "session_switch", "agent_start", "agent_end", "turn_start", "turn_end", "message_end", "tool_execution_start", "tool_execution_end"];
+  if (harness === "pi") events.push("agent_before_settle", "agent_settled", "ui_prompt_start", "ui_prompt_end");
   for (const name of events) {
     host.on(name, async (event, ctx) => {
       if (stopped) return;
       await start(ctx);
       if (stopped || !observer) return;
-      await runtime2.runPromiseExit(Effect_exports.sync(() => observer?.update(ctx, event)).pipe(Effect_exports.tapCause(reportCause(ctx, "native update"))));
+      await runtime2.runPromiseExit(Effect_exports.sync(() => {
+        if (name === "session_switch") rexReporter?.update(void 0, terminal);
+        observer?.update(ctx, event);
+        terminal = ctx.mode === "tui" && ctx.hasUI && process.stdout.isTTY === true;
+        rexReporter?.update(observer?.presence()?.programStatus, terminal);
+      }).pipe(Effect_exports.tapCause(reportCause(ctx, "native update"))));
     });
   }
   host.on("session_shutdown", async () => {
     stopped = true;
+    rexReporter?.close(terminal);
     try {
       await runtime2.dispose();
     } finally {