@tritard/waterbrother 0.16.141 → 0.16.142

package/package.json

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

package/src/discord.js

@@ -5,6 +5,8 @@ import { buildSelfAwarenessManifest, formatAboutWaterbrother, formatSelfState }
 import { createSession, listSessions, loadSession, saveSession } from "./session-store.js";
 import { loadGatewayBridge, loadGatewayState, saveGatewayBridge, saveGatewayState } from "./gateway-state.js";
 import {
+  addSharedRoomNote,
+  addVerificationResult,
   acceptSharedInvite,
   approveSharedInvite,
   assignSharedTask,
@@ -170,6 +172,14 @@ function buildDiscordHelp() {
     "/executor show the selected executor",
     "/reviewer show the assigned reviewer",
     "/verifier show the assigned verifier",
+    "/verify run verification through the assigned verifier or live terminal",
+    "/verification show the latest verification result",
+    "/rerun-verification rerun verification",
+    "/override-verification override the current blocking verification",
+    "/review-status show blocking review and latest reviewer outcome",
+    "/accept-reviewer-concerns clear blocking review by accepting the reviewer concerns",
+    "/override-reviewer override the current blocking reviewer outcome",
+    "/switch-executor-to-reviewer make the reviewer the executor",
     "/assign-role <terminal|this terminal> <executor|reviewer|verifier|standby> assign a room role",
     "/members list shared room members",
     "/tasks list shared room tasks",
@@ -399,6 +409,92 @@ function formatDiscordTaskHistory(result = {}) {
   return lines.join("\n");
 }
 
+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 getLatestReviewResult(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 || "")));
+  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 formatDiscordVerificationResult(result = {}, verifier = null) {
+  const lines = [
+    "Verification result",
+    `outcome: ${String(result.outcome || "failed")}`
+  ];
+  if (verifier) lines.splice(1, 0, `verifier: ${getAgentOwnerDisplay(verifier)}`);
+  if (result.failedCommand) lines.push(`failed step: ${String(result.failedCommand || "")}`);
+  if (result.isolation) lines.push(`environment: ${String(result.isolation || "")}`);
+  if (Array.isArray(result.commands) && result.commands.length) {
+    lines.push("commands:");
+    for (const command of result.commands) lines.push(`- ${command}`);
+  }
+  if (result.summary) lines.push("", "Summary", String(result.summary || ""));
+  if (Array.isArray(result.logs) && result.logs.length) {
+    lines.push("", "Top errors", ...result.logs.slice(0, 6).map((line) => `- ${line}`));
+  }
+  if (String(result.outcome || "").trim() !== "passed") {
+    lines.push("", "Next actions", "- /rerun-verification", "- /override-verification");
+  }
+  return lines.join("\n");
+}
+
+function formatDiscordReviewStatus(project = {}) {
+  const blockingReview = getLatestBlockingReviewPolicy(project);
+  const latestReview = getLatestReviewResult(project);
+  const reviewMeta = latestReview?.meta && typeof latestReview.meta === "object" ? latestReview.meta : {};
+  return [
+    "Reviewer status",
+    `blocking review: ${blockingReview ? "yes" : "no"}`,
+    `latest reviewer outcome: ${String(reviewMeta.outcome || "").trim() || "none"}`,
+    reviewMeta.agentId ? `reviewer agent: ${reviewMeta.agentId}` : ""
+  ].filter(Boolean).join("\n");
+}
+
 function parseDiscordInviteCommand(message = {}, text = "") {
   const value = String(text || "").trim();
   const match = value.match(/^\/?(?:room\s+)?invite\s+(.+)$/i);
@@ -1049,7 +1145,163 @@ async function handleDiscordControlCommand(runtime, state, message, rawText) {
     const agent = chooseAgentByRole(project, "verifier");
     const liveHosts = await getLiveBridgeHosts({ cwd: session?.cwd || "" });
     const live = agent ? liveHosts.some((host) => String(host?.ownerId || "") === String(agent?.ownerId || "") || String(host?.sessionId || "") === String(agent?.sessionId || "")) : false;
-    return formatDiscordAgentStatus("Verifier", agent, { live });
+    const latestVerification = getLatestVerificationResult(project);
+    const blockingVerification = getBlockingVerificationResult(project);
+    return [
+      formatDiscordAgentStatus("Verifier", agent, { live }),
+      `verification mode: ${String(project.verificationMode || "manual")}`,
+      `blocking verification: ${blockingVerification ? "yes" : "no"}`,
+      `latest verification outcome: ${String(latestVerification?.outcome || "").trim() || "none"}`
+    ].filter(Boolean).join("\n");
+  }
+  if (normalized === "/verification" || normalized === "verification" || normalizedRoomAlias === "verification") {
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { project } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    const verifier = chooseAgentByRole(project, "verifier");
+    const result = getLatestVerificationResult(project);
+    if (!result) return "Verification result\nNo verification result is on record yet.";
+    return formatDiscordVerificationResult(result, verifier);
+  }
+  if (normalized === "/verify" || normalized === "verify" || normalized === "/run-verification" || normalizedRoomAlias === "verify" || normalizedRoomAlias === "run-verification") {
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { project, session } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    const actor = describeDiscordUser(message);
+    const verifier = chooseAgentByRole(project, "verifier");
+    const liveHosts = await getLiveBridgeHosts({ cwd: session?.cwd || "" });
+    const verifierHost = verifier ? liveHosts.find((host) => String(host?.ownerId || "") === String(verifier?.ownerId || "") || String(host?.sessionId || "") === String(verifier?.sessionId || "")) : null;
+    const targetHost = verifierHost || await getLiveBridgeHost({ cwd: session?.cwd || "" });
+    if (!targetHost) {
+      return "No live Waterbrother TUI is connected. Start Waterbrother in the terminal first, then retry.";
+    }
+    const bridged = await runPromptViaBridge(runtime, message, "run verification", {
+      sessionId,
+      requestKind: "verification",
+      targetHost
+    });
+    const routedResult = bridged?.meta?.verificationResult && typeof bridged.meta.verificationResult === "object"
+      ? bridged.meta.verificationResult
+      : null;
+    if (routedResult) {
+      const nextProject = await addVerificationResult(session.cwd || process.cwd(), routedResult, {
+        actorId: actor.userId,
+        actorName: actor.displayName
+      });
+      const latest = getLatestVerificationResult(nextProject) || routedResult;
+      return formatDiscordVerificationResult(latest, verifier);
+    }
+    if (bridged?.error) return bridged.error;
+    return String(bridged?.content || "").trim() || "Verification result\n(no content)";
+  }
+  if (normalized === "/rerun-verification" || normalized === "rerun verification" || normalizedRoomAlias === "rerun verification") {
+    return handleDiscordControlCommand(runtime, state, message, "/verify");
+  }
+  if (normalized === "/override-verification" || normalized === "override verification" || normalizedRoomAlias === "override verification") {
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { project, session } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    const blockingVerification = getBlockingVerificationResult(project);
+    if (!blockingVerification) return "Verification override\nNo blocking verification is active.";
+    const actor = describeDiscordUser(message);
+    await addSharedRoomNote(session.cwd || process.cwd(), "Blocking verification overridden for now", {
+      actorId: actor.userId,
+      actorName: actor.displayName,
+      type: "verification-override",
+      meta: {
+        verificationResultId: String(blockingVerification.id || "").trim(),
+        outcome: String(blockingVerification.outcome || "").trim()
+      }
+    });
+    return [
+      "Verification overridden",
+      `latest outcome: ${String(blockingVerification.outcome || "failed")}`,
+      "Execution can proceed for now."
+    ].join("\n");
+  }
+  if (normalized === "/review-status" || normalized === "review status" || normalizedRoomAlias === "review-status" || normalizedRoomAlias === "review status") {
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { project } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    return formatDiscordReviewStatus(project);
+  }
+  if (normalized === "/accept-reviewer-concerns" || normalized === "accept reviewer concerns" || normalizedRoomAlias === "accept reviewer concerns") {
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { project, session } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    const blockingReview = getLatestBlockingReviewPolicy(project);
+    if (!blockingReview) return "Reviewer concerns\nNo blocking review is active.";
+    const result = getLatestReviewResult(project);
+    if (!result) return "Reviewer concerns\nNo reviewer result is on record yet.";
+    const meta = result.meta && typeof result.meta === "object" ? result.meta : {};
+    const blockingMeta = blockingReview.meta && typeof blockingReview.meta === "object" ? blockingReview.meta : {};
+    if (String(meta.agentId || "").trim() !== String(blockingMeta.agentId || "").trim()) {
+      return "Reviewer concerns\nThe latest reviewer result does not match the current blocking reviewer.";
+    }
+    if (String(meta.outcome || "").trim() !== "concerns") {
+      return "Reviewer concerns\nThe latest reviewer result is not concerns.";
+    }
+    const actor = describeDiscordUser(message);
+    await addSharedRoomNote(session.cwd || process.cwd(), "Reviewer concerns accepted; revise before continuing", {
+      actorId: actor.userId,
+      actorName: actor.displayName,
+      type: "review-concerns-accepted",
+      meta: { agentId: String(meta.agentId || "").trim() }
+    });
+    await addSharedRoomNote(session.cwd || process.cwd(), "Blocking review cleared after reviewer concerns were accepted", {
+      actorId: actor.userId,
+      actorName: actor.displayName,
+      type: "review-policy-cleared",
+      meta: { agentId: String(meta.agentId || "").trim() }
+    });
+    return "Reviewer concerns accepted\nBlocking review has been cleared so the team can revise and continue.";
+  }
+  if (normalized === "/override-reviewer" || normalized === "override reviewer" || normalizedRoomAlias === "override reviewer") {
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { project, session } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    const blockingReview = getLatestBlockingReviewPolicy(project);
+    if (!blockingReview) return "Reviewer override\nNo blocking review is active.";
+    const result = getLatestReviewResult(project);
+    const meta = result?.meta && typeof result.meta === "object" ? result.meta : {};
+    const blockingMeta = blockingReview.meta && typeof blockingReview.meta === "object" ? blockingReview.meta : {};
+    if (String(meta.agentId || "").trim() !== String(blockingMeta.agentId || "").trim()) {
+      return "Reviewer override\nThe latest reviewer result does not match the current blocking reviewer.";
+    }
+    const actor = describeDiscordUser(message);
+    await addSharedRoomNote(session.cwd || process.cwd(), "Reviewer outcome overridden by the room", {
+      actorId: actor.userId,
+      actorName: actor.displayName,
+      type: "review-policy-override",
+      meta: { agentId: String(meta.agentId || "").trim() }
+    });
+    return "Reviewer overridden\nExecution may proceed.";
+  }
+  if (normalized === "/switch-executor-to-reviewer" || normalized === "switch executor to reviewer" || normalizedRoomAlias === "switch executor to reviewer") {
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { project, session } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    const reviewer = chooseAgentByRole(project, "reviewer");
+    if (!reviewer) return "Executor switch\nNo reviewer is assigned.";
+    const currentExecutor = chooseAgentByRole(project, "executor");
+    const actor = describeDiscordUser(message);
+    if (currentExecutor?.id && currentExecutor.id !== reviewer.id) {
+      await upsertSharedAgent(session.cwd || process.cwd(), { ...currentExecutor, role: "standby" }, {
+        actorId: actor.userId,
+        actorName: actor.displayName
+      });
+    }
+    await upsertSharedAgent(session.cwd || process.cwd(), { ...reviewer, role: "executor" }, {
+      actorId: actor.userId,
+      actorName: actor.displayName
+    });
+    await addSharedRoomNote(session.cwd || process.cwd(), `${reviewer.ownerName || reviewer.label || reviewer.ownerId || "Reviewer"} is now the executor`, {
+      actorId: actor.userId,
+      actorName: actor.displayName,
+      type: "executor-handoff-reassigned",
+      meta: { currentAgentId: String(reviewer.id || "").trim() }
+    });
+    return `Executor switched\nexecutor: ${reviewer.ownerName || reviewer.label || reviewer.ownerId || reviewer.id || "reviewer"}`;
   }
   if (normalized.startsWith("/assign-role ") || normalizedRoomAlias.startsWith("assign-role ")) {
     const body = normalized.startsWith("/assign-role ") ? value.slice("/assign-role ".length).trim() : roomAlias.slice("assign-role ".length).trim();
@@ -1395,7 +1647,9 @@ async function getLiveBridgeHosts({ cwd = "" } = {}) {
 }
 
 async function runPromptViaBridge(runtime, message, promptText, options = {}) {
-  const host = await getLiveBridgeHost();
+  const host = options.targetHost && typeof options.targetHost === "object"
+    ? options.targetHost
+    : await getLiveBridgeHost();
   if (!host) {
     return { error: "No live Waterbrother TUI is connected. Start Waterbrother in the terminal first, then retry." };
   }
@@ -1413,7 +1667,7 @@ async function runPromptViaBridge(runtime, message, promptText, options = {}) {
     displayName: actor.displayName,
     sessionId: String(options.sessionId || "").trim(),
     text: String(promptText || "").trim(),
-    requestKind: "prompt",
+    requestKind: String(options.requestKind || "prompt").trim() || "prompt",
     explicitExecution: true,
     targetPid: Number(host?.pid || 0),
     targetSessionId: String(host?.sessionId || "").trim(),