@h-rig/pi-rig 0.0.6-alpha.8 → 0.0.6-alpha.80

package/dist/src/index.js

@@ -1,8 +1,11 @@
 // @bun
+var __require = import.meta.require;
+
 // packages/pi-rig/src/client.ts
 import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { dirname, resolve } from "path";
+import { RIG_PROTOCOL_VERSION, RIG_WS_CHANNELS, RIG_WS_METHODS } from "@rig/contracts";
 function cleanString(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
@@ -79,8 +82,9 @@ function createRigContextFromEnv(env = process.env) {
   const discovered = discoverRigContext(env);
   const serverUrl = env.RIG_SERVER_URL ?? env.RIG_SERVER_BASE_URL ?? discovered.serverUrl;
   const projectRoot = env.RIG_PROJECT_ROOT ?? env.PROJECT_RIG_ROOT ?? discovered.projectRoot;
-  const authToken = env.RIG_AUTH_TOKEN ?? env.RIG_GITHUB_TOKEN ?? env.GITHUB_TOKEN ?? env.GH_TOKEN ?? discovered.authToken;
+  const authToken = env.RIG_AUTH_TOKEN ?? env.RIG_SERVER_AUTH_TOKEN ?? discovered.authToken;
   const steeringPollMs = cleanNonNegativeInteger(env.RIG_STEERING_POLL_MS);
+  const operatorSession = env.RIG_PI_OPERATOR_SESSION === "1" || env.RIG_PI_OPERATOR_SESSION === "true";
   const active = Boolean(runId || taskId || serverUrl || projectRoot);
   if (!active)
     return { active: false };
@@ -91,7 +95,8 @@ function createRigContextFromEnv(env = process.env) {
     ...serverUrl ? { serverUrl } : {},
     ...projectRoot ? { projectRoot } : {},
     ...authToken ? { authToken } : {},
-    ...steeringPollMs !== null ? { steeringPollMs } : {}
+    ...steeringPollMs !== null ? { steeringPollMs } : {},
+    ...operatorSession ? { operatorSession } : {}
   };
 }
 function joinUrl(baseUrl, pathname) {
@@ -116,6 +121,8 @@ function requireServerUrl(context) {
   }
   return context.serverUrl;
 }
+var BRIDGE_REQUEST_TIMEOUT_MS = 30000;
+var PROTOCOL_CHECK_TIMEOUT_MS = 1e4;
 
 class RigBridgeClient {
   context;
@@ -124,18 +131,46 @@ class RigBridgeClient {
     this.context = input.context;
     this.fetchImpl = input.fetchImpl ?? fetch;
   }
-  async request(pathname, init) {
+  async request(pathname, init, timeoutMs = BRIDGE_REQUEST_TIMEOUT_MS) {
     const headers = new Headers(init?.headers);
     if (this.context.authToken && !headers.has("authorization")) {
       headers.set("authorization", `Bearer ${this.context.authToken}`);
     }
-    const response = await this.fetchImpl(joinUrl(requireServerUrl(this.context), pathname), { ...init, headers });
+    if (this.context.projectRoot && !headers.has("x-rig-project-root")) {
+      headers.set("x-rig-project-root", this.context.projectRoot);
+    }
+    const signal = init?.signal ?? (timeoutMs > 0 ? AbortSignal.timeout(timeoutMs) : undefined);
+    const response = await this.fetchImpl(joinUrl(requireServerUrl(this.context), pathname), { ...init, headers, signal });
     return readJsonResponse(response);
   }
-  async status() {
-    const payload = await this.request("/api/server/status");
+  async status(timeoutMs) {
+    const payload = await this.request("/api/server/status", undefined, timeoutMs);
     return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
   }
+  async checkProtocolCompatibility() {
+    let payload;
+    try {
+      payload = await this.status(PROTOCOL_CHECK_TIMEOUT_MS);
+    } catch (error) {
+      return {
+        status: "indeterminate",
+        serverProtocolVersion: null,
+        message: `Rig server protocol check failed: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+    const raw = payload.protocolVersion;
+    const serverProtocolVersion = typeof raw === "number" && Number.isInteger(raw) && raw >= 0 ? raw : null;
+    if (serverProtocolVersion === RIG_PROTOCOL_VERSION) {
+      return { status: "compatible", serverProtocolVersion, message: null };
+    }
+    const serverLabel = serverProtocolVersion === null ? "v0 (no protocolVersion reported)" : `v${serverProtocolVersion}`;
+    const updateHint = (serverProtocolVersion ?? 0) < RIG_PROTOCOL_VERSION ? "update the Rig server (upgrade @h-rig/cli / @h-rig/server and restart it)" : "update pi-rig (upgrade @h-rig/pi-rig, or reinstall the extension from this server)";
+    return {
+      status: "mismatch",
+      serverProtocolVersion,
+      message: `Rig server speaks protocol ${serverLabel}, this pi-rig speaks v${RIG_PROTOCOL_VERSION} \u2014 ${updateHint}. The Rig bridge is disabled for this session.`
+    };
+  }
   async listTasks() {
     const payload = await this.request("/api/workspace/tasks");
     return Array.isArray(payload) ? payload.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
@@ -157,6 +192,20 @@ class RigBridgeClient {
     const payload = await this.request(`/api/runs/${encodeURIComponent(runId)}`);
     return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { runId };
   }
+  async runLogs(runId = this.context.runId, limit = 20) {
+    if (!runId)
+      throw new Error("runId is required");
+    const payload = await this.request(`/api/runs/${encodeURIComponent(runId)}/logs?limit=${encodeURIComponent(String(limit))}`);
+    const entries = payload && typeof payload === "object" && !Array.isArray(payload) ? payload.entries : null;
+    return Array.isArray(entries) ? entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
+  }
+  async runTimeline(runId = this.context.runId, limit = 20) {
+    if (!runId)
+      throw new Error("runId is required");
+    const payload = await this.request(`/api/runs/${encodeURIComponent(runId)}/timeline?limit=${encodeURIComponent(String(limit))}`);
+    const entries = payload && typeof payload === "object" && !Array.isArray(payload) ? payload.entries : null;
+    return Array.isArray(entries) ? entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
+  }
   async steer(message, runId = this.context.runId) {
     if (!runId)
       throw new Error("runId is required");
@@ -167,6 +216,16 @@ class RigBridgeClient {
     });
     return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true };
   }
+  async stop(runId = this.context.runId) {
+    if (!runId)
+      throw new Error("runId is required");
+    const payload = await this.request("/api/runs/stop", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ runId })
+    });
+    return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true, runId };
+  }
   async pollSteering(runId = this.context.runId) {
     if (!runId)
       return [];
@@ -198,9 +257,371 @@ class RigBridgeClient {
     const payload = await this.request(`/api/workspace/tasks/${encodeURIComponent(taskId)}`);
     return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
   }
+  async piProxy(action, init, runId = this.context.runId) {
+    if (!runId)
+      throw new Error("runId is required");
+    return this.request(`/api/runs/${encodeURIComponent(runId)}/pi/${action}`, init);
+  }
+  async workerCommands(runId = this.context.runId) {
+    const payload = await this.piProxy("commands", undefined, runId);
+    const commands = Array.isArray(payload) ? payload : payload && typeof payload === "object" && !Array.isArray(payload) && Array.isArray(payload.commands) ? payload.commands : [];
+    return commands.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)));
+  }
+  async workerRunCommand(command, args, runId = this.context.runId) {
+    const text = `/${command}${args.trim() ? ` ${args.trim()}` : ""}`;
+    const payload = await this.piProxy("commands/run", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ text })
+    }, runId);
+    return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true };
+  }
+  async workerShell(command, runId = this.context.runId) {
+    const payload = await this.piProxy("shell", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ text: command })
+    }, runId);
+    return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true };
+  }
+  async workerAbort(runId = this.context.runId) {
+    const payload = await this.piProxy("abort", { method: "POST" }, runId);
+    return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true };
+  }
+  async workerCapabilities(runId = this.context.runId) {
+    const payload = await this.piProxy("capabilities", undefined, runId);
+    return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+  }
+  async workerRespondExtensionUi(requestId, response, runId = this.context.runId) {
+    const payload = await this.piProxy("extension-ui/respond", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ requestId, ...response })
+    }, runId);
+    return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true };
+  }
+  async fetchRunSessionFile(runId = this.context.runId) {
+    if (!runId)
+      return null;
+    const payload = await this.request(`/api/runs/${encodeURIComponent(runId)}/session-file`);
+    if (!payload || typeof payload !== "object" || Array.isArray(payload))
+      return null;
+    const record = payload;
+    if (record.ok !== true || typeof record.content !== "string" || !record.content.trim())
+      return null;
+    return {
+      fileName: typeof record.fileName === "string" && record.fileName.trim() ? record.fileName : `rig-run-${runId}.jsonl`,
+      content: record.content
+    };
+  }
+}
+function buildRigWebSocketUrl(serverUrl, authToken) {
+  const url = new URL(serverUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  if (authToken) {
+    url.searchParams.set("token", authToken);
+  }
+  return url.toString();
+}
+function defaultWebSocketFactory() {
+  const ctor = globalThis.WebSocket;
+  if (typeof ctor !== "function")
+    return null;
+  return (url) => new ctor(url);
+}
+function webSocketEventText(data) {
+  if (typeof data === "string")
+    return data;
+  if (data instanceof Uint8Array)
+    return new TextDecoder().decode(data);
+  return null;
+}
+
+class RigBridgeSocket {
+  context;
+  handlers;
+  factory;
+  reconnectBaseMs;
+  reconnectMaxMs;
+  socket = null;
+  connectedFlag = false;
+  closed = false;
+  started = false;
+  attempt = 0;
+  reconnectTimer = null;
+  ackSequence = 0;
+  constructor(input) {
+    this.context = input.context;
+    this.handlers = input.handlers ?? {};
+    this.factory = input.webSocketFactory ?? defaultWebSocketFactory();
+    this.reconnectBaseMs = input.reconnectBaseMs ?? 1000;
+    this.reconnectMaxMs = input.reconnectMaxMs ?? 30000;
+  }
+  get connected() {
+    return this.connectedFlag;
+  }
+  start() {
+    if (this.closed)
+      return false;
+    if (this.started)
+      return true;
+    if (!this.context.serverUrl || !this.factory)
+      return false;
+    this.started = true;
+    this.connect();
+    return true;
+  }
+  close() {
+    this.closed = true;
+    this.connectedFlag = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    try {
+      this.socket?.close();
+    } catch {}
+    this.socket = null;
+  }
+  ackSteering(runId, ids) {
+    if (!this.connectedFlag || !this.socket || ids.length === 0)
+      return;
+    try {
+      this.socket.send(JSON.stringify({
+        id: `pi-rig-steer-ack-${++this.ackSequence}`,
+        body: { _tag: RIG_WS_METHODS.ackRunSteering, runId, ids }
+      }));
+    } catch {}
+  }
+  connect() {
+    if (this.closed || !this.context.serverUrl || !this.factory)
+      return;
+    let socket;
+    try {
+      socket = this.factory(buildRigWebSocketUrl(this.context.serverUrl, this.context.authToken));
+    } catch {
+      this.scheduleReconnect();
+      return;
+    }
+    this.socket = socket;
+    let gone = false;
+    socket.addEventListener("open", () => {
+      if (this.closed || gone)
+        return;
+      this.attempt = 0;
+      this.connectedFlag = true;
+      this.handlers.onConnect?.();
+    });
+    const onGone = () => {
+      if (gone)
+        return;
+      gone = true;
+      const wasConnected = this.connectedFlag;
+      this.connectedFlag = false;
+      try {
+        socket.close();
+      } catch {}
+      if (this.socket === socket)
+        this.socket = null;
+      if (this.closed)
+        return;
+      if (wasConnected)
+        this.handlers.onDisconnect?.();
+      this.scheduleReconnect();
+    };
+    socket.addEventListener("close", onGone);
+    socket.addEventListener("error", onGone);
+    socket.addEventListener("message", (event) => {
+      if (!this.closed)
+        this.handleMessage(event);
+    });
+  }
+  scheduleReconnect() {
+    if (this.closed || this.reconnectTimer)
+      return;
+    const delay = Math.min(this.reconnectBaseMs * 2 ** this.attempt, this.reconnectMaxMs);
+    this.attempt += 1;
+    const timer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, delay);
+    this.reconnectTimer = timer;
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+  }
+  handleMessage(event) {
+    const text = webSocketEventText(event.data);
+    if (!text)
+      return;
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return;
+    const record = parsed;
+    if (record.type !== "push" || typeof record.channel !== "string")
+      return;
+    const data = record.data && typeof record.data === "object" && !Array.isArray(record.data) ? record.data : null;
+    if (record.channel === RIG_WS_CHANNELS.runSteering) {
+      if (!data || !this.context.runId || data.runId !== this.context.runId)
+        return;
+      const message = data.message && typeof data.message === "object" && !Array.isArray(data.message) ? data.message : null;
+      if (message)
+        this.handlers.onSteeringMessage?.(message);
+      return;
+    }
+    if (record.channel === RIG_WS_CHANNELS.event) {
+      if (data)
+        this.handlers.onRigEvent?.(data);
+      return;
+    }
+    if (record.channel === RIG_WS_CHANNELS.snapshotInvalidated) {
+      this.handlers.onSnapshotInvalidated?.();
+    }
+  }
+}
+function buildRunPiEventsWebSocketUrl(context) {
+  if (!context.serverUrl || !context.runId)
+    return null;
+  const url = new URL(`${context.serverUrl.replace(/\/+$/, "")}/api/runs/${encodeURIComponent(context.runId)}/pi/events`);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  if (context.authToken)
+    url.searchParams.set("token", context.authToken);
+  if (context.projectRoot)
+    url.searchParams.set("rigProjectRoot", context.projectRoot);
+  return url.toString();
+}
+
+class RigWorkerEventsSocket {
+  context;
+  handlers;
+  factory;
+  reconnectBaseMs;
+  reconnectMaxMs;
+  socket = null;
+  connectedFlag = false;
+  closed = false;
+  started = false;
+  attempt = 0;
+  reconnectTimer = null;
+  constructor(input) {
+    this.context = input.context;
+    this.handlers = input.handlers ?? {};
+    this.factory = input.webSocketFactory ?? defaultWebSocketFactory();
+    this.reconnectBaseMs = input.reconnectBaseMs ?? 1000;
+    this.reconnectMaxMs = input.reconnectMaxMs ?? 30000;
+  }
+  get connected() {
+    return this.connectedFlag;
+  }
+  start() {
+    if (this.closed)
+      return false;
+    if (this.started)
+      return true;
+    if (!buildRunPiEventsWebSocketUrl(this.context) || !this.factory)
+      return false;
+    this.started = true;
+    this.connect();
+    return true;
+  }
+  close() {
+    this.closed = true;
+    this.connectedFlag = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    try {
+      this.socket?.close();
+    } catch {}
+    this.socket = null;
+  }
+  connect() {
+    const target = buildRunPiEventsWebSocketUrl(this.context);
+    if (this.closed || !target || !this.factory)
+      return;
+    let socket;
+    try {
+      socket = this.factory(target);
+    } catch {
+      this.scheduleReconnect();
+      return;
+    }
+    this.socket = socket;
+    let gone = false;
+    socket.addEventListener("open", () => {
+      if (this.closed || gone)
+        return;
+      this.attempt = 0;
+      this.connectedFlag = true;
+      this.handlers.onConnect?.();
+    });
+    const onGone = () => {
+      if (gone)
+        return;
+      gone = true;
+      const wasConnected = this.connectedFlag;
+      this.connectedFlag = false;
+      try {
+        socket.close();
+      } catch {}
+      if (this.socket === socket)
+        this.socket = null;
+      if (this.closed)
+        return;
+      if (wasConnected)
+        this.handlers.onDisconnect?.();
+      this.scheduleReconnect();
+    };
+    socket.addEventListener("close", onGone);
+    socket.addEventListener("error", onGone);
+    socket.addEventListener("message", (event) => {
+      if (this.closed)
+        return;
+      const text = webSocketEventText(event.data);
+      if (!text)
+        return;
+      let parsed;
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        return;
+      }
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        this.handlers.onFrame?.(parsed);
+      }
+    });
+  }
+  scheduleReconnect() {
+    if (this.closed || this.reconnectTimer)
+      return;
+    const delay = Math.min(this.reconnectBaseMs * 2 ** this.attempt, this.reconnectMaxMs);
+    this.attempt += 1;
+    const timer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, delay);
+    this.reconnectTimer = timer;
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+  }
 }
 
 // packages/pi-rig/src/commands.ts
+function runRecordFromPayload(payload) {
+  return payload.run && typeof payload.run === "object" && !Array.isArray(payload.run) ? payload.run : payload;
+}
+function formatEntry(entry) {
+  const type = String(entry.type ?? entry.title ?? "event");
+  const text = typeof entry.text === "string" ? entry.text : typeof entry.detail === "string" ? entry.detail : typeof entry.message === "string" ? entry.message : JSON.stringify(entry);
+  return `${type}: ${text}`;
+}
 function createRigSlashCommands(input) {
   const notify = input.notify ?? (() => {});
   async function handleRig(args) {
@@ -229,23 +650,276 @@ function createRigSlashCommands(input) {
       }
       if (first === "attach") {
         const run = await input.client.attach(second);
-        const runRecord = run.run && typeof run.run === "object" ? run.run : run;
+        const runRecord = runRecordFromPayload(run);
         notify(`Attached to ${String(runRecord.runId ?? second ?? input.context.runId ?? "run")}: ${String(runRecord.status ?? "unknown")}`, "info");
         return;
       }
-      notify("Usage: /rig status | /rig task list | /rig task run [id] | /rig attach [run-id]", "error");
+      if (first === "timeline" || first === "logs") {
+        const runId = second || input.context.runId;
+        const entries = first === "timeline" ? await input.client.runTimeline(runId, 20) : await input.client.runLogs(runId, 20);
+        notify(entries.length > 0 ? entries.slice(-10).map(formatEntry).join(`
+`) : `No ${first} entries for ${runId ?? "run"}.`, "info");
+        return;
+      }
+      if (first === "steer") {
+        const message = args.trim().slice("steer".length).trim();
+        if (!message) {
+          notify("Usage: /rig steer <message>", "error");
+          return;
+        }
+        await input.client.steer(message);
+        notify("Rig steering message queued.", "info");
+        return;
+      }
+      if (first === "stop") {
+        await input.client.stop(second || input.context.runId);
+        notify("Rig stop requested.", "info");
+        return;
+      }
+      if (first === "abort") {
+        await input.client.workerAbort(second || input.context.runId);
+        notify("Worker turn abort requested.", "info");
+        return;
+      }
+      if (first === "sh") {
+        const command = args.trim().slice("sh".length).trim();
+        if (!command) {
+          notify("Usage: /rig sh <command> \u2014 runs in the WORKER workspace", "error");
+          return;
+        }
+        await input.client.workerShell(command, input.context.runId);
+        notify("Shell command sent to the worker workspace.", "info");
+        return;
+      }
+      notify("Usage: /rig status | /rig task list | /rig task run [id] | /rig attach [run-id] | /rig timeline [run-id] | /rig logs [run-id] | /rig steer <message> | /rig stop [run-id] | /rig abort [run-id] | /rig sh <command>", "error");
     } catch (error) {
       notify(error instanceof Error ? error.message : String(error), "error");
     }
   }
   return {
     rig: {
-      description: "Rig control-plane commands: status, task list, task run, attach",
+      description: "Rig control-plane commands: status, task list, task run, attach, timeline, logs, steer, stop",
       handler: handleRig
     }
   };
 }
 
+// packages/pi-rig/src/live-mirror.ts
+async function loadPiModules() {
+  const components = await import("@earendil-works/pi-coding-agent");
+  return { components };
+}
+function createRootContainer() {
+  const children = [];
+  return {
+    addChild(child) {
+      children.push(child);
+    },
+    removeChild(child) {
+      const index = children.indexOf(child);
+      if (index >= 0)
+        children.splice(index, 1);
+    },
+    clear() {
+      children.length = 0;
+    },
+    render(width) {
+      return children.flatMap((child) => child.render(width));
+    }
+  };
+}
+var DRONE_MESSAGE_TYPE = "rig-drone";
+var DRONE_USER_MESSAGE_TYPE = "rig-drone-user";
+function recordOf(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function messageRole(event) {
+  const message = recordOf(event.message);
+  return message && typeof message.role === "string" ? message.role : null;
+}
+function userMessageText(message) {
+  const content = message.content;
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    return content.flatMap((block) => {
+      const record = recordOf(block);
+      return record && record.type === "text" && typeof record.text === "string" ? [record.text] : [];
+    }).join(`
+`);
+  }
+  return "";
+}
+async function createLiveMirror(input) {
+  const { pi } = input;
+  const modules = input.modules ?? await loadPiModules();
+  const cwd = input.workerCwd ?? process.cwd();
+  const turns = new Map;
+  const toolOwners = new Map;
+  const userComponents = new Map;
+  let streamingTurn = null;
+  let sequence = 0;
+  let tui = null;
+  let renderTimer = null;
+  const requestRender = () => {
+    if (renderTimer)
+      return;
+    renderTimer = setTimeout(() => {
+      renderTimer = null;
+      tui?.requestRender?.();
+    }, 33);
+    renderTimer.unref?.();
+  };
+  pi.registerMessageRenderer?.(DRONE_MESSAGE_TYPE, (message) => {
+    const details = recordOf(recordOf(message)?.details);
+    const key = details && typeof details.key === "string" ? details.key : null;
+    return key ? turns.get(key)?.root : undefined;
+  });
+  pi.registerMessageRenderer?.(DRONE_USER_MESSAGE_TYPE, (message) => {
+    const details = recordOf(recordOf(message)?.details);
+    const key = details && typeof details.key === "string" ? details.key : null;
+    return key ? userComponents.get(key) : undefined;
+  });
+  const ensureToolComponent = (turn, toolCallId, toolName, args) => {
+    const existing = turn.tools.get(toolCallId);
+    if (existing)
+      return existing;
+    const component = new modules.components.ToolExecutionComponent(toolName, toolCallId, args, {}, undefined, tui, cwd);
+    turn.root.addChild(component);
+    turn.tools.set(toolCallId, component);
+    toolOwners.set(toolCallId, turn);
+    return component;
+  };
+  const startAssistantTurn = (message) => {
+    const key = `turn-${++sequence}`;
+    const root = createRootContainer();
+    const assistant = new modules.components.AssistantMessageComponent;
+    root.addChild(assistant);
+    const turn = { root, assistant, tools: new Map };
+    assistant.updateContent(message);
+    turns.set(key, turn);
+    streamingTurn = turn;
+    pi.sendMessage?.({ customType: DRONE_MESSAGE_TYPE, content: "drone turn", display: true, details: { key } }, { triggerTurn: false });
+    requestRender();
+  };
+  const updateAssistantTurn = (message) => {
+    const turn = streamingTurn;
+    if (!turn)
+      return;
+    turn.assistant.updateContent(message);
+    const content = Array.isArray(message.content) ? message.content : [];
+    for (const block of content) {
+      const record = recordOf(block);
+      if (!record || record.type !== "toolCall")
+        continue;
+      const id = typeof record.id === "string" ? record.id : null;
+      const name = typeof record.name === "string" ? record.name : "tool";
+      if (!id)
+        continue;
+      const component = ensureToolComponent(turn, id, name, record.arguments);
+      component.updateArgs(record.arguments);
+    }
+    requestRender();
+  };
+  const endAssistantTurn = (message) => {
+    const turn = streamingTurn;
+    if (!turn)
+      return;
+    turn.assistant.updateContent(message);
+    const stopReason = typeof message.stopReason === "string" ? message.stopReason : "stop";
+    if (stopReason === "aborted" || stopReason === "error") {
+      const errorText = typeof message.errorMessage === "string" && message.errorMessage ? message.errorMessage : stopReason === "aborted" ? "Operation aborted" : "Error";
+      for (const component of turn.tools.values()) {
+        component.updateResult({ content: [{ type: "text", text: errorText }], isError: true });
+      }
+    } else {
+      for (const component of turn.tools.values()) {
+        component.setArgsComplete();
+      }
+    }
+    streamingTurn = null;
+    requestRender();
+  };
+  const mirrorUserMessage = (message) => {
+    const text = userMessageText(message).trim();
+    if (!text)
+      return;
+    const key = `user-${++sequence}`;
+    userComponents.set(key, new modules.components.UserMessageComponent(text));
+    pi.sendMessage?.({ customType: DRONE_USER_MESSAGE_TYPE, content: text, display: true, details: { key } }, { triggerTurn: false });
+    requestRender();
+  };
+  return {
+    captureTui(capturedTui) {
+      tui = recordOf(capturedTui);
+      return { render: () => [] };
+    },
+    handleWorkerEvent(event) {
+      const type = typeof event.type === "string" ? event.type : null;
+      switch (type) {
+        case "message_start": {
+          const message = recordOf(event.message);
+          if (!message)
+            return;
+          if (messageRole(event) === "assistant")
+            startAssistantTurn(message);
+          else if (messageRole(event) === "user")
+            mirrorUserMessage(message);
+          return;
+        }
+        case "message_update": {
+          const message = recordOf(event.message);
+          if (message && messageRole(event) === "assistant")
+            updateAssistantTurn(message);
+          return;
+        }
+        case "message_end": {
+          const message = recordOf(event.message);
+          if (message && messageRole(event) === "assistant")
+            endAssistantTurn(message);
+          return;
+        }
+        case "tool_execution_start": {
+          const id = typeof event.toolCallId === "string" ? event.toolCallId : null;
+          const name = typeof event.toolName === "string" ? event.toolName : "tool";
+          if (!id)
+            return;
+          const turn = toolOwners.get(id) ?? streamingTurn;
+          if (!turn)
+            return;
+          ensureToolComponent(turn, id, name, event.args).markExecutionStarted();
+          requestRender();
+          return;
+        }
+        case "tool_execution_update": {
+          const id = typeof event.toolCallId === "string" ? event.toolCallId : null;
+          const component = id ? toolOwners.get(id)?.tools.get(id) : undefined;
+          const partial = recordOf(event.partialResult);
+          if (component && partial) {
+            const content = Array.isArray(partial.content) ? partial.content : [];
+            component.updateResult({ ...partial, content, isError: false }, true);
+            requestRender();
+          }
+          return;
+        }
+        case "tool_execution_end": {
+          const id = typeof event.toolCallId === "string" ? event.toolCallId : null;
+          const component = id ? toolOwners.get(id)?.tools.get(id) : undefined;
+          const result = recordOf(event.result);
+          if (component && result) {
+            const content = Array.isArray(result.content) ? result.content : [];
+            component.updateResult({ ...result, content, isError: event.isError === true });
+            requestRender();
+          }
+          return;
+        }
+        default:
+          return;
+      }
+    }
+  };
+}
+
 // packages/pi-rig/src/tools.ts
 function textResult(text, details) {
   return { content: [{ type: "text", text }], ...details ? { details } : {} };
@@ -308,7 +982,8 @@ function createPiRigExtensionState(input = {}) {
   const context = createRigContextFromEnv(input.env ?? process.env);
   return {
     ...context,
-    client: new RigBridgeClient({ context, fetchImpl: input.fetchImpl })
+    client: new RigBridgeClient({ context, fetchImpl: input.fetchImpl }),
+    ...input.webSocketFactory ? { webSocketFactory: input.webSocketFactory } : {}
   };
 }
 function notify(ctx, message, level = "info") {
@@ -318,6 +993,91 @@ function notify(ctx, message, level = "info") {
     notifyFn.call(ui, message, level);
   }
 }
+function canNotify(ctx) {
+  const ui = ctx && typeof ctx === "object" ? ctx.ui : null;
+  return Boolean(ui && typeof ui === "object" && typeof ui.notify === "function");
+}
+function setWidget(ctx, id, lines) {
+  const ui = ctx && typeof ctx === "object" ? ctx.ui : null;
+  const setWidgetFn = ui && typeof ui === "object" ? ui.setWidget : null;
+  if (typeof setWidgetFn === "function") {
+    setWidgetFn.call(ui, id, lines);
+  }
+}
+function setStatus(ctx, id, text) {
+  const ui = ctx && typeof ctx === "object" ? ctx.ui : null;
+  const setStatusFn = ui && typeof ui === "object" ? ui.setStatus : null;
+  if (typeof setStatusFn === "function") {
+    setStatusFn.call(ui, id, text);
+  }
+}
+function uiOf(ctx) {
+  const ui = ctx && typeof ctx === "object" ? ctx.ui : null;
+  return ui && typeof ui === "object" ? ui : null;
+}
+function setTitle(ctx, title) {
+  const ui = uiOf(ctx);
+  const setTitleFn = ui?.setTitle;
+  if (typeof setTitleFn === "function")
+    setTitleFn.call(ui, title);
+}
+function shutdownPi(ctx) {
+  const shutdownFn = ctx && typeof ctx === "object" ? ctx.shutdown : null;
+  if (typeof shutdownFn === "function")
+    shutdownFn.call(ctx);
+}
+async function askNativeDialog(ctx, request) {
+  const ui = uiOf(ctx);
+  if (!ui)
+    return null;
+  const { method, prompt, choices } = request;
+  try {
+    if (method === "confirm" && typeof ui.confirm === "function") {
+      const confirmed = await ui.confirm("Worker request", prompt);
+      return { value: confirmed, confirmed };
+    }
+    if (choices.length > 0 && typeof ui.select === "function") {
+      const selected = await ui.select(prompt, choices);
+      return selected === undefined ? { cancelled: true } : { value: selected };
+    }
+    if (typeof ui.input === "function") {
+      const value = await ui.input("Worker request", prompt);
+      return value === undefined ? { cancelled: true } : { value };
+    }
+  } catch {
+    return { cancelled: true };
+  }
+  return null;
+}
+function shortPath(path, segments = 3) {
+  const parts = path.split("/").filter(Boolean);
+  if (parts.length <= segments)
+    return path;
+  return `\u2026/${parts.slice(-segments).join("/")}`;
+}
+function createBridgeGate(state) {
+  let pending = null;
+  let warned = false;
+  return async (ctx) => {
+    if (!state.active || !state.serverUrl)
+      return { allowed: true, message: null, status: "indeterminate" };
+    pending ??= state.client.checkProtocolCompatibility().then((check2) => {
+      if (check2.status === "indeterminate")
+        pending = null;
+      return check2;
+    });
+    const check = await pending;
+    if (check.status !== "mismatch")
+      return { allowed: true, message: null, status: check.status };
+    const message = check.message ?? "Rig protocol mismatch \u2014 the Rig bridge is disabled.";
+    if (!warned && canNotify(ctx)) {
+      warned = true;
+      notify(ctx, message, "error");
+      setStatus(ctx, "rig", "Rig bridge disabled (protocol mismatch)");
+    }
+    return { allowed: false, message, status: "mismatch" };
+  };
+}
 function steeringText(message) {
   const text = typeof message.message === "string" ? message.message.trim() : "";
   if (!text)
@@ -326,54 +1086,525 @@ function steeringText(message) {
   return `[Rig steering from ${actor}]
 ${text}`;
 }
-async function consumeQueuedSteering(pi, state, ctx) {
-  if (!state.active || !state.runId || typeof pi.sendUserMessage !== "function")
+function unrefTimer(timer) {
+  if (typeof timer.unref === "function") {
+    timer.unref();
+  }
+}
+var STEERING_DEDUPE_LIMIT = 500;
+function rememberDeliveredSteeringId(deliveredIds, id) {
+  deliveredIds.add(id);
+  if (deliveredIds.size > STEERING_DEDUPE_LIMIT) {
+    const oldest = deliveredIds.values().next().value;
+    if (typeof oldest === "string")
+      deliveredIds.delete(oldest);
+  }
+}
+async function deliverSteeringMessage(pi, deliveredIds, message) {
+  if (typeof pi.sendUserMessage !== "function")
+    return false;
+  const id = typeof message.id === "string" && message.id.trim() ? message.id : null;
+  if (id && deliveredIds.has(id))
+    return false;
+  const text = steeringText(message);
+  if (!text)
+    return false;
+  if (id)
+    rememberDeliveredSteeringId(deliveredIds, id);
+  await pi.sendUserMessage(text, { deliverAs: "steer", triggerTurn: true });
+  return true;
+}
+async function consumeQueuedSteering(pi, state, ctx, gate, deliveredIds) {
+  if (state.operatorSession || !state.active || !state.runId || typeof pi.sendUserMessage !== "function")
+    return;
+  if (!(await gate(ctx)).allowed)
     return;
   try {
     const messages = await state.client.consumeSteering(state.runId);
+    let deliveredCount = 0;
     for (const message of messages) {
-      const text = steeringText(message);
-      if (!text)
-        continue;
-      await pi.sendUserMessage(text, { deliverAs: "steer", triggerTurn: true });
+      if (await deliverSteeringMessage(pi, deliveredIds, message))
+        deliveredCount += 1;
     }
-    if (messages.length > 0) {
-      notify(ctx, `Delivered ${messages.length} Rig steering message${messages.length === 1 ? "" : "s"}.`);
+    if (deliveredCount > 0) {
+      notify(ctx, `Delivered ${deliveredCount} Rig steering message${deliveredCount === 1 ? "" : "s"}.`);
     }
   } catch (error) {
     notify(ctx, `Rig steering sync failed: ${error instanceof Error ? error.message : String(error)}`, "error");
   }
 }
-function startLiveSteeringPoll(pi, state, ctx) {
-  if (!state.active || !state.runId || typeof pi.sendUserMessage !== "function")
+function inputText(event) {
+  if (!event || typeof event !== "object" || Array.isArray(event))
+    return null;
+  const text = event.text;
+  return typeof text === "string" && text.trim() ? text.trim() : null;
+}
+async function handleOperatorInput(event, state, ctx, gate) {
+  if (!state.operatorSession || !state.active || !state.runId)
+    return;
+  const text = inputText(event);
+  if (!text || text.startsWith("/"))
+    return;
+  if (!(await gate(ctx)).allowed)
+    return;
+  if (text.startsWith("!")) {
+    const command = text.slice(1).trim();
+    if (!command)
+      return;
+    try {
+      await state.client.workerShell(command, state.runId);
+      notify(ctx, "Shell command sent to the worker workspace.");
+    } catch (error) {
+      notify(ctx, `Worker shell failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+    }
+    return { action: "handled" };
+  }
+  try {
+    await state.client.steer(text, state.runId);
+    notify(ctx, "Rig steering message queued.");
+  } catch (error) {
+    notify(ctx, `Rig steering failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+  }
+  return { action: "handled" };
+}
+function runLocation(run) {
+  const worktree = typeof run.worktreePath === "string" && run.worktreePath.trim() ? run.worktreePath.trim() : null;
+  const projectRoot = typeof run.projectRoot === "string" && run.projectRoot.trim() ? run.projectRoot.trim() : null;
+  return worktree ?? projectRoot ?? "remote/local worker workspace";
+}
+function runPayload(payload) {
+  return payload.run && typeof payload.run === "object" && !Array.isArray(payload.run) ? payload.run : payload;
+}
+var OPERATOR_WIDGET_WS_FALLBACK_MS = 1e4;
+function startOperatorRunStatusLine(state, ctx, live) {
+  if (!state.operatorSession || !state.active || !state.runId)
+    return;
+  const shortId = state.runId.slice(0, 8);
+  let inFlight = false;
+  let lastRefreshAt = 0;
+  const refresh = async () => {
+    if (inFlight)
+      return;
+    inFlight = true;
+    lastRefreshAt = Date.now();
+    try {
+      const run = runPayload(await state.client.attach(state.runId));
+      const status = String(run.status ?? "unknown");
+      setStatus(ctx, "rig", `drone ${shortId} \xB7 ${status} \xB7 ${shortPath(runLocation(run))}`);
+    } catch (error) {
+      setStatus(ctx, "rig", `drone ${shortId} \xB7 server unreachable: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      inFlight = false;
+    }
+  };
+  refresh();
+  const timer = setInterval(() => {
+    const triggered = live?.consumePushTrigger() ?? false;
+    if ((live?.isConnected() ?? false) && !triggered && Date.now() - lastRefreshAt < OPERATOR_WIDGET_WS_FALLBACK_MS) {
+      return;
+    }
+    refresh();
+  }, 5000);
+  unrefTimer(timer);
+}
+function operatorInboxNotification(event) {
+  const type = typeof event.type === "string" ? event.type : null;
+  if (type !== "rig.approval.requested" && type !== "rig.user-input.requested")
+    return null;
+  const payload = event.payload && typeof event.payload === "object" && !Array.isArray(event.payload) ? event.payload : {};
+  const runId = typeof payload.runId === "string" && payload.runId.trim() ? payload.runId : typeof event.aggregateId === "string" && event.aggregateId.trim() ? event.aggregateId : "unknown";
+  const requestId = typeof payload.requestId === "string" && payload.requestId.trim() ? payload.requestId : `${type}:${runId}`;
+  const waitingOn = type === "rig.approval.requested" ? "an approval" : "user input";
+  return {
+    key: requestId,
+    text: `Run ${runId} is waiting on ${waitingOn} \u2014 resolve with /rig inbox or \`rig inbox\`.`
+  };
+}
+function startOperatorBridge(state, ctx) {
+  if (!state.operatorSession || !state.active)
+    return;
+  const notifiedRequests = new Set;
+  let pushTrigger = false;
+  const socket = new RigBridgeSocket({
+    context: state,
+    webSocketFactory: state.webSocketFactory,
+    handlers: {
+      onRigEvent: (event) => {
+        pushTrigger = true;
+        const notification = operatorInboxNotification(event);
+        if (!notification || notifiedRequests.has(notification.key))
+          return;
+        notifiedRequests.add(notification.key);
+        if (notifiedRequests.size > 1000) {
+          const oldest = notifiedRequests.values().next().value;
+          if (typeof oldest === "string")
+            notifiedRequests.delete(oldest);
+        }
+        notify(ctx, notification.text);
+      },
+      onSnapshotInvalidated: () => {
+        pushTrigger = true;
+      },
+      onDisconnect: () => {
+        pushTrigger = true;
+      }
+    }
+  });
+  if (!socket.start())
+    return;
+  return {
+    isConnected: () => socket.connected,
+    consumePushTrigger: () => {
+      const triggered = pushTrigger;
+      pushTrigger = false;
+      return triggered;
+    }
+  };
+}
+function workerStatusLine(status) {
+  const model = status.model && typeof status.model === "object" && !Array.isArray(status.model) ? status.model : null;
+  const modelId = model && typeof model.id === "string" ? model.id : null;
+  const usage = status.contextUsage && typeof status.contextUsage === "object" && !Array.isArray(status.contextUsage) ? status.contextUsage : null;
+  const percent = usage && typeof usage.percent === "number" ? `${Math.round(usage.percent)}% ctx` : null;
+  const streaming = status.isStreaming === true ? "streaming" : null;
+  const parts = [modelId, percent, streaming].filter((value) => Boolean(value));
+  return parts.length > 0 ? `worker ${parts.join(" \xB7 ")}` : "worker session connected";
+}
+function applyRigTheme(ctx) {
+  const ui = uiOf(ctx);
+  if (!ui || typeof ui.getTheme !== "function" || typeof ui.setTheme !== "function")
+    return;
+  try {
+    const theme = ui.getTheme("rig");
+    if (theme)
+      ui.setTheme(theme);
+  } catch {}
+}
+var MICRO_DRONE_BLADES = ["---", "\\\\\\", "|||", "///"];
+var MICRO_DRONE_EYES = ["@", "o", "."];
+function applyDroneWorkingIndicator(ctx) {
+  const ui = uiOf(ctx);
+  if (!ui || typeof ui.setWorkingIndicator !== "function")
+    return;
+  const frames = Array.from({ length: 12 }, (_, index) => {
+    const blade = MICRO_DRONE_BLADES[index % MICRO_DRONE_BLADES.length];
+    const eye = MICRO_DRONE_EYES[Math.floor(index / 2) % MICRO_DRONE_EYES.length];
+    return `(${blade})${eye}(${blade})`;
+  });
+  try {
+    ui.setWorkingIndicator({ frames, intervalMs: 120 });
+  } catch {}
+}
+function renderWorkerCapabilities(capabilities) {
+  const names = (value, key = "name") => Array.isArray(value) ? value.flatMap((entry) => {
+    if (typeof entry === "string")
+      return [entry];
+    if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+      const name = entry[key];
+      return typeof name === "string" ? [name] : [];
+    }
+    return [];
+  }) : [];
+  const lines = ["Drone capabilities (in effect for this run)"];
+  const tools = Array.isArray(capabilities.tools) ? capabilities.tools : [];
+  const activeTools = tools.flatMap((tool) => {
+    const record = tool && typeof tool === "object" && !Array.isArray(tool) ? tool : null;
+    return record && record.active === true && typeof record.name === "string" ? [record.name] : [];
+  });
+  const inactiveCount = tools.length - activeTools.length;
+  lines.push(`  tools       ${activeTools.join(", ") || "(none)"}${inactiveCount > 0 ? `  (+${inactiveCount} inactive)` : ""}`);
+  const extensions = Array.isArray(capabilities.extensions) ? capabilities.extensions : [];
+  const extensionLabels = extensions.flatMap((entry) => {
+    const record = entry && typeof entry === "object" && !Array.isArray(entry) ? entry : null;
+    if (!record)
+      return [];
+    const path = typeof record.path === "string" ? record.path : "";
+    const short = path.split("/").filter(Boolean).slice(-2).join("/") || path || "extension";
+    return [short];
+  });
+  lines.push(`  extensions  ${extensionLabels.join(", ") || "(none)"}`);
+  lines.push(`  hooks       ${names(capabilities.hookEvents).join(", ") || "(none)"}`);
+  lines.push(`  skills      ${names(capabilities.skills).join(", ") || "(none)"}`);
+  lines.push(`  prompts     ${names(capabilities.prompts).join(", ") || "(none)"}`);
+  const model = typeof capabilities.model === "string" ? capabilities.model : "(unknown)";
+  const thinking = typeof capabilities.thinkingLevel === "string" ? capabilities.thinkingLevel : "";
+  lines.push(`  model       ${model}${thinking ? ` \xB7 ${thinking}` : ""}`);
+  if (typeof capabilities.cwd === "string" && capabilities.cwd)
+    lines.push(`  cwd         ${capabilities.cwd}`);
+  lines.push("  (drone commands are in your palette \xB7 /worker toggles this panel)");
+  return lines;
+}
+function registerOperatorConsoleCommands(pi, state, tryRegister) {
+  if (typeof pi.registerCommand !== "function")
+    return;
+  let capabilitiesShown = false;
+  tryRegister("command:detach", () => pi.registerCommand?.("detach", {
+    description: "Detach from this run; the drone keeps flying",
+    handler: async (_args, ctx) => {
+      notify(ctx, "Detached. The drone continues on the worker.");
+      shutdownPi(ctx);
+    }
+  }));
+  tryRegister("command:stop", () => pi.registerCommand?.("stop", {
+    description: "Abort the drone's current turn and detach",
+    handler: async (_args, ctx) => {
+      try {
+        await state.client.workerAbort(state.runId);
+        notify(ctx, "Abort requested; detaching.");
+      } catch (error) {
+        notify(ctx, `Abort failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+      }
+      shutdownPi(ctx);
+    }
+  }));
+  tryRegister("command:worker", () => pi.registerCommand?.("worker", {
+    description: "Toggle the drone's capability panel (tools, extensions, hooks, skills, model)",
+    handler: async (_args, ctx) => {
+      if (capabilitiesShown) {
+        const ui = uiOf(ctx);
+        if (ui && typeof ui.setWidget === "function")
+          ui.setWidget("rig-worker-capabilities", undefined);
+        capabilitiesShown = false;
+        return;
+      }
+      try {
+        const capabilities = await state.client.workerCapabilities(state.runId);
+        setWidget(ctx, "rig-worker-capabilities", renderWorkerCapabilities(capabilities));
+        capabilitiesShown = true;
+      } catch (error) {
+        notify(ctx, `Drone capabilities unavailable: ${error instanceof Error ? error.message : String(error)}`, "error");
+      }
+    }
+  }));
+}
+function startWorkerSessionMirror(pi, state, ctx) {
+  if (!state.operatorSession || !state.active || !state.runId)
+    return;
+  let mirror = null;
+  const pendingEvents = [];
+  createLiveMirror({ pi }).then((created) => {
+    mirror = created;
+    const ui = uiOf(ctx);
+    if (ui && typeof ui.setWidget === "function") {
+      ui.setWidget("rig-tui-capture", (tui) => created.captureTui(tui));
+    }
+    for (const event of pendingEvents.splice(0))
+      created.handleWorkerEvent(event);
+  }).catch((error) => {
+    notify(ctx, `Live drone transcript unavailable: ${error instanceof Error ? error.message : String(error)}`, "error");
+  });
+  const socket = new RigWorkerEventsSocket({
+    context: state,
+    webSocketFactory: state.webSocketFactory,
+    handlers: {
+      onFrame: (frame) => {
+        if (frame.type === "status.update") {
+          const status = frame.status && typeof frame.status === "object" && !Array.isArray(frame.status) ? frame.status : null;
+          if (status)
+            setStatus(ctx, "rig-worker", workerStatusLine(status));
+          return;
+        }
+        if (frame.type !== "pi.event")
+          return;
+        const event = frame.event && typeof frame.event === "object" && !Array.isArray(frame.event) ? frame.event : null;
+        if (!event)
+          return;
+        if (event.type === "extension_ui_request") {
+          forwardWorkerUiRequest(state, ctx, event);
+          return;
+        }
+        if (mirror)
+          mirror.handleWorkerEvent(event);
+        else
+          pendingEvents.push(event);
+      },
+      onConnect: () => {
+        setStatus(ctx, "rig-worker", "drone link live");
+      },
+      onDisconnect: () => {
+        setStatus(ctx, "rig-worker", "drone link down (reconnecting\u2026)");
+      }
+    }
+  });
+  socket.start();
+}
+async function forwardWorkerUiRequest(state, ctx, event) {
+  const request = event.request && typeof event.request === "object" && !Array.isArray(event.request) ? event.request : event;
+  const requestId = String(request.requestId ?? request.id ?? `ui-${state.runId}-${event.timestamp ?? ""}`);
+  const method = String(request.method ?? request.type ?? "input");
+  const prompt = typeof request.prompt === "string" && request.prompt.trim() ? request.prompt : typeof request.message === "string" && request.message.trim() ? request.message : typeof request.title === "string" && request.title.trim() ? request.title : method;
+  const rawChoices = Array.isArray(request.options) ? request.options : Array.isArray(request.items) ? request.items : [];
+  const choices = rawChoices.map((option) => {
+    if (typeof option === "string")
+      return option;
+    if (option && typeof option === "object" && !Array.isArray(option)) {
+      const record = option;
+      return String(record.label ?? record.value ?? record.name ?? "");
+    }
+    return "";
+  }).filter(Boolean);
+  const answer = await askNativeDialog(ctx, { method, prompt, choices });
+  if (!answer)
+    return;
+  try {
+    await state.client.workerRespondExtensionUi(requestId, answer, state.runId);
+  } catch (error) {
+    notify(ctx, `Failed to answer the drone's question: ${error instanceof Error ? error.message : String(error)}`, "error");
+  }
+}
+async function registerWorkerCommands(pi, state, ctx, registeredNames = new Set) {
+  if (!state.operatorSession || !state.active || !state.runId)
+    return false;
+  if (typeof pi.registerCommand !== "function")
+    return false;
+  let commands = [];
+  try {
+    commands = await state.client.workerCommands(state.runId);
+  } catch {
+    return false;
+  }
+  let registered = 0;
+  for (const command of commands) {
+    const name = typeof command.name === "string" && command.name.trim() ? command.name.trim() : null;
+    if (!name || name === "rig" || registeredNames.has(name))
+      continue;
+    const description = typeof command.description === "string" && command.description.trim() ? `[worker] ${command.description.trim()}` : "[worker] remote session command";
+    try {
+      pi.registerCommand(name, {
+        description,
+        handler: async (args, commandCtx) => {
+          try {
+            await state.client.workerRunCommand(name, args, state.runId);
+            notify(commandCtx, `Sent /${name} to the worker session.`);
+          } catch (error) {
+            notify(commandCtx, `Worker /${name} failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+          }
+        }
+      });
+      registeredNames.add(name);
+      registered += 1;
+    } catch {
+      registeredNames.add(name);
+    }
+  }
+  if (registered > 0) {
+    notify(ctx, `Worker session commands available: ${registered} registered from the run's Pi session.`);
+  }
+  return true;
+}
+function startWorkerCommandRegistration(pi, state, ctx) {
+  const registeredNames = new Set;
+  let attempts = 0;
+  let inFlight = false;
+  const attempt = async () => {
+    if (inFlight)
+      return false;
+    inFlight = true;
+    attempts += 1;
+    try {
+      return await registerWorkerCommands(pi, state, ctx, registeredNames);
+    } finally {
+      inFlight = false;
+    }
+  };
+  attempt().then((ready) => {
+    if (ready)
+      return;
+    const timer = setInterval(() => {
+      if (attempts >= 60) {
+        clearInterval(timer);
+        return;
+      }
+      attempt().then((nextReady) => {
+        if (nextReady)
+          clearInterval(timer);
+      });
+    }, 2000);
+    unrefTimer(timer);
+  });
+}
+function startSteeringBridge(pi, state, ctx, gate, deliveredIds) {
+  if (state.operatorSession || !state.active || !state.runId || typeof pi.sendUserMessage !== "function")
     return;
+  const runId = state.runId;
+  const socket = new RigBridgeSocket({
+    context: state,
+    webSocketFactory: state.webSocketFactory,
+    handlers: {
+      onSteeringMessage: (message) => {
+        (async () => {
+          try {
+            if (!await deliverSteeringMessage(pi, deliveredIds, message))
+              return;
+            const id = typeof message.id === "string" && message.id.trim() ? message.id : null;
+            if (id)
+              socket.ackSteering(runId, [id]);
+            notify(ctx, "Delivered 1 Rig steering message.");
+          } catch (error) {
+            notify(ctx, `Rig steering sync failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+          }
+        })();
+      },
+      onConnect: () => {
+        consumeQueuedSteering(pi, state, ctx, gate, deliveredIds);
+      }
+    }
+  });
+  (async () => {
+    const gateResult = await gate(ctx);
+    if (!gateResult.allowed)
+      return;
+    if (gateResult.status === "compatible") {
+      socket.start();
+    }
+  })();
   const intervalMs = state.steeringPollMs ?? 1000;
   if (intervalMs <= 0)
     return;
+  const WS_CONNECTED_SWEEP_MS = 1e4;
   let inFlight = false;
+  let lastSweepAt = 0;
   const timer = setInterval(() => {
     if (inFlight)
       return;
+    if (socket.connected && Date.now() - lastSweepAt < WS_CONNECTED_SWEEP_MS)
+      return;
     inFlight = true;
-    consumeQueuedSteering(pi, state, ctx).finally(() => {
+    lastSweepAt = Date.now();
+    consumeQueuedSteering(pi, state, ctx, gate, deliveredIds).finally(() => {
       inFlight = false;
     });
   }, intervalMs);
-  if (typeof timer.unref === "function") {
-    timer.unref();
-  }
+  unrefTimer(timer);
 }
 function createPiRigExtension(pi, options = {}) {
   const state = options.state ?? createPiRigExtensionState();
+  const gate = createBridgeGate(state);
+  const deliveredSteeringIds = new Set;
   const commands = createRigSlashCommands({
     context: state,
     client: state.client,
     notify: (message, level) => notify(globalThis, message, level)
   });
+  const tryRegister = (label, register) => {
+    try {
+      register();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (/conflict|already|duplicate/i.test(message))
+        return;
+      throw error;
+    }
+  };
   for (const [name, command] of Object.entries(commands)) {
-    pi.registerCommand?.(name, {
+    tryRegister(`command:${name}`, () => pi.registerCommand?.(name, {
       description: command.description,
       handler: async (args, ctx) => {
+        const gateResult = await gate(ctx);
+        if (!gateResult.allowed) {
+          notify(ctx, gateResult.message ?? "Rig bridge disabled (protocol mismatch).", "error");
+          return;
+        }
         const nextCommands = createRigSlashCommands({
           context: state,
           client: state.client,
@@ -381,26 +1612,53 @@ function createPiRigExtension(pi, options = {}) {
         });
         await nextCommands.rig.handler(args, ctx);
       }
-    });
+    }));
+  }
+  if (state.operatorSession && state.active && state.runId) {
+    registerOperatorConsoleCommands(pi, state, tryRegister);
   }
   if (state.active && state.runId) {
     for (const tool of createRigTools({ context: state, client: state.client })) {
-      pi.registerTool?.(tool);
+      tryRegister(`tool:${String(tool.name ?? "rig-tool")}`, () => pi.registerTool?.({
+        ...tool,
+        execute: async (toolCallId, params) => {
+          const gateResult = await gate(globalThis);
+          if (!gateResult.allowed) {
+            return { content: [{ type: "text", text: gateResult.message ?? "Rig bridge disabled (protocol mismatch)." }], isError: true };
+          }
+          return tool.execute(toolCallId, params);
+        }
+      }));
     }
-    startLiveSteeringPoll(pi, state, globalThis);
+    startSteeringBridge(pi, state, globalThis, gate, deliveredSteeringIds);
   }
+  pi.on?.("input", async (event, ctx) => handleOperatorInput(event, state, ctx, gate));
   pi.on?.("session_start", async (_event, ctx) => {
     if (!state.active || !state.runId)
       return;
-    const ui = ctx && typeof ctx === "object" ? ctx.ui : null;
-    const setStatus = ui && typeof ui === "object" ? ui.setStatus : null;
-    if (typeof setStatus === "function") {
-      setStatus.call(ui, "rig", `Rig ${state.runId}`);
+    const shortId = state.runId.slice(0, 8);
+    setStatus(ctx, "rig", `drone ${shortId} \xB7 waiting for worker daemon\u2026`);
+    if (state.operatorSession) {
+      setTitle(ctx, `Rig \xB7 run ${shortId}`);
+      applyRigTheme(ctx);
+      applyDroneWorkingIndicator(ctx);
+    }
+    const gateResult = await gate(ctx);
+    if (!gateResult.allowed) {
+      setStatus(ctx, "rig", `drone ${shortId} \xB7 bridge disabled (protocol mismatch)`);
+      return;
+    }
+    setStatus(ctx, "rig", `drone ${shortId} \xB7 connecting\u2026`);
+    const live = gateResult.status === "compatible" ? startOperatorBridge(state, ctx) : undefined;
+    startOperatorRunStatusLine(state, ctx, live);
+    if (state.operatorSession && gateResult.status === "compatible") {
+      startWorkerSessionMirror(pi, state, ctx);
+      startWorkerCommandRegistration(pi, state, ctx);
     }
-    await consumeQueuedSteering(pi, state, ctx);
+    await consumeQueuedSteering(pi, state, ctx, gate, deliveredSteeringIds);
   });
   pi.on?.("turn_end", async (_event, ctx) => {
-    await consumeQueuedSteering(pi, state, ctx);
+    await consumeQueuedSteering(pi, state, ctx, gate, deliveredSteeringIds);
   });
 }
 export {