@tritard/waterbrother 0.16.78 → 0.16.80

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tritard/waterbrother",
-  "version": "0.16.78",
+  "version": "0.16.80",
   "description": "Waterbrother: bring-your-own-model coding CLI with local tools, sessions, operator modes, and approval controls",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -3107,23 +3107,49 @@ async function clearTelegramBridgeHost() {
 async function dequeueTelegramBridgeRequest({ cwd }) {
   const bridge = await loadGatewayBridge(TELEGRAM_BRIDGE_SERVICE);
   const activeHost = bridge.activeHost || {};
-  if (Number(activeHost.pid || 0) !== process.pid) {
-    return null;
-  }
-  if (activeHost.cwd && String(activeHost.cwd) !== String(cwd || "")) {
-    return null;
-  }
+  const currentHost = Number(activeHost.pid || 0) === process.pid
+    ? activeHost
+    : (Array.isArray(bridge.hosts) ? bridge.hosts.find((host) => Number(host?.pid || 0) === process.pid) : null) || {};
   const pending = Array.isArray(bridge.pendingRequests) ? bridge.pendingRequests : [];
   if (!pending.length) {
     return null;
   }
-  const [next, ...rest] = pending;
+  const nextIndex = pending.findIndex((request) => {
+    const targetPid = Number(request?.targetPid || 0);
+    const targetSessionId = String(request?.targetSessionId || "").trim();
+    if (targetPid > 0 && targetPid !== process.pid) {
+      return false;
+    }
+    if (targetSessionId && targetSessionId !== String(currentHost.sessionId || "").trim()) {
+      return false;
+    }
+    if (currentHost.cwd && String(currentHost.cwd) !== String(cwd || "")) {
+      return false;
+    }
+    return true;
+  });
+  if (nextIndex < 0) {
+    return null;
+  }
+  const next = pending[nextIndex];
+  const rest = pending.filter((_, index) => index !== nextIndex);
   bridge.pendingRequests = rest;
-  bridge.activeHost = {
-    ...activeHost,
-    updatedAt: new Date().toISOString()
-  };
-  bridge.hosts = upsertTelegramBridgeHostEntry(bridge.hosts, bridge.activeHost);
+  if (Number(currentHost.pid || 0) === process.pid) {
+    const updatedHost = {
+      ...currentHost,
+      updatedAt: new Date().toISOString()
+    };
+    if (Number(activeHost.pid || 0) === process.pid) {
+      bridge.activeHost = updatedHost;
+    }
+    bridge.hosts = upsertTelegramBridgeHostEntry(bridge.hosts, updatedHost);
+  } else if (Number(activeHost.pid || 0) === process.pid) {
+    bridge.activeHost = {
+      ...activeHost,
+      updatedAt: new Date().toISOString()
+    };
+    bridge.hosts = upsertTelegramBridgeHostEntry(bridge.hosts, bridge.activeHost);
+  }
   await saveGatewayBridge(TELEGRAM_BRIDGE_SERVICE, bridge);
   return next;
 }

package/src/gateway-state.js

@@ -54,6 +54,9 @@ function normalizeBridgeRequest(parsed = {}) {
     sessionId: String(parsed?.sessionId || "").trim(),
     text: String(parsed?.text || "").trim(),
     explicitExecution: parsed?.explicitExecution === true,
+    targetPid: Number.isFinite(Number(parsed?.targetPid)) ? Math.floor(Number(parsed.targetPid)) : 0,
+    targetSessionId: String(parsed?.targetSessionId || "").trim(),
+    targetOwnerId: String(parsed?.targetOwnerId || "").trim(),
     runtimeProfile: String(parsed?.runtimeProfile || "").trim(),
     replyToMessageId: Number.isFinite(Number(parsed?.replyToMessageId)) ? Math.floor(Number(parsed.replyToMessageId)) : 0,
     requestedAt: String(parsed?.requestedAt || "").trim(),

package/src/gateway.js

@@ -473,6 +473,16 @@ function formatBridgeHostLabel(host = {}) {
   return [owner || label, label && label !== owner ? `(${label})` : "", runtime ? `[${runtime}]` : ""].filter(Boolean).join(" ").trim();
 }
 
+function findLiveHostForAgent(hosts = [], agent = {}) {
+  const ownerId = String(agent?.ownerId || "").trim();
+  const sessionId = String(agent?.sessionId || "").trim();
+  return (Array.isArray(hosts) ? hosts : []).find((host) => {
+    const hostOwnerId = String(host?.ownerId || "").trim();
+    const hostSessionId = String(host?.sessionId || "").trim();
+    return (ownerId && hostOwnerId === ownerId) || (sessionId && hostSessionId === sessionId);
+  }) || null;
+}
+
 function getLatestBlockingReviewPolicy(project) {
   const events = Array.isArray(project?.recentEvents) ? [...project.recentEvents] : [];
   const ordered = events
@@ -1890,6 +1900,44 @@ class TelegramGateway {
       const actorId = String(message?.from?.id || "").trim();
       const actorName = peer?.username || [message?.from?.first_name, message?.from?.last_name].filter(Boolean).join(" ").trim() || actorId;
       const session = await loadSession(sessionId);
+      if (/\bsend to reviewer\b/.test(reply) || /\breviewer\b/.test(reply) || /\bsend review\b/.test(reply)) {
+        const targetHost = continuation.context?.reviewerHost && typeof continuation.context.reviewerHost === "object"
+          ? continuation.context.reviewerHost
+          : null;
+        if (!targetHost?.pid) {
+          return {
+            markup: "The assigned reviewer is not live right now. Reply with <code>override</code> or <code>reviewed</code> instead.",
+            remember: {
+              text: String(continuation.lastPrompt || "").trim() || "Reply with override or reviewed.",
+              kind: continuation.kind,
+              source: continuation.source,
+              context: continuation.context || {},
+              force: true
+            }
+          };
+        }
+        const reviewPrompt = String(continuation.context?.reviewPrompt || "").trim();
+        await addSharedRoomNote(session.cwd || this.cwd, `${continuation.context?.ownerName || "Assigned"} blocking review dispatched to reviewer terminal`, {
+          actorId,
+          actorName,
+          type: "review-policy-dispatched",
+          meta: {
+            agentId: String(continuation.context?.agentId || "").trim(),
+            reviewerPid: Number(targetHost.pid || 0)
+          }
+        });
+        const content = await this.runPromptViaBridge(message, sessionId, reviewPrompt, {
+          explicitExecution: true,
+          targetHost
+        });
+        return {
+          markup: [
+            "<b>Reviewer response</b>",
+            `reviewer: <code>${escapeTelegramHtml(continuation.context?.ownerName || "unknown")}</code>`,
+            renderTelegramChunks(content || "(no content)").join("\n\n")
+          ].join("\n\n")
+        };
+      }
       if (/\boverride\b/.test(reply)) {
         await addSharedRoomNote(session.cwd || this.cwd, `${continuation.context?.ownerName || "Assigned"} blocking review overridden for now`, {
           actorId,
@@ -1925,7 +1973,7 @@ class TelegramGateway {
         };
       }
       return {
-        markup: "Reply with <code>override</code> to proceed anyway, or <code>reviewed</code> after the blocking review is complete.",
+        markup: "Reply with <code>send to reviewer</code>, <code>override</code>, or <code>reviewed</code> after the blocking review is complete.",
         remember: {
           text: String(continuation.lastPrompt || "").trim() || "Reply with override or reviewed.",
           kind: continuation.kind,
@@ -2631,7 +2679,7 @@ class TelegramGateway {
   }
 
   async runPromptViaBridge(message, sessionId, promptText, options = {}) {
-    const host = await this.getLiveBridgeHost();
+    const host = options.targetHost || await this.getLiveBridgeHost();
     if (!host) {
       return null;
     }
@@ -2650,6 +2698,9 @@ class TelegramGateway {
       sessionId: String(sessionId || "").trim(),
       text: String(promptText || "").trim(),
       explicitExecution: options.explicitExecution === true,
+      targetPid: Number(host?.pid || 0),
+      targetSessionId: String(host?.sessionId || "").trim(),
+      targetOwnerId: String(host?.ownerId || "").trim(),
       runtimeProfile: String(project?.runtimeProfile || "").trim(),
       replyToMessageId: message.message_id,
       requestedAt: new Date().toISOString(),
@@ -2678,7 +2729,11 @@ class TelegramGateway {
       }
 
       const activeHost = nextBridge.activeHost || {};
-      if (Number(activeHost.pid || 0) <= 0) {
+      const knownHosts = Array.isArray(nextBridge.hosts) ? nextBridge.hosts : [];
+      if (Number(host?.pid || 0) > 0 && !knownHosts.some((item) => Number(item?.pid || 0) === Number(host.pid || 0))) {
+        break;
+      }
+      if (Number(activeHost.pid || 0) <= 0 && !(Number(host?.pid || 0) > 0)) {
         break;
       }
     }
@@ -3797,12 +3852,26 @@ Ask them to run <code>/whoami</code> and then <code>/accept-invite ${escapeTeleg
       if (blockingReview) {
         const meta = blockingReview.meta && typeof blockingReview.meta === "object" ? blockingReview.meta : {};
         const reviewerName = String(meta.ownerName || meta.agentId || "assigned reviewer").trim();
-        const followUp = `Blocking review is assigned to ${reviewerName}. Reply with override to proceed anyway, or reviewed when the review is done.`;
+        const reviewerAgent = listProjectAgents(operatorGate.project).find((agent) => String(agent?.id || "").trim() === String(meta.agentId || "").trim()) || null;
+        const liveHosts = await this.getLiveBridgeHosts({ cwd: operatorGate.session?.cwd || this.cwd });
+        const reviewerHost = reviewerAgent ? findLiveHostForAgent(liveHosts, reviewerAgent) : null;
+        const reviewPrompt = [
+          `Review this pending Telegram Roundtable request before execution.`,
+          `Requester: ${this.describeTelegramUser(message?.from || {}).displayName || userId}`,
+          `Project: ${operatorGate.project.projectName || path.basename(operatorGate.session?.cwd || this.cwd)}`,
+          "",
+          `Pending request:`,
+          promptText
+        ].join("\n");
+        const followUp = reviewerHost
+          ? `Blocking review is assigned to ${reviewerName}. Reply with send to reviewer to route it there, override to proceed anyway, or reviewed when the review is done.`
+          : `Blocking review is assigned to ${reviewerName}. Reply with override to proceed anyway, or reviewed when the review is done.`;
         await this.sendMarkup(
           message.chat.id,
           [
             "<b>Blocking review in effect</b>",
             `reviewer: <code>${escapeTelegramHtml(reviewerName)}</code>`,
+            reviewerHost ? `reviewer terminal: <code>${escapeTelegramHtml(formatBridgeHostLabel(reviewerHost) || reviewerHost.sessionId || "live terminal")}</code>` : "",
             "Execution is paused until the blocking review is cleared or overridden.",
             followUp
           ].join("\n"),
@@ -3813,12 +3882,27 @@ Ask them to run <code>/whoami</code> and then <code>/accept-invite ${escapeTeleg
           source: "review-policy-gate",
           context: {
             agentId: String(meta.agentId || "").trim(),
-            ownerName: reviewerName
+            ownerName: reviewerName,
+            reviewPrompt,
+            reviewerHost: reviewerHost
+              ? {
+                  pid: Number(reviewerHost.pid || 0),
+                  sessionId: String(reviewerHost.sessionId || "").trim(),
+                  ownerId: String(reviewerHost.ownerId || "").trim(),
+                  ownerName: String(reviewerHost.ownerName || "").trim(),
+                  label: String(reviewerHost.label || "").trim(),
+                  surface: String(reviewerHost.surface || "").trim(),
+                  provider: String(reviewerHost.provider || "").trim(),
+                  model: String(reviewerHost.model || "").trim(),
+                  runtimeProfile: String(reviewerHost.runtimeProfile || "").trim()
+                }
+              : null
           },
           force: true
         });
         return;
       }
+      const liveHosts = await this.getLiveBridgeHosts({ cwd: operatorGate.session?.cwd || this.cwd });
       const host = await this.getLiveBridgeHost();
       const activeExecutor = {
         surface: host?.surface || (host ? "live-tui" : "telegram-fallback"),
@@ -3831,10 +3915,12 @@ Ask them to run <code>/whoami</code> and then <code>/accept-invite ${escapeTeleg
         label: host?.label || ""
       };
       const selectedExecutor = chooseExecutorAgent(operatorGate.project, activeExecutor);
+      const selectedLiveHost = selectedExecutor ? findLiveHostForAgent(liveHosts, selectedExecutor) : null;
       if (
         selectedExecutor?.ownerId
         && activeExecutor.ownerId
         && String(selectedExecutor.ownerId).trim() !== String(activeExecutor.ownerId).trim()
+        && !selectedLiveHost
       ) {
         const selectedName = String(selectedExecutor.ownerName || selectedExecutor.label || selectedExecutor.ownerId || "selected executor").trim();
         const currentName = String(activeExecutor.ownerName || activeExecutor.label || activeExecutor.ownerId || "current terminal").trim();
@@ -3871,7 +3957,10 @@ Ask them to run <code>/whoami</code> and then <code>/accept-invite ${escapeTeleg
         return;
       }
       previewMessage = await this.sendProgressMessage(message.chat.id, message.message_id);
-      const content = (await this.runPromptViaBridge(message, sessionId, promptText, { explicitExecution: shouldExecutePrompt }))
+      const content = (await this.runPromptViaBridge(message, sessionId, promptText, {
+        explicitExecution: shouldExecutePrompt,
+        targetHost: selectedLiveHost || host || null
+      }))
         ?? (await this.runPromptFallback(sessionId, promptText));
       await this.deliverPromptResult(message.chat.id, message.message_id, previewMessage, content);
       await this.rememberContinuation(message, content);