@tritard/waterbrother 0.16.26 → 0.16.28

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,7 +279,7 @@ 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
 - in Telegram groups, Waterbrother only responds when directly targeted: slash commands, `@botname` mentions, or replies to a bot message

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tritard/waterbrother",
-  "version": "0.16.26",
+  "version": "0.16.28",
   "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
@@ -3794,6 +3803,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 +3925,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 } = {}) {
@@ -7705,6 +7762,15 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
       continue;
     }
 
+    if (line === "/room tasks") {
+      try {
+        await runRoomCommand(["room", "tasks"], { cwd: context.cwd, asJson: false });
+      } 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) {
@@ -7742,6 +7808,35 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
       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 });
+      } 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 });
+      } 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) {

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",
@@ -310,6 +314,16 @@ 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 parseInviteCommand(text) {
   const parts = String(text || "").trim().split(/\s+/).filter(Boolean);
   const userId = String(parts[1] || "").trim();
@@ -950,6 +964,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(
@@ -1064,6 +1089,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);

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);
 }