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

package/dist/plugins/pi.js

@@ -1,6 +1,6 @@
 // src/plugin.ts
 import { NodeServices } from "@effect/platform-node";
-import { Cause as Cause3, Clock as Clock3, Config as Config3, Console as Console2, Effect as Effect6, Layer as Layer3, Logger, ManagedRuntime, Schema as Schema5 } from "effect";
+import { Cause as Cause3, Clock as Clock3, Console as Console2, Effect as Effect7, Formatter as Formatter2, Layer as Layer3, Logger, ManagedRuntime, Schema as Schema5 } from "effect";
 
 // src/inspection.ts
 import { Effect, Option, Path as PlatformPath, Schema, SchemaParser } from "effect";
@@ -40,6 +40,13 @@ var ProcessIdentity = Schema.Struct({
   ownership: Schema.Literals(["owned", "shared", "unknown"])
 });
 var NativeWorkState = Schema.Struct({ id: Id, state: Schema.Literals(["pending", "active", "completed", "cancelled", "unknown"]) });
+var RexText = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(4096), Schema.makeFilter(
+  (value) => /[\u0000-\u001f\u007f-\u009f]/u.test(value) ? "Control characters are forbidden" : void 0
+));
+var ProgramStatus = Schema.Union([
+  Schema.Struct({ state: Schema.Literals(["idle", "working", "done", "error"]) }),
+  Schema.Struct({ state: Schema.Literal("blocked"), kind: Schema.Literals(["permission", "question", "auth"]) })
+]);
 var SessionPresence = Schema.Struct({
   ref: SessionRef,
   observedAt: Timestamp,
@@ -60,7 +67,8 @@ var SessionPresence = Schema.Struct({
   agent: Schema.optional(Id),
   cwd: Schema.optional(Path),
   repository: Schema.optional(Path),
-  rex: Schema.optional(Schema.Struct({ serverId: Schema.optional(Id), blockId: Schema.optional(Id), sessionId: Schema.optional(Id), windowId: Schema.optional(Id), paneId: Schema.optional(Id), terminalId: Schema.optional(Id) })),
+  rex: Schema.optional(Schema.Struct({ serverAddress: Schema.optional(RexText), blockId: Schema.optional(RexText), sessionId: Schema.optional(RexText) })),
+  programStatus: Schema.optional(ProgramStatus),
   processes: Schema.optional(bounded(ProcessIdentity, 128)),
   activity: Schema.optional(Schema.Struct({
     state: Schema.Literals(["idle", "working", "waiting", "stopped", "unknown"]),
@@ -561,7 +569,7 @@ var Mcp = class extends Context.Service()("@samuelho-dev/coordinator/Mcp", {
 };
 
 // src/native.ts
-import { Cause as Cause2, Clock as Clock2, Config as Config2, Console, Crypto, Data as Data2, Duration, Effect as Effect5, FileSystem as FileSystem3, Option as Option4, Path as Path2, PlatformError as PlatformError2, Schedule, Schema as Schema4, Scope } from "effect";
+import { Cause as Cause2, Clock as Clock2, Config as Config3, Console, Crypto, Data as Data2, Duration, Effect as Effect6, FileSystem as FileSystem3, Option as Option4, Path as Path2, PlatformError as PlatformError2, Schedule, Schema as Schema4, Scope } from "effect";
 import { Hex } from "effect/encoding";
 
 // src/platform.ts
@@ -879,16 +887,51 @@ var observeResources = (roots) => Effect4.gen(function* () {
   };
 });
 
+// src/rex.ts
+import { randomUUID } from "node:crypto";
+import { Config as Config2, Effect as Effect5 } from "effect";
+var readRexContext = Effect5.gen(function* () {
+  const serverAddress = yield* Config2.String("REX_SERVER").pipe(Config2.withDefault(""));
+  const sessionId = yield* Config2.String("REX_SESSION").pipe(Config2.withDefault(""));
+  const blockId = yield* Config2.String("REX_BLOCK").pipe(Config2.withDefault(""));
+  return serverAddress || sessionId || blockId ? {
+    ...serverAddress ? { serverAddress } : {},
+    ...sessionId ? { sessionId } : {},
+    ...blockId ? { blockId } : {}
+  } : void 0;
+});
+var rexSequence = (id, status) => {
+  if (id.length > 128 || id.split("/").length > 8 || !/^[A-Za-z0-9_.+-]{1,32}(?:\/[A-Za-z0-9_.+-]{1,32})*$/u.test(id)) return "";
+  return `\x1B]7501;id=${id}:state=${status?.state ?? "clear"}:app=coordinator:title=Q29vcmRpbmF0b3I=${status?.state === "blocked" ? `:kind=${status.kind}` : ""}\x1B\\`;
+};
+var createRexReporter = (write) => {
+  const id = `coordinator/${randomUUID().replaceAll("-", "")}`;
+  let previous;
+  return {
+    update: (status, terminal) => {
+      if (!terminal) return;
+      const sequence = rexSequence(id, status);
+      if (previous === sequence || previous === void 0 && status === void 0) return;
+      write(sequence);
+      previous = sequence;
+    },
+    close: (terminal) => {
+      if (terminal && previous !== void 0 && !/:state=(?:done|error):/u.test(previous)) write(rexSequence(id, void 0));
+      previous = void 0;
+    }
+  };
+};
+
 // src/native.ts
 var NativeError = class extends Data2.TaggedError("NativeError") {
 };
-var json = (text) => Effect5.try({ try: () => JSON.parse(text), catch: () => new NativeError({ operation: "Invalid native JSON" }) });
+var json = (text) => Effect6.try({ try: () => JSON.parse(text), catch: () => new NativeError({ operation: "Invalid native JSON" }) });
 var maximumBytes = 65536;
 var platformFailure = (operation) => () => new NativeError({ operation });
 var sanitizeFileFinalizers = (operation) => (effect) => effect.pipe(
-  Effect5.catchCause((cause) => Effect5.failCause(Cause2.fromReasons(cause.reasons.map((reason) => reason._tag === "Die" && PlatformError2.isPlatformError(reason.defect) && reason.defect.reason.module === "FileSystem" ? Cause2.makeFailReason(new NativeError({ operation })) : reason))))
+  Effect6.catchCause((cause) => Effect6.failCause(Cause2.fromReasons(cause.reasons.map((reason) => reason._tag === "Die" && PlatformError2.isPlatformError(reason.defect) && reason.defect.reason.module === "FileSystem" ? Cause2.makeFailReason(new NativeError({ operation })) : reason))))
 );
-var validateDirectory = (directory, exact = false) => Effect5.gen(function* () {
+var validateDirectory = (directory, exact = false) => Effect6.gen(function* () {
   const fs = yield* FileSystem3.FileSystem;
   const host = yield* Host;
   const info = yield* fs.stat(directory);
@@ -896,7 +939,7 @@ var validateDirectory = (directory, exact = false) => Effect5.gen(function* () {
     return yield* new NativeError({ operation: "Unsafe private directory" });
   }
 });
-var readPrivateText = (file, exact = false) => Effect5.scoped(Effect5.gen(function* () {
+var readPrivateText = (file, exact = false) => Effect6.scoped(Effect6.gen(function* () {
   const fs = yield* FileSystem3.FileSystem;
   const path = yield* Path2.Path;
   const host = yield* Host;
@@ -915,73 +958,73 @@ var readPrivateText = (file, exact = false) => Effect5.scoped(Effect5.gen(functi
   if (length > maximumBytes) return yield* new NativeError({ operation: "Private file exceeds bound" });
   return new TextDecoder().decode(bytes.subarray(0, length));
 })).pipe(sanitizeFileFinalizers("Read private file"));
-var readPrivateFile = (file) => readPrivateText(file).pipe(Effect5.mapError(platformFailure("Read private file")));
-var loadConnectorConfig = (file) => Effect5.gen(function* () {
+var readPrivateFile = (file) => readPrivateText(file).pipe(Effect6.mapError(platformFailure("Read private file")));
+var loadConnectorConfig = (file) => Effect6.gen(function* () {
   const fs = yield* FileSystem3.FileSystem;
   const path = yield* Path2.Path;
   const host = yield* Host;
-  const selected = yield* Config2.String("COORDINATOR_CONNECTOR_CONFIG").pipe(Config2.option);
-  const xdg = yield* Config2.String("XDG_CONFIG_HOME").pipe(Config2.option);
+  const selected = yield* Config3.String("COORDINATOR_CONNECTOR_CONFIG").pipe(Config3.option);
+  const xdg = yield* Config3.String("XDG_CONFIG_HOME").pipe(Config3.option);
   const explicit = file ?? Option4.getOrUndefined(selected);
   const target = explicit ?? path.join(Option4.getOrUndefined(xdg) ?? path.join(host.homeDirectory, ".config"), "coordinator", "inspector.json");
   const exists = explicit !== void 0 || (yield* fs.readDirectory(path.dirname(target)).pipe(
-    Effect5.map((entries) => entries.includes(path.basename(target))),
-    Effect5.catch((error) => error.reason._tag === "NotFound" ? Effect5.succeed(false) : Effect5.fail(error)),
-    Effect5.mapError(platformFailure("Locate connector configuration"))
+    Effect6.map((entries) => entries.includes(path.basename(target))),
+    Effect6.catch((error) => error.reason._tag === "NotFound" ? Effect6.succeed(false) : Effect6.fail(error)),
+    Effect6.mapError(platformFailure("Locate connector configuration"))
   ));
   const fields = yield* Schema4.decodeUnknownEffect(Schema4.Struct({
     inspectorUrl: Schema4.optional(Schema4.Unknown),
     apiToken: Schema4.optional(Schema4.Unknown),
     tokenFile: Schema4.optional(Schema4.Unknown)
   }), { onExcessProperty: "error" })(exists ? yield* json(yield* readPrivateFile(target)) : {}).pipe(
-    Effect5.mapError(platformFailure("Invalid connector configuration"))
+    Effect6.mapError(platformFailure("Invalid connector configuration"))
   );
-  const url = yield* Config2.String("COORDINATOR_API_URL").pipe(Config2.option);
-  const token = yield* Config2.String("COORDINATOR_API_TOKEN").pipe(Config2.option);
+  const url = yield* Config3.String("COORDINATOR_API_URL").pipe(Config3.option);
+  const token = yield* Config3.String("COORDINATOR_API_TOKEN").pipe(Config3.option);
   const inspectorUrl = Option4.getOrUndefined(url) ?? fields.inspectorUrl;
   if (!exists && inspectorUrl === void 0) return void 0;
   return yield* Schema4.decodeUnknownEffect(ConnectorConfig, { onExcessProperty: "error" })({
     ...fields,
     ...inspectorUrl === void 0 ? {} : { inspectorUrl },
     ...Option4.isNone(token) ? {} : { apiToken: token.value }
-  }).pipe(Effect5.mapError(platformFailure("Invalid connector configuration")));
+  }).pipe(Effect6.mapError(platformFailure("Invalid connector configuration")));
 });
-var readConnectorToken = (config) => Effect5.gen(function* () {
+var readConnectorToken = (config) => Effect6.gen(function* () {
   if (config.apiToken !== void 0) return config.apiToken;
   if (config.tokenFile === void 0) return yield* new NativeError({ operation: "Connector credential required" });
   const token = (yield* readPrivateFile(config.tokenFile)).trim();
   if (token.length < 16 || token.length > 4096 || !/^[A-Za-z0-9._~+\/-]+=*$/.test(token)) return yield* new NativeError({ operation: "Invalid connector credential" });
   return token;
 });
-var resolveNativeConfig = (config) => Effect5.gen(function* () {
+var resolveNativeConfig = (config) => Effect6.gen(function* () {
   const fs = yield* FileSystem3.FileSystem;
   const path = yield* Path2.Path;
   const crypto = yield* Crypto.Crypto;
   const host = yield* Host;
-  const xdg = yield* Config2.String("XDG_STATE_HOME").pipe(Config2.option);
+  const xdg = yield* Config3.String("XDG_STATE_HOME").pipe(Config3.option);
   const base = Option4.getOrUndefined(xdg) ?? (host.platform === "darwin" ? path.join(host.homeDirectory, "Library", "Application Support") : path.join(host.homeDirectory, ".local", "state"));
   if (!path.isAbsolute(base) || path.resolve(base) !== base || /[\0\r\n]/.test(base)) return yield* new NativeError({ operation: "Unsafe state path" });
   const stateDirectory = path.join(base, "coordinator");
   yield* fs.makeDirectory(stateDirectory, { recursive: true, mode: 448 });
   yield* validateDirectory(stateDirectory, true);
   const target = path.join(stateDirectory, "machine-id");
-  const readIdentity = readPrivateText(target, true).pipe(Effect5.flatMap((text) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\n$/.test(text) ? Effect5.succeed(text.slice(0, -1)) : Effect5.fail(new NativeError({ operation: "Invalid installation identity" }))));
-  const existing = yield* readIdentity.pipe(Effect5.map(Option4.some), Effect5.catch((error) => error._tag === "PlatformError" && error.reason._tag === "NotFound" ? Effect5.succeed(Option4.none()) : Effect5.fail(error)));
+  const readIdentity = readPrivateText(target, true).pipe(Effect6.flatMap((text) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\n$/.test(text) ? Effect6.succeed(text.slice(0, -1)) : Effect6.fail(new NativeError({ operation: "Invalid installation identity" }))));
+  const existing = yield* readIdentity.pipe(Effect6.map(Option4.some), Effect6.catch((error) => error._tag === "PlatformError" && error.reason._tag === "NotFound" ? Effect6.succeed(Option4.none()) : Effect6.fail(error)));
   if (Option4.isSome(existing)) return { ...config, machineId: existing.value, stateDirectory };
   const temporary = path.join(stateDirectory, `.machine-id-${yield* crypto.randomUUIDv4()}`);
   const machineId = yield* crypto.randomUUIDv4();
-  return yield* Effect5.scoped(Effect5.gen(function* () {
-    const cleanupScope = yield* Effect5.scope;
-    yield* Effect5.scoped(Effect5.uninterruptibleMask((restore) => Effect5.gen(function* () {
+  return yield* Effect6.scoped(Effect6.gen(function* () {
+    const cleanupScope = yield* Effect6.scope;
+    yield* Effect6.scoped(Effect6.uninterruptibleMask((restore) => Effect6.gen(function* () {
       const handle = yield* fs.open(temporary, { flag: "wx", mode: 384 });
-      yield* Scope.addFinalizer(cleanupScope, fs.remove(temporary).pipe(Effect5.orDie));
+      yield* Scope.addFinalizer(cleanupScope, fs.remove(temporary).pipe(Effect6.orDie));
       yield* restore(handle.writeAll(new TextEncoder().encode(machineId + "\n")));
     })));
-    yield* fs.link(temporary, target).pipe(Effect5.catch((error) => error.reason._tag === "AlreadyExists" ? Effect5.void : Effect5.fail(error)));
+    yield* fs.link(temporary, target).pipe(Effect6.catch((error) => error.reason._tag === "AlreadyExists" ? Effect6.void : Effect6.fail(error)));
     return yield* readIdentity;
-  })).pipe(Effect5.map((identity) => ({ ...config, machineId: identity, stateDirectory })));
-}).pipe(sanitizeFileFinalizers("Resolve private native installation identity"), Effect5.mapError(platformFailure("Resolve private native installation identity")));
-var withProcessResources = (inspection) => Effect5.gen(function* () {
+  })).pipe(Effect6.map((identity) => ({ ...config, machineId: identity, stateDirectory })));
+}).pipe(sanitizeFileFinalizers("Resolve private native installation identity"), Effect6.mapError(platformFailure("Resolve private native installation identity")));
+var withProcessResources = (inspection) => Effect6.gen(function* () {
   const roots = inspection.presence.processes ?? [];
   if (roots.length === 0) {
     if (new TextEncoder().encode(JSON.stringify(inspection)).length > INSPECTION_LIMIT - 2 * 1024) return yield* new NativeError({ operation: "Native inspection exceeds connector budget" });
@@ -1038,14 +1081,14 @@ var withProcessResources = (inspection) => Effect5.gen(function* () {
   if (new TextEncoder().encode(JSON.stringify(result)).length > INSPECTION_LIMIT - 2 * 1024) return yield* new NativeError({ operation: "Native inspection exceeds connector budget" });
   return result;
 });
-var connectNative = (config, callbacks) => Effect5.gen(function* () {
+var connectNative = (config, callbacks) => Effect6.gen(function* () {
   const mcp = yield* Mcp;
   const clock = yield* Clock2.Clock;
   const now = () => Number(clock.monotonicTimeNanosUnsafe() / 1000000n);
   let token = yield* readConnectorToken(config);
   const crypto = yield* Crypto.Crypto;
   const identity = { connectorId: yield* crypto.randomUUIDv4(), incarnation: yield* crypto.randomUUIDv4() };
-  const report = callbacks.report ?? ((notice) => Effect5.logDebug({ message: "Native inspector", state: notice.state, operation: notice.operation, code: notice.code, status: notice.status }));
+  const report = callbacks.report ?? ((notice) => Effect6.logDebug({ message: "Native inspector", state: notice.state, operation: notice.operation, code: notice.code, status: notice.status }));
   let isUnavailable = false;
   let hasReportedHealthy = false;
   let failedAt;
@@ -1056,14 +1099,14 @@ var connectNative = (config, callbacks) => Effect5.gen(function* () {
     code: error._tag,
     status: error.status
   });
-  const unavailable2 = (operation, error) => Effect5.gen(function* () {
+  const unavailable2 = (operation, error) => Effect6.gen(function* () {
     healthyAt = void 0;
     failedAt ??= now();
     if (isUnavailable || now() - failedAt < 5e3) return;
     isUnavailable = true;
     yield* report(failure("unavailable", operation, error));
   });
-  const recovered = Effect5.gen(function* () {
+  const recovered = Effect6.gen(function* () {
     healthyAt ??= now();
     if (now() - healthyAt < 1e4) return false;
     const resetBackoff = failedAt !== void 0;
@@ -1075,37 +1118,37 @@ var connectNative = (config, callbacks) => Effect5.gen(function* () {
     if (shouldReport) yield* report({ state: "recovered", operation: "connection" });
     return resetBackoff;
   });
-  const post = (route, input, output, value) => mcp.post(config.inspectorUrl, token, route, input, output, value).pipe(Effect5.tapError((error) => unavailable2(route, error)));
-  yield* Effect5.addFinalizer(() => mcp.post(config.inspectorUrl, token, "/connector/disconnect", ConnectorDisconnect, ConnectorAccepted, identity, 500).pipe(
-    Effect5.catch((error) => Effect5.logDebug({ operation: "/connector/disconnect", code: error._tag, status: error._tag === "HttpError" ? error.status : void 0 }))
+  const post = (route, input, output, value) => mcp.post(config.inspectorUrl, token, route, input, output, value).pipe(Effect6.tapError((error) => unavailable2(route, error)));
+  yield* Effect6.addFinalizer(() => mcp.post(config.inspectorUrl, token, "/connector/disconnect", ConnectorDisconnect, ConnectorAccepted, identity, 500).pipe(
+    Effect6.catch((error) => Effect6.logDebug({ operation: "/connector/disconnect", code: error._tag, status: error._tag === "HttpError" ? error.status : void 0 }))
   ));
-  const announce = Effect5.gen(function* () {
+  const announce = Effect6.gen(function* () {
     const sessions = yield* callbacks.presence();
     if (sessions.length > 256) return yield* new NativeError({ operation: "Native presence exceeds bound" });
     yield* post("/connector/announce", ConnectorAnnounce, ConnectorAccepted, { ...identity, machineId: config.machineId, sessions });
-  }).pipe(Effect5.tapError((error) => unavailable2("native presence", error)));
-  const observationFailure = (error) => Effect5.logDebug({ operation: "native detail", code: error._tag, status: error.status }).pipe(
-    Effect5.as({
+  }).pipe(Effect6.tapError((error) => unavailable2("native presence", error)));
+  const observationFailure = (error) => Effect6.logDebug({ operation: "native detail", code: error._tag, status: error.status }).pipe(
+    Effect6.as({
       code: error._tag === "TimeoutError" ? "timeout" : error._tag === "HttpError" && error.status === 404 ? "not-found" : "unavailable",
       message: "Native session observation unavailable"
     })
   );
-  const cycle = Effect5.gen(function* () {
+  const cycle = Effect6.gen(function* () {
     const pending = yield* post("/connector/poll", ConnectorPoll, ConnectorPollResult, identity);
     for (const request of pending.requests) {
-      const observation = yield* callbacks.inspect(request.ref).pipe(Effect5.timeout("8 seconds"), Effect5.catch(observationFailure));
+      const observation = yield* callbacks.inspect(request.ref).pipe(Effect6.timeout("8 seconds"), Effect6.catch(observationFailure));
       yield* post("/connector/result", ConnectorResult, ConnectorAccepted, { ...identity, requestId: request.requestId, observation });
     }
     if (yield* recovered) return true;
-    yield* Effect5.sleep("1 second");
+    yield* Effect6.sleep("1 second");
     return false;
   });
-  const retryable = (error) => Effect5.gen(function* () {
+  const retryable = (error) => Effect6.gen(function* () {
     if (error._tag === "TimeoutError") return true;
     if (error._tag !== "HttpError") return false;
     if (error.status === 401 || error.status === 403) {
       const next = yield* readConnectorToken(config).pipe(
-        Effect5.catch((failure2) => unavailable2("credential reload", failure2).pipe(Effect5.as(void 0)))
+        Effect6.catch((failure2) => unavailable2("credential reload", failure2).pipe(Effect6.as(void 0)))
       );
       if (next === void 0 || next === token) return false;
       token = next;
@@ -1116,15 +1159,15 @@ var connectNative = (config, callbacks) => Effect5.gen(function* () {
   const maximumDelay = Duration.seconds(30);
   const backoff = Schedule.min([Schedule.exponential("2 seconds"), Schedule.spaced(maximumDelay)]).pipe(
     Schedule.jittered,
-    Schedule.modifyDelay(({ duration }) => Effect5.succeed(Duration.min(duration, maximumDelay)))
+    Schedule.modifyDelay(({ duration }) => Effect6.succeed(Duration.min(duration, maximumDelay)))
   );
-  return yield* Effect5.forever(Effect5.gen(function* () {
+  return yield* Effect6.forever(Effect6.gen(function* () {
     yield* announce;
-    yield* Effect5.raceFirst(
-      Effect5.forever(Effect5.sleep("10 seconds").pipe(Effect5.andThen(announce))),
-      cycle.pipe(Effect5.repeat({ until: (resetBackoff) => resetBackoff }))
+    yield* Effect6.raceFirst(
+      Effect6.forever(Effect6.sleep("10 seconds").pipe(Effect6.andThen(announce))),
+      cycle.pipe(Effect6.repeat({ until: (resetBackoff) => resetBackoff }))
     );
-  }).pipe(Effect5.retry({ while: retryable, schedule: backoff })));
+  }).pipe(Effect6.retry({ while: retryable, schedule: backoff })));
 });
 var Id2 = Schema4.String.check(Schema4.isMinLength(1), Schema4.isMaxLength(256));
 var N = Schema4.Finite.check(Schema4.isGreaterThanOrEqualTo(0));
@@ -1148,6 +1191,8 @@ var Cache = Schema4.Struct({ version: Schema4.Literal(2), kind: Schema4.Literal(
 var ClaudeRoster = Schema4.Array(Schema4.Struct({ sessionId: Schema4.optional(Id2), id: Schema4.optional(Id2), pid: Schema4.optional(Schema4.Int), cwd: Schema4.optional(Schema4.String), kind: Schema4.optional(Id2), status: Schema4.optional(Schema4.Literals(["busy", "waiting", "idle"])), waitingFor: Schema4.optional(Schema4.String) })).check(Schema4.isMaxLength(256));
 
 // src/plugin.ts
+import { highlightCode } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
 var provenance = (source, scope, scopeDescription, observedAt, nativeUpdatedAt = null) => ({
   source,
   scope,
@@ -1160,11 +1205,13 @@ var provenance = (source, scope, scopeDescription, observedAt, nativeUpdatedAt =
   partial: false,
   stale: false
 });
-var createNativeObserver = (harness, machineId, processes = []) => Effect6.gen(function* () {
+var createNativeObserver = (harness, machineId, processes = []) => Effect7.gen(function* () {
   const host = yield* Host;
   const clock = yield* Clock3.Clock;
-  const rexSession = yield* Config3.String("REX_SESSION").pipe(Config3.withDefault(""));
-  const rexBlock = yield* Config3.String("REX_BLOCK").pipe(Config3.withDefault(""));
+  const rex = yield* readRexContext;
+  let programStatus;
+  let userPrompt;
+  let stopReason;
   let current;
   let identity;
   let lastActivityAt;
@@ -1176,6 +1223,9 @@ var createNativeObserver = (harness, machineId, processes = []) => Effect6.gen(f
     const key = JSON.stringify([ctx.sessionManager.getSessionId(), harness === "omp" ? ctx.agent?.id : void 0]);
     if (identity !== key) {
       latest = void 0;
+      programStatus = void 0;
+      userPrompt = void 0;
+      stopReason = void 0;
       activeTools.clear();
       identity = key;
     }
@@ -1184,6 +1234,24 @@ var createNativeObserver = (harness, machineId, processes = []) => Effect6.gen(f
     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;
@@ -1203,6 +1271,7 @@ var createNativeObserver = (harness, machineId, processes = []) => Effect6.gen(f
   const presence = (now = 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: now,
@@ -1211,13 +1280,15 @@ var createNativeObserver = (harness, machineId, processes = []) => Effect6.gen(f
       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" }
       }
     };
   };
@@ -1321,6 +1392,9 @@ var createNativeObserver = (harness, machineId, processes = []) => Effect6.gen(f
     current = void 0;
     identity = void 0;
     latest = void 0;
+    programStatus = void 0;
+    userPrompt = void 0;
+    stopReason = void 0;
     lastActivityAt = void 0;
     activeTools.clear();
   } };
@@ -1337,9 +1411,9 @@ Use the available session.inspect MCP tool for on-demand details relevant to thi
 </session-inspection>`;
   return harness === "pi" ? { action: "transform", text, ...input.images ? { images: input.images } : {} } : { text, ...input.images ? { images: input.images } : {} };
 };
-var registerCoordinateKeyword = Effect6.gen(function* () {
-  const { MAGIC_KEYWORDS } = yield* Effect6.tryPromise({ try: () => import("@oh-my-pi/pi-coding-agent/modes/magic-keywords"), catch: () => new NativeError({ operation: "Load native keyword definitions" }) });
-  const { isMagicKeyword, setMagicKeywords } = yield* Effect6.tryPromise({ try: () => import("@oh-my-pi/pi-tui/prompt/magic-keywords"), catch: () => new NativeError({ operation: "Load native keyword highlighter" }) });
+var registerCoordinateKeyword = Effect7.gen(function* () {
+  const { MAGIC_KEYWORDS } = yield* Effect7.tryPromise({ try: () => import("@oh-my-pi/pi-coding-agent/modes/magic-keywords"), catch: () => new NativeError({ operation: "Load native keyword definitions" }) });
+  const { isMagicKeyword, setMagicKeywords } = yield* Effect7.tryPromise({ try: () => import("@oh-my-pi/pi-tui/prompt/magic-keywords"), catch: () => new NativeError({ operation: "Load native keyword highlighter" }) });
   setMagicKeywords([...MAGIC_KEYWORDS.filter(({ word }) => isMagicKeyword(word)), { word: "coordinate", hue: [190, 260] }]);
 });
 function plugin(host) {
@@ -1349,6 +1423,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 (args) => {
+      if (args.trim() !== "list") {
+        host.sendMessage({ customType: "coordinator-list", content: "Usage: /coordinator list", display: true }, { triggerTurn: false });
+        return;
+      }
+      const exit = await runtime.runPromiseExit(Effect7.gen(function* () {
+        const activeConfig = config ?? (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 (exit._tag === "Failure") {
+        const error = Cause3.findErrorOption(exit.cause);
+        const reason = error._tag === "Some" ? error.value._tag === "HttpError" ? `HTTP ${error.value.status}` : error.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 result = { sessions: exit.value };
+      host.sendMessage({
+        customType: "coordinator-list",
+        content: Formatter2.formatJson(result, { space: 2 }),
+        display: true,
+        details: result
+      }, { triggerTurn: false });
+    }
+  });
   if (harness === "pi") {
     const register = (descriptor) => {
       const document = Schema5.toJsonSchemaDocument(Schema5.toCodecJson(descriptor.input), { onExcessProperty: "error" });
@@ -1357,7 +1478,7 @@ function plugin(host) {
         label: `Coordinator ${descriptor.name}`,
         description: descriptor.description,
         parameters: { ...document.schema, type: "object", $defs: document.definitions },
-        execute: (_id, params, signal) => runtime.runPromise(Effect6.gen(function* () {
+        execute: (_id, params, signal) => runtime.runPromise(Effect7.gen(function* () {
           const activeConfig = config ?? (yield* loadConnectorConfig());
           if (!activeConfig) return yield* new NativeError({ operation: "Connector configuration required" });
           const input = yield* Schema5.decodeUnknownEffect(Schema5.toCodecJson(descriptor.input), { onExcessProperty: "error" })(params);
@@ -1372,21 +1493,21 @@ function plugin(host) {
     register(InspectionTools.inspect);
   }
   let lastError;
-  const report = (ctx) => (notice) => Effect6.gen(function* () {
+  const report = (ctx) => (notice) => Effect7.gen(function* () {
     if (stopped) return;
     if (notice.state !== "error") {
       if (notice.state === "recovered") lastError = void 0;
-      yield* Effect6.logDebug("Native inspector connection", { state: notice.state, operation: notice.operation, code: notice.code, status: notice.status });
+      yield* Effect7.logDebug("Native inspector connection", { state: notice.state, operation: notice.operation, code: notice.code, status: notice.status });
       return;
     }
     if (lastError?.operation === notice.operation && lastError.code === notice.code && lastError.status === notice.status) return;
     lastError = notice;
     const message = `Native inspector unavailable (operation=${notice.operation}${notice.code === void 0 ? "" : `, code=${notice.code}`}${notice.status === void 0 ? "" : `, status=${notice.status}`})`;
-    if (ctx.hasUI) yield* Effect6.sync(() => ctx.ui.notify(message, "warning"));
+    if (ctx.hasUI) yield* Effect7.sync(() => ctx.ui.notify(message, "warning"));
     else yield* Console2.error(message);
   });
   const reportCause = (ctx, operation) => (cause) => {
-    if (Cause3.hasInterruptsOnly(cause)) return Effect6.void;
+    if (Cause3.hasInterruptsOnly(cause)) return Effect7.void;
     const error = Cause3.findErrorOption(cause);
     return report(ctx)({
       state: "error",
@@ -1395,7 +1516,7 @@ function plugin(host) {
       status: error._tag === "Some" ? error.value.status : void 0
     });
   };
-  const start = (ctx) => starting ??= runtime.runPromiseExit(Effect6.gen(function* () {
+  const start = (ctx) => starting ??= runtime.runPromiseExit(Effect7.gen(function* () {
     config = yield* loadConnectorConfig();
     if (!config || stopped) return false;
     const nativeConfig = yield* resolveNativeConfig(config);
@@ -1403,13 +1524,15 @@ 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;
     runtime.runFork(connectNative(nativeConfig, {
-      presence: () => Effect6.sync(() => {
+      presence: () => Effect7.sync(() => {
         const p = observer?.presence();
         return p ? [p] : [];
       }),
-      inspect: (ref) => Effect6.gen(function* () {
+      inspect: (ref) => Effect7.gen(function* () {
         const observation = observer?.inspect();
         if (!observation || sessionRefKey(ref) !== sessionRefKey(observation.presence.ref)) {
           return yield* new HttpError({ status: 404, message: "Native session unavailable" });
@@ -1418,14 +1541,14 @@ function plugin(host) {
       }),
       report: report(ctx)
     }).pipe(
-      Effect6.scoped,
-      Effect6.tapCause(reportCause(ctx, "connector")),
-      Effect6.onExit(() => Effect6.sync(() => {
+      Effect7.scoped,
+      Effect7.tapCause(reportCause(ctx, "connector")),
+      Effect7.onExit(() => Effect7.sync(() => {
         starting = void 0;
       }))
     ));
     return true;
-  }).pipe(Effect6.tapCause(reportCause(ctx, "startup")))).then((exit) => {
+  }).pipe(Effect7.tapCause(reportCause(ctx, "startup")))).then((exit) => {
     if (exit._tag === "Failure" || !exit.value) {
       starting = void 0;
       observer?.clear();
@@ -1434,16 +1557,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 runtime.runPromiseExit(Effect6.sync(() => observer?.update(ctx, event)).pipe(Effect6.tapCause(reportCause(ctx, "native update"))));
+      await runtime.runPromiseExit(Effect7.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(Effect7.tapCause(reportCause(ctx, "native update"))));
     });
   }
   host.on("session_shutdown", async () => {
     stopped = true;
+    rexReporter?.close(terminal);
     try {
       await runtime.dispose();
     } finally {
@@ -1454,14 +1584,14 @@ function plugin(host) {
   });
   host.on("input", async (event, ctx) => {
     if (harness !== "omp" || !isCoordinateInput(event.text) || stopped) return;
-    const exit = await runtime.runPromiseExit(Effect6.gen(function* () {
+    const exit = await runtime.runPromiseExit(Effect7.gen(function* () {
       const activeConfig = config ?? (yield* loadConnectorConfig());
       if (!activeConfig) return;
       const token = yield* readConnectorToken(activeConfig);
       const mcp = yield* Mcp;
       const snapshot = yield* mcp.call(activeConfig.inspectorUrl, token, InspectionTools.list, { limit: 100 });
       return transformCoordinateInput(harness, event, snapshot);
-    }).pipe(Effect6.tapCause(reportCause(ctx, "coordinate"))));
+    }).pipe(Effect7.tapCause(reportCause(ctx, "coordinate"))));
     return exit._tag === "Success" ? exit.value : void 0;
   });
 }