@tritard/waterbrother 0.16.28 → 0.16.30

package/README.md

@@ -267,6 +267,8 @@ Shared project foundation is now live:
 - 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`
+- assign and claim shared work with `waterbrother room task assign` and `waterbrother room task claim`
+- 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`
 - human collaboration notes live in `ROUNDTABLE.md`
@@ -279,10 +281,13 @@ 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`, and `/task ...` from Telegram
+- shared projects now support `/room`, `/members`, `/tasks`, `/mode`, `/claim`, `/release`, `/invite`, `/remove-member`, `/room-runtime`, 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
+- in shared plan-mode groups, targeted `task:` and `todo:` messages are captured directly into the Roundtable task queue
 - 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.28",
+  "version": "0.16.30",
   "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,7 +59,9 @@ import { formatPlanForDisplay } from "./planner.js";
 import { parseCharterFromGoal, runExperimentLoop, formatExperimentSummary, gitReturnToBranch } from "./experiment.js";
 import {
   addSharedTask,
+  assignSharedTask,
   claimSharedOperator,
+  claimSharedTask,
   disableSharedProject,
   enableSharedProject,
   formatSharedProjectStatus,
@@ -70,6 +72,7 @@ import {
   moveSharedTask,
   releaseSharedOperator,
   removeSharedMember,
+  setSharedRuntimeProfile,
   setSharedRoomMode,
   upsertSharedMember
 } from "./shared-project.js";
@@ -159,7 +162,11 @@ const INTERACTIVE_COMMANDS = [
   { 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 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" },
   { name: "/room claim", description: "Claim operator control for the shared room" },
   { name: "/room release", description: "Release operator control for the shared room" },
@@ -289,7 +296,10 @@ Usage:
   waterbrother room remove <member-id>
   waterbrother room tasks
   waterbrother room task add <text>
+  waterbrother room task assign <id> <member-id>
+  waterbrother room task claim <id>
   waterbrother room task move <id> <open|active|blocked|done>
+  waterbrother room runtime [<name>|clear]
   waterbrother room mode <chat|plan|execute>
   waterbrother room claim
   waterbrother room release
@@ -2612,6 +2622,24 @@ function buildRuntimeStatusPayload(runtime, agent, currentSession = null) {
   };
 }
 
+function buildRoomStatusPayload(project, runtime = null, currentSession = null) {
+  if (!project) {
+    return { enabled: false };
+  }
+  return {
+    ...project,
+    executor: {
+      surface: "local-tui",
+      roomRuntimeProfile: project.runtimeProfile || "",
+      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,
@@ -3774,16 +3802,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, agent = null, context = 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;
   }
 
@@ -3814,7 +3843,7 @@ async function runRoomCommand(positional, { cwd = process.cwd(), asJson = false
       return;
     }
     for (const task of tasks) {
-      console.log(`${task.id}\t${task.state}\t${task.text}`);
+      console.log(`${task.id}\t${task.state}\t${task.assignedTo || "-"}\t${task.text}`);
     }
     return;
   }
@@ -3848,7 +3877,34 @@ async function runRoomCommand(positional, { cwd = process.cwd(), asJson = false
       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 (action === "assign") {
+      const taskId = String(positional[3] || "").trim();
+      const memberId = String(positional[4] || "").trim();
+      if (!taskId || !memberId) {
+        throw new Error("Usage: waterbrother room task assign <id> <member-id>");
+      }
+      const result = await assignSharedTask(cwd, taskId, memberId, { actorId: operator.id });
+      if (asJson) {
+        printData({ ok: true, action: "task-assign", task: result.task, project: result.project }, true);
+        return;
+      }
+      console.log(`Assigned shared task [${result.task.id}] to ${memberId}`);
+      return;
+    }
+    if (action === "claim") {
+      const taskId = String(positional[3] || "").trim();
+      if (!taskId) {
+        throw new Error("Usage: waterbrother room task claim <id>");
+      }
+      const result = await claimSharedTask(cwd, taskId, { actorId: operator.id });
+      if (asJson) {
+        printData({ ok: true, action: "task-claim", task: result.task, project: result.project }, true);
+        return;
+      }
+      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 (sub === "add") {
@@ -3925,7 +3981,35 @@ 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 move <id> <open|active|blocked|done>|mode <chat|plan|execute>|claim|release");
+  if (sub === "runtime") {
+    const nextProfile = String(positional[2] || "").trim();
+    if (!nextProfile) {
+      const project = await loadSharedProject(cwd);
+      if (asJson) {
+        printData({ ok: true, runtimeProfile: project?.runtimeProfile || "", project }, true);
+        return;
+      }
+      console.log(project?.runtimeProfile || "none");
+      return;
+    }
+    const normalized = nextProfile.toLowerCase() === "clear" ? "" : nextProfile;
+    const project = await setSharedRuntimeProfile(cwd, normalized, { actorId: operator.id });
+    if (normalized && agent && context && currentSession) {
+      const { config } = await loadConfigLayers(cwd);
+      const loaded = await loadNamedRuntimeProfile(normalized, { cwd, config, runtime: context.runtime, context, agent, session: currentSession });
+      if (!loaded) {
+        throw new Error(`runtime profile "${normalized}" not found`);
+      }
+    }
+    if (asJson) {
+      printData({ ok: true, action: "runtime", runtimeProfile: project.runtimeProfile, project }, true);
+      return;
+    }
+    console.log(project.runtimeProfile ? `Room runtime profile set to ${project.runtimeProfile}` : "Room runtime profile cleared");
+    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");
 }
 
 async function runMcpCommand(positional, runtime, { cwd, asJson = false } = {}) {
@@ -7114,6 +7198,20 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
 
         remoteSessionId = currentSession.id;
         await touchTelegramBridgeHost({ sessionId: currentSession.id, cwd: context.cwd });
+        if (remoteRequest.runtimeProfile && remoteRequest.runtimeProfile !== currentSession.runtimeProfile) {
+          const { config } = await loadConfigLayers(context.cwd);
+          const loaded = await loadNamedRuntimeProfile(remoteRequest.runtimeProfile, {
+            cwd: context.cwd,
+            config,
+            runtime: context.runtime,
+            context,
+            agent,
+            session: currentSession
+          });
+          if (loaded) {
+            console.log(cyan(`telegram runtime -> ${remoteRequest.runtimeProfile}`));
+          }
+        }
         console.log(cyan(`telegram request from ${remoteActor}`));
         console.log(`${cyan("telegram>")} ${sanitizeTerminalText(remoteRequest.text || "")}`);
         await runTextTurnInteractive({
@@ -7746,7 +7844,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, agent, context });
       } catch (error) {
         console.log(`room status failed: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -7755,7 +7853,7 @@ 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, agent, context });
       } catch (error) {
         console.log(`room members failed: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -7764,7 +7862,7 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
 
     if (line === "/room tasks") {
       try {
-        await runRoomCommand(["room", "tasks"], { cwd: context.cwd, asJson: false });
+        await runRoomCommand(["room", "tasks"], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession, agent, context });
       } catch (error) {
         console.log(`room tasks failed: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -7787,7 +7885,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, agent, context });
       } catch (error) {
         console.log(`room add failed: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -7801,7 +7899,7 @@ 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, agent, context });
       } catch (error) {
         console.log(`room remove failed: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -7815,7 +7913,7 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
         continue;
       }
       try {
-        await runRoomCommand(["room", "task", "add", ...text.split(" ")], { cwd: context.cwd, asJson: false });
+        await runRoomCommand(["room", "task", "add", ...text.split(" ")], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession, agent, context });
       } catch (error) {
         console.log(`room task add failed: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -7830,13 +7928,42 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
         continue;
       }
       try {
-        await runRoomCommand(["room", "task", "move", taskId, state], { cwd: context.cwd, asJson: false });
+        await runRoomCommand(["room", "task", "move", taskId, state], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession, agent, context });
       } catch (error) {
         console.log(`room task move 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);
+      if (!taskId || !memberId) {
+        console.log("Usage: /room task assign <id> <member-id>");
+        continue;
+      }
+      try {
+        await runRoomCommand(["room", "task", "assign", taskId, memberId], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession, agent, context });
+      } catch (error) {
+        console.log(`room task assign failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      continue;
+    }
+
+    if (line.startsWith("/room task claim ")) {
+      const taskId = line.replace("/room task claim", "").trim();
+      if (!taskId) {
+        console.log("Usage: /room task claim <id>");
+        continue;
+      }
+      try {
+        await runRoomCommand(["room", "task", "claim", taskId], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession, agent, context });
+      } catch (error) {
+        console.log(`room task claim failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      continue;
+    }
+
     if (line.startsWith("/room mode ")) {
       const nextMode = line.replace("/room mode", "").trim().toLowerCase();
       if (!nextMode) {
@@ -7844,16 +7971,26 @@ 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, agent, context });
       } catch (error) {
         console.log(`room mode failed: ${error instanceof Error ? error.message : String(error)}`);
       }
       continue;
     }
 
