@tritard/waterbrother 0.16.30 → 0.16.32

package/README.md

@@ -265,9 +265,9 @@ Shared project foundation is now live:
 - enable it with `waterbrother project share`
 - inspect it with `waterbrother room status`
 - control conversation vs execution with `waterbrother room mode chat|plan|execute`
-- manage collaborators with `waterbrother room members`, `waterbrother room add`, and `waterbrother room remove`
+- manage collaborators with `waterbrother room members`, `waterbrother room invites`, `waterbrother room invite`, `waterbrother room invite accept`, and `waterbrother room remove`
 - manage the shared backlog with `waterbrother room tasks`, `waterbrother room task add`, and `waterbrother room task move`
-- assign and claim shared work with `waterbrother room task assign` and `waterbrother room task claim`
+- assign, claim, and discuss shared work with `waterbrother room task assign`, `waterbrother room task claim`, `waterbrother room task comment`, and `waterbrother room task history`
 - choose a shared execution preset with `waterbrother room runtime <profile>`
 - claim or release the shared operator lock with `waterbrother room claim` and `waterbrother room release`
 - shared project metadata lives in `.waterbrother/shared.json`
@@ -281,7 +281,8 @@ Current Telegram behavior:
 - pending pairings are explicit and expire automatically after 12 hours unless approved
 - paired Telegram users drive the same live session and permissions as the terminal operator when the TUI bridge is attached
 - Telegram now supports remote workspace control with `/cwd`, `/use <path>`, `/desktop`, and `/new-project <name>`
-- shared projects now support `/room`, `/members`, `/tasks`, `/mode`, `/claim`, `/release`, `/invite`, `/remove-member`, `/room-runtime`, and `/task ...` from Telegram
+- shared projects now support `/room`, `/members`, `/invites`, `/tasks`, `/mode`, `/claim`, `/release`, `/invite`, `/accept-invite`, `/approve-invite`, `/reject-invite`, `/remove-member`, `/room-runtime`, and `/task ...` from Telegram
+- `/room` now includes pending invite count plus task ownership summaries
 - shared Telegram execution only runs when the shared room is in `execute` mode
 - room administration is owner-only, and only owners/editors can hold the operator lock
 - `/room` status now shows the active executor surface plus provider/model/runtime identity

package/package.json

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

package/src/cli.js

