@tritard/waterbrother 0.16.139 → 0.16.141

package/package.json

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

package/src/discord.js

@@ -7,18 +7,25 @@ import { loadGatewayBridge, loadGatewayState, saveGatewayBridge, saveGatewayStat
 import {
   acceptSharedInvite,
   approveSharedInvite,
+  assignSharedTask,
+  addSharedTask,
   claimSharedOperator,
+  claimSharedTask,
+  commentSharedTask,
   createSharedInvite,
   enableSharedProject,
+  getSharedTaskHistory,
   listSharedEvents,
   listSharedInvites,
   listSharedTasks,
   loadSharedProject,
+  moveSharedTask,
   rejectSharedInvite,
   releaseSharedOperator,
   removeSharedMember,
   setSharedRoom,
-  setSharedRoomMode
+  setSharedRoomMode,
+  upsertSharedAgent
 } from "./shared-project.js";
 
 const DISCORD_API_BASE = "https://discord.com/api/v10";
@@ -159,8 +166,19 @@ function buildDiscordHelp() {
     "/project share enable Roundtable on the current project and bind this Discord channel",
     "/room show shared room status for the current project",
     "/people list recently seen Discord users in this channel",
+    "/terminals list live Waterbrother terminals for this project",
+    "/executor show the selected executor",
+    "/reviewer show the assigned reviewer",
+    "/verifier show the assigned verifier",
+    "/assign-role <terminal|this terminal> <executor|reviewer|verifier|standby> assign a room role",
     "/members list shared room members",
     "/tasks list shared room tasks",
+    "/task add <text> add a shared task",
+    "/task move <id> <open|active|blocked|done> move a shared task",
+    "/task assign <id> <member-id> assign a shared task",
+    "/task claim <id> claim a shared task for yourself",
+    "/task comment <id> <text> add a shared task comment",
+    "/task history <id> show shared task history and comments",
     "/events list recent shared room events",
     "/invites list pending shared room invites",
     "/invite <@user|user-id> [owner|editor|observer] create a shared room invite",
@@ -310,6 +328,77 @@ function formatDiscordPeople({ people = [], project = null } = {}) {
   ].join("\n");
 }
 
+function getAgentOwnerDisplay(agent = {}, fallback = "") {
+  return String(agent?.ownerName || fallback || agent?.label || agent?.ownerId || agent?.id || "unknown").trim() || "unknown";
+}
+
+function getAgentTerminalDisplay(agent = {}, fallback = "") {
+  return String(agent?.label || fallback || agent?.ownerName || agent?.ownerId || agent?.id || "terminal").trim() || "terminal";
+}
+
+function formatBridgeHostLabel(host = {}) {
+  const owner = String(host?.ownerName || host?.ownerId || "").trim();
+  const label = String(host?.label || "").trim();
+  const sessionSuffix = String(host?.sessionId || "").trim().slice(-6);
+  const runtime = host?.provider && host?.model ? `${host.provider}/${host.model}` : "";
+  const primary = label || owner || (sessionSuffix ? `terminal ${sessionSuffix}` : "live terminal");
+  return [primary, owner && label && owner !== label ? `(${owner})` : "", runtime ? `[${runtime}]` : ""].filter(Boolean).join(" ").trim();
+}
+
+function chooseAgentByRole(project = {}, role = "") {
+  return (Array.isArray(project?.agents) ? project.agents : []).find((agent) => String(agent?.role || "").trim() === String(role || "").trim()) || null;
+}
+
+function formatDiscordAgentStatus(title, agent = null, options = {}) {
+  if (!agent) return `${title}\nNo ${String(title || "").toLowerCase()} is assigned yet.`;
+  return [
+    title,
+    `owner: ${getAgentOwnerDisplay(agent)}`,
+    `terminal: ${getAgentTerminalDisplay(agent)}`,
+    `role: ${agent.role || "standby"}`,
+    `runtime: ${agent.provider && agent.model ? `${agent.provider}/${agent.model}` : "unknown"}`,
+    `live: ${options.live ? "yes" : "no"}`
+  ].join("\n");
+}
+
+function formatDiscordLiveHosts(hosts = []) {
+  if (!hosts.length) return "Live terminals\n- none";
+  return [
+    "Live terminals",
+    ...hosts.map((host) => `- ${formatBridgeHostLabel(host)}${host?.surface ? ` (${host.surface})` : ""}`)
+  ].join("\n");
+}
+
+function formatDiscordTaskHistory(result = {}) {
+  const task = result?.task;
+  if (!task) return "No shared task found.";
+  const lines = [
+    `Task [${task.id}]`,
+    `${task.text}`,
+    `state: ${task.state}${task.assignedTo ? `  assigned: ${task.assignedTo}` : ""}`,
+    "",
+    "History"
+  ];
+  const history = Array.isArray(result.history) ? result.history : [];
+  const comments = Array.isArray(result.comments) ? result.comments : [];
+  if (history.length) {
+    for (const entry of history.slice(-8)) {
+      lines.push(`- ${entry.createdAt} ${entry.type} ${entry.text}`);
+    }
+  } else {
+    lines.push("- none");
+  }
+  lines.push("", "Comments");
+  if (comments.length) {
+    for (const comment of comments.slice(-8)) {
+      lines.push(`- ${comment.createdAt} ${comment.actorName || comment.actorId || "unknown"}: ${comment.text}`);
+    }
+  } else {
+    lines.push("- none");
+  }
+  return lines.join("\n");
+}
+
 function parseDiscordInviteCommand(message = {}, text = "") {
   const value = String(text || "").trim();
   const match = value.match(/^\/?(?:room\s+)?invite\s+(.+)$/i);
@@ -467,6 +556,60 @@ function resolveDiscordInviteTarget(state, message = {}, rawTarget = "") {
   return direct;
 }
 
+function resolveDiscordAgentTarget(project = {}, liveHosts = [], rawTarget = "") {
+  const value = String(rawTarget || "").trim().toLowerCase();
+  if (!value) return null;
+  if (/^(?:this|my)(?:\s+terminal)?$/.test(value)) {
+    const host = liveHosts[0] || null;
+    if (!host) return null;
+    return {
+      id: `agent:discord-bridge:${String(host.sessionId || host.pid || "current").trim()}`,
+      ownerId: String(host.ownerId || "").trim(),
+      ownerName: String(host.ownerName || "").trim(),
+      label: String(host.label || "").trim(),
+      surface: String(host.surface || "live-tui").trim(),
+      provider: String(host.provider || "").trim(),
+      model: String(host.model || "").trim(),
+      runtimeProfile: String(host.runtimeProfile || "").trim(),
+      sessionId: String(host.sessionId || "").trim(),
+      cwd: String(host.cwd || "").trim(),
+      role: "standby"
+    };
+  }
+  if (["executor", "reviewer", "verifier"].includes(value)) {
+    return chooseAgentByRole(project, value);
+  }
+  const candidates = [
+    ...(Array.isArray(project?.agents) ? project.agents : []),
+    ...liveHosts.map((host) => ({
+      id: `agent:discord-bridge:${String(host.sessionId || host.pid || "current").trim()}`,
+      ownerId: String(host.ownerId || "").trim(),
+      ownerName: String(host.ownerName || "").trim(),
+      label: String(host.label || "").trim(),
+      surface: String(host.surface || "live-tui").trim(),
+      provider: String(host.provider || "").trim(),
+      model: String(host.model || "").trim(),
+      runtimeProfile: String(host.runtimeProfile || "").trim(),
+      sessionId: String(host.sessionId || "").trim(),
+      cwd: String(host.cwd || "").trim(),
+      role: "standby"
+    }))
+  ];
+  const exact = candidates.find((agent) => {
+    const label = String(agent?.label || "").trim().toLowerCase();
+    const owner = String(agent?.ownerName || "").trim().toLowerCase();
+    const sessionId = String(agent?.sessionId || "").trim().toLowerCase();
+    return value === label || value === owner || value === sessionId;
+  });
+  if (exact) return exact;
+  const partial = candidates.filter((agent) => {
+    const label = String(agent?.label || "").trim().toLowerCase();
+    const owner = String(agent?.ownerName || "").trim().toLowerCase();
+    return (label && label.includes(value)) || (owner && owner.includes(value));
+  });
+  return partial.length === 1 ? partial[0] : null;
+}
+
 async function loadDiscordGatewayState() {
   return loadGatewayState("discord");
 }
@@ -875,6 +1018,133 @@ async function handleDiscordControlCommand(runtime, state, message, rawText) {
       "Use /room to inspect room state."
     ].join("\n");
   }
+  if (normalized === "/terminals" || normalized === "terminals" || normalized === "/live" || normalized === "live" || normalizedRoomAlias === "terminals") {
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const session = await loadSession(sessionId).catch(() => null);
+    const liveHosts = await getLiveBridgeHosts({ cwd: session?.cwd || "" });
+    return formatDiscordLiveHosts(liveHosts);
+  }
+  if (normalized === "/executor" || normalized === "executor" || normalizedRoomAlias === "executor") {
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { project, session } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    const agent = chooseAgentByRole(project, "executor");
+    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("Executor", agent, { live });
+  }
+  if (normalized === "/reviewer" || normalized === "reviewer" || normalizedRoomAlias === "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 agent = chooseAgentByRole(project, "reviewer");
+    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("Reviewer", agent, { live });
+  }
+  if (normalized === "/verifier" || normalized === "verifier" || normalizedRoomAlias === "verifier") {
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { project, session } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    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 });
+  }
+  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();
+    const match = body.match(/^(.+?)\s+(executor|reviewer|verifier|standby)\s*$/i);
+    if (!match) return "Usage: /assign-role <terminal|this terminal> <executor|reviewer|verifier|standby>";
+    const targetText = String(match[1] || "").trim();
+    const nextRole = String(match[2] || "").trim().toLowerCase();
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { project, session } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    const liveHosts = await getLiveBridgeHosts({ cwd: session?.cwd || "" });
+    const targetAgent = resolveDiscordAgentTarget(project, liveHosts, targetText);
+    if (!targetAgent) {
+      return `No terminal found for ${targetText}. Use /terminals first.`;
+    }
+    const actor = describeDiscordUser(message);
+    const nextProject = await upsertSharedAgent(session.cwd || process.cwd(), {
+      ...targetAgent,
+      role: nextRole
+    }, {
+      actorId: actor.userId,
+      actorName: actor.displayName
+    });
+    return [
+      "Room role updated",
+      `owner: ${getAgentOwnerDisplay(targetAgent, actor.displayName || actor.userId)}`,
+      `terminal: ${getAgentTerminalDisplay(targetAgent, "terminal")}`,
+      `role: ${nextRole}`,
+      `project: ${nextProject.projectName || "project"}`
+    ].join("\n");
+  }
+  if (normalized.startsWith("/task add ") || normalizedRoomAlias.startsWith("task add ")) {
+    const taskText = normalized.startsWith("/task add ") ? value.slice("/task add ".length).trim() : roomAlias.slice("task add ".length).trim();
+    if (!taskText) return "Usage: /task add <text>";
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { session, project } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    const actor = describeDiscordUser(message);
+    const result = await addSharedTask(session.cwd || process.cwd(), taskText, { actorId: actor.userId, actorName: actor.displayName });
+    return `Added shared task ${result.task.id}`;
+  }
+  if (normalized.startsWith("/task move ") || normalizedRoomAlias.startsWith("task move ")) {
+    const rest = normalized.startsWith("/task move ") ? value.slice("/task move ".length).trim() : roomAlias.slice("task move ".length).trim();
+    const [taskId, nextState] = rest.split(/\s+/, 2);
+    if (!taskId || !nextState) return "Usage: /task move <id> <open|active|blocked|done>";
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { session, project } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    const actor = describeDiscordUser(message);
+    const result = await moveSharedTask(session.cwd || process.cwd(), taskId, nextState, { actorId: actor.userId, actorName: actor.displayName });
+    return `Moved shared task ${result.task.id} to ${result.task.state}`;
+  }
+  if (normalized.startsWith("/task assign ") || normalizedRoomAlias.startsWith("task assign ")) {
+    const rest = normalized.startsWith("/task assign ") ? value.slice("/task assign ".length).trim() : roomAlias.slice("task assign ".length).trim();
+    const [taskId, memberId] = rest.split(/\s+/, 2);
+    if (!taskId || !memberId) return "Usage: /task assign <id> <member-id>";
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { session, project } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    const actor = describeDiscordUser(message);
+    const result = await assignSharedTask(session.cwd || process.cwd(), taskId, memberId, { actorId: actor.userId, actorName: actor.displayName });
+    return `Assigned shared task ${result.task.id} to ${memberId}`;
+  }
+  if (normalized.startsWith("/task claim ") || normalizedRoomAlias.startsWith("task claim ")) {
+    const taskId = normalized.startsWith("/task claim ") ? value.slice("/task claim ".length).trim() : roomAlias.slice("task claim ".length).trim();
+    if (!taskId) return "Usage: /task claim <id>";
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { session, project } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    const actor = describeDiscordUser(message);
+    const result = await claimSharedTask(session.cwd || process.cwd(), taskId, { actorId: actor.userId, actorName: actor.displayName });
+    return `Claimed shared task ${result.task.id}`;
+  }
+  if (normalized.startsWith("/task comment ") || normalizedRoomAlias.startsWith("task comment ")) {
+    const rest = normalized.startsWith("/task comment ") ? value.slice("/task comment ".length).trim() : roomAlias.slice("task comment ".length).trim();
+    const [taskId, ...parts] = rest.split(/\s+/);
+    const commentText = parts.join(" ").trim();
+    if (!taskId || !commentText) return "Usage: /task comment <id> <text>";
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { session, project } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    const actor = describeDiscordUser(message);
+    const result = await commentSharedTask(session.cwd || process.cwd(), taskId, commentText, { actorId: actor.userId, actorName: actor.displayName });
+    return `Commented on shared task ${result.task.id}`;
+  }
+  if (normalized.startsWith("/task history ") || normalizedRoomAlias.startsWith("task history ")) {
+    const taskId = normalized.startsWith("/task history ") ? value.slice("/task history ".length).trim() : roomAlias.slice("task history ".length).trim();
+    if (!taskId) return "Usage: /task history <id>";
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { session, project } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    const actor = describeDiscordUser(message);
+    const result = await getSharedTaskHistory(session.cwd || process.cwd(), taskId, { actorId: actor.userId, actorName: actor.displayName });
+    return formatDiscordTaskHistory(result);
+  }
   if (normalized === "/people" || normalized === "people" || normalizedRoomAlias === "people") {
     const sessionId = await ensurePeerSession(runtime, state, message);
     const { project } = await bindSharedRoomForMessage(message, sessionId);
@@ -1096,6 +1366,34 @@ async function getLiveBridgeHost({ cwd = "" } = {}) {
   return matchingHosts[0] || null;
 }
 
+async function getLiveBridgeHosts({ cwd = "" } = {}) {
+  const bridge = await loadGatewayBridge("discord");
+  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;
+    }
+    nextHosts.push(host);
+  }
+  if (changed || nextHosts.length !== hosts.length) {
+    bridge.hosts = nextHosts;
+    await saveGatewayBridge("discord", bridge);
+  }
+  return cwd
+    ? nextHosts.filter((host) => !host?.cwd || String(host.cwd) === String(cwd || ""))
+    : nextHosts;
+}
+
 async function runPromptViaBridge(runtime, message, promptText, options = {}) {
   const host = await getLiveBridgeHost();
   if (!host) {