@sideboard-ai/core 0.1.46 → 0.1.49

package/dist/chunk-E35APBHV.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+
+import {
+  run
+} from "./chunk-ISY4EGF6.js";
+import {
+  appDataDir
+} from "./chunk-7MV3RXSC.js";
+
+// src/brightsy/connected-teams.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/brightsy/config.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function brightsyConfigPath() {
+  return join(homedir(), ".brightsy", "config.json");
+}
+function loadBrightsyConfig() {
+  const path = brightsyConfigPath();
+  if (!existsSync(path)) {
+    throw new Error("Brightsy not logged in \u2014 run `brightsy login` first");
+  }
+  const raw = JSON.parse(readFileSync(path, "utf8"));
+  if (!raw.access_token || !raw.account_id) {
+    throw new Error("Brightsy config incomplete \u2014 run `brightsy login`");
+  }
+  return raw;
+}
+function saveBrightsyConfig(cfg) {
+  writeFileSync(brightsyConfigPath(), `${JSON.stringify(cfg, null, 2)}
+`, {
+    mode: 384
+  });
+}
+
+// src/brightsy/accounts.ts
+async function runBrightsyTeamsJson(args) {
+  const listed = await run("brightsy", ["teams", ...args, "--json"], {
+    reject: false
+  });
+  if (listed.exitCode !== 0) {
+    throw new Error(
+      listed.stderr.trim() || listed.stdout.trim() || "brightsy teams failed \u2014 is `@brightsy/cli` installed and logged in?"
+    );
+  }
+  const raw = listed.stdout.trim();
+  if (!raw) {
+    throw new Error("brightsy teams returned empty output");
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error("brightsy teams returned invalid JSON");
+  }
+}
+async function listBrightsyAccounts() {
+  const data = await runBrightsyTeamsJson([]);
+  return Array.isArray(data.teams) ? data.teams : [];
+}
+async function performBrightsyAccountSwitch(accountIdOrSlug) {
+  const data = await runBrightsyTeamsJson([
+    "switch",
+    accountIdOrSlug
+  ]);
+  if (!data.active?.id) {
+    throw new Error(`Team switch failed for: ${accountIdOrSlug}`);
+  }
+  const cfg = loadBrightsyConfig();
+  if (data.active.slug && data.active.slug !== cfg.account_slug) {
+    cfg.account_slug = data.active.slug;
+    saveBrightsyConfig(cfg);
+  }
+  return { cfg, target: data.active };
+}
+
+// src/brightsy/connected-teams.ts
+function storePath() {
+  return join2(appDataDir(), "brightsy-teams.json");
+}
+function readStore() {
+  const path = storePath();
+  if (!existsSync2(path)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    return Array.isArray(parsed.teams) ? parsed.teams : [];
+  } catch {
+    return [];
+  }
+}
+function writeStore(teams) {
+  mkdirSync(appDataDir(), { recursive: true });
+  const path = storePath();
+  writeFileSync2(path, `${JSON.stringify({ teams }, null, 2)}
+`, {
+    mode: 384
+  });
+  return teams;
+}
+function listConnectedBrightsyTeams() {
+  return readStore().map(({ id, slug, name, expires_at }) => ({
+    id,
+    slug,
+    name,
+    expires_at
+  }));
+}
+function getConnectedBrightsyTeamsRaw() {
+  return readStore();
+}
+function applyConnectedTeamToCli(team) {
+  let base = {};
+  try {
+    base = loadBrightsyConfig();
+  } catch {
+  }
+  saveBrightsyConfig({
+    ...base,
+    access_token: team.access_token,
+    refresh_token: team.refresh_token ?? base.refresh_token,
+    expires_at: team.expires_at ?? base.expires_at,
+    account_id: team.id,
+    account_slug: team.slug,
+    endpoint: team.endpoint ?? base.endpoint ?? "https://brightsy.ai",
+    oauth_client_id: base.oauth_client_id
+  });
+}
+async function refreshTeamToken(team) {
+  if (!team.refresh_token) return team;
+  const endpoint = (team.endpoint || "https://brightsy.ai").replace(/\/$/, "");
+  const cfg = (() => {
+    try {
+      return loadBrightsyConfig();
+    } catch {
+      return null;
+    }
+  })();
+  const clientId = cfg?.oauth_client_id || "brightsy-cli";
+  const res = await fetch(`${endpoint}/oauth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: team.refresh_token,
+      client_id: clientId
+    })
+  });
+  if (!res.ok) return team;
+  const data = await res.json();
+  if (!data.access_token) return team;
+  return {
+    ...team,
+    access_token: data.access_token,
+    refresh_token: data.refresh_token || team.refresh_token,
+    expires_at: data.expires_in ? Date.now() + data.expires_in * 1e3 : team.expires_at
+  };
+}
+async function ensureConnectedBrightsyTeamTokens() {
+  const teams = readStore();
+  if (teams.length === 0) return [];
+  const next = [];
+  let changed = false;
+  for (const team of teams) {
+    const expired = typeof team.expires_at === "number" && Date.now() >= team.expires_at - 6e4;
+    if (!expired) {
+      next.push(team);
+      continue;
+    }
+    const refreshed = await refreshTeamToken(team);
+    if (refreshed.access_token !== team.access_token) changed = true;
+    next.push(refreshed);
+  }
+  if (changed) writeStore(next);
+  try {
+    const cfg = loadBrightsyConfig();
+    const active = next.find((t) => t.id === cfg.account_id);
+    if (active && active.access_token !== cfg.access_token) {
+      applyConnectedTeamToCli(active);
+    }
+  } catch {
+  }
+  return next;
+}
+function ensureCliTeamTracked(meta) {
+  try {
+    const cfg = loadBrightsyConfig();
+    const existing = readStore();
+    if (existing.some((t) => t.id === cfg.account_id)) {
+      return listConnectedBrightsyTeams();
+    }
+    const team = {
+      id: cfg.account_id,
+      slug: meta?.slug || cfg.account_slug || cfg.account_id,
+      name: meta?.name || cfg.account_slug || cfg.account_id,
+      access_token: cfg.access_token,
+      refresh_token: cfg.refresh_token,
+      expires_at: cfg.expires_at,
+      endpoint: cfg.endpoint
+    };
+    writeStore([...existing, team]);
+  } catch {
+  }
+  return listConnectedBrightsyTeams();
+}
+async function connectBrightsyTeam(accountIdOrSlug) {
+  const accounts = await listBrightsyAccounts();
+  const target = accounts.find((a) => a.id === accountIdOrSlug) ?? accounts.find((a) => a.slug === accountIdOrSlug);
+  if (!target) {
+    throw new Error(`Brightsy team not found: ${accountIdOrSlug}`);
+  }
+  const existing = readStore();
+  const already = existing.find((t) => t.id === target.id);
+  if (already) {
+    applyConnectedTeamToCli(already);
+    return listConnectedBrightsyTeams();
+  }
+  const { cfg: minted } = await performBrightsyAccountSwitch(target.id);
+  const team = {
+    id: target.id,
+    slug: target.slug,
+    name: target.name,
+    access_token: minted.access_token,
+    refresh_token: minted.refresh_token,
+    expires_at: minted.expires_at,
+    endpoint: minted.endpoint
+  };
+  writeStore([...existing, team]);
+  return listConnectedBrightsyTeams();
+}
+async function disconnectBrightsyTeam(accountIdOrSlug) {
+  const before = readStore();
+  const removed = before.find(
+    (t) => t.id === accountIdOrSlug || t.slug === accountIdOrSlug
+  );
+  const teams = before.filter(
+    (t) => t.id !== accountIdOrSlug && t.slug !== accountIdOrSlug
+  );
+  writeStore(teams);
+  if (removed) {
+    try {
+      const cfg = loadBrightsyConfig();
+      if (cfg.account_id === removed.id) {
+        if (teams[0]) {
+          applyConnectedTeamToCli(teams[0]);
+        }
+      }
+    } catch {
+    }
+  }
+  return listConnectedBrightsyTeams();
+}
+function brightsyMcpServerName(slug) {
+  const cleaned = slug.replace(/[^A-Za-z0-9_-]/g, "_").replace(/^_+|_+$/g, "");
+  return `brightsy_${cleaned || "team"}`;
+}
+
+export {
+  loadBrightsyConfig,
+  listConnectedBrightsyTeams,
+  getConnectedBrightsyTeamsRaw,
+  applyConnectedTeamToCli,
+  ensureConnectedBrightsyTeamTokens,
+  ensureCliTeamTracked,
+  connectBrightsyTeam,
+  disconnectBrightsyTeam,
+  brightsyMcpServerName
+};

package/dist/chunk-EOYDCKQC.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+
+import {
+  normalizeThinkingEffort
+} from "./chunk-KGZBYWZ3.js";
+import {
+  threadFilePath,
+  threadLockPath,
+  threadsDir
+} from "./chunk-7MV3RXSC.js";
+
+// src/store/thread-store.ts
+import { randomUUID } from "crypto";
+import {
+  existsSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+  readdirSync
+} from "fs";
+import lockfile from "proper-lockfile";
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function resolveThreadEffort(raw) {
+  const fromField = normalizeThinkingEffort(raw.effort);
+  if (fromField) return fromField;
+  if (raw.fast) return "low";
+  return "high";
+}
+function normalizeThread(raw) {
+  return {
+    ...raw,
+    model: raw.model ?? null,
+    effort: resolveThreadEffort(raw),
+    fast: Boolean(raw.fast),
+    planMode: Boolean(raw.planMode),
+    autonomy: raw.autonomy ?? "default",
+    lastError: raw.lastError ?? null,
+    agentPid: raw.agentPid ?? null,
+    attachments: Array.isArray(raw.attachments) ? raw.attachments : [],
+    prTitle: raw.prTitle ?? null,
+    userSetTitle: Boolean(raw.userSetTitle),
+    activeRuns: Array.isArray(raw.activeRuns) ? raw.activeRuns : [],
+    quotaResumeAt: raw.quotaResumeAt ?? null,
+    quotaContinuedFromId: raw.quotaContinuedFromId ?? null
+  };
+}
+function createEmptyThread(partial) {
+  const ts = nowIso();
+  return {
+    id: randomUUID(),
+    sessionId: partial.sessionId ?? null,
+    autonomy: partial.autonomy ?? "default",
+    model: partial.model ?? null,
+    effort: partial.effort ?? "high",
+    fast: partial.fast ?? false,
+    planMode: partial.planMode ?? false,
+    sourceIsFork: partial.sourceIsFork ?? false,
+    status: partial.status ?? "idle",
+    queue: partial.queue ?? [],
+    parentThreadId: partial.parentThreadId ?? null,
+    devPort: partial.devPort ?? null,
+    activeRuns: partial.activeRuns ?? [],
+    prUrl: partial.prUrl ?? null,
+    prTitle: partial.prTitle ?? null,
+    userSetTitle: partial.userSetTitle ?? false,
+    messages: partial.messages ?? [],
+    attachments: partial.attachments ?? [],
+    createdAt: ts,
+    updatedAt: ts,
+    title: partial.title,
+    sourceType: partial.sourceType,
+    sourceRef: partial.sourceRef,
+    branchName: partial.branchName,
+    worktreePath: partial.worktreePath,
+    repoPath: partial.repoPath,
+    agent: partial.agent,
+    lastError: null,
+    agentPid: null
+  };
+}
+async function withThreadLock(id, fn) {
+  const lockPath = threadLockPath(id);
+  writeFileSync(lockPath, "", { flag: "a" });
+  let release;
+  try {
+    release = await lockfile.lock(lockPath, {
+      retries: { retries: 10, minTimeout: 50, maxTimeout: 200 },
+      stale: 6e4
+    });
+    return await fn();
+  } finally {
+    if (release) await release();
+  }
+}
+function readThread(id) {
+  const path = threadFilePath(id);
+  if (!existsSync(path)) return null;
+  const raw = readFileSync(path, "utf8");
+  return normalizeThread(JSON.parse(raw));
+}
+function writeThread(thread) {
+  const path = threadFilePath(idPath(thread.id));
+  const tmp = `${path}.${process.pid}.tmp`;
+  const next = { ...thread, updatedAt: nowIso() };
+  writeFileSync(tmp, JSON.stringify(next, null, 2), "utf8");
+  renameSync(tmp, path);
+}
+function idPath(id) {
+  return id;
+}
+function listThreads(opts) {
+  const files = readdirSync(threadsDir()).filter((f) => f.endsWith(".json"));
+  const threads = files.map((f) => {
+    try {
+      return normalizeThread(
+        JSON.parse(readFileSync(threadFilePath(f.replace(/\.json$/, "")), "utf8"))
+      );
+    } catch {
+      return null;
+    }
+  }).filter((t) => t !== null).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  if (opts?.includeArchived) return threads;
+  return threads.filter((t) => t.status !== "archived");
+}
+function deleteThreadRecord(id) {
+  const path = threadFilePath(id);
+  if (existsSync(path)) unlinkSync(path);
+  const lock = threadLockPath(id);
+  if (existsSync(lock)) {
+    try {
+      unlinkSync(lock);
+    } catch {
+    }
+  }
+}
+function updateThread(id, patch) {
+  const current = readThread(id);
+  if (!current) throw new Error(`Thread not found: ${id}`);
+  const next = { ...current, ...patch, id: current.id, updatedAt: nowIso() };
+  writeThread(next);
+  return next;
+}
+function appendMessage(id, message) {
+  const current = readThread(id);
+  if (!current) throw new Error(`Thread not found: ${id}`);
+  return updateThread(id, { messages: [...current.messages, message] });
+}
+function setStatus(id, status, lastError) {
+  return updateThread(id, { status, lastError: lastError ?? null });
+}
+function findThreadByRef(ref) {
+  const all = listThreads({ includeArchived: true });
+  return all.find((t) => t.id === ref || t.id.startsWith(ref) || t.branchName === ref || t.title === ref) ?? null;
+}
+
+export {
+  resolveThreadEffort,
+  normalizeThread,
+  createEmptyThread,
+  withThreadLock,
+  readThread,
+  writeThread,
+  listThreads,
+  deleteThreadRecord,
+  updateThread,
+  appendMessage,
+  setStatus,
+  findThreadByRef
+};

package/dist/chunk-GZXBYHJC.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+
+import {
+  resolveGithubRepoSlug
+} from "./chunk-ZVV5EEQN.js";
+import {
+  globalAgentCwd,
+  sideboardReposDir
+} from "./chunk-7MV3RXSC.js";
+
+// src/orchestrator/coordinator-prompt.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+function formatWorkspaceInventory(workspaces) {
+  if (workspaces.length === 0) return "(no registered workspaces)";
+  return workspaces.map((w) => {
+    const slug = w.githubSlug?.trim() ? `  github:${w.githubSlug.trim()}` : "";
+    return `- ${w.name}: ${w.path}${slug}`;
+  }).join("\n");
+}
+async function enrichWorkspacesWithGithub(workspaces) {
+  return Promise.all(
+    workspaces.map(async (w) => {
+      const githubSlug = await resolveGithubRepoSlug(w.path).catch(() => null);
+      return { ...w, githubSlug };
+    })
+  );
+}
+function coordinatorGreenfieldPlaybook(reposDir) {
+  return [
+    "Greenfield (new app / new GitHub repo) \u2014 use Bash + MCP:",
+    `- Create or clone under \`${reposDir}/<name>\` (never inside this synthetic home cwd).`,
+    "- Examples:",
+    `  - Clone: \`git clone <url> ${reposDir}/<name>\``,
+    `  - New GitHub repo: \`gh repo create <owner>/<name> --private --clone -- ${reposDir}/<name>\` (or mkdir + git init + gh repo create + remote add + push)`,
+    "- Then: add_workspace with that absolute path \u2192 create_thread (repoPath + parentThreadId) \u2192 send_to_thread (build) \u2192 wait_for_turn \u2192 send_to_thread (`gh pr create --draft -R <origin-owner/name>`).",
+    "- Always target the child worktree's **origin** (`github:` slug from list_workspaces / `git remote get-url origin` in that worktree). Never open PRs against `upstream`.",
+    "- Do coding work in the child worktree thread, not by editing files in this home cwd."
+  ].join("\n");
+}
+var COORDINATOR_TOOL_PLAYBOOK = [
+  "Role: you oversee Sideboard worktree agents across registered repos. You do not live inside one of those worktrees.",
+  "Sideboard MCP (fleet control \u2014 prefer these for status and orchestration):",
+  "Discover:",
+  "- list_workspaces \u2014 registered repos (path + github slug when known)",
+  "- list_branches / list_prs / list_issues \u2014 pass repoPath from list_workspaces (issues: Linear API or GitHub Issues)",
+  "- list_models \u2014 only when you need a specific model (rare); otherwise leave model unset = Auto",
+  "- list_threads / get_thread \u2014 fleet status (what is going on)",
+  "Workspaces:",
+  "- add_workspace / remove_workspace \u2014 register or unregister a git repo",
+  "Worktree threads (chats):",
+  "- create_thread \u2014 create a worktree + chat from branch | pr | ticket; pass repoPath + parentThreadId",
+  "- fork_worktree \u2014 fork a worktree chat into a NEW git worktree + chat (transcript attached); optional agent; leave model unset (Auto) unless you have a reason. Not for orchestration chats.",
+  "- fork_chat \u2014 fork a worktree chat (same worktree tab) OR a Global orchestration chat (new orchestration tab); optional agent; leave model unset (Auto) unless you have a reason. Remote coordinators: use this to continue another orchestration chat on a different agent after session limits.",
+  "- send_to_thread \u2014 queue a prompt (start/continue a chat turn); pass force_stop: true to interrupt mid-turn / clear stale queued prompts before replacing with a new request",
+  "- wait_for_turn / get_turn_result \u2014 wait for and read the agent reply",
+  "- stop_thread \u2014 force-stop: kill in-flight turn AND clear queued prompts (do not leave stale queue after an interrupt)",
+  "- archive_thread / restore_thread \u2014 archive (tears down worktree when last tab) or restore",
+  "Setup / run:",
+  "- run_setup \u2014 re-run worktree setup",
+  "- list_run_scripts / run_dev_script / stop_dev_script \u2014 start/stop named run scripts",
+  "Inspect / review / PRs:",
+  "- get_diff \u2014 compact diff summary",
+  '- request_review \u2014 open a Review chat tab on a worktree thread (attaches .sideboard/review.md when present, else local guidelines; sends "Review."); then wait_for_turn / get_turn_result on the returned id',
+  "- Ask the worktree agent via send_to_thread to open a draft PR with `gh pr create --draft -R <origin-owner/name>` (workspace `github:` slug / that worktree's origin \u2014 never upstream). Do not open PRs from the orchestrator yourself.",
+  "Human-only (do not attempt): merge, ready-for-review land, purge_thread.",
+  "Thread links in replies: when mentioning a chat/thread for the user, include a markdown link `[Title](sideboard://thread/<id>)` using the full id (or the link field from create_thread / list_threads). Sideboard renders these as clickable opens.",
+  "Bash / Read / etc: allowed for (1) inspecting target worktrees / registered repo paths from MCP, and (2) greenfield setup under ~/sideboard/repos (git clone, gh repo create, git init+remote). Never git init/clone *inside* this synthetic home cwd \u2014 emptiness here is expected, not a bug."
+].join("\n");
+function coordinatorTurnReminder(opts) {
+  const goal = opts.goal?.trim();
+  return [
+    "Sideboard Orchestration (mandatory):",
+    "- You oversee Sideboard worktree agents. You are not yourself checked out in a project worktree.",
+    "- This cwd is a synthetic empty home (not a git repo). Emptiness here is expected \u2014 it is not a problem to fix.",
+    "- Registered workspaces / child threads are the fleet you manage via Sideboard MCP.",
+    `- Parent thread id (pass as parentThreadId when creating children): ${opts.parentId}`,
+    goal ? `- Goal / title: ${goal}` : null,
+    `- For "what's going on": call list_threads (and list_workspaces if needed). Summarize fleet status \u2014 do not ls/git-status this synthetic home.`,
+    "- Existing repo: create_thread on a repoPath \u2192 send_to_thread \u2192 wait_for_turn.",
+    "- New repo: Bash (clone or gh repo create under ~/sideboard/repos/<name>) \u2192 add_workspace \u2192 create_thread \u2192 send_to_thread \u2192 wait_for_turn \u2192 draft PR.",
+    "- When naming threads for the user, link them as `[Title](sideboard://thread/<id>)`."
+  ].filter(Boolean).join("\n");
+}
+function ensureGlobalCoordinatorCwd() {
+  const dir = globalAgentCwd();
+  mkdirSync(dir, { recursive: true });
+  const reposDir = sideboardReposDir();
+  const body = [
+    "# Sideboard Orchestration",
+    "",
+    "You are the Sideboard **Orchestration** agent \u2014 you oversee worktree agents in the Sideboard app.",
+    "You are **not** connected to a single project workspace. This directory is a synthetic empty cwd (not a git worktree).",
+    "It being empty / not a git repo is **normal**. Do not initialize git here or ask the user to point you at a repo for *your* checkout.",
+    "Repos from `list_workspaces` and threads from `list_threads` are the fleet you orchestrate.",
+    'For status questions ("what\'s going on?"), use `list_threads` / `list_workspaces` \u2014 never diagnose this synthetic home as a broken worktree.',
+    "Bash is fine for inspecting **child worktree** / registered-repo paths, and for greenfield repo setup under the Sideboard repos directory \u2014 not for treating this home as the project.",
+    "",
+    COORDINATOR_TOOL_PLAYBOOK,
+    "",
+    coordinatorGreenfieldPlaybook(reposDir),
+    "",
+    "When creating threads, pass `repoPath` from `list_workspaces` (or the path you just registered) and `parentThreadId` for children.",
+    "Typical flow (existing): list_workspaces \u2192 list_branches|list_prs|list_issues \u2192 create_thread \u2192 send_to_thread \u2192 wait_for_turn.",
+    "Typical flow (new app): Bash create/clone under repos dir \u2192 add_workspace \u2192 create_thread \u2192 send_to_thread (implement) \u2192 wait_for_turn \u2192 draft PR via worktree agent.",
+    "Always ask worktree agents to open draft PRs (`send_to_thread` + `gh pr create --draft -R <origin>`); never open PRs from the orchestrator."
+  ].join("\n");
+  writeFileSync(join(dir, "CLAUDE.md"), `${body}
+`, "utf8");
+  writeFileSync(join(dir, "AGENTS.md"), `${body}
+`, "utf8");
+  return dir;
+}
+function coordinatorSystemPrompt(opts) {
+  const audience = opts.audience ?? "cloud";
+  const reposDir = sideboardReposDir();
+  const intro = audience === "cloud" ? [
+    "You are a Sideboard coordinator responding to a request from a Brightsy cloud agent (Slack, Discord, Teams, or other chat).",
+    "Your reply will be sent back to that cloud agent \u2014 be concise and actionable."
+  ] : [
+    "You are a Sideboard orchestration agent: you oversee worktree agents across registered workspaces in the Sideboard app.",
+    "Stay concise and actionable; prefer Sideboard MCP for fleet status; use Bash for greenfield repo setup and inspecting target worktree paths."
+  ];
+  return [
+    ...intro,
+    "You operate across ALL registered workspaces below.",
+    "You have no project git home \u2014 this process cwd is synthetic and empty on purpose.",
+    COORDINATOR_TOOL_PLAYBOOK,
+    coordinatorGreenfieldPlaybook(reposDir),
+    "When creating threads, pass the correct repoPath for the target workspace and parentThreadId for children.",
+    "Typical flow (existing): list_workspaces \u2192 list_branches|list_prs|list_issues \u2192 create_thread \u2192 send_to_thread (implement) \u2192 wait_for_turn \u2192 send_to_thread (ask for `gh pr create --draft -R <origin-owner/name>` using the workspace github slug) \u2192 wait_for_turn. Never target upstream. Never open PRs from the orchestrator.",
+    "Typical flow (new app): Bash under repos dir (clone or gh repo create) \u2192 add_workspace \u2192 create_thread \u2192 send_to_thread \u2192 wait_for_turn \u2192 draft PR via worktree agent.",
+    `Goal: ${opts.goal}`,
+    `Parent thread id (pass as parentThreadId when creating children): ${opts.parentId}`,
+    "Registered workspaces:",
+    formatWorkspaceInventory(opts.workspaces)
+  ].join("\n");
+}
+
+export {
+  formatWorkspaceInventory,
+  enrichWorkspacesWithGithub,
+  coordinatorGreenfieldPlaybook,
+  COORDINATOR_TOOL_PLAYBOOK,
+  coordinatorTurnReminder,
+  ensureGlobalCoordinatorCwd,
+  coordinatorSystemPrompt
+};