@@ -59,17 +59,24 @@ import { formatPlanForDisplay } from "./planner.js";
 import { parseCharterFromGoal, runExperimentLoop, formatExperimentSummary, gitReturnToBranch } from "./experiment.js";
 import {
   addSharedTask,
+  acceptSharedInvite,
+  approveSharedInvite,
   assignSharedTask,
   claimSharedOperator,
   claimSharedTask,
+  commentSharedTask,
+  createSharedInvite,
   disableSharedProject,
   enableSharedProject,
   formatSharedProjectStatus,
+  getSharedTaskHistory,
   getSharedProjectPaths,
+  listSharedInvites,
   listSharedMembers,
   listSharedTasks,
   loadSharedProject,
   moveSharedTask,
+  rejectSharedInvite,
   releaseSharedOperator,
   removeSharedMember,
   setSharedRuntimeProfile,
@@ -158,13 +165,20 @@ const INTERACTIVE_COMMANDS = [
   { name: "/unshare-project", description: "Disable shared-project mode in the current cwd" },
   { name: "/room", description: "Show shared room status for the current project" },
   { name: "/room members", description: "List shared-project members" },
+  { name: "/room invites", description: "List pending shared-project invites" },
   { name: "/room add <id> [owner|editor|observer]", description: "Add or update a shared-project member" },
+  { name: "/room invite <id> [owner|editor|observer]", description: "Create a pending shared-project invite" },
+  { name: "/room invite approve <invite-id>", description: "Approve a pending shared-project invite" },
+  { name: "/room invite accept <invite-id>", description: "Accept your own pending shared-project invite" },
+  { name: "/room invite reject <invite-id>", description: "Reject a pending shared-project invite" },
   { name: "/room remove <id>", description: "Remove a shared-project member" },
   { name: "/room tasks", description: "List Roundtable tasks for the shared project" },
   { name: "/room task add <text>", description: "Add a Roundtable task" },
   { name: "/room task assign <id> <member-id>", description: "Assign a Roundtable task to a shared member" },
   { name: "/room task claim <id>", description: "Claim a Roundtable task for yourself" },
   { name: "/room task move <id> <open|active|blocked|done>", description: "Move a Roundtable task between states" },
+  { name: "/room task comment <id> <text>", description: "Add a Roundtable task comment" },
+  { name: "/room task history <id>", description: "Show Roundtable task history and comments" },
   { name: "/room runtime", description: "Show the shared room runtime profile" },
   { name: "/room runtime <name|clear>", description: "Set or clear the shared room runtime profile" },
   { name: "/room mode <chat|plan|execute>", description: "Set collaboration mode for the shared room" },
@@ -2626,8 +2640,22 @@ function buildRoomStatusPayload(project, runtime = null, currentSession = null)
   if (!project) {
     return { enabled: false };
   }
+  const tasks = Array.isArray(project.tasks) ? project.tasks : [];
+  const taskSummary = {
+    total: tasks.length,
+    byState: {},
+    byAssignee: {}
+  };
+  for (const task of tasks) {
+    const state = String(task?.state || "open");
+    taskSummary.byState[state] = (taskSummary.byState[state] || 0) + 1;
+    const assignee = String(task?.assignedTo || "").trim() || "unassigned";
+    taskSummary.byAssignee[assignee] = (taskSummary.byAssignee[assignee] || 0) + 1;
+  }
   return {
     ...project,
+    pendingInviteCount: Array.isArray(project.pendingInvites) ? project.pendingInvites.length : 0,
+    taskSummary,
     executor: {
       surface: "local-tui",
       roomRuntimeProfile: project.runtimeProfile || "",
@@ -3832,6 +3860,22 @@ async function runRoomCommand(positional, { cwd = process.cwd(), asJson = false,
     return;
   }
 
+  if (sub === "invites") {
+    const invites = await listSharedInvites(cwd);
+    if (asJson) {
+      printData({ ok: true, invites }, true);
+      return;
+    }
+    if (!invites.length) {
+      console.log("No pending shared-project invites");
+      return;
+    }
+    for (const invite of invites) {
+      console.log(`${invite.id}\t${invite.memberId}\t${invite.role}\t${invite.memberName || ""}`);
+    }
+    return;
+  }
+
   if (sub === "tasks") {
     const tasks = await listSharedTasks(cwd);
     if (asJson) {
@@ -3904,7 +3948,40 @@ async function runRoomCommand(positional, { cwd = process.cwd(), asJson = false,
       console.log(`Claimed shared task [${result.task.id}]`);
       return;
     }
-    throw new Error("Usage: waterbrother room task add <text>|assign <id> <member-id>|claim <id>|move <id> <open|active|blocked|done>");
+    if (action === "comment") {
+      const taskId = String(positional[3] || "").trim();
+      const text = String(positional.slice(4).join(" ") || "").trim();
+      if (!taskId || !text) {
+        throw new Error("Usage: waterbrother room task comment <id> <text>");
+      }
+      const result = await commentSharedTask(cwd, taskId, text, { actorId: operator.id, actorName: operator.name });
+      if (asJson) {
+        printData({ ok: true, action: "task-comment", task: result.task, comment: result.comment, project: result.project }, true);
+        return;
+      }
+      console.log(`Commented on shared task [${result.task.id}]`);
+      return;
+    }
+    if (action === "history") {
+      const taskId = String(positional[3] || "").trim();
+      if (!taskId) {
+        throw new Error("Usage: waterbrother room task history <id>");
+      }
+      const result = await getSharedTaskHistory(cwd, taskId, { actorId: operator.id });
+      if (asJson) {
+        printData({ ok: true, action: "task-history", ...result }, true);
+        return;
+      }
+      console.log(`[${result.task.id}] ${result.task.text}`);
+      for (const entry of result.history) {
+        console.log(`history\t${entry.createdAt}\t${entry.type}\t${entry.actorName || entry.actorId || "-"}\t${entry.text}`);
+      }
+      for (const comment of result.comments) {
+        console.log(`comment\t${comment.createdAt}\t${comment.actorName || comment.actorId || "-"}\t${comment.text}`);
+      }
+      return;
+    }
+    throw new Error("Usage: waterbrother room task add <text>|assign <id> <member-id>|claim <id>|move <id> <open|active|blocked|done>|comment <id> <text>|history <id>");
   }
 
   if (sub === "add") {
@@ -3927,6 +4004,45 @@ async function runRoomCommand(positional, { cwd = process.cwd(), asJson = false,
     return;
   }
 
+  if (sub === "invite") {
+    const actionOrMemberId = String(positional[2] || "").trim();
+    const maybeAction = actionOrMemberId.toLowerCase();
+    if (maybeAction === "approve" || maybeAction === "reject" || maybeAction === "accept") {
+      const inviteId = String(positional[3] || "").trim();
+      if (!inviteId) {
+        throw new Error(`Usage: waterbrother room invite ${maybeAction} <invite-id>`);
+      }
+      const result = maybeAction === "approve"
+        ? await approveSharedInvite(cwd, inviteId, { actorId: operator.id })
+        : maybeAction === "accept"
+          ? await acceptSharedInvite(cwd, inviteId, { actorId: operator.id, actorName: operator.name })
+          : await rejectSharedInvite(cwd, inviteId, { actorId: operator.id });
+      if (asJson) {
+        printData({ ok: true, action: `invite-${maybeAction}`, invite: result.invite, project: result.project }, true);
+        return;
+      }
+      console.log(`${maybeAction === "approve" ? "Approved" : maybeAction === "accept" ? "Accepted" : "Rejected"} shared invite [${result.invite.id}]`);
+      return;
+    }
+    const memberId = actionOrMemberId;
+    const role = String(positional[3] || "editor").trim().toLowerCase();
+    const name = String(positional.slice(4).join(" ") || memberId).trim();
+    if (!memberId) {
+      throw new Error("Usage: waterbrother room invite <member-id> [owner|editor|observer] [display name]|approve <invite-id>|accept <invite-id>|reject <invite-id>");
+    }
+    const result = await createSharedInvite(
+      cwd,
+      { id: memberId, role, name, paired: true },
+      { actorId: operator.id, actorName: operator.name }
+    );
+    if (asJson) {
+      printData({ ok: true, action: "invite", invite: result.invite, project: result.project }, true);
+      return;
+    }
+    console.log(`Created shared-project invite [${result.invite.id}] for ${memberId} as ${result.invite.role}`);
+    return;
+  }
+
   if (sub === "remove") {
     const memberId = String(positional[2] || "").trim();
     if (!memberId) {
@@ -4009,7 +4125,7 @@ async function runRoomCommand(positional, { cwd = process.cwd(), asJson = false,
     return;
   }
 
-  throw new Error("Usage: waterbrother room status|members|add <member-id> [owner|editor|observer] [display name]|remove <member-id>|tasks|task add <text>|task assign <id> <member-id>|task claim <id>|task move <id> <open|active|blocked|done>|runtime [<name>|clear]|mode <chat|plan|execute>|claim|release");
+  throw new Error("Usage: waterbrother room status|members|invites|add <member-id> [owner|editor|observer] [display name]|invite <member-id> [owner|editor|observer] [display name]|invite approve <invite-id>|invite accept <invite-id>|invite reject <invite-id>|remove <member-id>|tasks|task add <text>|task assign <id> <member-id>|task claim <id>|task move <id> <open|active|blocked|done>|task comment <id> <text>|task history <id>|runtime [<name>|clear]|mode <chat|plan|execute>|claim|release");
 }
 
 async function runMcpCommand(positional, runtime, { cwd, asJson = false } = {}) {
@@ -7860,6 +7976,15 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
       continue;
     }
 
+    if (line === "/room invites") {
+      try {
+        await runRoomCommand(["room", "invites"], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession, agent, context });
+      } catch (error) {
+        console.log(`room invites failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      continue;
+    }
+
     if (line === "/room tasks") {
       try {
         await runRoomCommand(["room", "tasks"], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession, agent, context });
@@ -7906,6 +8031,39 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
       continue;
     }
 
+    if (line.startsWith("/room invite ")) {
+      const raw = line.replace("/room invite", "").trim();
+      if (!raw) {
+        console.log("Usage: /room invite <member-id> [owner|editor|observer] [display name] | /room invite approve <invite-id> | /room invite accept <invite-id> | /room invite reject <invite-id>");
+        continue;
+      }
+      const parts = raw.split(/\s+/).filter(Boolean);
+      const first = String(parts[0] || "").toLowerCase();
+      try {
+        if (["approve", "accept", "reject"].includes(first)) {
+          const inviteId = String(parts[1] || "").trim();
+          if (!inviteId) {
+            console.log(`Usage: /room invite ${first} <invite-id>`);
+            continue;
+          }
+          await runRoomCommand(["room", "invite", first, inviteId], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession, agent, context });
+        } else {
+          const memberId = parts.shift() || "";
+          let role = "editor";
+          if (parts.length && ["owner", "editor", "observer"].includes(String(parts[0] || "").toLowerCase())) {
+            role = String(parts.shift() || "editor").toLowerCase();
+          }
+          const displayName = parts.join(" ").trim();
+          const positional = ["room", "invite", memberId, role];
+          if (displayName) positional.push(...displayName.split(" "));
+          await runRoomCommand(positional, { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession, agent, context });
+        }
+      } catch (error) {
+        console.log(`room invite failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      continue;
+    }
+
     if (line.startsWith("/room task add ")) {
       const text = line.replace("/room task add", "").trim();
       if (!text) {
@@ -7935,6 +8093,36 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
       continue;
     }
 
+    if (line.startsWith("/room task comment ")) {
+      const raw = line.replace("/room task comment", "").trim();
+      const [taskId, ...textParts] = raw.split(/\s+/);
+      const text = textParts.join(" ").trim();
+      if (!taskId || !text) {
+        console.log("Usage: /room task comment <id> <text>");
+        continue;
+      }
+      try {
+        await runRoomCommand(["room", "task", "comment", taskId, ...text.split(" ")], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession, agent, context });
+      } catch (error) {
+        console.log(`room task comment failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      continue;
+    }
+
+    if (line.startsWith("/room task history ")) {
+      const taskId = line.replace("/room task history", "").trim();
+      if (!taskId) {
+        console.log("Usage: /room task history <id>");
+        continue;
+      }
+      try {
+        await runRoomCommand(["room", "task", "history", taskId], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession, agent, context });
+      } catch (error) {
+        console.log(`room task history failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      continue;
+    }
+
     if (line.startsWith("/room task assign ")) {
       const raw = line.replace("/room task assign", "").trim();
       const [taskId, memberId] = raw.split(/\s+/, 2);

package/src/gateway.js

@@ -8,7 +8,7 @@ import { createSession, listSessions, loadSession, saveSession } from "./session
 import { DEFAULT_PENDING_PAIRING_TTL_MINUTES, loadGatewayBridge, loadGatewayState, prunePendingPairings, saveGatewayBridge, saveGatewayState } from "./gateway-state.js";
 import { getGatewayStatus, getChannelSpec } from "./channels.js";
 import { canonicalizeLoosePath } from "./path-utils.js";
-import { addSharedTask, assignSharedTask, claimSharedOperator, claimSharedTask, getSharedMember, listSharedTasks, loadSharedProject, moveSharedTask, releaseSharedOperator, setSharedRoom, setSharedRoomMode, setSharedRuntimeProfile, upsertSharedMember, removeSharedMember } from "./shared-project.js";
+import { acceptSharedInvite, addSharedTask, approveSharedInvite, assignSharedTask, claimSharedOperator, claimSharedTask, commentSharedTask, createSharedInvite, getSharedTaskHistory, listSharedInvites, listSharedTasks, loadSharedProject, moveSharedTask, rejectSharedInvite, releaseSharedOperator, setSharedRoom, setSharedRoomMode, setSharedRuntimeProfile, removeSharedMember } from "./shared-project.js";
 
 const execFileAsync = promisify(execFile);
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
@@ -27,6 +27,7 @@ const TELEGRAM_COMMANDS = [
   { command: "runtime", description: "Show active runtime status" },
   { command: "room", description: "Show shared room status" },
   { command: "members", description: "List shared room members" },
+  { command: "invites", description: "List pending shared room invites" },
   { command: "tasks", description: "List shared Roundtable tasks" },
   { command: "room_runtime", description: "Show or set shared room runtime profile" },
   { command: "mode", description: "Show or set shared room mode" },
@@ -208,8 +209,14 @@ function buildRemoteHelp() {
     "<code>/task assign &lt;id&gt; &lt;member-id&gt;</code> assign a shared task",
     "<code>/task claim &lt;id&gt;</code> claim a shared task for yourself",
     "<code>/task move &lt;id&gt; &lt;open|active|blocked|done&gt;</code> move a shared Roundtable task",
+    "<code>/task comment &lt;id&gt; &lt;text&gt;</code> add a task comment",
+    "<code>/task history &lt;id&gt;</code> show task history and comments",
     "<code>/room-runtime</code> or <code>/room-runtime &lt;name|clear&gt;</code> inspect or set the shared room runtime profile",
-    "<code>/invite &lt;user-id&gt; [owner|editor|observer]</code> add or update a shared project member",
+    "<code>/invites</code> list pending shared invites",
+    "<code>/invite &lt;user-id&gt; [owner|editor|observer]</code> create a pending shared-project invite",
+    "<code>/accept-invite &lt;invite-id&gt;</code> accept your own pending invite",
+    "<code>/approve-invite &lt;invite-id&gt;</code> approve a pending invite",
+    "<code>/reject-invite &lt;invite-id&gt;</code> reject a pending invite",
     "<code>/remove-member &lt;user-id&gt;</code> remove a shared project member",
     "<code>/mode</code> or <code>/mode &lt;chat|plan|execute&gt;</code> inspect or change shared room mode",
     "<code>/claim</code> claim operator control for a shared project",
@@ -293,6 +300,20 @@ function formatTelegramRoomMarkup(project, options = {}) {
     ? members.map((member) => `• ${escapeTelegramHtml(member.name || member.id)} <i>(${escapeTelegramHtml(member.role || "editor")})</i>`).join("\n")
     : "• none";
   const executor = options.executor || {};
+  const pendingInviteCount = Array.isArray(project.pendingInvites) ? project.pendingInvites.length : 0;
+  const tasks = Array.isArray(project.tasks) ? project.tasks : [];
+  const byState = new Map();
+  const byAssignee = new Map();
+  for (const task of tasks) {
+    const state = String(task?.state || "open");
+    byState.set(state, (byState.get(state) || 0) + 1);
+    const assignee = String(task?.assignedTo || "").trim() || "unassigned";
+    byAssignee.set(assignee, (byAssignee.get(assignee) || 0) + 1);
+  }
+  const ownershipLines = [...byAssignee.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 4)
+    .map(([assignee, count]) => `• <code>${escapeTelegramHtml(assignee)}</code> ${count}`);
   const executorBits = [
     `surface: <code>${escapeTelegramHtml(executor.surface || "telegram")}</code>`,
     `provider: <code>${escapeTelegramHtml(executor.provider || "unknown")}</code>`,
@@ -314,8 +335,14 @@ function formatTelegramRoomMarkup(project, options = {}) {
     `room mode: <code>${escapeTelegramHtml(project.roomMode || "chat")}</code>`,
     `room: <code>${escapeTelegramHtml(roomLabel)}</code>`,
     `active operator: <code>${escapeTelegramHtml(active)}</code>`,
+    `pending invites: <code>${pendingInviteCount}</code>`,
     "<b>Executor</b>",
     ...executorBits,
+    "<b>Task Summary</b>",
+    `total: <code>${tasks.length}</code>`,
+    ...[...byState.entries()].map(([state, count]) => `${escapeTelegramHtml(state)}: <code>${count}</code>`),
+    "<b>Ownership</b>",
+    ...(ownershipLines.length ? ownershipLines : ["• none"]),
     "<b>Members</b>",
     memberLines
   ].join("\n");
@@ -335,6 +362,16 @@ function formatTelegramMembersMarkup(project) {
   ].join("\n");
 }
 
+function formatTelegramInvitesMarkup(invites = []) {
+  if (!invites.length) {
+    return "<b>Pending invites</b>\n• none";
+  }
+  return [
+    "<b>Pending invites</b>",
+    ...invites.map((invite) => `• <code>${escapeTelegramHtml(invite.id)}</code> ${escapeTelegramHtml(invite.memberName || invite.memberId)} <i>(${escapeTelegramHtml(invite.role)})</i>`)
+  ].join("\n");
+}
+
 function formatTelegramTasksMarkup(tasks = []) {
   if (!tasks.length) {
     return "<b>Shared tasks</b>\n• none";
@@ -345,6 +382,35 @@ function formatTelegramTasksMarkup(tasks = []) {
   ].join("\n");
 }
 
+function formatTelegramTaskHistoryMarkup(result) {
+  const task = result?.task;
+  if (!task) return "No shared task found.";
+  const lines = [
+    `<b>Task</b> <code>${escapeTelegramHtml(task.id)}</code>`,
+    `${escapeTelegramHtml(task.text)}`,
+    `state: <code>${escapeTelegramHtml(task.state)}</code>${task.assignedTo ? `  assigned: <code>${escapeTelegramHtml(task.assignedTo)}</code>` : ""}`
+  ];
+  const history = Array.isArray(result.history) ? result.history : [];
+  const comments = Array.isArray(result.comments) ? result.comments : [];
+  lines.push("", "<b>History</b>");
+  if (history.length) {
+    for (const entry of history.slice(-8)) {
+      lines.push(`• ${escapeTelegramHtml(entry.createdAt)} ${escapeTelegramHtml(entry.type)} ${escapeTelegramHtml(entry.text)}`);
+    }
+  } else {
+    lines.push("• none");
+  }
+  lines.push("", "<b>Comments</b>");
+  if (comments.length) {
+    for (const comment of comments.slice(-8)) {
+      lines.push(`• ${escapeTelegramHtml(comment.actorName || comment.actorId || "-")}: ${escapeTelegramHtml(comment.text)}`);
+    }
+  } else {
+    lines.push("• none");
+  }
+  return lines.join("\n");
+}
+
 function classifyTelegramGroupIntent(text = "") {
   const normalized = String(text || "").trim();
   const lower = normalized.toLowerCase();
@@ -1052,6 +1118,21 @@ class TelegramGateway {
       return;
     }
 
+    if (text === "/invites") {
+      const { session, project } = await this.bindSharedRoomForMessage(message, sessionId);
+      if (!project?.enabled) {
+        await this.sendMessage(message.chat.id, "This project is not shared.", message.message_id);
+        return;
+      }
+      try {
+        const invites = await listSharedInvites(session.cwd || this.cwd);
+        await this.sendMessage(message.chat.id, formatTelegramInvitesMarkup(invites), message.message_id);
+      } catch (error) {
+        await this.sendMessage(message.chat.id, escapeTelegramHtml(error instanceof Error ? error.message : String(error)), message.message_id);
+      }
+      return;
+    }
+
     if (text === "/tasks") {
       const { session, project } = await this.bindSharedRoomForMessage(message, sessionId);
       if (!project?.enabled) {
@@ -1066,7 +1147,7 @@ class TelegramGateway {
     if (text.startsWith("/task ")) {
       const taskShortcut = text.replace("/task", "").trim().toLowerCase();
       if (taskShortcut === "") {
-        await this.sendMessage(message.chat.id, "Usage: /task add <text> | /task assign <id> <member-id> | /task claim <id> | /task move <id> <open|active|blocked|done>", message.message_id);
+        await this.sendMessage(message.chat.id, "Usage: /task add <text> | /task assign <id> <member-id> | /task claim <id> | /task move <id> <open|active|blocked|done> | /task comment <id> <text> | /task history <id>", message.message_id);
         return;
       }
     }
@@ -1179,15 +1260,14 @@ class TelegramGateway {
         return;
       }
       try {
-        const next = await upsertSharedMember(
+        const result = await createSharedInvite(
           session.cwd || this.cwd,
           { id: nextUserId, role, name: nextUserId, paired: true },
-          { actorId: userId }
+          { actorId: userId, actorName: peer?.username || [message?.from?.first_name, message?.from?.last_name].filter(Boolean).join(" ").trim() || userId }
         );
-        const member = getSharedMember(next, nextUserId);
         await this.sendMessage(
           message.chat.id,
-          `Shared member set: <code>${escapeTelegramHtml(member?.id || nextUserId)}</code> <i>(${escapeTelegramHtml(member?.role || role)})</i>`,
+          `Created pending invite <code>${escapeTelegramHtml(result.invite.id)}</code> for <code>${escapeTelegramHtml(result.invite.memberId)}</code> <i>(${escapeTelegramHtml(result.invite.role)})</i>`,
           message.message_id
         );
       } catch (error) {
@@ -1196,6 +1276,69 @@ class TelegramGateway {
       return;
     }
 
+    if (text.startsWith("/approve-invite ")) {
+      const { session, project } = await this.bindSharedRoomForMessage(message, sessionId);
+      if (!project?.enabled) {
+        await this.sendMessage(message.chat.id, "This project is not shared.", message.message_id);
+        return;
+      }
+      const inviteId = text.replace("/approve-invite", "").trim();
+      if (!inviteId) {
+        await this.sendMessage(message.chat.id, "Usage: /approve-invite <invite-id>", message.message_id);
+        return;
+      }
+      try {
+        const result = await approveSharedInvite(session.cwd || this.cwd, inviteId, { actorId: userId });
+        await this.sendMessage(message.chat.id, `Approved invite <code>${escapeTelegramHtml(result.invite.id)}</code>`, message.message_id);
+      } catch (error) {
+        await this.sendMessage(message.chat.id, escapeTelegramHtml(error instanceof Error ? error.message : String(error)), message.message_id);
+      }
+      return;
+    }
+
+    if (text.startsWith("/accept-invite ")) {
+      const { session, project } = await this.bindSharedRoomForMessage(message, sessionId);
+      if (!project?.enabled) {
+        await this.sendMessage(message.chat.id, "This project is not shared.", message.message_id);
+        return;
+      }
+      const inviteId = text.replace("/accept-invite", "").trim();
+      if (!inviteId) {
+        await this.sendMessage(message.chat.id, "Usage: /accept-invite <invite-id>", message.message_id);
+        return;
+      }
+      try {
+        const result = await acceptSharedInvite(session.cwd || this.cwd, inviteId, {
+          actorId: userId,
+          actorName: peer?.username || [message?.from?.first_name, message?.from?.last_name].filter(Boolean).join(" ").trim() || userId
+        });
+        await this.sendMessage(message.chat.id, `Accepted invite <code>${escapeTelegramHtml(result.invite.id)}</code>`, message.message_id);
+      } catch (error) {
+        await this.sendMessage(message.chat.id, escapeTelegramHtml(error instanceof Error ? error.message : String(error)), message.message_id);
+      }
+      return;
+    }
+
+    if (text.startsWith("/reject-invite ")) {
+      const { session, project } = await this.bindSharedRoomForMessage(message, sessionId);
+      if (!project?.enabled) {
+        await this.sendMessage(message.chat.id, "This project is not shared.", message.message_id);
+        return;
+      }
+      const inviteId = text.replace("/reject-invite", "").trim();
+      if (!inviteId) {
+        await this.sendMessage(message.chat.id, "Usage: /reject-invite <invite-id>", message.message_id);
+        return;
+      }
+      try {
+        const result = await rejectSharedInvite(session.cwd || this.cwd, inviteId, { actorId: userId });
+        await this.sendMessage(message.chat.id, `Rejected invite <code>${escapeTelegramHtml(result.invite.id)}</code>`, message.message_id);
+      } catch (error) {
+        await this.sendMessage(message.chat.id, escapeTelegramHtml(error instanceof Error ? error.message : String(error)), message.message_id);
+      }
+      return;
+    }
+
     if (text.startsWith("/remove-member ")) {
       const { session, project } = await this.bindSharedRoomForMessage(message, sessionId);
       if (!project?.enabled) {
@@ -1280,6 +1423,51 @@ class TelegramGateway {
       return;
     }
 
+    if (text.startsWith("/task comment ")) {
+      const { session, project } = await this.bindSharedRoomForMessage(message, sessionId);
+      if (!project?.enabled) {
+        await this.sendMessage(message.chat.id, "This project is not shared.", message.message_id);
+        return;
+      }
+      const rest = text.replace("/task comment", "").trim();
+      const [taskId, ...textParts] = rest.split(/\s+/);
+      const commentText = textParts.join(" ").trim();
+      if (!taskId || !commentText) {
+        await this.sendMessage(message.chat.id, "Usage: /task comment <id> <text>", message.message_id);
+        return;
+      }
+      try {
+        const result = await commentSharedTask(session.cwd || this.cwd, taskId, commentText, {
+          actorId: userId,
+          actorName: peer?.username || [message?.from?.first_name, message?.from?.last_name].filter(Boolean).join(" ").trim() || userId
+        });
+        await this.sendMessage(message.chat.id, `Commented on shared task <code>${escapeTelegramHtml(result.task.id)}</code>`, message.message_id);
+      } catch (error) {
+        await this.sendMessage(message.chat.id, escapeTelegramHtml(error instanceof Error ? error.message : String(error)), message.message_id);
+      }
+      return;
+    }
+
+    if (text.startsWith("/task history ")) {
+      const { session, project } = await this.bindSharedRoomForMessage(message, sessionId);
+      if (!project?.enabled) {
+        await this.sendMessage(message.chat.id, "This project is not shared.", message.message_id);
+        return;
+      }
+      const taskId = text.replace("/task history", "").trim();
+      if (!taskId) {
+        await this.sendMessage(message.chat.id, "Usage: /task history <id>", message.message_id);
+        return;
+      }
+      try {
+        const result = await getSharedTaskHistory(session.cwd || this.cwd, taskId, { actorId: userId });
+        await this.sendMessage(message.chat.id, formatTelegramTaskHistoryMarkup(result), message.message_id);
+      } catch (error) {
+        await this.sendMessage(message.chat.id, escapeTelegramHtml(error instanceof Error ? error.message : String(error)), message.message_id);
+      }
+      return;
+    }
+
     if (text.startsWith("/task claim ")) {
       const { session, project } = await this.bindSharedRoomForMessage(message, sessionId);
       if (!project?.enabled) {

package/src/shared-project.js

@@ -7,6 +7,10 @@ const SHARED_FILE = path.join(".waterbrother", "shared.json");
 const ROUNDTABLE_FILE = "ROUNDTABLE.md";
 const TASK_STATES = ["open", "active", "blocked", "done"];
 
+function makeId(prefix = "id") {
+  return `${prefix}_${crypto.randomBytes(3).toString("hex")}`;
+}
+
 function normalizeMember(member = {}) {
   return {
     id: String(member.id || "").trim(),
@@ -31,6 +35,11 @@ function normalizeSharedProject(project = {}, cwd = process.cwd()) {
         .map((task) => normalizeSharedTask(task))
         .filter((task) => task.id && task.text)
     : [];
+  const pendingInvites = Array.isArray(project.pendingInvites)
+    ? project.pendingInvites
+        .map((invite) => normalizePendingInvite(invite))
+        .filter((invite) => invite.id && invite.memberId && invite.status === "pending")
+    : [];
   const activeOperator = project.activeOperator && typeof project.activeOperator === "object"
     ? {
         id: String(project.activeOperator.id || "").trim(),
@@ -57,6 +66,7 @@ function normalizeSharedProject(project = {}, cwd = process.cwd()) {
     runtimeProfile: String(project.runtimeProfile || "").trim(),
     members,
     tasks,
+    pendingInvites,
     activeOperator: activeOperator?.id ? activeOperator : null,
     approvalPolicy: String(project.approvalPolicy || "owner").trim() || "owner",
     createdAt: String(project.createdAt || new Date().toISOString()).trim(),
@@ -65,14 +75,60 @@ function normalizeSharedProject(project = {}, cwd = process.cwd()) {
 }
 
 function normalizeSharedTask(task = {}) {
+  const comments = Array.isArray(task.comments)
+    ? task.comments
+        .map((comment) => normalizeTaskComment(comment))
+        .filter((comment) => comment.id && comment.text)
+    : [];
+  const history = Array.isArray(task.history)
+    ? task.history
+        .map((entry) => normalizeTaskHistoryEntry(entry))
+        .filter((entry) => entry.id && entry.type)
+    : [];
   return {
-    id: String(task.id || `rt_${crypto.randomBytes(3).toString("hex")}`).trim(),
+    id: String(task.id || makeId("rt")).trim(),
     text: String(task.text || "").trim(),
     state: TASK_STATES.includes(String(task.state || "").trim()) ? String(task.state).trim() : "open",
     createdAt: String(task.createdAt || new Date().toISOString()).trim(),
     updatedAt: String(task.updatedAt || new Date().toISOString()).trim(),
     createdBy: String(task.createdBy || "").trim(),
-    assignedTo: String(task.assignedTo || "").trim()
+    assignedTo: String(task.assignedTo || "").trim(),
+    comments,
+    history
+  };
+}
+
+function normalizeTaskComment(comment = {}) {
+  return {
+    id: String(comment.id || makeId("rtc")).trim(),
+    text: String(comment.text || "").trim(),
+    actorId: String(comment.actorId || "").trim(),
+    actorName: String(comment.actorName || "").trim(),
+    createdAt: String(comment.createdAt || new Date().toISOString()).trim()
+  };
+}
+
+function normalizeTaskHistoryEntry(entry = {}) {
+  return {
+    id: String(entry.id || makeId("rth")).trim(),
+    type: String(entry.type || "").trim(),
+    text: String(entry.text || "").trim(),
+    actorId: String(entry.actorId || "").trim(),
+    actorName: String(entry.actorName || "").trim(),
+    createdAt: String(entry.createdAt || new Date().toISOString()).trim()
+  };
+}
+
+function normalizePendingInvite(invite = {}) {
+  return {
+    id: String(invite.id || makeId("inv")).trim(),
+    memberId: String(invite.memberId || invite.userId || "").trim(),
+    memberName: String(invite.memberName || invite.name || "").trim(),
+    role: ["owner", "editor", "observer"].includes(String(invite.role || "").trim()) ? String(invite.role).trim() : "editor",
+    invitedBy: String(invite.invitedBy || "").trim(),
+    invitedByName: String(invite.invitedByName || "").trim(),
+    status: "pending",
+    createdAt: String(invite.createdAt || new Date().toISOString()).trim()
   };
 }
 
@@ -110,6 +166,9 @@ function defaultRoundtableContent(project) {
   const activeOperator = project.activeOperator?.id
     ? `${project.activeOperator.name || project.activeOperator.id}`
     : "none";
+  const inviteLines = (project.pendingInvites || []).length
+    ? project.pendingInvites.map((invite) => `- [${invite.id}] ${invite.memberName || invite.memberId} (${invite.role}) invited by ${invite.invitedByName || invite.invitedBy || "-"}`).join("\n")
+    : "- none";
   const taskLines = TASK_STATES.flatMap((state) => {
     const tasks = (project.tasks || []).filter((task) => task.state === state);
     if (!tasks.length) return [`- ${state}: -`];
@@ -129,6 +188,9 @@ function defaultRoundtableContent(project) {
     "## Members",
     memberLines,
     "",
+    "## Pending Invites",
+    inviteLines,
+    "",
     "## Current Goal",
     "-",
     "",
@@ -156,6 +218,13 @@ function buildRoundtableTaskSection(project) {
   return ["## Task Queue", ...taskLines, ""].join("\n");
 }
 
+function buildRoundtablePendingInviteSection(project) {
+  const lines = (project.pendingInvites || []).length
+    ? project.pendingInvites.map((invite) => `- [${invite.id}] ${invite.memberName || invite.memberId} (${invite.role}) invited by ${invite.invitedByName || invite.invitedBy || "-"}`)
+    : ["- none"];
+  return ["## Pending Invites", ...lines, ""].join("\n");
+}
+
 async function syncRoundtableTaskSection(cwd, project) {
   const target = roundtablePath(cwd);
   if (!(await pathExists(target))) return null;
@@ -171,6 +240,21 @@ async function syncRoundtableTaskSection(cwd, project) {
   return target;
 }
 
+async function syncRoundtablePendingInviteSection(cwd, project) {
+  const target = roundtablePath(cwd);
+  if (!(await pathExists(target))) return null;
+  const current = await fs.readFile(target, "utf8");
+  const nextSection = buildRoundtablePendingInviteSection(project);
+  let nextContent;
+  if (/^## Pending Invites\s*$/m.test(current)) {
+    nextContent = current.replace(/## Pending Invites[\s\S]*?(?=^## |\s*$)/m, `${nextSection}\n`);
+  } else {
+    nextContent = current.replace(/^## Current Goal/m, `${nextSection}\n## Current Goal`);
+  }
+  await fs.writeFile(target, nextContent.endsWith("\n") ? nextContent : `${nextContent}\n`, "utf8");
+  return target;
+}
+
 export async function ensureRoundtable(cwd, project) {
   const target = roundtablePath(cwd);
   if (await pathExists(target)) return target;
@@ -204,6 +288,7 @@ export async function saveSharedProject(cwd, project) {
   await writeJsonAtomically(sharedFilePath(cwd), next);
   await ensureRoundtable(cwd, next);
   await syncRoundtableTaskSection(cwd, next);
+  await syncRoundtablePendingInviteSection(cwd, next);
   return next;
 }
 
@@ -330,6 +415,12 @@ export async function listSharedMembers(cwd) {
   return project.members || [];
 }
 
+export async function listSharedInvites(cwd) {
+  const project = await loadSharedProject(cwd);
+  requireSharedProject(project);
+  return project.pendingInvites || [];
+}
+
 export async function upsertSharedMember(cwd, member = {}, options = {}) {
   const existing = await loadSharedProject(cwd);
   requireOwner(existing, options.actorId);
@@ -353,6 +444,125 @@ export async function upsertSharedMember(cwd, member = {}, options = {}) {
   return next;
 }
 
+export async function createSharedInvite(cwd, member = {}, options = {}) {
+  const existing = await loadSharedProject(cwd);
+  requireOwner(existing, options.actorId);
+  const inviteMember = normalizeMember(member);
+  if (!inviteMember.id) throw new Error("member id is required");
+  if (getSharedMember(existing, inviteMember.id)) {
+    throw new Error(`Member ${inviteMember.id} is already part of the shared project.`);
+  }
+  const pendingInvites = Array.isArray(existing.pendingInvites) ? [...existing.pendingInvites] : [];
+  const existingInviteIndex = pendingInvites.findIndex((invite) => invite.memberId === inviteMember.id);
+  const invite = normalizePendingInvite({
+    id: existingInviteIndex >= 0 ? pendingInvites[existingInviteIndex].id : "",
+    memberId: inviteMember.id,
+    memberName: inviteMember.name || inviteMember.id,
+    role: inviteMember.role,
+    invitedBy: String(options.actorId || "").trim(),
+    invitedByName: String(options.actorName || options.actorId || "").trim()
+  });
+  if (existingInviteIndex >= 0) pendingInvites[existingInviteIndex] = invite;
+  else pendingInvites.push(invite);
+  const next = await saveSharedProject(cwd, {
+    ...existing,
+    pendingInvites
+  });
+  await appendRoundtableEvent(
+    cwd,
+    `- ${new Date().toISOString()}: invite created [${invite.id}] for ${invite.memberName || invite.memberId} as ${invite.role}`
+  );
+  return { project: next, invite };
+}
+
+export async function approveSharedInvite(cwd, inviteId = "", options = {}) {
+  const existing = await loadSharedProject(cwd);
+  requireOwner(existing, options.actorId);
+  const normalizedId = String(inviteId || "").trim();
+  if (!normalizedId) throw new Error("invite id is required");
+  const pendingInvites = Array.isArray(existing.pendingInvites) ? [...existing.pendingInvites] : [];
+  const index = pendingInvites.findIndex((invite) => invite.id === normalizedId);
+  if (index < 0) throw new Error(`No pending invite found for ${normalizedId}`);
+  const invite = pendingInvites[index];
+  const members = Array.isArray(existing.members) ? [...existing.members] : [];
+  if (!members.some((item) => item.id === invite.memberId)) {
+    members.push(normalizeMember({
+      id: invite.memberId,
+      name: invite.memberName,
+      role: invite.role,
+      paired: true
+    }));
+  }
+  pendingInvites.splice(index, 1);
+  const next = await saveSharedProject(cwd, {
+    ...existing,
+    members,
+    pendingInvites
+  });
+  await appendRoundtableEvent(
+    cwd,
+    `- ${new Date().toISOString()}: invite approved [${invite.id}] for ${invite.memberName || invite.memberId}`
+  );
+  return { project: next, invite };
+}
+
+export async function rejectSharedInvite(cwd, inviteId = "", options = {}) {
+  const existing = await loadSharedProject(cwd);
+  requireOwner(existing, options.actorId);
+  const normalizedId = String(inviteId || "").trim();
+  if (!normalizedId) throw new Error("invite id is required");
+  const pendingInvites = Array.isArray(existing.pendingInvites) ? [...existing.pendingInvites] : [];
+  const index = pendingInvites.findIndex((invite) => invite.id === normalizedId);
+  if (index < 0) throw new Error(`No pending invite found for ${normalizedId}`);
+  const [invite] = pendingInvites.splice(index, 1);
+  const next = await saveSharedProject(cwd, {
+    ...existing,
+    pendingInvites
+  });
+  await appendRoundtableEvent(
+    cwd,
+    `- ${new Date().toISOString()}: invite rejected [${invite.id}] for ${invite.memberName || invite.memberId}`
+  );
+  return { project: next, invite };
+}
+
+export async function acceptSharedInvite(cwd, inviteId = "", options = {}) {
+  const existing = await loadSharedProject(cwd);
+  requireSharedProject(existing);
+  const normalizedId = String(inviteId || "").trim();
+  const actorId = String(options.actorId || "").trim();
+  const actorName = String(options.actorName || options.actorId || "").trim();
+  if (!normalizedId) throw new Error("invite id is required");
+  if (!actorId) throw new Error("actor id is required");
+  const pendingInvites = Array.isArray(existing.pendingInvites) ? [...existing.pendingInvites] : [];
+  const index = pendingInvites.findIndex((invite) => invite.id === normalizedId);
+  if (index < 0) throw new Error(`No pending invite found for ${normalizedId}`);
+  const invite = pendingInvites[index];
+  if (invite.memberId !== actorId) {
+    throw new Error("Only the invited user can accept this invite.");
+  }
+  const members = Array.isArray(existing.members) ? [...existing.members] : [];
+  if (!members.some((item) => item.id === invite.memberId)) {
+    members.push(normalizeMember({
+      id: invite.memberId,
+      name: actorName || invite.memberName || invite.memberId,
+      role: invite.role,
+      paired: true
+    }));
+  }
+  pendingInvites.splice(index, 1);
+  const next = await saveSharedProject(cwd, {
+    ...existing,
+    members,
+    pendingInvites
+  });
+  await appendRoundtableEvent(
+    cwd,
+    `- ${new Date().toISOString()}: invite accepted [${invite.id}] by ${actorName || actorId}`
+  );
+  return { project: next, invite };
+}
+
 export async function removeSharedMember(cwd, memberId = "", options = {}) {
   const existing = await loadSharedProject(cwd);
   requireOwner(existing, options.actorId);
@@ -382,6 +592,15 @@ export async function listSharedTasks(cwd) {
   return project.tasks || [];
 }
 
+function makeTaskHistoryEntry(type = "", text = "", options = {}) {
+  return normalizeTaskHistoryEntry({
+    type,
+    text,
+    actorId: String(options.actorId || "").trim(),
+    actorName: String(options.actorName || options.actorId || "").trim()
+  });
+}
+
 export async function addSharedTask(cwd, text = "", options = {}) {
   const existing = await loadSharedProject(cwd);
   requireMember(existing, options.actorId);
@@ -390,7 +609,10 @@ export async function addSharedTask(cwd, text = "", options = {}) {
   const task = normalizeSharedTask({
     text: normalizedText,
     state: "open",
-    createdBy: String(options.actorId || "").trim()
+    createdBy: String(options.actorId || "").trim(),
+    history: [
+      makeTaskHistoryEntry("created", `Task created: ${normalizedText}`, options)
+    ]
   });
   const next = await saveSharedProject(cwd, {
     ...existing,
@@ -416,7 +638,11 @@ export async function moveSharedTask(cwd, taskId = "", state = "open", options =
     ...tasks[index],
     state: normalizedState,
     updatedAt: new Date().toISOString(),
-    assignedTo: normalizedState === "active" ? String(options.actorId || "").trim() : tasks[index].assignedTo
+    assignedTo: normalizedState === "active" ? String(options.actorId || "").trim() : tasks[index].assignedTo,
+    history: [
+      ...(tasks[index].history || []),
+      makeTaskHistoryEntry("state", `Task moved to ${normalizedState}`, options)
+    ]
   };
   const next = await saveSharedProject(cwd, {
     ...existing,
@@ -442,7 +668,11 @@ export async function assignSharedTask(cwd, taskId = "", memberId = "", options
   tasks[index] = {
     ...tasks[index],
     assignedTo: normalizedMemberId,
-    updatedAt: new Date().toISOString()
+    updatedAt: new Date().toISOString(),
+    history: [
+      ...(tasks[index].history || []),
+      makeTaskHistoryEntry("assign", `Task assigned to ${normalizedMemberId}`, options)
+    ]
   };
   const next = await saveSharedProject(cwd, {
     ...existing,
@@ -465,7 +695,11 @@ export async function claimSharedTask(cwd, taskId = "", options = {}) {
     ...tasks[index],
     assignedTo: actorId,
     state: "active",
-    updatedAt: new Date().toISOString()
+    updatedAt: new Date().toISOString(),
+    history: [
+      ...(tasks[index].history || []),
+      makeTaskHistoryEntry("claim", `Task claimed by ${actorId}`, options)
+    ]
   };
   const next = await saveSharedProject(cwd, {
     ...existing,
@@ -475,6 +709,50 @@ export async function claimSharedTask(cwd, taskId = "", options = {}) {
   return { project: next, task: tasks[index] };
 }
 
+export async function commentSharedTask(cwd, taskId = "", text = "", options = {}) {
+  const existing = await loadSharedProject(cwd);
+  requireMember(existing, options.actorId);
+  const normalizedId = String(taskId || "").trim();
+  const normalizedText = String(text || "").trim();
+  if (!normalizedId) throw new Error("task id is required");
+  if (!normalizedText) throw new Error("comment text is required");
+  const tasks = [...(existing.tasks || [])];
+  const index = tasks.findIndex((task) => task.id === normalizedId);
+  if (index < 0) throw new Error(`No shared task found for ${normalizedId}`);
+  const comment = normalizeTaskComment({
+    text: normalizedText,
+    actorId: String(options.actorId || "").trim(),
+    actorName: String(options.actorName || options.actorId || "").trim()
+  });
+  const historyEntry = makeTaskHistoryEntry("comment", `Comment added: ${normalizedText}`, options);
+  tasks[index] = {
+    ...tasks[index],
+    updatedAt: new Date().toISOString(),
+    comments: [...(tasks[index].comments || []), comment],
+    history: [...(tasks[index].history || []), historyEntry]
+  };
+  const next = await saveSharedProject(cwd, {
+    ...existing,
+    tasks
+  });
+  await appendRoundtableEvent(cwd, `- ${new Date().toISOString()}: task comment [${tasks[index].id}] ${normalizedText}`);
+  return { project: next, task: tasks[index], comment };
+}
+
+export async function getSharedTaskHistory(cwd, taskId = "", options = {}) {
+  const existing = await loadSharedProject(cwd);
+  requireMember(existing, options.actorId);
+  const normalizedId = String(taskId || "").trim();
+  if (!normalizedId) throw new Error("task id is required");
+  const task = (existing.tasks || []).find((item) => item.id === normalizedId);
+  if (!task) throw new Error(`No shared task found for ${normalizedId}`);
+  return {
+    task,
+    comments: task.comments || [],
+    history: task.history || []
+  };
+}
+
 export async function claimSharedOperator(cwd, operator = {}) {
   const existing = await loadSharedProject(cwd);
   requireSharedProject(existing);
@@ -535,9 +813,11 @@ export function formatSharedProjectStatus(project) {
     room: project.room,
     mode: project.mode,
     roomMode: project.roomMode,
+    runtimeProfile: project.runtimeProfile,
     approvalPolicy: project.approvalPolicy,
     activeOperator: project.activeOperator,
     members: project.members,
+    pendingInvites: project.pendingInvites,
     tasks: project.tasks
   }, null, 2);
 }