@h-rig/pi-rig 0.0.6-alpha.63 → 0.0.6-alpha.65

package/dist/src/client.js

@@ -3,6 +3,7 @@
 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;
 }
@@ -138,6 +139,30 @@ class RigBridgeClient {
     const payload = await this.request("/api/server/status");
     return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
   }
+  async checkProtocolCompatibility() {
+    let payload;
+    try {
+      payload = await this.status();
+    } 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))) : [];
@@ -225,7 +250,179 @@ class RigBridgeClient {
     return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
   }
 }
+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?.();
+    }
+  }
+}
 export {
   createRigContextFromEnv,
-  RigBridgeClient
+  buildRigWebSocketUrl,
+  RigBridgeSocket,
+  RigBridgeClient,
+  RIG_PROTOCOL_VERSION
 };

package/dist/src/index.js

@@ -3,6 +3,7 @@
 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;
 }
@@ -138,6 +139,30 @@ class RigBridgeClient {
     const payload = await this.request("/api/server/status");
     return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
   }
+  async checkProtocolCompatibility() {
+    let payload;
+    try {
+      payload = await this.status();
+    } 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))) : [];
@@ -225,6 +250,175 @@ class RigBridgeClient {
     return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
   }
 }
+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?.();
+    }
+  }
+}
 
 // packages/pi-rig/src/commands.ts
 function runRecordFromPayload(payload) {
@@ -364,7 +558,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") {
@@ -374,6 +569,10 @@ 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;
@@ -403,6 +602,25 @@ function setFooter(ctx, line) {
     invalidate() {}
   }));
 }
+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();
+    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)
@@ -411,19 +629,48 @@ function steeringText(message) {
   return `[Rig steering from ${actor}]
 ${text}`;
 }
-async function consumeQueuedSteering(pi, state, ctx) {
+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");
@@ -435,12 +682,14 @@ function inputText(event) {
   const text = event.text;
   return typeof text === "string" && text.trim() ? text.trim() : null;
 }
-async function handleOperatorInput(event, state, ctx) {
+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;
   try {
     await state.client.steer(text, state.runId);
     notify(ctx, "Rig steering message queued.");
@@ -463,15 +712,18 @@ function runLocation(run) {
 function runPayload(payload) {
   return payload.run && typeof payload.run === "object" && !Array.isArray(payload.run) ? payload.run : payload;
 }
-function startOperatorRunWidget(state, ctx) {
+var OPERATOR_WIDGET_WS_FALLBACK_MS = 1e4;
+function startOperatorRunWidget(state, ctx, live) {
   if (!state.operatorSession || !state.active || !state.runId)
     return;
   let inFlight = false;
   let frame = 0;
+  let lastRefreshAt = 0;
   const refresh = async () => {
     if (inFlight)
       return;
     inFlight = true;
+    lastRefreshAt = Date.now();
     const spinner = SPINNER_FRAMES[frame++ % SPINNER_FRAMES.length] ?? "\u2022";
     try {
       const [runPayloadRecord, timeline] = await Promise.all([
@@ -502,32 +754,127 @@ function startOperatorRunWidget(state, ctx) {
     }
   };
   refresh();
-  const timer = setInterval(() => void refresh(), 1000);
-  if (typeof timer.unref === "function") {
-    timer.unref();
-  }
+  const timer = setInterval(() => {
+    const triggered = live?.consumePushTrigger() ?? false;
+    if ((live?.isConnected() ?? false) && !triggered && Date.now() - lastRefreshAt < OPERATOR_WIDGET_WS_FALLBACK_MS) {
+      return;
+    }
+    refresh();
+  }, 1000);
+  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 startLiveSteeringPoll(pi, state, ctx) {
+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 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,
@@ -537,6 +884,11 @@ function createPiRigExtension(pi, options = {}) {
     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,
@@ -548,20 +900,33 @@ function createPiRigExtension(pi, options = {}) {
   }
   if (state.active && state.runId) {
     for (const tool of createRigTools({ context: state, client: state.client })) {
-      pi.registerTool?.(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));
+  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 gateResult = await gate(ctx);
+    if (!gateResult.allowed)
+      return;
     setStatus(ctx, "rig", `Rig ${state.runId}`);
-    startOperatorRunWidget(state, ctx);
-    await consumeQueuedSteering(pi, state, ctx);
+    const live = gateResult.status === "compatible" ? startOperatorBridge(state, ctx) : undefined;
+    startOperatorRunWidget(state, ctx, live);
+    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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h-rig/pi-rig",
-  "version": "0.0.6-alpha.63",
+  "version": "0.0.6-alpha.65",
   "type": "module",
   "description": "Rig package",
   "license": "UNLICENSED",
@@ -32,8 +32,11 @@
       "./dist/src/index.js"
     ]
   },
+  "dependencies": {
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.65"
+  },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "npm:@h-rig/pi-coding-agent@0.0.6-alpha.63",
+    "@earendil-works/pi-coding-agent": ">=0.79.0",
     "typebox": "*"
   }
 }