@iroaxel/arcena 4.3.157

package/dist/cli.js

@@ -0,0 +1,3504 @@
+#!/usr/bin/env -S node --max-old-space-size=8192 --expose-gc
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  ActivityIndicator,
+  AnimationProvider,
+  AssistantMessage,
+  Box_default,
+  CompactionDone,
+  CompactionSpinner,
+  GGBoss,
+  InputArea,
+  MODELS,
+  MessageResponse,
+  ModelSelector,
+  SelectList,
+  Static,
+  StreamingArea,
+  TerminalSizeProvider,
+  Text,
+  ThemeContext,
+  ToolExecution,
+  ToolUseLoader,
+  UserMessage,
+  bossStore,
+  closeLogger,
+  getAppPaths,
+  getBossState,
+  getContextWindow,
+  getSplashAudioDurationMs,
+  initLogger,
+  loadSettings,
+  loadTheme,
+  log,
+  playSplashAudio,
+  render_default,
+  require_jsx_runtime,
+  require_react,
+  saveSettings,
+  subscribeToBossStore,
+  tasksStore,
+  useAnimationActive,
+  useAnimationTick,
+  useBossState,
+  useDoublePress,
+  useTasksState,
+  useTerminalSize,
+  useTheme,
+  use_app_default,
+  use_input_default,
+  use_stdout_default
+} from "./chunk-OWJSBNAJ.js";
+import "./chunk-KZJPLEZU.js";
+import {
+  source_default
+} from "./chunk-YKKUCYNE.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-YNWFCUMR.js";
+
+// src/cli.ts
+init_esm_shims();
+import path5 from "path";
+
+// src/links.ts
+init_esm_shims();
+import fs from "fs/promises";
+import path from "path";
+function getLinksPath() {
+  return path.join(getAppPaths().agentDir, "boss", "links.json");
+}
+async function loadLinks() {
+  try {
+    const content = await fs.readFile(getLinksPath(), "utf-8");
+    const parsed = JSON.parse(content);
+    return { projects: parsed.projects ?? [] };
+  } catch {
+    return { projects: [] };
+  }
+}
+async function saveLinks(links) {
+  const p = getLinksPath();
+  await fs.mkdir(path.dirname(p), { recursive: true, mode: 448 });
+  await fs.writeFile(p, JSON.stringify(links, null, 2), "utf-8");
+}
+
+// src/link-command.tsx
+init_esm_shims();
+var import_react2 = __toESM(require_react(), 1);
+
+// src/discover.ts
+init_esm_shims();
+import fs2 from "fs/promises";
+import { createReadStream } from "fs";
+import readline from "readline";
+import os from "os";
+import path2 from "path";
+async function discoverProjects() {
+  const [gg, cc, cx] = await Promise.all([
+    discoverGgcoderProjects(),
+    discoverClaudeProjects(),
+    discoverCodexProjects()
+  ]);
+  const byPath = /* @__PURE__ */ new Map();
+  for (const p of [...gg, ...cc, ...cx]) {
+    const existing = byPath.get(p.path);
+    if (!existing) {
+      byPath.set(p.path, p);
+      continue;
+    }
+    byPath.set(p.path, {
+      name: existing.name,
+      path: existing.path,
+      lastActiveMs: Math.max(existing.lastActiveMs, p.lastActiveMs),
+      lastActiveDisplay: "",
+      // recomputed below
+      sources: mergeSources(existing.sources, p.sources)
+    });
+  }
+  const merged = Array.from(byPath.values()).map((p) => ({
+    ...p,
+    lastActiveDisplay: formatRelativeTime(p.lastActiveMs)
+  }));
+  merged.sort((a, b) => b.lastActiveMs - a.lastActiveMs);
+  return merged;
+}
+var SOURCE_ORDER = {
+  arcicoder: 0,
+  "claude-code": 1,
+  codex: 2
+};
+function mergeSources(a, b) {
+  const set = /* @__PURE__ */ new Set([...a, ...b]);
+  return Array.from(set).sort((x, y) => SOURCE_ORDER[x] - SOURCE_ORDER[y]);
+}
+async function discoverGgcoderProjects() {
+  const sessionsDir = getAppPaths().sessionsDir;
+  let entries;
+  try {
+    entries = await fs2.readdir(sessionsDir);
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const entry of entries) {
+    const dir = path2.join(sessionsDir, entry);
+    const mtime = await maxJsonlMtime(dir);
+    if (mtime === null) continue;
+    const decoded = "/" + entry.replace(/_/g, "/");
+    if (!await isDirectory(decoded)) continue;
+    results.push({
+      name: path2.basename(decoded),
+      path: decoded,
+      lastActiveMs: mtime,
+      lastActiveDisplay: formatRelativeTime(mtime),
+      sources: ["arcicoder"]
+    });
+  }
+  return results;
+}
+async function discoverClaudeProjects() {
+  const projectsDir = path2.join(os.homedir(), ".claude", "projects");
+  let entries;
+  try {
+    entries = await fs2.readdir(projectsDir);
+  } catch {
+    return [];
+  }
+  const results = await Promise.all(
+    entries.map(async (entry) => {
+      const dir = path2.join(projectsDir, entry);
+      const mtime = await maxJsonlMtime(dir);
+      if (mtime === null) return null;
+      const cwd = await readFirstFromJsonlDir(dir, claudeCwdExtractor) ?? fallbackDashDecode(entry);
+      if (!cwd) return null;
+      if (!await isDirectory(cwd)) return null;
+      return {
+        name: path2.basename(cwd),
+        path: cwd,
+        lastActiveMs: mtime,
+        lastActiveDisplay: formatRelativeTime(mtime),
+        sources: ["claude-code"]
+      };
+    })
+  );
+  return results.filter((p) => p !== null);
+}
+async function discoverCodexProjects() {
+  const sessionsDir = path2.join(os.homedir(), ".codex", "sessions");
+  if (!await isDirectory(sessionsDir)) return [];
+  const files = await collectJsonlFiles(sessionsDir, 4);
+  if (files.length === 0) return [];
+  files.sort((a, b) => b.mtime - a.mtime);
+  const byCwd = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    const cwd = await readFirstFromFile(f.path, codexCwdExtractor);
+    if (!cwd) continue;
+    const prev = byCwd.get(cwd);
+    if (prev === void 0 || f.mtime > prev) byCwd.set(cwd, f.mtime);
+  }
+  const results = [];
+  for (const [cwd, mtime] of byCwd) {
+    if (!await isDirectory(cwd)) continue;
+    results.push({
+      name: path2.basename(cwd),
+      path: cwd,
+      lastActiveMs: mtime,
+      lastActiveDisplay: formatRelativeTime(mtime),
+      sources: ["codex"]
+    });
+  }
+  return results;
+}
+async function isDirectory(p) {
+  try {
+    const s = await fs2.stat(p);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function maxJsonlMtime(dir) {
+  if (!await isDirectory(dir)) return null;
+  const files = await collectJsonlFiles(dir, 2);
+  if (files.length === 0) return null;
+  let max = 0;
+  for (const f of files) if (f.mtime > max) max = f.mtime;
+  return max > 0 ? max : null;
+}
+async function collectJsonlFiles(dir, maxDepth) {
+  const out = [];
+  await walk(dir, 0);
+  return out;
+  async function walk(current, depth) {
+    let entries;
+    try {
+      entries = await fs2.readdir(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = path2.join(current, e.name);
+      if (e.isFile() && e.name.endsWith(".jsonl")) {
+        try {
+          const s = await fs2.stat(full);
+          out.push({ path: full, mtime: s.mtimeMs });
+        } catch {
+        }
+      } else if (e.isDirectory() && depth < maxDepth) {
+        await walk(full, depth + 1);
+      }
+    }
+  }
+}
+var claudeCwdExtractor = (line) => {
+  try {
+    const parsed = JSON.parse(line);
+    if (typeof parsed.cwd === "string" && parsed.cwd.startsWith("/")) return parsed.cwd;
+  } catch {
+  }
+  return null;
+};
+var CODEX_CWD_RE = /<cwd>([^<]+)<\/cwd>/;
+var codexCwdExtractor = (line) => {
+  try {
+    const parsed = JSON.parse(line);
+    const cwd = parsed.payload?.cwd;
+    if (typeof cwd === "string" && cwd.startsWith("/")) return cwd;
+  } catch {
+  }
+  const m = CODEX_CWD_RE.exec(line);
+  if (m && m[1] && m[1].startsWith("/")) return m[1];
+  return null;
+};
+async function readFirstFromJsonlDir(dir, extractor) {
+  const files = await collectJsonlFiles(dir, 2);
+  if (files.length === 0) return null;
+  files.sort((a, b) => b.mtime - a.mtime);
+  for (const f of files) {
+    const v = await readFirstFromFile(f.path, extractor);
+    if (v) return v;
+  }
+  return null;
+}
+async function readFirstFromFile(file, extractor) {
+  return new Promise((resolve) => {
+    const stream = createReadStream(file, { encoding: "utf-8" });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    let lines = 0;
+    let done = false;
+    const MAX_LINES = 200;
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      resolve(value);
+      rl.close();
+      stream.destroy();
+    };
+    rl.on("line", (line) => {
+      if (done) return;
+      lines++;
+      if (lines > MAX_LINES) {
+        finish(null);
+        return;
+      }
+      const v = extractor(line);
+      if (v) finish(v);
+    });
+    rl.on("close", () => finish(null));
+    rl.on("error", () => finish(null));
+    stream.on("error", () => finish(null));
+  });
+}
+function fallbackDashDecode(entry) {
+  if (!entry.startsWith("-")) return null;
+  return "/" + entry.slice(1).replace(/-/g, "/");
+}
+function formatRelativeTime(ms) {
+  if (ms === 0) return "\u2014";
+  const diff = Date.now() - ms;
+  if (diff < 6e4) return "just now";
+  const min = 6e4;
+  const hour = 60 * min;
+  const day = 24 * hour;
+  const week = 7 * day;
+  const month = 30 * day;
+  if (diff < hour) return `${Math.floor(diff / min)}m ago`;
+  if (diff < day) return `${Math.floor(diff / hour)}h ago`;
+  if (diff < week) return `${Math.floor(diff / day)}d ago`;
+  if (diff < month) return `${Math.floor(diff / week)}w ago`;
+  return `${Math.floor(diff / month)}mo ago`;
+}
+
+// src/banner.tsx
+init_esm_shims();
+var import_react = __toESM(require_react(), 1);
+
+// src/branding.ts
+init_esm_shims();
+
+// package.json
+var package_default = {
+  name: "@iroaxel/arcena",
+  version: "4.3.157",
+  type: "module",
+  description: "Orchestrator agent that drives multiple arcicoder sessions across projects from a single chat",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/BigBlindGorg/ARCena.git",
+    directory: "packages/gg-boss"
+  },
+  bin: {
+    arcena: "./dist/cli.js"
+  },
+  exports: {
+    ".": {
+      import: "./dist/index.js",
+      types: "./dist/index.d.ts"
+    }
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "tsup && cp -R assets/. dist/ && chmod +x dist/cli.js",
+    check: "tsc --noEmit",
+    test: "vitest run"
+  },
+  devDependencies: {
+    "@iroaxel/gg-agent": "workspace:*",
+    "@iroaxel/gg-ai": "workspace:*",
+    "@iroaxel/arcicoder": "workspace:*",
+    "@types/node": "^25.6.0",
+    "@types/react": "^19.2.14",
+    chalk: "^5.6.2",
+    ink: "^7.0.2",
+    react: "^19.2.5",
+    tsup: "^8.5.1",
+    typescript: "^6.0.3",
+    vitest: "^4.1.4",
+    zod: "^4.4.3"
+  },
+  optionalDependencies: {
+    "@huggingface/transformers": "^3.6.0",
+    "ogg-opus-decoder": "^1.6.13"
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// src/branding.ts
+var VERSION = package_default.version;
+var BRAND = "ARCena";
+var AUTHOR = "Axel";
+var LOGO_LINES = [" \u2584\u2580\u2580\u2580 \u2584\u2580\u2580\u2580", " \u2588 \u2580\u2588 \u2588 \u2580\u2588", " \u2580\u2584\u2584\u2580 \u2580\u2584\u2584\u2580"];
+var LOGO_GAP = "   ";
+var GRADIENT = [
+  "#dc2626",
+  // red-600
+  "#e11d48",
+  // rose-600
+  "#be185d",
+  // pink-700
+  "#a21caf",
+  // fuchsia-700
+  "#c026d3",
+  // fuchsia-600
+  "#d946ef",
+  // fuchsia-500
+  "#c026d3",
+  // fuchsia-600 (back)
+  "#a21caf",
+  // fuchsia-700 (back)
+  "#be185d",
+  // pink-700 (back)
+  "#e11d48",
+  // rose-600 (back)
+  "#dc2626",
+  // red-600 (back)
+  "#b91c1c"
+  // red-700 (slight darker tail)
+];
+var PULSE_COLORS = [
+  "#dc2626",
+  // crimson
+  "#e11d48",
+  // rose
+  "#be185d",
+  // wine
+  "#a21caf",
+  // magenta
+  "#c026d3",
+  // fuchsia
+  "#a21caf",
+  // back
+  "#be185d",
+  // back
+  "#e11d48"
+  // back
+];
+var COLORS = {
+  primary: "#e11d48",
+  // crimson-rose — main brand color
+  accent: "#d946ef",
+  // fuchsia — secondary
+  text: "#e2e8f0",
+  textDim: "#6b7280",
+  success: "#4ade80",
+  warning: "#fbbf24",
+  error: "#f87171"
+};
+function clearScreen() {
+  process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+}
+
+// src/banner.tsx
+var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
+function BossBanner({ subtitle, hint, showShortcuts }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Box_default, { flexDirection: "column", marginTop: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Box_default, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(GradientText, { text: LOGO_LINES[0] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { children: LOGO_GAP }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: COLORS.primary, bold: true, children: BRAND }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Text, { color: COLORS.textDim, children: [
+        " v",
+        VERSION
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: COLORS.textDim, children: " \xB7 By " }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: COLORS.text, bold: true, children: AUTHOR })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Box_default, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(GradientText, { text: LOGO_LINES[1] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { children: LOGO_GAP }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: COLORS.accent, children: subtitle })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Box_default, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(GradientText, { text: LOGO_LINES[2] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { children: LOGO_GAP }),
+      showShortcuts ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Text, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: COLORS.primary, children: "^T" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: COLORS.textDim, children: " tasks" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: COLORS.textDim, children: "  " }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: COLORS.primary, children: "Tab" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: COLORS.textDim, children: " scope" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: COLORS.textDim, children: "  " }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: COLORS.primary, children: "\u21E7Tab" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: COLORS.textDim, children: " thinking" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: COLORS.textDim, children: "  " }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: COLORS.primary, children: "ESC" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: COLORS.textDim, children: " interrupt" })
+      ] }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: COLORS.textDim, children: hint ?? "" })
+    ] })
+  ] });
+}
+function GradientText({ text }) {
+  const chars = [];
+  let colorIdx = 0;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === " ") {
+      chars.push(ch);
+    } else {
+      const color = GRADIENT[colorIdx % GRADIENT.length];
+      chars.push(
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color, children: ch }, i)
+      );
+      colorIdx++;
+    }
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { children: chars });
+}
+
+// src/link-command.tsx
+var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
+var VISIBLE_ROWS = 12;
+function sourceBadge(sources) {
+  if (sources.length > 1) return { label: "[mix]", color: COLORS.success };
+  const only = sources[0];
+  if (only === "arcicoder") return { label: "[gg ]", color: COLORS.accent };
+  if (only === "claude-code") return { label: "[cc ]", color: COLORS.warning };
+  if (only === "codex") return { label: "[cx ]", color: COLORS.primary };
+  return { label: "[?? ]", color: COLORS.textDim };
+}
+function LinkScreen({ projects, initialSelected, onDone }) {
+  const [cursor, setCursor] = (0, import_react2.useState)(0);
+  const [selected, setSelected] = (0, import_react2.useState)(new Set(initialSelected));
+  const [scrollOffset, setScrollOffset] = (0, import_react2.useState)(0);
+  const visible = projects.slice(scrollOffset, scrollOffset + VISIBLE_ROWS);
+  use_input_default((input, key) => {
+    if (key.ctrl && input === "c") {
+      onDone([], true);
+      return;
+    }
+    if (projects.length === 0) {
+      if (key.return || key.escape || input === "q") onDone([], true);
+      return;
+    }
+    if (key.upArrow) {
+      const next = Math.max(0, cursor - 1);
+      setCursor(next);
+      if (next < scrollOffset) setScrollOffset(next);
+    } else if (key.downArrow) {
+      const next = Math.min(projects.length - 1, cursor + 1);
+      setCursor(next);
+      if (next >= scrollOffset + VISIBLE_ROWS) setScrollOffset(next - VISIBLE_ROWS + 1);
+    } else if (input === " ") {
+      const p = projects[cursor];
+      if (!p) return;
+      const nextSet = new Set(selected);
+      if (nextSet.has(p.path)) nextSet.delete(p.path);
+      else nextSet.add(p.path);
+      setSelected(nextSet);
+    } else if (input === "a") {
+      const allSelected = projects.every((p) => selected.has(p.path));
+      setSelected(allSelected ? /* @__PURE__ */ new Set() : new Set(projects.map((p) => p.path)));
+    } else if (key.return) {
+      onDone(
+        projects.filter((p) => selected.has(p.path)).map((p) => p.path),
+        false
+      );
+    } else if (key.escape || input === "q") {
+      onDone([], true);
+    }
+  });
+  const subtitle = projects.length === 0 ? "Link projects" : `Link projects \xB7 ${projects.length} discovered \xB7 ${selected.size} selected`;
+  const hint = "\u2191\u2193 navigate \xB7 space toggle \xB7 a all \xB7 enter save \xB7 esc cancel";
+  if (projects.length === 0) {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Box_default, { flexDirection: "column", paddingX: 2, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(BossBanner, { subtitle: "Link projects", hint: "No projects yet" }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Box_default, { flexDirection: "column", marginLeft: 2, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: COLORS.textDim, children: "No arcicoder projects found in ~/.gg/sessions/." }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Text, { color: COLORS.textDim, children: [
+          "Run arcicoder in a project at least once, then re-run",
+          " ",
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: COLORS.accent, children: "arcena link" }),
+          "."
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Box_default, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: COLORS.textDim, children: "Press any key to exit." }) })
+      ] })
+    ] });
+  }
+  const showingTop = scrollOffset > 0;
+  const showingBottom = scrollOffset + VISIBLE_ROWS < projects.length;
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Box_default, { flexDirection: "column", paddingX: 2, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(BossBanner, { subtitle, hint }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Box_default, { flexDirection: "column", marginLeft: 2, children: [
+      showingTop && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: COLORS.textDim, children: "  \u2191 more above" }),
+      visible.map((p, i) => {
+        const realIndex = scrollOffset + i;
+        const isCursor = realIndex === cursor;
+        const isSelected = selected.has(p.path);
+        const checkbox = isSelected ? "[\u2713]" : "[ ]";
+        const arrow = isCursor ? "\u276F" : " ";
+        const nameColor = isCursor ? COLORS.primary : isSelected ? COLORS.success : COLORS.text;
+        const checkboxColor = isSelected ? COLORS.success : COLORS.textDim;
+        const badge = sourceBadge(p.sources);
+        return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Box_default, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: COLORS.primary, children: arrow }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { children: " " }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: checkboxColor, children: checkbox }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { children: " " }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: badge.color, children: badge.label }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { children: " " }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: nameColor, bold: isCursor, children: p.name }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: COLORS.textDim, children: "  " }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: COLORS.textDim, children: p.lastActiveDisplay })
+        ] }, p.path);
+      }),
+      showingBottom && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: COLORS.textDim, children: "  \u2193 more below" })
+    ] })
+  ] });
+}
+function LinkApp({ projects, initialSelected, resolve }) {
+  const { exit } = use_app_default();
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    LinkScreen,
+    {
+      projects,
+      initialSelected,
+      onDone: (selected, cancelled) => {
+        resolve({ selected, cancelled });
+        exit();
+      }
+    }
+  );
+}
+async function runLinkCommand() {
+  const projects = await discoverProjects();
+  const links = await loadLinks();
+  const initialSelected = new Set(links.projects.map((p) => p.cwd));
+  clearScreen();
+  const result = await new Promise((resolve) => {
+    const { waitUntilExit } = render_default(
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(LinkApp, { projects, initialSelected, resolve })
+    );
+    void waitUntilExit();
+  });
+  if (result.cancelled) {
+    process.stdout.write(source_default.hex(COLORS.textDim)("\nCancelled. No changes saved.\n"));
+    return;
+  }
+  const linked = result.selected.map((path6) => projects.find((p) => p.path === path6)).filter((p) => Boolean(p)).map((p) => ({ name: p.name, cwd: p.path }));
+  await saveLinks({ projects: linked });
+  process.stdout.write("\n");
+  if (linked.length === 0) {
+    process.stdout.write(source_default.hex(COLORS.warning)("Cleared linked projects.\n"));
+  } else {
+    process.stdout.write(
+      source_default.hex(COLORS.success)(
+        `Linked ${linked.length} project${linked.length === 1 ? "" : "s"}:
+`
+      )
+    );
+    for (const p of linked) {
+      process.stdout.write(
+        "  " + source_default.hex(COLORS.primary)("\xB7") + " " + source_default.hex(COLORS.text)(p.name) + "\n"
+      );
+    }
+    process.stdout.write("\n");
+    process.stdout.write(
+      source_default.hex(COLORS.textDim)(`Run `) + source_default.hex(COLORS.accent)("arcena") + source_default.hex(COLORS.textDim)(` to start the orchestrator.
+`)
+    );
+  }
+}
+
+// src/serve-mode.ts
+init_esm_shims();
+import path3 from "path";
+import fs3 from "fs/promises";
+
+// src/voice-transcriber.ts
+init_esm_shims();
+var TARGET_SAMPLE_RATE = 16e3;
+var MODEL_ID = "Xenova/whisper-tiny.en";
+var transcriber = null;
+var loadPromise = null;
+var onProgress = null;
+function setProgressCallback(cb) {
+  onProgress = cb;
+}
+function resample(audio, fromRate, toRate) {
+  if (fromRate === toRate) return audio;
+  const ratio = fromRate / toRate;
+  const newLength = Math.round(audio.length / ratio);
+  const result = new Float32Array(newLength);
+  for (let i = 0; i < newLength; i++) {
+    const srcIndex = i * ratio;
+    const low = Math.floor(srcIndex);
+    const high = Math.min(low + 1, audio.length - 1);
+    const frac = srcIndex - low;
+    result[i] = audio[low] * (1 - frac) + audio[high] * frac;
+  }
+  return result;
+}
+function downmixToMono(channelData) {
+  if (channelData.length === 0) return new Float32Array();
+  if (channelData.length === 1) return channelData[0];
+  const samples = channelData[0].length;
+  const out = new Float32Array(samples);
+  const scale = 1 / channelData.length;
+  for (let i = 0; i < samples; i++) {
+    let mixed = 0;
+    for (const channel of channelData) mixed += channel[i] ?? 0;
+    out[i] = mixed * scale;
+  }
+  return out;
+}
+async function decodeOggOpus(buffer) {
+  const { OggOpusDecoder } = await import("ogg-opus-decoder");
+  const decoder = new OggOpusDecoder();
+  await decoder.ready;
+  try {
+    const decoded = await decoder.decodeFile(buffer);
+    if (!decoded.channelData?.length || !decoded.channelData[0]?.length) {
+      throw new Error("Decoded audio is empty");
+    }
+    const mono = downmixToMono(decoded.channelData);
+    return resample(mono, decoded.sampleRate, TARGET_SAMPLE_RATE);
+  } finally {
+    decoder.free();
+  }
+}
+async function getTranscriber() {
+  if (transcriber) return transcriber;
+  if (!loadPromise) {
+    loadPromise = (async () => {
+      const { pipeline } = await import("@huggingface/transformers");
+      const instance = await pipeline("automatic-speech-recognition", MODEL_ID, {
+        dtype: "fp32",
+        progress_callback: onProgress ?? void 0
+      });
+      transcriber = instance;
+      return instance;
+    })();
+  }
+  return loadPromise;
+}
+function isModelLoaded() {
+  return transcriber !== null;
+}
+async function transcribeVoice(fileUrl) {
+  const response = await fetch(fileUrl);
+  if (!response.ok) throw new Error(`Failed to download voice file: ${response.status}`);
+  const buffer = new Uint8Array(await response.arrayBuffer());
+  const pcm = await decodeOggOpus(buffer);
+  const asr = await getTranscriber();
+  const result = await asr(pcm);
+  const text = Array.isArray(result) ? result[0]?.text : result.text;
+  return (text ?? "").trim();
+}
+
+// src/telegram.ts
+init_esm_shims();
+var TELEGRAM_API = "https://api.telegram.org";
+var MAX_MESSAGE_LENGTH = 4096;
+var TelegramBot = class {
+  token;
+  allowedUserId;
+  offset = 0;
+  running = false;
+  onMessage = null;
+  onVoiceMessage = null;
+  onCallback = null;
+  onBotAdded = null;
+  onBotRemoved = null;
+  constructor(config) {
+    this.token = config.botToken;
+    this.allowedUserId = config.allowedUserId;
+  }
+  /** Register handler for incoming text messages. */
+  onText(handler) {
+    this.onMessage = handler;
+  }
+  /** Register handler for incoming voice notes. */
+  onVoice(handler) {
+    this.onVoiceMessage = handler;
+  }
+  /** Register handler for inline keyboard button presses. */
+  onCallbackQuery(handler) {
+    this.onCallback = handler;
+  }
+  /** Register handler for when the bot is added to a group. */
+  onAddedToGroup(handler) {
+    this.onBotAdded = handler;
+  }
+  /** Register handler for when the bot is removed from a group. */
+  onRemovedFromGroup(handler) {
+    this.onBotRemoved = handler;
+  }
+  /** Start long polling. Blocks until stop() is called. */
+  async start() {
+    this.running = true;
+    const me = await this.apiCall("getMe");
+    if (!me.ok) {
+      throw new Error(`Invalid bot token: ${JSON.stringify(me)}`);
+    }
+    while (this.running) {
+      try {
+        const updates = await this.getUpdates();
+        for (const update of updates) {
+          await this.handleUpdate(update);
+        }
+      } catch (err) {
+        if (!this.running) break;
+        console.error(`[telegram] Poll error: ${err instanceof Error ? err.message : err}`);
+        await sleep(3e3);
+      }
+    }
+  }
+  /** Stop long polling. */
+  stop() {
+    this.running = false;
+  }
+  /** Send a text message to a specific chat. Converts markdown and splits long messages. */
+  async send(chatId, text, buttons) {
+    const converted = toTelegramMarkdown(text);
+    const chunks = splitMessage(converted);
+    for (let i = 0; i < chunks.length; i++) {
+      const isLast = i === chunks.length - 1;
+      const replyMarkup = isLast && buttons ? {
+        inline_keyboard: buttons.map(
+          (row) => row.map((b) => ({ text: b.text, callback_data: b.callback_data }))
+        )
+      } : void 0;
+      await this.apiCall("sendMessage", {
+        chat_id: chatId,
+        text: chunks[i],
+        parse_mode: "Markdown",
+        ...replyMarkup ? { reply_markup: replyMarkup } : {}
+      });
+    }
+  }
+  /** Send a plain text message (no markdown parsing) to a specific chat. */
+  async sendPlain(chatId, text) {
+    const chunks = splitMessage(text);
+    for (const chunk of chunks) {
+      await this.apiCall("sendMessage", {
+        chat_id: chatId,
+        text: chunk
+      });
+    }
+  }
+  /** Send a typing indicator to a specific chat. */
+  async sendTyping(chatId) {
+    await this.apiCall("sendChatAction", {
+      chat_id: chatId,
+      action: "typing"
+    });
+  }
+  /** Get a direct download URL for a Telegram file. */
+  async getFileUrl(fileId) {
+    const result = await this.apiCall("getFile", { file_id: fileId });
+    if (!result.ok) throw new Error(`Failed to get file: ${JSON.stringify(result)}`);
+    const filePath = result.result.file_path;
+    return `${TELEGRAM_API}/file/bot${this.token}/${filePath}`;
+  }
+  // ── Private ───────────────────────────────────────────
+  async getUpdates() {
+    const result = await this.apiCall("getUpdates", {
+      offset: this.offset,
+      timeout: 30,
+      allowed_updates: ["message", "callback_query", "my_chat_member"]
+    });
+    if (!result.ok || !Array.isArray(result.result)) return [];
+    const updates = result.result;
+    if (updates.length > 0) {
+      this.offset = updates[updates.length - 1].update_id + 1;
+    }
+    return updates;
+  }
+  async handleUpdate(update) {
+    if (update.message) {
+      const msg = update.message;
+      if (msg.from.id !== this.allowedUserId) {
+        return;
+      }
+      if (msg.text && this.onMessage) {
+        this.onMessage({
+          text: msg.text,
+          chatId: msg.chat.id,
+          chatType: msg.chat.type,
+          chatTitle: msg.chat.title
+        });
+      } else if (msg.voice && this.onVoiceMessage) {
+        this.onVoiceMessage({
+          fileId: msg.voice.file_id,
+          duration: msg.voice.duration,
+          chatId: msg.chat.id,
+          chatType: msg.chat.type,
+          chatTitle: msg.chat.title
+        });
+      }
+    }
+    if (update.my_chat_member) {
+      const member = update.my_chat_member;
+      const status = member.new_chat_member.status;
+      if ((status === "member" || status === "administrator") && this.onBotAdded) {
+        this.onBotAdded(member.chat.id, member.chat.title);
+      } else if ((status === "left" || status === "kicked") && this.onBotRemoved) {
+        this.onBotRemoved(member.chat.id);
+      }
+    }
+    if (update.callback_query) {
+      const cb = update.callback_query;
+      if (cb.from.id !== this.allowedUserId) return;
+      await this.apiCall("answerCallbackQuery", { callback_query_id: cb.id });
+      if (cb.data && this.onCallback) {
+        this.onCallback(cb.data, cb.message.chat.id);
+      }
+    }
+  }
+  async apiCall(method, body) {
+    const url = `${TELEGRAM_API}/bot${this.token}/${method}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      return { ok: false };
+    }
+    return response.json();
+  }
+};
+function toTelegramMarkdown(text) {
+  const lines = text.split("\n");
+  const result = [];
+  let inCodeBlock = false;
+  for (const line of lines) {
+    if (line.trimStart().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      result.push(line);
+      continue;
+    }
+    if (inCodeBlock) {
+      result.push(line);
+      continue;
+    }
+    let transformed = line;
+    const headingMatch = transformed.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      transformed = `*${headingMatch[2]}*`;
+      result.push(transformed);
+      continue;
+    }
+    if (/^(-{3,}|_{3,}|\*{3,})$/.test(transformed.trim())) {
+      result.push("");
+      continue;
+    }
+    transformed = transformed.replace(/\*\*(.+?)\*\*/g, "*$1*");
+    result.push(transformed);
+  }
+  return result.join("\n");
+}
+function splitMessage(text) {
+  if (text.length <= MAX_MESSAGE_LENGTH) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= MAX_MESSAGE_LENGTH) {
+      chunks.push(remaining);
+      break;
+    }
+    let splitAt = remaining.lastIndexOf("\n", MAX_MESSAGE_LENGTH);
+    if (splitAt === -1 || splitAt < MAX_MESSAGE_LENGTH * 0.5) {
+      splitAt = remaining.lastIndexOf(" ", MAX_MESSAGE_LENGTH);
+    }
+    if (splitAt === -1 || splitAt < MAX_MESSAGE_LENGTH * 0.5) {
+      splitAt = MAX_MESSAGE_LENGTH;
+    }
+    chunks.push(remaining.slice(0, splitAt));
+    remaining = remaining.slice(splitAt).trimStart();
+  }
+  return chunks;
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/serve-mode.ts
+function getTelegramConfigPath() {
+  return path3.join(getAppPaths().agentDir, "boss", "telegram.json");
+}
+async function loadBossTelegramConfig() {
+  try {
+    const raw = await fs3.readFile(getTelegramConfigPath(), "utf-8");
+    const data = JSON.parse(raw);
+    if (data.botToken && data.userId) return data;
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function saveBossTelegramConfig(config) {
+  const file = getTelegramConfigPath();
+  await fs3.mkdir(path3.dirname(file), { recursive: true });
+  await fs3.writeFile(file, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
+}
+function formatItemForTelegram(item) {
+  switch (item.kind) {
+    case "user":
+    case "tool":
+    case "worker_event":
+      return null;
+    case "assistant": {
+      const cleaned = stripScopePrefix(item.text).trim();
+      return cleaned ? truncate(cleaned, 1500) : null;
+    }
+    case "worker_error":
+      return `\u2717 *${item.project}* \u2014 ${truncate(item.message, 300)}`;
+    case "info":
+      if (item.level !== "warning" && item.level !== "error") return null;
+      return `${item.level === "error" ? "\u2717 " : "\u26A0 "}_${truncate(item.text, 300)}_`;
+    case "task_dispatch": {
+      if (item.tasks.length === 0) return null;
+      const projects = [...new Set(item.tasks.map((t) => t.project))];
+      if (item.tasks.length === 1) {
+        const t = item.tasks[0];
+        return `\u2192 *${t.project}*: ${truncate(t.title, 140)}`;
+      }
+      return `\u2192 Dispatched ${item.tasks.length} tasks across ${projects.length} project${projects.length === 1 ? "" : "s"}`;
+    }
+    case "update_notice":
+      return `\u2728 ${item.text}`;
+  }
+}
+function stripScopePrefix(text) {
+  return text.replace(/^\s*\[scope:[^\]]+\]\s*/, "");
+}
+function truncate(text, max) {
+  if (text.length <= max) return text;
+  return text.slice(0, max - 1).trimEnd() + "\u2026";
+}
+function scopePrefix(scope) {
+  if (scope === "all") return "[scope:all] ";
+  return `[scope:${scope}] `;
+}
+async function runBossServeMode(options) {
+  initLogger({
+    version: VERSION,
+    bossProvider: options.bossProvider,
+    bossModel: options.bossModel,
+    bossThinking: options.bossThinkingLevel,
+    workerProvider: options.workerProvider,
+    workerModel: options.workerModel,
+    projectCount: 0
+  });
+  const links = await loadLinks();
+  if (links.projects.length === 0) {
+    console.error(
+      source_default.hex(COLORS.error)("No linked projects.\n") + source_default.hex(COLORS.textDim)("Run ") + source_default.hex(COLORS.accent)("arcena link") + source_default.hex(COLORS.textDim)(" first to choose which projects the boss should manage.")
+    );
+    process.exit(1);
+  }
+  const projects = links.projects.map((p) => ({ name: p.name, cwd: p.cwd }));
+  await tasksStore.load();
+  const bot = new TelegramBot({
+    botToken: options.telegram.botToken,
+    allowedUserId: options.telegram.userId
+  });
+  const boss = new GGBoss({
+    bossProvider: options.bossProvider,
+    bossModel: options.bossModel,
+    bossThinkingLevel: options.bossThinkingLevel,
+    workerProvider: options.workerProvider,
+    workerModel: options.workerModel,
+    workerThinkingLevel: options.workerThinkingLevel,
+    projects
+  });
+  await boss.initialize();
+  log("INFO", "serve", "boss initialized", { projects: projects.map((p) => p.name).join(",") });
+  const allowedChatId = options.telegram.userId;
+  const pendingScopeSelections = /* @__PURE__ */ new Map();
+  const pendingModelSelections = /* @__PURE__ */ new Map();
+  let lastHistoryLen = getBossState().history.length;
+  let typingInterval = null;
+  let isStreaming = false;
+  function sendQueued(text) {
+    bot.send(allowedChatId, text).catch((err) => {
+      log("WARN", "telegram", `send failed: ${err instanceof Error ? err.message : String(err)}`);
+      bot.sendPlain(allowedChatId, text.replace(/[*_`]/g, "")).catch(() => {
+      });
+    });
+  }
+  function startTyping() {
+    if (typingInterval) return;
+    bot.sendTyping(allowedChatId).catch(() => {
+    });
+    typingInterval = setInterval(() => {
+      bot.sendTyping(allowedChatId).catch(() => {
+      });
+    }, 4e3);
+  }
+  function stopTyping() {
+    if (typingInterval) {
+      clearInterval(typingInterval);
+      typingInterval = null;
+    }
+  }
+  function flushNewItems(state) {
+    const len = state.history.length;
+    if (len <= lastHistoryLen) return;
+    const fresh = state.history.slice(lastHistoryLen);
+    lastHistoryLen = len;
+    for (const item of fresh) {
+      const formatted = formatItemForTelegram(item);
+      if (formatted) sendQueued(formatted);
+    }
+  }
+  async function applyModelChoice(target, selected) {
+    try {
+      if (target === "boss") {
+        await boss.switchBossModel(selected.provider, selected.id);
+        await saveSettings({ bossProvider: selected.provider, bossModel: selected.id });
+        await bot.send(allowedChatId, `Boss \u2192 *${selected.name}*`);
+      } else {
+        await boss.switchWorkerModel(selected.provider, selected.id);
+        await saveSettings({ workerProvider: selected.provider, workerModel: selected.id });
+        await bot.send(allowedChatId, `Workers \u2192 *${selected.name}*`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log("WARN", "model_switch", message, { target, model: selected.id });
+      await bot.send(allowedChatId, `Failed to switch ${target}: ${message}`);
+    }
+  }
+  const unsubscribe = subscribeToBossStore(() => {
+    if (getBossState().pendingFlush.length > 0) {
+      bossStore.commitPendingFlush();
+    }
+    const state = getBossState();
+    flushNewItems(state);
+    const streamingNow = state.streaming !== null;
+    if (streamingNow && !isStreaming) {
+      isStreaming = true;
+      startTyping();
+    } else if (!streamingNow && isStreaming) {
+      isStreaming = false;
+      stopTyping();
+    }
+  });
+  bot.onText(async (msg) => {
+    const { text, chatId } = msg;
+    if (chatId !== allowedChatId) return;
+    const pendingScopes = pendingScopeSelections.get(chatId);
+    if (pendingScopes && /^\s*\d+\s*$/.test(text)) {
+      pendingScopeSelections.delete(chatId);
+      const num = parseInt(text.trim(), 10);
+      if (num < 1 || num > pendingScopes.length) {
+        await bot.send(chatId, "Invalid selection. Send /scope to try again.");
+        return;
+      }
+      const chosen = pendingScopes[num - 1];
+      bossStore.setScope(chosen);
+      await bot.send(chatId, `Scope: *${chosen}*`);
+      return;
+    }
+    const pendingModel = pendingModelSelections.get(chatId);
+    if (pendingModel && /^\s*\d+\s*$/.test(text)) {
+      pendingModelSelections.delete(chatId);
+      const num = parseInt(text.trim(), 10);
+      if (num < 1 || num > pendingModel.models.length) {
+        await bot.send(chatId, "Invalid selection. Send /m to try again.");
+        return;
+      }
+      const selected = pendingModel.models[num - 1];
+      await applyModelChoice(pendingModel.target, selected);
+      return;
+    }
+    if (!text.startsWith("/")) {
+      const scoped = scopePrefix(getBossState().scope) + text;
+      boss.enqueueUserMessage(scoped);
+      return;
+    }
+    const parts = text.trim().split(/\s+/);
+    const cmd = parts[0].slice(1).toLowerCase().replace(/@\w+$/, "");
+    if (cmd === "help" || cmd === "start") {
+      await bot.send(chatId, buildTelegramHelpText());
+      return;
+    }
+    if (cmd === "m" || cmd === "model" || cmd === "model-boss" || cmd === "model-workers") {
+      const target = cmd === "model-workers" ? "workers" : "boss";
+      const arg = parts.slice(1).join(" ").trim().toLowerCase();
+      const state = getBossState();
+      const currentId = target === "boss" ? state.bossModel : state.workerModel;
+      if (arg) {
+        const num = parseInt(arg, 10);
+        let match;
+        if (!isNaN(num) && num >= 1 && num <= MODELS.length) {
+          match = MODELS[num - 1];
+        } else {
+          match = MODELS.find(
+            (m) => m.name.toLowerCase().includes(arg) || m.id.toLowerCase().includes(arg)
+          );
+        }
+        if (!match) {
+          await bot.send(chatId, `No model matching "${arg}". Send /${cmd} to see the list.`);
+          return;
+        }
+        await applyModelChoice(target, match);
+        return;
+      }
+      let listText = `*${target === "boss" ? "Boss" : "Worker"} model*
+`;
+      let lastProvider = "";
+      MODELS.forEach((m, i) => {
+        if (m.provider !== lastProvider) {
+          lastProvider = m.provider;
+          listText += `
+_${providerLabel(m.provider)}_
+`;
+        }
+        const active = m.id === currentId ? "  \u2190" : "";
+        listText += `  *${i + 1}.* ${m.name}${active}
+`;
+      });
+      listText += `
+Send the number, or \`/${cmd} <name>\`.`;
+      pendingModelSelections.set(chatId, { target, models: [...MODELS] });
+      await bot.send(chatId, listText);
+      return;
+    }
+    if (cmd === "scope" || cmd === "s") {
+      const state = getBossState();
+      const arg = parts.slice(1).join(" ").trim().toLowerCase();
+      const names = ["all", ...state.workers.map((w) => w.name)];
+      if (!arg) {
+        const lines = names.map((n, i) => {
+          const active = n === state.scope ? "  \u2190" : "";
+          const label = n === "all" ? "*All*" : `*${n}*`;
+          return `*${i + 1}.* ${label}${active}`;
+        });
+        pendingScopeSelections.set(chatId, names);
+        await bot.send(
+          chatId,
+          `*Scope*  \u2014  current: *${state.scope}*
+
+${lines.join("\n")}
+
+Send the number, or \`/scope <name>\`.`
+        );
+        return;
+      }
+      const num = parseInt(arg, 10);
+      let chosen;
+      if (!isNaN(num) && num >= 1 && num <= names.length) {
+        chosen = names[num - 1];
+      } else {
+        const exact = names.find((n) => n.toLowerCase() === arg);
+        chosen = exact ?? names.find((n) => n.toLowerCase().includes(arg)) ?? null;
+      }
+      if (!chosen) {
+        await bot.send(chatId, `No scope matching "${arg}". Send /scope to see the list.`);
+        return;
+      }
+      bossStore.setScope(chosen);
+      await bot.send(chatId, `Scope: *${chosen}*`);
+      return;
+    }
+    if (cmd === "status") {
+      const state = getBossState();
+      const lines = [`*${BRAND}* \u2014 ${state.bossModel}`, `Scope  *${state.scope}*`, ""];
+      lines.push("*Workers*");
+      for (const w of state.workers) {
+        const dot = w.status === "working" ? "\u25CF" : w.status === "error" ? "\u2717" : "\u25CB";
+        lines.push(`  ${dot} *${w.name}* \u2014 _${w.status}_`);
+      }
+      const tasks = tasksStore.list();
+      const open = tasks.filter((t) => t.status === "pending" || t.status === "in_progress").length;
+      lines.push("");
+      lines.push(`Tasks  ${open} open  \xB7  ${tasks.length} total`);
+      await bot.send(chatId, lines.join("\n"));
+      return;
+    }
+    if (cmd === "cancel") {
+      boss.abort();
+      await bot.send(chatId, "_Aborted current boss turn._");
+      return;
+    }
+    if (cmd === "new" || cmd === "n") {
+      await boss.newSession();
+      await bot.send(chatId, "\u2500\u2500 *New session* \u2500\u2500");
+      return;
+    }
+    if (cmd === "tasks") {
+      const tasks = tasksStore.list();
+      if (tasks.length === 0) {
+        await bot.send(chatId, "_No tasks._");
+        return;
+      }
+      const lines = tasks.slice(0, 30).map((t, i) => {
+        const status = t.status.replace("_", " ");
+        return `*${i + 1}.* [${status}] *${t.project}* \u2014 ${t.description.split("\n")[0]}`;
+      });
+      await bot.send(chatId, `*Tasks*
+
+${lines.join("\n")}`);
+      return;
+    }
+    boss.enqueueUserMessage(text);
+  });
+  bot.onVoice(async (msg) => {
+    const { chatId } = msg;
+    if (chatId !== allowedChatId) return;
+    try {
+      if (!isModelLoaded()) {
+        await bot.send(
+          chatId,
+          "Setting up voice transcription \u2014 downloading Whisper model. This only happens once."
+        );
+        setProgressCallback((info) => {
+          if (info.status === "progress" && info.progress !== void 0) {
+            const pct = Math.round(info.progress);
+            if (pct % 25 === 0 && pct > 0) {
+              bot.sendTyping(chatId).catch(() => {
+              });
+            }
+          }
+        });
+      }
+      await bot.sendTyping(chatId);
+      const fileUrl = await bot.getFileUrl(msg.fileId);
+      const transcribed = await transcribeVoice(fileUrl);
+      if (!transcribed) {
+        await bot.send(chatId, "_Could not transcribe voice note._");
+        return;
+      }
+      await bot.send(chatId, `_Voice: "${transcribed}"_`);
+      const scoped = scopePrefix(getBossState().scope) + transcribed;
+      boss.enqueueUserMessage(scoped);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log("ERROR", "voice", message);
+      const hint = /Cannot find module|Cannot resolve|MODULE_NOT_FOUND/.test(message) ? "\n\nVoice transcription needs the optional `@huggingface/transformers` and `ogg-opus-decoder` packages. Reinstall with `npm i -g @iroaxel/arcena` and ensure optional deps installed." : "";
+      await bot.send(chatId, `_Voice transcription failed: ${message}_${hint}`);
+    }
+  });
+  process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+  printBanner({
+    bossModel: options.bossModel,
+    workerModel: options.workerModel,
+    userId: options.telegram.userId,
+    projectCount: projects.length
+  });
+  let shuttingDown = false;
+  const shutdown = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    console.log(source_default.hex(COLORS.textDim)("\nShutting down..."));
+    bot.stop();
+    stopTyping();
+    unsubscribe();
+    await boss.dispose().catch(() => {
+    });
+    closeLogger();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => void shutdown());
+  process.on("SIGTERM", () => void shutdown());
+  const runPromise = boss.run().catch((err) => {
+    log("ERROR", "boss", err instanceof Error ? err.message : String(err));
+  });
+  await bot.start();
+  await runPromise;
+}
+function buildTelegramHelpText() {
+  return [
+    "*ARCena* \u2014 orchestrator over Telegram",
+    "",
+    "*Commands*",
+    "/scope (/s) \u2014 switch project focus (All / per-worker)",
+    "/m, /model-boss \u2014 switch the orchestrator's model",
+    "/model-workers \u2014 switch every worker's model",
+    "/status \u2014 workers + open tasks",
+    "/tasks \u2014 list tasks",
+    "/new \u2014 fresh boss session",
+    "/cancel \u2014 abort the current boss turn",
+    "/help \u2014 this message",
+    "",
+    "Voice notes are transcribed locally with Whisper and sent as prompts.",
+    "Send any message to talk to the boss."
+  ].join("\n");
+}
+function providerLabel(provider) {
+  switch (provider) {
+    case "anthropic":
+      return "Anthropic";
+    case "openai":
+      return "OpenAI";
+    case "glm":
+      return "Z.AI";
+    case "moonshot":
+      return "Moonshot";
+    case "minimax":
+      return "MiniMax";
+    case "deepseek":
+      return "DeepSeek";
+    case "openrouter":
+      return "OpenRouter";
+    case "xiaomi":
+      return "Xiaomi";
+    default:
+      return provider;
+  }
+}
+function gradientText(text) {
+  let i = 0;
+  return text.split("").map((ch) => ch === " " ? ch : source_default.hex(GRADIENT[i++ % GRADIENT.length])(ch)).join("");
+}
+function printBanner(opts) {
+  console.log();
+  console.log(
+    `  ${gradientText(LOGO_LINES[0])}${LOGO_GAP}` + source_default.hex(COLORS.primary).bold(BRAND) + source_default.hex(COLORS.textDim)(` v${VERSION}`) + source_default.hex(COLORS.textDim)(" \xB7 By ") + source_default.white.bold(AUTHOR)
+  );
+  console.log(
+    `  ${gradientText(LOGO_LINES[1])}${LOGO_GAP}` + source_default.hex(COLORS.accent)(`Boss: ${opts.bossModel}`)
+  );
+  console.log(
+    `  ${gradientText(LOGO_LINES[2])}${LOGO_GAP}` + source_default.hex(COLORS.textDim)(`Workers: ${opts.workerModel}`)
+  );
+  console.log();
+  console.log(
+    source_default.hex(COLORS.textDim)("  Mode      ") + source_default.hex(COLORS.accent)("Telegram") + source_default.hex(COLORS.textDim)("  \xB7  User ") + source_default.white(String(opts.userId)) + source_default.hex(COLORS.textDim)(
+      `  \xB7  ${opts.projectCount} project${opts.projectCount === 1 ? "" : "s"}`
+    )
+  );
+  console.log();
+  console.log(
+    source_default.hex(COLORS.success)("  Ready. ") + source_default.hex(COLORS.textDim)("Open Telegram and message your bot.")
+  );
+  console.log();
+  console.log(
+    source_default.hex(COLORS.textDim)("  /help  ") + source_default.hex(COLORS.textDim)("commands") + source_default.hex(COLORS.textDim)("    /status  ") + source_default.hex(COLORS.textDim)("workers + tasks") + source_default.hex(COLORS.textDim)("    /cancel  ") + source_default.hex(COLORS.textDim)("abort turn")
+  );
+  console.log();
+}
+
+// src/telegram-setup.ts
+init_esm_shims();
+import readline2 from "readline/promises";
+async function runBossTelegramSetup() {
+  process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+  printSetupBanner();
+  const existing = await loadBossTelegramConfig();
+  if (existing) {
+    console.log(
+      source_default.hex(COLORS.textDim)("  Current config:\n") + source_default.hex(COLORS.textDim)(
+        `    Bot token: ${existing.botToken.slice(0, 10)}...${existing.botToken.slice(-4)}
+`
+      ) + source_default.hex(COLORS.textDim)(`    User ID:   ${existing.userId}
+`)
+    );
+  }
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    console.log(
+      source_default.hex(COLORS.accent)("  Step 1: Bot Token\n") + source_default.hex(COLORS.textDim)("    1. Open BotFather: ") + source_default.hex(COLORS.primary).underline("https://t.me/BotFather") + "\n" + source_default.hex(COLORS.textDim)("    2. Send /newbot and follow the prompts\n") + source_default.hex(COLORS.textDim)("    3. Copy the bot token\n")
+    );
+    const tokenPrompt = existing ? source_default.hex(COLORS.primary)("  Paste bot token (enter to keep current): ") : source_default.hex(COLORS.primary)("  Paste bot token: ");
+    const tokenInput = await rl.question(tokenPrompt);
+    const botToken = tokenInput.trim() || existing?.botToken;
+    if (!botToken) {
+      console.log(source_default.hex(COLORS.error)("\n  No bot token provided. Setup cancelled."));
+      return;
+    }
+    if (!/^\d+:[A-Za-z0-9_-]+$/.test(botToken)) {
+      console.log(
+        source_default.hex(COLORS.error)("\n  Invalid token format. Expected: 123456789:ABCdef...")
+      );
+      return;
+    }
+    console.log(
+      source_default.hex(COLORS.accent)("\n  Step 2: User ID\n") + source_default.hex(COLORS.textDim)("    1. Open userinfobot: ") + source_default.hex(COLORS.primary).underline("https://t.me/userinfobot") + "\n" + source_default.hex(COLORS.textDim)("    2. Send any message \u2014 it replies with your numeric ID\n") + source_default.hex(COLORS.textDim)("    Only this user ID can control the boss.\n")
+    );
+    const userPrompt = existing ? source_default.hex(COLORS.primary)(`  Your Telegram user ID (enter to keep ${existing.userId}): `) : source_default.hex(COLORS.primary)("  Your Telegram user ID: ");
+    const userInput = await rl.question(userPrompt);
+    const userId = userInput.trim() ? parseInt(userInput.trim(), 10) : existing?.userId;
+    if (!userId || isNaN(userId)) {
+      console.log(source_default.hex(COLORS.error)("\n  Invalid user ID. Must be a number."));
+      return;
+    }
+    console.log(source_default.hex(COLORS.textDim)("\n  Verifying bot token..."));
+    const verifyRes = await fetch(`https://api.telegram.org/bot${botToken}/getMe`, {
+      method: "POST"
+    });
+    const verifyData = await verifyRes.json();
+    if (!verifyData.ok || !verifyData.result) {
+      console.log(
+        source_default.hex(COLORS.error)(
+          "\n  Invalid bot token \u2014 Telegram rejected it. Check and try again."
+        )
+      );
+      return;
+    }
+    const config = { botToken, userId };
+    await saveBossTelegramConfig(config);
+    console.log(
+      source_default.hex(COLORS.success)(
+        `
+  \u2713 Connected to @${verifyData.result.username} (${verifyData.result.first_name})
+`
+      ) + source_default.hex(COLORS.success)(`  \u2713 Authorized user ID: ${userId}
+
+`) + source_default.hex(COLORS.primary)("  To start:\n") + source_default.hex(COLORS.textDim)("    arcena serve\n")
+    );
+  } finally {
+    rl.close();
+  }
+}
+function gradientText2(text) {
+  let i = 0;
+  return text.split("").map((ch) => ch === " " ? ch : source_default.hex(GRADIENT[i++ % GRADIENT.length])(ch)).join("");
+}
+function printSetupBanner() {
+  console.log();
+  console.log(
+    `  ${gradientText2(LOGO_LINES[0])}${LOGO_GAP}` + source_default.hex(COLORS.primary).bold(BRAND) + source_default.hex(COLORS.textDim)(` v${VERSION}`) + source_default.hex(COLORS.textDim)(" \xB7 By ") + source_default.white.bold(AUTHOR)
+  );
+  console.log(
+    `  ${gradientText2(LOGO_LINES[1])}${LOGO_GAP}` + source_default.hex(COLORS.accent)("Telegram Setup")
+  );
+  console.log(
+    `  ${gradientText2(LOGO_LINES[2])}${LOGO_GAP}` + source_default.hex(COLORS.textDim)("Remote Control")
+  );
+  console.log();
+}
+
+// src/orchestrator-app.tsx
+init_esm_shims();
+var import_react11 = __toESM(require_react(), 1);
+
+// ../ggcoder/dist/ui/components/index.js
+init_esm_shims();
+
+// ../ggcoder/dist/ui/components/DiffView.js
+init_esm_shims();
+var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
+var import_react3 = __toESM(require_react(), 1);
+
+// ../ggcoder/dist/ui/components/Overlay.js
+init_esm_shims();
+var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
+var import_react4 = __toESM(require_react(), 1);
+
+// ../ggcoder/dist/ui/components/SessionSelector.js
+init_esm_shims();
+var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
+var import_react5 = __toESM(require_react(), 1);
+
+// ../ggcoder/dist/ui/components/SettingsSelector.js
+init_esm_shims();
+var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1);
+var import_react6 = __toESM(require_react(), 1);
+
+// ../ggcoder/dist/ui/components/ThinkingIndicator.js
+init_esm_shims();
+var import_jsx_runtime7 = __toESM(require_jsx_runtime(), 1);
+var import_react7 = __toESM(require_react(), 1);
+
+// src/boss-footer.tsx
+init_esm_shims();
+var import_react8 = __toESM(require_react(), 1);
+var import_jsx_runtime8 = __toESM(require_jsx_runtime(), 1);
+var PARTIAL_BLOCKS = [" ", "\u258F", "\u258E", "\u258D", "\u258C", "\u258B", "\u258A", "\u2589", "\u2588"];
+var LIGHT_SHADE = "\u2591";
+var SHORT_MODELS = {
+  "claude-opus-4-7": "Opus",
+  "claude-sonnet-4-6": "Sonnet",
+  "claude-haiku-4-5": "Haiku",
+  "claude-haiku-4-5-20251001": "Haiku",
+  "gpt-5.5": "GPT-5.5",
+  "gpt-5.5-pro": "GPT-5.5 Pro",
+  "gpt-5.4": "GPT-5.4",
+  "gpt-5.4-mini": "GPT-5.4 Mini",
+  "gpt-5.3-codex": "GPT-5.3 Codex"
+};
+function shortModel(model) {
+  return SHORT_MODELS[model] ?? model;
+}
+function getContextPercent(model, tokensIn) {
+  const limit = getContextWindow(model);
+  if (!limit || tokensIn === 0) return 0;
+  return Math.round(tokensIn / limit * 100);
+}
+var SHORT_RADIO = {
+  "somafm-groove-salad": "Groove Salad",
+  "somafm-drone-zone": "Drone Zone",
+  "radio-paradise": "Radio Paradise",
+  "george-fm": "George FM"
+};
+function BossFooter({
+  bossModel,
+  workerModel,
+  tokensIn,
+  exitPending,
+  bossThinkingLevel,
+  updatePending,
+  currentRadioStationId
+}) {
+  const theme = useTheme();
+  const { columns } = useTerminalSize();
+  if (exitPending) {
+    return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Box_default, { paddingX: 1, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Text, { color: theme.warning, children: "Press Ctrl+C again to exit" }) });
+  }
+  const contextPct = getContextPercent(bossModel, tokensIn);
+  const contextColor = contextPct >= 80 ? theme.error : contextPct >= 50 ? theme.warning : theme.success;
+  const sep = /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Text, { color: theme.border, children: " \u2502 " });
+  const barWidth = 8;
+  const fillFloat = Math.min(contextPct / 100 * barWidth, barWidth);
+  const barChars = [];
+  for (let i = 0; i < barWidth; i++) {
+    const cellFill = Math.max(0, Math.min(1, fillFloat - i));
+    const eighths = Math.round(cellFill * 8);
+    if (eighths === 8) {
+      barChars.push(
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Text, { color: contextColor, children: PARTIAL_BLOCKS[8] }, i)
+      );
+    } else if (eighths > 0) {
+      barChars.push(
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Text, { color: contextColor, children: PARTIAL_BLOCKS[eighths] }, i)
+      );
+    } else {
+      barChars.push(
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Text, { color: theme.textDim, children: LIGHT_SHADE }, i)
+      );
+    }
+  }
+  const radioName = currentRadioStationId ? SHORT_RADIO[currentRadioStationId] ?? currentRadioStationId : null;
+  const bossM = shortModel(bossModel);
+  const wkrM = shortModel(workerModel);
+  const estFull = 2 + 12 + // bar + " 99%"
+  3 + 5 + bossM.length + // " │ boss <model>"
+  3 + 8 + wkrM.length + // " │ workers <model>"
+  3 + 12 + // " │ Thinking off"
+  (radioName ? 3 + 2 + radioName.length : 0) + // " │ ♪ Name"
+  (updatePending ? 3 + 28 : 0);
+  const dropLabels = estFull > columns;
+  const dropThinking = estFull > columns + 14;
+  const useShortUpdate = updatePending && estFull > columns + 6;
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(Box_default, { paddingX: 1, width: columns, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Box_default, { flexGrow: 1 }),
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(Box_default, { flexShrink: 0, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Text, { children: barChars }),
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(Text, { color: contextColor, children: [
+        " ",
+        contextPct,
+        "%"
+      ] }),
+      sep,
+      !dropLabels && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Text, { color: theme.textDim, children: "boss " }),
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Text, { color: COLORS.primary, bold: true, children: bossM }),
+      sep,
+      !dropLabels && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Text, { color: theme.textDim, children: "workers " }),
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Text, { color: COLORS.accent, bold: true, children: wkrM }),
+      !dropThinking && /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_jsx_runtime8.Fragment, { children: [
+        sep,
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Text, { color: bossThinkingLevel ? theme.accent : theme.textDim, children: bossThinkingLevel ? "Thinking on" : "Thinking off" })
+      ] }),
+      radioName && /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_jsx_runtime8.Fragment, { children: [
+        sep,
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(Text, { color: theme.secondary ?? theme.accent, children: [
+          "\u266A ",
+          radioName
+        ] })
+      ] }),
+      updatePending && /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_jsx_runtime8.Fragment, { children: [
+        sep,
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Text, { color: theme.success, bold: true, wrap: "truncate", children: useShortUpdate ? "Update ready" : "Update ready. Restart ARCena." })
+      ] })
+    ] })
+  ] });
+}
+
+// src/slash-commands.ts
+init_esm_shims();
+var BOSS_SLASH_COMMANDS = [
+  { name: "help", aliases: ["?"], description: "Show available commands" },
+  { name: "model-boss", aliases: [], description: "Switch the orchestrator's model" },
+  { name: "model-workers", aliases: [], description: "Switch every worker's model" },
+  { name: "compact", aliases: [], description: "Compact the boss's context now" },
+  { name: "clear", aliases: [], description: "Clear chat history and terminal" },
+  { name: "radio", aliases: [], description: "Stream a free internet radio station" },
+  { name: "quit", aliases: ["q", "exit"], description: "Exit arcena" }
+];
+function isSlashCommand(value) {
+  return value.startsWith("/") && !value.startsWith("//");
+}
+function parseSlash(value) {
+  if (!isSlashCommand(value)) return null;
+  const rest = value.slice(1).trim();
+  if (!rest) return null;
+  const space = rest.indexOf(" ");
+  if (space === -1) return { name: rest.toLowerCase(), args: "" };
+  return { name: rest.slice(0, space).toLowerCase(), args: rest.slice(space + 1).trim() };
+}
+function canonicalName(name) {
+  for (const cmd of BOSS_SLASH_COMMANDS) {
+    if (cmd.name === name) return cmd.name;
+    if (cmd.aliases.includes(name)) return cmd.name;
+  }
+  return null;
+}
+function buildHelpText() {
+  const lines = ["**arcena commands**", ""];
+  for (const cmd of BOSS_SLASH_COMMANDS) {
+    const aliases = cmd.aliases.length > 0 ? ` (${cmd.aliases.map((a) => "/" + a).join(", ")})` : "";
+    lines.push(`- \`/${cmd.name}\`${aliases} \u2014 ${cmd.description}`);
+  }
+  lines.push("");
+  lines.push("**Global keybindings**");
+  lines.push("- `Ctrl+T` \u2014 open the Tasks pane");
+  lines.push("- `Tab` \u2014 switch project scope (All / per-project pill in the input)");
+  lines.push("- `Shift+Tab` \u2014 toggle the boss's extended thinking on/off");
+  lines.push("- `Esc` \u2014 interrupt the boss while it's running");
+  lines.push("- `Ctrl+C` (twice) \u2014 exit");
+  lines.push("");
+  lines.push("**Inside the Tasks pane (Ctrl+T)**");
+  lines.push("- `\u2191` / `\u2193` (or `k` / `j`) \u2014 navigate tasks");
+  lines.push("- `r` \u2014 run all pending and blocked tasks across idle workers");
+  lines.push("- `d` \u2014 delete the selected task");
+  lines.push("- `Esc` \u2014 close the Tasks pane");
+  lines.push("");
+  lines.push("**Inside model pickers (`/model-boss`, `/model-workers`)**");
+  lines.push("- `\u2191` / `\u2193` \u2014 navigate models");
+  lines.push("- `Enter` \u2014 select");
+  lines.push("- `Esc` \u2014 cancel");
+  lines.push("");
+  lines.push("**Radio** (`/radio`)");
+  lines.push("- Pick a station to stream while you work, or select `Off` to stop.");
+  lines.push("- Requires `mpv` (recommended), `ffplay`, `mpg123`, or `vlc/cvlc` installed.");
+  lines.push("");
+  lines.push("**Input area**");
+  lines.push("- `\u2191` / `\u2193` \u2014 recall previous prompts (when input is empty)");
+  lines.push("- `Enter` \u2014 send  \xB7  `Shift+Enter` \u2014 newline");
+  lines.push("- `/` \u2014 open the slash-command menu (Tab / arrows to pick, Enter to insert)");
+  return lines.join("\n");
+}
+
+// src/tool-formatters.ts
+init_esm_shims();
+
+// src/colors.ts
+init_esm_shims();
+var PROJECT_COLORS = [
+  "#60a5fa",
+  // blue
+  "#a78bfa",
+  // violet
+  "#4ade80",
+  // green
+  "#fbbf24",
+  // amber
+  "#f472b6",
+  // pink
+  "#22d3ee",
+  // cyan
+  "#fb923c",
+  // orange
+  "#34d399"
+  // emerald
+];
+function stableHash(s) {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) {
+    h = h * 31 + s.charCodeAt(i) | 0;
+  }
+  return Math.abs(h);
+}
+function projectColor(name) {
+  return PROJECT_COLORS[stableHash(name) % PROJECT_COLORS.length];
+}
+
+// src/tool-formatters.ts
+function truncate2(s, max) {
+  if (max <= 1) return "\u2026";
+  return s.length > max ? s.slice(0, max - 1) + "\u2026" : s;
+}
+function promptWorkerDetailLen(project) {
+  const cols = process.stdout.columns ?? 80;
+  const fixed = 2 + 13 + 1 + project.length + 3 + 1 + 1 + 11 + 6;
+  return Math.max(20, cols - fixed);
+}
+var bossToolFormatters = {
+  formatLabel(name) {
+    switch (name) {
+      case "list_workers":
+        return "List Workers";
+      case "get_worker_status":
+        return "Worker Status";
+      case "prompt_worker":
+        return "Prompt Worker";
+      case "get_worker_summary":
+        return "Worker Summary";
+      default:
+        return void 0;
+    }
+  },
+  formatDetail(name, args) {
+    switch (name) {
+      case "list_workers":
+        return "";
+      case "get_worker_status":
+      case "get_worker_summary":
+        return truncate2(String(args.project ?? ""), 40);
+      case "prompt_worker": {
+        const project = String(args.project ?? "");
+        const message = String(args.message ?? "").replace(/\s+/g, " ");
+        const fresh = args.fresh === true;
+        const maxMsg = promptWorkerDetailLen(project) - (fresh ? 8 : 0);
+        const truncMsg = truncate2(message, Math.max(15, maxMsg));
+        const head = fresh ? "fresh \xB7 " : "";
+        return project ? `${head}${project} \xB7 ${truncMsg}` : `${head}${truncMsg}`;
+      }
+      default:
+        return void 0;
+    }
+  },
+  formatInline(name, result, isError) {
+    if (isError) return void 0;
+    switch (name) {
+      case "list_workers": {
+        const lines = result.split("\n").filter((l) => l.startsWith("-"));
+        return `${lines.length} worker${lines.length === 1 ? "" : "s"}`;
+      }
+      case "prompt_worker": {
+        if (result.includes("currently working")) {
+          return { text: "busy \u2014 skipped", color: "#fbbf24" };
+        }
+        if (result.includes("Unknown project")) {
+          return { text: "unknown project", color: "#f87171" };
+        }
+        const project = String(result.match(/"([^"]+)"/)?.[1] ?? "");
+        const color = project ? projectColor(project) : "#e11d48";
+        return { text: "dispatched", color };
+      }
+      case "get_worker_status": {
+        const parts = result.split(":");
+        if (parts.length < 2) return void 0;
+        const status = parts.slice(1).join(":").trim();
+        const project = parts[0].trim();
+        return { text: status, color: projectColor(project) };
+      }
+      case "get_worker_summary": {
+        const turnMatch = result.match(/Turn:\s*(\d+)/);
+        const projectMatch = result.match(/Project:\s*(.+)/);
+        const toolsMatch = result.match(/Tools used:\s*(.+)/);
+        const tools = toolsMatch ? toolsMatch[1] : "";
+        const toolCount = tools && tools !== "(no tools used)" ? tools.split(",").length : 0;
+        const turn = turnMatch ? `turn ${turnMatch[1]}` : void 0;
+        const tCount = toolCount > 0 ? `${toolCount} tool${toolCount === 1 ? "" : "s"}` : void 0;
+        const summary = [turn, tCount].filter(Boolean).join(" \xB7 ");
+        if (!summary) return void 0;
+        const project = projectMatch ? projectMatch[1].trim() : "";
+        return project ? { text: summary, color: projectColor(project) } : { text: summary, color: "#9ca3af" };
+      }
+      default:
+        return void 0;
+    }
+  }
+};
+
+// src/boss-phrases.ts
+init_esm_shims();
+var BOSS_PHRASES = {
+  // Generic between-states fallback. Probably never shown but keep for safety.
+  idle: ["Standing by", "Waiting for orders", "On call"],
+  // Boss has issued a request, waiting for the LLM to begin streaming.
+  waiting: [
+    "Briefing",
+    "Reviewing the room",
+    "Triaging",
+    "Lining up the brief",
+    "Surveying projects",
+    "Reading the room",
+    "Picking the right hand",
+    "Marshalling thoughts",
+    "Checking the board",
+    "Sizing up the work"
+  ],
+  // LLM is mid-thinking-block (extended reasoning).
+  thinking: [
+    "Strategising",
+    "Plotting next move",
+    "Weighing options",
+    "Reasoning",
+    "Deliberating",
+    "Thinking it through",
+    "Mapping the play",
+    "Considering angles",
+    "Calculating odds",
+    "Drafting the call"
+  ],
+  // LLM is streaming text — boss is forming its dispatch / response.
+  generating: [
+    "Drafting",
+    "Composing dispatch",
+    "Writing the brief",
+    "Penning instructions",
+    "Wording it up",
+    "Putting it on paper",
+    "Phrasing the ask",
+    "Forming the directive",
+    "Scripting the plan"
+  ],
+  // Boss is invoking a tool — most often prompt_worker.
+  tools: [
+    "Coordinating",
+    "Dispatching",
+    "Routing",
+    "Delegating",
+    "Issuing orders",
+    "Handing off",
+    "Aligning workers",
+    "Conducting",
+    "Calling the team",
+    "Steering",
+    "Pulling levers"
+  ],
+  // Provider retry (overloaded / rate-limited / etc.).
+  retrying: [
+    "Reattempting",
+    "Course correcting",
+    "Trying again",
+    "Pushing through",
+    "Holding the line"
+  ]
+};
+
+// src/boss-tasks-overlay.tsx
+init_esm_shims();
+var import_react9 = __toESM(require_react(), 1);
+var import_jsx_runtime9 = __toESM(require_jsx_runtime(), 1);
+function statusGlyph(status) {
+  switch (status) {
+    case "done":
+      return "\u2713";
+    case "in_progress":
+      return "~";
+    case "blocked":
+      return "\u2717";
+    case "skipped":
+      return "\u2014";
+    default:
+      return " ";
+  }
+}
+function BossTasksOverlay({
+  boss,
+  workers,
+  onClose
+}) {
+  const theme = useTheme();
+  const tasksState = useTasksState();
+  const tasks = tasksState.tasks;
+  const [selectedIndex, setSelectedIndex] = (0, import_react9.useState)(0);
+  const [status, setStatusMsg] = (0, import_react9.useState)("");
+  const statusTimer = (0, import_react9.useRef)(null);
+  const showStatus = (0, import_react9.useCallback)((msg) => {
+    setStatusMsg(msg);
+    if (statusTimer.current) clearTimeout(statusTimer.current);
+    statusTimer.current = setTimeout(() => setStatusMsg(""), 2500);
+  }, []);
+  const groupedTasks = workers.map((w) => ({
+    project: w.name,
+    tasks: tasks.filter((t) => t.project === w.name).sort((a, b) => a.createdAt.localeCompare(b.createdAt))
+  }));
+  const flatTasks = groupedTasks.flatMap((g) => g.tasks);
+  (0, import_react9.useEffect)(() => {
+    if (flatTasks.length === 0) {
+      setSelectedIndex(0);
+    } else if (selectedIndex >= flatTasks.length) {
+      setSelectedIndex(flatTasks.length - 1);
+    }
+  }, [flatTasks.length, selectedIndex]);
+  const selected = flatTasks[selectedIndex];
+  const MAX_VISIBLE = 12;
+  const startIdx = Math.max(
+    0,
+    Math.min(flatTasks.length - MAX_VISIBLE, selectedIndex - MAX_VISIBLE + 1, selectedIndex)
+  );
+  const endIdx = Math.min(flatTasks.length, startIdx + MAX_VISIBLE);
+  const visibleIdSet = new Set(flatTasks.slice(startIdx, endIdx).map((t) => t.id));
+  const showingTop = startIdx > 0;
+  const showingBottom = endIdx < flatTasks.length;
+  use_input_default((input, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (key.upArrow || input === "k") {
+      setSelectedIndex((i) => Math.max(0, i - 1));
+      return;
+    }
+    if (key.downArrow || input === "j") {
+      setSelectedIndex((i) => Math.min(flatTasks.length - 1, i + 1));
+      return;
+    }
+    if (input === "d" && selected) {
+      void tasksStore.remove(selected.id).then(() => showStatus("Deleted"));
+      return;
+    }
+    if (input === "r") {
+      onClose();
+      void (async () => {
+        const dispatched = [];
+        for (const w of workers) {
+          const next = tasksStore.nextDispatchable(w.name);
+          if (!next) continue;
+          if (next.status === "blocked") {
+            await tasksStore.update(next.id, { status: "pending", notes: void 0 });
+          }
+          const res = await boss.dispatchTaskById(next.id);
+          if (res.ok) dispatched.push({ project: w.name, title: next.title });
+        }
+        if (dispatched.length === 0) {
+          bossStore.appendInfo("No pending or blocked tasks to run.", "info");
+        } else {
+          bossStore.appendTaskDispatch(dispatched);
+        }
+      })();
+      return;
+    }
+  });
+  const doneCount = tasks.filter((t) => t.status === "done").length;
+  const inProgressCount = tasks.filter((t) => t.status === "in_progress").length;
+  const pendingCount = tasks.filter((t) => t.status === "pending").length;
+  const blockedCount = tasks.filter((t) => t.status === "blocked").length;
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(Box_default, { flexDirection: "column", marginTop: 1, paddingX: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(Box_default, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Text, { color: COLORS.primary, bold: true, children: "Tasks" }),
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Text, { color: theme.textDim, children: `  \xB7  ${tasks.length} total  \xB7  ` }),
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+        CountsRow,
+        {
+          theme,
+          done: doneCount,
+          active: inProgressCount,
+          pending: pendingCount,
+          blocked: blockedCount
+        }
+      )
+    ] }),
+    flatTasks.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Box_default, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(Text, { color: theme.textDim, children: [
+      "  No tasks yet. Ask the boss to plan some \u2014 e.g. ",
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Text, { color: theme.text, children: '"plan some work"' }),
+      "."
+    ] }) }),
+    showingTop && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Text, { color: theme.textDim, children: `  \u2191 ${startIdx} more above` }),
+    groupedTasks.map((group, gIdx) => {
+      const startInFlat = groupedTasks.slice(0, gIdx).reduce((acc, g) => acc + g.tasks.length, 0);
+      const visibleInSection = group.tasks.filter((t) => visibleIdSet.has(t.id));
+      if (visibleInSection.length === 0) return null;
+      return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(Box_default, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(Text, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Text, { color: projectColor(group.project), bold: true, children: group.project }),
+          /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Text, { color: theme.textDim, children: ` \xB7 ${group.tasks.length}` })
+        ] }),
+        visibleInSection.map((task) => {
+          const realIdx = startInFlat + group.tasks.indexOf(task);
+          const isSelected = realIdx === selectedIndex;
+          const prefix = isSelected ? "\u276F " : "  ";
+          const glyph = statusGlyph(task.status);
+          const color = isSelected ? theme.primary : task.status === "done" ? theme.success : task.status === "in_progress" ? theme.warning : task.status === "blocked" ? theme.error : theme.text;
+          return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(Text, { color, bold: isSelected, children: [
+            prefix,
+            "[",
+            glyph,
+            "] ",
+            task.title
+          ] }, task.id);
+        })
+      ] }, group.project);
+    }),
+    showingBottom && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Text, { color: theme.textDim, children: `  \u2193 ${flatTasks.length - endIdx} more below` }),
+    status && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Box_default, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Text, { color: theme.success, children: " " + status }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Box_default, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(Text, { color: theme.textDim, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Text, { color: theme.primary, children: "\u2191\u2193" }),
+      " move \xB7 (",
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Text, { color: theme.primary, children: "d" }),
+      ")elete \xB7 (",
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Text, { color: theme.primary, children: "r" }),
+      ")un pending \xB7 ",
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Text, { color: theme.primary, children: "ESC" }),
+      " close"
+    ] }) })
+  ] });
+}
+function CountsRow({
+  theme,
+  done,
+  active,
+  pending,
+  blocked
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(Text, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(Text, { color: theme.success, children: [
+      done,
+      " done"
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Text, { color: theme.textDim, children: " \xB7 " }),
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(Text, { color: theme.warning, children: [
+      active,
+      " active"
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Text, { color: theme.textDim, children: " \xB7 " }),
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(Text, { color: theme.text, children: [
+      pending,
+      " pending"
+    ] }),
+    blocked > 0 && /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_jsx_runtime9.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Text, { color: theme.textDim, children: " \xB7 " }),
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(Text, { color: theme.error, children: [
+        blocked,
+        " blocked"
+      ] })
+    ] })
+  ] });
+}
+
+// src/radio-picker.tsx
+init_esm_shims();
+var import_react10 = __toESM(require_react(), 1);
+
+// src/radio.ts
+init_esm_shims();
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+var RADIO_STATIONS = [
+  {
+    id: "somafm-groove-salad",
+    name: "SomaFM \xB7 Groove Salad",
+    description: "Chilled downtempo, ambient grooves",
+    url: "http://ice1.somafm.com/groovesalad-128-mp3"
+  },
+  {
+    id: "somafm-drone-zone",
+    name: "SomaFM \xB7 Drone Zone",
+    description: "Atmospheric textures with minimal beats",
+    url: "http://ice1.somafm.com/dronezone-128-mp3"
+  },
+  {
+    id: "radio-paradise",
+    name: "Radio Paradise",
+    description: "Eclectic mix \u2014 rock, electronica, jazz",
+    url: "http://stream.radioparadise.com/mp3-128"
+  },
+  {
+    id: "george-fm",
+    name: "George FM",
+    description: "NZ dance + electronic",
+    url: "https://mediaworks.streamguys1.com/george_net_icy"
+  }
+];
+var PLAYERS = [
+  { cmd: "mpv", args: (u) => ["--really-quiet", "--no-video", "--no-terminal", u] },
+  {
+    cmd: "ffplay",
+    args: (u) => ["-nodisp", "-autoexit", "-loglevel", "quiet", u]
+  },
+  { cmd: "mpg123", args: (u) => ["-q", u] },
+  { cmd: "cvlc", args: (u) => ["--play-and-exit", "--quiet", u] }
+];
+var currentChild = null;
+var currentStationId = null;
+function getCurrentStation() {
+  return currentStationId;
+}
+function stopRadio() {
+  if (!currentChild) return;
+  try {
+    if (process.platform !== "win32" && currentChild.pid) {
+      try {
+        process.kill(-currentChild.pid, "SIGTERM");
+      } catch {
+        currentChild.kill("SIGTERM");
+      }
+    } else {
+      currentChild.kill("SIGTERM");
+    }
+  } catch {
+  }
+  currentChild = null;
+  currentStationId = null;
+  log("INFO", "radio", "stopped");
+}
+function isWsl() {
+  if (process.platform !== "linux") return false;
+  return !!process.env.WSL_DISTRO_NAME || existsSync("/proc/sys/fs/binfmt_misc/WSLInterop");
+}
+function tryPlayOnWindowsHost(station) {
+  const allowedUrls = new Set(RADIO_STATIONS.map((s) => s.url));
+  if (!allowedUrls.has(station.url)) return null;
+  if (!/^https?:\/\//i.test(station.url)) return null;
+  const psScript = [
+    "Add-Type -AssemblyName presentationCore;",
+    "Add-Type -AssemblyName WindowsBase;",
+    "$p = New-Object System.Windows.Media.MediaPlayer;",
+    "$p.Open([uri]$env:GGBOSS_RADIO_URL);",
+    "$p.Play();",
+    "[System.Windows.Threading.Dispatcher]::Run();"
+  ].join(" ");
+  try {
+    const child = spawn(
+      "powershell.exe",
+      ["-NoProfile", "-WindowStyle", "Hidden", "-Command", psScript],
+      {
+        detached: true,
+        stdio: "ignore",
+        env: {
+          ...process.env,
+          GGBOSS_RADIO_URL: station.url,
+          WSLENV: (process.env.WSLENV ? process.env.WSLENV + ":" : "") + "GGBOSS_RADIO_URL"
+        }
+      }
+    );
+    return child;
+  } catch {
+    return null;
+  }
+}
+function playRadio(stationId) {
+  const station = RADIO_STATIONS.find((s) => s.id === stationId);
+  if (!station) return { ok: false, error: `Unknown station: ${stationId}` };
+  stopRadio();
+  if (isWsl()) {
+    const child = tryPlayOnWindowsHost(station);
+    if (child) {
+      let errored = false;
+      child.once("error", () => {
+        errored = true;
+      });
+      if (child.pid && !errored) {
+        currentChild = child;
+        currentStationId = stationId;
+        log("INFO", "radio", "playing", {
+          station: station.id,
+          player: "powershell.exe (wsl\u2192host)",
+          url: station.url
+        });
+        child.unref();
+        return { ok: true };
+      }
+    }
+  }
+  for (const player of PLAYERS) {
+    try {
+      const child = spawn(player.cmd, player.args(station.url), {
+        detached: process.platform !== "win32",
+        stdio: "ignore"
+      });
+      let errored = false;
+      child.once("error", () => {
+        errored = true;
+      });
+      if (child.pid && !errored) {
+        currentChild = child;
+        currentStationId = stationId;
+        log("INFO", "radio", "playing", {
+          station: station.id,
+          player: player.cmd,
+          url: station.url
+        });
+        child.unref();
+        return { ok: true };
+      }
+    } catch {
+    }
+  }
+  log("WARN", "radio", "no compatible player found", { platform: process.platform });
+  return {
+    ok: false,
+    error: buildInstallHint()
+  };
+}
+function buildInstallHint() {
+  const base = "Radio needs a streaming player. Install one of: mpv (recommended), ffplay, mpg123, or vlc.";
+  switch (process.platform) {
+    case "darwin":
+      return `${base} On macOS: \`brew install mpv\` (or \`brew install ffmpeg\` for ffplay).`;
+    case "linux":
+      return `${base} On Linux (Debian/Ubuntu): \`sudo apt install mpv\`. Fedora: \`sudo dnf install mpv\`. Arch: \`sudo pacman -S mpv\`.`;
+    case "win32":
+      return `${base} On Windows: \`winget install mpv.mpv\` (or download from https://mpv.io).`;
+    default:
+      return `${base} See https://mpv.io for platform installation instructions.`;
+  }
+}
+
+// src/radio-picker.tsx
+var import_jsx_runtime10 = __toESM(require_jsx_runtime(), 1);
+function RadioPicker({
+  currentStationId: currentStationId2,
+  onSelect,
+  onCancel
+}) {
+  const items = [
+    ...RADIO_STATIONS.map((s) => ({
+      label: `${currentStationId2 === s.id ? "* " : "  "}${s.name}`,
+      value: s.id,
+      description: s.description
+    })),
+    {
+      label: `${currentStationId2 === null ? "* " : "  "}Off`,
+      value: "off",
+      description: "Stop the radio"
+    }
+  ];
+  const initialIndex = Math.max(
+    0,
+    items.findIndex((i) => i.value === (currentStationId2 ?? "off"))
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+    SelectList,
+    {
+      items,
+      onSelect: (v) => onSelect(v === "off" ? "off" : v),
+      onCancel,
+      initialIndex,
+      windowSize: 6
+    }
+  );
+}
+
+// src/auto-update.ts
+init_esm_shims();
+import { spawn as spawn2 } from "child_process";
+import fs4 from "fs";
+import path4 from "path";
+import os2 from "os";
+var PACKAGE_NAME = "@iroaxel/arcena";
+var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+var CHECK_INTERVAL_MS = 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 1e4;
+function getStateFilePath() {
+  return path4.join(os2.homedir(), ".gg", "boss", "update-state.json");
+}
+function readState() {
+  try {
+    const raw = fs4.readFileSync(getStateFilePath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeState(state) {
+  try {
+    const dir = path4.dirname(getStateFilePath());
+    fs4.mkdirSync(dir, { recursive: true, mode: 448 });
+    fs4.writeFileSync(getStateFilePath(), JSON.stringify(state));
+  } catch {
+  }
+}
+function compareVersions(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+function detectInstallInfo() {
+  const scriptPath = (process.argv[1] ?? "").replace(/\\/g, "/");
+  if (scriptPath.includes("/_npx/")) {
+    return { packageManager: "unknown" /* UNKNOWN */, updateCommand: null };
+  }
+  if (scriptPath.includes("/.pnpm") || scriptPath.includes("/pnpm/global")) {
+    return {
+      packageManager: "pnpm" /* PNPM */,
+      updateCommand: `pnpm add -g ${PACKAGE_NAME}@latest`
+    };
+  }
+  if (scriptPath.includes("/.yarn/") || scriptPath.includes("/yarn/global")) {
+    return {
+      packageManager: "yarn" /* YARN */,
+      updateCommand: `yarn global add ${PACKAGE_NAME}@latest`
+    };
+  }
+  return {
+    packageManager: "npm" /* NPM */,
+    updateCommand: `npm install -g ${PACKAGE_NAME}@latest`
+  };
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const response = await fetch(REGISTRY_URL, { signal: controller.signal });
+    clearTimeout(timeout);
+    const data = await response.json();
+    const version = data.version?.trim();
+    return version && /^\d+\.\d+\.\d+/.test(version) ? version : null;
+  } catch {
+    return null;
+  }
+}
+function performUpdateInBackground(command) {
+  try {
+    const parts = command.split(" ");
+    const child = spawn2(parts[0], parts.slice(1), {
+      detached: true,
+      stdio: "ignore",
+      env: { ...process.env, npm_config_loglevel: "silent" }
+    });
+    child.unref();
+  } catch {
+  }
+}
+function checkAndAutoUpdate(currentVersion) {
+  try {
+    const state = readState();
+    let message = null;
+    if (state?.updatePending && state.latestVersion) {
+      if (compareVersions(state.latestVersion, currentVersion) > 0) {
+        const info = detectInstallInfo();
+        if (info.updateCommand) {
+          performUpdateInBackground(info.updateCommand);
+          message = `Axel just shipped ${state.latestVersion}! Installing in the background \u2014 takes effect next launch.`;
+          writeState({
+            ...state,
+            lastCheckedAt: Date.now(),
+            updatePending: false,
+            lastUpdateAttempt: Date.now()
+          });
+        }
+      } else {
+        writeState({ ...state, updatePending: false });
+      }
+    }
+    const shouldCheck = !state || Date.now() - state.lastCheckedAt > CHECK_INTERVAL_MS;
+    if (shouldCheck) scheduleBackgroundCheck(currentVersion);
+    return message;
+  } catch {
+    return null;
+  }
+}
+function getPendingUpdate(currentVersion) {
+  try {
+    const state = readState();
+    if (!state?.latestVersion) return null;
+    if (compareVersions(state.latestVersion, currentVersion) <= 0) return null;
+    return { latestVersion: state.latestVersion };
+  } catch {
+    return null;
+  }
+}
+function scheduleBackgroundCheck(currentVersion) {
+  fetchLatestVersion().then((latestVersion) => {
+    const newState = {
+      lastCheckedAt: Date.now(),
+      latestVersion: latestVersion ?? void 0,
+      updatePending: false
+    };
+    if (latestVersion && compareVersions(latestVersion, currentVersion) > 0) {
+      newState.updatePending = true;
+    }
+    writeState(newState);
+  }).catch(() => {
+  });
+}
+var periodicTimer = null;
+function startPeriodicUpdateCheck(currentVersion, onUpdate) {
+  if (periodicTimer) return;
+  periodicTimer = setInterval(() => {
+    fetchLatestVersion().then((latestVersion) => {
+      if (!latestVersion) return;
+      if (compareVersions(latestVersion, currentVersion) <= 0) return;
+      const info = detectInstallInfo();
+      if (!info.updateCommand) return;
+      writeState({
+        lastCheckedAt: Date.now(),
+        latestVersion,
+        updatePending: true
+      });
+      onUpdate(
+        `Ken just pushed a fresh update \u2014 ${currentVersion} \u2192 ${latestVersion}! Restart arcena to grab it (or run ${info.updateCommand} if you can't wait).`
+      );
+      stopPeriodicUpdateCheck();
+    }).catch(() => {
+    });
+  }, CHECK_INTERVAL_MS);
+  periodicTimer.unref();
+}
+function stopPeriodicUpdateCheck() {
+  if (periodicTimer) {
+    clearInterval(periodicTimer);
+    periodicTimer = null;
+  }
+}
+
+// src/orchestrator-app.tsx
+var import_jsx_runtime11 = __toESM(require_jsx_runtime(), 1);
+function BossApp(props) {
+  const theme = loadTheme("dark");
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(TerminalSizeProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(ThemeContext.Provider, { value: theme, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(AnimationProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(BossAppInner, { ...props }) }) }) });
+}
+function BossAppInner({ boss, resetUI }) {
+  const state = useBossState();
+  const { exit } = use_app_default();
+  const { stdout } = use_stdout_default();
+  const { resizeKey, columns, rows } = useTerminalSize();
+  const runStartRef = (0, import_react11.useRef)(null);
+  runStartRef.current = state.runStartMs;
+  const charCountRef = (0, import_react11.useRef)(0);
+  charCountRef.current = state.streaming?.text.length ?? 0;
+  const realTokensAccumRef = (0, import_react11.useRef)(0);
+  realTokensAccumRef.current = state.bossInputTokens;
+  const [lastUserMessage, setLastUserMessage] = (0, import_react11.useState)("");
+  const overlay = state.overlay;
+  const [currentRadio, setCurrentRadio] = (0, import_react11.useState)(() => getCurrentStation());
+  const [updatePending, setUpdatePending] = (0, import_react11.useState)(
+    () => getPendingUpdate(VERSION) !== null
+  );
+  (0, import_react11.useEffect)(() => {
+    startPeriodicUpdateCheck(VERSION, (msg) => {
+      bossStore.appendUpdateNotice(msg);
+      setUpdatePending(true);
+    });
+    return () => stopPeriodicUpdateCheck();
+  }, []);
+  const workersRunning = state.workers.filter((w) => w.status === "working").length;
+  const titlePrevRef = (0, import_react11.useRef)("");
+  (0, import_react11.useEffect)(() => {
+    if (!stdout) return;
+    let title;
+    if (workersRunning > 0) {
+      const label = `${workersRunning} worker${workersRunning === 1 ? "" : "s"} running`;
+      title = `\u25CF ${label} \xB7 ARCena`;
+    } else if (state.phase === "working") {
+      title = "\u25CF ARCena";
+    } else {
+      title = "ARCena";
+    }
+    if (title !== titlePrevRef.current) {
+      titlePrevRef.current = title;
+      stdout.write(`\x1B]0;${title}\x1B\\`);
+    }
+  }, [stdout, workersRunning, state.phase]);
+  (0, import_react11.useEffect)(() => {
+    return () => {
+      stdout?.write(`\x1B]0;ARCena\x1B\\`);
+    };
+  }, [stdout]);
+  const staticItems = (0, import_react11.useMemo)(
+    () => [{ kind: "banner", id: "banner" }, ...state.history],
+    [state.history]
+  );
+  const openOverlay = (0, import_react11.useCallback)(
+    (next) => {
+      bossStore.setOverlay(next);
+      if (resetUI) resetUI();
+    },
+    [resetUI]
+  );
+  const closeOverlay = (0, import_react11.useCallback)(() => {
+    bossStore.setOverlay(null);
+    if (resetUI) resetUI();
+  }, [resetUI]);
+  void stdout;
+  const handleDoubleExit = useDoublePress(
+    (pending) => bossStore.setExitPending(pending),
+    () => exit()
+  );
+  (0, import_react11.useEffect)(() => {
+    if (state.pendingFlush.length > 0) {
+      bossStore.commitPendingFlush();
+    }
+  }, [state.flushGeneration, state.pendingFlush.length]);
+  use_input_default((input, key) => {
+    if (key.ctrl && input === "t") {
+      if (overlay === "tasks") closeOverlay();
+      else openOverlay("tasks");
+      return;
+    }
+    if (key.escape && state.phase === "working") {
+      boss.abort();
+    }
+  });
+  const handleSlashCommand = async (value) => {
+    const parsed = parseSlash(value);
+    if (!parsed) return false;
+    const name = canonicalName(parsed.name);
+    if (!name) {
+      bossStore.appendInfo(`Unknown command: /${parsed.name}`, "warning");
+      return true;
+    }
+    switch (name) {
+      case "help":
+        bossStore.appendUser(value);
+        bossStore.appendInfo(buildHelpText(), "info");
+        return true;
+      case "clear":
+        bossStore.clearHistory();
+        resetUI?.();
+        await boss.resetConversation();
+        bossStore.appendInfo("Session cleared.", "info");
+        return true;
+      case "model-boss":
+        openOverlay("model-boss");
+        return true;
+      case "model-workers":
+        openOverlay("model-workers");
+        return true;
+      case "compact":
+        bossStore.appendUser(value);
+        await boss.manualCompact();
+        return true;
+      case "radio":
+        openOverlay("radio");
+        return true;
+      case "quit":
+        exit();
+        return true;
+    }
+    return false;
+  };
+  const handleModelSelect = (value) => {
+    const colon = value.indexOf(":");
+    if (colon < 0) {
+      closeOverlay();
+      return;
+    }
+    const provider = value.slice(0, colon);
+    const model = value.slice(colon + 1);
+    if (overlay === "model-boss") {
+      void boss.switchBossModel(provider, model);
+    } else if (overlay === "model-workers") {
+      void boss.switchWorkerModel(provider, model);
+    }
+    closeOverlay();
+  };
+  const handleSubmit = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed) return;
+    if (trimmed.startsWith("/") && !trimmed.startsWith("//")) {
+      void handleSlashCommand(trimmed);
+      return;
+    }
+    bossStore.appendUser(trimmed);
+    setLastUserMessage(trimmed);
+    const scoped = scopePrefix2(state.scope) + trimmed;
+    boss.enqueueUserMessage(scoped);
+  };
+  const handleAbort = () => {
+    if (state.phase === "working") {
+      boss.abort();
+      return;
+    }
+    handleDoubleExit();
+  };
+  if (rows < 14) {
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Box_default, { flexDirection: "column", width: columns, paddingX: 1, marginTop: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { bold: true, color: COLORS.accent, children: "Terminal too small" }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: COLORS.primary, children: `Resize to at least 14 rows to use ARCena (currently ${rows}).` })
+    ] });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Box_default, { flexDirection: "column", width: columns, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Static, { items: staticItems, style: { width: "100%" }, children: (item) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Box_default, { flexDirection: "column", paddingRight: 1, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(StaticRowView, { row: item }) }, item.id) }, resizeKey),
+    overlay === "tasks" ? /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(BossTasksOverlay, { boss, workers: state.workers, onClose: closeOverlay }) : /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_jsx_runtime11.Fragment, { children: [
+      state.streaming && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(StreamingTurnView, { turn: state.streaming, isRunning: state.phase === "working" }),
+      state.phase === "working" && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Box_default, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+        ActivityIndicator,
+        {
+          phase: state.activityPhase,
+          elapsedMs: state.runStartMs ? Date.now() - state.runStartMs : 0,
+          runStartRef,
+          thinkingMs: state.streaming?.thinkingMs ?? 0,
+          isThinking: state.activityPhase === "thinking",
+          tokenEstimate: state.bossInputTokens,
+          charCountRef,
+          realTokensAccumRef,
+          userMessage: lastUserMessage,
+          activeToolNames: (state.streaming?.tools ?? []).filter((t) => t.status === "running").map((t) => t.name),
+          retryInfo: state.retryInfo,
+          phrases: BOSS_PHRASES,
+          pulseColors: PULSE_COLORS
+        }
+      ) }),
+      state.compaction?.state === "running" && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(CompactionSpinner, {}),
+      state.compaction?.state === "done" && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+        CompactionDone,
+        {
+          originalCount: state.compaction.originalCount,
+          newCount: state.compaction.newCount,
+          tokensBefore: state.compaction.tokensBefore,
+          tokensAfter: state.compaction.tokensAfter
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+        InputArea,
+        {
+          onSubmit: handleSubmit,
+          onAbort: handleAbort,
+          disabled: state.phase === "working",
+          isActive: !overlay,
+          cwd: process.cwd(),
+          commands: BOSS_SLASH_COMMANDS,
+          scopeBadge: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(ScopePill, { scope: state.scope }),
+          disableMouseTracking: true,
+          onTab: () => bossStore.cycleScope(),
+          onShiftTab: () => {
+            const next = state.bossThinkingLevel ? void 0 : "medium";
+            void boss.setBossThinking(next);
+          }
+        }
+      ),
+      overlay === "model-boss" || overlay === "model-workers" ? /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+        ModelSelector,
+        {
+          onSelect: handleModelSelect,
+          onCancel: closeOverlay,
+          loggedInProviders: state.loggedInProviders,
+          currentModel: overlay === "model-boss" ? state.bossModel : state.workerModel,
+          currentProvider: overlay === "model-boss" ? state.bossProvider : state.workerProvider
+        }
+      ) : overlay === "radio" ? /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+        RadioPicker,
+        {
+          currentStationId: currentRadio,
+          onCancel: closeOverlay,
+          onSelect: (value) => {
+            if (value === "off") {
+              stopRadio();
+              setCurrentRadio(null);
+              bossStore.appendInfo("Radio off.", "info");
+            } else {
+              const result = playRadio(value);
+              if (result.ok) {
+                setCurrentRadio(value);
+                const station = RADIO_STATIONS.find((s) => s.id === value);
+                bossStore.appendInfo(`Now playing: ${station?.name ?? value}`, "info");
+              } else {
+                bossStore.appendInfo(result.error ?? "Radio failed to start.", "warning");
+              }
+            }
+            closeOverlay();
+          }
+        }
+      ) : /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_jsx_runtime11.Fragment, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+          BossFooter,
+          {
+            bossModel: state.bossModel,
+            workerModel: state.workerModel,
+            tokensIn: state.bossInputTokens,
+            exitPending: state.exitPending,
+            bossThinkingLevel: state.bossThinkingLevel,
+            updatePending,
+            currentRadioStationId: currentRadio
+          }
+        ),
+        !state.exitPending && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+          WorkerStatusBar,
+          {
+            workers: state.workers,
+            pendingMessages: state.pendingUserMessages
+          }
+        )
+      ] })
+    ] })
+  ] });
+}
+function ScopePill({ scope }) {
+  const theme = useTheme();
+  const isAll = scope === "all";
+  const bg = isAll ? COLORS.accent : projectColor(scope);
+  const label = isAll ? "All" : scope;
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Text, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: theme.textDim, children: "Project " }),
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: "black", backgroundColor: bg, bold: true, children: ` ${label} ` }),
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Text, { color: theme.textDim, children: [
+      "  ",
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: theme.primary, children: "Tab" }),
+      " to switch"
+    ] })
+  ] });
+}
+function scopePrefix2(scope) {
+  if (scope === "all") return "[scope:all] ";
+  return `[scope:${scope}] `;
+}
+var SHIMMER_WIDTH = 3;
+function formatElapsed(ms) {
+  const total = Math.floor(ms / 1e3);
+  const m = Math.floor(total / 60);
+  const s = total % 60;
+  return `${m}:${s.toString().padStart(2, "0")}`;
+}
+function AnimationActiveSentinel() {
+  useAnimationActive();
+  return null;
+}
+function ShimmerName({
+  name,
+  color,
+  tick
+}) {
+  const cycle = name.length + SHIMMER_WIDTH * 2;
+  const shimmerPos = tick % cycle - SHIMMER_WIDTH;
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { children: name.split("").map((ch, i) => {
+    const isBright = Math.abs(i - shimmerPos) <= SHIMMER_WIDTH;
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color, bold: isBright, dimColor: !isBright, children: ch }, i);
+  }) });
+}
+function WorkerStatusBar({
+  workers,
+  pendingMessages
+}) {
+  const theme = useTheme();
+  const { columns } = useTerminalSize();
+  const working = workers.filter((w) => w.status === "working");
+  const errored = workers.filter((w) => w.status === "error");
+  const idleCount = workers.length - working.length - errored.length;
+  const anyWorking = working.length > 0;
+  const tick = useAnimationTick();
+  const now = Date.now();
+  if (workers.length === 0) return null;
+  const slots = [];
+  for (const w of working) {
+    const projectHue = projectColor(w.name);
+    const elapsed = w.workStartedAt ? formatElapsed(now - w.workStartedAt) : null;
+    slots.push(
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_react11.default.Fragment, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(ShimmerName, { name: w.name, color: projectHue, tick }),
+        elapsed && /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Text, { color: theme.textDim, children: [
+          " ",
+          elapsed
+        ] })
+      ] }, `w-${w.name}`)
+    );
+  }
+  for (const w of errored) {
+    slots.push(
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_react11.default.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Text, { color: theme.error, children: [
+        "\u2717 ",
+        w.name
+      ] }) }, `e-${w.name}`)
+    );
+  }
+  if (idleCount > 0) {
+    slots.push(
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_react11.default.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Text, { color: theme.textDim, children: [
+        "\u25CB ",
+        idleCount,
+        " idle"
+      ] }) }, "idle")
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Box_default, { paddingX: 1, width: columns, flexShrink: 1, children: [
+    anyWorking && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(AnimationActiveSentinel, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Text, { wrap: "truncate", children: [
+      slots.map((slot, i) => /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_react11.default.Fragment, { children: [
+        i > 0 && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: theme.border, children: " \u2502 " }),
+        slot
+      ] }, i)),
+      pendingMessages > 0 && /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_jsx_runtime11.Fragment, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: theme.textDim, children: "   " }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Text, { color: theme.warning, children: [
+          pendingMessages,
+          " message",
+          pendingMessages === 1 ? "" : "s",
+          " queued"
+        ] })
+      ] })
+    ] })
+  ] });
+}
+function StaticRowView({ row }) {
+  if (row.kind === "banner") {
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Box_default, { paddingX: 1, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(BossBanner, { subtitle: "Orchestrator", showShortcuts: true }) });
+  }
+  if (row.kind === "user") return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(UserMessage, { text: row.text });
+  if (row.kind === "assistant") return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(AssistantRow, { item: row });
+  if (row.kind === "tool") return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(ToolHistoryRow, { item: row });
+  if (row.kind === "worker_event") return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(WorkerEventRow, { item: row });
+  if (row.kind === "worker_error") return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(WorkerErrorRow, { item: row });
+  if (row.kind === "info") return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(InfoRow, { text: row.text, level: row.level ?? "info" });
+  if (row.kind === "task_dispatch") return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(TaskDispatchRow, { tasks: row.tasks });
+  if (row.kind === "update_notice") return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(UpdateNoticeRow, { text: row.text });
+  return null;
+}
+function UpdateNoticeRow({ text }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Box_default, { marginTop: 1, flexShrink: 1, borderStyle: "round", borderColor: COLORS.accent, paddingX: 1, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Text, { wrap: "wrap", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: COLORS.accent, bold: true, children: "\u2728 " }),
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: COLORS.primary, bold: true, children: text })
+  ] }) });
+}
+function TaskDispatchRow({
+  tasks
+}) {
+  const theme = useTheme();
+  const count = tasks.length;
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Box_default, { flexDirection: "column", paddingX: 1, marginTop: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Text, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: COLORS.primary, bold: true, children: "\u23FA " }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Text, { color: theme.text, bold: true, children: [
+        "Running ",
+        count,
+        " task",
+        count === 1 ? "" : "s",
+        ":"
+      ] })
+    ] }),
+    tasks.map((t, i) => /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Text, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: theme.textDim, children: "    \u2022 " }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: projectColor(t.project), bold: true, children: t.project }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: theme.textDim, children: ": " }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: theme.text, children: t.title })
+    ] }, `${t.project}-${i}`))
+  ] });
+}
+var SHORTCUT_PATTERNS = [
+  // Modifier+Key combos: Ctrl+T, Shift+Tab, Cmd+K, Ctrl+Shift+P, Ctrl+C
+  /\b(?:Ctrl|Cmd|Alt|Option|Opt|Shift|Meta|Win|Super)(?:\s*\+\s*(?:Ctrl|Cmd|Alt|Option|Opt|Shift|Meta|Win|Super))*\s*\+\s*(?:Tab|Enter|Esc|Escape|Space|Backspace|Delete|Del|Home|End|PageUp|PageDown|Up|Down|Left|Right|F[1-9]|F1[0-2]|[A-Z0-9]|\/|\?|\.|,|;|=|-)\b/g,
+  // Bare named keys (only when surrounded by clear key context)
+  /\b(?:Ctrl-[A-Z]|F[1-9]|F1[0-2])\b/g
+];
+function highlightShortcuts(text) {
+  if (!text) return text;
+  const SENTINEL = "\uE000";
+  const masks = [];
+  let masked = text.replace(/```[\s\S]*?```|`[^`]+`/g, (m) => {
+    const idx = masks.push(m) - 1;
+    return `${SENTINEL}${idx}${SENTINEL}`;
+  });
+  for (const re of SHORTCUT_PATTERNS) {
+    masked = masked.replace(re, (m) => `\`${m}\``);
+  }
+  return masked.replace(
+    new RegExp(`${SENTINEL}(\\d+)${SENTINEL}`, "g"),
+    (_, i) => masks[Number(i)]
+  );
+}
+function AssistantRow({ item }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+    AssistantMessage,
+    {
+      text: highlightShortcuts(item.text),
+      thinking: item.thinking,
+      thinkingMs: item.thinkingMs
+    }
+  );
+}
+function ToolHistoryRow({ item }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+    ToolExecution,
+    {
+      status: "done",
+      name: item.name,
+      args: item.args,
+      result: item.result,
+      isError: item.isError,
+      details: item.details,
+      formatters: bossToolFormatters
+    }
+  );
+}
+function parseStatusGrade(text) {
+  const matches = [...text.matchAll(/^\s*Status:\s*(DONE|UNVERIFIED|PARTIAL|BLOCKED|INFO)\b/gim)];
+  const last = matches[matches.length - 1];
+  if (!last) return null;
+  return last[1].toUpperCase();
+}
+function parseWorkerTrailer(text) {
+  const out = {};
+  const grab = (label) => {
+    const re = new RegExp(
+      `^\\s*${label}:\\s*([\\s\\S]*?)(?=^\\s*(?:Changed|Skipped|Verified|Notes|Status):|$)`,
+      "im"
+    );
+    const m = re.exec(text);
+    if (!m) return void 0;
+    const v = m[1].replace(/```[\s\S]*?```/g, "[code]").replace(/`([^`]+)`/g, "$1").replace(/\s+/g, " ").trim();
+    return v.length > 0 ? v : void 0;
+  };
+  out.changed = grab("Changed");
+  out.skipped = grab("Skipped");
+  out.verified = grab("Verified");
+  out.notes = grab("Notes");
+  return out;
+}
+function clip(text, maxLen) {
+  return text.length <= maxLen ? text : text.slice(0, Math.max(1, maxLen - 1)) + "\u2026";
+}
+function summarizeFinalText(text, maxLen) {
+  if (!text) return "";
+  const trailer = parseWorkerTrailer(text);
+  const parts = [];
+  if (trailer.changed) parts.push(`Changed: ${trailer.changed}`);
+  if (trailer.verified) parts.push(`Verified: ${trailer.verified}`);
+  if (trailer.skipped) parts.push(`Skipped: ${trailer.skipped}`);
+  if (trailer.notes) parts.push(`Notes: ${trailer.notes}`);
+  if (parts.length > 0) return clip(parts.join("  \xB7  "), maxLen);
+  const beforeSummary = text.split(/^Changed:|^Skipped:|^Verified:|^Notes:|^Status:/im)[0];
+  const stripped = beforeSummary.replace(/```[\s\S]*?```/g, "[code]").replace(/`([^`]+)`/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/^\s*[-*]\s+/gm, "").replace(/^#+\s+/gm, "").replace(/\s+/g, " ").trim();
+  if (!stripped) return "";
+  const firstSentence = stripped.match(/^[^.!?\n]+[.!?]/);
+  return clip(firstSentence ? firstSentence[0] : stripped, maxLen);
+}
+function statusGradeColor(grade, theme) {
+  switch (grade) {
+    case "DONE":
+      return theme.success;
+    case "UNVERIFIED":
+    case "PARTIAL":
+      return theme.warning;
+    case "BLOCKED":
+      return theme.error;
+    case "INFO":
+      return theme.textDim;
+    default:
+      return theme.textDim;
+  }
+}
+function WorkerEventRow({ item }) {
+  const theme = useTheme();
+  const { columns } = useTerminalSize();
+  const failedCount = item.toolsUsed.filter((t) => !t.ok).length;
+  const total = item.toolsUsed.length;
+  const grade = parseStatusGrade(item.finalText);
+  const loaderStatus = grade === "BLOCKED" || failedCount > 0 ? "error" : grade === "UNVERIFIED" || grade === "PARTIAL" ? "queued" : "done";
+  const headerColor = loaderStatus === "error" ? theme.toolError : projectColor(item.project);
+  const toolSummary = total === 0 ? "no tools" : failedCount > 0 ? `${total} tools (${failedCount} failed)` : `${total} tool${total === 1 ? "" : "s"}`;
+  const fieldMaxLen = Math.max(20, columns - 14);
+  const trailer = parseWorkerTrailer(item.finalText);
+  const hasTrailer = !!(trailer.changed || trailer.skipped || trailer.verified || trailer.notes);
+  const fallbackSummary = hasTrailer ? "" : summarizeFinalText(item.finalText, fieldMaxLen);
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Box_default, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Box_default, { flexDirection: "row", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(ToolUseLoader, { status: loaderStatus }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Box_default, { flexGrow: 1, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Text, { wrap: "wrap", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: headerColor, bold: true, children: item.project }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: theme.text, children: `  turn ${item.turnIndex}` }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: theme.textDim, children: `  \xB7  ${toolSummary}` }),
+        grade && /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_jsx_runtime11.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: theme.textDim, children: "  \xB7  " }),
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: statusGradeColor(grade, theme), bold: true, children: grade })
+        ] })
+      ] }) })
+    ] }),
+    hasTrailer ? /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_jsx_runtime11.Fragment, { children: [
+      trailer.changed && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(TrailerLine, { label: "Changed", value: trailer.changed, maxLen: fieldMaxLen }),
+      trailer.verified && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+        TrailerLine,
+        {
+          label: "Verified",
+          value: trailer.verified,
+          maxLen: fieldMaxLen,
+          labelColor: theme.success
+        }
+      ),
+      trailer.skipped && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+        TrailerLine,
+        {
+          label: "Skipped",
+          value: trailer.skipped,
+          maxLen: fieldMaxLen,
+          labelColor: theme.warning
+        }
+      ),
+      trailer.notes && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(TrailerLine, { label: "Notes", value: trailer.notes, maxLen: fieldMaxLen })
+    ] }) : fallbackSummary && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(MessageResponse, { children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: theme.textDim, wrap: "truncate", children: fallbackSummary }) })
+  ] });
+}
+function TrailerLine({
+  label,
+  value,
+  maxLen,
+  labelColor
+}) {
+  const theme = useTheme();
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(MessageResponse, { children: /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Text, { wrap: "truncate", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Text, { color: labelColor ?? theme.textDim, bold: true, children: [
+      label,
+      ":"
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: theme.text, children: ` ${clip(value, maxLen - label.length - 2)}` })
+  ] }) });
+}
+function WorkerErrorRow({ item }) {
+  const theme = useTheme();
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Box_default, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Box_default, { flexDirection: "row", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(ToolUseLoader, { status: "error" }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Box_default, { flexGrow: 1, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Text, { wrap: "wrap", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: theme.toolError, bold: true, children: item.project }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: theme.textDim, children: "  worker error" })
+      ] }) })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(MessageResponse, { children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color: theme.error, wrap: "wrap", children: item.message }) })
+  ] });
+}
+function InfoRow({
+  text,
+  level
+}) {
+  if (level === "info") return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(AssistantMessage, { text });
+  const theme = useTheme();
+  const color = level === "error" ? theme.error : theme.warning;
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Box_default, { marginTop: 1, flexDirection: "row", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(ToolUseLoader, { status: level === "error" ? "error" : "queued" }),
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Box_default, { flexGrow: 1, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Text, { color, wrap: "wrap", children: text }) })
+  ] });
+}
+function StreamingTurnView({
+  turn,
+  isRunning
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(Box_default, { flexDirection: "column", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+      StreamingArea,
+      {
+        isRunning,
+        streamingText: turn.text,
+        streamingThinking: turn.thinking,
+        thinkingMs: turn.thinkingMs
+      }
+    ),
+    turn.tools.map((t) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(StreamingToolRow, { tool: t }, t.toolCallId))
+  ] });
+}
+function StreamingToolRow({ tool }) {
+  if (tool.status === "running") {
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+      ToolExecution,
+      {
+        status: "running",
+        name: tool.name,
+        args: tool.args,
+        formatters: bossToolFormatters
+      }
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+    ToolExecution,
+    {
+      status: "done",
+      name: tool.name,
+      args: tool.args,
+      result: tool.result ?? "",
+      isError: tool.status === "error",
+      details: tool.details,
+      formatters: bossToolFormatters
+    }
+  );
+}
+function renderBossApp(opts) {
+  const ref = { instance: null };
+  const resetUI = () => {
+    const old = ref.instance;
+    if (!old) return;
+    process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+    old.unmount();
+    ref.instance = render_default(/* @__PURE__ */ (0, import_jsx_runtime11.jsx)(BossApp, { boss: opts.boss, resetUI }), {
+      exitOnCtrlC: false
+    });
+  };
+  const instance = render_default(/* @__PURE__ */ (0, import_jsx_runtime11.jsx)(BossApp, { boss: opts.boss, resetUI }), {
+    // Disable Ink's built-in exit-on-Ctrl+C — we need our own double-press
+    // handler in BossApp to drive the "Press Ctrl+C again to exit" footer
+    // message. With this flag true (the default), Ink kills the process on
+    // the very first Ctrl+C and InputArea's onAbort never runs.
+    exitOnCtrlC: false
+  });
+  ref.instance = instance;
+  let resizeTimer = null;
+  const onTerminalResize = () => {
+    if (resizeTimer) clearTimeout(resizeTimer);
+    resizeTimer = setTimeout(() => {
+      resizeTimer = null;
+      resetUI();
+    }, 250);
+  };
+  process.stdout.on("resize", onTerminalResize);
+  return {
+    // Follow ref.instance through restarts: when /clear nukes the current
+    // instance and creates a new one, this promise re-binds to whichever
+    // Ink instance is alive now. Without the loop, we'd wait on the OLD
+    // instance's waitUntilExit (which already resolved on unmount) and
+    // exit the CLI immediately after every /clear.
+    waitUntilExit: async () => {
+      while (true) {
+        const current = ref.instance;
+        if (!current) {
+          process.stdout.off("resize", onTerminalResize);
+          if (resizeTimer) clearTimeout(resizeTimer);
+          return;
+        }
+        await current.waitUntilExit();
+        if (ref.instance === current) {
+          ref.instance = null;
+          process.stdout.off("resize", onTerminalResize);
+          if (resizeTimer) clearTimeout(resizeTimer);
+          return;
+        }
+      }
+    },
+    unmount: () => {
+      process.stdout.off("resize", onTerminalResize);
+      if (resizeTimer) clearTimeout(resizeTimer);
+      ref.instance?.unmount();
+    }
+  };
+}
+
+// src/splash.tsx
+init_esm_shims();
+var import_react12 = __toESM(require_react(), 1);
+var import_jsx_runtime12 = __toESM(require_jsx_runtime(), 1);
+var SPLASH_LINES = [
+  "   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588    \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588                          ",
+  "  \u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2588  \u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2588   \u2591\u2591\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2588                         ",
+  " \u2588\u2588\u2588     \u2591\u2591\u2591  \u2588\u2588\u2588     \u2591\u2591\u2591     \u2591\u2588\u2588\u2588    \u2591\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588   \u2588\u2588\u2588\u2588\u2588   \u2588\u2588\u2588\u2588\u2588 ",
+  "\u2591\u2588\u2588\u2588         \u2591\u2588\u2588\u2588             \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2591\u2591\u2588\u2588\u2588 \u2588\u2588\u2588\u2591\u2591   \u2588\u2588\u2588\u2591\u2591  ",
+  "\u2591\u2588\u2588\u2588    \u2588\u2588\u2588\u2588\u2588\u2591\u2588\u2588\u2588    \u2588\u2588\u2588\u2588\u2588    \u2591\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2588\u2591\u2588\u2588\u2588 \u2591\u2588\u2588\u2588\u2591\u2591\u2588\u2588\u2588\u2588\u2588 \u2591\u2591\u2588\u2588\u2588\u2588\u2588 ",
+  "\u2591\u2591\u2588\u2588\u2588  \u2591\u2591\u2588\u2588\u2588 \u2591\u2591\u2588\u2588\u2588  \u2591\u2591\u2588\u2588\u2588     \u2591\u2588\u2588\u2588    \u2591\u2588\u2588\u2588\u2591\u2588\u2588\u2588 \u2591\u2588\u2588\u2588 \u2591\u2591\u2591\u2591\u2588\u2588\u2588 \u2591\u2591\u2591\u2591\u2588\u2588\u2588",
+  " \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588  \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588 \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588 ",
+  "  \u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591    \u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591     \u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591   \u2591\u2591\u2591\u2591\u2591\u2591  \u2591\u2591\u2591\u2591\u2591\u2591  \u2591\u2591\u2591\u2591\u2591\u2591  "
+];
+var SPLASH_WIDTH = SPLASH_LINES[0].length;
+function colorForLine(lineIdx, totalLines, offset) {
+  const t = totalLines <= 1 ? 0 : (lineIdx + offset) % totalLines;
+  const idx = Math.floor(t / totalLines * GRADIENT.length) % GRADIENT.length;
+  return GRADIENT[idx];
+}
+function SplashLogo({ offset }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Box_default, { flexDirection: "column", children: SPLASH_LINES.map((line, i) => {
+    const hue = colorForLine(i, SPLASH_LINES.length, offset);
+    const segments = [];
+    let buf = "";
+    let bufDim = false;
+    for (const ch of line) {
+      const dim = ch === "\u2591";
+      if (segments.length === 0 && buf.length === 0) {
+        buf = ch;
+        bufDim = dim;
+        continue;
+      }
+      if (dim === bufDim) {
+        buf += ch;
+      } else {
+        segments.push({ text: buf, dim: bufDim });
+        buf = ch;
+        bufDim = dim;
+      }
+    }
+    if (buf) segments.push({ text: buf, dim: bufDim });
+    return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Text, { children: segments.map((seg, j) => /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Text, { color: hue, dimColor: seg.dim, children: seg.text }, j)) }, i);
+  }) });
+}
+function SplashScreen({ caption }) {
+  const [offset, setOffset] = (0, import_react12.useState)(0);
+  (0, import_react12.useEffect)(() => {
+    const timer = setInterval(() => {
+      setOffset((o) => o + 1);
+    }, 120);
+    return () => {
+      clearInterval(timer);
+    };
+  }, []);
+  const [size, setSize] = (0, import_react12.useState)(() => ({
+    columns: process.stdout.columns ?? 80,
+    rows: process.stdout.rows ?? 24
+  }));
+  (0, import_react12.useEffect)(() => {
+    const handler = () => setSize({
+      columns: process.stdout.columns ?? 80,
+      rows: process.stdout.rows ?? 24
+    });
+    process.stdout.on("resize", handler);
+    return () => {
+      process.stdout.off("resize", handler);
+    };
+  }, []);
+  const SPLASH_BLOCK_HEIGHT = SPLASH_LINES.length + 3;
+  const verticalPad = Math.max(0, Math.floor((size.rows - SPLASH_BLOCK_HEIGHT) / 2));
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(Box_default, { flexDirection: "column", width: size.columns, height: size.rows, alignItems: "center", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Box_default, { height: verticalPad, flexShrink: 0 }),
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(Box_default, { flexDirection: "column", alignItems: "flex-start", flexShrink: 0, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(SplashLogo, { offset }),
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Box_default, { width: SPLASH_WIDTH, marginTop: 1, justifyContent: "center", children: /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(Text, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Text, { color: COLORS.text, bold: true, children: BRAND }),
+        /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(Text, { color: COLORS.textDim, children: [
+          " v",
+          VERSION
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Text, { color: COLORS.textDim, children: " \xB7 By " }),
+        /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Text, { color: COLORS.text, bold: true, children: AUTHOR })
+      ] }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Box_default, { width: SPLASH_WIDTH, justifyContent: "center", children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Text, { color: COLORS.textDim, children: caption ?? "Spinning up the orchestrator\u2026" }) })
+    ] })
+  ] });
+}
+function showSplash(opts) {
+  const start = Date.now();
+  void playSplashAudio();
+  const instance = render_default(/* @__PURE__ */ (0, import_jsx_runtime12.jsx)(SplashScreen, { caption: opts.caption }));
+  const audioDurationMs = getSplashAudioDurationMs();
+  const defaultMinMs = audioDurationMs + 200;
+  return {
+    dismiss: async () => {
+      const minMs = opts.minMs ?? defaultMinMs;
+      const elapsed = Date.now() - start;
+      const remaining = Math.max(0, minMs - elapsed);
+      if (remaining > 0) {
+        await new Promise((r) => setTimeout(r, remaining));
+      }
+      instance.unmount();
+      await new Promise((r) => setImmediate(r));
+    }
+  };
+}
+
+// src/cli.ts
+function parseProjectSpec(raw) {
+  const eq = raw.indexOf("=");
+  if (eq > 0) {
+    const name = raw.slice(0, eq);
+    const cwd2 = path5.resolve(raw.slice(eq + 1));
+    return { name, cwd: cwd2 };
+  }
+  const cwd = path5.resolve(raw);
+  return { name: path5.basename(cwd), cwd };
+}
+function parseArgs(argv) {
+  const args = {
+    projects: []
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--project" || a === "-p") {
+      const v = argv[++i];
+      if (!v) throw new Error("--project requires a value");
+      args.projects.push(parseProjectSpec(v));
+    } else if (a === "--boss-model") {
+      const v = argv[++i];
+      if (!v) throw new Error("--boss-model requires a value");
+      args.bossModel = v;
+    } else if (a === "--worker-model") {
+      const v = argv[++i];
+      if (!v) throw new Error("--worker-model requires a value");
+      args.workerModel = v;
+    } else if (a === "--resume") {
+      const v = argv[++i];
+      if (!v) throw new Error("--resume requires a session id");
+      args.resumeSessionId = v;
+    } else if (a === "--help" || a === "-h") {
+      printHelpAndExit();
+    } else {
+      throw new Error(`Unknown argument: ${a}`);
+    }
+  }
+  return args;
+}
+function printHelpAndExit() {
+  const c = (color, text) => source_default.hex(color)(text);
+  process.stdout.write(
+    "\n" + c(COLORS.primary, "ARCena") + c(COLORS.textDim, " \u2014 orchestrator that drives multiple arcicoder workers from one chat.\n\n") + c(COLORS.text, "Usage\n") + "  " + c(COLORS.accent, "arcena") + c(
+      COLORS.textDim,
+      "                              start orchestrator using linked projects\n"
+    ) + "  " + c(COLORS.accent, "arcena link") + c(COLORS.textDim, "                         pick which projects to link (interactive)\n") + "  " + c(COLORS.accent, "arcena telegram") + c(COLORS.textDim, "                     configure Telegram bot integration\n") + "  " + c(COLORS.accent, "arcena serve") + c(COLORS.textDim, "                        run the boss over Telegram (no TUI)\n") + "  " + c(COLORS.accent, "arcena continue") + c(COLORS.textDim, "                     resume the most recent boss session\n") + "  " + c(COLORS.accent, "arcena --resume <id>") + c(COLORS.textDim, "                resume a specific boss session\n") + "  " + c(COLORS.accent, "arcena --project <spec> [...]") + c(COLORS.textDim, "       override links with explicit project(s)\n\n") + c(COLORS.text, "Options\n") + "  " + c(COLORS.primary, "--project, -p <spec>") + c(COLORS.textDim, '    project to manage. spec is "cwd" or "name=cwd". repeatable.\n') + "  " + c(COLORS.primary, "--boss-model <id>") + c(COLORS.textDim, "       model for the orchestrator (default: claude-opus-4-7)\n") + "  " + c(COLORS.primary, "--worker-model <id>") + c(COLORS.textDim, "     model for workers (default: claude-sonnet-4-6)\n") + "  " + c(COLORS.primary, "--help, -h") + c(COLORS.textDim, "              show this help\n\n") + c(COLORS.textDim, "Talk to the boss at the prompt. Press ") + c(COLORS.accent, "Ctrl+C") + c(COLORS.textDim, " twice to exit.\n\n")
+  );
+  process.exit(0);
+}
+async function runServeSubcommand(argv) {
+  let cliBotToken;
+  let cliUserId;
+  let cliBossModel;
+  let cliWorkerModel;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--bot-token") cliBotToken = argv[++i];
+    else if (a === "--user-id") cliUserId = argv[++i];
+    else if (a === "--boss-model") cliBossModel = argv[++i];
+    else if (a === "--worker-model") cliWorkerModel = argv[++i];
+    else if (a === "--help" || a === "-h") {
+      process.stdout.write(
+        "\nggboss serve \u2014 drive the boss from Telegram\n\nOptions\n  --bot-token <token>   Telegram bot token (or env GG_BOSS_TELEGRAM_BOT_TOKEN)\n  --user-id <id>        Allowed Telegram user ID (or env GG_BOSS_TELEGRAM_USER_ID)\n  --boss-model <id>     Override boss model\n  --worker-model <id>   Override worker model\n\nRun `arcena telegram` first to save credentials interactively.\n\n"
+      );
+      process.exit(0);
+    } else {
+      throw new Error(`Unknown argument: ${a}`);
+    }
+  }
+  const saved = await loadBossTelegramConfig();
+  const botToken = cliBotToken ?? process.env.GG_BOSS_TELEGRAM_BOT_TOKEN ?? saved?.botToken;
+  const userIdStr = cliUserId ?? process.env.GG_BOSS_TELEGRAM_USER_ID;
+  const userId = userIdStr ? parseInt(userIdStr, 10) : saved?.userId;
+  if (!botToken || !userId || isNaN(userId)) {
+    process.stderr.write(
+      source_default.hex(COLORS.error)("Telegram not configured.\n\n") + "Run " + source_default.hex(COLORS.primary).bold("arcena telegram") + " to set up your bot token and user ID.\n\n" + source_default.hex(COLORS.textDim)("Or provide manually:\n") + source_default.hex(COLORS.textDim)("  arcena serve --bot-token TOKEN --user-id ID\n")
+    );
+    process.exit(1);
+  }
+  const settings = await loadSettings();
+  const bossProvider = settings.bossProvider ?? "anthropic";
+  const bossModel = cliBossModel ?? settings.bossModel ?? "claude-opus-4-7";
+  const workerProvider = settings.workerProvider ?? "anthropic";
+  const workerModel = cliWorkerModel ?? settings.workerModel ?? "claude-sonnet-4-6";
+  await runBossServeMode({
+    bossProvider,
+    bossModel,
+    bossThinkingLevel: settings.bossThinkingLevel,
+    workerProvider,
+    workerModel,
+    telegram: { botToken, userId }
+  });
+}
+async function runOrchestrator(args) {
+  if (args.projects.length === 0) {
+    const links = await loadLinks();
+    if (links.projects.length === 0) {
+      process.stderr.write(
+        "\n" + source_default.hex(COLORS.warning)("No linked projects.") + source_default.hex(COLORS.textDim)(" Run ") + source_default.hex(COLORS.accent)("arcena link") + source_default.hex(COLORS.textDim)(" to choose, or pass ") + source_default.hex(COLORS.accent)("--project") + source_default.hex(COLORS.textDim)(".\n\n")
+      );
+      process.exit(1);
+    }
+    args.projects = links.projects.map((p) => ({ name: p.name, cwd: p.cwd }));
+  }
+  clearScreen();
+  const splash = showSplash({
+    caption: `Spinning up ${args.projects.length} worker${args.projects.length === 1 ? "" : "s"}\u2026`
+  });
+  const settings = await loadSettings();
+  const finalBossProvider = args.bossProvider ?? settings.bossProvider ?? "anthropic";
+  const finalBossModel = args.bossModel ?? settings.bossModel ?? "claude-opus-4-7";
+  const finalWorkerProvider = args.workerProvider ?? settings.workerProvider ?? "anthropic";
+  const finalWorkerModel = args.workerModel ?? settings.workerModel ?? "claude-sonnet-4-6";
+  initLogger({
+    version: VERSION,
+    bossProvider: finalBossProvider,
+    bossModel: finalBossModel,
+    bossThinking: settings.bossThinkingLevel,
+    workerProvider: finalWorkerProvider,
+    workerModel: finalWorkerModel,
+    projectCount: args.projects.length
+  });
+  log("INFO", "cli", "linked projects", {
+    projects: args.projects.map((p) => p.name).join(",")
+  });
+  const updateMessage = checkAndAutoUpdate(VERSION);
+  if (updateMessage) log("INFO", "auto_update", updateMessage);
+  const boss = new GGBoss({
+    bossProvider: finalBossProvider,
+    bossModel: finalBossModel,
+    bossThinkingLevel: settings.bossThinkingLevel,
+    workerProvider: finalWorkerProvider,
+    workerModel: finalWorkerModel,
+    projects: args.projects,
+    continueRecent: args.continueRecent,
+    resumeSessionId: args.resumeSessionId
+  });
+  await boss.initialize();
+  await splash.dismiss();
+  clearScreen();
+  const ink = renderBossApp({ boss });
+  const runPromise = boss.run();
+  await ink.waitUntilExit();
+  await boss.dispose();
+  stopRadio();
+  await runPromise.catch(() => {
+  });
+  process.exit(0);
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv[0] === "link") {
+    await runLinkCommand();
+    process.exit(0);
+  }
+  if (argv[0] === "telegram") {
+    await runBossTelegramSetup();
+    process.exit(0);
+  }
+  if (argv[0] === "serve") {
+    await runServeSubcommand(argv.slice(1));
+    return;
+  }
+  const isContinue = argv[0] === "continue";
+  const args = parseArgs(isContinue ? argv.slice(1) : argv);
+  if (isContinue) args.continueRecent = true;
+  await runOrchestrator(args);
+}
+process.on("uncaughtException", (err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  const stack = err instanceof Error ? err.stack : void 0;
+  log("ERROR", "uncaught_exception", message, { stack });
+});
+process.on("unhandledRejection", (reason) => {
+  const message = reason instanceof Error ? reason.message : String(reason);
+  const stack = reason instanceof Error ? reason.stack : void 0;
+  log("ERROR", "unhandled_rejection", message, { stack });
+});
+main().catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(source_default.hex(COLORS.error)(`
+gg-boss failed: ${message}
+`));
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map