@tritard/waterbrother 0.16.74 → 0.16.76

package/package.json

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

package/src/gateway.js

@@ -419,6 +419,28 @@ function chooseExecutorAgent(project, fallbackExecutor = {}) {
   return null;
 }
 
+function getLatestBlockingReviewPolicy(project) {
+  const events = Array.isArray(project?.recentEvents) ? [...project.recentEvents] : [];
+  const ordered = events
+    .filter((event) => event?.createdAt)
+    .sort((a, b) => String(b.createdAt || "").localeCompare(String(a.createdAt || "")));
+  const resolvedAgents = new Set();
+  for (const event of ordered) {
+    const type = String(event?.type || "").trim();
+    const meta = event?.meta && typeof event.meta === "object" ? event.meta : {};
+    const agentId = String(meta.agentId || "").trim();
+    if (!agentId) continue;
+    if (type === "review-policy-cleared" || type === "review-policy-override") {
+      resolvedAgents.add(agentId);
+      continue;
+    }
+    if (type === "review-policy" && String(meta.policy || "").trim() === "blocking" && !resolvedAgents.has(agentId)) {
+      return event;
+    }
+  }
+  return null;
+}
+
 function memberRoleWeight(role = "") {
   const normalized = String(role || "").trim().toLowerCase();
   if (normalized === "owner") return 3;
@@ -1778,6 +1800,124 @@ class TelegramGateway {
         ].join("\n")
       };
     }
+    if (continuation.kind === "blocking-review-override") {
+      const reply = this.stripBotMention(String(message?.text || "").trim()).toLowerCase();
+      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 (/\boverride\b/.test(reply)) {
+        await addSharedRoomNote(session.cwd || this.cwd, `${continuation.context?.ownerName || "Assigned"} blocking review overridden for now`, {
+          actorId,
+          actorName,
+          type: "review-policy-override",
+          meta: {
+            agentId: String(continuation.context?.agentId || "").trim()
+          }
+        });
+        return {
+          markup: [
+            "<b>Blocking review overridden</b>",
+            `reviewer: <code>${escapeTelegramHtml(continuation.context?.ownerName || "unknown")}</code>`,
+            "Execution can proceed for now."
+          ].join("\n")
+        };
+      }
+      if (/\breviewed\b/.test(reply) || /\bdone\b/.test(reply) || /\bcomplete\b/.test(reply)) {
+        await addSharedRoomNote(session.cwd || this.cwd, `${continuation.context?.ownerName || "Assigned"} blocking review marked complete`, {
+          actorId,
+          actorName,
+          type: "review-policy-cleared",
+          meta: {
+            agentId: String(continuation.context?.agentId || "").trim()
+          }
+        });
+        return {
+          markup: [
+            "<b>Blocking review cleared</b>",
+            `reviewer: <code>${escapeTelegramHtml(continuation.context?.ownerName || "unknown")}</code>`,
+            "Execution can proceed."
+          ].join("\n")
+        };
+      }
+      return {
+        markup: "Reply with <code>override</code> to proceed anyway, or <code>reviewed</code> after the blocking review is complete.",
+        remember: {
+          text: String(continuation.lastPrompt || "").trim() || "Reply with override or reviewed.",
+          kind: continuation.kind,
+          source: continuation.source,
+          context: continuation.context || {},
+          force: true
+        }
+      };
+    }
+    if (continuation.kind === "executor-handoff-override") {
+      const reply = this.stripBotMention(String(message?.text || "").trim()).toLowerCase();
+      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 (/\boverride\b/.test(reply)) {
+        await addSharedRoomNote(session.cwd || this.cwd, `${continuation.context?.selectedOwnerName || "Selected executor"} handoff overridden; current terminal may execute`, {
+          actorId,
+          actorName,
+          type: "executor-handoff-override",
+          meta: {
+            selectedAgentId: String(continuation.context?.selectedAgentId || "").trim(),
+            currentOwnerId: String(continuation.context?.currentOwnerId || "").trim()
+          }
+        });
+        return {
+          markup: [
+            "<b>Executor handoff overridden</b>",
+            `selected executor: <code>${escapeTelegramHtml(continuation.context?.selectedOwnerName || "unknown")}</code>`,
+            "Execution can proceed on the current terminal for now."
+          ].join("\n")
+        };
+      }
+      if (/\buse this terminal\b/.test(reply) || /\bthis terminal\b/.test(reply) || /\buse current\b/.test(reply)) {
+        await upsertSharedAgent(session.cwd || this.cwd, {
+          id: String(continuation.context?.currentAgentId || "").trim(),
+          ownerId: String(continuation.context?.currentOwnerId || "").trim(),
+          ownerName: String(continuation.context?.currentOwnerName || "").trim(),
+          label: String(continuation.context?.currentLabel || "").trim(),
+          surface: String(continuation.context?.currentSurface || "live-tui").trim(),
+          role: "executor",
+          provider: String(continuation.context?.currentProvider || "").trim(),
+          model: String(continuation.context?.currentModel || "").trim(),
+          runtimeProfile: String(continuation.context?.currentRuntimeProfile || "").trim(),
+          sessionId: String(continuation.context?.currentSessionId || "").trim(),
+          cwd: String(session.cwd || this.cwd).trim(),
+          chatId: String(message?.chat?.id || "").trim()
+        }, {
+          actorId,
+          actorName
+        });
+        await addSharedRoomNote(session.cwd || this.cwd, `${continuation.context?.currentOwnerName || "Current terminal"} is now the selected executor`, {
+          actorId,
+          actorName,
+          type: "executor-handoff-reassigned",
+          meta: {
+            currentAgentId: String(continuation.context?.currentAgentId || "").trim()
+          }
+        });
+        return {
+          markup: [
+            "<b>Executor reassigned</b>",
+            `executor: <code>${escapeTelegramHtml(continuation.context?.currentOwnerName || "current terminal")}</code>`,
+            "Execution can proceed on this terminal."
+          ].join("\n")
+        };
+      }
+      return {
+        markup: "Reply with <code>override</code> to proceed anyway, or <code>use this terminal</code> to make the current terminal the executor.",
+        remember: {
+          text: String(continuation.lastPrompt || "").trim() || "Reply with override or use this terminal.",
+          kind: continuation.kind,
+          source: continuation.source,
+          context: continuation.context || {},
+          force: true
+        }
+      };
+    }
     return null;
   }
 
