@tritard/waterbrother 0.16.49 → 0.16.51

package/README.md

@@ -297,7 +297,8 @@ Current Telegram behavior:
 - pending pairings are explicit and expire automatically after 12 hours unless approved
 - paired Telegram users drive the same live session and permissions as the terminal operator when the TUI bridge is attached
 - Telegram now supports remote workspace control with `/project`, `/project use <path|name>`, `/project new <name>`, `/project share`, plus the lower-level `/cwd`, `/use <path>`, `/desktop`, and `/new-project <name>` commands
-- Telegram owners can pair visible chat participants conversationally or with `/pair <user-id|@username>`, then continue with shared-room invites without dropping back to the terminal
+- Telegram owners can pair visible chat participants conversationally or with `/pair <user-id|@username>`, and owner requests like “add Austin as editor” now pair the person if needed and add them to the shared project directly
+- Telegram also answers live state questions from room state now, including prompts like “is Austin paired?”, “is Austin in the project?”, “who is in the room?”, and “what project is this chat bound to?”
 - Telegram owners can also use conversational project and member requests like “share this project in this chat”, “switch to TelegramTest”, or “add Austin as editor”, and Waterbrother routes those through the same project and shared-room actions
 - shared projects now support `/room`, `/events`, `/members`, `/invites`, `/whoami`, `/people`, `/tasks`, `/mode`, `/claim`, `/release`, `/invite`, `/accept-invite`, `/approve-invite`, `/reject-invite`, `/remove-member`, `/room-runtime`, and `/task ...` from Telegram
 - Telegram now supports `/whoami` for Telegram-id and shared-room membership visibility, plus `/events` for recent shared-room activity

package/package.json

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

package/src/gateway.js

@@ -379,6 +379,37 @@ function parseTelegramPairingIntent(text = "") {
   return null;
 }
 
