@tritard/waterbrother 0.16.65 → 0.16.67

package/package.json

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

package/src/cli.js

@@ -92,6 +92,7 @@ import {
   removeSharedMember,
   setSharedRuntimeProfile,
   setSharedRoomMode,
+  upsertSharedAgent,
   upsertSharedMember
 } from "./shared-project.js";
 import { findRelevantRegressions, buildRegressionWarningBlock } from "./regressions.js";
@@ -3004,47 +3005,89 @@ async function stopTrackedGateway(service = "telegram", { io = console } = {}) {
   return { stopped, pid };
 }
 
-function createTelegramBridgeHostRecord({ sessionId, cwd }) {
+function createTelegramBridgeHostRecord({ sessionId, cwd, label = "", surface = "live-tui", ownerId = "", ownerName = "", provider = "", model = "", runtimeProfile = "" }) {
   const now = new Date().toISOString();
   return {
     pid: process.pid,
     sessionId: String(sessionId || "").trim(),
     cwd: String(cwd || "").trim(),
+    label: String(label || "").trim(),
+    surface: String(surface || "live-tui").trim() || "live-tui",
+    ownerId: String(ownerId || "").trim(),
+    ownerName: String(ownerName || "").trim(),
+    provider: String(provider || "").trim(),
+    model: String(model || "").trim(),
+    runtimeProfile: String(runtimeProfile || "").trim(),
     startedAt: now,
     updatedAt: now
   };
 }
 
-async function registerTelegramBridgeHost({ sessionId, cwd }) {
+async function syncSharedTelegramBridgeAgent({ cwd, host = {}, actor = {} }) {
+  try {
+    const project = await loadSharedProject(cwd);
+    if (!project?.enabled) return null;
+    return await upsertSharedAgent(cwd, {
+      id: `agent:telegram-bridge:${String(host.sessionId || process.pid).trim()}`,
+      ownerId: String(actor.id || "").trim() || String(host.ownerId || "").trim(),
+      ownerName: String(actor.name || "").trim() || String(host.ownerName || "").trim(),
+      label: String(host.label || "").trim() || "Waterbrother live TUI",
+      surface: String(host.surface || "").trim() || "live-tui",
+      role: "executor",
+      provider: String(host.provider || "").trim(),
+      model: String(host.model || "").trim(),
+      runtimeProfile: String(host.runtimeProfile || "").trim(),
+      sessionId: String(host.sessionId || "").trim(),
+      cwd: String(cwd || "").trim(),
+      chatId: String(project.room?.chatId || "").trim()
+    }, {
+      actorId: String(actor.id || "").trim(),
+      actorName: String(actor.name || "").trim()
+    });
+  } catch {
+    return null;
+  }
+}
+
+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 });
+  bridge.activeHost = createTelegramBridgeHostRecord({ sessionId, cwd, label, surface, ownerId, ownerName, provider, model, runtimeProfile });
   bridge.deliveredReplies = Array.isArray(bridge.deliveredReplies) ? bridge.deliveredReplies.slice(-50) : [];
   bridge.pendingRequests = Array.isArray(bridge.pendingRequests) ? bridge.pendingRequests : [];
   await saveGatewayBridge(TELEGRAM_BRIDGE_SERVICE, bridge);
+  await syncSharedTelegramBridgeAgent({ cwd, host: bridge.activeHost, actor: actor || { id: ownerId, name: ownerName } });
   return bridge.activeHost;
 }
 
