@tritard/waterbrother 0.16.46 → 0.16.47

package/README.md

@@ -296,7 +296,7 @@ Current Telegram behavior:
 - the gateway sends typing activity and edits one in-progress message into the final reply before falling back to chunked follow-up messages
 - 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>`
+- 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
 - 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
 - `/room` now includes pending invite count plus task ownership summaries

package/package.json

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

package/src/cli.js

@@ -124,6 +124,10 @@ const INTERACTIVE_COMMANDS = [
   { name: "/sessions", description: "List recent sessions" },
   { name: "/new", description: "Start a new session" },
   { name: "/resume <id>", description: "Resume a saved session" },
+  { name: "/project", description: "Show current project cwd and shared-room state" },
+  { name: "/project use <path|name>", description: "Switch the live session to another project or directory" },
+  { name: "/project new <name>", description: "Create a Desktop project and switch into it" },
+  { name: "/project share", description: "Enable shared-project mode in the current project" },
   { name: "/run <prompt>", description: "Run a normal prompt without treating it as a slash command" },
   { name: "/fork", description: "Fork current session into a new session" },
   { name: "/clear", description: "Clear current conversation history" },
@@ -8019,6 +8023,18 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
       continue;
     }
 
+    if (line === "/project") {
+      const sharedProject = await loadSharedProject(context.cwd).catch(() => null);
+      console.log(JSON.stringify({
+        cwd: context.cwd,
+        project: path.basename(context.cwd),
+        shared: sharedProject?.enabled === true,
+        roomMode: sharedProject?.enabled ? sharedProject.roomMode || "chat" : null,
+        room: sharedProject?.enabled ? sharedProject.room || null : null
+      }, null, 2));
+      continue;
+    }
+
     if (line === "/desktop") {
       try {
         const desktopPath = path.join(process.env.HOME || process.env.USERPROFILE || "", "Desktop");
@@ -8045,6 +8061,24 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
       continue;
     }
 
+    if (line.startsWith("/project use ")) {
+      const rawPath = line.replace("/project use", "").trim();
+      if (!rawPath) {
+        console.log("Usage: /project use <path|name>");
+        continue;
+      }
+      try {
+        const projectPath = /^(~\/|\/|\.\/|\.\.\/)/.test(rawPath) || /^\/(?:desktop|downloads|documents)\b/i.test(rawPath)
+          ? rawPath
+          : path.join(process.env.HOME || process.env.USERPROFILE || "", "Desktop", rawPath);
+        const nextCwd = await switchSessionWorkspace({ agent, session: currentSession, context, nextCwd: projectPath });
+        console.log(`cwd set to ${nextCwd}`);
+      } catch (error) {
+        console.log(`project switch failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      continue;
+    }
+
     if (line.startsWith("/new-project ")) {
       const projectName = line.replace("/new-project", "").trim();
       if (!projectName) {
@@ -8079,6 +8113,30 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
       continue;
     }
 
+    if (line.startsWith("/project new ")) {
+      const projectName = line.replace("/project new", "").trim();
+      if (!projectName) {
+        console.log("Usage: /project new <name>");
+        continue;
+      }
+      try {
+        const target = canonicalizeLoosePath(path.join(process.env.HOME || process.env.USERPROFILE || "", "Desktop", projectName));
+        await fs.mkdir(target, { recursive: true });
+        await saveCurrentSession(currentSession, agent);
+        const fresh = await createSession({ cwd: target, model: agent.getModel(), agentProfile: agent.getProfile() });
+        currentSession = fresh;
+        agent.resetConversation();
+        await switchSessionWorkspace({ agent, session: currentSession, context, nextCwd: target });
+        context.lastUsage = null;
+        context.costTracker = createCostTracker();
+        console.log(`started new project session: ${currentSession.id}`);
+        console.log(`cwd set to ${target}`);
+      } catch (error) {
+        console.log(`new project failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      continue;
+    }
+
     if (line.startsWith("/run ")) {
       const promptText = line.replace("/run", "").trim();
       if (!promptText) {
@@ -8275,6 +8333,15 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
       continue;
     }
 
+    if (line === "/project share") {
+      try {
+        await runProjectCommand(["project", "share"], { cwd: context.cwd, asJson: false });
+      } catch (error) {
+        console.log(`project share failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      continue;
+    }
+
     if (line === "/unshare-project") {
       try {
         await runProjectCommand(["project", "unshare"], { cwd: context.cwd, asJson: false });

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 { acceptSharedInvite, addSharedTask, approveSharedInvite, assignSharedTask, claimSharedOperator, claimSharedTask, commentSharedTask, createSharedInvite, getSharedTaskHistory, listSharedEvents, listSharedInvites, listSharedTasks, loadSharedProject, moveSharedTask, rejectSharedInvite, releaseSharedOperator, setSharedRoom, setSharedRoomMode, setSharedRuntimeProfile, removeSharedMember } from "./shared-project.js";
+import { acceptSharedInvite, addSharedTask, approveSharedInvite, assignSharedTask, claimSharedOperator, claimSharedTask, commentSharedTask, createSharedInvite, enableSharedProject, getSharedTaskHistory, listSharedEvents, listSharedInvites, listSharedTasks, loadSharedProject, moveSharedTask, rejectSharedInvite, releaseSharedOperator, setSharedRoom, setSharedRoomMode, setSharedRuntimeProfile, removeSharedMember, upsertSharedMember } from "./shared-project.js";
 import { buildSelfAwarenessManifest, formatAboutWaterbrother, formatSelfState, resolveLocalConceptQuestion } from "./self-awareness.js";
 
 const execFileAsync = promisify(execFile);
@@ -29,6 +29,7 @@ const TELEGRAM_COMMANDS = [
   { command: "status", description: "Show the linked remote session" },
   { command: "whoami", description: "Show your Telegram identity and room membership" },
   { command: "people", description: "Show recently seen Telegram people in this chat" },
+  { command: "project", description: "Show or change the linked project" },
   { command: "cwd", description: "Show the current remote working directory" },
   { command: "runtime", description: "Show active runtime status" },
   { command: "room", description: "Show shared room status" },
@@ -209,6 +210,10 @@ function buildRemoteHelp() {
     "<code>/status</code> show the current linked remote session",
     "<code>/whoami</code> show your Telegram identity and room membership",
     "<code>/people</code> list recent Telegram users in this chat for easier invites",
+    "<code>/project</code> show the linked project and sharing state",
+    "<code>/project use &lt;path|name&gt;</code> switch to another project or directory",
+    "<code>/project new &lt;name&gt;</code> create a Desktop project and switch into it",
+    "<code>/project share</code> enable Roundtable in the current project and bind this chat",
     "<code>/cwd</code> show the current remote working directory",
     "<code>/use &lt;path&gt;</code> switch the linked session to another directory",
     "<code>/desktop</code> switch the linked session to <code>~/Desktop</code>",
@@ -262,6 +267,67 @@ function formatGatewaySessionStatus({ sessionId, userId, username, cwd, runtimeP
   return bits.join("\n");
 }
 
+function formatTelegramProjectMarkup({ cwd, project, chatId = "", title = "" }) {
+  const lines = [
+    "<b>Linked project</b>",
+    `cwd: <code>${escapeTelegramHtml(cwd || "-")}</code>`,
+    `name: <code>${escapeTelegramHtml(project?.projectName || path.basename(cwd || "") || "-")}</code>`,
+    `shared: <code>${project?.enabled ? "yes" : "no"}</code>`
+  ];
+  if (project?.enabled) {
+    lines.push(`room mode: <code>${escapeTelegramHtml(project.roomMode || "chat")}</code>`);
+    lines.push(
+      `bound chat: <code>${escapeTelegramHtml(project.room?.provider === "telegram" && project.room?.chatId ? `${project.room.provider} ${project.room.chatId}` : "none")}</code>`
+    );
+    lines.push(`members: <code>${escapeTelegramHtml(String((project.members || []).length))}</code>`);
+  }
+  if (!project?.enabled) {
+    lines.push("Use <code>/project share</code> to turn on Roundtable for this project in this chat.");
+  } else if (chatId && String(project.room?.chatId || "") !== String(chatId || "")) {
+    lines.push(`This chat is not bound yet. Run <code>/project share</code> to bind ${escapeTelegramHtml(title || "this chat")} to the current project.`);
+  }
+  return lines.join("\n");
+}
+
+function normalizeTelegramProjectIntentText(text = "") {
+  return String(text || "").trim().replace(/\s+/g, " ");
+}
+
+function parseTelegramProjectIntent(text = "") {
+  const value = normalizeTelegramProjectIntentText(text);
+  const lowered = value.toLowerCase();
+  if (!value) return null;
+  if (/^(how|what|why|when|where|who)\b/.test(lowered)) return null;
+
+  if (
+    /\b(?:share|enable|turn on|set up)\b.*\b(?:roundtable|shared room|shared project)\b/.test(lowered)
+    || /\bshare (?:this|the) (?:repo|project)\b.*\b(?:chat|group|telegram|room|here)\b/.test(lowered)
+  ) {
+    return { action: "share-project" };
+  }
+
+  const newProjectMatch = value.match(/^(?:make|create|start)(?:\s+(?:me|a|an))?(?:\s+new)?\s+project(?:\s+(?:called|named))?\s+["“]?([^"”]+?)["”]?\s*$/i);
+  if (newProjectMatch?.[1]) {
+    return { action: "new-project", name: newProjectMatch[1].trim(), share: /\b(shared|roundtable)\b/i.test(value) };
+  }
+
+  if (/^(?:switch|change|move|use)\b/.test(lowered)) {
+    if (/\bdesktop\b/.test(lowered)) {
+      return { action: "use-path", target: "~/Desktop" };
+    }
+    const projectMatch = value.match(/^(?:switch|change|move|use)(?:\s+(?:the|my))?(?:\s+(?:project|repo|repository|folder|directory|workspace|cwd))?\s+(?:to\s+)?["“]?([^"”]+?)["”]?\s*$/i);
+    if (projectMatch?.[1]) {
+      return { action: "use-path", target: projectMatch[1].trim() };
+    }
+  }
+
+  if (/^(?:show|check)\s+(?:the\s+)?project\b/i.test(value) || /^what project\b/i.test(lowered)) {
+    return { action: "show-project" };
+  }
+
+  return null;
+}
+
 async function buildTelegramSelfAwarenessMarkup({ cwd, runtime, currentSession, kind = "about" }) {
   const manifest = await buildSelfAwarenessManifest({ cwd, runtime, currentSession });
   if (kind === "state") {
@@ -1027,19 +1093,96 @@ class TelegramGateway {
     return { session, project };
   }
 
+  canBootstrapTelegramOwner(project, userId) {
+    const normalizedUserId = String(userId || "").trim();
+    const members = Array.isArray(project?.members) ? project.members : [];
+    if (!project?.enabled || !normalizedUserId || !members.length) return false;
+    if (members.some((member) => String(member?.id || "").trim() === normalizedUserId)) return false;
+    if (members.some((member) => !String(member?.id || "").trim().startsWith("local:"))) return false;
+    return members.some((member) => String(member?.role || "").trim() === "owner");
+  }
+
+  async maybeBootstrapTelegramOwner(cwd, project, actor = {}) {
+    const normalizedCwd = String(cwd || "").trim();
+    const userId = String(actor.userId || "").trim();
+    if (!this.canBootstrapTelegramOwner(project, userId)) {
+      return project;
+    }
+    const bootstrapOwner = (project.members || []).find((member) => String(member?.role || "").trim() === "owner");
+    if (!bootstrapOwner?.id) return project;
+    return upsertSharedMember(
+      normalizedCwd,
+      { id: userId, name: actor.displayName || userId, role: "owner", paired: true },
+      { actorId: bootstrapOwner.id, actorName: bootstrapOwner.name || bootstrapOwner.id }
+    );
+  }
+
   async bindSharedRoomForMessage(message, sessionId) {
     const { session, project } = await this.loadSharedProjectForSession(sessionId);
     if (!project?.enabled) {
       return { session, project };
     }
-    const next = await setSharedRoom(session.cwd || this.cwd, {
+    let next = await setSharedRoom(session.cwd || this.cwd, {
       provider: "telegram",
       chatId: String(message.chat.id),
       title: String(message.chat.title || "").trim()
     });
+    next = await this.maybeBootstrapTelegramOwner(session.cwd || this.cwd, next, this.describeTelegramUser(message?.from || {}));
     return { session, project: next };
   }
 
+  async ensureProjectSharedForChat(message, sessionId) {
+    const session = await loadSession(sessionId);
+    const cwd = session.cwd || this.cwd;
+    const actor = this.describeTelegramUser(message?.from || {});
+    let project = await loadSharedProject(cwd);
+    if (!project?.enabled) {
+      project = await enableSharedProject(cwd, {
+        userId: actor.userId,
+        userName: actor.displayName || actor.userId,
+        role: "owner"
+      });
+    } else {
+      project = await this.maybeBootstrapTelegramOwner(cwd, project, actor);
+    }
+    project = await setSharedRoom(cwd, {
+      provider: "telegram",
+      chatId: String(message.chat.id),
+      title: String(message.chat.title || "").trim()
+    });
+    return { session, project };
+  }
+
+  async resolveTelegramProjectTarget(rawTarget) {
+    const value = String(rawTarget || "").trim();
+    if (!value) {
+      throw new Error("project path is required");
+    }
+    if (/^~\/?desktop$/i.test(value) || /^desktop$/i.test(value) || /^\/desktop$/i.test(value)) {
+      return canonicalizeLoosePath(path.join(process.env.HOME || process.env.USERPROFILE || "", "Desktop"));
+    }
+    if (/^(~\/|\/|\.\/|\.\.\/)/.test(value) || /^\/(?:desktop|downloads|documents)\b/i.test(value)) {
+      return canonicalizeLoosePath(value);
+    }
+    return canonicalizeLoosePath(path.join(process.env.HOME || process.env.USERPROFILE || "", "Desktop", value));
+  }
+
+  async switchPeerProject(message, target, { create = false, share = false } = {}) {
+    const nextCwd = await this.resolveTelegramProjectTarget(target);
+    if (create) {
+      await fs.mkdir(nextCwd, { recursive: true });
+    }
+    const sessionId = await this.ensurePeerSession(message);
+    await this.updatePeerSessionCwd(message, nextCwd);
+    let project = await loadSharedProject(nextCwd);
+    if (share) {
+      ({ project } = await this.ensureProjectSharedForChat(message, sessionId));
+    } else if (project?.enabled) {
+      ({ project } = await this.bindSharedRoomForMessage(message, sessionId));
+    }
+    return { sessionId, cwd: nextCwd, project };
+  }
+
   async buildRoomMarkup(message, sessionId) {
     const { project } = await this.bindSharedRoomForMessage(message, sessionId);
     const host = await this.getLiveBridgeHost();
@@ -1364,6 +1507,88 @@ class TelegramGateway {
       return;
     }
 
+    if (text === "/project") {
+      const { session, project } = await this.bindSharedRoomForMessage(message, sessionId);
+      await this.sendMarkup(
+        message.chat.id,
+        formatTelegramProjectMarkup({
+          cwd: session.cwd || this.cwd,
+          project,
+          chatId: String(message.chat.id),
+          title: String(message.chat.title || "").trim()
+        }),
+        message.message_id
+      );
+      return;
+    }
+
+    if (text === "/project share") {
+      try {
+        const { session, project } = await this.ensureProjectSharedForChat(message, sessionId);
+        await this.sendMarkup(
+          message.chat.id,
+          `${formatTelegramProjectMarkup({
+            cwd: session.cwd || this.cwd,
+            project,
+            chatId: String(message.chat.id),
+            title: String(message.chat.title || "").trim()
+          })}\n\nRoundtable is now enabled for this project in this chat.`,
+          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("/project use ")) {
+      const rawPath = text.replace("/project use", "").trim();
+      if (!rawPath) {
+        await this.sendMarkup(message.chat.id, "Usage: <code>/project use &lt;path|name&gt;</code>", message.message_id);
+        return;
+      }
+      try {
+        const result = await this.switchPeerProject(message, rawPath);
+        await this.sendMarkup(
+          message.chat.id,
+          `${formatTelegramProjectMarkup({
+            cwd: result.cwd,
+            project: result.project,
+            chatId: String(message.chat.id),
+            title: String(message.chat.title || "").trim()
+          })}\n\nLinked project switched successfully.`,
+          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("/project new ")) {
+      const projectName = text.replace("/project new", "").trim();
+      if (!projectName) {
+        await this.sendMarkup(message.chat.id, "Usage: <code>/project new &lt;name&gt;</code>", message.message_id);
+        return;
+      }
+      try {
+        const result = await this.switchPeerProject(message, projectName, { create: true });
+        await this.sendMarkup(
+          message.chat.id,
+          `${formatTelegramProjectMarkup({
+            cwd: result.cwd,
+            project: result.project,
+            chatId: String(message.chat.id),
+            title: String(message.chat.title || "").trim()
+          })}\n\nCreated and switched to a new Desktop project.`,
+          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 === "/status") {
       await this.sendMarkup(
         message.chat.id,
@@ -1901,6 +2126,74 @@ 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 projectIntent = parseTelegramProjectIntent(promptText);
+    if (projectIntent?.action === "show-project") {
+      await this.sendMarkup(
+        message.chat.id,
+        formatTelegramProjectMarkup({
+          cwd: sharedBinding.session.cwd || this.cwd,
+          project: sharedBinding.project,
+          chatId: String(message.chat.id),
+          title: String(message.chat.title || "").trim()
+        }),
+        message.message_id
+      );
+      return;
+    }
+    if (projectIntent?.action === "share-project") {
+      try {
+        const { session, project } = await this.ensureProjectSharedForChat(message, sessionId);
+        await this.sendMarkup(
+          message.chat.id,
+          `${formatTelegramProjectMarkup({
+            cwd: session.cwd || this.cwd,
+            project,
+            chatId: String(message.chat.id),
+            title: String(message.chat.title || "").trim()
+          })}\n\nRoundtable is now enabled for this project in this chat.`,
+          message.message_id
+        );
+      } catch (error) {
+        await this.sendMessage(message.chat.id, escapeTelegramHtml(error instanceof Error ? error.message : String(error)), message.message_id);
+      }
+      return;
+    }
+    if (projectIntent?.action === "use-path") {
+      try {
+        const result = await this.switchPeerProject(message, projectIntent.target);
+        await this.sendMarkup(
+          message.chat.id,
+          `${formatTelegramProjectMarkup({
+            cwd: result.cwd,
+            project: result.project,
+            chatId: String(message.chat.id),
+            title: String(message.chat.title || "").trim()
+          })}\n\nLinked project switched successfully.`,
+          message.message_id
+        );
+      } catch (error) {
+        await this.sendMessage(message.chat.id, escapeTelegramHtml(error instanceof Error ? error.message : String(error)), message.message_id);
+      }
+      return;
+    }
+    if (projectIntent?.action === "new-project") {
+      try {
+        const result = await this.switchPeerProject(message, projectIntent.name, { create: true, share: projectIntent.share });
+        await this.sendMarkup(
+          message.chat.id,
+          `${formatTelegramProjectMarkup({
+            cwd: result.cwd,
+            project: result.project,
+            chatId: String(message.chat.id),
+            title: String(message.chat.title || "").trim()
+          })}\n\nCreated and switched to a new Desktop project${projectIntent.share ? ", with Roundtable enabled for this chat" : ""}.`,
+          message.message_id
+        );
+      } catch (error) {
+        await this.sendMessage(message.chat.id, escapeTelegramHtml(error instanceof Error ? error.message : String(error)), message.message_id);
+      }
+      return;
+    }
     const manifest = await buildSelfAwarenessManifest({ cwd: sharedBinding.session.cwd || this.cwd, runtime: this.runtime, currentSession: sharedBinding.session });
     const localConceptAnswer = resolveLocalConceptQuestion(promptText, manifest);
     if (