@@ -3467,6 +3607,83 @@ Ask them to run <code>/whoami</code> and then <code>/accept-invite ${escapeTeleg
         await this.sendMessage(message.chat.id, escapeTelegramHtml(gateReason), message.message_id, { parseMode: "HTML" });
         return;
       }
+      const blockingReview = getLatestBlockingReviewPolicy(operatorGate.project);
+      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.`;
+        await this.sendMarkup(
+          message.chat.id,
+          [
+            "<b>Blocking review in effect</b>",
+            `reviewer: <code>${escapeTelegramHtml(reviewerName)}</code>`,
+            "Execution is paused until the blocking review is cleared or overridden.",
+            followUp
+          ].join("\n"),
+          message.message_id
+        );
+        await this.rememberContinuationWithOptions(message, followUp, {
+          kind: "blocking-review-override",
+          source: "review-policy-gate",
+          context: {
+            agentId: String(meta.agentId || "").trim(),
+            ownerName: reviewerName
+          },
+          force: true
+        });
+        return;
+      }
+      const host = await this.getLiveBridgeHost();
+      const activeExecutor = {
+        surface: host?.surface || (host ? "live-tui" : "telegram-fallback"),
+        provider: host?.provider || this.runtime.provider,
+        model: host?.model || this.runtime.model,
+        runtimeProfile: host?.runtimeProfile || operatorGate.project?.runtimeProfile || this.channel.defaultRuntimeProfile || this.gateway.defaultRuntimeProfile || "",
+        hostSessionId: host?.sessionId || "",
+        ownerId: host?.ownerId || "",
+        ownerName: host?.ownerName || "",
+        label: host?.label || ""
+      };
+      const selectedExecutor = chooseExecutorAgent(operatorGate.project, activeExecutor);
+      if (
+        selectedExecutor?.ownerId
+        && activeExecutor.ownerId
+        && String(selectedExecutor.ownerId).trim() !== String(activeExecutor.ownerId).trim()
+      ) {
+        const selectedName = String(selectedExecutor.ownerName || selectedExecutor.label || selectedExecutor.ownerId || "selected executor").trim();
+        const currentName = String(activeExecutor.ownerName || activeExecutor.label || activeExecutor.ownerId || "current terminal").trim();
+        const followUp = `Selected executor is ${selectedName}. Reply with override to proceed anyway, or use this terminal to make ${currentName} the executor.`;
+        await this.sendMarkup(
+          message.chat.id,
+          [
+            "<b>Executor handoff required</b>",
+            `selected executor: <code>${escapeTelegramHtml(selectedName)}</code>`,
+            `current terminal: <code>${escapeTelegramHtml(currentName)}</code>`,
+            "Execution is paused because this room selected a different terminal as executor.",
+            followUp
+          ].join("\n"),
+          message.message_id
+        );
+        await this.rememberContinuationWithOptions(message, followUp, {
+          kind: "executor-handoff-override",
+          source: "executor-handoff-gate",
+          context: {
+            selectedAgentId: String(selectedExecutor.id || "").trim(),
+            selectedOwnerName: selectedName,
+            currentAgentId: String(host?.sessionId ? `agent:telegram-bridge:${host.sessionId}` : "").trim(),
+            currentOwnerId: String(activeExecutor.ownerId || "").trim(),
+            currentOwnerName: currentName,
+            currentLabel: String(activeExecutor.label || "").trim(),
+            currentSurface: String(activeExecutor.surface || "").trim(),
+            currentProvider: String(activeExecutor.provider || "").trim(),
+            currentModel: String(activeExecutor.model || "").trim(),
+            currentRuntimeProfile: String(activeExecutor.runtimeProfile || "").trim(),
+            currentSessionId: String(activeExecutor.hostSessionId || "").trim()
+          },
+          force: true
+        });
+        return;
+      }
       previewMessage = await this.sendProgressMessage(message.chat.id, message.message_id);
       const content = (await this.runPromptViaBridge(message, sessionId, promptText, { explicitExecution: shouldExecutePrompt }))
         ?? (await this.runPromptFallback(sessionId, promptText));