squadrant 0.10.0 → 0.11.1

package/dist/squadrantd.js

@@ -152,6 +152,48 @@ function saveConfig(config, configPath = DEFAULT_CONFIG_PATH) {
   fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
 }
 
+// packages/shared/dist/project-config.js
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+function defaultRoot() {
+  return path2.join(os2.homedir(), ".config", "squadrant");
+}
+function projectConfigPath(name, root = defaultRoot()) {
+  return path2.join(root, "projects", `${name}.json`);
+}
+function loadProjectOverride(name, root = defaultRoot()) {
+  try {
+    return JSON.parse(fs2.readFileSync(projectConfigPath(name, root), "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function deepMerge(base, patch) {
+  if (patch === null || typeof patch !== "object" || Array.isArray(patch))
+    return patch ?? base;
+  const out = { ...base };
+  for (const [k, v] of Object.entries(patch)) {
+    out[k] = deepMerge(out[k], v);
+  }
+  return out;
+}
+function saveProjectOverride(name, patch, root = defaultRoot()) {
+  const merged = deepMerge(loadProjectOverride(name, root), patch);
+  const file = projectConfigPath(name, root);
+  fs2.mkdirSync(path2.dirname(file), { recursive: true });
+  fs2.writeFileSync(file, JSON.stringify(merged, null, 2) + "\n");
+}
+var DEFAULT_NOTIFY = { active: false, cap: true, crew: "alert_only" };
+function resolveNotify(globalNotify, override) {
+  let n = { ...DEFAULT_NOTIFY };
+  if (globalNotify)
+    n = deepMerge(n, globalNotify);
+  if (override.telegram?.notify)
+    n = deepMerge(n, override.telegram.notify);
+  return n;
+}
+
 // packages/shared/dist/types/control.js
 var TERMINAL_STATES = /* @__PURE__ */ new Set([
   "done",
@@ -185,22 +227,22 @@ var MINIMAL_TEMPLATE = [
   ``
 ].join("\n");
 function ensureSocketAutomation(opts = {}) {
-  const path14 = opts.path ?? defaultCmuxConfigPath();
-  if (!existsSync(path14)) {
-    mkdirSync(dirname(path14), { recursive: true });
-    writeFileSync(path14, MINIMAL_TEMPLATE);
-    return { path: path14, changed: true, alreadySet: false };
+  const path16 = opts.path ?? defaultCmuxConfigPath();
+  if (!existsSync(path16)) {
+    mkdirSync(dirname(path16), { recursive: true });
+    writeFileSync(path16, MINIMAL_TEMPLATE);
+    return { path: path16, changed: true, alreadySet: false };
   }
-  const text = readFileSync(path14, "utf-8");
+  const text = readFileSync(path16, "utf-8");
   const current = parse(text)?.automation?.socketControlMode;
   if (current === AUTOMATION_MODE) {
-    return { path: path14, changed: false, alreadySet: true };
+    return { path: path16, changed: false, alreadySet: true };
   }
   const edits = modify(text, [...SOCKET_CONTROL_MODE_PATH], AUTOMATION_MODE, {
     formattingOptions: { insertSpaces: true, tabSize: 2 }
   });
-  writeFileSync(path14, applyEdits(text, edits));
-  return { path: path14, changed: true, alreadySet: false };
+  writeFileSync(path16, applyEdits(text, edits));
+  return { path: path16, changed: true, alreadySet: false };
 }
 
 // packages/shared/dist/lib/cmux-probe.js
@@ -322,9 +364,9 @@ function sleep(ms) {
 function defaultStatePath() {
   return join4(homedir3(), ".config", "squadrant", "state", "cmux-autoconfig.json");
 }
-function readState(path14) {
+function readState(path16) {
   try {
-    return JSON.parse(readFileSync4(path14, "utf-8"));
+    return JSON.parse(readFileSync4(path16, "utf-8"));
   } catch {
     return {};
   }
@@ -373,14 +415,14 @@ var compatManifest = {
 
 // packages/shared/dist/lib/git-worktree.js
 import { execFileSync as execFileSync2 } from "child_process";
-import path2 from "path";
+import path3 from "path";
 
 // packages/shared/dist/lib/resolve-text-input.js
-import fs2 from "fs";
+import fs3 from "fs";
 
 // packages/shared/dist/lib/runtime-sync.js
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 
 // packages/shared/dist/lib/tool-compat.js
 function parseSemVer(v) {
@@ -414,13 +456,13 @@ function checkToolCompat(name, rawVersion, entry) {
 }
 
 // packages/shared/dist/lib/canonical-source.js
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 
 // packages/shared/dist/lib/daily-logs.js
 import { execSync } from "child_process";
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
 import matter from "gray-matter";
 
 // packages/core/dist/state-machine.js
@@ -871,7 +913,7 @@ function createDaemon(deps) {
 }
 
 // packages/core/dist/mailbox.js
-import { promises as fs6 } from "fs";
+import { promises as fs7 } from "fs";
 import { join as join5 } from "path";
 import { randomUUID } from "crypto";
 function inboxDir(stateRoot) {
@@ -888,7 +930,7 @@ async function listRotatedOldestFirst(stateRoot, project) {
   const dir = inboxDir(stateRoot);
   let entries;
   try {
-    entries = await fs6.readdir(dir);
+    entries = await fs7.readdir(dir);
   } catch {
     return [];
   }
@@ -897,7 +939,7 @@ async function listRotatedOldestFirst(stateRoot, project) {
 }
 async function readMaxSeqFromFile(file) {
   try {
-    const buf = await fs6.readFile(file, "utf-8");
+    const buf = await fs7.readFile(file, "utf-8");
     if (!buf.trim())
       return 0;
     const lines = buf.trim().split("\n");
@@ -939,12 +981,12 @@ function withProjectLock(project, fn) {
 function appendEntry(stateRoot, project, build) {
   return withProjectLock(project, async () => {
     const dir = inboxDir(stateRoot);
-    await fs6.mkdir(dir, { recursive: true });
+    await fs7.mkdir(dir, { recursive: true });
     const file = logPath(stateRoot, project);
     const lastSeq = await readMaxSeq(stateRoot, project);
     const seq = lastSeq + 1;
     const entry = build(seq);
-    await fs6.appendFile(file, JSON.stringify(entry) + "\n", { encoding: "utf-8" });
+    await fs7.appendFile(file, JSON.stringify(entry) + "\n", { encoding: "utf-8" });
     return seq;
   });
 }
@@ -975,7 +1017,7 @@ function cursorPath(stateRoot, project, subscriber) {
 async function readCursor(opts) {
   let buf;
   try {
-    buf = await fs6.readFile(cursorPath(opts.stateRoot, opts.project, opts.subscriber), "utf-8");
+    buf = await fs7.readFile(cursorPath(opts.stateRoot, opts.project, opts.subscriber), "utf-8");
   } catch (e) {
     if (e.code === "ENOENT")
       return null;
@@ -990,7 +1032,7 @@ async function readCursor(opts) {
   }
 }
 async function writeCursor(opts) {
-  await fs6.mkdir(inboxDir(opts.stateRoot), { recursive: true });
+  await fs7.mkdir(inboxDir(opts.stateRoot), { recursive: true });
   const dest = cursorPath(opts.stateRoot, opts.project, opts.subscriber);
   const tmp = `${dest}.${process.pid}.${randomUUID()}.tmp`;
   const data = {
@@ -998,7 +1040,7 @@ async function writeCursor(opts) {
     subscriber: opts.subscriber,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const handle = await fs6.open(tmp, "w");
+  const handle = await fs7.open(tmp, "w");
   try {
     await handle.writeFile(JSON.stringify(data), { encoding: "utf-8" });
     await handle.sync();
@@ -1006,9 +1048,9 @@ async function writeCursor(opts) {
     await handle.close();
   }
   try {
-    await fs6.rename(tmp, dest);
+    await fs7.rename(tmp, dest);
   } catch (e) {
-    await fs6.unlink(tmp).catch(() => {
+    await fs7.unlink(tmp).catch(() => {
     });
     throw e;
   }
@@ -1019,7 +1061,7 @@ async function* readFromCursor(opts) {
   for (const file of files) {
     let buf;
     try {
-      buf = await fs6.readFile(file, "utf-8");
+      buf = await fs7.readFile(file, "utf-8");
     } catch (e) {
       if (e.code === "ENOENT")
         continue;
@@ -1043,7 +1085,7 @@ async function mailboxStats(stateRoot, project) {
   const file = logPath(stateRoot, project);
   let sizeBytes = 0;
   try {
-    sizeBytes = (await fs6.stat(file)).size;
+    sizeBytes = (await fs7.stat(file)).size;
   } catch (e) {
     if (e.code !== "ENOENT")
       throw e;
@@ -1058,7 +1100,7 @@ async function mailboxStats(stateRoot, project) {
 }
 async function oldestEntryAgeMs(file) {
   try {
-    const buf = await fs6.readFile(file, "utf-8");
+    const buf = await fs7.readFile(file, "utf-8");
     const firstLine = buf.split("\n").find((l) => l.trim());
     if (!firstLine)
       return 0;
@@ -1073,7 +1115,7 @@ async function rotateIfNeeded(opts) {
     const file = logPath(opts.stateRoot, opts.project);
     let size = 0;
     try {
-      size = (await fs6.stat(file)).size;
+      size = (await fs7.stat(file)).size;
     } catch (e) {
       if (e.code === "ENOENT")
         return { rotated: false };
@@ -1089,22 +1131,22 @@ async function rotateIfNeeded(opts) {
       const dst = `${file}.${n + 1}`;
       if (n + 1 > opts.keepCount) {
         try {
-          await fs6.unlink(src);
+          await fs7.unlink(src);
         } catch (e) {
           if (e.code !== "ENOENT")
             throw e;
         }
       } else {
         try {
-          await fs6.rename(src, dst);
+          await fs7.rename(src, dst);
         } catch (e) {
           if (e.code !== "ENOENT")
             throw e;
         }
       }
     }
-    await fs6.rename(file, `${file}.1`);
-    await fs6.writeFile(file, "", { encoding: "utf-8" });
+    await fs7.rename(file, `${file}.1`);
+    await fs7.writeFile(file, "", { encoding: "utf-8" });
     return { rotated: true, from: file, to: `${file}.1` };
   });
 }
@@ -2078,10 +2120,10 @@ function distBuiltAt() {
     return 0;
   }
 }
-function gatherLogStats(path14, now, windowMs) {
+function gatherLogStats(path16, now, windowMs) {
   let sizeBytes = 0;
   try {
-    sizeBytes = statSync2(path14).size;
+    sizeBytes = statSync2(path16).size;
   } catch {
     return { errorCount: 0, sizeBytes: 0, windowMs };
   }
@@ -2092,7 +2134,7 @@ function gatherLogStats(path14, now, windowMs) {
   const len = sizeBytes - start;
   let text = "";
   try {
-    const fd = openSync2(path14, "r");
+    const fd = openSync2(path16, "r");
     try {
       const buf = Buffer.alloc(len);
       readSync(fd, buf, 0, len, start);
@@ -2417,8 +2459,8 @@ function startDaemon(ctx, opts, pkgVersion) {
 
 // packages/core/dist/session-freshness.js
 import crypto from "crypto";
-import fs7 from "fs";
-import path6 from "path";
+import fs8 from "fs";
+import path7 from "path";
 
 // packages/core/dist/crew-lifecycle.js
 import { exec as nodeExec } from "child_process";
@@ -2498,19 +2540,30 @@ var REGISTRY = {
         return usage("spawn", "usage: /spawn <project> <task...>");
       return ok("spawn", ["crew", "spawn", project, task]);
     }
+  },
+  mute: {
+    usage: "/mute <project>",
+    build: (a) => a[0] ? ok("mute", ["telegram", "notify", a[0], "off"]) : usage("mute", "usage: /mute <project>")
+  },
+  unmute: {
+    usage: "/unmute <project>",
+    build: (a) => a[0] ? ok("unmute", ["telegram", "notify", a[0], "on"]) : usage("unmute", "usage: /unmute <project>")
   }
 };
 function helpText() {
   const lines = Object.values(REGISTRY).map((e) => `  ${e.usage}`);
   return ["Available commands:", ...lines, "  /help"].join("\n");
 }
+function stripBotMention(token) {
+  return token.split("@")[0];
+}
 function parseCommand(text) {
   const trimmed = text.trim();
   if (!trimmed.startsWith("/")) {
     return { kind: "unknown", message: "unknown command \u2014 send /help" };
   }
   const tokens = trimmed.slice(1).split(/\s+/).filter((t) => t.length > 0);
-  const name = (tokens[0] ?? "").toLowerCase();
+  const name = stripBotMention(tokens[0] ?? "").toLowerCase();
   const args = tokens.slice(1);
   if (name === "help") {
     return { kind: "usage", name: "help", message: helpText() };
@@ -2568,6 +2621,17 @@ ${ev.message}` : "");
 ${ev.question}`;
     case "task.idle":
       return `\u{1F4A4} [${project}] CREW IDLE \xB7 ${ev.id}`;
+    case "task.failed":
+      return `\u274C [${project}] CREW FAILED \xB7 ${ev.id}
+${ev.error}`;
+    case "task.approval.requested":
+      return `\u{1F510} [${project}] APPROVAL NEEDED \xB7 ${ev.id}
+${ev.question}`;
+    case "task.input.requested":
+      return `\u2753 [${project}] INPUT NEEDED \xB7 ${ev.id}
+${ev.question}`;
+    case "task.timeout":
+      return `\u23F1\uFE0F [${project}] CREW TIMEOUT \xB7 ${ev.id}`;
     default:
       return `\u2139\uFE0F [${project}] ${ev.type} \xB7 ${ev.id}`;
   }
@@ -2577,35 +2641,49 @@ function formatInbound(text) {
 }
 
 // packages/core/dist/telegram/state.js
-import fs8 from "fs";
-import path7 from "path";
+import fs9 from "fs";
+import path8 from "path";
 function statePath(stateRoot) {
-  return path7.join(stateRoot, "telegram-state.json");
+  return path8.join(stateRoot, "telegram-state.json");
 }
 function topicKey(project, scope = "project") {
   return `${project}::${scope}`;
 }
 function loadState(stateRoot) {
   try {
-    const raw = fs8.readFileSync(statePath(stateRoot), "utf-8");
+    const raw = fs9.readFileSync(statePath(stateRoot), "utf-8");
     const data = JSON.parse(raw);
-    return {
+    const result = {
       offset: typeof data.offset === "number" ? data.offset : 0,
-      topics: data.topics ?? {}
+      topics: data.topics ?? {},
+      notify: data.notify ?? {}
     };
+    if (typeof data.lastUserId === "number")
+      result.lastUserId = data.lastUserId;
+    return result;
   } catch {
-    return { offset: 0, topics: {} };
+    return { offset: 0, topics: {}, notify: {} };
   }
 }
 function saveState(stateRoot, s) {
-  fs8.mkdirSync(stateRoot, { recursive: true });
-  fs8.writeFileSync(statePath(stateRoot), JSON.stringify(s, null, 2) + "\n");
+  fs9.mkdirSync(stateRoot, { recursive: true });
+  fs9.writeFileSync(statePath(stateRoot), JSON.stringify(s, null, 2) + "\n");
 }
 function setTopic(stateRoot, project, topicId, scope = "project") {
   const s = loadState(stateRoot);
   s.topics[topicKey(project, scope)] = topicId;
   saveState(stateRoot, s);
 }
+function setLastUserId(stateRoot, id) {
+  const s = loadState(stateRoot);
+  s.lastUserId = id;
+  saveState(stateRoot, s);
+}
+function setNotify(stateRoot, project, active) {
+  const s = loadState(stateRoot);
+  s.notify[project] = active;
+  saveState(stateRoot, s);
+}
 function findProjectByThread(stateRoot, threadId) {
   const s = loadState(stateRoot);
   for (const [key, id] of Object.entries(s.topics)) {
@@ -2645,24 +2723,141 @@ function createTelegramClient(opts) {
     getUpdates(offset, timeoutSec = 50) {
       return call("getUpdates", { offset, timeout: timeoutSec });
     },
-    async sendMessage(chatId, threadId, text) {
+    async sendMessage(chatId, threadId, text, replyMarkup) {
       const body = { chat_id: chatId, text };
       if (threadId !== void 0)
         body.message_thread_id = threadId;
+      if (replyMarkup !== void 0)
+        body.reply_markup = replyMarkup;
       await call("sendMessage", body);
     },
+    async answerCallbackQuery(callbackQueryId, text) {
+      const body = { callback_query_id: callbackQueryId };
+      if (text !== void 0)
+        body.text = text;
+      await call("answerCallbackQuery", body);
+    },
+    async editMessageReplyMarkup(chatId, messageId, replyMarkup) {
+      await call("editMessageReplyMarkup", { chat_id: chatId, message_id: messageId, reply_markup: replyMarkup });
+    },
     async createForumTopic(chatId, name) {
       const r = await call("createForumTopic", { chat_id: chatId, name });
       return r.message_thread_id;
+    },
+    async setMyCommands(commands) {
+      await call("setMyCommands", { commands });
     }
   };
 }
 
+// packages/core/dist/telegram/bridge.js
+import os3 from "os";
+import path9 from "path";
+
+// packages/core/dist/telegram/panels.js
+var mark = (on, label) => on ? `\u2022 ${label}` : label;
+var TIERS = ["none", "alert_only", "all"];
+function notifyPanel(s) {
+  return {
+    inline_keyboard: [
+      [{ text: `Captain: ${s.cap ? "ON" : "OFF"}`, callback_data: `n:cap:${s.cap ? "off" : "on"}` }],
+      TIERS.map((t) => ({ text: mark(s.crew === t, `crew:${t}`), callback_data: `n:crew:${t}` })),
+      [{ text: s.active ? "\u{1F515} Mute topic" : "\u{1F514} Unmute", callback_data: `n:active:${s.active ? "off" : "on"}` }]
+    ]
+  };
+}
+function effortPanel(current) {
+  const modes = ["max", "balance", "low"];
+  return {
+    inline_keyboard: [modes.map((m) => ({ text: mark(current === m, m), callback_data: `e:${m}` }))]
+  };
+}
+function projectPicker(action, projects) {
+  return { inline_keyboard: projects.map((p) => [{ text: p, callback_data: `${action}:${p}` }]) };
+}
+var SPAWN_PROMPT_PREFIX = "\u{1F195} Reply with the task for a crew on: ";
+function buildSpawnPrompt(project) {
+  return `${SPAWN_PROMPT_PREFIX}${project}`;
+}
+function parseSpawnPrompt(text) {
+  if (!text || !text.startsWith(SPAWN_PROMPT_PREFIX))
+    return null;
+  const project = text.slice(SPAWN_PROMPT_PREFIX.length).trim();
+  return project.length > 0 ? project : null;
+}
+function spawnPicker(projects) {
+  return { inline_keyboard: projects.map((p) => [{ text: p, callback_data: `sp:${p}` }]) };
+}
+var PICK_ACTIONS = ["cr", "lc", "mu", "um"];
+function parseCallback(data) {
+  const parts = data.split(":");
+  if (parts[0] === "n" && (parts[1] === "cap" || parts[1] === "crew" || parts[1] === "active") && parts[2]) {
+    return { t: "notify", dim: parts[1], val: parts[2] };
+  }
+  if (parts[0] === "e" && parts[1])
+    return { t: "effort", mode: parts[1] };
+  if (PICK_ACTIONS.includes(parts[0]) && parts[1]) {
+    return { t: "pick", action: parts[0], project: parts.slice(1).join(":") };
+  }
+  if (parts[0] === "sp" && parts[1])
+    return { t: "spawn", project: parts.slice(1).join(":") };
+  return null;
+}
+
+// packages/core/dist/telegram/tiers.js
+var DONE_ONLY = /* @__PURE__ */ new Set(["task.done", "task.failed"]);
+var ALERTS = /* @__PURE__ */ new Set([
+  ...DONE_ONLY,
+  "task.blocked",
+  "task.approval.requested",
+  "task.input.requested",
+  "task.timeout"
+]);
+function tierIncludes(tier, eventType) {
+  switch (tier) {
+    case "none":
+      return false;
+    case "done_only":
+      return DONE_ONLY.has(eventType);
+    case "alert_only":
+      return ALERTS.has(eventType);
+    case "all":
+      return true;
+  }
+}
+
 // packages/core/dist/telegram/bridge.js
 var LONG_POLL_SEC = 50;
 var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+var CREW_TIERS = ["all", "alert_only", "done_only", "none"];
+var RECOGNIZED_CHANNEL_COMMANDS = /* @__PURE__ */ new Set(["status", "projects", "crews", "launch", "effort", "spawn"]);
+function parseNotifyPref(text) {
+  const parts = text.trim().split(/\s+/);
+  if (stripBotMention(parts[0] ?? "").toLowerCase() !== "/notify")
+    return null;
+  const dimension = parts[1]?.toLowerCase();
+  if ((dimension === "crew" || dimension === "cap") && parts[2])
+    return { dimension, value: parts[2].toLowerCase() };
+  return null;
+}
+function isBareSpawn(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("/"))
+    return false;
+  const tokens = trimmed.slice(1).split(/\s+/).filter((t) => t.length > 0);
+  return stripBotMention(tokens[0] ?? "").toLowerCase() === "spawn" && tokens.length === 1;
+}
+function notifyToggle(text) {
+  const first = stripBotMention(text.trim().split(/\s+/)[0] ?? "").toLowerCase();
+  if (first === "/unmute")
+    return true;
+  if (first === "/mute")
+    return false;
+  return null;
+}
 function createTelegramBridge(opts) {
   const { cfg, stateRoot, client, appendCaptainMessage: appendCaptainMessage2, log, ensureCaptainAlive, runCommand, sendReply } = opts;
+  const configRoot = opts.configRoot ?? path9.join(os3.homedir(), ".config", "squadrant");
   const pollMs = cfg.pollMs ?? 1e3;
   let running = false;
   function persistOffset(next) {
@@ -2671,6 +2866,13 @@ function createTelegramBridge(opts) {
     saveState(stateRoot, s);
   }
   async function deliverOutbound(project, ev) {
+    const resolved = resolveNotify(cfg.notify, loadProjectOverride(project, configRoot));
+    const live = loadState(stateRoot).notify[project];
+    const active = live ?? resolved.active;
+    if (!active)
+      return;
+    if (!tierIncludes(resolved.crew, ev.type))
+      return;
     let threadId = loadState(stateRoot).topics[topicKey(project)];
     if (threadId === void 0) {
       threadId = await client.createForumTopic(cfg.supergroupId, topicName(project));
@@ -2678,41 +2880,225 @@ function createTelegramBridge(opts) {
     }
     await client.sendMessage(cfg.supergroupId, threadId, formatLifecycle(project, ev));
   }
-  async function reply(threadId, text) {
+  function resolveLiveNotify(project) {
+    const resolved = resolveNotify(cfg.notify, loadProjectOverride(project, configRoot));
+    const live = loadState(stateRoot).notify[project];
+    return { ...resolved, active: live ?? resolved.active };
+  }
+  async function editMarkup(chatId, messageId, markup) {
+    try {
+      await client.editMessageReplyMarkup(chatId, messageId, markup);
+    } catch (e) {
+      const msg = e.message;
+      if (!/not modified/i.test(msg))
+        throw e;
+    }
+  }
+  async function handleCallback(cq) {
+    try {
+      if (!cq.data || !cq.message) {
+        await client.answerCallbackQuery(cq.id);
+        return;
+      }
+      if (!isControlEnabled(cfg) || !isAuthorized(cq.from?.id, cfg)) {
+        await client.answerCallbackQuery(cq.id, "\u26D4 not authorized");
+        return;
+      }
+      const action = parseCallback(cq.data);
+      if (!action) {
+        await client.answerCallbackQuery(cq.id);
+        return;
+      }
+      const chatId = cq.message.chat.id;
+      const messageId = cq.message.message_id;
+      if (action.t === "notify") {
+        const resolved = findProjectByThread(stateRoot, cq.message.message_thread_id ?? -1);
+        if (!resolved) {
+          await client.answerCallbackQuery(cq.id, "no project for this topic");
+          return;
+        }
+        const project2 = resolved.project;
+        if (action.dim === "active") {
+          setNotify(stateRoot, project2, action.val === "on");
+        } else if (action.dim === "cap") {
+          saveProjectOverride(project2, { telegram: { notify: { cap: action.val === "on" } } }, configRoot);
+        } else {
+          saveProjectOverride(project2, { telegram: { notify: { crew: action.val } } }, configRoot);
+        }
+        await client.answerCallbackQuery(cq.id, `\u2705 ${action.dim} = ${action.val}`);
+        await editMarkup(chatId, messageId, notifyPanel(resolveLiveNotify(project2)));
+        return;
+      }
+      if (action.t === "effort") {
+        if (runCommand)
+          await runCommand(["effort", action.mode]);
+        await client.answerCallbackQuery(cq.id, `\u2705 effort = ${action.mode}`);
+        await editMarkup(chatId, messageId, effortPanel(action.mode));
+        return;
+      }
+      if (action.t === "spawn") {
+        await reply(cq.message.message_thread_id, buildSpawnPrompt(action.project), { force_reply: true, selective: true });
+        await client.answerCallbackQuery(cq.id);
+        return;
+      }
+      const { action: act, project } = action;
+      if (act === "cr") {
+        const out = runCommand ? await runCommand(["crew", "list", project]) : "(command runner unavailable)";
+        await client.answerCallbackQuery(cq.id);
+        await reply(void 0, out);
+      } else if (act === "lc") {
+        if (runCommand)
+          await runCommand(["launch", project]);
+        await client.answerCallbackQuery(cq.id, `launching ${project}`);
+      } else if (act === "mu") {
+        setNotify(stateRoot, project, false);
+        await client.answerCallbackQuery(cq.id, `\u{1F515} muted ${project}`);
+      } else {
+        setNotify(stateRoot, project, true);
+        await client.answerCallbackQuery(cq.id, `\u{1F514} unmuted ${project}`);
+      }
+    } catch (e) {
+      log(`telegram callback failed data=${cq.data}: ${e.message}`);
+      try {
+        await client.answerCallbackQuery(cq.id, "\u26A0\uFE0F failed");
+      } catch {
+      }
+    }
+  }
+  async function reply(threadId, text, replyMarkup) {
     if (!sendReply)
       return;
     try {
-      await sendReply(threadId, text);
+      if (replyMarkup !== void 0)
+        await sendReply(threadId, text, replyMarkup);
+      else
+        await sendReply(threadId, text);
     } catch (e) {
       log(`telegram reply failed: ${e.message}`);
     }
   }
-  async function handleGeneral(text, fromId) {
-    if (!text.startsWith("/")) {
-      await reply(void 0, "Send /help for commands.");
+  function currentEffort() {
+    try {
+      return loadConfig(path9.join(configRoot, "config.json")).defaults.effort ?? "balance";
+    } catch {
+      return "balance";
+    }
+  }
+  function projectNames() {
+    try {
+      return Object.keys(loadConfig(path9.join(configRoot, "config.json")).projects);
+    } catch {
+      return [];
+    }
+  }
+  async function replySpawnPicker(threadId) {
+    const projects = projectNames();
+    if (projects.length === 0) {
+      await reply(threadId, "no projects registered");
       return;
     }
+    await reply(threadId, "Pick a project to spawn a crew on:", spawnPicker(projects));
+  }
+  async function runChannelCommand(text, fromId, threadId) {
     if (!isControlEnabled(cfg) || !isAuthorized(fromId, cfg)) {
-      await reply(void 0, "\u26D4 not authorized");
+      await reply(threadId, "\u26D4 not authorized");
+      return;
+    }
+    const tokens = text.trim().slice(1).split(/\s+/).filter((t) => t.length > 0);
+    const name = stripBotMention(tokens[0] ?? "").toLowerCase();
+    const noArg = tokens.length === 1;
+    if (noArg && name === "effort") {
+      await reply(threadId, "Effort mode:", effortPanel(currentEffort()));
+      return;
+    }
+    if (noArg && name === "spawn") {
+      await replySpawnPicker(threadId);
+      return;
+    }
+    const PICKERS = { crews: "cr", launch: "lc", mute: "mu", unmute: "um" };
+    if (noArg && name in PICKERS) {
+      const projects = projectNames();
+      if (projects.length === 0) {
+        await reply(threadId, "no projects registered");
+        return;
+      }
+      await reply(threadId, `Pick a project:`, projectPicker(PICKERS[name], projects));
       return;
     }
     const parsed = parseCommand(text);
     if (parsed.kind !== "ok") {
-      await reply(void 0, parsed.message);
+      await reply(threadId, parsed.message);
       return;
     }
     try {
       const out = runCommand ? await runCommand(parsed.argv) : "(command runner unavailable)";
-      await reply(void 0, out);
+      await reply(threadId, out);
     } catch (e) {
-      await reply(void 0, `\u26A0\uFE0F command failed: ${e.message}`);
+      await reply(threadId, `\u26A0\uFE0F command failed: ${e.message}`);
       log(`telegram command failed argv=${JSON.stringify(parsed.argv)}: ${e.message}`);
     }
   }
+  async function handleGeneral(text, fromId) {
+    if (!text.startsWith("/")) {
+      await reply(void 0, "Send /help for commands.");
+      return;
+    }
+    await runChannelCommand(text, fromId, void 0);
+  }
   async function handleProjectTopic(text, threadId, fromId) {
     const resolved = findProjectByThread(stateRoot, threadId);
     if (!resolved)
       return;
+    if (isBareSpawn(text)) {
+      if (!isControlEnabled(cfg) || !isAuthorized(fromId, cfg)) {
+        await reply(threadId, "\u26D4 not authorized");
+        return;
+      }
+      await replySpawnPicker(threadId);
+      return;
+    }
+    const toggle = notifyToggle(text);
+    if (toggle !== null) {
+      if (!isControlEnabled(cfg) || !isAuthorized(fromId, cfg)) {
+        await reply(threadId, "\u26D4 not authorized");
+        return;
+      }
+      setNotify(stateRoot, resolved.project, toggle);
+      await reply(threadId, toggle ? `\u{1F514} ${resolved.project} notifications ON` : `\u{1F515} ${resolved.project} notifications OFF`);
+      return;
+    }
+    if (stripBotMention(text.trim().split(/\s+/)[0] ?? "").toLowerCase() === "/notify") {
+      if (!isControlEnabled(cfg) || !isAuthorized(fromId, cfg)) {
+        await reply(threadId, "\u26D4 not authorized");
+        return;
+      }
+      const pref = parseNotifyPref(text);
+      if (pref === null) {
+        await reply(threadId, `\u{1F514} ${resolved.project} notifications`, notifyPanel(resolveLiveNotify(resolved.project)));
+        return;
+      }
+      if (pref.dimension === "crew") {
+        if (!CREW_TIERS.includes(pref.value)) {
+          await reply(threadId, "crew must be all|alert_only|done_only|none");
+          return;
+        }
+        saveProjectOverride(resolved.project, { telegram: { notify: { crew: pref.value } } }, configRoot);
+      } else {
+        if (pref.value !== "on" && pref.value !== "off") {
+          await reply(threadId, "cap must be on|off");
+          return;
+        }
+        saveProjectOverride(resolved.project, { telegram: { notify: { cap: pref.value === "on" } } }, configRoot);
+      }
+      await reply(threadId, `\u2705 ${pref.dimension} = ${pref.value}`);
+      return;
+    }
+    const firstTok = stripBotMention(text.trim().split(/\s+/)[0] ?? "").toLowerCase();
+    if (firstTok.startsWith("/") && RECOGNIZED_CHANNEL_COMMANDS.has(firstTok.slice(1))) {
+      await runChannelCommand(text, fromId, threadId);
+      return;
+    }
+    setNotify(stateRoot, resolved.project, true);
     if (ensureCaptainAlive && isControlEnabled(cfg) && isAuthorized(fromId, cfg)) {
       try {
         const r = await ensureCaptainAlive(resolved.project);
@@ -2725,11 +3111,35 @@ function createTelegramBridge(opts) {
     await appendCaptainMessage2({ stateRoot, project: resolved.project, text: formatInbound(text), source: "telegram" });
   }
   async function handleUpdate(u) {
+    if (u.callback_query) {
+      await handleCallback(u.callback_query);
+      return;
+    }
     const m = u.message;
     if (!m || m.text === void 0)
       return;
     if (!cfg.chats.includes(m.chat.id))
       return;
+    if (m.from?.id !== void 0 && loadState(stateRoot).lastUserId !== m.from.id) {
+      setLastUserId(stateRoot, m.from.id);
+    }
+    const spawnProject = parseSpawnPrompt(m.reply_to_message?.text);
+    if (spawnProject) {
+      const threadId = m.message_thread_id;
+      if (!isControlEnabled(cfg) || !isAuthorized(m.from?.id, cfg)) {
+        await reply(threadId, "\u26D4 not authorized");
+        return;
+      }
+      const task = m.text.trim();
+      if (!task) {
+        await reply(threadId, "spawn cancelled \u2014 empty task");
+        return;
+      }
+      if (runCommand)
+        await runCommand(["crew", "spawn", spawnProject, task]);
+      await reply(threadId, `\u{1F195} spawning a crew on ${spawnProject}\u2026`);
+      return;
+    }
     if (m.message_thread_id === void 0) {
       await handleGeneral(m.text, m.from?.id);
       return;
@@ -2771,7 +3181,7 @@ function createTelegramBridge(opts) {
 }
 
 // packages/core/dist/telegram/setup.js
-import fs9 from "fs";
+import fs10 from "fs";
 
 // packages/cli/src/control/telegram-control.ts
 import { execFile } from "child_process";
@@ -2834,28 +3244,28 @@ import { execSync as execSync4 } from "child_process";
 import { execSync as execSync5 } from "child_process";
 
 // packages/agents/dist/drivers/launch-cmd.js
-import fs10 from "fs";
-import path8 from "path";
+import fs11 from "fs";
+import path10 from "path";
 
 // packages/agents/dist/projection/cursor.js
 import { mkdir, readFile, writeFile } from "fs/promises";
-import path9 from "path";
-import os2 from "os";
+import path11 from "path";
+import os4 from "os";
 
 // packages/agents/dist/projection/codex.js
 import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import path10 from "path";
-import os3 from "os";
+import path12 from "path";
+import os5 from "os";
 
 // packages/agents/dist/projection/gemini.js
 import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import path11 from "path";
-import os4 from "os";
+import path13 from "path";
+import os6 from "os";
 
 // packages/agents/dist/projection/opencode.js
 import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import path12 from "path";
-import os5 from "os";
+import path14 from "path";
+import os7 from "os";
 
 // packages/agents/dist/codex/app-server-client.js
 import { EventEmitter } from "events";
@@ -4071,9 +4481,9 @@ function createCmuxDriver() {
 import { execFileSync as execFileSync5, execSync as execSync7 } from "child_process";
 
 // packages/workspaces/dist/workspaces/obsidian.js
-import fs11 from "fs/promises";
+import fs12 from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
-import path13 from "path";
+import path15 from "path";
 
 // packages/workspaces/dist/cmux/events-bridge.js
 import { spawn as nodeSpawn2 } from "child_process";
@@ -4290,10 +4700,11 @@ function buildTelegramBridge(cfg, stateRoot, log) {
     launch: createLaunch(CLI_BIN)
   });
   const runCommand = createRunCommand(CLI_BIN);
-  const sendReply = (threadId, text) => client.sendMessage(cfg.supergroupId, threadId, text);
+  const sendReply = (threadId, text, replyMarkup) => client.sendMessage(cfg.supergroupId, threadId, text, replyMarkup);
   return createTelegramBridge({
     cfg,
     stateRoot,
+    configRoot: dirname5(stateRoot),
     client,
     appendCaptainMessage,
     log,