@tritard/waterbrother 0.16.76 → 0.16.77

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tritard/waterbrother",
-  "version": "0.16.76",
+  "version": "0.16.77",
   "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,53 @@ function chooseExecutorAgent(project, fallbackExecutor = {}) {
   return null;
 }
 
+function getAgentRuntimeKey(agent = {}) {
+  const provider = String(agent?.provider || "").trim();
+  const model = String(agent?.model || "").trim();
+  return provider && model ? `${provider}/${model}` : "";
+}
+
+function listRuntimeGroups(project, fallbackExecutor = {}) {
+  const groups = new Map();
+  for (const agent of listProjectAgents(project)) {
+    const runtime = getAgentRuntimeKey(agent);
+    if (!runtime) continue;
+    if (!groups.has(runtime)) {
+      groups.set(runtime, []);
+    }
+    groups.get(runtime).push(agent);
+  }
+  if (!groups.size && fallbackExecutor?.provider && fallbackExecutor?.model) {
+    const runtime = `${fallbackExecutor.provider}/${fallbackExecutor.model}`;
+    groups.set(runtime, [{
+      id: "",
+      ownerId: String(project?.activeOperator?.id || "").trim(),
+      ownerName: String(project?.activeOperator?.name || project?.activeOperator?.id || "").trim(),
+      label: String(project?.activeOperator?.name || project?.activeOperator?.id || "active terminal").trim(),
+      surface: String(fallbackExecutor.surface || "").trim(),
+      role: "executor",
+      provider: String(fallbackExecutor.provider || "").trim(),
+      model: String(fallbackExecutor.model || "").trim(),
+      runtimeProfile: String(fallbackExecutor.runtimeProfile || "").trim(),
+      sessionId: String(fallbackExecutor.hostSessionId || "").trim()
+    }]);
+  }
+  return [...groups.entries()].map(([runtime, agents]) => ({ runtime, agents }));
+}
+
+function summarizeRuntimeConflict(project, fallbackExecutor = {}) {
+  const groups = listRuntimeGroups(project, fallbackExecutor).sort((left, right) => right.agents.length - left.agents.length);
+  const uniqueRuntimes = groups.filter((group) => String(group.runtime || "").trim());
+  if (!uniqueRuntimes.length) {
+    return { hasConflict: false, runtimeCount: 0, groups: [] };
+  }
+  return {
+    hasConflict: uniqueRuntimes.length > 1,
+    runtimeCount: uniqueRuntimes.length,
+    groups: uniqueRuntimes
+  };
+}
+
 function getLatestBlockingReviewPolicy(project) {
   const events = Array.isArray(project?.recentEvents) ? [...project.recentEvents] : [];
   const ordered = events
@@ -486,6 +533,7 @@ function formatTelegramSummaryMarkup({ cwd, project, chatId = "", title = "", ex
   if (project?.enabled) {
     const participants = listProjectParticipants(project);
     const agents = listProjectAgents(project);
+    const runtimeConflict = summarizeRuntimeConflict(project, executor);
     lines.push(`room mode: <code>${escapeTelegramHtml(project.roomMode || "chat")}</code>`);
     lines.push(`bound chat: <code>${escapeTelegramHtml(roomLabel)}</code>`);
     lines.push(`active operator: <code>${escapeTelegramHtml(activeOperator)}</code>`);
@@ -493,6 +541,9 @@ function formatTelegramSummaryMarkup({ cwd, project, chatId = "", title = "", ex
     if (agents.length) {
       lines.push(`agents: <code>${escapeTelegramHtml(String(agents.length))}</code>`);
     }
+    if (runtimeConflict.runtimeCount) {
+      lines.push(`runtime split: <code>${escapeTelegramHtml(runtimeConflict.hasConflict ? `yes (${runtimeConflict.runtimeCount})` : "no")}</code>`);
+    }
     if (executor?.surface) lines.push(`executor: <code>${escapeTelegramHtml(executor.surface)}</code>`);
     if (executor?.provider && executor?.model) {
       lines.push(`runtime: <code>${escapeTelegramHtml(`${executor.provider}/${executor.model}`)}</code>`);
@@ -679,9 +730,16 @@ function parseTelegramStateIntent(text = "") {
   if (/\bwho are the bots\b/.test(lower) || /\bwho are the agents\b/.test(lower) || /\bwhat bots are here\b/.test(lower) || /\bwhat agents are here\b/.test(lower)) {
     return { action: "agent-list" };
   }
+  if (/\bmodel conflict\b/.test(lower) || /\bruntime conflict\b/.test(lower) || /\bmodel split\b/.test(lower) || /\bruntime split\b/.test(lower) || /\bcompare models\b/.test(lower) || /\bcompare bots\b/.test(lower)) {
+    return { action: "model-conflict" };
+  }
   if (/\bwhich (?:bot|agent|terminal) should take this\b/.test(lower) || /\bwho should take this\b/.test(lower) || /\bwho should handle this\b/.test(lower)) {
     return { action: "executor-recommendation" };
   }
+  const agentPerspectiveMatch = value.match(/^(?:what does|how does)\s+(.+?)['’]s\s+model\s+think\??$/i);
+  if (agentPerspectiveMatch?.[1]) {
+    return { action: "agent-perspective", target: agentPerspectiveMatch[1].trim() };
+  }
   const agentModelMatch = value.match(/^(?:what model is|which model is|what runtime is)\s+(.+?)['’]s\s+(?:bot|terminal)(?:\s+on)?\??$/i);
   if (agentModelMatch?.[1]) {
     return { action: "agent-model", target: agentModelMatch[1].trim() };
@@ -795,6 +853,7 @@ function formatTelegramRoomMarkup(project, options = {}) {
   const agentLines = agents.length
     ? agents.map((agent) => `• ${escapeTelegramHtml(formatAgentLabel(agent) || agent.id || "agent")} <code>${escapeTelegramHtml(agent.surface || "unknown")}</code>`)
     : ["• none"];
+  const runtimeConflict = summarizeRuntimeConflict(project, executor);
   const executorBits = [
     `surface: <code>${escapeTelegramHtml(executor.surface || "telegram")}</code>`,
     `provider: <code>${escapeTelegramHtml(executor.provider || "unknown")}</code>`,
@@ -819,6 +878,16 @@ function formatTelegramRoomMarkup(project, options = {}) {
     `pending invites: <code>${pendingInviteCount}</code>`,
     "<b>Executor</b>",
     ...executorBits,
+    "<b>Runtime Split</b>",
+    runtimeConflict.runtimeCount
+      ? `status: <code>${escapeTelegramHtml(runtimeConflict.hasConflict ? `split (${runtimeConflict.runtimeCount})` : "aligned")}</code>`
+      : "status: <code>unknown</code>",
+    ...runtimeConflict.groups.map((group) => {
+      const owners = group.agents
+        .map((agent) => String(agent.ownerName || agent.label || agent.ownerId || agent.id || "").trim())
+        .filter(Boolean);
+      return `• <code>${escapeTelegramHtml(group.runtime)}</code>${owners.length ? ` — ${escapeTelegramHtml(owners.join(", "))}` : ""}`;
+    }),
     "<b>Task Summary</b>",
     `total: <code>${tasks.length}</code>`,
     ...[...byState.entries()].map(([state, count]) => `${escapeTelegramHtml(state)}: <code>${count}</code>`),
@@ -1998,6 +2067,51 @@ class TelegramGateway {
       ].join("\n");
     }
 
+    if (intent.action === "model-conflict") {
+      if (!project?.enabled) {
+        return "This project is not shared.";
+      }
+      const summary = summarizeRuntimeConflict(project, executor);
+      if (!summary.runtimeCount) {
+        return "<b>Model conflict check</b>\nNo registered terminal runtime is known yet.";
+      }
+      const lines = [
+        "<b>Model conflict check</b>",
+        summary.hasConflict
+          ? `This room has a runtime split across <code>${escapeTelegramHtml(String(summary.runtimeCount))}</code> models.`
+          : "This room is currently aligned on one runtime."
+      ];
+      for (const group of summary.groups) {
+        const owners = group.agents
+          .map((agent) => String(agent.ownerName || agent.label || agent.ownerId || agent.id || "").trim())
+          .filter(Boolean);
+        lines.push(`• <code>${escapeTelegramHtml(group.runtime)}</code>${owners.length ? ` — ${escapeTelegramHtml(owners.join(", "))}` : ""}`);
+      }
+      if (summary.hasConflict) {
+        lines.push("If you want a second opinion, assign a reviewer or ask whose bot should handle the work.");
+      }
+      return lines.join("\n");
+    }
+
+    if (intent.action === "agent-perspective") {
+      if (!project?.enabled) {
+        return "This project is not shared.";
+      }
+      const agent = resolveProjectAgent(project, intent.target);
+      if (!agent) {
+        return `No terminal found for ${escapeTelegramHtml(intent.target || "that person")} in this room yet.`;
+      }
+      const runtime = agent.provider && agent.model ? `${agent.provider}/${agent.model}` : "unknown";
+      return [
+        "<b>Model perspective</b>",
+        `person: <code>${escapeTelegramHtml(agent.ownerName || agent.ownerId || agent.label || agent.id || "-")}</code>`,
+        `terminal: <code>${escapeTelegramHtml(agent.label || agent.id || "unknown")}</code>`,
+        `runtime: <code>${escapeTelegramHtml(runtime)}</code>`,
+        `role: <code>${escapeTelegramHtml(agent.role || "standby")}</code>`,
+        "This shows which model would speak for that terminal. To get its perspective in the room, assign it as reviewer or executor."
+      ].join("\n");
+    }
+
     if (intent.action === "agent-model") {
       if (!project?.enabled) {
         return "This project is not shared.";