@tritard/waterbrother 0.16.39 → 0.16.40

package/README.md

@@ -297,14 +297,15 @@ Current Telegram behavior:
 - Telegram now supports remote workspace control with `/cwd`, `/use <path>`, `/desktop`, and `/new-project <name>`
 - shared projects now support `/room`, `/members`, `/invites`, `/tasks`, `/mode`, `/claim`, `/release`, `/invite`, `/accept-invite`, `/approve-invite`, `/reject-invite`, `/remove-member`, `/room-runtime`, and `/task ...` from Telegram
 - `/room` now includes pending invite count plus task ownership summaries
-- local `/status` now includes `sharedRoom` with pending invites, task ownership summary, and recent task activity
+- local `/status` now includes `sharedRoom` with pending invites, task ownership summary, and recent shared-room event activity
+- the TUI now prints a small Roundtable event feed when new shared-room activity lands
 - Telegram now posts a Roundtable ownership notice when shared task ownership changes via assign/claim/move
 - 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
 - repo-first concept resolution now covers Waterbrother itself, Roundtable, Telegram, shared rooms, the gateway, runtime profiles, approvals, and sessions
 - 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 Telegram groups, directly targeted messages are now classified as chat, planning, or execution; explicit execution should use `/run <prompt>`
 - in Telegram group `chat` or `plan` flows, targeted Waterbrother/project questions are now answered directly from local repo state instead of returning only a generic planner hint
 - 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>`

package/package.json

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

package/src/cli.js

@@ -2682,18 +2682,11 @@ function buildRoomStatusPayload(project, runtime = null, currentSession = null)
     const assignee = String(task?.assignedTo || "").trim() || "unassigned";
     taskSummary.byAssignee[assignee] = (taskSummary.byAssignee[assignee] || 0) + 1;
   }
-  const recentActivity = tasks
-    .flatMap((task) => (Array.isArray(task.history) ? task.history.map((entry) => ({
-      taskId: task.id,
-      taskText: task.text,
-      type: entry.type,
-      text: entry.text,
-      actorId: entry.actorId || "",
-      actorName: entry.actorName || "",
-      createdAt: entry.createdAt || ""
-    })) : []))
-    .sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt)))
-    .slice(0, 5);
+  const recentActivity = Array.isArray(project.recentEvents)
+    ? [...project.recentEvents]
+        .sort((a, b) => String(b.createdAt || "").localeCompare(String(a.createdAt || "")))
+        .slice(0, 8)
+    : [];
   return {
     ...project,
     pendingInviteCount: Array.isArray(project.pendingInvites) ? project.pendingInvites.length : 0,
@@ -2711,6 +2704,39 @@ function buildRoomStatusPayload(project, runtime = null, currentSession = null)
   };
 }
 
+function getLatestSharedRoomEventId(project) {
+  const events = Array.isArray(project?.recentEvents) ? project.recentEvents : [];
+  return events.length ? String(events[events.length - 1]?.id || "").trim() : "";
+}
+
+function formatSharedRoomEventFeedLine(event = {}) {
+  const timestamp = String(event.createdAt || "").trim();
+  const shortTime = timestamp ? timestamp.replace("T", " ").replace(/\.\d+Z$/, "Z") : "";
+  const actor = String(event.actorName || event.actorId || "").trim();
+  const prefix = actor ? `${actor}: ` : "";
+  return `${styleSystemPrefix()} ${dim("[roundtable]")} ${shortTime ? `${shortTime} ` : ""}${prefix}${event.text || ""}`.trim();
+}
+
+async function flushSharedRoomEventFeed({ cwd, lastSeenEventId = "" } = {}) {
+  const project = await loadSharedProject(cwd).catch(() => null);
+  const events = Array.isArray(project?.recentEvents) ? project.recentEvents : [];
+  if (!events.length) {
+    return { latestEventId: "", printed: 0 };
+  }
+  let unseen = events;
+  if (lastSeenEventId) {
+    const index = events.findIndex((event) => String(event.id || "").trim() === lastSeenEventId);
+    unseen = index >= 0 ? events.slice(index + 1) : [];
+  }
+  for (const event of unseen) {
+    console.log(formatSharedRoomEventFeedLine(event));
+  }
+  return {
+    latestEventId: getLatestSharedRoomEventId(project),
+    printed: unseen.length
+  };
+}
+
 async function applyRuntimeSelection({
   config,
   context,
@@ -3844,11 +3870,64 @@ function getLocalOperatorIdentity() {
   };
 }
 
+function printSharedProjectNextSteps(project) {
+  console.log(dim(`room mode: ${project.roomMode || "chat"}`));
+  console.log(dim(`room runtime: ${project.runtimeProfile || "none"}`));
+  console.log(dim("Next: invite members with `waterbrother room invite <member-id> [owner|editor|observer]`, then use `waterbrother room mode execute` when you want a claimed operator to act."));
+}
+
+async function configureSharedProjectInteractive(cwd, operator, initialProject) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return initialProject;
+  }
+  let project = initialProject;
+  const currentMode = project?.roomMode || "chat";
+  const enteredMode = (await promptLine(`Shared room mode [${currentMode}] (chat|plan|execute, Enter to keep): `)).trim().toLowerCase();
+  if (enteredMode) {
+    if (!["chat", "plan", "execute"].includes(enteredMode)) {
+      console.log(yellow("Ignoring invalid room mode. Keeping existing mode."));
+    } else if (enteredMode !== currentMode) {
+      project = await setSharedRoomMode(cwd, enteredMode, { actorId: operator.id });
+    }
+  }
+
+  const currentRuntime = project?.runtimeProfile || "";
+  const enteredRuntime = (await promptLine(`Shared room runtime profile [${currentRuntime || "none"}] (Enter to keep, clear to unset): `)).trim();
+  if (enteredRuntime) {
+    const nextRuntime = enteredRuntime.toLowerCase() === "clear" ? "" : enteredRuntime;
+    project = await setSharedRuntimeProfile(cwd, nextRuntime, { actorId: operator.id });
+  }
+
+  const createInvite = await promptYesNo("Create the first shared-project invite now?", {
+    input: process.stdin,
+    output: process.stdout
+  });
+  if (createInvite) {
+    const memberId = (await promptLine("Telegram user id or member id: ")).trim();
+    if (memberId) {
+      const role = (await promptLine("Role [editor] (owner|editor|observer): ")).trim().toLowerCase() || "editor";
+      const name = (await promptLine("Display name (Enter to reuse id): ")).trim() || memberId;
+      const result = await createSharedInvite(
+        cwd,
+        { id: memberId, role, name, paired: true },
+        { actorId: operator.id, actorName: operator.name }
+      );
+      project = result.project;
+      console.log(green(`Created shared-project invite [${result.invite.id}] for ${memberId} as ${result.invite.role}`));
+    }
+  }
+
+  return project;
+}
+
 async function runProjectCommand(positional, { cwd = process.cwd(), asJson = false } = {}) {
   const sub = String(positional[1] || "").trim().toLowerCase();
   if (sub === "share") {
     const operator = getLocalOperatorIdentity();
-    const project = await enableSharedProject(cwd, { userId: operator.id, userName: operator.name, role: "owner" });
+    let project = await enableSharedProject(cwd, { userId: operator.id, userName: operator.name, role: "owner" });
+    if (!asJson) {
+      project = await configureSharedProjectInteractive(cwd, operator, project);
+    }
     const paths = getSharedProjectPaths(cwd);
     if (asJson) {
       printData({ ok: true, action: "share", project, paths }, true);
@@ -3857,6 +3936,7 @@ async function runProjectCommand(positional, { cwd = process.cwd(), asJson = fal
     console.log(`Shared project enabled in ${cwd}`);
     console.log(`shared metadata: ${paths.sharedJson}`);
     console.log(`roundtable: ${paths.roundtable}`);
+    printSharedProjectNextSteps(project);
     return;
   }
 
@@ -7342,7 +7422,12 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
     console.log(formatBorderRow(clampColumns(process.stdout.columns || 80)));
   }
 
+  let lastSeenSharedRoomEventId = getLatestSharedRoomEventId(await loadSharedProject(context.cwd).catch(() => null));
   while (true) {
+    const sharedFeed = await flushSharedRoomEventFeed({ cwd: context.cwd, lastSeenEventId: lastSeenSharedRoomEventId });
+    if (sharedFeed.latestEventId) {
+      lastSeenSharedRoomEventId = sharedFeed.latestEventId;
+    }
     await touchTelegramBridgeHost({ sessionId: currentSession.id, cwd: context.cwd });
     const nextInput = await readInteractiveLine({
         getFooterText(inputBuffer) {
@@ -7908,6 +7993,16 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
         context.costTracker = createCostTracker();
         console.log(`started new project session: ${currentSession.id}`);
         console.log(`cwd set to ${target}`);
+        const shareProject = await promptYesNo("Make this new project shared?", { input: process.stdin, output: process.stdout });
+        if (shareProject) {
+          const operator = getLocalOperatorIdentity();
+          const project = await configureSharedProjectInteractive(
+            target,
+            operator,
+            await enableSharedProject(target, { userId: operator.id, userName: operator.name, role: "owner" })
+          );
+          printSharedProjectNextSteps(project);
+        }
       } catch (error) {
         console.log(`new project failed: ${error instanceof Error ? error.message : String(error)}`);
       }

package/src/gateway.js

@@ -25,6 +25,7 @@ const TELEGRAM_COMMANDS = [
   { command: "help", description: "Show Telegram control help" },
   { command: "about", description: "Show local Waterbrother identity and capabilities" },
   { command: "state", description: "Show current Waterbrother self-awareness state" },
+  { command: "run", description: "Execute an explicit remote prompt" },
   { command: "status", description: "Show the linked remote session" },
   { command: "cwd", description: "Show the current remote working directory" },
   { command: "runtime", description: "Show active runtime status" },
@@ -201,6 +202,7 @@ function buildRemoteHelp() {
     "<code>/help</code> show this help",
     "<code>/about</code> show Waterbrother identity and local capabilities",
     "<code>/state</code> show current Waterbrother self-awareness state",
+    "<code>/run &lt;prompt&gt;</code> execute an explicit remote request",
     "<code>/status</code> show the current linked remote session",
     "<code>/cwd</code> show the current remote working directory",
     "<code>/use &lt;path&gt;</code> switch the linked session to another directory",
@@ -231,7 +233,8 @@ function buildRemoteHelp() {
     "<code>/new</code> start a fresh remote session",
     "<code>/clear</code> clear the current remote conversation history",
     "",
-    "Any other message is sent to the linked Waterbrother session.",
+    "In private chats, any other message is sent to the linked Waterbrother session.",
+    "In groups, explicit execution should use <code>/run &lt;prompt&gt;</code>.",
     "",
     "<b>Current limitation</b>",
     "• fallback remote runs still use <code>approval=never</code> if no live TUI host is attached",
@@ -1662,8 +1665,16 @@ class TelegramGateway {
       return;
     }
 
-    const promptText = this.stripBotMention(text);
-    const groupIntent = this.isGroupChat(message) ? classifyTelegramGroupIntent(promptText) : { kind: "execution", reason: "private chat" };
+    if (text === "/run") {
+      await this.sendMessage(message.chat.id, "Usage: <code>/run &lt;prompt&gt;</code>", message.message_id);
+      return;
+    }
+
+    const isExplicitRun = text.startsWith("/run ");
+    const promptText = this.stripBotMention(isExplicitRun ? text.replace("/run", "").trim() : text);
+    const groupIntent = this.isGroupChat(message)
+      ? (isExplicitRun ? { kind: "execution", reason: "explicit /run" } : classifyTelegramGroupIntent(promptText))
+      : { kind: "execution", reason: "private chat" };
     const sharedBinding = await this.bindSharedRoomForMessage(message, sessionId);
     const manifest = await buildSelfAwarenessManifest({ cwd: sharedBinding.session.cwd || this.cwd, runtime: this.runtime, currentSession: sharedBinding.session });
     const localConceptAnswer = resolveLocalConceptQuestion(promptText, manifest);
@@ -1696,6 +1707,14 @@ class TelegramGateway {
       await this.sendMessage(message.chat.id, escapeTelegramHtml(planHint), message.message_id, { parseMode: "HTML" });
       return;
     }
+    if (this.isGroupChat(message) && groupIntent.kind === "execution" && !isExplicitRun) {
+      await this.sendMessage(
+        message.chat.id,
+        "Execution requests in groups must use <code>/run &lt;prompt&gt;</code>. Discussion and planning can stay as normal targeted messages.",
+        message.message_id
+      );
+      return;
+    }
     if (localConceptAnswer) {
       await this.sendMessage(message.chat.id, renderTelegramChunks(localConceptAnswer).join("\n\n"), message.message_id, { parseMode: "HTML" });
       return;

package/src/shared-project.js

@@ -6,6 +6,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"];
+const RECENT_EVENT_LIMIT = 24;
 
 function makeId(prefix = "id") {
   return `${prefix}_${crypto.randomBytes(3).toString("hex")}`;
@@ -40,6 +41,12 @@ function normalizeSharedProject(project = {}, cwd = process.cwd()) {
         .map((invite) => normalizePendingInvite(invite))
         .filter((invite) => invite.id && invite.memberId && invite.status === "pending")
     : [];
+  const recentEvents = Array.isArray(project.recentEvents)
+    ? project.recentEvents
+        .map((event) => normalizeSharedEvent(event))
+        .filter((event) => event.id && event.text)
+        .slice(-RECENT_EVENT_LIMIT)
+    : [];
   const activeOperator = project.activeOperator && typeof project.activeOperator === "object"
     ? {
         id: String(project.activeOperator.id || "").trim(),
@@ -67,6 +74,7 @@ function normalizeSharedProject(project = {}, cwd = process.cwd()) {
     members,
     tasks,
     pendingInvites,
+    recentEvents,
     activeOperator: activeOperator?.id ? activeOperator : null,
     approvalPolicy: String(project.approvalPolicy || "owner").trim() || "owner",
     createdAt: String(project.createdAt || new Date().toISOString()).trim(),
@@ -74,6 +82,18 @@ function normalizeSharedProject(project = {}, cwd = process.cwd()) {
   };
 }
 
+function normalizeSharedEvent(event = {}) {
+  return {
+    id: String(event.id || makeId("rte")).trim(),
+    type: String(event.type || "note").trim(),
+    text: String(event.text || "").trim(),
+    actorId: String(event.actorId || "").trim(),
+    actorName: String(event.actorName || "").trim(),
+    createdAt: String(event.createdAt || new Date().toISOString()).trim(),
+    meta: event.meta && typeof event.meta === "object" ? { ...event.meta } : {}
+  };
+}
+
 function normalizeSharedTask(task = {}) {
   const comments = Array.isArray(task.comments)
     ? task.comments
@@ -269,6 +289,16 @@ export async function appendRoundtableEvent(cwd, line) {
   return target;
 }
 
+async function recordSharedProjectEvent(cwd, project, text, { type = "note", actorId = "", actorName = "", meta = {} } = {}) {
+  const event = normalizeSharedEvent({ type, text, actorId, actorName, meta });
+  const next = await saveSharedProject(cwd, {
+    ...project,
+    recentEvents: [...(project.recentEvents || []), event].slice(-RECENT_EVENT_LIMIT)
+  });
+  await appendRoundtableEvent(cwd, `- ${event.createdAt}: ${event.text}`);
+  return { project: next, event };
+}
+
 export async function loadSharedProject(cwd) {
   try {
     const raw = await fs.readFile(sharedFilePath(cwd), "utf8");
@@ -311,8 +341,11 @@ export async function enableSharedProject(cwd, options = {}) {
       claimedAt: new Date().toISOString()
     }
   });
-  await appendRoundtableEvent(cwd, `- ${new Date().toISOString()}: sharing enabled by ${member.name || member.id}`);
-  return project;
+  return (await recordSharedProjectEvent(cwd, project, `sharing enabled by ${member.name || member.id}`, {
+    type: "sharing-enabled",
+    actorId: member.id,
+    actorName: member.name
+  })).project;
 }
 
 export async function disableSharedProject(cwd) {
@@ -323,8 +356,7 @@ export async function disableSharedProject(cwd) {
     enabled: false,
     activeOperator: null
   });
-  await appendRoundtableEvent(cwd, `- ${new Date().toISOString()}: sharing disabled`);
-  return next;
+  return (await recordSharedProjectEvent(cwd, next, "sharing disabled", { type: "sharing-disabled" })).project;
 }
 
 export async function setSharedRoom(cwd, room = {}) {
@@ -338,7 +370,9 @@ export async function setSharedRoom(cwd, room = {}) {
       title: String(room.title || existing.room?.title || "").trim()
     }
   });
-  return next;
+  return (await recordSharedProjectEvent(cwd, next, `room linked to ${next.room.provider || "unknown"} ${next.room.chatId || ""}`.trim(), {
+    type: "room-linked"
+  })).project;
 }
 
 export async function setSharedRoomMode(cwd, roomMode = "chat", options = {}) {
@@ -352,8 +386,10 @@ export async function setSharedRoomMode(cwd, roomMode = "chat", options = {}) {
     ...existing,
     roomMode: normalized
   });
-  await appendRoundtableEvent(cwd, `- ${new Date().toISOString()}: room mode set to ${normalized}`);
-  return next;
+  return (await recordSharedProjectEvent(cwd, next, `room mode set to ${normalized}`, {
+    type: "room-mode",
+    actorId: String(options.actorId || "").trim()
+  })).project;
 }
 
 export async function setSharedRuntimeProfile(cwd, runtimeProfile = "", options = {}) {
@@ -364,11 +400,10 @@ export async function setSharedRuntimeProfile(cwd, runtimeProfile = "", options
     ...existing,
     runtimeProfile: normalized
   });
-  await appendRoundtableEvent(
-    cwd,
-    `- ${new Date().toISOString()}: room runtime profile ${normalized ? `set to ${normalized}` : "cleared"}`
-  );
-  return next;
+  return (await recordSharedProjectEvent(cwd, next, `room runtime profile ${normalized ? `set to ${normalized}` : "cleared"}`, {
+    type: "room-runtime",
+    actorId: String(options.actorId || "").trim()
+  })).project;
 }
 
 export function getSharedMember(project, memberId = "") {
@@ -437,11 +472,11 @@ export async function upsertSharedMember(cwd, member = {}, options = {}) {
     ...existing,
     members
   });
-  await appendRoundtableEvent(
-    cwd,
-    `- ${new Date().toISOString()}: member ${nextMember.name || nextMember.id} set to role ${nextMember.role}`
-  );
-  return next;
+  return (await recordSharedProjectEvent(cwd, next, `member ${nextMember.name || nextMember.id} set to role ${nextMember.role}`, {
+    type: "member-upsert",
+    actorId: String(options.actorId || "").trim(),
+    meta: { memberId: nextMember.id, role: nextMember.role }
+  })).project;
 }
 
 export async function createSharedInvite(cwd, member = {}, options = {}) {
@@ -468,11 +503,13 @@ export async function createSharedInvite(cwd, member = {}, options = {}) {
     ...existing,
     pendingInvites
   });
-  await appendRoundtableEvent(
-    cwd,
-    `- ${new Date().toISOString()}: invite created [${invite.id}] for ${invite.memberName || invite.memberId} as ${invite.role}`
-  );
-  return { project: next, invite };
+  const recorded = await recordSharedProjectEvent(cwd, next, `invite created [${invite.id}] for ${invite.memberName || invite.memberId} as ${invite.role}`, {
+    type: "invite-created",
+    actorId: String(options.actorId || "").trim(),
+    actorName: String(options.actorName || "").trim(),
+    meta: { inviteId: invite.id, memberId: invite.memberId, role: invite.role }
+  });
+  return { project: recorded.project, invite };
 }
 
 export async function approveSharedInvite(cwd, inviteId = "", options = {}) {
@@ -499,11 +536,12 @@ export async function approveSharedInvite(cwd, inviteId = "", options = {}) {
     members,
     pendingInvites
   });
-  await appendRoundtableEvent(
-    cwd,
-    `- ${new Date().toISOString()}: invite approved [${invite.id}] for ${invite.memberName || invite.memberId}`
-  );
-  return { project: next, invite };
+  const recorded = await recordSharedProjectEvent(cwd, next, `invite approved [${invite.id}] for ${invite.memberName || invite.memberId}`, {
+    type: "invite-approved",
+    actorId: String(options.actorId || "").trim(),
+    meta: { inviteId: invite.id, memberId: invite.memberId }
+  });
+  return { project: recorded.project, invite };
 }
 
 export async function rejectSharedInvite(cwd, inviteId = "", options = {}) {
@@ -519,11 +557,12 @@ export async function rejectSharedInvite(cwd, inviteId = "", options = {}) {
     ...existing,
     pendingInvites
   });
-  await appendRoundtableEvent(
-    cwd,
-    `- ${new Date().toISOString()}: invite rejected [${invite.id}] for ${invite.memberName || invite.memberId}`
-  );
-  return { project: next, invite };
+  const recorded = await recordSharedProjectEvent(cwd, next, `invite rejected [${invite.id}] for ${invite.memberName || invite.memberId}`, {
+    type: "invite-rejected",
+    actorId: String(options.actorId || "").trim(),
+    meta: { inviteId: invite.id, memberId: invite.memberId }
+  });
+  return { project: recorded.project, invite };
 }
 
 export async function acceptSharedInvite(cwd, inviteId = "", options = {}) {
@@ -556,11 +595,13 @@ export async function acceptSharedInvite(cwd, inviteId = "", options = {}) {
     members,
     pendingInvites
   });
-  await appendRoundtableEvent(
-    cwd,
-    `- ${new Date().toISOString()}: invite accepted [${invite.id}] by ${actorName || actorId}`
-  );
-  return { project: next, invite };
+  const recorded = await recordSharedProjectEvent(cwd, next, `invite accepted [${invite.id}] by ${actorName || actorId}`, {
+    type: "invite-accepted",
+    actorId,
+    actorName,
+    meta: { inviteId: invite.id, memberId: invite.memberId }
+  });
+  return { project: recorded.project, invite };
 }
 
 export async function removeSharedMember(cwd, memberId = "", options = {}) {
@@ -579,11 +620,11 @@ export async function removeSharedMember(cwd, memberId = "", options = {}) {
     members: (existing.members || []).filter((member) => member.id !== normalizedId),
     activeOperator: existing.activeOperator?.id === normalizedId ? null : existing.activeOperator
   });
-  await appendRoundtableEvent(
-    cwd,
-    `- ${new Date().toISOString()}: member removed ${current.name || current.id}`
-  );
-  return next;
+  return (await recordSharedProjectEvent(cwd, next, `member removed ${current.name || current.id}`, {
+    type: "member-removed",
+    actorId: String(options.actorId || "").trim(),
+    meta: { memberId: current.id }
+  })).project;
 }
 
 export async function listSharedTasks(cwd) {
@@ -618,8 +659,13 @@ export async function addSharedTask(cwd, text = "", options = {}) {
     ...existing,
     tasks: [...(existing.tasks || []), task]
   });
-  await appendRoundtableEvent(cwd, `- ${new Date().toISOString()}: task added [${task.id}] ${task.text}`);
-  return { project: next, task };
+  const recorded = await recordSharedProjectEvent(cwd, next, `task added [${task.id}] ${task.text}`, {
+    type: "task-added",
+    actorId: String(options.actorId || "").trim(),
+    actorName: String(options.actorName || "").trim(),
+    meta: { taskId: task.id }
+  });
+  return { project: recorded.project, task };
 }
 
 export async function moveSharedTask(cwd, taskId = "", state = "open", options = {}) {
@@ -648,8 +694,13 @@ export async function moveSharedTask(cwd, taskId = "", state = "open", options =
     ...existing,
     tasks
   });
-  await appendRoundtableEvent(cwd, `- ${new Date().toISOString()}: task moved [${tasks[index].id}] -> ${normalizedState}`);
-  return { project: next, task: tasks[index] };
+  const recorded = await recordSharedProjectEvent(cwd, next, `task moved [${tasks[index].id}] -> ${normalizedState}`, {
+    type: "task-moved",
+    actorId: String(options.actorId || "").trim(),
+    actorName: String(options.actorName || "").trim(),
+    meta: { taskId: tasks[index].id, state: normalizedState }
+  });
+  return { project: recorded.project, task: tasks[index] };
 }
 
 export async function assignSharedTask(cwd, taskId = "", memberId = "", options = {}) {
@@ -678,8 +729,13 @@ export async function assignSharedTask(cwd, taskId = "", memberId = "", options
     ...existing,
     tasks
   });
-  await appendRoundtableEvent(cwd, `- ${new Date().toISOString()}: task assigned [${tasks[index].id}] -> ${normalizedMemberId}`);
-  return { project: next, task: tasks[index] };
+  const recorded = await recordSharedProjectEvent(cwd, next, `task assigned [${tasks[index].id}] -> ${normalizedMemberId}`, {
+    type: "task-assigned",
+    actorId: String(options.actorId || "").trim(),
+    actorName: String(options.actorName || "").trim(),
+    meta: { taskId: tasks[index].id, memberId: normalizedMemberId }
+  });
+  return { project: recorded.project, task: tasks[index] };
 }
 
 export async function claimSharedTask(cwd, taskId = "", options = {}) {
@@ -705,8 +761,13 @@ export async function claimSharedTask(cwd, taskId = "", options = {}) {
     ...existing,
     tasks
   });
-  await appendRoundtableEvent(cwd, `- ${new Date().toISOString()}: task claimed [${tasks[index].id}] by ${actorId}`);
-  return { project: next, task: tasks[index] };
+  const recorded = await recordSharedProjectEvent(cwd, next, `task claimed [${tasks[index].id}] by ${actorId}`, {
+    type: "task-claimed",
+    actorId,
+    actorName: String(options.actorName || "").trim(),
+    meta: { taskId: tasks[index].id }
+  });
+  return { project: recorded.project, task: tasks[index] };
 }
 
 export async function commentSharedTask(cwd, taskId = "", text = "", options = {}) {
@@ -735,8 +796,13 @@ export async function commentSharedTask(cwd, taskId = "", text = "", options = {
     ...existing,
     tasks
   });
-  await appendRoundtableEvent(cwd, `- ${new Date().toISOString()}: task comment [${tasks[index].id}] ${normalizedText}`);
-  return { project: next, task: tasks[index], comment };
+  const recorded = await recordSharedProjectEvent(cwd, next, `task comment [${tasks[index].id}] ${normalizedText}`, {
+    type: "task-comment",
+    actorId: String(options.actorId || "").trim(),
+    actorName: String(options.actorName || "").trim(),
+    meta: { taskId: tasks[index].id }
+  });
+  return { project: recorded.project, task: tasks[index], comment };
 }
 
 export async function getSharedTaskHistory(cwd, taskId = "", options = {}) {
@@ -778,8 +844,11 @@ export async function claimSharedOperator(cwd, operator = {}) {
     members,
     activeOperator: nextOperator
   });
-  await appendRoundtableEvent(cwd, `- ${new Date().toISOString()}: operator claimed by ${nextOperator.name || nextOperator.id}`);
-  return next;
+  return (await recordSharedProjectEvent(cwd, next, `operator claimed by ${nextOperator.name || nextOperator.id}`, {
+    type: "operator-claimed",
+    actorId: nextOperator.id,
+    actorName: nextOperator.name
+  })).project;
 }
 
 export async function releaseSharedOperator(cwd, operatorId = "", options = {}) {
@@ -799,8 +868,10 @@ export async function releaseSharedOperator(cwd, operatorId = "", options = {})
     ...existing,
     activeOperator: null
   });
-  await appendRoundtableEvent(cwd, `- ${new Date().toISOString()}: operator released`);
-  return next;
+  return (await recordSharedProjectEvent(cwd, next, "operator released", {
+    type: "operator-released",
+    actorId
+  })).project;
 }
 
 export function formatSharedProjectStatus(project) {
@@ -818,7 +889,8 @@ export function formatSharedProjectStatus(project) {
     activeOperator: project.activeOperator,
     members: project.members,
     pendingInvites: project.pendingInvites,
-    tasks: project.tasks
+    tasks: project.tasks,
+    recentEvents: project.recentEvents
   }, null, 2);
 }