squadrant 0.9.2 → 0.10.0

package/dist/squadrantd.js

@@ -185,22 +185,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 path14 = opts.path ?? defaultCmuxConfigPath();
+  if (!existsSync(path14)) {
+    mkdirSync(dirname(path14), { recursive: true });
+    writeFileSync(path14, MINIMAL_TEMPLATE);
+    return { path: path14, changed: true, alreadySet: false };
   }
-  const text = readFileSync(path13, "utf-8");
+  const text = readFileSync(path14, "utf-8");
   const current = parse(text)?.automation?.socketControlMode;
   if (current === AUTOMATION_MODE) {
-    return { path: path13, changed: false, alreadySet: true };
+    return { path: path14, 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(path14, applyEdits(text, edits));
+  return { path: path14, changed: true, alreadySet: false };
 }
 
 // packages/shared/dist/lib/cmux-probe.js
@@ -322,15 +322,15 @@ function sleep(ms) {
 function defaultStatePath() {
   return join4(homedir3(), ".config", "squadrant", "state", "cmux-autoconfig.json");
 }
-function readState(path13) {
+function readState(path14) {
   try {
-    return JSON.parse(readFileSync4(path13, "utf-8"));
+    return JSON.parse(readFileSync4(path14, "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 +338,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,
@@ -936,27 +936,39 @@ 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);
+function appendEntry(stateRoot, project, build) {
+  return withProjectLock(project, async () => {
+    const dir = inboxDir(stateRoot);
     await fs6.mkdir(dir, { recursive: true });
-    const file = logPath(opts.stateRoot, opts.project);
-    const lastSeq = await readMaxSeq(opts.stateRoot, opts.project);
+    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
-    };
+    const entry = build(seq);
     await fs6.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`);
 }
@@ -1241,6 +1253,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 +1550,7 @@ function buildContext(opts) {
     codexDriver: null,
     opencodeBridge: null,
     cmuxEventsBridge: null,
+    telegramBridge: void 0,
     broadcast: () => {
     },
     schedulePromotion: () => {
@@ -2035,10 +2078,10 @@ function distBuiltAt() {
     return 0;
   }
 }
-function gatherLogStats(path13, now, windowMs) {
+function gatherLogStats(path14, now, windowMs) {
   let sizeBytes = 0;
   try {
-    sizeBytes = statSync2(path13).size;
+    sizeBytes = statSync2(path14).size;
   } catch {
     return { errorCount: 0, sizeBytes: 0, windowMs };
   }
@@ -2049,7 +2092,7 @@ function gatherLogStats(path13, now, windowMs) {
   const len = sizeBytes - start;
   let text = "";
   try {
-    const fd = openSync2(path13, "r");
+    const fd = openSync2(path14, "r");
     try {
       const buf = Buffer.alloc(len);
       readSync(fd, buf, 0, len, start);
@@ -2126,7 +2169,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 +2299,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 +2395,10 @@ function startDaemon(ctx, opts, pkgVersion) {
         ctx.cmuxEventsBridge.stop();
       } catch {
       }
+      try {
+        ctx.telegramBridge?.stop();
+      } catch {
+      }
       try {
         ctx.codexDriver.stop?.();
       } catch {
@@ -2365,6 +2423,404 @@ import path6 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]);
+    }
+  }
+};
+function helpText() {
+  const lines = Object.values(REGISTRY).map((e) => `  ${e.usage}`);
+  return ["Available commands:", ...lines, "  /help"].join("\n");
+}
+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 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}`;
+    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 fs8 from "fs";
+import path7 from "path";
+function statePath(stateRoot) {
+  return path7.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 data = JSON.parse(raw);
+    return {
+      offset: typeof data.offset === "number" ? data.offset : 0,
+      topics: data.topics ?? {}
+    };
+  } catch {
+    return { offset: 0, topics: {} };
+  }
+}
+function saveState(stateRoot, s) {
+  fs8.mkdirSync(stateRoot, { recursive: true });
+  fs8.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 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) {
+      const body = { chat_id: chatId, text };
+      if (threadId !== void 0)
+        body.message_thread_id = threadId;
+      await call("sendMessage", body);
+    },
+    async createForumTopic(chatId, name) {
+      const r = await call("createForumTopic", { chat_id: chatId, name });
+      return r.message_thread_id;
+    }
+  };
+}
+
+// packages/core/dist/telegram/bridge.js
+var LONG_POLL_SEC = 50;
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+function createTelegramBridge(opts) {
+  const { cfg, stateRoot, client, appendCaptainMessage: appendCaptainMessage2, log, ensureCaptainAlive, runCommand, sendReply } = opts;
+  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) {
+    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));
+  }
+  async function reply(threadId, text) {
+    if (!sendReply)
+      return;
+    try {
+      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.");
+      return;
+    }
+    if (!isControlEnabled(cfg) || !isAuthorized(fromId, cfg)) {
+      await reply(void 0, "\u26D4 not authorized");
+      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 (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) {
+    const m = u.message;
+    if (!m || m.text === void 0)
+      return;
+    if (!cfg.chats.includes(m.chat.id))
+      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 fs9 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,27 +2834,27 @@ 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 fs10 from "fs";
+import path8 from "path";
 
 // packages/agents/dist/projection/cursor.js
 import { mkdir, readFile, writeFile } from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 import os2 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 path10 from "path";
 import os3 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 path11 from "path";
 import os4 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 path12 from "path";
 import os5 from "os";
 
 // packages/agents/dist/codex/app-server-client.js
@@ -2979,7 +3435,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 +3463,7 @@ var OpencodeSseBridge = class {
             return;
           }
         }
-        await sleep2(reconnectMs);
+        await sleep3(reconnectMs);
       }
     }
     this.controllers.delete(taskId);
@@ -3243,7 +3699,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 +3709,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 +4071,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 fs11 from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
-import path12 from "path";
+import path13 from "path";
 
 // packages/workspaces/dist/cmux/events-bridge.js
 import { spawn as nodeSpawn2 } from "child_process";
@@ -3661,7 +4117,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 +4137,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 +4160,7 @@ var CmuxEventsBridge = class {
       this.child = null;
       if (this.stopped || this.deps.stopAfterFirstRun)
         break;
-      await sleep2(reconnectMs);
+      await sleep3(reconnectMs);
     }
   }
   onData(chunk) {
@@ -3811,6 +4267,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 +4278,30 @@ 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) => client.sendMessage(cfg.supergroupId, threadId, text);
+  return createTelegramBridge({
+    cfg,
+    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 +4358,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 });