@tritard/waterbrother 0.16.27 → 0.16.29

package/README.md

@@ -266,6 +266,7 @@ Shared project foundation is now live:
 - 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 the shared backlog with `waterbrother room tasks`, `waterbrother room task add`, and `waterbrother room task move`
 - claim or release the shared operator lock with `waterbrother room claim` and `waterbrother room release`
 - shared project metadata lives in `.waterbrother/shared.json`
 - human collaboration notes live in `ROUNDTABLE.md`
@@ -278,10 +279,12 @@ 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`, `/mode`, `/claim`, `/release`, `/invite`, and `/remove-member` from Telegram
+- shared projects now support `/room`, `/members`, `/tasks`, `/mode`, `/claim`, `/release`, `/invite`, `/remove-member`, and `/task ...` from Telegram
 - 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
 - in Telegram groups, Waterbrother only responds when directly targeted: slash commands, `@botname` mentions, or replies to a bot message
+- in Telegram groups, directly targeted messages are now classified as chat, planning, or execution; only explicit execution requests run the live session
 - pairing is now explicit: first DM creates a pending request, then approve locally with `waterbrother gateway pair telegram <user-id>`
 
 ## Release flow

package/package.json

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

package/src/cli.js

@@ -58,13 +58,16 @@ import { scanForInitiatives, formatInitiatives, buildInitiativeFixPrompt } from
 import { formatPlanForDisplay } from "./planner.js";
 import { parseCharterFromGoal, runExperimentLoop, formatExperimentSummary, gitReturnToBranch } from "./experiment.js";
 import {
+  addSharedTask,
   claimSharedOperator,
   disableSharedProject,
   enableSharedProject,
   formatSharedProjectStatus,
   getSharedProjectPaths,
   listSharedMembers,
+  listSharedTasks,
   loadSharedProject,
+  moveSharedTask,
   releaseSharedOperator,
   removeSharedMember,
   setSharedRoomMode,
@@ -154,6 +157,9 @@ const INTERACTIVE_COMMANDS = [
   { name: "/room members", description: "List shared-project members" },
   { name: "/room add <id> [owner|editor|observer]", description: "Add or update a shared-project member" },
   { 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 move <id> <open|active|blocked|done>", description: "Move a Roundtable task between states" },
   { name: "/room mode <chat|plan|execute>", description: "Set collaboration mode for the shared room" },
   { name: "/room claim", description: "Claim operator control for the shared room" },
   { name: "/room release", description: "Release operator control for the shared room" },
@@ -281,6 +287,9 @@ Usage:
   waterbrother room members
   waterbrother room add <member-id> [owner|editor|observer]
   waterbrother room remove <member-id>
+  waterbrother room tasks
+  waterbrother room task add <text>
+  waterbrother room task move <id> <open|active|blocked|done>
   waterbrother room mode <chat|plan|execute>
   waterbrother room claim
   waterbrother room release
@@ -2603,6 +2612,23 @@ function buildRuntimeStatusPayload(runtime, agent, currentSession = null) {
   };
 }
 
+function buildRoomStatusPayload(project, runtime = null, currentSession = null) {
+  if (!project) {
+    return { enabled: false };
+  }
+  return {
+    ...project,
+    executor: {
+      surface: "local-tui",
+      runtimeProfile: currentSession?.runtimeProfile || runtime?.gateway?.defaultRuntimeProfile || "",
+      provider: runtime?.provider || "unknown",
+      model: runtime?.model || "unknown",
+      designModel: runtime?.designModel || "unknown",
+      agentProfile: runtime?.agentProfile || "coder"
+    }
+  };
+}
+
 async function applyRuntimeSelection({
   config,
   context,
@@ -3765,16 +3791,17 @@ async function runProjectCommand(positional, { cwd = process.cwd(), asJson = fal
   throw new Error("Usage: waterbrother project share|unshare");
 }
 
-async function runRoomCommand(positional, { cwd = process.cwd(), asJson = false } = {}) {
+async function runRoomCommand(positional, { cwd = process.cwd(), asJson = false, runtime = null, currentSession = null } = {}) {
   const sub = String(positional[1] || "status").trim().toLowerCase();
   const operator = getLocalOperatorIdentity();
   if (sub === "status") {
     const project = await loadSharedProject(cwd);
+    const payload = buildRoomStatusPayload(project, runtime, currentSession);
     if (asJson) {
-      printData(project || { enabled: false, cwd }, true);
+      printData(payload, true);
       return;
     }
-    console.log(formatSharedProjectStatus(project));
+    console.log(JSON.stringify(payload, null, 2));
     return;
   }
 
@@ -3794,6 +3821,54 @@ async function runRoomCommand(positional, { cwd = process.cwd(), asJson = false
     return;
   }
 
+  if (sub === "tasks") {
+    const tasks = await listSharedTasks(cwd);
+    if (asJson) {
+      printData({ ok: true, tasks }, true);
+      return;
+    }
+    if (!tasks.length) {
+      console.log("No shared-project tasks");
+      return;
+    }
+    for (const task of tasks) {
+      console.log(`${task.id}\t${task.state}\t${task.text}`);
+    }
+    return;
+  }
+
+  if (sub === "task") {
+    const action = String(positional[2] || "").trim().toLowerCase();
+    if (action === "add") {
+      const text = String(positional.slice(3).join(" ") || "").trim();
+      if (!text) {
+        throw new Error("Usage: waterbrother room task add <text>");
+      }
+      const result = await addSharedTask(cwd, text, { actorId: operator.id });
+      if (asJson) {
+        printData({ ok: true, action: "task-add", task: result.task, project: result.project }, true);
+        return;
+      }
+      console.log(`Added shared task [${result.task.id}] ${result.task.text}`);
+      return;
+    }
+    if (action === "move") {
+      const taskId = String(positional[3] || "").trim();
+      const state = String(positional[4] || "").trim().toLowerCase();
+      if (!taskId || !state) {
+        throw new Error("Usage: waterbrother room task move <id> <open|active|blocked|done>");
+      }
+      const result = await moveSharedTask(cwd, taskId, state, { actorId: operator.id });
+      if (asJson) {
+        printData({ ok: true, action: "task-move", task: result.task, project: result.project }, true);
+        return;
+      }
+      console.log(`Moved shared task [${result.task.id}] to ${result.task.state}`);
+      return;
+    }
+    throw new Error("Usage: waterbrother room task add <text>|move <id> <open|active|blocked|done>");
+  }
+
   if (sub === "add") {
     const memberId = String(positional[2] || "").trim();
     const role = String(positional[3] || "editor").trim().toLowerCase();
@@ -3868,7 +3943,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>|mode <chat|plan|execute>|claim|release");
+  throw new Error("Usage: waterbrother room status|members|add <member-id> [owner|editor|observer] [display name]|remove <member-id>|tasks|task add <text>|task move <id> <open|active|blocked|done>|mode <chat|plan|execute>|claim|release");
 }
 
 async function runMcpCommand(positional, runtime, { cwd, asJson = false } = {}) {
@@ -7689,7 +7764,7 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
 
     if (line === "/room") {
       try {
-        await runRoomCommand(["room", "status"], { cwd: context.cwd, asJson: false });
+        await runRoomCommand(["room", "status"], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession });
       } catch (error) {
         console.log(`room status failed: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -7698,13 +7773,22 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
 
     if (line === "/room members") {
       try {
-        await runRoomCommand(["room", "members"], { cwd: context.cwd, asJson: false });
+        await runRoomCommand(["room", "members"], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession });
       } catch (error) {
         console.log(`room members 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 });
+      } catch (error) {
+        console.log(`room tasks failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      continue;
+    }
+
     if (line.startsWith("/room add ")) {
       const raw = line.replace("/room add", "").trim();
       if (!raw) {
@@ -7721,7 +7805,7 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
       try {
         const positional = ["room", "add", memberId, role];
         if (displayName) positional.push(...displayName.split(" "));
-        await runRoomCommand(positional, { cwd: context.cwd, asJson: false });
+        await runRoomCommand(positional, { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession });
       } catch (error) {
         console.log(`room add failed: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -7735,13 +7819,42 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
         continue;
       }
       try {
-        await runRoomCommand(["room", "remove", memberId], { cwd: context.cwd, asJson: false });
+        await runRoomCommand(["room", "remove", memberId], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession });
       } catch (error) {
         console.log(`room remove 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) {
+        console.log("Usage: /room task add <text>");
+        continue;
+      }
+      try {
+        await runRoomCommand(["room", "task", "add", ...text.split(" ")], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession });
+      } catch (error) {
+        console.log(`room task add failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      continue;
+    }
+
+    if (line.startsWith("/room task move ")) {
+      const raw = line.replace("/room task move", "").trim();
+      const [taskId, state] = raw.split(/\s+/, 2);
+      if (!taskId || !state) {
+        console.log("Usage: /room task move <id> <open|active|blocked|done>");
+        continue;
+      }
+      try {
+        await runRoomCommand(["room", "task", "move", taskId, state], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession });
+      } catch (error) {
+        console.log(`room task move failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      continue;
+    }
+
     if (line.startsWith("/room mode ")) {
       const nextMode = line.replace("/room mode", "").trim().toLowerCase();
       if (!nextMode) {
@@ -7749,7 +7862,7 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
         continue;
       }
       try {
-        await runRoomCommand(["room", "mode", nextMode], { cwd: context.cwd, asJson: false });
+        await runRoomCommand(["room", "mode", nextMode], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession });
       } catch (error) {
         console.log(`room mode failed: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -7758,7 +7871,7 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
 
     if (line === "/room claim") {
       try {
-        await runRoomCommand(["room", "claim"], { cwd: context.cwd, asJson: false });
+        await runRoomCommand(["room", "claim"], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession });
       } catch (error) {
         console.log(`room claim failed: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -7767,7 +7880,7 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
 
     if (line === "/room release") {
       try {
-        await runRoomCommand(["room", "release"], { cwd: context.cwd, asJson: false });
+        await runRoomCommand(["room", "release"], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession });
       } catch (error) {
         console.log(`room release failed: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -9596,7 +9709,7 @@ export async function runCli(argv) {
   }
 
   if (command === "room") {
-    await runRoomCommand(positional, { cwd: startupCwd, asJson });
+    await runRoomCommand(positional, { cwd: startupCwd, asJson, runtime });
     return;
   }
 

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 { claimSharedOperator, getSharedMember, loadSharedProject, releaseSharedOperator, setSharedRoom, setSharedRoomMode, upsertSharedMember, removeSharedMember } from "./shared-project.js";
+import { addSharedTask, claimSharedOperator, getSharedMember, listSharedTasks, loadSharedProject, moveSharedTask, releaseSharedOperator, setSharedRoom, setSharedRoomMode, upsertSharedMember, 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: "tasks", description: "List shared Roundtable tasks" },
   { command: "mode", description: "Show or set shared room mode" },
   { command: "claim", description: "Claim operator control for a shared project" },
   { command: "release", description: "Release operator control for a shared project" },
@@ -201,6 +202,9 @@ function buildRemoteHelp() {
     "<code>/runtime</code> show active provider/model/runtime state",
     "<code>/room</code> show shared project room status",
     "<code>/members</code> list shared project members",
+    "<code>/tasks</code> list shared project tasks",
+    "<code>/task add &lt;text&gt;</code> add a shared Roundtable task",
+    "<code>/task move &lt;id&gt; &lt;open|active|blocked|done&gt;</code> move a shared Roundtable task",
     "<code>/invite &lt;user-id&gt; [owner|editor|observer]</code> add or update a shared project member",
     "<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",
@@ -270,7 +274,7 @@ function formatSessionListMarkup(currentSessionId, sessions = []) {
   return lines.join("\n");
 }
 
-function formatTelegramRoomMarkup(project) {
+function formatTelegramRoomMarkup(project, options = {}) {
   if (!project?.enabled) {
     return "<b>Shared room</b>\nThis project is not shared.";
   }
@@ -284,6 +288,18 @@ function formatTelegramRoomMarkup(project) {
   const memberLines = members.length
     ? members.map((member) => `• ${escapeTelegramHtml(member.name || member.id)} <i>(${escapeTelegramHtml(member.role || "editor")})</i>`).join("\n")
     : "• none";
+  const executor = options.executor || {};
+  const executorBits = [
+    `surface: <code>${escapeTelegramHtml(executor.surface || "telegram")}</code>`,
+    `provider: <code>${escapeTelegramHtml(executor.provider || "unknown")}</code>`,
+    `model: <code>${escapeTelegramHtml(executor.model || "unknown")}</code>`
+  ];
+  if (executor.runtimeProfile) {
+    executorBits.push(`runtime profile: <code>${escapeTelegramHtml(executor.runtimeProfile)}</code>`);
+  }
+  if (executor.hostSessionId) {
+    executorBits.push(`host session: <code>${escapeTelegramHtml(executor.hostSessionId)}</code>`);
+  }
   return [
     "<b>Shared room</b>",
     `project: <code>${escapeTelegramHtml(project.projectName || "")}</code>`,
@@ -291,6 +307,8 @@ function formatTelegramRoomMarkup(project) {
     `room mode: <code>${escapeTelegramHtml(project.roomMode || "chat")}</code>`,
     `room: <code>${escapeTelegramHtml(roomLabel)}</code>`,
     `active operator: <code>${escapeTelegramHtml(active)}</code>`,
+    "<b>Executor</b>",
+    ...executorBits,
     "<b>Members</b>",
     memberLines
   ].join("\n");
@@ -310,6 +328,45 @@ function formatTelegramMembersMarkup(project) {
   ].join("\n");
 }
 
+function formatTelegramTasksMarkup(tasks = []) {
+  if (!tasks.length) {
+    return "<b>Shared tasks</b>\n• none";
+  }
+  return [
+    "<b>Shared tasks</b>",
+    ...tasks.map((task) => `• <code>${escapeTelegramHtml(task.id)}</code> <i>(${escapeTelegramHtml(task.state)})</i> ${escapeTelegramHtml(task.text)}`)
+  ].join("\n");
+}
+
+function classifyTelegramGroupIntent(text = "") {
+  const normalized = String(text || "").trim();
+  const lower = normalized.toLowerCase();
+  if (!normalized) return { kind: "chat", reason: "empty" };
+  if (/^(hi|hello|hey|yo|thanks|thank you|cool|nice|ok|okay|k)\b/.test(lower)) {
+    return { kind: "chat", reason: "casual language" };
+  }
+  if (
+    lower.includes("brainstorm")
+    || lower.includes("what do you think")
+    || lower.includes("should we")
+    || lower.includes("could we")
+    || lower.includes("let's think")
+    || lower.includes("plan this")
+    || lower.includes("ideas for")
+    || normalized.endsWith("?")
+  ) {
+    return { kind: "plan", reason: "planning language" };
+  }
+  if (
+    /^(make|create|build|implement|fix|change|update|add|remove|delete|rename|refactor|write|edit|move|run|search|open|use|switch|generate|ship|deploy|debug|investigate|audit)\b/.test(lower)
+    || /[`/].+/.test(normalized)
+    || /\b(file|folder|directory|repo|project|code|command|function|component|page|route|api|schema|bug)\b/.test(lower)
+  ) {
+    return { kind: "execution", reason: "explicit work request" };
+  }
+  return { kind: "chat", reason: "default non-execution" };
+}
+
 function parseInviteCommand(text) {
   const parts = String(text || "").trim().split(/\s+/).filter(Boolean);
   const userId = String(parts[1] || "").trim();
@@ -682,6 +739,19 @@ class TelegramGateway {
     return { session, project: next };
   }
 
+  async buildRoomMarkup(message, sessionId) {
+    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: this.channel.defaultRuntimeProfile || this.gateway.defaultRuntimeProfile || "",
+      hostSessionId: host?.sessionId || ""
+    };
+    return project?.enabled ? formatTelegramRoomMarkup(project, { executor }) : "<b>Shared room</b>\nThis project is not shared.";
+  }
+
   async ensureSharedOperator(message, sessionId) {
     const { session, project } = await this.loadSharedProjectForSession(sessionId);
     if (!project?.enabled) return { ok: true, project: null, session };
@@ -939,8 +1009,7 @@ class TelegramGateway {
     }
 
     if (text === "/room") {
-      const { project } = await this.bindSharedRoomForMessage(message, sessionId);
-      await this.sendMessage(message.chat.id, project?.enabled ? formatTelegramRoomMarkup(project) : "<b>Shared room</b>\nThis project is not shared.", message.message_id);
+      await this.sendMessage(message.chat.id, await this.buildRoomMarkup(message, sessionId), message.message_id);
       return;
     }
 
@@ -950,6 +1019,17 @@ class TelegramGateway {
       return;
     }
 
+    if (text === "/tasks") {
+      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 tasks = await listSharedTasks(session.cwd || this.cwd);
+      await this.sendMessage(message.chat.id, formatTelegramTasksMarkup(tasks), message.message_id);
+      return;
+    }
+
     if (text === "/mode") {
       const { project } = await this.bindSharedRoomForMessage(message, sessionId);
       await this.sendMessage(
@@ -1004,7 +1084,7 @@ class TelegramGateway {
       }
       try {
         const released = await releaseSharedOperator(session.cwd || this.cwd, userId, { actorId: userId });
-        await this.sendMessage(message.chat.id, released.activeOperator?.id ? formatTelegramRoomMarkup(released) : "Shared room released.", message.message_id);
+        await this.sendMessage(message.chat.id, released.activeOperator?.id ? await this.buildRoomMarkup(message, sessionId) : "Shared room released.", message.message_id);
       } catch (error) {
         await this.sendMessage(message.chat.id, escapeTelegramHtml(error instanceof Error ? error.message : String(error)), message.message_id);
       }
@@ -1064,6 +1144,46 @@ class TelegramGateway {
       return;
     }
 
+    if (text.startsWith("/task add ")) {
+      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 taskText = text.replace("/task add", "").trim();
+      if (!taskText) {
+        await this.sendMessage(message.chat.id, "Usage: /task add <text>", message.message_id);
+        return;
+      }
+      try {
+        const result = await addSharedTask(session.cwd || this.cwd, taskText, { actorId: userId });
+        await this.sendMessage(message.chat.id, `Added 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 move ")) {
+      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, state] = text.replace("/task move", "").trim().split(/\s+/, 2);
+      if (!taskId || !state) {
+        await this.sendMessage(message.chat.id, "Usage: /task move <id> <open|active|blocked|done>", message.message_id);
+        return;
+      }
+      try {
+        const result = await moveSharedTask(session.cwd || this.cwd, taskId, state, { actorId: userId });
+        await this.sendMessage(message.chat.id, `Moved shared task <code>${escapeTelegramHtml(result.task.id)}</code> to <code>${escapeTelegramHtml(result.task.state)}</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 === "/runtime") {
       const status = await this.runRuntimeStatus();
       await this.sendMessage(message.chat.id, formatRuntimeStatus(status), message.message_id);
@@ -1171,16 +1291,29 @@ class TelegramGateway {
       return;
     }
 
+    const promptText = this.stripBotMention(text);
+    const groupIntent = this.isGroupChat(message) ? classifyTelegramGroupIntent(promptText) : { kind: "execution", reason: "private chat" };
+    if (this.isGroupChat(message) && groupIntent.kind !== "execution") {
+      const planHint = groupIntent.kind === "plan"
+        ? "Planning/brainstorming message detected. No execution will run in the group. Use /task add to capture work, or switch to /mode execute and send an explicit execution request."
+        : "Chat message detected. No execution will run in the group. Use /task add to capture work or send an explicit execution request when you want the bot to act.";
+      await this.sendMessage(message.chat.id, escapeTelegramHtml(planHint), message.message_id, { parseMode: "HTML" });
+      return;
+    }
+
     const stopTyping = await this.startTypingLoop(message.chat.id);
     let previewMessage = null;
     try {
       const operatorGate = await this.ensureSharedOperator(message, sessionId);
       if (!operatorGate.ok) {
-        await this.sendMessage(message.chat.id, escapeTelegramHtml(operatorGate.reason || "Shared room is not available."), message.message_id, { parseMode: "HTML" });
+        const gateReason =
+          this.isGroupChat(message) && groupIntent.kind === "execution" && operatorGate.project?.enabled && operatorGate.project?.roomMode !== "execute"
+            ? `Execution request detected, but the shared room is in ${operatorGate.project?.roomMode || "chat"} mode. Switch to /mode execute before asking Waterbrother to change code.`
+            : operatorGate.reason || "Shared room is not available.";
+        await this.sendMessage(message.chat.id, escapeTelegramHtml(gateReason), message.message_id, { parseMode: "HTML" });
         return;
       }
       previewMessage = await this.sendProgressMessage(message.chat.id, message.message_id);
-      const promptText = this.stripBotMention(text);
       const content = (await this.runPromptViaBridge(message, sessionId, promptText))
         ?? (await this.runPromptFallback(sessionId, promptText));
       await this.deliverPromptResult(message.chat.id, message.message_id, previewMessage, content);

package/src/shared-project.js

@@ -5,6 +5,7 @@ import path from "node:path";
 
 const SHARED_FILE = path.join(".waterbrother", "shared.json");
 const ROUNDTABLE_FILE = "ROUNDTABLE.md";
+const TASK_STATES = ["open", "active", "blocked", "done"];
 
 function normalizeMember(member = {}) {
   return {
@@ -25,6 +26,11 @@ function memberRoleWeight(role = "") {
 
 function normalizeSharedProject(project = {}, cwd = process.cwd()) {
   const members = Array.isArray(project.members) ? project.members.map(normalizeMember).filter((item) => item.id) : [];
+  const tasks = Array.isArray(project.tasks)
+    ? project.tasks
+        .map((task) => normalizeSharedTask(task))
+        .filter((task) => task.id && task.text)
+    : [];
   const activeOperator = project.activeOperator && typeof project.activeOperator === "object"
     ? {
         id: String(project.activeOperator.id || "").trim(),
@@ -49,6 +55,7 @@ function normalizeSharedProject(project = {}, cwd = process.cwd()) {
       ? String(project.roomMode).trim()
       : "chat",
     members,
+    tasks,
     activeOperator: activeOperator?.id ? activeOperator : null,
     approvalPolicy: String(project.approvalPolicy || "owner").trim() || "owner",
     createdAt: String(project.createdAt || new Date().toISOString()).trim(),
@@ -56,6 +63,18 @@ function normalizeSharedProject(project = {}, cwd = process.cwd()) {
   };
 }
 
+function normalizeSharedTask(task = {}) {
+  return {
+    id: String(task.id || `rt_${crypto.randomBytes(3).toString("hex")}`).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()
+  };
+}
+
 function sharedFilePath(cwd) {
   return path.join(cwd, SHARED_FILE);
 }
@@ -90,6 +109,11 @@ function defaultRoundtableContent(project) {
   const activeOperator = project.activeOperator?.id
     ? `${project.activeOperator.name || project.activeOperator.id}`
     : "none";
+  const taskLines = TASK_STATES.flatMap((state) => {
+    const tasks = (project.tasks || []).filter((task) => task.state === state);
+    if (!tasks.length) return [`- ${state}: -`];
+    return [`- ${state}:`, ...tasks.map((task) => `  - [${task.id}] ${task.text}`)];
+  });
   return [
     "# Roundtable",
     "",
@@ -116,14 +140,35 @@ function defaultRoundtableContent(project) {
     "-",
     "",
     "## Task Queue",
-    "- open: -",
-    "- active: -",
-    "- blocked: -",
-    "- done: -",
+    ...taskLines,
     ""
   ].join("\n");
 }
 
+function buildRoundtableTaskSection(project) {
+  const taskLines = TASK_STATES.flatMap((state) => {
+    const tasks = (project.tasks || []).filter((task) => task.state === state);
+    if (!tasks.length) return [`- ${state}: -`];
+    return [`- ${state}:`, ...tasks.map((task) => `  - [${task.id}] ${task.text}`)];
+  });
+  return ["## Task Queue", ...taskLines, ""].join("\n");
+}
+
+async function syncRoundtableTaskSection(cwd, project) {
+  const target = roundtablePath(cwd);
+  if (!(await pathExists(target))) return null;
+  const current = await fs.readFile(target, "utf8");
+  const nextSection = buildRoundtableTaskSection(project);
+  let nextContent;
+  if (/^## Task Queue\s*$/m.test(current)) {
+    nextContent = current.replace(/## Task Queue[\s\S]*$/, nextSection);
+  } else {
+    nextContent = `${current.trimEnd()}\n\n${nextSection}`;
+  }
+  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;
@@ -156,6 +201,7 @@ export async function saveSharedProject(cwd, project) {
   }, cwd);
   await writeJsonAtomically(sharedFilePath(cwd), next);
   await ensureRoundtable(cwd, next);
+  await syncRoundtableTaskSection(cwd, next);
   return next;
 }
 
@@ -247,6 +293,20 @@ function requireOwner(project, actorId = "") {
   }
 }
 
+function requireEditor(project, actorId = "") {
+  requireSharedProject(project);
+  if (!memberHasAtLeastRole(project, actorId, "editor")) {
+    throw new Error("Only a shared-project owner or editor can do that.");
+  }
+}
+
+function requireMember(project, actorId = "") {
+  requireSharedProject(project);
+  if (!getSharedMember(project, actorId)) {
+    throw new Error("Only a shared-project member can do that.");
+  }
+}
+
 export async function listSharedMembers(cwd) {
   const project = await loadSharedProject(cwd);
   requireSharedProject(project);
@@ -299,6 +359,56 @@ export async function removeSharedMember(cwd, memberId = "", options = {}) {
   return next;
 }
 
+export async function listSharedTasks(cwd) {
+  const project = await loadSharedProject(cwd);
+  requireSharedProject(project);
+  return project.tasks || [];
+}
+
+export async function addSharedTask(cwd, text = "", options = {}) {
+  const existing = await loadSharedProject(cwd);
+  requireMember(existing, options.actorId);
+  const normalizedText = String(text || "").trim();
+  if (!normalizedText) throw new Error("task text is required");
+  const task = normalizeSharedTask({
+    text: normalizedText,
+    state: "open",
+    createdBy: String(options.actorId || "").trim()
+  });
+  const next = await saveSharedProject(cwd, {
+    ...existing,
+    tasks: [...(existing.tasks || []), task]
+  });
+  await appendRoundtableEvent(cwd, `- ${new Date().toISOString()}: task added [${task.id}] ${task.text}`);
+  return { project: next, task };
+}
+
+export async function moveSharedTask(cwd, taskId = "", state = "open", options = {}) {
+  const existing = await loadSharedProject(cwd);
+  requireEditor(existing, options.actorId);
+  const normalizedId = String(taskId || "").trim();
+  const normalizedState = String(state || "").trim().toLowerCase();
+  if (!normalizedId) throw new Error("task id is required");
+  if (!TASK_STATES.includes(normalizedState)) {
+    throw new Error(`Invalid task state. Expected one of ${TASK_STATES.join(", ")}.`);
+  }
+  const tasks = [...(existing.tasks || [])];
+  const index = tasks.findIndex((task) => task.id === normalizedId);
+  if (index < 0) throw new Error(`No shared task found for ${normalizedId}`);
+  tasks[index] = {
+    ...tasks[index],
+    state: normalizedState,
+    updatedAt: new Date().toISOString(),
+    assignedTo: normalizedState === "active" ? String(options.actorId || "").trim() : tasks[index].assignedTo
+  };
+  const next = await saveSharedProject(cwd, {
+    ...existing,
+    tasks
+  });
+  await appendRoundtableEvent(cwd, `- ${new Date().toISOString()}: task moved [${tasks[index].id}] -> ${normalizedState}`);
+  return { project: next, task: tasks[index] };
+}
+
 export async function claimSharedOperator(cwd, operator = {}) {
   const existing = await loadSharedProject(cwd);
   requireSharedProject(existing);
@@ -361,7 +471,8 @@ export function formatSharedProjectStatus(project) {
     roomMode: project.roomMode,
     approvalPolicy: project.approvalPolicy,
     activeOperator: project.activeOperator,
-    members: project.members
+    members: project.members,
+    tasks: project.tasks
   }, null, 2);
 }