@sideboard-ai/core 0.1.46 → 0.1.49

package/dist/{agents-6L6VENDT.js → agents-3P4N6KHC.js}

@@ -26,7 +26,7 @@ import {
   permissionMode,
   resolveCursorModelId,
   resolveQuotaFallbackAgent
-} from "./chunk-TQK2OYPU.js";
+} from "./chunk-SS34TVSY.js";
 import {
   ORCHESTRATOR_AGENT_KINDS,
   assertOrchestratorCapableAgent,

package/dist/agents-LUB3Q773.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+import {
+  CLAUDE_MODEL_CATALOG,
+  PLAN_MODE_INSTRUCTION,
+  allAdapters,
+  brightsyAdapter,
+  claudeAdapter,
+  codexAdapter,
+  cursorAdapter,
+  cursorSdkMessageToEvents,
+  decodeBrightsyTarget,
+  encodeBrightsyTarget,
+  getAdapter,
+  getAgentSetupInfo,
+  installAgent,
+  isCursorAutoModel,
+  isSessionQuotaLimit,
+  listAgentSetupInfo,
+  listBrightsyChatTargets,
+  listCodexModels,
+  listCursorModels,
+  listModelsForAgent,
+  listOpencodeModels,
+  loginAgent,
+  openInSystemTerminal,
+  opencodeAdapter,
+  parseCursorRunnerLine,
+  parseSessionQuotaResetAt,
+  permissionMode,
+  resolveCursorModelId,
+  resolveQuotaFallbackAgent
+} from "./chunk-RQI4TOXK.js";
+import "./chunk-E35APBHV.js";
+import "./chunk-HBJSHRY2.js";
+import {
+  ORCHESTRATOR_AGENT_KINDS,
+  assertOrchestratorCapableAgent,
+  coerceOrchestratorAgent,
+  isOrchestratorCapableAgent
+} from "./chunk-S2LL5HA4.js";
+import {
+  ensureAgentPath
+} from "./chunk-ISY4EGF6.js";
+import "./chunk-KGZBYWZ3.js";
+import "./chunk-7MV3RXSC.js";
+export {
+  CLAUDE_MODEL_CATALOG,
+  ORCHESTRATOR_AGENT_KINDS,
+  PLAN_MODE_INSTRUCTION,
+  allAdapters,
+  assertOrchestratorCapableAgent,
+  brightsyAdapter,
+  claudeAdapter,
+  codexAdapter,
+  coerceOrchestratorAgent,
+  cursorAdapter,
+  cursorSdkMessageToEvents,
+  decodeBrightsyTarget,
+  encodeBrightsyTarget,
+  ensureAgentPath,
+  getAdapter,
+  getAgentSetupInfo,
+  installAgent,
+  isCursorAutoModel,
+  isOrchestratorCapableAgent,
+  isSessionQuotaLimit,
+  listAgentSetupInfo,
+  listBrightsyChatTargets,
+  listCodexModels,
+  listCursorModels,
+  listModelsForAgent,
+  listOpencodeModels,
+  loginAgent,
+  openInSystemTerminal,
+  opencodeAdapter,
+  parseCursorRunnerLine,
+  parseSessionQuotaResetAt,
+  permissionMode,
+  resolveCursorModelId,
+  resolveQuotaFallbackAgent
+};

package/dist/app-settings-7XVDQJ7F.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+
+import {
+  HARNESS_ENV_KEYS,
+  appSettingsPath,
+  applyAppEnvironment,
+  autoCleanupOrphansEnabled,
+  autoRenameBranchEnabled,
+  autoRunAfterSetupEnabled,
+  brightsyCloudConnectAgent,
+  brightsyCloudConnectEnabled,
+  caffeinateWhileCloudConnectEnabled,
+  caffeinateWhileRunningEnabled,
+  childEnvWithAppSettings,
+  claudeChromeEnabled,
+  claudeUserSettingsPath,
+  deleteBranchOnPurgeEnabled,
+  getDefaultAgent,
+  getDefaultEffort,
+  getDefaultFast,
+  getDefaultModel,
+  getIssueSource,
+  getLinearApiKey,
+  harnessEnvKey,
+  isLinearConnected,
+  loadAppSettings,
+  maxConcurrentAgents,
+  orchestrationQuotaFallbackAgent,
+  orchestrationQuotaOnLimit,
+  resolveClaudeExecutable,
+  resolveEffectiveIssueSource,
+  resolveThreadDefaults,
+  saveAppSettings,
+  updateAdvancedSettings,
+  updateAppEnvironment,
+  updateBrightsySettings,
+  updateClaudeSettings,
+  updateDefaultsSettings,
+  updateIntegrationsSettings
+} from "./chunk-HBJSHRY2.js";
+import "./chunk-KGZBYWZ3.js";
+import "./chunk-7MV3RXSC.js";
+export {
+  HARNESS_ENV_KEYS,
+  appSettingsPath,
+  applyAppEnvironment,
+  autoCleanupOrphansEnabled,
+  autoRenameBranchEnabled,
+  autoRunAfterSetupEnabled,
+  brightsyCloudConnectAgent,
+  brightsyCloudConnectEnabled,
+  caffeinateWhileCloudConnectEnabled,
+  caffeinateWhileRunningEnabled,
+  childEnvWithAppSettings,
+  claudeChromeEnabled,
+  claudeUserSettingsPath,
+  deleteBranchOnPurgeEnabled,
+  getDefaultAgent,
+  getDefaultEffort,
+  getDefaultFast,
+  getDefaultModel,
+  getIssueSource,
+  getLinearApiKey,
+  harnessEnvKey,
+  isLinearConnected,
+  loadAppSettings,
+  maxConcurrentAgents,
+  orchestrationQuotaFallbackAgent,
+  orchestrationQuotaOnLimit,
+  resolveClaudeExecutable,
+  resolveEffectiveIssueSource,
+  resolveThreadDefaults,
+  saveAppSettings,
+  updateAdvancedSettings,
+  updateAppEnvironment,
+  updateBrightsySettings,
+  updateClaudeSettings,
+  updateDefaultsSettings,
+  updateIntegrationsSettings
+};

package/dist/{chunk-SZAKJ4TR.js → chunk-3NAS4MWH.js}

@@ -1,6 +1,6 @@
 import {
   isGlobalRepoPath
-} from "./chunk-SPCU3MFY.js";
+} from "./chunk-5WYEJ3F3.js";
 import {
   ensureGhPreferOrigin,
   resolveRepoRoot

package/dist/{chunk-SPCU3MFY.js → chunk-5WYEJ3F3.js}

@@ -1,9 +1,9 @@
-import {
-  ensureGlobalCoordinatorCwd
-} from "./chunk-6NAPN2N5.js";
 import {
   assertOrchestratorCapableAgent
 } from "./chunk-GI7E5733.js";
+import {
+  ensureGlobalCoordinatorCwd
+} from "./chunk-ZQCQIWIP.js";
 import {
   allocateTeamName,
   takenSlugsFromThread,

package/dist/chunk-7MV3RXSC.js

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+
+
+// src/store/paths.ts
+import { basename } from "path";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { mkdirSync } from "fs";
+
+// src/hook/settings.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { parse as parseToml } from "smol-toml";
+function expandHome(path) {
+  if (path.startsWith("~/") || path === "~") {
+    return join(homedir(), path.slice(2));
+  }
+  return path;
+}
+function parseAvailableIn(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const out = [];
+  for (const item of raw) {
+    if (item === "local" || item === "cloud") out.push(item);
+  }
+  return out.length ? out : void 0;
+}
+function parseSettingsFile(path, source) {
+  if (!existsSync(path)) return null;
+  const raw = readFileSync(path, "utf8");
+  const data = parseToml(raw);
+  const scripts = data.scripts ?? {};
+  const setup = typeof scripts.setup === "string" ? scripts.setup : void 0;
+  const archive = typeof scripts.archive === "string" ? scripts.archive : void 0;
+  const runMode = "run_mode" in scripts ? scripts.run_mode === "nonconcurrent" ? "nonconcurrent" : "concurrent" : void 0;
+  const filesToCopy = [];
+  const files = data.files;
+  if (Array.isArray(files?.copy)) {
+    filesToCopy.push(...files.copy.map(String));
+  }
+  const copySection = data["files-to-copy"];
+  if (Array.isArray(copySection?.paths)) {
+    filesToCopy.push(...copySection.paths.map(String));
+  }
+  const fileIncludeGlobs = [];
+  if (Array.isArray(data.file_include_globs)) {
+    fileIncludeGlobs.push(...data.file_include_globs.map(String));
+  }
+  const filesGlobs = files;
+  if (Array.isArray(filesGlobs?.include)) {
+    fileIncludeGlobs.push(...filesGlobs.include.map(String));
+  }
+  if (Array.isArray(filesGlobs?.include_globs)) {
+    fileIncludeGlobs.push(...filesGlobs.include_globs.map(String));
+  }
+  const runScripts = [];
+  const run = scripts.run;
+  if (typeof run === "string" && run.trim()) {
+    runScripts.push({ name: "dev", command: run, default: true });
+  } else if (run && typeof run === "object") {
+    for (const [name, value] of Object.entries(run)) {
+      if (value && typeof value.command === "string") {
+        runScripts.push({
+          name,
+          command: value.command,
+          default: Boolean(value.default),
+          icon: typeof value.icon === "string" ? value.icon : void 0,
+          availableIn: parseAvailableIn(value.available_in)
+        });
+      }
+    }
+  }
+  const worktrees = data.worktrees;
+  const worktreesRoot2 = typeof worktrees?.root === "string" ? expandHome(worktrees.root) : void 0;
+  const editor = typeof data.editor === "string" ? String(data.editor) : void 0;
+  const promptsRaw = data.prompts ?? {};
+  const prompts = {
+    renameBranch: typeof promptsRaw.rename_branch === "string" ? promptsRaw.rename_branch : void 0,
+    createPr: typeof promptsRaw.create_pr === "string" ? promptsRaw.create_pr : void 0,
+    general: typeof promptsRaw.general === "string" ? promptsRaw.general : void 0
+  };
+  const hasPrompts = Boolean(prompts.renameBranch || prompts.createPr || prompts.general);
+  return {
+    source,
+    setup,
+    archive,
+    runMode,
+    filesToCopy: filesToCopy.length ? filesToCopy : void 0,
+    fileIncludeGlobs: fileIncludeGlobs.length ? fileIncludeGlobs : void 0,
+    runScripts,
+    worktreesRoot: worktreesRoot2,
+    editor,
+    prompts: hasPrompts ? prompts : void 0
+  };
+}
+function mergeRunScripts(base, overlay) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const s of base) byName.set(s.name, s);
+  for (const s of overlay) byName.set(s.name, s);
+  return [...byName.values()];
+}
+function mergeSettings(base, overlay) {
+  if (!base) return overlay;
+  if (!overlay) return base;
+  const prompts = {
+    renameBranch: overlay.prompts?.renameBranch ?? base.prompts?.renameBranch,
+    createPr: overlay.prompts?.createPr ?? base.prompts?.createPr,
+    general: overlay.prompts?.general ?? base.prompts?.general
+  };
+  const hasPrompts = Boolean(prompts.renameBranch || prompts.createPr || prompts.general);
+  return {
+    source: overlay.source,
+    setup: overlay.setup ?? base.setup,
+    archive: overlay.archive ?? base.archive,
+    runMode: overlay.runMode ?? base.runMode,
+    filesToCopy: overlay.filesToCopy ?? base.filesToCopy,
+    fileIncludeGlobs: overlay.fileIncludeGlobs ?? base.fileIncludeGlobs,
+    runScripts: mergeRunScripts(base.runScripts, overlay.runScripts),
+    worktreesRoot: overlay.worktreesRoot ?? base.worktreesRoot,
+    editor: overlay.editor ?? base.editor,
+    prompts: hasPrompts ? prompts : void 0
+  };
+}
+function finalizeSettings(parsed) {
+  if (!parsed) return null;
+  return {
+    ...parsed,
+    runMode: parsed.runMode ?? "concurrent",
+    runScripts: parsed.runScripts
+  };
+}
+function familyFiles(rootPath, source) {
+  const dir = join(rootPath, `.${source}`);
+  return {
+    toml: join(dir, "settings.toml"),
+    local: join(dir, "settings.local.toml")
+  };
+}
+function familyExists(rootPath, source) {
+  const files = familyFiles(rootPath, source);
+  return existsSync(files.toml) || existsSync(files.local);
+}
+function detectFamily(rootPath) {
+  if (familyExists(rootPath, "sideboard")) return "sideboard";
+  if (familyExists(rootPath, "conductor")) return "conductor";
+  return null;
+}
+function loadCommittedToml(rootPath, source) {
+  return parseSettingsFile(familyFiles(rootPath, source).toml, source);
+}
+function loadLocalToml(rootPath, source) {
+  return parseSettingsFile(familyFiles(rootPath, source).local, source);
+}
+function loadAnyLocal(rootPath) {
+  return mergeSettings(
+    loadLocalToml(rootPath, "conductor"),
+    loadLocalToml(rootPath, "sideboard")
+  );
+}
+function normPath(p) {
+  return p.replace(/\/+$/, "");
+}
+function loadRepoSettings(repoPath) {
+  const family = detectFamily(repoPath);
+  if (!family) return null;
+  const merged = mergeSettings(
+    loadCommittedToml(repoPath, family),
+    loadLocalToml(repoPath, family)
+  );
+  return finalizeSettings(merged);
+}
+function loadWorkspaceSettings(worktreePath, repoPath) {
+  const wtFamily = detectFamily(worktreePath);
+  const repoFamily = repoPath && normPath(repoPath) !== normPath(worktreePath) ? detectFamily(repoPath) : null;
+  const wtToml = wtFamily ? loadCommittedToml(worktreePath, wtFamily) : null;
+  const repoToml = repoPath && repoFamily ? loadCommittedToml(repoPath, repoFamily) : null;
+  let merged = wtToml ?? repoToml;
+  if (repoPath && normPath(repoPath) !== normPath(worktreePath)) {
+    merged = mergeSettings(merged, loadAnyLocal(repoPath));
+  }
+  merged = mergeSettings(merged, loadAnyLocal(worktreePath));
+  return finalizeSettings(merged);
+}
+function settingsSourceLabel(rootPath) {
+  const family = detectFamily(rootPath);
+  if (!family) return null;
+  const files = familyFiles(rootPath, family);
+  if (existsSync(files.toml) && existsSync(files.local)) {
+    return `.${family}/settings.toml + local`;
+  }
+  if (existsSync(files.local)) return `.${family}/settings.local.toml`;
+  return `.${family}/settings.toml`;
+}
+function workspaceSettingsSourceLabel(worktreePath, repoPath) {
+  const wt = settingsSourceLabel(worktreePath);
+  if (wt) return `${wt} (worktree)`;
+  if (repoPath && normPath(repoPath) !== normPath(worktreePath)) {
+    const repo = settingsSourceLabel(repoPath);
+    if (repo) return `${repo} (main repo)`;
+  }
+  return null;
+}
+
+// src/store/paths.ts
+function appDataDir() {
+  const override = process.env.SIDEBOARD_APP_DATA?.trim();
+  const base = override ? override : process.platform === "darwin" ? join2(homedir2(), "Library", "Application Support", "sideboard") : process.platform === "win32" ? join2(process.env.APPDATA ?? join2(homedir2(), "AppData", "Roaming"), "sideboard") : join2(homedir2(), ".local", "share", "sideboard");
+  mkdirSync(base, { recursive: true });
+  return base;
+}
+function threadsDir() {
+  const dir = join2(appDataDir(), "threads");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function locksDir() {
+  const dir = join2(appDataDir(), "locks");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function sideboardHomeDir() {
+  const dir = join2(homedir2(), "sideboard");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function sideboardReposDir() {
+  const dir = join2(sideboardHomeDir(), "repos");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function sideboardWorkspacesDir() {
+  const dir = join2(sideboardHomeDir(), "workspaces");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function repoSlug(repoPath) {
+  return basename(repoPath.replace(/\/$/, "")) || "repo";
+}
+function worktreesRoot(repoPath) {
+  const settings = loadRepoSettings(repoPath);
+  if (settings?.worktreesRoot) {
+    mkdirSync(settings.worktreesRoot, { recursive: true });
+    return settings.worktreesRoot;
+  }
+  const dir = join2(sideboardWorkspacesDir(), repoSlug(repoPath));
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function threadFilePath(id) {
+  return join2(threadsDir(), `${id}.json`);
+}
+function threadLockPath(id) {
+  return join2(locksDir(), `${id}.lock`);
+}
+function globalAgentCwd() {
+  const dir = join2(appDataDir(), "global");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export {
+  loadRepoSettings,
+  loadWorkspaceSettings,
+  workspaceSettingsSourceLabel,
+  appDataDir,
+  threadsDir,
+  locksDir,
+  sideboardHomeDir,
+  sideboardReposDir,
+  sideboardWorkspacesDir,
+  repoSlug,
+  worktreesRoot,
+  threadFilePath,
+  threadLockPath,
+  globalAgentCwd
+};

package/dist/chunk-DF5VQQKA.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+
+import {
+  assertOrchestratorCapableAgent
+} from "./chunk-S2LL5HA4.js";
+import {
+  ensureGlobalCoordinatorCwd
+} from "./chunk-GZXBYHJC.js";
+import {
+  allocateTeamName,
+  takenSlugsFromThread,
+  teamSlugFromName
+} from "./chunk-ZVV5EEQN.js";
+import {
+  createEmptyThread,
+  listThreads,
+  updateThread,
+  writeThread
+} from "./chunk-EOYDCKQC.js";
+import {
+  globalAgentCwd
+} from "./chunk-7MV3RXSC.js";
+
+// src/brightsy/cloud-connect-constants.ts
+var CLOUD_ORCHESTRATOR_GOAL = "Cloud-connected Sideboard orchestrator";
+var SIDEBOARD_FORCE_STOP = "SIDEBOARD_FORCE_STOP";
+var CLOUD_COORDINATOR_BUSY_REPLY = [
+  "Sideboard is busy with an in-progress client/desktop tool turn on the global coordinator.",
+  "I did not start a new orchestration turn.",
+  `To force-stop the in-progress turn, send another desktop request whose first line is exactly ${SIDEBOARD_FORCE_STOP}`,
+  "(optional follow-up request on later lines).",
+  "What do you want me to do? (retry later, wait until idle, force-stop, rephrase, or cancel)"
+].join(" ");
+var CLOUD_COORDINATOR_STOPPED_REPLY = [
+  "Sideboard force-stopped the in-progress global coordinator turn.",
+  "No new orchestration request was started."
+].join(" ");
+var CLOUD_COORDINATOR_TIMEOUT_REPLY = [
+  "Sideboard global coordinator timed out waiting for the local agent turn to finish.",
+  "I did not produce a full orchestration result.",
+  `To force-stop the in-progress turn, send another desktop request whose first line is exactly ${SIDEBOARD_FORCE_STOP}`,
+  "(optional follow-up request on later lines).",
+  "What do you want me to do? (retry later, wait, force-stop, rephrase, or cancel)"
+].join(" ");
+
+// src/store/global-workspace.ts
+var GLOBAL_WORKSPACE_ID = "__global__";
+function isGlobalThread(thread) {
+  return Boolean(thread && thread.repoPath === GLOBAL_WORKSPACE_ID);
+}
+function isGlobalRepoPath(repoPath) {
+  return repoPath === GLOBAL_WORKSPACE_ID;
+}
+function isOrchestratorThread(thread) {
+  return Boolean(
+    thread && (thread.sourceType === "orchestration" || isGlobalThread(thread))
+  );
+}
+function orchestratorSessionPoisonedByBuiltins(thread) {
+  if (!thread?.messages?.length) return false;
+  let usedBuiltin = false;
+  let usedSideboardMcp = false;
+  for (const msg of thread.messages) {
+    for (const part of msg.parts ?? []) {
+      if (part.type !== "tool") continue;
+      if (part.name.startsWith("mcp__sideboard")) {
+        usedSideboardMcp = true;
+      } else if (part.name === "Bash" || part.name === "Edit" || part.name === "Write" || part.name === "Read" || part.name === "Glob" || part.name === "Grep") {
+        usedBuiltin = true;
+      }
+    }
+  }
+  return usedBuiltin && !usedSideboardMcp;
+}
+function isCloudCoordinatorThread(thread) {
+  if (thread.sourceRef === CLOUD_ORCHESTRATOR_GOAL) {
+    return isGlobalThread(thread) || thread.sourceType === "orchestration";
+  }
+  if (thread.title === CLOUD_ORCHESTRATOR_GOAL) {
+    return isGlobalThread(thread) || thread.sourceType === "orchestration";
+  }
+  return false;
+}
+function orchestrationTitleNeedsSoccerNickname(thread) {
+  if (!isOrchestratorThread(thread)) return false;
+  const title = thread.title?.trim() ?? "";
+  if (teamSlugFromName(title)) return false;
+  if (title === CLOUD_ORCHESTRATOR_GOAL) return true;
+  if (!title || title === "Untitled") return true;
+  if (thread.userSetTitle) return false;
+  if (thread.sourceRef?.trim() && title === thread.sourceRef.trim()) return true;
+  return false;
+}
+function takenTeamSlugsForOrchestration() {
+  const taken = /* @__PURE__ */ new Set(["global"]);
+  for (const thread of listThreads({ includeArchived: true })) {
+    if (thread.status === "archived") continue;
+    for (const slug of takenSlugsFromThread(thread)) {
+      taken.add(slug);
+    }
+  }
+  return [...taken];
+}
+function createGlobalChat(opts) {
+  ensureGlobalCoordinatorCwd();
+  const isCloud = opts.sourceRef === CLOUD_ORCHESTRATOR_GOAL || opts.title?.trim() === CLOUD_ORCHESTRATOR_GOAL;
+  const explicit = opts.title?.trim();
+  const title = explicit && explicit !== CLOUD_ORCHESTRATOR_GOAL ? explicit : allocateTeamName(takenTeamSlugsForOrchestration()).name;
+  const sourceRef = opts.sourceRef?.trim() || (isCloud ? CLOUD_ORCHESTRATOR_GOAL : title);
+  const agent = assertOrchestratorCapableAgent(opts.agent);
+  const thread = createEmptyThread({
+    title,
+    // Stick nicknames the same way chat tabs do (avoid later sync overwrites).
+    userSetTitle: true,
+    sourceType: "orchestration",
+    sourceRef,
+    branchName: "global",
+    worktreePath: globalAgentCwd(),
+    repoPath: GLOBAL_WORKSPACE_ID,
+    agent,
+    autonomy: opts.autonomy ?? "default",
+    model: opts.model ?? null,
+    effort: opts.effort ?? "high",
+    fast: Boolean(opts.fast),
+    planMode: Boolean(opts.planMode),
+    attachments: opts.attachments ?? [],
+    parentThreadId: opts.parentThreadId ?? null,
+    status: "idle"
+  });
+  writeThread(thread);
+  return thread;
+}
+function healOrchestrationSoccerTitles() {
+  let healed = 0;
+  const taken = new Set(takenTeamSlugsForOrchestration());
+  for (const thread of listThreads({ includeArchived: true })) {
+    if (thread.status === "archived") continue;
+    if (!orchestrationTitleNeedsSoccerNickname(thread)) continue;
+    const team = allocateTeamName(taken);
+    taken.add(team.slug);
+    updateThread(thread.id, { title: team.name, userSetTitle: true });
+    healed += 1;
+  }
+  return healed;
+}
+function listGlobalThreads(includeArchived = false) {
+  return listThreads({ includeArchived }).filter(
+    (t) => t.repoPath === GLOBAL_WORKSPACE_ID
+  );
+}
+function findCloudCoordinator() {
+  return listThreads({ includeArchived: true }).find(
+    (t) => t.status !== "archived" && isCloudCoordinatorThread(t)
+  );
+}
+function ensureCloudCoordinator(agent) {
+  const existing = findCloudCoordinator();
+  if (existing) {
+    if (existing.repoPath !== GLOBAL_WORKSPACE_ID) {
+      return updateThread(existing.id, {
+        repoPath: GLOBAL_WORKSPACE_ID,
+        worktreePath: globalAgentCwd(),
+        branchName: "global"
+      });
+    }
+    return existing;
+  }
+  const created = createGlobalChat({
+    sourceRef: CLOUD_ORCHESTRATOR_GOAL,
+    agent
+  });
+  const all = listThreads({ includeArchived: true }).filter(
+    (t) => t.status !== "archived" && isCloudCoordinatorThread(t)
+  ).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  return all[0] ?? created;
+}
+
+export {
+  GLOBAL_WORKSPACE_ID,
+  isGlobalThread,
+  isGlobalRepoPath,
+  isOrchestratorThread,
+  orchestratorSessionPoisonedByBuiltins,
+  isCloudCoordinatorThread,
+  orchestrationTitleNeedsSoccerNickname,
+  takenTeamSlugsForOrchestration,
+  createGlobalChat,
+  healOrchestrationSoccerTitles,
+  listGlobalThreads,
+  ensureCloudCoordinator
+};