squadrant 0.9.2 → 0.11.0

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 path13 = opts.path ?? defaultCmuxConfigPath();
-  if (!existsSync(path13)) {
-    mkdirSync(dirname(path13), { recursive: true });
-    writeFileSync(path13, MINIMAL_TEMPLATE);
-    return { path: path13, 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(path13, "utf-8");
+  const text = readFileSync(path16, "utf-8");
   const current = parse(text)?.automation?.socketControlMode;
   if (current === AUTOMATION_MODE) {
-    return { path: path13, 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(path13, applyEdits(text, edits));
-  return { path: path13, changed: true, alreadySet: false };
+  writeFileSync(path16, applyEdits(text, edits));
+  return { path: path16, changed: true, alreadySet: false };
 }
 
 // packages/shared/dist/lib/cmux-probe.js
@@ -322,15 +364,15 @@ function sleep(ms) {
 function defaultStatePath() {
   return join4(homedir3(), ".config", "squadrant", "state", "cmux-autoconfig.json");
 }
-function readState(path13) {
+function readState(path16) {
   try {
-    return JSON.parse(readFileSync4(path13, "utf-8"));
+    return JSON.parse(readFileSync4(path16, "utf-8"));
   } catch {
     return {};
   }
 }
 async function ensureCmuxAutoConfig(opts = {}) {
-  const statePath = opts.statePath ?? defaultStatePath();
+  const statePath2 = opts.statePath ?? defaultStatePath();
   const ensureConfig = opts.ensureConfig ?? ensureSocketAutomation;
   const probe = opts.probe ?? probeCmuxDaemonDirect;
   const cfg = ensureConfig({ path: opts.configPath });
@@ -338,15 +380,15 @@ async function ensureCmuxAutoConfig(opts = {}) {
   const needsRestart = verdict === "denied";
   let promptedThisRun = false;
   if (needsRestart) {
-    const already = readState(statePath).promptedRestart === true;
+    const already = readState(statePath2).promptedRestart === true;
     if (!already) {
-      mkdirSync2(dirname2(statePath), { recursive: true });
-      writeFileSync3(statePath, JSON.stringify({ promptedRestart: true }));
+      mkdirSync2(dirname2(statePath2), { recursive: true });
+      writeFileSync3(statePath2, JSON.stringify({ promptedRestart: true }));
       promptedThisRun = true;
     }
   } else if (verdict === "reachable") {
-    if (existsSync4(statePath))
-      rmSync2(statePath, { force: true });
+    if (existsSync4(statePath2))
+      rmSync2(statePath2, { force: true });
   }
   return {
     configPath: cfg.path,
@@ -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");
@@ -936,34 +978,46 @@ function withProjectLock(project, fn) {
   projectLocks.set(project, next.catch(() => void 0));
   return next;
 }
-async function appendToMailbox(opts) {
-  return withProjectLock(opts.project, async () => {
-    const dir = inboxDir(opts.stateRoot);
-    await fs6.mkdir(dir, { recursive: true });
-    const file = logPath(opts.stateRoot, opts.project);
-    const lastSeq = await readMaxSeq(opts.stateRoot, opts.project);
+function appendEntry(stateRoot, project, build) {
+  return withProjectLock(project, async () => {
+    const dir = inboxDir(stateRoot);
+    await fs7.mkdir(dir, { recursive: true });
+    const file = logPath(stateRoot, project);
+    const lastSeq = await readMaxSeq(stateRoot, project);
     const seq = lastSeq + 1;
-    const entry = {
-      seq,
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      taskId: opts.taskRecord.id,
-      ...opts.taskRecord.name !== void 0 ? { name: opts.taskRecord.name } : {},
-      kind: opts.event.type,
-      provider: opts.taskRecord.provider,
-      payload: extractPayload(opts.event),
-      message: opts.message ?? null
-    };
-    await fs6.appendFile(file, JSON.stringify(entry) + "\n", { encoding: "utf-8" });
+    const entry = build(seq);
+    await fs7.appendFile(file, JSON.stringify(entry) + "\n", { encoding: "utf-8" });
     return seq;
   });
 }
+async function appendToMailbox(opts) {
+  return appendEntry(opts.stateRoot, opts.project, (seq) => ({
+    seq,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    taskId: opts.taskRecord.id,
+    ...opts.taskRecord.name !== void 0 ? { name: opts.taskRecord.name } : {},
+    kind: opts.event.type,
+    provider: opts.taskRecord.provider,
+    payload: extractPayload(opts.event),
+    message: opts.message ?? null
+  }));
+}
+async function appendCaptainMessage(opts) {
+  await appendEntry(opts.stateRoot, opts.project, (seq) => ({
+    seq,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    kind: "captain.message",
+    payload: { source: opts.source },
+    message: opts.text
+  }));
+}
 function cursorPath(stateRoot, project, subscriber) {
   return join5(inboxDir(stateRoot), `${project}.${subscriber}.cursor`);
 }
 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;
@@ -978,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 = {
@@ -986,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();
@@ -994,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;
   }
@@ -1007,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;
@@ -1031,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;
@@ -1046,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;
@@ -1061,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 };
@@ -1077,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` };
   });
 }
@@ -1241,6 +1295,36 @@ function isDaemonSocketLive(sockPath, timeoutMs = 500) {
     });
   });
 }
+function sendRequest(sockPath, msg, timeoutMs = 5e3) {
+  return new Promise((resolve2, reject) => {
+    const conn = createConnection(sockPath);
+    const dec = createDecoder();
+    const timer = setTimeout(() => {
+      conn.destroy();
+      reject(new Error("control plane unavailable: request timed out"));
+    }, timeoutMs);
+    conn.setEncoding("utf-8");
+    conn.on("connect", () => conn.write(encodeMsg({ ...msg, _v: PROTOCOL_VERSION })));
+    conn.on("data", (chunk) => {
+      for (const m of dec.push(chunk)) {
+        clearTimeout(timer);
+        conn.destroy();
+        if (m._v !== void 0 && m._v !== PROTOCOL_VERSION) {
+          reject(new Error(`squadrantd protocol v${m._v}, this client expects v${PROTOCOL_VERSION} \u2014 upgrade squadrantd or this CLI`));
+        } else if (m.ok) {
+          resolve2(m.reply);
+        } else {
+          reject(new Error(m.error));
+        }
+        return;
+      }
+    });
+    conn.on("error", () => {
+      clearTimeout(timer);
+      reject(new Error("control plane unavailable: cannot reach squadrantd socket"));
+    });
+  });
+}
 function encodeFrame(f) {
   return JSON.stringify(f) + "\n";
 }
@@ -1508,6 +1592,7 @@ function buildContext(opts) {
     codexDriver: null,
     opencodeBridge: null,
     cmuxEventsBridge: null,
+    telegramBridge: void 0,
     broadcast: () => {
     },
     schedulePromotion: () => {
@@ -2035,10 +2120,10 @@ function distBuiltAt() {
     return 0;
   }
 }
-function gatherLogStats(path13, now, windowMs) {
+function gatherLogStats(path16, now, windowMs) {
   let sizeBytes = 0;
   try {
-    sizeBytes = statSync2(path13).size;
+    sizeBytes = statSync2(path16).size;
   } catch {
     return { errorCount: 0, sizeBytes: 0, windowMs };
   }
@@ -2049,7 +2134,7 @@ function gatherLogStats(path13, now, windowMs) {
   const len = sizeBytes - start;
   let text = "";
   try {
-    const fd = openSync2(path13, "r");
+    const fd = openSync2(path16, "r");
     try {
       const buf = Buffer.alloc(len);
       readSync(fd, buf, 0, len, start);
@@ -2126,7 +2211,11 @@ function startDaemon(ctx, opts, pkgVersion) {
   const { daemonCmux } = ctx;
   const probes = createProbes(ctx);
   const { defaultNotify, deliveryTick: initialDeliveryTick } = createDelivery(ctx, daemonCmux);
-  const notify = opts.notify ?? defaultNotify;
+  const baseNotify = opts.notify ?? defaultNotify;
+  const notify = ctx.telegramBridge ? async (args) => {
+    await baseNotify(args);
+    ctx.telegramBridge.pushLifecycle(args.project, args.event);
+  } : baseNotify;
   const surfaceProbe = buildSurfaceProbe(ctx, probes, daemonCmux);
   const ingest = (project) => (e) => void ctx.d.handle({ kind: "event", project, event: e });
   const d = createDaemon({
@@ -2252,6 +2341,13 @@ function startDaemon(ctx, opts, pkgVersion) {
         log(`cmux events bridge start failed: ${e.message}`);
       }
     }
+    if (ctx.telegramBridge) {
+      try {
+        ctx.telegramBridge.start();
+      } catch (e) {
+        log(`telegram bridge start failed: ${e.message}`);
+      }
+    }
     const autoConfigSafe = !!opts.runCmuxAutoConfig || !process.env.VITEST;
     if (autoConfigSafe) {
       try {
@@ -2341,6 +2437,10 @@ function startDaemon(ctx, opts, pkgVersion) {
         ctx.cmuxEventsBridge.stop();
       } catch {
       }
+      try {
+        ctx.telegramBridge?.stop();
+      } catch {
+      }
       try {
         ctx.codexDriver.stop?.();
       } catch {
@@ -2359,12 +2459,769 @@ 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";
 
+// packages/core/dist/telegram/auth.js
+function isControlEnabled(cfg) {
+  return cfg.remoteControl === true;
+}
+function isAuthorized(fromId, cfg) {
+  if (fromId === void 0)
+    return false;
+  return Array.isArray(cfg.users) && cfg.users.includes(fromId);
+}
+
+// packages/core/dist/telegram/commands.js
+var WRITABLE_CONFIG_KEYS = ["defaults.effort"];
+var EFFORT_MODES = /* @__PURE__ */ new Set(["max", "balance", "low"]);
+function ok(name, argv) {
+  return { kind: "ok", name, argv };
+}
+function usage(name, message) {
+  return { kind: "usage", name, message };
+}
+var REGISTRY = {
+  status: { usage: "/status", build: () => ok("status", ["status"]) },
+  projects: { usage: "/projects", build: () => ok("projects", ["projects", "list"]) },
+  crews: {
+    usage: "/crews <project>",
+    build: (a) => a[0] ? ok("crews", ["crew", "list", a[0]]) : usage("crews", "usage: /crews <project>")
+  },
+  launch: {
+    usage: "/launch <project>",
+    build: (a) => a[0] ? ok("launch", ["launch", a[0]]) : usage("launch", "usage: /launch <project>")
+  },
+  effort: {
+    usage: "/effort [max|balance|low]",
+    build: (a) => {
+      if (a.length === 0)
+        return ok("effort", ["effort"]);
+      if (!EFFORT_MODES.has(a[0]))
+        return usage("effort", "usage: /effort [max|balance|low]");
+      return ok("effort", ["effort", a[0]]);
+    }
+  },
+  config: {
+    usage: "/config get <key> | /config set <key> <value>",
+    build: (a) => {
+      const sub = a[0];
+      if (sub === "get") {
+        const key = a[1];
+        if (!key)
+          return usage("config", "usage: /config get <key>");
+        return ok("config", ["config", "get", key]);
+      }
+      if (sub === "set") {
+        const key = a[1];
+        const value = a.slice(2).join(" ");
+        if (!key || value === "")
+          return usage("config", "usage: /config set <key> <value>");
+        if (!WRITABLE_CONFIG_KEYS.includes(key)) {
+          return {
+            kind: "denied",
+            message: `\u26D4 '${key}' is not writable over Telegram. Allowed: ${WRITABLE_CONFIG_KEYS.join(", ")}`
+          };
+        }
+        return ok("config", ["config", "set", key, value]);
+      }
+      return usage("config", "usage: /config get <key> | /config set <key> <value>");
+    }
+  },
+  spawn: {
+    usage: "/spawn <project> <task...>",
+    build: (a) => {
+      const project = a[0];
+      const task = a.slice(1).join(" ");
+      if (!project || task === "")
+        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 = stripBotMention(tokens[0] ?? "").toLowerCase();
+  const args = tokens.slice(1);
+  if (name === "help") {
+    return { kind: "usage", name: "help", message: helpText() };
+  }
+  const entry = REGISTRY[name];
+  if (!entry) {
+    return { kind: "unknown", message: `unknown command '/${name}' \u2014 send /help` };
+  }
+  return entry.build(args);
+}
+
+// packages/core/dist/telegram/ensure-captain.js
+var DEFAULT_WARMUP_TIMEOUT_MS = 12e4;
+var DEFAULT_POLL_MS = 1e3;
+var defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function createEnsureCaptainAlive(deps) {
+  const warmupTimeoutMs = deps.warmupTimeoutMs ?? DEFAULT_WARMUP_TIMEOUT_MS;
+  const pollMs = deps.pollMs ?? DEFAULT_POLL_MS;
+  const sleep3 = deps.sleep ?? defaultSleep;
+  const now = deps.now ?? (() => Date.now());
+  const inFlight = /* @__PURE__ */ new Map();
+  async function run(project) {
+    if (await deps.isAlive(project))
+      return "alive";
+    await deps.launch(project);
+    const deadline = now() + warmupTimeoutMs;
+    while (now() < deadline) {
+      if (await deps.isAlive(project))
+        return "launched";
+      await sleep3(pollMs);
+    }
+    return "timeout";
+  }
+  return function ensure(project) {
+    const existing = inFlight.get(project);
+    if (existing)
+      return existing;
+    const p = run(project).finally(() => inFlight.delete(project));
+    inFlight.set(project, p);
+    return p;
+  };
+}
+
+// packages/core/dist/telegram/format.js
+function topicName(project) {
+  return project;
+}
+function formatLifecycle(project, ev) {
+  switch (ev.type) {
+    case "task.done":
+      return `\u2705 [${project}] CREW DONE \xB7 ${ev.id}` + (ev.message ? `
+${ev.message}` : "");
+    case "task.blocked":
+      return `\u{1F6A7} [${project}] CREW BLOCKED \xB7 ${ev.id}
+${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}`;
+  }
+}
+function formatInbound(text) {
+  return `\u{1F4E9} [from Telegram] ${text}`;
+}
+
+// packages/core/dist/telegram/state.js
+import fs9 from "fs";
+import path8 from "path";
+function statePath(stateRoot) {
+  return path8.join(stateRoot, "telegram-state.json");
+}
+function topicKey(project, scope = "project") {
+  return `${project}::${scope}`;
+}
+function loadState(stateRoot) {
+  try {
+    const raw = fs9.readFileSync(statePath(stateRoot), "utf-8");
+    const data = JSON.parse(raw);
+    const result = {
+      offset: typeof data.offset === "number" ? data.offset : 0,
+      topics: data.topics ?? {},
+      notify: data.notify ?? {}
+    };
+    if (typeof data.lastUserId === "number")
+      result.lastUserId = data.lastUserId;
+    return result;
+  } catch {
+    return { offset: 0, topics: {}, notify: {} };
+  }
+}
+function saveState(stateRoot, s) {
+  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)) {
+    if (id !== threadId)
+      continue;
+    const sep2 = key.indexOf("::");
+    if (sep2 === -1)
+      continue;
+    return { project: key.slice(0, sep2), scope: key.slice(sep2 + 2) };
+  }
+  return null;
+}
+
+// packages/core/dist/telegram/client.js
+function createTelegramClient(opts) {
+  const fetchImpl = opts.fetch ?? fetch;
+  const base = `https://api.telegram.org/bot${opts.token}`;
+  async function call(method, body) {
+    const res = await fetchImpl(`${base}/${method}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    const json = await res.json();
+    if (!res.ok || !json.ok) {
+      const code = json.error_code ?? res.status;
+      const desc = json.description ?? "unknown error";
+      throw new Error(`telegram ${method} failed (${code}): ${desc}`);
+    }
+    return json.result;
+  }
+  return {
+    async getMe() {
+      const r = await call("getMe", {});
+      return { id: r.id, username: r.username };
+    },
+    getUpdates(offset, timeoutSec = 50) {
+      return call("getUpdates", { offset, timeout: timeoutSec });
+    },
+    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"];
+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) {
+    const s = loadState(stateRoot);
+    s.offset = next;
+    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));
+      setTopic(stateRoot, project, threadId);
+    }
+    await client.sendMessage(cfg.supergroupId, threadId, formatLifecycle(project, ev));
+  }
+  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 {
+      if (replyMarkup !== void 0)
+        await sendReply(threadId, text, replyMarkup);
+      else
+        await sendReply(threadId, text);
+    } catch (e) {
+      log(`telegram reply failed: ${e.message}`);
+    }
+  }
+  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 handleGeneral(text, fromId) {
+    if (!text.startsWith("/")) {
+      await reply(void 0, "Send /help for commands.");
+      return;
+    }
+    if (!isControlEnabled(cfg) || !isAuthorized(fromId, cfg)) {
+      await reply(void 0, "\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(void 0, "Effort mode:", effortPanel(currentEffort()));
+      return;
+    }
+    if (noArg && name === "spawn") {
+      await replySpawnPicker(void 0);
+      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(void 0, "no projects registered");
+        return;
+      }
+      await reply(void 0, `Pick a project:`, projectPicker(PICKERS[name], projects));
+      return;
+    }
+    const parsed = parseCommand(text);
+    if (parsed.kind !== "ok") {
+      await reply(void 0, parsed.message);
+      return;
+    }
+    try {
+      const out = runCommand ? await runCommand(parsed.argv) : "(command runner unavailable)";
+      await reply(void 0, out);
+    } catch (e) {
+      await reply(void 0, `\u26A0\uFE0F command failed: ${e.message}`);
+      log(`telegram command failed argv=${JSON.stringify(parsed.argv)}: ${e.message}`);
+    }
+  }
+  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;
+    }
+    setNotify(stateRoot, resolved.project, true);
+    if (ensureCaptainAlive && isControlEnabled(cfg) && isAuthorized(fromId, cfg)) {
+      try {
+        const r = await ensureCaptainAlive(resolved.project);
+        if (r === "timeout")
+          await reply(threadId, "\u26A0\uFE0F captain didn't warm up; message queued.");
+      } catch (e) {
+        log(`telegram auto-launch failed project=${resolved.project}: ${e.message}`);
+      }
+    }
+    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;
+    }
+    await handleProjectTopic(m.text, m.message_thread_id, m.from?.id);
+  }
+  async function pollLoop() {
+    while (running) {
+      try {
+        const offset = loadState(stateRoot).offset;
+        const updates = await client.getUpdates(offset, LONG_POLL_SEC);
+        for (const u of updates) {
+          await handleUpdate(u);
+          persistOffset(u.update_id + 1);
+        }
+      } catch (e) {
+        log(`telegram inbound poll failed: ${e.message}`);
+      }
+      if (running)
+        await sleep2(pollMs);
+    }
+  }
+  return {
+    start() {
+      if (running)
+        return;
+      running = true;
+      void pollLoop();
+    },
+    stop() {
+      running = false;
+    },
+    pushLifecycle(project, ev) {
+      void deliverOutbound(project, ev).catch((e) => {
+        log(`telegram outbound failed project=${project}: ${e.message}`);
+      });
+    }
+  };
+}
+
+// packages/core/dist/telegram/setup.js
+import fs10 from "fs";
+
+// packages/cli/src/control/telegram-control.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var pExecFile = promisify(execFile);
+var MAX_OUTPUT = 3500;
+function capOutput(stdout, stderr, max = MAX_OUTPUT) {
+  const out = stdout.trim();
+  const err = stderr.trim();
+  let combined = out;
+  if (err) combined = combined ? `${combined}
+[stderr] ${err}` : `[stderr] ${err}`;
+  if (!combined) combined = "(no output)";
+  if (combined.length > max) combined = combined.slice(0, max) + "\n\u2026[truncated]";
+  return combined;
+}
+var COMMAND_TIMEOUT_MS = 6e4;
+function createRunCommand(cliBin) {
+  return async (argv) => {
+    try {
+      const { stdout, stderr } = await pExecFile(
+        process.execPath,
+        [cliBin, ...argv],
+        { timeout: COMMAND_TIMEOUT_MS, maxBuffer: 4 * 1024 * 1024 }
+      );
+      return capOutput(stdout ?? "", stderr ?? "");
+    } catch (e) {
+      const err = e;
+      return capOutput(err.stdout ?? "", err.stderr ?? err.message ?? "command failed");
+    }
+  };
+}
+function createIsCaptainAlive(sock) {
+  return async (project) => {
+    try {
+      const health = await sendRequest(sock, { kind: "health", project }, 5e3);
+      const captain = health?.find((h) => h.kind === "captain" && h.project === project);
+      return captain != null && captain.state !== "gone" && captain.state !== "unknown";
+    } catch {
+      return false;
+    }
+  };
+}
+function createLaunch(cliBin) {
+  return async (project) => {
+    await pExecFile(process.execPath, [cliBin, "launch", project], { timeout: 3e4 });
+  };
+}
+
 // packages/agents/dist/drivers/claude.js
 import { execSync as execSync2 } from "child_process";
 
@@ -2378,28 +3235,28 @@ import { execSync as execSync4 } from "child_process";
 import { execSync as execSync5 } from "child_process";
 
 // packages/agents/dist/drivers/launch-cmd.js
-import fs8 from "fs";
-import path7 from "path";
+import fs11 from "fs";
+import path10 from "path";
 
 // packages/agents/dist/projection/cursor.js
 import { mkdir, readFile, writeFile } from "fs/promises";
-import path8 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 path9 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 path10 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 path11 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";
@@ -2979,7 +3836,7 @@ var OpencodeSseBridge = class {
   }
   async run(taskId, port, ac) {
     const fetchImpl = this.deps.fetchImpl ?? fetch;
-    const sleep2 = this.deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const sleep3 = this.deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
     const reconnectMs = this.deps.reconnectMs ?? 500;
     const maxBoot = this.deps.maxBootAttempts ?? 60;
     const url = `http://127.0.0.1:${port}/event`;
@@ -3007,7 +3864,7 @@ var OpencodeSseBridge = class {
             return;
           }
         }
-        await sleep2(reconnectMs);
+        await sleep3(reconnectMs);
       }
     }
     this.controllers.delete(taskId);
@@ -3243,7 +4100,7 @@ function runHeadless(opts) {
 }
 
 // packages/workspaces/dist/runtimes/cmux.js
-import { execFile, execFileSync as execFileSync4 } from "child_process";
+import { execFile as execFile2, execFileSync as execFileSync4 } from "child_process";
 var CMUX_TIMEOUT = 15e3;
 var CmuxTimeoutError = class extends Error {
   constructor(cmd) {
@@ -3253,7 +4110,7 @@ var CmuxTimeoutError = class extends Error {
 };
 function cmux(args) {
   return new Promise((resolve2, reject) => {
-    execFile(
+    execFile2(
       resolveCmuxBin(),
       args,
       // CMUX_QUIET=1 silences cmux 0.64's one-time deprecation hints (e.g. the
@@ -3615,9 +4472,9 @@ function createCmuxDriver() {
 import { execFileSync as execFileSync5, execSync as execSync7 } from "child_process";
 
 // packages/workspaces/dist/workspaces/obsidian.js
-import fs9 from "fs/promises";
+import fs12 from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
-import path12 from "path";
+import path15 from "path";
 
 // packages/workspaces/dist/cmux/events-bridge.js
 import { spawn as nodeSpawn2 } from "child_process";
@@ -3661,7 +4518,7 @@ var CmuxEventsBridge = class {
   async run() {
     const spawnImpl = this.deps.spawnImpl ?? ((bin2, args2) => nodeSpawn2(bin2, args2, { stdio: ["ignore", "pipe", "ignore"] }));
     const bin = this.deps.cmuxBin ?? resolveCmuxBin();
-    const sleep2 = this.deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const sleep3 = this.deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
     const reconnectMs = this.deps.reconnectMs ?? 1e3;
     const args = [
       "events",
@@ -3681,7 +4538,7 @@ var CmuxEventsBridge = class {
         this.deps.log?.(`cmux events spawn failed: ${e.message}`);
         if (this.deps.stopAfterFirstRun)
           return;
-        await sleep2(reconnectMs);
+        await sleep3(reconnectMs);
         continue;
       }
       this.child = child;
@@ -3704,7 +4561,7 @@ var CmuxEventsBridge = class {
       this.child = null;
       if (this.stopped || this.deps.stopAfterFirstRun)
         break;
-      await sleep2(reconnectMs);
+      await sleep3(reconnectMs);
     }
   }
   onData(chunk) {
@@ -3811,6 +4668,8 @@ import net from "net";
 
 // packages/cli/src/control/squadrantd.ts
 var SELF_PATH2 = fileURLToPath3(import.meta.url);
+var CLI_BIN = join13(dirname5(SELF_PATH2), "index.js");
+var DAEMON_SOCK = join13(homedir8(), ".config", "squadrant", "squadrant.sock");
 function readPkgVersion() {
   try {
     const pkgPath = join13(dirname5(SELF_PATH2), "..", "package.json");
@@ -3820,6 +4679,31 @@ function readPkgVersion() {
   }
 }
 var PKG_VERSION = readPkgVersion();
+function buildTelegramBridge(cfg, stateRoot, log) {
+  const token = cfg.botToken ?? process.env.TELEGRAM_BOT_TOKEN;
+  if (!token) {
+    log("telegram: config present but no botToken / TELEGRAM_BOT_TOKEN set \u2014 bridge disabled");
+    return void 0;
+  }
+  const client = createTelegramClient({ token });
+  const ensureCaptainAlive = createEnsureCaptainAlive({
+    isAlive: createIsCaptainAlive(DAEMON_SOCK),
+    launch: createLaunch(CLI_BIN)
+  });
+  const runCommand = createRunCommand(CLI_BIN);
+  const sendReply = (threadId, text, replyMarkup) => client.sendMessage(cfg.supergroupId, threadId, text, replyMarkup);
+  return createTelegramBridge({
+    cfg,
+    stateRoot,
+    configRoot: dirname5(stateRoot),
+    client,
+    appendCaptainMessage,
+    log,
+    ensureCaptainAlive,
+    runCommand,
+    sendReply
+  });
+}
 function startSquadrantd(opts = {}) {
   const ctx = buildContext(opts);
   const { stateRoot, store, log, spawn: spawn2, writeResult, inFlightHeadlessIds, activeHeadlessKills } = ctx;
@@ -3876,6 +4760,8 @@ function startSquadrantd(opts = {}) {
   ctx.codexDriver = codexDriver;
   ctx.opencodeBridge = opencodeBridge;
   ctx.cmuxEventsBridge = cmuxEventsBridge;
+  const tgCfg = loadConfig().telegram;
+  ctx.telegramBridge = opts.telegramBridge ?? (tgCfg && !process.env.VITEST ? buildTelegramBridge(tgCfg, stateRoot, log) : void 0);
   ctx.daemonCmux = opts.daemonCmux ?? (opts.makeDaemonCmux ?? (() => new DaemonCmux(createCmuxDriver())))();
   const launchHeadless = opts.launchHeadless ?? (async (rec) => {
     const ingest = (e) => void ctx.d.handle({ kind: "event", project: rec.project, event: e });