-async function touchTelegramBridgeHost({ sessionId, cwd }) {
+async function touchTelegramBridgeHost({ sessionId, cwd, label = "", surface = "live-tui", ownerId = "", ownerName = "", provider = "", model = "", runtimeProfile = "", actor = null }) {
   const bridge = await loadGatewayBridge(TELEGRAM_BRIDGE_SERVICE);
   const activeHost = bridge.activeHost || {};
   if (Number(activeHost.pid || 0) !== process.pid) {
-    bridge.activeHost = createTelegramBridgeHostRecord({ sessionId, cwd });
+    bridge.activeHost = createTelegramBridgeHostRecord({ sessionId, cwd, label, surface, ownerId, ownerName, provider, model, runtimeProfile });
   } else {
     bridge.activeHost = {
       ...activeHost,
       sessionId: String(sessionId || "").trim(),
       cwd: String(cwd || "").trim(),
+      label: String(label || activeHost.label || "").trim(),
+      surface: String(surface || activeHost.surface || "live-tui").trim() || "live-tui",
+      ownerId: String(ownerId || activeHost.ownerId || "").trim(),
+      ownerName: String(ownerName || activeHost.ownerName || "").trim(),
+      provider: String(provider || activeHost.provider || "").trim(),
+      model: String(model || activeHost.model || "").trim(),
+      runtimeProfile: String(runtimeProfile || activeHost.runtimeProfile || "").trim(),
       updatedAt: new Date().toISOString()
     };
   }
   await saveGatewayBridge(TELEGRAM_BRIDGE_SERVICE, bridge);
+  await syncSharedTelegramBridgeAgent({ cwd, host: bridge.activeHost, actor: actor || { id: ownerId, name: ownerName } });
   return bridge.activeHost;
 }
 
 async function clearTelegramBridgeHost() {
   const bridge = await loadGatewayBridge(TELEGRAM_BRIDGE_SERVICE);
   if (Number(bridge.activeHost?.pid || 0) === process.pid) {
-    bridge.activeHost = { pid: 0, sessionId: "", cwd: "", startedAt: "", updatedAt: "" };
+    bridge.activeHost = { pid: 0, sessionId: "", cwd: "", label: "", surface: "", ownerId: "", ownerName: "", provider: "", model: "", runtimeProfile: "", startedAt: "", updatedAt: "" };
     await saveGatewayBridge(TELEGRAM_BRIDGE_SERVICE, bridge);
   }
 }
@@ -7458,7 +7501,23 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
 
   const gatewayHandle = await maybeAutostartGateway(context.runtime, { cwd: context.cwd });
   let gatewayCleanupDone = false;
-  await registerTelegramBridgeHost({ sessionId: currentSession.id, cwd: context.cwd });
+  const telegramBridgeOperator = buildOperatorIdentity({
+    mode: agent.getExperienceMode(),
+    autonomy: agent.getAutonomyMode(),
+    profile: agent.getProfile()
+  });
+  await registerTelegramBridgeHost({
+    sessionId: currentSession.id,
+    cwd: context.cwd,
+    label: `${telegramBridgeOperator.name} terminal`,
+    surface: "live-tui",
+    ownerId: telegramBridgeOperator.id,
+    ownerName: telegramBridgeOperator.name,
+    provider: context.runtime.provider,
+    model: context.runtime.model,
+    runtimeProfile: currentSession.runtimeProfile || "",
+    actor: { id: telegramBridgeOperator.id, name: telegramBridgeOperator.name }
+  });
   const cleanupManagedGateway = async () => {
     if (gatewayCleanupDone) return;
     gatewayCleanupDone = true;
@@ -7494,7 +7553,18 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
     if (sharedFeed.latestEventId) {
       lastSeenSharedRoomEventId = sharedFeed.latestEventId;
     }
-    await touchTelegramBridgeHost({ sessionId: currentSession.id, cwd: context.cwd });
+    await touchTelegramBridgeHost({
+      sessionId: currentSession.id,
+      cwd: context.cwd,
+      label: `${telegramBridgeOperator.name} terminal`,
+      surface: "live-tui",
+      ownerId: telegramBridgeOperator.id,
+      ownerName: telegramBridgeOperator.name,
+      provider: context.runtime.provider,
+      model: context.runtime.model,
+      runtimeProfile: currentSession.runtimeProfile || "",
+      actor: { id: telegramBridgeOperator.id, name: telegramBridgeOperator.name }
+    });
     const nextInput = await readInteractiveLine({
         getFooterText(inputBuffer) {
           const footer = buildInteractiveFooter({
@@ -7574,7 +7644,18 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
         }
 
         remoteSessionId = currentSession.id;
-        await touchTelegramBridgeHost({ sessionId: currentSession.id, cwd: context.cwd });
+        await touchTelegramBridgeHost({
+          sessionId: currentSession.id,
+          cwd: context.cwd,
+          label: `${telegramBridgeOperator.name} terminal`,
+          surface: "live-tui",
+          ownerId: telegramBridgeOperator.id,
+          ownerName: telegramBridgeOperator.name,
+          provider: context.runtime.provider,
+          model: context.runtime.model,
+          runtimeProfile: currentSession.runtimeProfile || "",
+          actor: { id: telegramBridgeOperator.id, name: telegramBridgeOperator.name }
+        });
         if (remoteRequest.runtimeProfile && remoteRequest.runtimeProfile !== currentSession.runtimeProfile) {
           const { config } = await loadConfigLayers(context.cwd);
           const loaded = await loadNamedRuntimeProfile(remoteRequest.runtimeProfile, {

package/src/gateway-state.js

@@ -83,10 +83,17 @@ function normalizeGatewayBridge(parsed = {}) {
           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: "", startedAt: "", updatedAt: "" },
+      : { pid: 0, sessionId: "", cwd: "", label: "", surface: "", ownerId: "", ownerName: "", provider: "", model: "", runtimeProfile: "", startedAt: "", updatedAt: "" },
     pendingRequests,
     deliveredReplies
   };

package/src/gateway.js

@@ -285,6 +285,32 @@ function formatGatewaySessionStatus({ sessionId, userId, username, cwd, runtimeP
   return bits.join("\n");
 }
 
+function listProjectParticipants(project) {
+  return Array.isArray(project?.participants) ? project.participants : [];
+}
+
+function listProjectAgents(project) {
+  return Array.isArray(project?.agents) ? project.agents : [];
+}
+
+function findProjectParticipant(project, memberId = "") {
+  const normalizedId = String(memberId || "").trim();
+  if (!normalizedId) return null;
+  return listProjectParticipants(project).find((participant) => String(participant?.memberId || participant?.id || "").trim() === normalizedId) || null;
+}
+
+function formatAgentLabel(agent = {}) {
+  const label = String(agent?.label || agent?.name || "").trim();
+  const role = String(agent?.role || "").trim();
+  const provider = String(agent?.provider || "").trim();
+  const model = String(agent?.model || "").trim();
+  const bits = [];
+  if (label) bits.push(label);
+  if (role) bits.push(`(${role})`);
+  if (provider && model) bits.push(`[${provider}/${model}]`);
+  return bits.join(" ").trim();
+}
+
 function formatTelegramSummaryMarkup({ cwd, project, chatId = "", title = "", executor = {} }) {
   const roomLabel = project?.room?.chatId
     ? `${project.room.provider || "telegram"} ${project.room.chatId}${project.room.title ? ` (${project.room.title})` : ""}`
@@ -299,10 +325,15 @@ function formatTelegramSummaryMarkup({ cwd, project, chatId = "", title = "", ex
     `shared: <code>${project?.enabled ? "yes" : "no"}</code>`
   ];
   if (project?.enabled) {
+    const participants = listProjectParticipants(project);
+    const agents = listProjectAgents(project);
     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>`);
-    lines.push(`members: <code>${escapeTelegramHtml(String((project.members || []).length))}</code>`);
+    lines.push(`participants: <code>${escapeTelegramHtml(String(participants.length || (project.members || []).length))}</code>`);
+    if (agents.length) {
+      lines.push(`agents: <code>${escapeTelegramHtml(String(agents.length))}</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>`);
@@ -489,6 +520,8 @@ function formatTelegramRoomMarkup(project, options = {}) {
     return "<b>Shared room</b>\nThis project is not shared.";
   }
   const members = Array.isArray(project.members) ? project.members : [];
+  const participants = listProjectParticipants(project);
+  const agents = listProjectAgents(project);
   const active = project.activeOperator?.id
     ? `${project.activeOperator.name || project.activeOperator.id} (${project.activeOperator.id})`
     : "none";
@@ -513,6 +546,20 @@ function formatTelegramRoomMarkup(project, options = {}) {
     .sort((a, b) => b[1] - a[1])
     .slice(0, 4)
     .map(([assignee, count]) => `• <code>${escapeTelegramHtml(assignee)}</code> ${count}`);
+  const participantLines = participants.length
+    ? participants.map((participant) => {
+        const channelBits = [];
+        if (participant?.channels?.telegram?.userId) channelBits.push(`tg:${participant.channels.telegram.userId}`);
+        if (participant?.channels?.local?.username) channelBits.push(`local:${participant.channels.local.username}`);
+        const label = participant.displayName || participant.memberId || participant.id || "unknown";
+        return `• ${escapeTelegramHtml(label)} <i>(${escapeTelegramHtml(participant.role || "editor")})</i>${channelBits.length ? ` <code>${escapeTelegramHtml(channelBits.join(" "))}</code>` : ""}`;
+      })
+    : members.length
+      ? members.map((member) => `• ${escapeTelegramHtml(member.name || member.id)} <i>(${escapeTelegramHtml(member.role || "editor")})</i>`)
+      : ["• none"];
+  const agentLines = agents.length
+    ? agents.map((agent) => `• ${escapeTelegramHtml(formatAgentLabel(agent) || agent.id || "agent")} <code>${escapeTelegramHtml(agent.surface || "unknown")}</code>`)
+    : ["• none"];
   const executorBits = [
     `surface: <code>${escapeTelegramHtml(executor.surface || "telegram")}</code>`,
     `provider: <code>${escapeTelegramHtml(executor.provider || "unknown")}</code>`,
@@ -542,8 +589,10 @@ function formatTelegramRoomMarkup(project, options = {}) {
     ...[...byState.entries()].map(([state, count]) => `${escapeTelegramHtml(state)}: <code>${count}</code>`),
     "<b>Ownership</b>",
     ...(ownershipLines.length ? ownershipLines : ["• none"]),
-    "<b>Members</b>",
-    memberLines
+    "<b>Participants</b>",
+    ...participantLines,
+    "<b>Agents</b>",
+    ...agentLines
   ].join("\n");
 }
 
@@ -576,13 +625,24 @@ function formatTelegramMembersMarkup(project) {
   if (!project?.enabled) {
     return "This project is not shared.";
   }
-  const members = Array.isArray(project.members) ? project.members : [];
-  if (!members.length) {
-    return "<b>Shared members</b>\n• none";
+  const participants = listProjectParticipants(project);
+  if (!participants.length) {
+    const members = Array.isArray(project.members) ? project.members : [];
+    if (!members.length) {
+      return "<b>Shared participants</b>\n• none";
+    }
+    return [
+      "<b>Shared participants</b>",
+      ...members.map((member) => `• ${escapeTelegramHtml(member.name || member.id)} <i>(${escapeTelegramHtml(member.role || "editor")})</i> <code>${escapeTelegramHtml(member.id || "")}</code>`)
+    ].join("\n");
   }
   return [
-    "<b>Shared members</b>",
-    ...members.map((member) => `• ${escapeTelegramHtml(member.name || member.id)} <i>(${escapeTelegramHtml(member.role || "editor")})</i> <code>${escapeTelegramHtml(member.id || "")}</code>`)
+    "<b>Shared participants</b>",
+    ...participants.map((participant) => {
+      const id = participant.memberId || participant.id || "";
+      const telegramId = participant?.channels?.telegram?.userId ? ` tg:${participant.channels.telegram.userId}` : "";
+      return `• ${escapeTelegramHtml(participant.displayName || id)} <i>(${escapeTelegramHtml(participant.role || "editor")})</i> <code>${escapeTelegramHtml(`${id}${telegramId}`.trim())}</code>`;
+    })
   ].join("\n");
 }
 
@@ -656,11 +716,13 @@ function formatTelegramPeopleMarkup({ people = [], project = null }) {
     "<b>Recent Telegram people</b>",
     ...people.map((person) => {
       const member = members.find((entry) => String(entry?.id || "").trim() === person.userId);
+      const participant = findProjectParticipant(project, person.userId);
       const pendingInvite = pendingInvites.find((entry) => String(entry?.memberId || "").trim() === person.userId);
       const bits = [`<code>${escapeTelegramHtml(person.userId)}</code>`];
       if (person.usernameHandle) bits.push(`@${escapeTelegramHtml(person.usernameHandle)}`);
       bits.push(escapeTelegramHtml(person.displayName || person.userId));
-      if (member?.role) bits.push(`<i>member:${escapeTelegramHtml(member.role)}</i>`);
+      if (participant?.role) bits.push(`<i>participant:${escapeTelegramHtml(participant.role)}</i>`);
+      else if (member?.role) bits.push(`<i>member:${escapeTelegramHtml(member.role)}</i>`);
       else if (pendingInvite?.id) bits.push(`<i>pending:${escapeTelegramHtml(pendingInvite.id)}</i>`);
       else if (person.paired) bits.push("<i>paired</i>");
       return `• ${bits.join(" ")}`;
@@ -1116,6 +1178,9 @@ class TelegramGateway {
   }
 
   buildTrustedRoomIntroMarkup({ project, actor }) {
+    const participants = listProjectParticipants(project);
+    const agents = listProjectAgents(project);
+    const executorAgent = agents.find((agent) => String(agent?.role || "").trim() === "executor") || null;
     return [
       "<b>Roundtable room</b>",
       `${escapeTelegramHtml(actor.displayName || actor.userId)} is now in <code>${escapeTelegramHtml(project.projectName || "this project")}</code> as <code>observer</code>.`,
@@ -1123,10 +1188,12 @@ class TelegramGateway {
       project.activeOperator?.id
         ? `active operator: <code>${escapeTelegramHtml(project.activeOperator.name || project.activeOperator.id)}</code>`
         : "active operator: <code>none</code>",
+      `participants: <code>${escapeTelegramHtml(String(participants.length || (project.members || []).length))}</code>`,
+      executorAgent ? `active terminal: <code>${escapeTelegramHtml(formatAgentLabel(executorAgent) || executorAgent.id)}</code>` : "",
       "As observer, you can ask questions, discuss plans, and review work here.",
       "An owner can promote you to editor or owner conversationally.",
       "Examples: <code>what project is this chat bound to?</code>, <code>who is in the room?</code>, <code>what can I do here?</code>"
-    ].join("\n");
+    ].filter(Boolean).join("\n");
   }
 
   describeTelegramUser(from = {}) {
@@ -1744,10 +1811,10 @@ class TelegramGateway {
     const { project } = await this.bindSharedRoomForMessage(message, sessionId);
     const host = await this.getLiveBridgeHost();
     const executor = {
-      surface: host ? "live-tui" : "telegram-fallback",
-      provider: this.runtime.provider,
-      model: this.runtime.model,
-      runtimeProfile: project?.runtimeProfile || this.channel.defaultRuntimeProfile || this.gateway.defaultRuntimeProfile || "",
+      surface: host?.surface || (host ? "live-tui" : "telegram-fallback"),
+      provider: host?.provider || this.runtime.provider,
+      model: host?.model || this.runtime.model,
+      runtimeProfile: host?.runtimeProfile || project?.runtimeProfile || this.channel.defaultRuntimeProfile || this.gateway.defaultRuntimeProfile || "",
       hostSessionId: host?.sessionId || ""
     };
     return project?.enabled

package/src/shared-project.js

@@ -57,6 +57,7 @@ function normalizeAgent(agent = {}) {
   return {
     id: String(agent.id || "").trim(),
     ownerId: String(agent.ownerId || "").trim(),
+    ownerName: String(agent.ownerName || "").trim(),
     label: String(agent.label || agent.name || "").trim(),
     surface: String(agent.surface || "").trim(),
     role: AGENT_ROLES.includes(String(agent.role || "").trim()) ? String(agent.role).trim() : "standby",
@@ -64,6 +65,8 @@ function normalizeAgent(agent = {}) {
     model: String(agent.model || "").trim(),
     runtimeProfile: String(agent.runtimeProfile || "").trim(),
     sessionId: String(agent.sessionId || "").trim(),
+    cwd: String(agent.cwd || "").trim(),
+    chatId: String(agent.chatId || "").trim(),
     updatedAt: String(agent.updatedAt || new Date().toISOString()).trim()
   };
 }
@@ -602,6 +605,38 @@ export async function upsertSharedMember(cwd, member = {}, options = {}) {
   })).project;
 }
 
+export async function upsertSharedAgent(cwd, agent = {}, options = {}) {
+  const existing = await loadSharedProject(cwd);
+  requireSharedProject(existing);
+  const nextAgent = normalizeAgent(agent);
+  if (!nextAgent.id) throw new Error("agent id is required");
+  if (options.actorId) {
+    requireMember(existing, options.actorId);
+  }
+  const agents = Array.isArray(existing.agents) ? [...existing.agents] : [];
+  const index = agents.findIndex((item) => item.id === nextAgent.id);
+  if (index >= 0) {
+    agents[index] = normalizeAgent({ ...agents[index], ...nextAgent });
+  } else {
+    agents.push(nextAgent);
+  }
+  const next = await saveSharedProject(cwd, {
+    ...existing,
+    agents
+  });
+  return (await recordSharedProjectEvent(cwd, next, `agent ${nextAgent.label || nextAgent.id} registered as ${nextAgent.role}`, {
+    type: "agent-upsert",
+    actorId: String(options.actorId || "").trim(),
+    actorName: String(options.actorName || "").trim(),
+    meta: {
+      agentId: nextAgent.id,
+      ownerId: nextAgent.ownerId,
+      role: nextAgent.role,
+      surface: nextAgent.surface
+    }
+  })).project;
+}
+
 export async function createSharedInvite(cwd, member = {}, options = {}) {
   const existing = await loadSharedProject(cwd);
   requireOwner(existing, options.actorId);