@tritard/waterbrother 0.16.108 → 0.16.110

package/package.json

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

package/src/gateway.js

@@ -646,6 +646,36 @@ function getLatestReviewResult(project) {
   return ordered.find((event) => String(event?.type || "").trim() === "review-result") || null;
 }
 
+function getBlockingVerificationResult(project) {
+  if (String(project?.verificationMode || "manual").trim() !== "blocking") {
+    return null;
+  }
+  const latestResult = getLatestVerificationResult(project);
+  const latestId = String(latestResult?.id || "").trim();
+  const latestOutcome = String(latestResult?.outcome || "").trim().toLowerCase();
+  if (!latestId || !latestOutcome || latestOutcome === "passed") {
+    return null;
+  }
+  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 || "")));
+  for (const event of ordered) {
+    const type = String(event?.type || "").trim();
+    const meta = event?.meta && typeof event.meta === "object" ? event.meta : {};
+    if (String(meta.verificationResultId || "").trim() !== latestId) {
+      continue;
+    }
+    if (type === "verification-override") {
+      return null;
+    }
+    if (type === "verification-result") {
+      return latestResult;
+    }
+  }
+  return latestResult;
+}
+
 function memberRoleWeight(role = "") {
   const normalized = String(role || "").trim().toLowerCase();
   if (normalized === "owner") return 3;
@@ -862,7 +892,9 @@ function parseTelegramAgentIntent(text = "") {
     /^(?:have|make|set)\s+(.+?)['’]s\s+(?:bot|terminal)\s+(?:be|as|to)?\s*(?:the\s+)?(executor|reviewer|verifier|standby)\s*$/i,
     /^(?:have|make|set)\s+(.+?)\s+(?:bot|terminal)\s+(?:be|as|to)?\s*(?:the\s+)?(executor|reviewer|verifier|standby)\s*$/i,
     /^(.+?)['’]s\s+(?:bot|terminal)\s+should\s+(?:be\s+)?(?:the\s+)?(executor|reviewer|verifier|standby)\s*$/i,
-    /^(.+?)\s+(?:bot|terminal)\s+should\s+(?:be\s+)?(?:the\s+)?(executor|reviewer|verifier|standby)\s*$/i
+    /^(.+?)\s+(?:bot|terminal)\s+should\s+(?:be\s+)?(?:the\s+)?(executor|reviewer|verifier|standby)\s*$/i,
+    /^(?:have|make|set)\s+(.+?)\s+(?:be|as|to)?\s*(?:the\s+)?(executor|reviewer|verifier|standby)\s*$/i,
+    /^(.+?)\s+should\s+(?:be\s+)?(?:the\s+)?(executor|reviewer|verifier|standby)\s*$/i
   ];
   for (const pattern of patterns) {
     const match = value.match(pattern);
@@ -914,6 +946,12 @@ function parseTelegramStateIntent(text = "") {
   if (/^(?:run|start|do)\s+verification\b/.test(lower) || /^(?:verify)\b/.test(lower) || /\bshow latest verification result\b/.test(lower) || /\bdid verification pass\b/.test(lower)) {
     return { action: /\bshow latest verification result\b/.test(lower) || /\bdid verification pass\b/.test(lower) ? "verification-status" : "run-verification" };
   }
+  if (/\boverride verification\b/.test(lower)) {
+    return { action: "verification-override" };
+  }
+  if (/\bre-?run verification\b/.test(lower) || /\brun verification again\b/.test(lower) || /\bverify again\b/.test(lower)) {
+    return { action: "verification-rerun" };
+  }
   if (/\bverification mode\b/.test(lower)) {
     const modeMatch = lower.match(/\b(off|manual|auto|blocking)\b/);
     return modeMatch?.[1] ? { action: "verification-mode-set", mode: modeMatch[1] } : { action: "verification-mode-status" };
@@ -2433,6 +2471,29 @@ class TelegramGateway {
         }
       };
     }
+    if (continuation.kind === "blocking-verification-override") {
+      const reply = this.stripBotMention(String(message?.text || "").trim()).toLowerCase();
+      if (/\boverride verification\b/.test(reply) || /\boverride\b/.test(reply)) {
+        return {
+          markup: await this.handleStateIntent(message, sessionId, { action: "verification-override" })
+        };
+      }
+      if (/\bre-?run verification\b/.test(reply) || /\brerun\b/.test(reply) || /\bverify again\b/.test(reply)) {
+        return {
+          markup: await this.handleStateIntent(message, sessionId, { action: "verification-rerun" })
+        };
+      }
+      return {
+        markup: "Reply with <code>rerun verification</code> or <code>override verification</code>.",
+        remember: {
+          text: String(continuation.lastPrompt || "").trim() || "Reply with rerun verification or override verification.",
+          kind: continuation.kind,
+          source: continuation.source,
+          context: continuation.context || {},
+          force: true
+        }
+      };
+    }
     return null;
   }
 
@@ -2530,6 +2591,37 @@ class TelegramGateway {
       return formatVerificationResultMarkup(result, verifier);
     }
 
+    if (intent.action === "verification-override") {
+      if (!project?.enabled) {
+        return "This project is not shared.";
+      }
+      const blockingVerification = getBlockingVerificationResult(project);
+      if (!blockingVerification) {
+        return "<b>Verification override</b>\nNo blocking verification is active.";
+      }
+      await addSharedRoomNote(cwd, "Blocking verification overridden for now", {
+        actorId,
+        actorName,
+        type: "verification-override",
+        meta: {
+          verificationResultId: String(blockingVerification.id || "").trim(),
+          outcome: String(blockingVerification.outcome || "").trim()
+        }
+      });
+      return [
+        "<b>Verification overridden</b>",
+        `latest outcome: <code>${escapeTelegramHtml(String(blockingVerification.outcome || "failed"))}</code>`,
+        "Execution can proceed for now."
+      ].join("\n");
+    }
+
+    if (intent.action === "verification-rerun") {
+      if (!project?.enabled) {
+        return "This project is not shared.";
+      }
+      return this.handleStateIntent(message, sessionId, { action: "run-verification" });
+    }
+
     if (intent.action === "run-verification") {
       if (!project?.enabled) {
         return "This project is not shared.";
@@ -3544,7 +3636,10 @@ class TelegramGateway {
     const sourcePrefix = sourceHost
       ? `<b>Handled by</b>\n<code>${escapeTelegramHtml(formatBridgeHostLabel(sourceHost) || sourceHost.sessionId || "live terminal")}</code>\n\n`
       : "";
-    const chunks = renderTelegramChunks(`${sourcePrefix}${String(content || "")}`);
+    const contentChunks = renderTelegramChunks(String(content || ""));
+    const chunks = contentChunks.length
+      ? [sourcePrefix ? `${sourcePrefix}${contentChunks[0]}` : contentChunks[0], ...contentChunks.slice(1)]
+      : (sourcePrefix ? [sourcePrefix.trim()] : []);
     if (!chunks.length) {
       if (previewMessage?.message_id) {
         await this.editMessage(chatId, previewMessage.message_id, "(no content)");
@@ -4618,6 +4713,31 @@ Ask them to run <code>/whoami</code> and then <code>/accept-invite ${escapeTeleg
         });
         return;
       }
+      const blockingVerification = getBlockingVerificationResult(operatorGate.project);
+      if (blockingVerification) {
+        const followUp = "Reply with rerun verification to try again, or override verification to proceed anyway.";
+        await this.sendMarkup(
+          message.chat.id,
+          [
+            "<b>Blocking verification in effect</b>",
+            `latest outcome: <code>${escapeTelegramHtml(String(blockingVerification.outcome || "failed"))}</code>`,
+            blockingVerification.summary ? `summary: <code>${escapeTelegramHtml(String(blockingVerification.summary || ""))}</code>` : "",
+            "Execution is paused until verification passes or the room overrides it.",
+            followUp
+          ].filter(Boolean).join("\n"),
+          message.message_id
+        );
+        await this.rememberContinuationWithOptions(message, followUp, {
+          kind: "blocking-verification-override",
+          source: "verification-policy-gate",
+          context: {
+            verificationResultId: String(blockingVerification.id || "").trim(),
+            outcome: String(blockingVerification.outcome || "").trim()
+          },
+          force: true
+        });
+        return;
+      }
       const liveHosts = await this.getLiveBridgeHosts({ cwd: operatorGate.session?.cwd || this.cwd });
       const host = await this.getLiveBridgeHost();
       const activeExecutor = {
@@ -4684,6 +4804,39 @@ Ask them to run <code>/whoami</code> and then <code>/accept-invite ${escapeTeleg
         sourceHost: typeof result === "string" ? null : (result?.sourceHost || null)
       });
       await this.rememberContinuation(message, finalContent);
+      if (["auto", "blocking"].includes(String(operatorGate.project?.verificationMode || "manual").trim())) {
+        const verificationMarkup = await this.handleStateIntent(message, sessionId, { action: "run-verification" });
+        if (verificationMarkup) {
+          await this.sendMarkup(message.chat.id, verificationMarkup, message.message_id);
+        }
+        if (String(operatorGate.project?.verificationMode || "manual").trim() === "blocking") {
+          const nextProject = await loadSharedProject(operatorGate.session?.cwd || this.cwd);
+          const nextBlockingVerification = getBlockingVerificationResult(nextProject);
+          if (nextBlockingVerification) {
+            const followUp = "Reply with rerun verification to try again, or override verification to proceed anyway.";
+            await this.sendMarkup(
+              message.chat.id,
+              [
+                "<b>Blocking verification in effect</b>",
+                `latest outcome: <code>${escapeTelegramHtml(String(nextBlockingVerification.outcome || "failed"))}</code>`,
+                nextBlockingVerification.summary ? `summary: <code>${escapeTelegramHtml(String(nextBlockingVerification.summary || ""))}</code>` : "",
+                "Further execution is paused until verification passes or the room overrides it.",
+                followUp
+              ].filter(Boolean).join("\n"),
+              message.message_id
+            );
+            await this.rememberContinuationWithOptions(message, followUp, {
+              kind: "blocking-verification-override",
+              source: "verification-policy-gate",
+              context: {
+                verificationResultId: String(nextBlockingVerification.id || "").trim(),
+                outcome: String(nextBlockingVerification.outcome || "").trim()
+              },
+              force: true
+            });
+          }
+        }
+      }
     } catch (error) {
       await this.deliverPromptFailure(message.chat.id, message.message_id, previewMessage, error);
     } finally {