@tritard/waterbrother 0.16.76 → 0.16.78

package/package.json

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

package/src/cli.js

@@ -3023,6 +3023,15 @@ function createTelegramBridgeHostRecord({ sessionId, cwd, label = "", surface =
   };
 }
 
+function upsertTelegramBridgeHostEntry(hosts = [], nextHost = {}) {
+  const list = Array.isArray(hosts) ? [...hosts] : [];
+  const pid = Number(nextHost?.pid || 0);
+  if (!pid) return list;
+  const filtered = list.filter((host) => Number(host?.pid || 0) !== pid);
+  filtered.unshift(nextHost);
+  return filtered.slice(0, 20);
+}
+
 async function syncSharedTelegramBridgeAgent({ cwd, host = {}, actor = {} }) {
   try {
     const project = await loadSharedProject(cwd);
@@ -3052,6 +3061,7 @@ async function syncSharedTelegramBridgeAgent({ cwd, host = {}, actor = {} }) {
 async function registerTelegramBridgeHost({ sessionId, cwd, label = "", surface = "live-tui", ownerId = "", ownerName = "", provider = "", model = "", runtimeProfile = "", actor = null }) {
   const bridge = await loadGatewayBridge(TELEGRAM_BRIDGE_SERVICE);
   bridge.activeHost = createTelegramBridgeHostRecord({ sessionId, cwd, label, surface, ownerId, ownerName, provider, model, runtimeProfile });
+  bridge.hosts = upsertTelegramBridgeHostEntry(bridge.hosts, bridge.activeHost);
   bridge.deliveredReplies = Array.isArray(bridge.deliveredReplies) ? bridge.deliveredReplies.slice(-50) : [];
   bridge.pendingRequests = Array.isArray(bridge.pendingRequests) ? bridge.pendingRequests : [];
   await saveGatewayBridge(TELEGRAM_BRIDGE_SERVICE, bridge);
@@ -3079,6 +3089,7 @@ async function touchTelegramBridgeHost({ sessionId, cwd, label = "", surface = "
       updatedAt: new Date().toISOString()
     };
   }
+  bridge.hosts = upsertTelegramBridgeHostEntry(bridge.hosts, bridge.activeHost);
   await saveGatewayBridge(TELEGRAM_BRIDGE_SERVICE, bridge);
   await syncSharedTelegramBridgeAgent({ cwd, host: bridge.activeHost, actor: actor || { id: ownerId, name: ownerName } });
   return bridge.activeHost;
@@ -3088,8 +3099,9 @@ async function clearTelegramBridgeHost() {
   const bridge = await loadGatewayBridge(TELEGRAM_BRIDGE_SERVICE);
   if (Number(bridge.activeHost?.pid || 0) === process.pid) {
     bridge.activeHost = { pid: 0, sessionId: "", cwd: "", label: "", surface: "", ownerId: "", ownerName: "", provider: "", model: "", runtimeProfile: "", startedAt: "", updatedAt: "" };
-    await saveGatewayBridge(TELEGRAM_BRIDGE_SERVICE, bridge);
   }
+  bridge.hosts = Array.isArray(bridge.hosts) ? bridge.hosts.filter((host) => Number(host?.pid || 0) !== process.pid) : [];
+  await saveGatewayBridge(TELEGRAM_BRIDGE_SERVICE, bridge);
 }
 
 async function dequeueTelegramBridgeRequest({ cwd }) {
@@ -3111,6 +3123,7 @@ async function dequeueTelegramBridgeRequest({ cwd }) {
     ...activeHost,
     updatedAt: new Date().toISOString()
   };
+  bridge.hosts = upsertTelegramBridgeHostEntry(bridge.hosts, bridge.activeHost);
   await saveGatewayBridge(TELEGRAM_BRIDGE_SERVICE, bridge);
   return next;
 }
@@ -3135,6 +3148,9 @@ async function deliverTelegramBridgeReply(request, { sessionId, content = "", er
       sessionId: String(sessionId || "").trim() || String(bridge.activeHost.sessionId || "")
     };
   }
+  if (Number(bridge.activeHost?.pid || 0) === process.pid) {
+    bridge.hosts = upsertTelegramBridgeHostEntry(bridge.hosts, bridge.activeHost);
+  }
   await saveGatewayBridge(TELEGRAM_BRIDGE_SERVICE, bridge);
 }
 

package/src/gateway-state.js

@@ -75,29 +75,39 @@ function normalizeBridgeReply(parsed = {}) {
 }
 
 function normalizeGatewayBridge(parsed = {}) {
+  const normalizeHost = (host = {}) => ({
+    pid: Number.isFinite(Number(host.pid)) ? Math.floor(Number(host.pid)) : 0,
+    sessionId: String(host.sessionId || "").trim(),
+    cwd: String(host.cwd || "").trim(),
+    label: String(host.label || "").trim(),
+    surface: String(host.surface || "").trim(),
+    ownerId: String(host.ownerId || "").trim(),
+    ownerName: String(host.ownerName || "").trim(),
+    provider: String(host.provider || "").trim(),
+    model: String(host.model || "").trim(),
+    runtimeProfile: String(host.runtimeProfile || "").trim(),
+    startedAt: String(host.startedAt || "").trim(),
+    updatedAt: String(host.updatedAt || "").trim()
+  });
   const pendingRequests = Array.isArray(parsed?.pendingRequests)
     ? parsed.pendingRequests.map(normalizeBridgeRequest).filter((item) => item.id)
     : [];
   const deliveredReplies = Array.isArray(parsed?.deliveredReplies)
     ? parsed.deliveredReplies.map(normalizeBridgeReply).filter((item) => item.requestId)
     : [];
+  const hosts = Array.isArray(parsed?.hosts)
+    ? parsed.hosts.map(normalizeHost).filter((host) => Number(host.pid || 0) > 0)
+    : [];
+  const activeHost = parsed?.activeHost && typeof parsed.activeHost === "object"
+    ? normalizeHost(parsed.activeHost)
+    : normalizeHost();
+  const mergedHosts = [...hosts];
+  if (Number(activeHost.pid || 0) > 0 && !mergedHosts.some((host) => Number(host.pid || 0) === Number(activeHost.pid || 0))) {
+    mergedHosts.unshift(activeHost);
+  }
   return {
-    activeHost: parsed?.activeHost && typeof parsed.activeHost === "object"
-      ? {
-          pid: Number.isFinite(Number(parsed.activeHost.pid)) ? Math.floor(Number(parsed.activeHost.pid)) : 0,
-          sessionId: String(parsed.activeHost.sessionId || "").trim(),
-          cwd: String(parsed.activeHost.cwd || "").trim(),
-          label: String(parsed.activeHost.label || "").trim(),
-          surface: String(parsed.activeHost.surface || "").trim(),
-          ownerId: String(parsed.activeHost.ownerId || "").trim(),
-          ownerName: String(parsed.activeHost.ownerName || "").trim(),
-          provider: String(parsed.activeHost.provider || "").trim(),
-          model: String(parsed.activeHost.model || "").trim(),
-          runtimeProfile: String(parsed.activeHost.runtimeProfile || "").trim(),
-          startedAt: String(parsed.activeHost.startedAt || "").trim(),
-          updatedAt: String(parsed.activeHost.updatedAt || "").trim()
-        }
-      : { pid: 0, sessionId: "", cwd: "", label: "", surface: "", ownerId: "", ownerName: "", provider: "", model: "", runtimeProfile: "", startedAt: "", updatedAt: "" },
+    activeHost,
+    hosts: mergedHosts.slice(-20),
     pendingRequests,
     deliveredReplies
   };

package/src/gateway.js

@@ -419,6 +419,60 @@ 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 formatBridgeHostLabel(host = {}) {
+  const owner = String(host?.ownerName || host?.ownerId || "").trim();
+  const label = String(host?.label || "").trim();
+  const runtime = host?.provider && host?.model ? `${host.provider}/${host.model}` : "";
+  return [owner || label, label && label !== owner ? `(${label})` : "", runtime ? `[${runtime}]` : ""].filter(Boolean).join(" ").trim();
+}
+
 function getLatestBlockingReviewPolicy(project) {
   const events = Array.isArray(project?.recentEvents) ? [...project.recentEvents] : [];
   const ordered = events
@@ -486,6 +540,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 +548,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 +737,19 @@ 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 (/\bwhich terminals are live\b/.test(lower) || /\bwhich bots are live\b/.test(lower) || /\bwho is live\b/.test(lower) || /\bwhat terminals are live\b/.test(lower)) {
+    return { action: "live-hosts" };
+  }
+  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 +863,8 @@ 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 liveHosts = Array.isArray(options.liveHosts) ? options.liveHosts : [];
   const executorBits = [
     `surface: <code>${escapeTelegramHtml(executor.surface || "telegram")}</code>`,
     `provider: <code>${escapeTelegramHtml(executor.provider || "unknown")}</code>`,
@@ -819,6 +889,21 @@ 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>Live Terminals</b>",
+    `count: <code>${escapeTelegramHtml(String(liveHosts.length))}</code>`,
+    ...(liveHosts.length
+      ? liveHosts.map((host) => `• ${escapeTelegramHtml(formatBridgeHostLabel(host) || host.sessionId || "terminal")} <code>${escapeTelegramHtml(host.surface || "live-tui")}</code>`)
+      : ["• none"]),
     "<b>Task Summary</b>",
     `total: <code>${tasks.length}</code>`,
     ...[...byState.entries()].map(([state, count]) => `${escapeTelegramHtml(state)}: <code>${count}</code>`),
@@ -1998,6 +2083,65 @@ class TelegramGateway {
       ].join("\n");
     }
 
+    if (intent.action === "live-hosts") {
+      const hosts = await this.getLiveBridgeHosts({ cwd });
+      if (!hosts.length) {
+        return "<b>Live terminals</b>\n• none";
+      }
+      return [
+        "<b>Live terminals</b>",
+        ...hosts.map((host) => {
+          const roleAgent = listProjectAgents(project).find((agent) => String(agent?.sessionId || "").trim() === String(host?.sessionId || "").trim()) || null;
+          return `• ${escapeTelegramHtml(formatBridgeHostLabel(host) || host.sessionId || "terminal")} <i>(${escapeTelegramHtml(roleAgent?.role || "live")})</i> <code>${escapeTelegramHtml(host.surface || "live-tui")}</code>`;
+        })
+      ].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.";
@@ -2027,12 +2171,20 @@ class TelegramGateway {
       const operatorLabel = project.activeOperator?.id
         ? `${project.activeOperator.name || project.activeOperator.id}`
         : "none";
+      const liveHosts = await this.getLiveBridgeHosts({ cwd });
+      const isLive = liveHosts.some((host) => {
+        const ownerId = String(host?.ownerId || "").trim();
+        const sessionId = String(host?.sessionId || "").trim();
+        return (ownerId && ownerId === String(agent.ownerId || "").trim())
+          || (sessionId && sessionId === String(agent.sessionId || "").trim());
+      });
       return [
         "<b>Execution recommendation</b>",
         `take this on: <code>${escapeTelegramHtml(agent.ownerName || agent.label || agent.ownerId || agent.id || "unknown")}</code>`,
         `role: <code>${escapeTelegramHtml(agent.role || "executor")}</code>`,
         `surface: <code>${escapeTelegramHtml(agent.surface || "unknown")}</code>`,
         `runtime: <code>${escapeTelegramHtml(agent.provider && agent.model ? `${agent.provider}/${agent.model}` : "unknown")}</code>`,
+        `live now: <code>${escapeTelegramHtml(isLive ? "yes" : "no")}</code>`,
         `active operator: <code>${escapeTelegramHtml(operatorLabel)}</code>`
       ].join("\n");
     }
@@ -2379,6 +2531,7 @@ class TelegramGateway {
   async buildRoomMarkup(message, sessionId) {
     const { project } = await this.bindSharedRoomForMessage(message, sessionId);
     const host = await this.getLiveBridgeHost();
+    const liveHosts = await this.getLiveBridgeHosts({ cwd: project?.cwd || this.cwd });
     const executor = {
       surface: host?.surface || (host ? "live-tui" : "telegram-fallback"),
       provider: host?.provider || this.runtime.provider,
@@ -2390,10 +2543,10 @@ class TelegramGateway {
       ? `${formatTelegramSummaryMarkup({
           cwd: project.cwd || this.cwd,
           project,
-          chatId: String(message.chat.id),
-          title: String(message.chat.title || "").trim(),
-          executor
-        })}\n\n${formatTelegramRoomMarkup(project, { executor })}`
+        chatId: String(message.chat.id),
+        title: String(message.chat.title || "").trim(),
+        executor
+        })}\n\n${formatTelegramRoomMarkup(project, { executor, liveHosts })}`
       : "<b>Shared room</b>\nThis project is not shared.";
   }
 
@@ -2444,6 +2597,39 @@ class TelegramGateway {
     return host;
   }
 
+  async getLiveBridgeHosts({ cwd = "" } = {}) {
+    const bridge = await loadGatewayBridge("telegram");
+    const hosts = Array.isArray(bridge.hosts) ? bridge.hosts : [];
+    const nextHosts = [];
+    let changed = false;
+    for (const host of hosts) {
+      const pid = Number(host?.pid || 0);
+      if (!Number.isFinite(pid) || pid <= 0) {
+        changed = true;
+        continue;
+      }
+      try {
+        process.kill(pid, 0);
+      } catch {
+        changed = true;
+        continue;
+      }
+      if (cwd && host.cwd && String(host.cwd) !== String(cwd || "")) {
+        continue;
+      }
+      nextHosts.push(host);
+    }
+    if (changed || nextHosts.length !== hosts.length) {
+      bridge.hosts = nextHosts;
+      const activePid = Number(bridge.activeHost?.pid || 0);
+      if (activePid > 0 && !nextHosts.some((host) => Number(host?.pid || 0) === activePid)) {
+        bridge.activeHost = { pid: 0, sessionId: "", cwd: "", label: "", surface: "", ownerId: "", ownerName: "", provider: "", model: "", runtimeProfile: "", startedAt: "", updatedAt: "" };
+      }
+      await saveGatewayBridge("telegram", bridge);
+    }
+    return nextHosts;
+  }
+
   async runPromptViaBridge(message, sessionId, promptText, options = {}) {
     const host = await this.getLiveBridgeHost();
     if (!host) {