@sideboard-ai/core 0.1.9

package/dist/index.js

@@ -0,0 +1,929 @@
+import {
+  CONTEXT_COMPACT_CHARS,
+  CONTEXT_KEEP_RECENT_CHARS,
+  CONTEXT_KEEP_RECENT_MESSAGES,
+  CONTEXT_MIN_MESSAGES,
+  Orchestrator,
+  adoptThread,
+  allocatePort,
+  allocatePortRange,
+  applyAgentEvent,
+  applyCompaction,
+  applyThreadIntoMain,
+  buildForkTranscriptAttachment,
+  buildSessionSeed,
+  buildWorkspaceScriptEnv,
+  captureLoginEnv,
+  captureTurnBaseline,
+  cleanupOrphanWorktrees,
+  cloneRepoIntoSideboard,
+  conductorDbPath,
+  confirmLand,
+  copyConfiguredFiles,
+  createChatTab,
+  createThread,
+  detectAgents,
+  discoverSkills,
+  estimateMessageChars,
+  estimateThreadChars,
+  expandComposerPrompt,
+  extractiveSummary,
+  finalizeParts,
+  findOrphanWorktrees,
+  forkChatTab,
+  forkMessageSlice,
+  forkThreadWorktree,
+  formatAgentInstructions,
+  formatMessagesAsTranscript,
+  formatRenameBranchDirective,
+  formatTranscriptMarkdown,
+  formatWorktreeDirective,
+  getDefaultRunScript,
+  getDiff,
+  getDiffSummary,
+  getOrchestrator,
+  getRunMode,
+  getRunScript,
+  hasCursorWorktreeSetup,
+  importConductorWorkspace,
+  importConductorWorkspaceAsync,
+  initializeGitRepository,
+  inspectGitWorktree,
+  isBrightsyNdjsonLine,
+  listBranchCommits,
+  listConductorWorkspaces,
+  listGitHubIssues,
+  listIssues,
+  listLinearIssues,
+  listLinearIssuesDirect,
+  listRunScripts,
+  listWorktreeFiles,
+  loadAgentInstructions,
+  maybeCompactContext,
+  mergeUsage,
+  normalizeParseResult,
+  partsToAssistantText,
+  previewLand,
+  readSkillBody,
+  readWorktreeFile,
+  readWorktreeInclude,
+  requireAgent,
+  resolveConductorCursorAgentId,
+  resolveFilesToCopy,
+  runArchiveScript,
+  runCursorWorktreeSetup,
+  runSetupScript,
+  sameWorktreePath,
+  shouldCompactContext,
+  shouldRunWorktreeCleanup,
+  spawnAgentTurn,
+  splitForCompaction,
+  startDevServer,
+  startMcpServer,
+  startOrchestration,
+  stripBrightsyNdjsonNoise,
+  summarizeConversation,
+  takenTeamSlugsForChatTab,
+  threadsSharingWorktree,
+  toolDescription,
+  toolDetail,
+  toolFilePath,
+  totalTokens,
+  validateLinearApiKey,
+  withAgentInstructions,
+  worktreeCleanupSettings,
+  writeWorktreeFile
+} from "./chunk-E4PWXO2C.js";
+import {
+  addWorkspace,
+  ensureWorkspace,
+  listWorkspaces,
+  removeWorkspace,
+  syncWorkspacesFromThreads
+} from "./chunk-TLJH3L2C.js";
+import {
+  CLOUD_COORDINATOR_BUSY_REPLY,
+  CLOUD_COORDINATOR_STOPPED_REPLY,
+  CLOUD_COORDINATOR_TIMEOUT_REPLY,
+  CLOUD_ORCHESTRATOR_GOAL,
+  GLOBAL_WORKSPACE_ID,
+  SIDEBOARD_FORCE_STOP,
+  createGlobalChat,
+  ensureCloudCoordinator,
+  healOrchestrationSoccerTitles,
+  isCloudCoordinatorThread,
+  isGlobalRepoPath,
+  isGlobalThread,
+  isOrchestratorThread,
+  listGlobalThreads,
+  orchestrationTitleNeedsSoccerNickname,
+  orchestratorSessionPoisonedByBuiltins,
+  parseForceStopMessage,
+  takenTeamSlugsForOrchestration
+} from "./chunk-2M4OHXYX.js";
+import {
+  COORDINATOR_TOOL_PLAYBOOK,
+  coordinatorSystemPrompt,
+  coordinatorTurnReminder,
+  enrichWorkspacesWithGithub,
+  ensureGlobalCoordinatorCwd,
+  formatWorkspaceInventory
+} from "./chunk-2R5VV4BA.js";
+import {
+  BRIGHTSY_MCP_ALLOWED_TOOLS,
+  MAX_ANTHROPIC_CACHE_CONTROL_BLOCKS,
+  PLAN_MODE_INSTRUCTION,
+  SIDEBOARD_MCP_ALLOWED_TOOLS,
+  allAdapters,
+  brightsyAdapter,
+  brightsyMcpAllowedTools,
+  buildCachedUserContent,
+  buildClaudeStreamJsonUserMessage,
+  claudeAdapter,
+  codexAdapter,
+  countCacheControlBlocks,
+  cursorAdapter,
+  decodeBrightsyTarget,
+  encodeBrightsyTarget,
+  findInvalidCacheControlTtlOrder,
+  flattenTurnInput,
+  getAdapter,
+  isBrightsyConnected,
+  listBrightsyChatTargets,
+  mcpAllowTools,
+  mcpAuthWarnings,
+  normalizeTurnInput,
+  opencodeAdapter,
+  parseMcpList,
+  permissionMode,
+  sanitizeMcpServerName,
+  writeInjectedMcpConfig
+} from "./chunk-WMCPLDW3.js";
+import {
+  brightsyConfigPath,
+  brightsyMcpServerName,
+  connectBrightsyTeam,
+  disconnectBrightsyTeam,
+  getBrightsySession,
+  listBrightsyAccounts,
+  listConnectedBrightsyTeams,
+  loadBrightsyConfig,
+  saveBrightsyConfig,
+  switchBrightsyAccount
+} from "./chunk-ILQK4P5R.js";
+import {
+  cursorSdkMessageToEvents,
+  parseCursorRunnerLine
+} from "./chunk-3DKGI32Q.js";
+import {
+  HARNESS_ENV_KEYS,
+  appSettingsPath,
+  applyAppEnvironment,
+  autoCleanupOrphansEnabled,
+  autoRenameBranchEnabled,
+  autoRunAfterSetupEnabled,
+  brightsyCloudConnectAgent,
+  brightsyCloudConnectEnabled,
+  caffeinateWhileCloudConnectEnabled,
+  caffeinateWhileRunningEnabled,
+  childEnvWithAppSettings,
+  claudeChromeEnabled,
+  claudeUserSettingsPath,
+  deleteBranchOnPurgeEnabled,
+  getIssueSource,
+  getLinearApiKey,
+  harnessEnvKey,
+  isLinearConnected,
+  loadAppSettings,
+  maxConcurrentAgents,
+  resolveClaudeExecutable,
+  resolveEffectiveIssueSource,
+  saveAppSettings,
+  updateAdvancedSettings,
+  updateAppEnvironment,
+  updateBrightsySettings,
+  updateClaudeSettings,
+  updateIntegrationsSettings
+} from "./chunk-3WF3X46L.js";
+import {
+  FAMOUS_SOCCER_TEAMS,
+  allocateTeamName,
+  allocateTeamSlug,
+  branchDisplayLabel,
+  collectTakenTeamSlugs,
+  commitAll,
+  createOrUpdatePr,
+  createThreadWorktree,
+  currentBranch,
+  detectLocalMergeConflicts,
+  fetchPrHead,
+  getPr,
+  getPrChecks,
+  getPrDetails,
+  isDirty,
+  isPlaceholderBranch,
+  listBranches,
+  listPrs,
+  listWorktrees,
+  mergePr,
+  normalizeWorktreePath,
+  parseGithubSlugFromRemoteUrl,
+  pushBranch,
+  removeWorktree,
+  resolveDefaultBranch,
+  resolveDiffBaseRef,
+  resolveGithubRepoSlug,
+  resolvePrSelector,
+  resolveRepoRoot,
+  resolveWorktreeStartPoint,
+  slugify,
+  suggestSlug,
+  threadDisplayLabel,
+  worktreeDisplayLabel,
+  worktreeDisplayLabelForGroup,
+  worktreeNameFromPath
+} from "./chunk-LL7DTZ5B.js";
+import {
+  appendMessage,
+  createEmptyThread,
+  deleteThreadRecord,
+  findThreadByRef,
+  listThreads,
+  normalizeThread,
+  readThread,
+  setStatus,
+  updateThread,
+  withThreadLock,
+  writeThread
+} from "./chunk-HYRHI3QU.js";
+import {
+  appDataDir,
+  getRepoSetupInfo,
+  globalAgentCwd,
+  hasConductorHook,
+  hasRepoHook,
+  hasWorkspaceHook,
+  loadConductorSettings,
+  loadRepoSettings,
+  loadWorkspaceSettings,
+  locksDir,
+  repoSlug,
+  settingsSourceLabel,
+  sideboardHomeDir,
+  sideboardReposDir,
+  sideboardWorkspacesDir,
+  threadFilePath,
+  threadLockPath,
+  threadsDir,
+  workspaceSettingsSourceLabel,
+  worktreesRoot
+} from "./chunk-M37RITA6.js";
+import {
+  ensureAgentPath,
+  gh,
+  git,
+  run
+} from "./chunk-AJ6ROGD7.js";
+
+// src/integrations/github.ts
+async function getGitHubStatus() {
+  const which = await run("which", ["gh"], { reject: false });
+  if (which.exitCode !== 0 || !which.stdout.trim()) {
+    return {
+      connected: false,
+      login: null,
+      hosts: [],
+      reason: "gh CLI not found on PATH"
+    };
+  }
+  const loginResult = await run(
+    "gh",
+    ["api", "user", "--jq", ".login"],
+    { reject: false }
+  );
+  if (loginResult.exitCode === 0 && loginResult.stdout.trim()) {
+    return {
+      connected: true,
+      login: loginResult.stdout.trim(),
+      hosts: ["github.com"],
+      reason: null
+    };
+  }
+  const status = await run("gh", ["auth", "status"], { reject: false });
+  const text = `${status.stdout}
+${status.stderr}`;
+  const loginMatch = text.match(/Logged in to ([^\s]+) account (\S+)/i) ?? text.match(/Logged in to ([^\s]+) as (\S+)/i);
+  if (loginMatch) {
+    return {
+      connected: true,
+      login: loginMatch[2].replace(/['"]/g, ""),
+      hosts: [loginMatch[1]],
+      reason: null
+    };
+  }
+  return {
+    connected: false,
+    login: null,
+    hosts: [],
+    reason: status.stderr.trim() || status.stdout.trim() || "Not logged in to GitHub (run: gh auth login)"
+  };
+}
+async function refreshGitHubAuth() {
+  return getGitHubStatus();
+}
+
+// src/brightsy/api.ts
+function formatBrightsyFetchError(err, url) {
+  if (!(err instanceof Error)) return `${String(err)} (${url})`;
+  const cause = err.cause;
+  let detail = "";
+  if (cause instanceof Error) {
+    const code = typeof cause.code === "string" ? cause.code : void 0;
+    detail = code ? ` [${code}: ${cause.message}]` : ` [${cause.message}]`;
+  } else if (cause != null) {
+    detail = ` [${String(cause)}]`;
+  }
+  return `${err.message}${detail} (${url})`;
+}
+var BrightsySideboardApi = class {
+  cfg;
+  fetchImpl;
+  constructor(cfgOrOpts) {
+    const isOpts = !!cfgOrOpts && typeof cfgOrOpts === "object" && ("fetchImpl" in cfgOrOpts || "cfg" in cfgOrOpts) && !("access_token" in cfgOrOpts);
+    if (isOpts) {
+      const opts = cfgOrOpts;
+      this.cfg = opts.cfg ?? loadBrightsyConfig();
+      this.fetchImpl = opts.fetchImpl ?? globalThis.fetch.bind(globalThis);
+    } else {
+      this.cfg = cfgOrOpts ?? loadBrightsyConfig();
+      this.fetchImpl = globalThis.fetch.bind(globalThis);
+    }
+  }
+  get accountId() {
+    return this.cfg.account_id;
+  }
+  get endpoint() {
+    return (this.cfg.endpoint || "https://brightsy.ai").replace(/\/$/, "");
+  }
+  async request(path, init = {}) {
+    await this.refreshIfNeeded();
+    const url = `${this.endpoint}${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.cfg.access_token}`,
+      Accept: "application/json"
+    };
+    if (init.body != null) headers["Content-Type"] = "application/json";
+    let res;
+    try {
+      res = await this.fetchImpl(url, {
+        method: init.method ?? "GET",
+        headers,
+        body: init.body != null ? JSON.stringify(init.body) : void 0
+      });
+    } catch (err) {
+      throw new Error(formatBrightsyFetchError(err, url));
+    }
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.error?.message ?? `${res.status} ${res.statusText} (${url})`);
+    }
+    return await res.json();
+  }
+  async refreshIfNeeded() {
+    const expiresAt = this.cfg.expires_at ?? 0;
+    if (!this.cfg.refresh_token || Date.now() < expiresAt - 6e4) return;
+    const clientId = this.cfg.oauth_client_id || "brightsy-cli";
+    const url = `${this.endpoint}/oauth/token`;
+    let res;
+    try {
+      res = await this.fetchImpl(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+          grant_type: "refresh_token",
+          refresh_token: this.cfg.refresh_token,
+          client_id: clientId
+        })
+      });
+    } catch (err) {
+      throw new Error(formatBrightsyFetchError(err, url));
+    }
+    if (!res.ok) return;
+    const data = await res.json();
+    if (!data.access_token) return;
+    this.cfg.access_token = data.access_token;
+    if (data.refresh_token) this.cfg.refresh_token = data.refresh_token;
+    if (data.expires_in) {
+      this.cfg.expires_at = Date.now() + data.expires_in * 1e3;
+    }
+    saveBrightsyConfig(this.cfg);
+  }
+  async getAccess() {
+    return this.request(
+      `/api/v1beta/desktop/access?accountId=${encodeURIComponent(this.accountId)}`
+    );
+  }
+  async setAccess(enabled, allow_always = false) {
+    return this.request("/api/v1beta/desktop/access", {
+      method: "PUT",
+      body: {
+        accountId: this.accountId,
+        enabled,
+        allow_always
+      }
+    });
+  }
+  async getTasks(status) {
+    const params = new URLSearchParams();
+    if (status) params.set("status", status);
+    params.set("accountId", this.accountId);
+    const q = `?${params.toString()}`;
+    const data = await this.request(
+      `/api/v1beta/desktop/tasks${q}`
+    );
+    return data.tasks ?? [];
+  }
+  async approveTask(taskId) {
+    await this.request(`/api/v1beta/desktop/tasks/${taskId}`, {
+      method: "PATCH",
+      body: { action: "approve" }
+    });
+  }
+  async markRunning(taskId) {
+    await this.request(`/api/v1beta/desktop/tasks/${taskId}`, {
+      method: "PATCH",
+      body: { task_status: "running" }
+    });
+  }
+  async submitResponse(taskId, response) {
+    await this.request(`/api/v1beta/desktop/tasks/${taskId}/response`, {
+      method: "POST",
+      body: { response }
+    });
+  }
+};
+function taskMessageText(task) {
+  const parts = task.message?.parts ?? [];
+  const text = parts.find((p) => p.kind === "text")?.text ?? "";
+  return text.trim();
+}
+
+// src/brightsy/cloud-connect.ts
+var POLL_MS = 5e3;
+var handleTaskChain = Promise.resolve();
+function enqueueHandleTask(fn) {
+  const run2 = handleTaskChain.then(fn, fn);
+  handleTaskChain = run2.then(
+    () => void 0,
+    () => void 0
+  );
+  return run2;
+}
+function refreshWorkspaces() {
+  const orch = getOrchestrator();
+  return orch.listWorkspaces();
+}
+async function handleTask(api, task, opts) {
+  const log = opts.onLog ?? (() => void 0);
+  let message = taskMessageText(task);
+  if (!message) {
+    log(`skip ${task.id.slice(0, 8)}: empty message`);
+    return;
+  }
+  if (task.task_status !== "pending" && task.task_status !== "running" && task.task_status !== "awaiting_confirmation") {
+    return;
+  }
+  const workspaces = refreshWorkspaces();
+  for (const ws of workspaces) {
+    await getOrchestrator().reconcile(ws.path).catch(() => void 0);
+  }
+  const inventory = await enrichWorkspacesWithGithub(workspaces);
+  const coordinator = ensureCloudCoordinator(opts.agent);
+  let fresh = readThread(coordinator.id) ?? coordinator;
+  const parsed = parseForceStopMessage(message);
+  if (parsed.forceStop) {
+    try {
+      getOrchestrator().stop(fresh.id);
+      log(`force-stop ${task.id.slice(0, 8)} \u2192 coordinator ${fresh.id.slice(0, 8)}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log(`force-stop ${task.id.slice(0, 8)}: ${msg}`);
+    }
+    if (!parsed.remainder) {
+      if (task.task_status === "awaiting_confirmation") {
+        await api.approveTask(task.id).catch(() => void 0);
+      }
+      await api.markRunning(task.id).catch(() => void 0);
+      await api.submitResponse(task.id, CLOUD_COORDINATOR_STOPPED_REPLY);
+      log(`replied stopped ${task.id.slice(0, 8)}`);
+      return;
+    }
+    message = parsed.remainder;
+    fresh = readThread(coordinator.id) ?? ensureCloudCoordinator(opts.agent);
+  }
+  if (fresh.status === "running" || fresh.status === "queued") {
+    log(
+      `busy ${task.id.slice(0, 8)} \u2192 coordinator ${fresh.id.slice(0, 8)} (${fresh.status})`
+    );
+    if (task.task_status === "awaiting_confirmation") {
+      await api.approveTask(task.id).catch(() => void 0);
+    }
+    await api.markRunning(task.id).catch(() => void 0);
+    await api.submitResponse(task.id, CLOUD_COORDINATOR_BUSY_REPLY);
+    log(`replied busy ${task.id.slice(0, 8)}`);
+    return;
+  }
+  if (task.task_status === "awaiting_confirmation") {
+    log(`approve ${task.id.slice(0, 8)}`);
+    await api.approveTask(task.id);
+    task = { ...task, task_status: "pending" };
+  }
+  log(
+    `run ${task.id.slice(0, 8)} \u2192 coordinator ${fresh.id.slice(0, 8)} (${inventory.length} workspace${inventory.length === 1 ? "" : "s"})`
+  );
+  await api.markRunning(task.id).catch(() => void 0);
+  const orch = getOrchestrator();
+  const prompt = [
+    coordinatorSystemPrompt({
+      goal: fresh.sourceRef || CLOUD_ORCHESTRATOR_GOAL,
+      parentId: fresh.id,
+      workspaces: inventory,
+      audience: "cloud"
+    }),
+    "",
+    "--- Cloud agent request ---",
+    message
+  ].join("\n");
+  try {
+    await orch.send(fresh.id, prompt);
+    await orch.waitForTurn(fresh.id, 14 * 60 * 1e3);
+    const result = orch.getTurnResult(fresh.id);
+    const reply = result.text.trim() || `(coordinator finished with status ${result.status}, no text)`;
+    await api.submitResponse(task.id, reply);
+    log(`replied ${task.id.slice(0, 8)} (${reply.length} chars)`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const timedOut = /timed out|timeout/i.test(msg);
+    const reply = timedOut ? CLOUD_COORDINATOR_TIMEOUT_REPLY : `Sideboard coordinator error: ${msg}`;
+    await api.submitResponse(task.id, reply).catch(() => void 0);
+    log(`replied error ${task.id.slice(0, 8)}: ${msg}`);
+    if (!timedOut) throw err;
+  }
+}
+async function runCloudConnect(opts) {
+  const log = opts.onLog ?? console.log;
+  const api = opts.api ?? new BrightsySideboardApi(
+    opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : void 0
+  );
+  const enableAccess = opts.enableAccess !== false;
+  const allowAlways = opts.allowAlways !== false;
+  const pollMs = opts.pollIntervalMs ?? POLL_MS;
+  const workspaces = refreshWorkspaces();
+  const coordinator = ensureCloudCoordinator(opts.agent);
+  const access = await api.getAccess();
+  if (!access.enabled) {
+    if (!enableAccess) {
+      throw new Error(
+        "Brightsy desktop access is disabled. Enable Cloud messages in Sideboard Settings \u2192 Brightsy, or Brightsy User Settings."
+      );
+    }
+    log("Enabling Brightsy desktop access\u2026");
+    await api.setAccess(true, allowAlways);
+  } else if (allowAlways && !access.allow_always) {
+    await api.setAccess(true, true);
+  }
+  log(
+    `Connected to Brightsy (${api.endpoint}). Polling desktop tasks every ${pollMs / 1e3}s\u2026`
+  );
+  log(
+    `Global coordinator: ${coordinator.id.slice(0, 8)}  agent: ${opts.agent}  global chats: ${listGlobalThreads().length}`
+  );
+  log(`Workspaces (${workspaces.length}):`);
+  for (const line of formatWorkspaceInventory(workspaces).split("\n")) {
+    log(`  ${line}`);
+  }
+  const inFlight = /* @__PURE__ */ new Set();
+  let consecutivePollFailures = 0;
+  while (!opts.signal?.aborted) {
+    try {
+      const hadFailures = consecutivePollFailures > 0;
+      const [pending, awaiting, running] = await Promise.all([
+        api.getTasks("pending"),
+        api.getTasks("awaiting_confirmation"),
+        api.getTasks("running")
+      ]);
+      consecutivePollFailures = 0;
+      if (hadFailures) log("poll recovered");
+      const tasks = [...awaiting, ...pending, ...running];
+      for (const task of tasks) {
+        if (inFlight.has(task.id)) continue;
+        if (task.task_status === "running") continue;
+        inFlight.add(task.id);
+        const message = taskMessageText(task);
+        if (message && parseForceStopMessage(message).forceStop) {
+          try {
+            getOrchestrator().stop(ensureCloudCoordinator(opts.agent).id);
+            log(
+              `force-stop interrupt ${task.id.slice(0, 8)} \u2192 coordinator`
+            );
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log(`force-stop interrupt ${task.id.slice(0, 8)}: ${msg}`);
+          }
+        }
+        void enqueueHandleTask(() => handleTask(api, task, opts)).catch((err) => {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`error ${task.id.slice(0, 8)}: ${msg}`);
+        }).finally(() => inFlight.delete(task.id));
+      }
+    } catch (err) {
+      consecutivePollFailures += 1;
+      const msg = err instanceof Error ? err.message : String(err);
+      if (consecutivePollFailures === 1) {
+        log(`poll retry: ${msg}`);
+      } else {
+        log(`poll error: ${msg}`);
+      }
+    }
+    await new Promise((resolve) => {
+      const t = setTimeout(resolve, pollMs);
+      opts.signal?.addEventListener(
+        "abort",
+        () => {
+          clearTimeout(t);
+          resolve();
+        },
+        { once: true }
+      );
+    });
+  }
+}
+export {
+  BRIGHTSY_MCP_ALLOWED_TOOLS,
+  BrightsySideboardApi,
+  CLOUD_COORDINATOR_BUSY_REPLY,
+  CLOUD_COORDINATOR_STOPPED_REPLY,
+  CLOUD_COORDINATOR_TIMEOUT_REPLY,
+  CLOUD_ORCHESTRATOR_GOAL,
+  CONTEXT_COMPACT_CHARS,
+  CONTEXT_KEEP_RECENT_CHARS,
+  CONTEXT_KEEP_RECENT_MESSAGES,
+  CONTEXT_MIN_MESSAGES,
+  COORDINATOR_TOOL_PLAYBOOK,
+  FAMOUS_SOCCER_TEAMS,
+  GLOBAL_WORKSPACE_ID,
+  HARNESS_ENV_KEYS,
+  MAX_ANTHROPIC_CACHE_CONTROL_BLOCKS,
+  Orchestrator,
+  PLAN_MODE_INSTRUCTION,
+  SIDEBOARD_FORCE_STOP,
+  SIDEBOARD_MCP_ALLOWED_TOOLS,
+  addWorkspace,
+  adoptThread,
+  allAdapters,
+  allocatePort,
+  allocatePortRange,
+  allocateTeamName,
+  allocateTeamSlug,
+  appDataDir,
+  appSettingsPath,
+  appendMessage,
+  applyAgentEvent,
+  applyAppEnvironment,
+  applyCompaction,
+  applyThreadIntoMain,
+  autoCleanupOrphansEnabled,
+  autoRenameBranchEnabled,
+  autoRunAfterSetupEnabled,
+  branchDisplayLabel,
+  brightsyAdapter,
+  brightsyCloudConnectAgent,
+  brightsyCloudConnectEnabled,
+  brightsyConfigPath,
+  brightsyMcpAllowedTools,
+  brightsyMcpServerName,
+  buildCachedUserContent,
+  buildClaudeStreamJsonUserMessage,
+  buildForkTranscriptAttachment,
+  buildSessionSeed,
+  buildWorkspaceScriptEnv,
+  caffeinateWhileCloudConnectEnabled,
+  caffeinateWhileRunningEnabled,
+  captureLoginEnv,
+  captureTurnBaseline,
+  childEnvWithAppSettings,
+  claudeAdapter,
+  claudeChromeEnabled,
+  claudeUserSettingsPath,
+  cleanupOrphanWorktrees,
+  cloneRepoIntoSideboard,
+  codexAdapter,
+  collectTakenTeamSlugs,
+  commitAll,
+  conductorDbPath,
+  confirmLand,
+  connectBrightsyTeam,
+  coordinatorSystemPrompt,
+  coordinatorTurnReminder,
+  copyConfiguredFiles,
+  countCacheControlBlocks,
+  createChatTab,
+  createEmptyThread,
+  createGlobalChat,
+  createOrUpdatePr,
+  createThread,
+  createThreadWorktree,
+  currentBranch,
+  cursorAdapter,
+  cursorSdkMessageToEvents,
+  decodeBrightsyTarget,
+  deleteBranchOnPurgeEnabled,
+  deleteThreadRecord,
+  detectAgents,
+  detectLocalMergeConflicts,
+  disconnectBrightsyTeam,
+  discoverSkills,
+  encodeBrightsyTarget,
+  enrichWorkspacesWithGithub,
+  ensureAgentPath,
+  ensureCloudCoordinator,
+  ensureGlobalCoordinatorCwd,
+  ensureWorkspace,
+  estimateMessageChars,
+  estimateThreadChars,
+  expandComposerPrompt,
+  extractiveSummary,
+  fetchPrHead,
+  finalizeParts,
+  findInvalidCacheControlTtlOrder,
+  findOrphanWorktrees,
+  findThreadByRef,
+  flattenTurnInput,
+  forkChatTab,
+  forkMessageSlice,
+  forkThreadWorktree,
+  formatAgentInstructions,
+  formatBrightsyFetchError,
+  formatMessagesAsTranscript,
+  formatRenameBranchDirective,
+  formatTranscriptMarkdown,
+  formatWorkspaceInventory,
+  formatWorktreeDirective,
+  getAdapter,
+  getBrightsySession,
+  getDefaultRunScript,
+  getDiff,
+  getDiffSummary,
+  getGitHubStatus,
+  getIssueSource,
+  getLinearApiKey,
+  getOrchestrator,
+  getPr,
+  getPrChecks,
+  getPrDetails,
+  getRepoSetupInfo,
+  getRunMode,
+  getRunScript,
+  gh,
+  git,
+  globalAgentCwd,
+  harnessEnvKey,
+  hasConductorHook,
+  hasCursorWorktreeSetup,
+  hasRepoHook,
+  hasWorkspaceHook,
+  healOrchestrationSoccerTitles,
+  importConductorWorkspace,
+  importConductorWorkspaceAsync,
+  initializeGitRepository,
+  inspectGitWorktree,
+  isBrightsyConnected,
+  isBrightsyNdjsonLine,
+  isCloudCoordinatorThread,
+  isDirty,
+  isGlobalRepoPath,
+  isGlobalThread,
+  isLinearConnected,
+  isOrchestratorThread,
+  isPlaceholderBranch,
+  listBranchCommits,
+  listBranches,
+  listBrightsyAccounts,
+  listBrightsyChatTargets,
+  listConductorWorkspaces,
+  listConnectedBrightsyTeams,
+  listGitHubIssues,
+  listGlobalThreads,
+  listIssues,
+  listLinearIssues,
+  listLinearIssuesDirect,
+  listPrs,
+  listRunScripts,
+  listThreads,
+  listWorkspaces,
+  listWorktreeFiles,
+  listWorktrees,
+  loadAgentInstructions,
+  loadAppSettings,
+  loadBrightsyConfig,
+  loadConductorSettings,
+  loadRepoSettings,
+  loadWorkspaceSettings,
+  locksDir,
+  maxConcurrentAgents,
+  maybeCompactContext,
+  mcpAllowTools,
+  mcpAuthWarnings,
+  mergePr,
+  mergeUsage,
+  normalizeParseResult,
+  normalizeThread,
+  normalizeTurnInput,
+  normalizeWorktreePath,
+  opencodeAdapter,
+  orchestrationTitleNeedsSoccerNickname,
+  orchestratorSessionPoisonedByBuiltins,
+  parseCursorRunnerLine,
+  parseForceStopMessage,
+  parseGithubSlugFromRemoteUrl,
+  parseMcpList,
+  partsToAssistantText,
+  permissionMode,
+  previewLand,
+  pushBranch,
+  readSkillBody,
+  readThread,
+  readWorktreeFile,
+  readWorktreeInclude,
+  refreshGitHubAuth,
+  removeWorkspace,
+  removeWorktree,
+  repoSlug,
+  requireAgent,
+  resolveClaudeExecutable,
+  resolveConductorCursorAgentId,
+  resolveDefaultBranch,
+  resolveDiffBaseRef,
+  resolveEffectiveIssueSource,
+  resolveFilesToCopy,
+  resolveGithubRepoSlug,
+  resolvePrSelector,
+  resolveRepoRoot,
+  resolveWorktreeStartPoint,
+  run,
+  runArchiveScript,
+  runCloudConnect,
+  runCursorWorktreeSetup,
+  runSetupScript,
+  sameWorktreePath,
+  sanitizeMcpServerName,
+  saveAppSettings,
+  setStatus,
+  settingsSourceLabel,
+  shouldCompactContext,
+  shouldRunWorktreeCleanup,
+  sideboardHomeDir,
+  sideboardReposDir,
+  sideboardWorkspacesDir,
+  slugify,
+  spawnAgentTurn,
+  splitForCompaction,
+  startDevServer,
+  startMcpServer,
+  startOrchestration,
+  stripBrightsyNdjsonNoise,
+  suggestSlug,
+  summarizeConversation,
+  switchBrightsyAccount,
+  syncWorkspacesFromThreads,
+  takenTeamSlugsForChatTab,
+  takenTeamSlugsForOrchestration,
+  taskMessageText,
+  threadDisplayLabel,
+  threadFilePath,
+  threadLockPath,
+  threadsDir,
+  threadsSharingWorktree,
+  toolDescription,
+  toolDetail,
+  toolFilePath,
+  totalTokens,
+  updateAdvancedSettings,
+  updateAppEnvironment,
+  updateBrightsySettings,
+  updateClaudeSettings,
+  updateIntegrationsSettings,
+  updateThread,
+  validateLinearApiKey,
+  withAgentInstructions,
+  withThreadLock,
+  workspaceSettingsSourceLabel,
+  worktreeCleanupSettings,
+  worktreeDisplayLabel,
+  worktreeDisplayLabelForGroup,
+  worktreeNameFromPath,
+  worktreesRoot,
+  writeInjectedMcpConfig,
+  writeThread,
+  writeWorktreeFile
+};