+    if (line === "/room runtime" || line.startsWith("/room runtime ")) {
+      const value = line === "/room runtime" ? "" : line.replace("/room runtime", "").trim();
+      try {
+        await runRoomCommand(value ? ["room", "runtime", value] : ["room", "runtime"], { cwd: context.cwd, asJson: false, runtime: context.runtime, currentSession, agent, context });
+      } catch (error) {
+        console.log(`room runtime failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      continue;
+    }
+
     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, agent, context });
       } catch (error) {
         console.log(`room claim failed: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -7862,7 +7999,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, agent, context });
       } catch (error) {
         console.log(`room release failed: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -9691,7 +9828,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-state.js

@@ -33,6 +33,7 @@ function normalizeBridgeRequest(parsed = {}) {
     username: String(parsed?.username || "").trim(),
     sessionId: String(parsed?.sessionId || "").trim(),
     text: String(parsed?.text || "").trim(),
+    runtimeProfile: String(parsed?.runtimeProfile || "").trim(),
     replyToMessageId: Number.isFinite(Number(parsed?.replyToMessageId)) ? Math.floor(Number(parsed.replyToMessageId)) : 0,
     requestedAt: String(parsed?.requestedAt || "").trim(),
     status: String(parsed?.status || "pending").trim() || "pending",

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, claimSharedOperator, getSharedMember, listSharedTasks, loadSharedProject, moveSharedTask, releaseSharedOperator, setSharedRoom, setSharedRoomMode, upsertSharedMember, removeSharedMember } from "./shared-project.js";
+import { addSharedTask, assignSharedTask, claimSharedOperator, claimSharedTask, getSharedMember, listSharedTasks, loadSharedProject, moveSharedTask, releaseSharedOperator, setSharedRoom, setSharedRoomMode, setSharedRuntimeProfile, upsertSharedMember, removeSharedMember } from "./shared-project.js";
 
 const execFileAsync = promisify(execFile);
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
@@ -28,6 +28,7 @@ const TELEGRAM_COMMANDS = [
   { command: "room", description: "Show shared room status" },
   { command: "members", description: "List shared room members" },
   { 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" },
   { command: "claim", description: "Claim operator control for a shared project" },
   { command: "release", description: "Release operator control for a shared project" },
@@ -204,7 +205,10 @@ function buildRemoteHelp() {
     "<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 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>/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>/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",
@@ -274,7 +278,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.";
   }
@@ -288,6 +292,21 @@ 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 (project.runtimeProfile) {
+    executorBits.unshift(`room runtime: <code>${escapeTelegramHtml(project.runtimeProfile)}</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>`,
@@ -295,6 +314,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");
@@ -320,10 +341,48 @@ function formatTelegramTasksMarkup(tasks = []) {
   }
   return [
     "<b>Shared tasks</b>",
-    ...tasks.map((task) => `• <code>${escapeTelegramHtml(task.id)}</code> <i>(${escapeTelegramHtml(task.state)})</i> ${escapeTelegramHtml(task.text)}`)
+    ...tasks.map((task) => `• <code>${escapeTelegramHtml(task.id)}</code> <i>(${escapeTelegramHtml(task.state)})</i> ${escapeTelegramHtml(task.text)}${task.assignedTo ? ` <code>@${escapeTelegramHtml(task.assignedTo)}</code>` : ""}`)
   ].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 suggestTaskText(text = "") {
+  return String(text || "")
+    .replace(/^@[\w_]+\s*/g, "")
+    .replace(/^(should we|could we|what do you think about|brainstorm|plan)\s+/i, "")
+    .replace(/[?]+$/g, "")
+    .trim()
+    .slice(0, 180);
+}
+
 function parseInviteCommand(text) {
   const parts = String(text || "").trim().split(/\s+/).filter(Boolean);
   const userId = String(parts[1] || "").trim();
@@ -696,6 +755,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: project?.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 };
@@ -750,6 +822,7 @@ class TelegramGateway {
     }
 
     const requestId = createBridgeRequestId();
+    const { project } = await this.bindSharedRoomForMessage(message, sessionId);
     const bridge = await loadGatewayBridge("telegram");
     const requests = Array.isArray(bridge.pendingRequests) ? bridge.pendingRequests : [];
     requests.push({
@@ -759,6 +832,7 @@ class TelegramGateway {
       username: [message?.from?.username, message?.from?.first_name, message?.from?.last_name].filter(Boolean).join(" ").trim(),
       sessionId: String(sessionId || "").trim(),
       text: String(promptText || "").trim(),
+      runtimeProfile: String(project?.runtimeProfile || "").trim(),
       replyToMessageId: message.message_id,
       requestedAt: new Date().toISOString(),
       status: "pending",
@@ -819,10 +893,25 @@ class TelegramGateway {
   }
 
   async runPromptFallback(sessionId, promptText) {
+    let providerArgs = [];
+    try {
+      const session = await loadSession(sessionId);
+      const project = await loadSharedProject(session.cwd || this.cwd);
+      const profileName = String(project?.runtimeProfile || "").trim();
+      const profile = profileName ? this.runtime.runtimeProfiles?.[profileName] : null;
+      if (profile) {
+        if (profile.provider) providerArgs.push("--provider", String(profile.provider));
+        if (profile.model) providerArgs.push("--model", String(profile.model));
+        if (profile.designModel) providerArgs.push("--design-model", String(profile.designModel));
+        if (profile.baseUrl) providerArgs.push("--base-url", String(profile.baseUrl));
+      }
+    } catch {}
+
     const { stdout } = await this.runWaterbrother([
       "resume",
       sessionId,
       promptText,
+      ...providerArgs,
       "--skip-onboarding",
       "--approval",
       "never",
@@ -953,8 +1042,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;
     }
 
@@ -975,6 +1063,26 @@ class TelegramGateway {
       return;
     }
 
+    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);
+        return;
+      }
+    }
+
+    if (text === "/room-runtime") {
+      const { project } = await this.bindSharedRoomForMessage(message, sessionId);
+      await this.sendMessage(
+        message.chat.id,
+        project?.enabled
+          ? `<b>Shared room runtime profile</b>\n<code>${escapeTelegramHtml(project.runtimeProfile || "none")}</code>`
+          : "This project is not shared.",
+        message.message_id
+      );
+      return;
+    }
+
     if (text === "/mode") {
       const { project } = await this.bindSharedRoomForMessage(message, sessionId);
       await this.sendMessage(
@@ -1003,6 +1111,29 @@ class TelegramGateway {
       return;
     }
 
+    if (text.startsWith("/room-runtime ")) {
+      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 requestedProfile = text.replace("/room-runtime", "").trim();
+      const normalized = requestedProfile.toLowerCase() === "clear" ? "" : requestedProfile;
+      try {
+        const next = await setSharedRuntimeProfile(session.cwd || this.cwd, normalized, { actorId: userId });
+        await this.sendMessage(
+          message.chat.id,
+          next.runtimeProfile
+            ? `Shared room runtime profile set to <code>${escapeTelegramHtml(next.runtimeProfile)}</code>`
+            : "Shared room runtime profile cleared.",
+          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 === "/claim") {
       const { session, project } = await this.bindSharedRoomForMessage(message, sessionId);
       if (!project?.enabled) {
@@ -1029,7 +1160,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);
       }
@@ -1129,6 +1260,46 @@ class TelegramGateway {
       return;
     }
 
+    if (text.startsWith("/task assign ")) {
+      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, memberId] = text.replace("/task assign", "").trim().split(/\s+/, 2);
+      if (!taskId || !memberId) {
+        await this.sendMessage(message.chat.id, "Usage: /task assign <id> <member-id>", message.message_id);
+        return;
+      }
+      try {
+        const result = await assignSharedTask(session.cwd || this.cwd, taskId, memberId, { actorId: userId });
+        await this.sendMessage(message.chat.id, `Assigned shared task <code>${escapeTelegramHtml(result.task.id)}</code> to <code>${escapeTelegramHtml(memberId)}</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 claim ")) {
+      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 claim", "").trim();
+      if (!taskId) {
+        await this.sendMessage(message.chat.id, "Usage: /task claim <id>", message.message_id);
+        return;
+      }
+      try {
+        const result = await claimSharedTask(session.cwd || this.cwd, taskId, { actorId: userId });
+        await this.sendMessage(message.chat.id, `Claimed 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 === "/runtime") {
       const status = await this.runRuntimeStatus();
       await this.sendMessage(message.chat.id, formatRuntimeStatus(status), message.message_id);
@@ -1236,16 +1407,48 @@ class TelegramGateway {
       return;
     }
 
+    const promptText = this.stripBotMention(text);
+    const groupIntent = this.isGroupChat(message) ? classifyTelegramGroupIntent(promptText) : { kind: "execution", reason: "private chat" };
+    const sharedBinding = await this.bindSharedRoomForMessage(message, sessionId);
+    if (
+      this.isGroupChat(message)
+      && sharedBinding.project?.enabled
+      && sharedBinding.project.roomMode === "plan"
+      && /^(task:|todo:)/i.test(promptText)
+    ) {
+      const taskText = promptText.replace(/^(task:|todo:)\s*/i, "").trim();
+      if (taskText) {
+        try {
+          const result = await addSharedTask(sharedBinding.session.cwd || this.cwd, taskText, { actorId: userId });
+          await this.sendMessage(message.chat.id, `Planner captured 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 (this.isGroupChat(message) && groupIntent.kind !== "execution") {
+      const suggestion = suggestTaskText(promptText);
+      const planHint = groupIntent.kind === "plan"
+        ? `Planning/brainstorming message detected. No execution will run in the group. Suggested task: ${suggestion || "capture the next concrete step"}. Use /task add ${suggestion || "<text>"} or switch to /mode execute when you want Waterbrother to act.`
+        : "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

@@ -54,6 +54,7 @@ function normalizeSharedProject(project = {}, cwd = process.cwd()) {
     roomMode: ["chat", "plan", "execute"].includes(String(project.roomMode || "").trim())
       ? String(project.roomMode).trim()
       : "chat",
+    runtimeProfile: String(project.runtimeProfile || "").trim(),
     members,
     tasks,
     activeOperator: activeOperator?.id ? activeOperator : null,
@@ -112,7 +113,7 @@ function defaultRoundtableContent(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 [`- ${state}:`, ...tasks.map((task) => `  - [${task.id}] ${task.text}${task.assignedTo ? ` @${task.assignedTo}` : ""}`)];
   });
   return [
     "# Roundtable",
@@ -121,6 +122,7 @@ function defaultRoundtableContent(project) {
     `- Name: ${project.projectName}`,
     `- Mode: ${project.mode}`,
     `- Room mode: ${project.roomMode}`,
+    `- Runtime profile: ${project.runtimeProfile || "-"}`,
     `- Approval policy: ${project.approvalPolicy}`,
     project.room?.provider ? `- Room: ${project.room.provider} ${project.room.chatId || ""}`.trim() : "- Room: not linked",
     "",
@@ -149,7 +151,7 @@ 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 [`- ${state}:`, ...tasks.map((task) => `  - [${task.id}] ${task.text}${task.assignedTo ? ` @${task.assignedTo}` : ""}`)];
   });
   return ["## Task Queue", ...taskLines, ""].join("\n");
 }
@@ -269,6 +271,21 @@ export async function setSharedRoomMode(cwd, roomMode = "chat", options = {}) {
   return next;
 }
 
+export async function setSharedRuntimeProfile(cwd, runtimeProfile = "", options = {}) {
+  const existing = await loadSharedProject(cwd);
+  requireOwner(existing, options.actorId);
+  const normalized = String(runtimeProfile || "").trim();
+  const next = await saveSharedProject(cwd, {
+    ...existing,
+    runtimeProfile: normalized
+  });
+  await appendRoundtableEvent(
+    cwd,
+    `- ${new Date().toISOString()}: room runtime profile ${normalized ? `set to ${normalized}` : "cleared"}`
+  );
+  return next;
+}
+
 export function getSharedMember(project, memberId = "") {
   const normalizedId = String(memberId || "").trim();
   if (!normalizedId || !project?.members?.length) return null;
@@ -409,6 +426,55 @@ export async function moveSharedTask(cwd, taskId = "", state = "open", options =
   return { project: next, task: tasks[index] };
 }
 
+export async function assignSharedTask(cwd, taskId = "", memberId = "", options = {}) {
+  const existing = await loadSharedProject(cwd);
+  requireEditor(existing, options.actorId);
+  const normalizedId = String(taskId || "").trim();
+  const normalizedMemberId = String(memberId || "").trim();
+  if (!normalizedId) throw new Error("task id is required");
+  if (!normalizedMemberId) throw new Error("member id is required");
+  if (!getSharedMember(existing, normalizedMemberId)) {
+    throw new Error(`No shared-project member found for ${normalizedMemberId}`);
+  }
+  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],
+    assignedTo: normalizedMemberId,
+    updatedAt: new Date().toISOString()
+  };
+  const next = await saveSharedProject(cwd, {
+    ...existing,
+    tasks
+  });
+  await appendRoundtableEvent(cwd, `- ${new Date().toISOString()}: task assigned [${tasks[index].id}] -> ${normalizedMemberId}`);
+  return { project: next, task: tasks[index] };
+}
+
+export async function claimSharedTask(cwd, taskId = "", options = {}) {
+  const existing = await loadSharedProject(cwd);
+  requireMember(existing, options.actorId);
+  const normalizedId = String(taskId || "").trim();
+  const actorId = String(options.actorId || "").trim();
+  if (!normalizedId) throw new Error("task id 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}`);
+  tasks[index] = {
+    ...tasks[index],
+    assignedTo: actorId,
+    state: "active",
+    updatedAt: new Date().toISOString()
+  };
+  const next = await saveSharedProject(cwd, {
+    ...existing,
+    tasks
+  });
+  await appendRoundtableEvent(cwd, `- ${new Date().toISOString()}: task claimed [${tasks[index].id}] by ${actorId}`);
+  return { project: next, task: tasks[index] };
+}
+
 export async function claimSharedOperator(cwd, operator = {}) {
   const existing = await loadSharedProject(cwd);
   requireSharedProject(existing);