+function parseTelegramStateIntent(text = "") {
+  const value = normalizeTelegramProjectIntentText(text);
+  const lower = value.toLowerCase();
+  if (!value) return null;
+
+  if (/\bwhat project\b/.test(lower) || /\bwhich project\b/.test(lower) || /\bproject is this chat\b/.test(lower) || /\bchat bound to\b/.test(lower)) {
+    return { action: "project-status" };
+  }
+  if (/\bwho is in the room\b/.test(lower) || /\bwho(?:'s| is) in the project\b/.test(lower) || /\bwho are the members\b/.test(lower) || /\bshow members\b/.test(lower)) {
+    return { action: "room-members" };
+  }
+  if (/\bwhat mode\b/.test(lower) || /\broom mode\b/.test(lower) || /\bmode are we in\b/.test(lower)) {
+    return { action: "room-mode" };
+  }
+  if (/\bwho can act\b/.test(lower) || /\bwho is the active operator\b/.test(lower) || /\bwho has the floor\b/.test(lower) || /\bwho claimed\b/.test(lower)) {
+    return { action: "active-operator" };
+  }
+
+  const pairedMatch = value.match(/^(?:is|has)\s+(.+?)\s+paired(?:\s+now)?\??$/i);
+  if (pairedMatch?.[1]) {
+    return { action: "pairing-status", target: pairedMatch[1].trim() };
+  }
+
+  const memberMatch = value.match(/^(?:is|has)\s+(.+?)\s+(?:in the project|in the room|a member)(?:\s+now)?\??$/i);
+  if (memberMatch?.[1]) {
+    return { action: "member-status", target: memberMatch[1].trim() };
+  }
+
+  return null;
+}
+
 async function buildTelegramSelfAwarenessMarkup({ cwd, runtime, currentSession, kind = "about" }) {
   const manifest = await buildSelfAwarenessManifest({ cwd, runtime, currentSession });
   if (kind === "state") {
@@ -1022,21 +1053,92 @@ class TelegramGateway {
         markup: `Updated <code>${escapeTelegramHtml(target.displayName || target.userId)}</code> to <code>${escapeTelegramHtml(intent.role)}</code> in this shared project.`
       };
     }
-    const result = await createSharedInvite(
+    const known = this.listKnownChatPeople(message);
+    const knownPerson = known.find((person) => String(person.userId || "").trim() === target.userId) || null;
+    let pairedNow = false;
+    if (!knownPerson?.paired) {
+      await this.pairKnownTelegramUser(message, target.userId, { skipOwnerCheck: true });
+      pairedNow = true;
+    }
+    const nextProject = await upsertSharedMember(
       session.cwd || this.cwd,
-      { id: target.userId, role: intent.role, name: target.displayName || target.userId, paired: true },
+      { id: target.userId, name: target.displayName || target.userId, role: intent.role, paired: true },
       { actorId, actorName }
     );
     return {
-      kind: "invite",
-      project: result.project,
-      markup: `Created pending invite <code>${escapeTelegramHtml(result.invite.id)}</code> for <code>${escapeTelegramHtml(target.displayName || target.userId)}</code> as <code>${escapeTelegramHtml(result.invite.role)}</code>.\nAsk them to run <code>/accept-invite ${escapeTelegramHtml(result.invite.id)}</code>.`
+      kind: "member",
+      project: nextProject,
+      markup: `${pairedNow ? `Paired <code>${escapeTelegramHtml(target.displayName || target.userId)}</code> <i>(${escapeTelegramHtml(target.userId)})</i> and ` : ""}added <code>${escapeTelegramHtml(target.displayName || target.userId)}</code> to this shared project as <code>${escapeTelegramHtml(intent.role)}</code>.`
     };
   }
 
-  async pairKnownTelegramUser(message, target) {
+  async handleStateIntent(message, sessionId, intent) {
+    const { session, project } = await this.bindSharedRoomForMessage(message, sessionId);
+    const cwd = session.cwd || this.cwd;
+    const known = this.listKnownChatPeople(message);
+
+    if (intent.action === "project-status") {
+      return formatTelegramProjectMarkup({
+        cwd,
+        project,
+        chatId: String(message.chat.id),
+        title: String(message.chat.title || "").trim()
+      });
+    }
+
+    if (intent.action === "room-members") {
+      return formatTelegramMembersMarkup(project);
+    }
+
+    if (intent.action === "room-mode") {
+      return project?.enabled
+        ? `<b>Shared room mode</b>\n<code>${escapeTelegramHtml(project.roomMode || "chat")}</code>`
+        : "This project is not shared.";
+    }
+
+    if (intent.action === "active-operator") {
+      if (!project?.enabled) {
+        return "This project is not shared.";
+      }
+      return project.activeOperator?.id
+        ? `<b>Active operator</b>\n<code>${escapeTelegramHtml(project.activeOperator.name || project.activeOperator.id)}</code>`
+        : "<b>Active operator</b>\nnone";
+    }
+
+    if (intent.action === "pairing-status") {
+      const person = this.resolveKnownPerson(message, intent.target);
+      const match = known.find((entry) => String(entry.userId || "").trim() === person.userId) || null;
+      return [
+        `<b>Telegram pairing</b>`,
+        `person: <code>${escapeTelegramHtml(match?.displayName || person.displayName || person.userId)}</code>`,
+        `user id: <code>${escapeTelegramHtml(person.userId)}</code>`,
+        `paired: <code>${escapeTelegramHtml(match?.paired ? "yes" : "no")}</code>`
+      ].join("\n");
+    }
+
+    if (intent.action === "member-status") {
+      if (!project?.enabled) {
+        return "This project is not shared.";
+      }
+      const person = this.resolveKnownPerson(message, intent.target);
+      const member = Array.isArray(project.members)
+        ? project.members.find((entry) => String(entry?.id || "").trim() === person.userId) || null
+        : null;
+      return [
+        `<b>Shared-project membership</b>`,
+        `person: <code>${escapeTelegramHtml(person.displayName || person.userId)}</code>`,
+        `user id: <code>${escapeTelegramHtml(person.userId)}</code>`,
+        `member: <code>${escapeTelegramHtml(member ? "yes" : "no")}</code>`,
+        member?.role ? `role: <code>${escapeTelegramHtml(member.role)}</code>` : ""
+      ].filter(Boolean).join("\n");
+    }
+
+    return null;
+  }
+
+  async pairKnownTelegramUser(message, target, { skipOwnerCheck = false } = {}) {
     const { session, project } = await this.bindSharedRoomForMessage(message, await this.ensurePeerSession(message));
-    if (project?.enabled) {
+    if (project?.enabled && !skipOwnerCheck) {
       const owner = Array.isArray(project.members)
         ? project.members.find((entry) => String(entry?.id || "").trim() === String(message?.from?.id || "").trim())
         : null;
@@ -2304,6 +2406,19 @@ Ask them to run <code>/whoami</code> and then <code>/accept-invite ${escapeTeleg
       ? (isExplicitRun ? { kind: "execution", reason: "explicit /run" } : classifyTelegramGroupIntent(promptText))
       : { kind: "execution", reason: "private chat" };
     const sharedBinding = await this.bindSharedRoomForMessage(message, sessionId);
+    const stateIntent = parseTelegramStateIntent(promptText);
+    if (stateIntent) {
+      try {
+        const markup = await this.handleStateIntent(message, sessionId, stateIntent);
+        if (markup) {
+          await this.sendMarkup(message.chat.id, markup, message.message_id);
+          return;
+        }
+      } catch (error) {
+        await this.sendMessage(message.chat.id, escapeTelegramHtml(error instanceof Error ? error.message : String(error)), message.message_id);
+        return;
+      }
+    }
     const pairingIntent = parseTelegramPairingIntent(promptText);
     if (pairingIntent) {
       try {