@sideboard-ai/core 0.1.9

package/dist/index.d.cts

@@ -0,0 +1,2284 @@
+import { ResultPromise } from 'execa';
+import { EventEmitter } from 'node:events';
+
+type AgentKind = 'claude' | 'codex' | 'opencode' | 'brightsy' | 'cursor';
+type SourceType = 'branch' | 'pr' | 'ticket' | 'orchestration' | 'adopt';
+type ThreadStatus = 'idle' | 'queued' | 'running' | 'stopped' | 'error' | 'broken' | 'archived';
+type Autonomy = 'default' | 'full';
+/** Structured agent turn content (thinking / tools / text). */
+type MessagePart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'thinking';
+    text: string;
+} | {
+    type: 'tool';
+    id: string;
+    name: string;
+    input?: Record<string, unknown>;
+    /** Short human label (e.g. "Fetch latest from origin"). */
+    description?: string;
+    /** Command / path shown in the monospace pill. */
+    detail?: string;
+    result?: string;
+    status: 'running' | 'done' | 'error';
+    filePath?: string;
+    additions?: number;
+    deletions?: number;
+};
+/** Token usage for a single agent turn, aggregated across the turn's API calls. */
+interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+}
+interface ThreadMessage {
+    role: 'user' | 'agent' | 'summary';
+    text: string;
+    /** Structured parts for expandable tool/thinking UI. Optional for older threads. */
+    parts?: MessagePart[];
+    /** Agent turn duration in milliseconds (from turn start to message persist). */
+    durationMs?: number;
+    /** Token usage for this turn, when the agent CLI reports it. */
+    usage?: TokenUsage;
+    ts: string;
+}
+/** Composer / turn attachment (e.g. forked chat transcript). */
+interface ThreadAttachment {
+    id: string;
+    name: string;
+    kind: 'transcript' | 'file' | 'issue' | 'workspace';
+    content: string;
+}
+interface Thread {
+    id: string;
+    title: string;
+    sourceType: SourceType;
+    sourceRef: string;
+    branchName: string;
+    worktreePath: string;
+    repoPath: string;
+    agent: AgentKind;
+    /** Agent model alias (e.g. sonnet, opus). null = Auto / CLI default. */
+    model: string | null;
+    /** Prefer faster/cheaper turns (Claude: --effort low). */
+    fast: boolean;
+    /** Plan-only turns — analyze and plan without editing files (Conductor-style). */
+    planMode: boolean;
+    sessionId: string | null;
+    autonomy: Autonomy;
+    sourceIsFork: boolean;
+    status: ThreadStatus;
+    queue: string[];
+    parentThreadId: string | null;
+    /** Port of the default/primary run script (legacy + sidebar). */
+    devPort: number | null;
+    /** Named run scripts currently tracked for this thread. */
+    activeRuns?: ActiveRun[];
+    prUrl: string | null;
+    /** Cached PR title for Conductor-style sidebar labels (PR title > branch). */
+    prTitle: string | null;
+    /** When true, `title` is a manual override and is not overwritten by branch/PR sync. */
+    userSetTitle: boolean;
+    createdAt: string;
+    updatedAt: string;
+    messages: ThreadMessage[];
+    /** Pending composer attachments (forked transcripts, etc.). */
+    attachments: ThreadAttachment[];
+    lastError?: string | null;
+}
+interface CreateChatTabInput {
+    /** Existing thread in the worktree to clone workspace metadata from. */
+    fromThreadId: string;
+    agent?: AgentKind;
+    title?: string;
+    attachments?: ThreadAttachment[];
+}
+interface ForkChatTabInput {
+    threadId: string;
+    /** Inclusive message index to fork through; default = all messages. */
+    throughIndex?: number;
+    agent?: AgentKind;
+    title?: string;
+}
+/** Fork a thread into a new git worktree (new branch + worktree dir). */
+interface ForkThreadWorktreeInput {
+    threadId: string;
+    /** Inclusive message index to seed transcript through; default = all messages. */
+    throughIndex?: number;
+    agent?: AgentKind;
+    title?: string;
+}
+interface ThreadOptionsPatch {
+    agent?: AgentKind;
+    model?: string | null;
+    fast?: boolean;
+    planMode?: boolean;
+    autonomy?: Autonomy;
+}
+interface AgentStatus {
+    agent: AgentKind;
+    installed: boolean;
+    authenticated: boolean;
+    linearMcp: boolean;
+    warnings: string[];
+    reason?: string;
+}
+interface BranchInfo {
+    name: string;
+    remote: boolean;
+    current: boolean;
+}
+interface PrInfo {
+    number: number;
+    title: string;
+    headRefName: string;
+    url: string;
+    isCrossRepository: boolean;
+}
+/** One CI check from `gh pr checks --json`, or a synthetic merge/review gate. */
+interface PrCheckRun {
+    name: string;
+    state: string;
+    bucket: 'pass' | 'fail' | 'pending' | 'skipping' | 'cancel' | string;
+    startedAt: string | null;
+    completedAt: string | null;
+    link: string | null;
+    description: string | null;
+    workflow: string | null;
+    /**
+     * Origin of the row. Omitted / `ci` = GitHub Actions / check suite.
+     * `mergeability` / `review` are Sideboard synthetics (conflicts, behind, review).
+     */
+    kind?: 'ci' | 'mergeability' | 'review';
+}
+interface PrActor {
+    login: string;
+    name?: string | null;
+}
+interface PrCommitInfo {
+    oid: string;
+    messageHeadline: string;
+    committedDate: string;
+    authors: PrActor[];
+}
+interface PrCommentInfo {
+    author: PrActor;
+    body: string;
+    createdAt: string;
+}
+interface PrReviewInfo {
+    author: PrActor;
+    state: string;
+    body: string;
+    submittedAt: string | null;
+}
+/** Rich PR payload for Sideboard Review tab (`gh pr view --json`). */
+interface PrDetails {
+    number: number;
+    title: string;
+    body: string;
+    url: string;
+    state: string;
+    isDraft: boolean;
+    reviewDecision: string | null;
+    author: PrActor;
+    baseRefName: string;
+    headRefName: string;
+    additions: number;
+    deletions: number;
+    changedFiles: number;
+    commits: PrCommitInfo[];
+    comments: PrCommentInfo[];
+    reviews: PrReviewInfo[];
+    checks: PrCheckRun[];
+}
+interface IssueInfo {
+    id: string;
+    identifier: string;
+    title: string;
+    url: string;
+    labels: string[];
+    /** When set, which tracker produced this issue. */
+    provider?: 'linear' | 'github';
+}
+interface DiffFile {
+    path: string;
+    /** Git name-status letter (M/A/D/R/…). */
+    status: string;
+    patch: string;
+    /** From `git diff --numstat` when available. */
+    additions?: number;
+    deletions?: number;
+}
+/** Cursor-style Changes panel filters. */
+type DiffScope = 'last_turn' | 'uncommitted' | 'staged' | 'unstaged' | 'commits';
+interface DiffScopeStat {
+    files: number;
+    additions: number;
+    deletions: number;
+}
+/** One commit on the branch (for the Changes → Commits submenu). */
+interface DiffCommit {
+    sha: string;
+    shortSha: string;
+    subject: string;
+    relativeTime: string;
+}
+interface DiffResult {
+    /** Active filter for this result. */
+    scope: DiffScope;
+    /** When scope is commits and a single commit is selected. */
+    commitSha?: string | null;
+    base: string;
+    files: DiffFile[];
+    stat: string;
+    dirty: boolean;
+    /** Commits on HEAD not yet on the remote tracking branch (0 if none/unknown). */
+    unpushed: number;
+    /** Counts for each filter option (for the Changes dropdown). */
+    scopeStats: Record<DiffScope, DiffScopeStat>;
+    /** True when a last-agent-turn baseline is available. */
+    hasLastTurnBase: boolean;
+    /** Recent commits on the branch (vs merge-base), for the Commits flyout. */
+    commits: DiffCommit[];
+}
+interface LandPreview {
+    branch: string;
+    target: string;
+    diffStat: string;
+    dirty: boolean;
+    blocked: boolean;
+    blockReason?: string;
+    isFork: boolean;
+}
+interface LandResult {
+    prUrl: string;
+    pushed: boolean;
+    committed: boolean;
+}
+type AgentEvent = {
+    type: 'stdout';
+    data: string;
+} | {
+    type: 'stderr';
+    data: string;
+} | {
+    type: 'session_id';
+    data: string;
+} | {
+    type: 'thinking';
+    data: string;
+} | {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input?: Record<string, unknown>;
+} | {
+    type: 'tool_result';
+    id: string;
+    content?: string;
+    isError?: boolean;
+} | {
+    type: 'usage';
+    data: TokenUsage;
+} | {
+    type: 'exit';
+    data: number | null;
+};
+type OrchestratorEvent = {
+    type: 'turn_started';
+    threadId: string;
+    prompt: string;
+} | {
+    type: 'turn_output';
+    threadId: string;
+    event: AgentEvent;
+} | {
+    type: 'turn_finished';
+    threadId: string;
+    exitCode: number | null;
+} | {
+    type: 'status_changed';
+    threadId: string;
+    status: ThreadStatus;
+} | {
+    type: 'queue_changed';
+    threadId: string;
+    queue: string[];
+} | {
+    type: 'context_compacted';
+    threadId: string;
+    olderCount: number;
+    method: 'claude' | 'extractive';
+} | {
+    type: 'dev_server_started';
+    threadId: string;
+    port: number;
+    scriptName?: string;
+} | {
+    type: 'dev_server_stopped';
+    threadId: string;
+    scriptName?: string;
+} | {
+    type: 'run_output';
+    threadId: string;
+    scriptName: string;
+    line: string;
+} | {
+    type: 'setup_started';
+    threadId: string;
+} | {
+    type: 'setup_output';
+    threadId: string;
+    line: string;
+} | {
+    type: 'setup_finished';
+    threadId: string;
+    exitCode: number | null;
+} | {
+    type: 'orphan_worktrees';
+    orphans: Array<{
+        path: string;
+        repoPath: string;
+    }>;
+} | {
+    type: 'error';
+    threadId: string;
+    message: string;
+};
+/** Active named run script (in-memory + mirrored on thread for UI). */
+interface ActiveRun {
+    scriptName: string;
+    port: number;
+    ports: number[];
+    startedAt: string;
+}
+/** Live snapshot for the global orchestrator board. */
+interface OrchestratorRuntime {
+    running: number;
+    maxConcurrent: number;
+    queued: number;
+    idle: number;
+    error: number;
+    stopped: number;
+    broken: number;
+    totalActive: number;
+}
+interface CreateThreadInput {
+    sourceType: Exclude<SourceType, 'orchestration'>;
+    sourceRef: string;
+    agent: AgentKind;
+    repoPath: string;
+    autonomy?: Autonomy;
+    /** Claude model id, or Brightsy `agent:` / `model:` target encoding. */
+    model?: string | null;
+    fast?: boolean;
+    planMode?: boolean;
+    /** Attachments available to the first prompt (and subsequent turns). */
+    attachments?: ThreadAttachment[];
+    title?: string;
+    parentThreadId?: string | null;
+    /** Optional first prompt — queued after the thread is created (Conductor-style). */
+    prompt?: string;
+}
+interface AdoptInput {
+    worktreePath: string;
+    agent: AgentKind;
+    title?: string;
+    sessionId?: string | null;
+    messages?: ThreadMessage[];
+    sourceRef?: string;
+}
+interface ConductorWorkspace {
+    id: string;
+    workspacePath: string;
+    branch: string;
+    workspaceName: string;
+    prTitle: string | null;
+    prDescription: string | null;
+    intendedTargetBranch: string | null;
+    notes: string | null;
+    claudeSessionId: string | null;
+    agentType: AgentKind | null;
+    messageCount: number;
+}
+
+declare function appDataDir(): string;
+declare function threadsDir(): string;
+declare function locksDir(): string;
+/** Conductor-style home root: ~/sideboard */
+declare function sideboardHomeDir(): string;
+declare function sideboardReposDir(): string;
+declare function sideboardWorkspacesDir(): string;
+declare function repoSlug(repoPath: string): string;
+/**
+ * Worktree root for a repo (new threads).
+ * Default: ~/sideboard/workspaces/<repo-slug>/
+ * Override via [.sideboard|.conductor]/settings.toml [worktrees] root = "..."
+ *
+ * Existing threads keep whatever absolute worktreePath is stored on their record,
+ * so older repo-local checkouts continue to work until archived.
+ */
+declare function worktreesRoot(repoPath: string): string;
+declare function threadFilePath(id: string): string;
+declare function threadLockPath(id: string): string;
+/** Empty synthetic cwd for global orchestration agents (not a git worktree). */
+declare function globalAgentCwd(): string;
+
+/** Well-known env keys managed from Settings → Agents (Conductor-style harnesses). */
+declare const HARNESS_ENV_KEYS: {
+    readonly claude: "ANTHROPIC_API_KEY";
+    readonly codex: "CODEX_API_KEY";
+    readonly cursor: "CURSOR_API_KEY";
+    readonly opencode: null;
+    readonly brightsy: null;
+};
+type HarnessId = keyof typeof HARNESS_ENV_KEYS;
+/** Claude Code harness options (executable override + Chrome). */
+interface ClaudeHarnessSettings {
+    /** Absolute path to Claude Code. Empty/omitted = `claude` on PATH. */
+    executablePath?: string;
+    /** When true, pass `--chrome` on Claude turns. */
+    chromeEnabled?: boolean;
+}
+/** Local agent that runs the Brightsy cloud coordinator. */
+type BrightsyCloudConnectAgent = 'claude' | 'codex' | 'opencode' | 'cursor';
+/** Brightsy cloud remote-orchestrator preferences (Slack / Discord / Teams). */
+interface BrightsyHarnessSettings {
+    /** When true, desktop app polls Brightsy for Sideboard cloud tasks. */
+    cloudConnectEnabled?: boolean;
+    /** Local agent used for the cloud coordinator (not Brightsy itself). */
+    cloudConnectAgent?: BrightsyCloudConnectAgent;
+}
+/** Preferred issue tracker for Create-from / Link issue. */
+type IssueSource = 'linear' | 'github';
+/**
+ * Sideboard-owned third-party connections (Account / Integrations).
+ * GitHub uses machine `gh` auth; Linear uses a stored API key.
+ */
+interface IntegrationsSettings {
+    /** Linear personal API key (https://linear.app/settings/api). */
+    linearApiKey?: string;
+    /**
+     * Preferred issue source for Create-from / Link issue (default: GitHub).
+     * When `linear` but no API key, runtime falls back to GitHub Issues.
+     */
+    issueSource?: IssueSource;
+}
+/**
+ * Conductor-inspired power-user preferences (Settings → Advanced).
+ * Defaults match Conductor where applicable (auto-rename on, others off).
+ */
+interface AdvancedAppSettings {
+    /**
+     * Ask the agent to rename the temporary `thread/<team>` branch on first send.
+     * Conductor: Git → “Auto-rename placeholder branch on send” (default on).
+     */
+    autoRenameBranch?: boolean;
+    /**
+     * After workspace setup finishes, start the default run/dev script.
+     * Conductor: `scripts.auto_run_after_setup` (default off).
+     */
+    autoRunAfterSetup?: boolean;
+    /**
+     * Keep the Mac awake with `caffeinate` while any agent turn is running.
+     * Conductor: General → “Caffeinate while agents are running”.
+     */
+    caffeinateWhileRunning?: boolean;
+    /**
+     * Keep the Mac awake with `caffeinate` while Brightsy cloud connect is listening
+     * (so Slack/Discord/Teams tasks can be polled). Default off.
+     */
+    caffeinateWhileCloudConnect?: boolean;
+    /**
+     * When purging a thread, also delete its git branch.
+     * Conductor: `git.delete_branch_on_archive` (default off).
+     */
+    deleteBranchOnPurge?: boolean;
+    /** Max concurrent agent turns across the orchestrator (default 3). */
+    maxConcurrent?: number;
+    /**
+     * Max Sideboard worktrees kept machine-wide before orphan cleanup
+     * (Cursor: cursor.worktreeMaxCount, default 25).
+     */
+    worktreeMaxCount?: number;
+    /** Hours between automatic orphan worktree cleanup passes (default 6). */
+    worktreeCleanupIntervalHours?: number;
+    /** ISO timestamp of last successful orphan cleanup. */
+    worktreeLastCleanupAt?: string;
+    /** When true, reconcile auto-removes excess orphan worktrees. */
+    autoCleanupOrphans?: boolean;
+}
+interface AppSettings {
+    /** Environment variables injected into agent / hook processes (and process.env). */
+    environment: Record<string, string>;
+    /** Claude Code–specific harness settings. */
+    claude: ClaudeHarnessSettings;
+    /** Brightsy cloud connect preferences (Slack / Discord / Teams). */
+    brightsy: BrightsyHarnessSettings;
+    /** GitHub / Linear connections and issue-source preference. */
+    integrations: IntegrationsSettings;
+    /** Power-user / Conductor-style advanced preferences. */
+    advanced: AdvancedAppSettings;
+}
+declare function appSettingsPath(): string;
+/** User-level Claude Code settings file (`~/.claude/settings.json`). */
+declare function claudeUserSettingsPath(): string;
+declare function loadAppSettings(): AppSettings;
+declare function saveAppSettings(settings: AppSettings): AppSettings;
+declare function updateAppEnvironment(patch: Record<string, string | null | undefined>): AppSettings;
+declare function updateClaudeSettings(patch: {
+    executablePath?: string | null;
+    chromeEnabled?: boolean;
+}): AppSettings;
+declare function updateBrightsySettings(patch: {
+    cloudConnectEnabled?: boolean;
+    cloudConnectAgent?: BrightsyCloudConnectAgent | null;
+}): AppSettings;
+declare function updateIntegrationsSettings(patch: {
+    linearApiKey?: string | null;
+    issueSource?: IssueSource | null;
+}): AppSettings;
+/** True when Sideboard has a Linear API key stored. */
+declare function isLinearConnected(settings?: AppSettings): boolean;
+/** Preferred issue source (default GitHub). */
+declare function getIssueSource(settings?: AppSettings): IssueSource;
+/**
+ * Runtime issue source: honors preference, but falls back to GitHub when
+ * Linear is preferred and not connected.
+ */
+declare function resolveEffectiveIssueSource(settings?: AppSettings): IssueSource;
+declare function getLinearApiKey(settings?: AppSettings): string | null;
+declare function brightsyCloudConnectEnabled(settings?: AppSettings): boolean;
+declare function brightsyCloudConnectAgent(settings?: AppSettings): BrightsyCloudConnectAgent;
+declare function updateAdvancedSettings(patch: Partial<AdvancedAppSettings>): AppSettings;
+/** Conductor default: on. */
+declare function autoRenameBranchEnabled(settings?: AppSettings): boolean;
+declare function autoRunAfterSetupEnabled(settings?: AppSettings): boolean;
+declare function caffeinateWhileRunningEnabled(settings?: AppSettings): boolean;
+declare function caffeinateWhileCloudConnectEnabled(settings?: AppSettings): boolean;
+declare function deleteBranchOnPurgeEnabled(settings?: AppSettings): boolean;
+declare function autoCleanupOrphansEnabled(settings?: AppSettings): boolean;
+declare function maxConcurrentAgents(settings?: AppSettings): number;
+/** Binary name or absolute path used to spawn Claude Code. */
+declare function resolveClaudeExecutable(settings?: AppSettings): string;
+declare function claudeChromeEnabled(settings?: AppSettings): boolean;
+/**
+ * Apply Sideboard-managed environment onto a process env object.
+ * Does not overwrite keys already set in the host environment (shell wins),
+ * matching Conductor's "shell or Settings" layering for credentials.
+ */
+declare function applyAppEnvironment(target?: NodeJS.ProcessEnv, settings?: AppSettings): NodeJS.ProcessEnv;
+/** Env for a child process: host env + Sideboard settings (settings fill gaps). */
+declare function childEnvWithAppSettings(extra?: Record<string, string | undefined>): NodeJS.ProcessEnv;
+declare function harnessEnvKey(harness: HarnessId): string | null;
+
+declare function normalizeThread(raw: Thread): Thread;
+declare function createEmptyThread(partial: Omit<Thread, 'id' | 'createdAt' | 'updatedAt' | 'messages' | 'queue' | 'status' | 'devPort' | 'activeRuns' | 'prUrl' | 'prTitle' | 'userSetTitle' | 'sessionId' | 'sourceIsFork' | 'parentThreadId' | 'autonomy' | 'model' | 'fast' | 'planMode' | 'attachments'> & Partial<Pick<Thread, 'sessionId' | 'sourceIsFork' | 'parentThreadId' | 'autonomy' | 'model' | 'fast' | 'planMode' | 'messages' | 'queue' | 'status' | 'devPort' | 'activeRuns' | 'prUrl' | 'prTitle' | 'userSetTitle' | 'attachments'>>): Thread;
+declare function withThreadLock<T>(id: string, fn: () => Promise<T>): Promise<T>;
+declare function readThread(id: string): Thread | null;
+declare function writeThread(thread: Thread): void;
+declare function listThreads(opts?: {
+    includeArchived?: boolean;
+}): Thread[];
+declare function deleteThreadRecord(id: string): void;
+declare function updateThread(id: string, patch: Partial<Thread>): Thread;
+declare function appendMessage(id: string, message: ThreadMessage): Thread;
+declare function setStatus(id: string, status: ThreadStatus, lastError?: string | null): Thread;
+declare function findThreadByRef(ref: string): Thread | null;
+
+interface Workspace {
+    path: string;
+    name: string;
+    addedAt: string;
+}
+declare function listWorkspaces(): Workspace[];
+declare function addWorkspace(repoPath: string): Promise<Workspace>;
+declare function removeWorkspace(repoPath: string): void;
+/** Ensure a repo path is registered (e.g. after creating a thread). */
+declare function ensureWorkspace(repoPath: string): Promise<Workspace>;
+/** Merge in repo paths discovered from existing threads. */
+declare function syncWorkspacesFromThreads(repoPaths: string[]): Workspace[];
+
+/** Sentinel repoPath for the home-less global orchestration workspace. */
+declare const GLOBAL_WORKSPACE_ID = "__global__";
+declare function isGlobalThread(thread: Pick<Thread, 'repoPath'> | null | undefined): boolean;
+declare function isGlobalRepoPath(repoPath: string | null | undefined): boolean;
+
+/** True for Global chats and legacy pinned-repo orchestration threads. */
+declare function isOrchestratorThread(thread: Pick<Thread, 'sourceType' | 'repoPath'> | null | undefined): boolean;
+/**
+ * True when a Global/orchestrator Claude session acted like a worktree coder
+ * (Bash/Read/etc) without ever calling Sideboard MCP — resume would keep that
+ * wrong identity ("empty worktree / not a git repo").
+ */
+declare function orchestratorSessionPoisonedByBuiltins(thread: Pick<Thread, 'messages'> | null | undefined): boolean;
+declare function isCloudCoordinatorThread(thread: Pick<Thread, 'sourceType' | 'sourceRef' | 'title' | 'repoPath'>): boolean;
+/** True when an orchestration chat still needs a soccer-team nickname. */
+declare function orchestrationTitleNeedsSoccerNickname(thread: Pick<Thread, 'title' | 'sourceRef' | 'sourceType' | 'repoPath' | 'userSetTitle'>): boolean;
+interface CreateGlobalChatOpts {
+    title?: string;
+    agent: AgentKind;
+    /** Goal / cloud marker on sourceRef. Title is always a soccer nickname. Cloud uses CLOUD_ORCHESTRATOR_GOAL as sourceRef. */
+    sourceRef?: string;
+    autonomy?: Autonomy;
+    model?: string | null;
+    fast?: boolean;
+    planMode?: boolean;
+    attachments?: ThreadAttachment[];
+    parentThreadId?: string | null;
+}
+/** Soccer-team slugs already used by active threads (orchestration + worktrees). */
+declare function takenTeamSlugsForOrchestration(): string[];
+/** Create a home-less orchestration chat under the Global workspace. */
+declare function createGlobalChat(opts: CreateGlobalChatOpts): Thread;
+/**
+ * Assign soccer nicknames to orchestration chats still using the cloud goal
+ * string, Untitled, or goal-as-title. Called from reconcile.
+ */
+declare function healOrchestrationSoccerTitles(): number;
+declare function listGlobalThreads(includeArchived?: boolean): Thread[];
+/** Find or create the singleton Brightsy cloud coordinator under Global. */
+declare function ensureCloudCoordinator(agent: AgentKind): Thread;
+
+declare function run(file: string, args: string[], opts?: {
+    cwd?: string;
+    reject?: boolean;
+    env?: Record<string, string>;
+}): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}>;
+declare function git(args: string[], cwd: string, opts?: {
+    reject?: boolean;
+}): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}>;
+declare function gh(args: string[], cwd: string, opts?: {
+    reject?: boolean;
+}): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}>;
+
+/**
+ * Memorable worktree / thread labels (Conductor-style nicknames).
+ * Slug is the directory + `thread/<slug>` branch; `name` is the UI title.
+ */
+interface TeamName {
+    name: string;
+    slug: string;
+}
+/** Famous soccer clubs — short, recognizable thread labels. */
+declare const FAMOUS_SOCCER_TEAMS: readonly TeamName[];
+declare function allocateTeamName(taken: Iterable<string>, random?: () => number): TeamName;
+
+/** Canonical worktree path for grouping tabs (browser-safe, no node:path). */
+declare function normalizeWorktreePath(worktreePath: string): string;
+declare function worktreeNameFromPath(worktreePath: string): string;
+/**
+ * True while the branch is still the Sideboard/Conductor-style placeholder
+ * (`thread/<soccer-team>` or equal to the worktree directory name).
+ */
+declare function isPlaceholderBranch(branchName: string, worktreePath: string): boolean;
+/** Branch shown in the UI — team nickname while placeholder, else the real branch. */
+declare function branchDisplayLabel(branchName: string, worktreePath: string): string;
+/**
+ * Conductor-style sidebar label:
+ * user override → PR title → branch (task name after rename) → soccer-team nickname.
+ */
+declare function threadDisplayLabel(thread: {
+    branchName: string;
+    worktreePath: string;
+    title?: string | null;
+    prTitle?: string | null;
+    userSetTitle?: boolean;
+}): string;
+/** @deprecated Prefer threadDisplayLabel — kept for call sites that only have branch/path. */
+declare function worktreeDisplayLabel(thread: {
+    branchName: string;
+    worktreePath: string;
+    title?: string | null;
+    prTitle?: string | null;
+    userSetTitle?: boolean;
+}): string;
+/** Stable worktree row label for a group of chat tabs. */
+declare function worktreeDisplayLabelForGroup(threads: {
+    branchName: string;
+    worktreePath: string;
+    createdAt: string;
+    title?: string | null;
+    prTitle?: string | null;
+    userSetTitle?: boolean;
+}[]): string;
+
+declare function slugify(input: string): string;
+declare function resolveRepoRoot(cwd: string): Promise<string>;
+/**
+ * Parse `owner/name` from a git remote URL (SSH or HTTPS).
+ */
+declare function parseGithubSlugFromRemoteUrl(url: string): string | null;
+/**
+ * Resolve `owner/name` for the GitHub repository connected to a local checkout.
+ * Used so Create-from PR/issue lists always target the selected workspace's remote
+ * (not whatever `gh` might infer from process cwd / upstream).
+ *
+ * Prefer **origin** over `gh repo view`. On Makerkit-style checkouts with both
+ * `origin` (your fork/product) and `upstream` (template), `gh repo view` often
+ * resolves to upstream — which lists the wrong open PRs in the create modal.
+ */
+declare function resolveGithubRepoSlug(repoPath: string): Promise<string | null>;
+declare function resolveDefaultBranch(repoPath: string): Promise<string>;
+/**
+ * Prefer `origin/<branch>` for diff/merge-base so Changes / Land don't inflate
+ * against a stale local default-branch tip (common after adopting a PR).
+ * Bare names like `main` upgrade when the remote-tracking ref exists; already-
+ * qualified refs (`origin/main`, `refs/…`) are left alone.
+ *
+ * `fallbackCwd` (usually the main repo) is tried when the worktree can't see
+ * the remote-tracking ref.
+ */
+declare function resolveDiffBaseRef(cwd: string, branchOrRef: string, fallbackCwd?: string): Promise<string>;
+declare function listBranches(repoPath: string, opts?: {
+    unmergedOnly?: boolean;
+}): Promise<BranchInfo[]>;
+declare function listPrs(repoPath: string): Promise<PrInfo[]>;
+declare function getPr(repoPath: string, number: number): Promise<PrInfo | null>;
+/** Prefer PR URL, then PR source ref, then branch name for `gh pr …`. */
+declare function resolvePrSelector(thread: Pick<Thread, 'prUrl' | 'sourceType' | 'sourceRef' | 'branchName'>): string | null;
+/**
+ * Local conflict probe for when GitHub reports mergeable=UNKNOWN (common) or
+ * when `gh` can't see mergeability. Merges HEAD into `origin/<base>` via
+ * `git merge-tree --write-tree` (exit 1 + "CONFLICT" ⇒ conflicts).
+ */
+declare function detectLocalMergeConflicts(cwd: string, baseRefName: string | null): Promise<{
+    conflicting: boolean;
+    base: string;
+    files: string[];
+}>;
+/** CI checks for a PR (`gh pr checks <selector> --json …`), plus synthetic
+ * mergeability / review rows (conflicts are not reported by `gh pr checks`).
+ * Returns `null` when no PR exists for the selector (so UI can show “link a PR”
+ * instead of “no checks yet”). Returns `[]` when a PR exists but has no checks. */
+declare function getPrChecks(cwd: string, selector: string): Promise<PrCheckRun[] | null>;
+/** PR description / commits / reviews (+ checks) for the Review tab. */
+declare function getPrDetails(cwd: string, selector: string): Promise<PrDetails | null>;
+declare function fetchPrHead(repoPath: string, number: number, localBranch: string): Promise<void>;
+interface CreateWorktreeResult {
+    branchName: string;
+    worktreePath: string;
+}
+/**
+ * Prefer an up-to-date remote tip (`origin/<branch>`) after fetch so new
+ * worktrees don't fork from a stale local main/master.
+ * Local-only refs (e.g. fetched PR heads, existing thread branches) stay local.
+ */
+declare function resolveWorktreeStartPoint(repoPath: string, sourceRef: string): Promise<string>;
+declare function createThreadWorktree(opts: {
+    repoPath: string;
+    sourceRef: string;
+    slug: string;
+}): Promise<CreateWorktreeResult>;
+declare function removeWorktree(repoPath: string, worktreePath: string, opts?: {
+    deleteBranch?: string;
+}): Promise<void>;
+declare function listWorktrees(repoPath: string): Promise<Array<{
+    path: string;
+    branch: string | null;
+}>>;
+declare function isDirty(worktreePath: string): Promise<boolean>;
+declare function currentBranch(worktreePath: string): Promise<string>;
+declare function commitAll(worktreePath: string, message: string): Promise<boolean>;
+declare function pushBranch(worktreePath: string, branchName: string): Promise<void>;
+/** Merge an open pull request via `gh pr merge` (squash by default).
+ * Draft PRs are marked ready first — GitHub rejects merge while still draft. */
+declare function mergePr(cwd: string, selector: string, opts?: {
+    method?: 'merge' | 'squash' | 'rebase';
+}): Promise<{
+    url: string;
+    state: string;
+}>;
+declare function createOrUpdatePr(worktreePath: string, opts: {
+    title: string;
+    body?: string;
+    base: string;
+    head: string;
+    draft?: boolean;
+    /** Open the GitHub PR form in the browser instead of creating via API. */
+    web?: boolean;
+}): Promise<string>;
+/** @deprecated Prefer allocateTeamSlug — kept for any external callers. */
+declare function suggestSlug(source: string): string;
+
+/** Slugs already used by worktree dirs, thread records, or `thread/<slug>` branches. */
+declare function collectTakenTeamSlugs(repoPath: string): Set<string>;
+/** Pick an unused soccer team for the worktree directory / branch slug. */
+declare function allocateTeamSlug(repoPath: string): TeamName;
+
+interface GitHubStatus {
+    connected: boolean;
+    login: string | null;
+    /** Hosts reported by `gh auth status` (usually github.com). */
+    hosts: string[];
+    /** Human-readable summary when disconnected. */
+    reason: string | null;
+}
+/**
+ * Machine-global GitHub auth via the `gh` CLI (same path Sideboard uses for PRs).
+ */
+declare function getGitHubStatus(): Promise<GitHubStatus>;
+/** Open interactive `gh auth login` in a terminal-friendly way (caller may spawn UI). */
+declare function refreshGitHubAuth(): Promise<GitHubStatus>;
+
+/**
+ * List open issues assigned to the authenticated Linear user via GraphQL.
+ * Uses Sideboard-stored API key (Account → Linear), not agent MCP.
+ */
+declare function listLinearIssuesDirect(opts?: {
+    limit?: number;
+    apiKey?: string | null;
+}): Promise<IssueInfo[]>;
+/** Probe Linear with the stored key (or provided key). */
+declare function validateLinearApiKey(apiKey: string): Promise<boolean>;
+
+interface ListIssuesResult {
+    source: IssueSource;
+    /** Preference before fallback (useful for “Set up Linear” UI). */
+    preferredSource: IssueSource;
+    linearConnected: boolean;
+    issues: IssueInfo[];
+}
+/**
+ * List GitHub Issues for the repo via `gh` (machine-global auth).
+ * Scoped to the workspace's connected GitHub remote via `--repo`.
+ */
+declare function listGitHubIssues(repoPath: string, opts?: {
+    limit?: number;
+}): Promise<IssueInfo[]>;
+/**
+ * Unified issue list for Create-from / Link issue / MCP / CLI.
+ * Uses Sideboard Account connections — not agent Linear MCP.
+ */
+declare function listIssues(repoPath: string): Promise<ListIssuesResult>;
+
+/**
+ * Turn payload for agent CLIs.
+ * `cachedPrefix` is stable context (instructions, conversation seed) sent before
+ * the varying current request. Claude Code injects Anthropic cache_control on the
+ * assembled API request (system + tools + messages, max 4). Sideboard must not use
+ * `--input-format stream-json` for user input or attach cache_control — either
+ * adds a fifth breakpoint and triggers API 400 "Found 5".
+ */
+interface AgentTurnInput {
+    /** Stable prefix — instructions / session seed (cacheable, but no cache_control). */
+    cachedPrefix?: string;
+    /** Current user/turn content (after the stable prefix). */
+    prompt: string;
+}
+declare function normalizeTurnInput(input: string | AgentTurnInput): Required<Pick<AgentTurnInput, 'prompt'>> & AgentTurnInput;
+/**
+ * Flatten to a single string for CLIs that don't accept cache_control blocks
+ * (Codex today; OpenCode `run` is plain text — OpenCode applies provider caching
+ * internally after it receives the message).
+ */
+declare function flattenTurnInput(input: string | AgentTurnInput): string;
+/** Anthropic cache breakpoint shape (used when validating assembled requests). */
+type AnthropicCacheControl = {
+    type: 'ephemeral';
+    ttl?: '5m' | '1h';
+};
+/**
+ * Anthropic content blocks for Claude stream-json user messages (legacy/tests).
+ * Production Claude turns use plain-text `-p` — see claudeAdapter.buildTurn.
+ * Always a single text block — never attach cache_control here.
+ */
+declare function buildCachedUserContent(input: string | AgentTurnInput): Array<{
+    type: 'text';
+    text: string;
+}>;
+/** NDJSON stdin line for `claude -p --input-format stream-json`. */
+declare function buildClaudeStreamJsonUserMessage(input: string | AgentTurnInput): string;
+type CacheControlCarrier = {
+    cache_control?: AnthropicCacheControl;
+    content?: unknown;
+};
+/**
+ * Walk nested Anthropic content blocks and verify 1h breakpoints never follow 5m
+ * ones (Anthropic rejects requests that violate this ordering).
+ */
+declare function findInvalidCacheControlTtlOrder(blocks: CacheControlCarrier[] | undefined): {
+    index: number;
+    ttl: '1h' | '5m';
+} | null;
+/** Count cache_control blocks in nested Anthropic content (API max is 4). */
+declare function countCacheControlBlocks(blocks: CacheControlCarrier[] | undefined): number;
+/** Anthropic allows at most four cache_control blocks per request. */
+declare const MAX_ANTHROPIC_CACHE_CONTROL_BLOCKS = 4;
+
+interface TurnCommand {
+    file: string;
+    args: string[];
+    cwd: string;
+    env?: Record<string, string>;
+    /** When set, written to the child process stdin (e.g. Claude stream-json). */
+    stdin?: string;
+}
+interface AttachCommand {
+    file: string;
+    args: string[];
+    cwd: string;
+    env?: Record<string, string>;
+}
+interface AgentAdapter {
+    kind: AgentKind;
+    detect(): Promise<AgentStatus>;
+    buildTurn(thread: Thread, input: string | AgentTurnInput): Promise<TurnCommand>;
+    parseEvent(line: string): AgentEvent | AgentEvent[] | null;
+    resolveSessionId(worktreePath: string, cached: string | null): Promise<string | null>;
+    buildAttach(thread: Thread): Promise<AttachCommand>;
+    /** Optional: list Linear issues via this agent's MCP connector */
+    listLinearIssues?(repoPath: string): Promise<Array<{
+        id: string;
+        identifier: string;
+        title: string;
+        url: string;
+        labels: string[];
+    }>>;
+}
+declare const PLAN_MODE_INSTRUCTION = "Plan mode is active and must remain active until the user turns Plan mode off in the UI (or explicitly asks you to implement). Analyze the codebase, search and read files as needed, and produce or refine a clear implementation plan. Do not modify, create, or delete any files. Do not exit plan mode on your own.";
+declare function permissionMode(thread: Pick<Thread, 'autonomy' | 'planMode'>): {
+    claude: string;
+    opencodePermission: string;
+    codexSandbox: 'read-only' | 'workspace-write';
+};
+
+/**
+ * Pure Brightsy chat-target helpers — safe to import from the Electron renderer
+ * (no Node / execa deps).
+ */
+type BrightsyChatTarget = {
+    type: 'agent' | 'model';
+    id: string;
+    name: string;
+    description?: string | null;
+    accountId?: string;
+    accountSlug?: string;
+    accountName?: string;
+};
+type BrightsyTeamTargets = {
+    accountId: string;
+    accountSlug: string;
+    accountName: string;
+    agents: BrightsyChatTarget[];
+    models: BrightsyChatTarget[];
+};
+type BrightsyChatTargets = {
+    /** Per connected-team agent/model lists for the composer picker. */
+    teams: BrightsyTeamTargets[];
+    /** Flat lists (active / first team) — backward compatible. */
+    agents: BrightsyChatTarget[];
+    models: BrightsyChatTarget[];
+    activeAccountId: string | null;
+};
+type DecodedBrightsyTarget = {
+    type: 'agent' | 'model';
+    id: string;
+    /** Team that owns this target (when encoded). */
+    accountId?: string;
+};
+/** Encode a Brightsy target into Thread.model (`agent:…` / `model:…` / `team:…:agent:…`). */
+declare function encodeBrightsyTarget(type: 'agent' | 'model', id: string, accountId?: string | null): string;
+/** Decode Thread.model for Brightsy turns. null/`default` → platform default agent. */
+declare function decodeBrightsyTarget(model: string | null | undefined): DecodedBrightsyTarget;
+
+/**
+ * Agents + models for each Sideboard-connected Brightsy team (composer picker).
+ * Falls back to CLI list-targets when no teams are connected yet.
+ */
+declare function listBrightsyChatTargets(): Promise<BrightsyChatTargets>;
+/**
+ * Brightsy hosted-agent adapter. `brightsy chat --json` emits NDJSON events
+ * (text deltas, tool output, usage, error, done); the message is piped on
+ * stdin. The CLI has no session resume, so resolveSessionId always returns
+ * null and Sideboard seeds each turn from thread history. Brightsy agents run
+ * server-side — they converse about the worktree but never edit local files.
+ * All Brightsy agents/models use OpenRouter chat-completions syntax; the CLI
+ * owns that wire format.
+ *
+ * Thread.model encodes the chat target as `agent:<id>` or `model:<id>`
+ * (null → Default Agent).
+ */
+declare const brightsyAdapter: AgentAdapter;
+
+declare const claudeAdapter: AgentAdapter;
+
+declare const codexAdapter: AgentAdapter;
+
+/** JSON payload written to the Cursor runner on stdin. */
+type CursorTurnRequest = {
+    prompt: string;
+    cwd: string;
+    agentId?: string | null;
+    model?: string | null;
+    fast?: boolean;
+    planMode?: boolean;
+    apiKey?: string;
+};
+/** Subset of Cursor SDK stream messages we care about (keeps tests free of the SDK). */
+type CursorSdkStreamMessage = {
+    type: string;
+    agent_id?: string;
+    text?: string;
+    call_id?: string;
+    name?: string;
+    status?: string;
+    args?: unknown;
+    result?: unknown;
+    message?: {
+        role?: string;
+        content?: Array<{
+            type?: string;
+            text?: string;
+            id?: string;
+            name?: string;
+            input?: unknown;
+        }>;
+    };
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheReadTokens?: number;
+        cacheWriteTokens?: number;
+    };
+};
+/**
+ * Map a Cursor SDK stream message into Sideboard AgentEvent(s).
+ * Mirrors how Conductor consumes `run.stream()` events.
+ */
+declare function cursorSdkMessageToEvents(msg: CursorSdkStreamMessage): AgentEvent[];
+/** Parse one NDJSON line emitted by the Cursor runner (already Sideboard AgentEvents). */
+declare function parseCursorRunnerLine(line: string): AgentEvent | AgentEvent[] | null;
+
+declare const cursorAdapter: AgentAdapter;
+
+declare const opencodeAdapter: AgentAdapter;
+
+/**
+ * Electron / GUI apps often inherit a minimal PATH that omits Homebrew and
+ * user bin dirs where `claude` / `codex` / `opencode` / `brightsy` live. Call
+ * once at process start (and before agent spawns) so adapters can resolve CLIs.
+ */
+declare function ensureAgentPath(env?: NodeJS.ProcessEnv): string;
+
+declare function getAdapter(kind: AgentKind): AgentAdapter;
+declare function allAdapters(): AgentAdapter[];
+
+interface SpawnTurnHandle {
+    pid: number | undefined;
+    kill: () => void;
+    done: Promise<{
+        exitCode: number | null;
+        sessionId: string | null;
+        assistantText: string;
+        parts: MessagePart[];
+        usage: TokenUsage | null;
+    }>;
+}
+declare function spawnAgentTurn(thread: Thread, input: string | AgentTurnInput, onEvent: (event: AgentEvent) => void): Promise<SpawnTurnHandle>;
+
+declare function toolDetail(name: string, input?: Record<string, unknown>): string | undefined;
+declare function toolDescription(name: string, input?: Record<string, unknown>): string;
+declare function toolFilePath(input?: Record<string, unknown>): string | undefined;
+/** Apply a structured agent event onto an accumulated parts list. */
+declare function applyAgentEvent(parts: MessagePart[], event: AgentEvent): MessagePart[];
+declare function partsToAssistantText(parts: MessagePart[]): string;
+/**
+ * Strip Brightsy CLI NDJSON control events that accidentally landed in transcript
+ * text (`tool_use` / `tool_result` / …). Matches one or more concatenated objects.
+ */
+declare function stripBrightsyNdjsonNoise(text: string): string;
+/** True when a stdout line is Brightsy CLI NDJSON (should never be answer text). */
+declare function isBrightsyNdjsonLine(line: string): boolean;
+declare function finalizeParts(parts: MessagePart[]): MessagePart[];
+declare function normalizeParseResult(parsed: AgentEvent | AgentEvent[] | null): AgentEvent[];
+
+/** Accumulate incremental usage (one CLI turn may report usage in several steps). */
+declare function mergeUsage(a: TokenUsage | null, b: TokenUsage): TokenUsage;
+/** Total tokens processed for a turn (input + output + cache reads/writes). */
+declare function totalTokens(u: TokenUsage): number;
+
+interface McpServerStatus {
+    name: string;
+    connected: boolean;
+    needsAuth: boolean;
+}
+/**
+ * Parse `claude mcp list` human output.
+ * Example lines:
+ *   claude.ai Brightsy Ai: https://mcp.brightsy.ai/mcp - ✔ Connected
+ *   claude.ai Slack: https://mcp.slack.com/mcp - ! Needs authentication
+ */
+declare function parseMcpList(text: string): McpServerStatus[];
+/**
+ * Claude Code turns MCP server display names into tool-name segments by
+ * replacing any character outside [A-Za-z0-9_-] with `_`.
+ * e.g. "claude.ai Brightsy Ai" → "claude_ai_Brightsy_Ai"
+ * Tools are then `mcp__claude_ai_Brightsy_Ai__list_agents`.
+ */
+declare function sanitizeMcpServerName(name: string): string;
+/**
+ * Allow-list entries for connected MCP servers.
+ * Emit both server-level and tool-wildcard forms (no spaces — `--allowedTools`
+ * splits on commas *and* spaces).
+ */
+declare function mcpAllowTools(servers: McpServerStatus[]): string[];
+declare function mcpAuthWarnings(servers: McpServerStatus[]): string[];
+
+/**
+ * Conductor-style first-turn instruction: rename the placeholder branch to match
+ * the task. Worktree directory stays the soccer-team nickname.
+ */
+declare function formatRenameBranchDirective(thread: Pick<Thread, 'worktreePath' | 'branchName'>, opts?: {
+    customPrompt?: string | null;
+}): string | null;
+/**
+ * Mandatory Sideboard isolation + landing guidance — agents must edit the thread
+ * worktree and open PRs whose titles/bodies describe the *purpose of the changes*.
+ */
+declare function formatWorktreeDirective(thread: Pick<Thread, 'worktreePath' | 'repoPath' | 'branchName'> & Partial<Pick<Thread, 'title' | 'prUrl'>>): string;
+interface AgentInstructionFile {
+    relativePath: string;
+    content: string;
+}
+/**
+ * Load agent instruction files from the worktree (CLAUDE.md, AGENTS.md, …).
+ * These are project conventions the CLI may auto-load; we attach them explicitly
+ * so non-interactive `-p` / `exec` turns always see them.
+ */
+declare function loadAgentInstructions(worktreePath: string, agent: AgentKind): AgentInstructionFile[];
+/** Format instruction files as a stable cacheable prefix (no current request). */
+declare function formatAgentInstructions(files: AgentInstructionFile[]): string | null;
+/** Prepend instruction files to the agent-facing prompt. */
+declare function withAgentInstructions(prompt: string, files: AgentInstructionFile[]): string;
+
+declare function detectAgents(): Promise<AgentStatus[]>;
+declare function requireAgent(agent: AgentStatus['agent'], opts?: {
+    requireLinear?: boolean;
+}): Promise<AgentStatus>;
+
+type RunMode = 'concurrent' | 'nonconcurrent';
+interface RunScript {
+    name: string;
+    command: string;
+    default?: boolean;
+    /** Lucide-style icon name (Conductor-compatible). */
+    icon?: string;
+    /** Where the script is available: local, cloud, or both. */
+    availableIn?: Array<'local' | 'cloud'>;
+}
+interface RepoSettings {
+    /** Which file family was loaded */
+    source: 'sideboard' | 'conductor';
+    setup?: string;
+    /** Script run before archive/purge tears down the worktree. */
+    archive?: string;
+    /** concurrent = multiple workspaces may run scripts; nonconcurrent = one at a time. */
+    runMode: RunMode;
+    filesToCopy?: string[];
+    /** Glob patterns from settings (Conductor file_include_globs). */
+    fileIncludeGlobs?: string[];
+    runScripts: RunScript[];
+    /** Optional override for worktree root (supports ~) */
+    worktreesRoot?: string;
+    editor?: string;
+    /** Conductor-compatible agent prompt overrides from `[prompts]`. */
+    prompts?: {
+        renameBranch?: string;
+        createPr?: string;
+        general?: string;
+    };
+}
+/**
+ * Load settings for a single checkout root.
+ * Prefer `.sideboard`, fall back to `.conductor`. Overlay `settings.local.toml`.
+ */
+declare function loadRepoSettings(repoPath: string): RepoSettings | null;
+/**
+ * Settings for a thread workspace.
+ *
+ * Scripts always run with cwd = worktree (not the main repo). Config resolution
+ * matches Conductor:
+ * 1. Committed `settings.toml` from the worktree (branch snapshot), else main repo
+ * 2. Overlay main-repo `settings.local.toml` (machine-local, applies to all workspaces)
+ * 3. Overlay worktree `settings.local.toml` if present
+ */
+declare function loadWorkspaceSettings(worktreePath: string, repoPath?: string | null): RepoSettings | null;
+/** @deprecated use loadRepoSettings */
+declare function loadConductorSettings(repoPath: string): RepoSettings | null;
+declare function hasRepoHook(repoPath: string): boolean;
+/** True if either the worktree or (optional) main repo has setup/run config. */
+declare function hasWorkspaceHook(worktreePath: string, repoPath?: string | null): boolean;
+/** @deprecated use hasRepoHook / hasWorkspaceHook */
+declare function hasConductorHook(worktreePath: string, repoPath?: string | null): boolean;
+declare function settingsSourceLabel(rootPath: string): string | null;
+/** Label including whether config was found in the worktree vs main repo. */
+declare function workspaceSettingsSourceLabel(worktreePath: string, repoPath?: string | null): string | null;
+interface RepoSetupInfo {
+    /** `.sideboard` or `.conductor` settings exist. */
+    hasConfig: boolean;
+    /** `[scripts] setup = "..."` is defined in the loaded config. */
+    hasSetupScript: boolean;
+    configLabel: string | null;
+}
+/** Setup panel state for a thread worktree (falls back to main repo config). */
+declare function getRepoSetupInfo(worktreePath: string, repoPath?: string | null): RepoSetupInfo;
+
+type ConductorSettings = RepoSettings;
+
+/**
+ * Read `.worktreeinclude` patterns (one per line; `#` comments; blank skipped).
+ * Conductor: repo-root file listing gitignored files to copy into each worktree.
+ */
+declare function readWorktreeInclude(repoPath: string): string[];
+/**
+ * Resolve files to copy using Conductor order:
+ * 1. `.worktreeinclude`
+ * 2. settings `filesToCopy` / `file_include_globs`
+ * 3. default `.env*`
+ */
+declare function resolveFilesToCopy(repoPath: string): string[];
+declare function copyConfiguredFiles(repoPath: string, worktreePath: string): string[];
+declare function captureLoginEnv(): Promise<NodeJS.ProcessEnv>;
+interface WorkspaceScriptEnvOpts {
+    worktreePath: string;
+    repoPath: string;
+    workspaceName?: string;
+    defaultBranch?: string;
+    ports?: number[];
+}
+/** Build Conductor/Sideboard env vars for setup/run scripts. */
+declare function buildWorkspaceScriptEnv(opts: WorkspaceScriptEnvOpts, baseEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+interface ScriptHandle {
+    pid: number | undefined;
+    kill: () => void;
+    done: Promise<number | null>;
+    child: ResultPromise;
+}
+declare function runSetupScript(repoPath: string, worktreePath: string, onLine?: (line: string) => void, opts?: {
+    signal?: AbortSignal;
+    defaultBranch?: string;
+}): Promise<{
+    ran: boolean;
+    exitCode: number | null;
+    source: string | null;
+    kill?: () => void;
+}>;
+declare function runArchiveScript(repoPath: string, worktreePath: string, onLine?: (line: string) => void): Promise<{
+    ran: boolean;
+    exitCode: number | null;
+}>;
+declare function listRunScripts(worktreePath: string, repoPath?: string | null): RunScript[];
+declare function getDefaultRunScript(worktreePath: string, repoPath?: string | null): RunScript | null;
+declare function getRunScript(worktreePath: string, repoPath: string | null | undefined, name?: string | null): RunScript | null;
+declare function getRunMode(worktreePath: string, repoPath?: string | null): 'concurrent' | 'nonconcurrent';
+declare function allocatePort(): Promise<number>;
+/** Allocate a contiguous block of ports (Conductor: CONDUCTOR_PORT … +9). */
+declare function allocatePortRange(size?: number): Promise<number[]>;
+interface DevServerHandle {
+    pid: number | undefined;
+    port: number;
+    ports: number[];
+    scriptName: string;
+    kill: () => void;
+    done: Promise<number | null>;
+}
+declare function startDevServer(repoPath: string, worktreePath: string, onLine?: (line: string) => void, opts?: {
+    scriptName?: string;
+    defaultBranch?: string;
+}): Promise<DevServerHandle | null>;
+
+/**
+ * Cursor `.cursor/worktrees.json` setup — used when Sideboard/Conductor
+ * settings have no setup script.
+ *
+ * Docs: https://cursor.com/docs/configuration/worktrees
+ */
+interface CursorWorktreesConfig {
+    'setup-worktree'?: string | string[];
+    'setup-worktree-unix'?: string | string[];
+    'setup-worktree-windows'?: string | string[];
+}
+/**
+ * Run Cursor worktree setup if `.cursor/worktrees.json` exists.
+ * Prefers worktree copy, then main repo. Sets ROOT_WORKTREE_PATH to the main checkout.
+ */
+declare function runCursorWorktreeSetup(repoPath: string, worktreePath: string, onLine?: (line: string) => void): Promise<{
+    ran: boolean;
+    exitCode: number | null;
+    source: string | null;
+}>;
+declare function hasCursorWorktreeSetup(worktreePath: string, repoPath?: string | null): boolean;
+
+/** Stable codes for the Changes panel (Cursor-style empty states). */
+type GitWorktreeStatus = 'ok' | 'missing_worktree' | 'not_git';
+declare function inspectGitWorktree(worktreePath: string): Promise<GitWorktreeStatus>;
+/** `git init` in the worktree so Changes can track files (Cursor-style). */
+declare function initializeGitRepository(worktreePath: string): Promise<void>;
+/**
+ * Snapshot current WIP as a stash commit (does not modify the working tree).
+ * Used as the "Last Agent Turn" baseline.
+ */
+declare function captureTurnBaseline(worktreePath: string): Promise<string | null>;
+interface GetDiffOptions {
+    base?: string;
+    maxHunkChars?: number;
+    scope?: DiffScope;
+    /** Stash/commit SHA captured at the start of the last agent turn. */
+    lastTurnBase?: string | null;
+    /** When scope is `commits`, show only this commit's patch. */
+    commitSha?: string | null;
+}
+/** Recent commits since merge-base (Cursor Commits submenu). */
+declare function listBranchCommits(worktreePath: string, repoPath: string, opts?: {
+    base?: string;
+    max?: number;
+}): Promise<DiffCommit[]>;
+/**
+ * Change set for the Changes panel, filtered by Cursor-style scope.
+ */
+declare function getDiff(worktreePath: string, repoPath: string, opts?: GetDiffOptions): Promise<DiffResult>;
+/** Tracked + untracked (non-ignored) files in a worktree. */
+declare function listWorktreeFiles(worktreePath: string, opts?: {
+    maxFiles?: number;
+}): Promise<string[]>;
+/** Read a text (or image) file from the worktree (capped). */
+declare function readWorktreeFile(worktreePath: string, relativePath: string, opts?: {
+    maxBytes?: number;
+}): {
+    path: string;
+    content: string;
+    truncated: boolean;
+    binary: boolean;
+    encoding: 'utf8' | 'base64';
+};
+/** Write a UTF-8 text file into the worktree. */
+declare function writeWorktreeFile(worktreePath: string, relativePath: string, content: string): {
+    path: string;
+};
+/** Compact summary for MCP token-frugal payloads */
+declare function getDiffSummary(worktreePath: string, repoPath: string, opts?: {
+    maxFiles?: number;
+    maxHunkChars?: number;
+}): Promise<{
+    base: string;
+    dirty: boolean;
+    stat: string;
+    files: Array<{
+        path: string;
+        status: string;
+        patch: string;
+        additions?: number;
+        deletions?: number;
+    }>;
+    truncated: boolean;
+}>;
+
+interface SkillInfo {
+    id: string;
+    name: string;
+    command: string;
+    description: string;
+    path: string;
+    source: 'workspace' | 'user' | 'cli';
+}
+/**
+ * Discover skills from the worktree + user/CLI skill locations.
+ * Workspace skills win over user/CLI when command names collide.
+ */
+declare function discoverSkills(worktreePath: string): SkillInfo[];
+declare function readSkillBody(skillPath: string, maxChars?: number): string;
+
+interface ExpandResult {
+    /** Prompt sent to the agent (may include attachments / skill bodies). */
+    agentPrompt: string;
+    mentionedFiles: string[];
+    skillsUsed: SkillInfo[];
+}
+/**
+ * Expand @file mentions, /skill commands, and composer attachments into agent context.
+ * Display text should remain the original user prompt.
+ */
+declare function expandComposerPrompt(worktreePath: string, prompt: string, opts?: {
+    skills?: SkillInfo[];
+    maxFileBytes?: number;
+    attachments?: ThreadAttachment[];
+}): ExpandResult;
+
+interface SummarizeResult {
+    summary: string;
+    method: 'claude' | 'extractive';
+}
+/**
+ * Summarize a conversation transcript for agent continuity.
+ * Prefers a fast Claude one-shot; falls back to extractive bullets.
+ */
+declare function summarizeConversation(transcript: string, opts?: {
+    cwd?: string;
+    timeoutMs?: number;
+}): Promise<SummarizeResult>;
+/** Deterministic fallback when Claude isn't available. */
+declare function extractiveSummary(transcript: string): string;
+
+/** Rough char budget before we compact (≈ 25k tokens at ~4 chars/token). */
+declare const CONTEXT_COMPACT_CHARS = 100000;
+/** Keep this much recent transcript after compaction. */
+declare const CONTEXT_KEEP_RECENT_CHARS = 24000;
+/** Always keep at least this many trailing messages. */
+declare const CONTEXT_KEEP_RECENT_MESSAGES = 12;
+/** Don't bother compacting tiny threads. */
+declare const CONTEXT_MIN_MESSAGES = 10;
+interface CompactThresholds {
+    maxChars?: number;
+    keepRecentChars?: number;
+    keepRecentMessages?: number;
+    minMessages?: number;
+}
+declare function estimateMessageChars(message: ThreadMessage): number;
+declare function estimateThreadChars(messages: ThreadMessage[]): number;
+declare function shouldCompactContext(messages: ThreadMessage[], thresholds?: CompactThresholds): boolean;
+/** Split into older (to summarize) + recent (kept verbatim). */
+declare function splitForCompaction(messages: ThreadMessage[], thresholds?: CompactThresholds): {
+    older: ThreadMessage[];
+    recent: ThreadMessage[];
+};
+type TranscriptToolDetail = 'full' | 'summary' | 'none';
+/**
+ * Format stored thread messages for agent context or summarization.
+ * Use `tools: 'full'` when the transcript is sent back to the agent so tool
+ * inputs/results are not truncated; `summary` keeps one-line tool labels for
+ * compaction prompts.
+ */
+declare function formatMessagesAsTranscript(messages: ThreadMessage[], opts?: {
+    tools?: TranscriptToolDetail;
+}): string;
+/**
+ * Seed prompt for a fresh agent session (no --resume).
+ * Includes summary + recent turns with full tool use data so continuity is not lost.
+ * Pass `tools: 'none'` for hosts that choke on tool-heavy seeds (e.g. Brightsy).
+ */
+declare function buildSessionSeed(messages: ThreadMessage[], opts?: {
+    tools?: TranscriptToolDetail;
+}): string | null;
+declare function applyCompaction(messages: ThreadMessage[], summaryText: string, thresholds?: CompactThresholds): ThreadMessage[];
+interface CompactResult {
+    didCompact: boolean;
+    thread: Thread;
+    summary?: string;
+    method?: 'claude' | 'extractive';
+    olderCount?: number;
+}
+/**
+ * If the thread transcript is oversized, summarize older turns, keep recent ones,
+ * and clear sessionId so the next agent turn starts fresh with a seed prompt.
+ */
+declare function maybeCompactContext(thread: Thread, thresholds?: CompactThresholds, summarize?: typeof summarizeConversation): Promise<CompactResult>;
+
+declare function previewLand(thread: Thread): Promise<LandPreview>;
+declare function confirmLand(thread: Thread, opts?: {
+    draft?: boolean;
+    web?: boolean;
+}): Promise<LandResult>;
+
+declare function createThread(input: CreateThreadInput, onSetupLine?: (line: string) => void): Promise<Thread>;
+/** @deprecated Prefer listIssues() from integrations/issues — agent-agnostic. */
+declare function listLinearIssues(agent: AgentKind, repoPath: string): Promise<{
+    id: string;
+    identifier: string;
+    title: string;
+    url: string;
+    labels: string[];
+}[]>;
+
+declare function sameWorktreePath(a: string, b: string): boolean;
+/** Soccer-team slugs already used by this worktree or sibling tab titles. */
+declare function takenTeamSlugsForChatTab(worktreePath: string): string[];
+declare function threadsSharingWorktree(worktreePath: string): Thread[];
+declare function formatTranscriptMarkdown(title: string, messages: ThreadMessage[]): string;
+declare function forkMessageSlice(from: Thread, throughIndex?: number): ThreadMessage[];
+declare function buildForkTranscriptAttachment(baseTitle: string, messages: ThreadMessage[]): ThreadAttachment;
+/** New chat tab in the same worktree (no new git worktree). */
+declare function createChatTab(input: CreateChatTabInput): Thread;
+/** Fork chat into a new tab with transcript attached in the composer. */
+declare function forkChatTab(input: ForkChatTabInput): Thread;
+
+/** Fork into a new git worktree branched from the source thread's branch. */
+declare function forkThreadWorktree(input: ForkThreadWorktreeInput, onSetupLine?: (line: string) => void): Promise<Thread>;
+
+/**
+ * Conductor persists Cursor SDK agent IDs under cursor-sdk-store/<hash>/agents.ndjson
+ * (not in sessions.claude_session_id). Prefer the newest durable agent for a cwd.
+ */
+declare function resolveConductorCursorAgentId(workspacePath: string): string | null;
+declare function adoptThread(input: AdoptInput): Promise<Thread>;
+declare function conductorDbPath(): string;
+declare function listConductorWorkspaces(): ConductorWorkspace[];
+declare function importConductorWorkspace(workspaceId: string): Thread;
+declare function importConductorWorkspaceAsync(workspaceId: string): Promise<Thread>;
+
+interface OrphanWorktree {
+    path: string;
+    repoPath: string;
+    mtimeMs: number;
+}
+/** Discover Sideboard worktrees on disk with no matching thread record. */
+declare function findOrphanWorktrees(repoPaths?: string[]): Promise<OrphanWorktree[]>;
+interface CleanupOrphansResult {
+    removed: string[];
+    kept: string[];
+    orphans: OrphanWorktree[];
+}
+/**
+ * Cursor-style cleanup: keep newest worktrees up to maxCount across the machine,
+ * remove older orphans (never removes paths still referenced by a thread).
+ */
+declare function cleanupOrphanWorktrees(opts?: {
+    maxCount?: number;
+    dryRun?: boolean;
+    repoPaths?: string[];
+}): Promise<CleanupOrphansResult>;
+declare function shouldRunWorktreeCleanup(settings?: AppSettings): boolean;
+declare function worktreeCleanupSettings(): Pick<AdvancedAppSettings, 'worktreeMaxCount' | 'worktreeCleanupIntervalHours' | 'worktreeLastCleanupAt' | 'autoCleanupOrphans'>;
+
+interface ApplyIntoMainResult {
+    applied: boolean;
+    method: 'merge' | 'cherry-pick';
+    targetBranch: string;
+    message: string;
+}
+/**
+ * Cursor `/apply-worktree` analog: bring the thread branch into the main
+ * checkout without landing a PR. Human-gated; leaves the thread intact.
+ */
+declare function applyThreadIntoMain(thread: Pick<Thread, 'repoPath' | 'worktreePath' | 'branchName'>, opts?: {
+    method?: 'merge' | 'cherry-pick';
+    targetBranch?: string;
+}): Promise<ApplyIntoMainResult>;
+
+declare class Orchestrator {
+    readonly events: EventEmitter<[never]>;
+    private readonly processes;
+    private readonly activeTurns;
+    private readonly draining;
+    /** Threads past setStatus(running) but not yet in activeTurns (spawn in flight). */
+    private readonly startingTurns;
+    /**
+     * Threads intentionally force-stopped. Prevents runTurn from re-asserting
+     * `running` after spawn, and from overwriting `stopped` with idle/error when
+     * the killed turn's handle.done resolves.
+     */
+    private readonly stoppedTurns;
+    /** WIP snapshot SHA at the start of the latest agent turn (per thread). */
+    private readonly turnBaselines;
+    private maxConcurrent;
+    private runningCount;
+    constructor(opts?: {
+        maxConcurrent?: number;
+    });
+    on(listener: (event: OrchestratorEvent) => void): () => void;
+    private emit;
+    /** True when disk says running but this process is not actually turning. */
+    private isStaleRunningThread;
+    reconcile(repoPath?: string, opts?: {
+        /**
+         * When true (default), mark disk-status `running` threads with no in-process
+         * turn as stopped. Must stay false in Sideboard MCP subprocesses — they do
+         * not own agent turns, so every live parent turn looks "dead".
+         */
+        reclaimStaleTurns?: boolean;
+    }): Promise<void>;
+    getThreads(includeArchived?: boolean): Thread[];
+    getThread(idOrRef: string): Thread | null;
+    createThread(input: CreateThreadInput): Promise<Thread>;
+    listWorkspaces(): Workspace[];
+    addWorkspace(repoPath: string): Promise<Workspace>;
+    removeWorkspace(repoPath: string): void;
+    adopt(input: Parameters<typeof adoptThread>[0]): Promise<Thread>;
+    listConductor(): ConductorWorkspace[];
+    adoptFromConductor(workspaceId: string): Promise<Thread>;
+    send(threadRef: string, prompt: string): Promise<Thread>;
+    fanOut(threadRefs: string[], prompt: string): Promise<Thread[]>;
+    private drainQueue;
+    private runTurn;
+    /**
+     * Stop an in-flight agent turn.
+     * Default `clearQueue: true` (force-stop): kills the turn AND empties queued prompts
+     * so drainQueue cannot continue / re-start work after an intentional stop. Desktop,
+     * CLI, MCP, and cloud-connect all share this default.
+     */
+    stop(threadRef: string, opts?: {
+        clearQueue?: boolean;
+    }): Thread;
+    startDev(threadRef: string, scriptName?: string): Promise<{
+        port: number;
+        scriptName: string;
+        ports: number[];
+    }>;
+    stopDev(threadRef: string, scriptName?: string): void;
+    listThreadRunScripts(threadRef: string): RunScript[];
+    getActiveRuns(threadRef: string): ActiveRun[];
+    runSetup(threadRef: string): Promise<{
+        exitCode: number | null;
+        source?: string | null;
+    }>;
+    cancelSetup(threadRef: string): void;
+    applyIntoMain(threadRef: string, opts?: {
+        method?: 'merge' | 'cherry-pick';
+        targetBranch?: string;
+    }): Promise<ApplyIntoMainResult>;
+    cloneRepo(url: string, name?: string): Promise<{
+        repoPath: string;
+        workspace: Workspace;
+    }>;
+    listOrphanWorktrees(repoPath?: string): Promise<OrphanWorktree[]>;
+    cleanupOrphans(opts?: {
+        dryRun?: boolean;
+        maxCount?: number;
+        repoPath?: string;
+    }): Promise<CleanupOrphansResult>;
+    /**
+     * Best-of-n / fanout: create N threads (one per agent) with the same prompt.
+     */
+    bestOfN(opts: {
+        prompt: string;
+        agents: AgentKind[];
+        repoPath: string;
+        sourceType?: 'branch' | 'pr' | 'ticket';
+        sourceRef?: string;
+        title?: string;
+    }): Promise<Thread[]>;
+    waitForTurn(threadRef: string, timeoutMs?: number): Promise<Thread>;
+    getTurnResult(threadRef: string): {
+        text: string;
+        status: string;
+        sessionId: string | null;
+    };
+    private assertNotGlobal;
+    diff(threadRef: string, opts?: {
+        scope?: DiffScope;
+        commitSha?: string | null;
+    }): Promise<DiffResult>;
+    diffSummary(threadRef: string): Promise<{
+        base: string;
+        dirty: boolean;
+        stat: string;
+        files: Array<{
+            path: string;
+            status: string;
+            patch: string;
+            additions?: number;
+            deletions?: number;
+        }>;
+        truncated: boolean;
+    }>;
+    initializeGit(threadRef: string): Promise<void>;
+    listFiles(threadRef: string): Promise<string[]>;
+    readFile(threadRef: string, relativePath: string): Promise<{
+        path: string;
+        content: string;
+        truncated: boolean;
+        binary: boolean;
+        encoding: 'utf8' | 'base64';
+    }>;
+    writeFile(threadRef: string, relativePath: string, content: string): Promise<{
+        path: string;
+    }>;
+    listSkills(threadRef: string): SkillInfo[];
+    previewLand(threadRef: string): Promise<LandPreview>;
+    confirmLand(threadRef: string, opts?: {
+        draft?: boolean;
+        web?: boolean;
+    }): Promise<LandResult>;
+    mergePr(threadRef: string): Promise<{
+        url: string;
+        state: string;
+    }>;
+    /** Resolve PR selector and optionally persist `prUrl` when found. */
+    private withPrSelector;
+    getPrChecks(threadRef: string): Promise<PrCheckRun[] | null>;
+    getPrDetails(threadRef: string): Promise<PrDetails | null>;
+    setAutonomy(threadRef: string, autonomy: Autonomy): Thread;
+    setThreadOptions(threadRef: string, patch: ThreadOptionsPatch): Thread;
+    createChatTab(input: {
+        fromThreadId: string;
+        agent?: Thread['agent'];
+        title?: string;
+    }): Thread;
+    forkChatTab(input: {
+        threadId: string;
+        throughIndex?: number;
+        agent?: Thread['agent'];
+        title?: string;
+    }): Thread;
+    forkThreadWorktree(input: {
+        threadId: string;
+        throughIndex?: number;
+        agent?: Thread['agent'];
+        title?: string;
+    }): Promise<Thread>;
+    renameThread(threadRef: string, title: string): Thread;
+    setAttachments(threadRef: string, attachments: Thread['attachments']): Thread;
+    listWorktreeChats(threadRef: string): Thread[];
+    archive(threadRef: string): Promise<Thread>;
+    purge(threadRef: string, opts?: {
+        deleteBranch?: boolean;
+    }): Promise<void>;
+    restore(threadRef: string): Promise<Thread>;
+    attachCommand(threadRef: string): Promise<AttachCommand>;
+    setMaxConcurrent(n: number): void;
+    getRuntime(): OrchestratorRuntime;
+    private requireThread;
+}
+declare function getOrchestrator(): Orchestrator;
+declare function startOrchestration(opts: {
+    goal: string;
+    agent: AgentKind;
+    /** Omit or pass GLOBAL_WORKSPACE_ID for a home-less Global chat. */
+    repoPath?: string;
+    autonomy?: Thread['autonomy'];
+    model?: string | null;
+    fast?: boolean;
+    planMode?: boolean;
+    attachments?: Thread['attachments'];
+}): Promise<Thread>;
+
+type WorkspaceInventoryEntry = Workspace & {
+    /** Best-effort GitHub `owner/repo` from remote / gh. */
+    githubSlug?: string | null;
+};
+/** Sync formatter — include `githubSlug` when already resolved. */
+declare function formatWorkspaceInventory(workspaces: WorkspaceInventoryEntry[]): string;
+/** Resolve GitHub slugs for registered workspaces (best-effort). */
+declare function enrichWorkspacesWithGithub(workspaces: Workspace[]): Promise<WorkspaceInventoryEntry[]>;
+declare const COORDINATOR_TOOL_PLAYBOOK: string;
+/**
+ * Short identity block prepended to every orchestration turn prompt.
+ * Survives Claude `--resume` (which drops cachedPrefix).
+ */
+declare function coordinatorTurnReminder(opts: {
+    parentId: string;
+    goal?: string;
+}): string;
+/**
+ * Write durable CLAUDE.md / AGENTS.md into the global synthetic cwd so Claude
+ * (and other agents that load AGENTS.md) keep orchestrator identity on resume.
+ */
+declare function ensureGlobalCoordinatorCwd(): string;
+declare function coordinatorSystemPrompt(opts: {
+    goal: string;
+    parentId: string;
+    workspaces: WorkspaceInventoryEntry[];
+    /** cloud = Brightsy reply framing; desktop = local Orchestration chat */
+    audience?: 'cloud' | 'desktop';
+}): string;
+
+/**
+ * Clone a repo into ~/sideboard/repos/<name> and register it as a workspace
+ * (Conductor Quick-start parity).
+ */
+declare function cloneRepoIntoSideboard(opts: {
+    url: string;
+    name?: string;
+}): Promise<{
+    repoPath: string;
+    workspace: Workspace;
+}>;
+
+/**
+ * Sideboard MCP server — agent-facing judgment surface.
+ * Deliberately excludes ready-for-review confirm_land and purge_thread.
+ * Draft PRs are allowed via create_draft_pr.
+ */
+declare function startMcpServer(): Promise<void>;
+
+interface BrightsyLocalConfig {
+    access_token: string;
+    refresh_token?: string;
+    account_id: string;
+    account_slug?: string;
+    endpoint?: string;
+    expires_at?: number;
+    oauth_client_id?: string;
+}
+declare function brightsyConfigPath(): string;
+declare function loadBrightsyConfig(): BrightsyLocalConfig;
+
+interface BrightsyAccount {
+    id: string;
+    name: string;
+    slug: string;
+    picture_url?: string;
+    role?: string;
+    is_personal_account?: boolean;
+    active?: boolean;
+}
+interface ConnectedBrightsyTeamInfo {
+    id: string;
+    slug: string;
+    name: string;
+    expires_at?: number;
+}
+interface BrightsySession {
+    connected: boolean;
+    endpoint: string;
+    /** CLI / Brightsy agent active team (~/.brightsy). */
+    accountId: string | null;
+    accountSlug: string | null;
+    accounts: BrightsyAccount[];
+    /** Teams connected in Sideboard for concurrent MCP injection. */
+    connectedTeams: ConnectedBrightsyTeamInfo[];
+    reason?: string;
+}
+/** List teams via `brightsy teams --json`. */
+declare function listBrightsyAccounts(): Promise<BrightsyAccount[]>;
+declare function getBrightsySession(): Promise<BrightsySession>;
+/**
+ * Activate a Brightsy team for CLI + MCP (same as connecting in Settings).
+ */
+declare function switchBrightsyAccount(accountIdOrSlug: string): Promise<BrightsySession>;
+
+/** Live status of the Brightsy cloud connect daemon in the desktop app. */
+interface CloudConnectStatus {
+    enabled: boolean;
+    running: boolean;
+    agent: BrightsyCloudConnectAgent;
+    endpoint: string | null;
+    workspaces: Workspace[];
+    lastError: string | null;
+    lastLog: string | null;
+}
+/** Shared typed surface for Electron preload ↔ renderer (and docs). */
+interface IpcApi {
+    detectAgents(): Promise<AgentStatus[]>;
+    getAppSettings(): Promise<AppSettings>;
+    saveAppSettings(settings: AppSettings): Promise<AppSettings>;
+    updateAppEnvironment(patch: Record<string, string | null | undefined>): Promise<AppSettings>;
+    updateClaudeSettings(patch: Partial<ClaudeHarnessSettings> & {
+        executablePath?: string | null;
+    }): Promise<AppSettings>;
+    /** Native file picker for a Claude Code executable override. */
+    pickClaudeExecutable(): Promise<string | null>;
+    /** Absolute path for PATH `claude`, or null if missing. */
+    resolveSystemClaudePath(): Promise<string | null>;
+    /** Ensure `~/.claude/settings.json` exists and open it in the OS default app. */
+    openClaudeUserSettings(): Promise<void>;
+    listBrightsyChatTargets(): Promise<BrightsyChatTargets>;
+    /** Brightsy login + connected teams (shared by CLI, Brightsy agent, and Claude MCP). */
+    getBrightsySession(): Promise<BrightsySession>;
+    /** Connect/activate a team for CLI + MCP (same as connectBrightsyTeam). */
+    switchBrightsyAccount(accountIdOrSlug: string): Promise<BrightsySession>;
+    /** Connect a team for CLI + MCP; activates it as the CLI session. */
+    connectBrightsyTeam(accountIdOrSlug: string): Promise<BrightsySession>;
+    /** Disconnect a team from the shared CLI + MCP selection. */
+    disconnectBrightsyTeam(accountIdOrSlug: string): Promise<BrightsySession>;
+    /** Brightsy cloud remote orchestrator status (desktop daemon). */
+    getCloudConnectStatus(): Promise<CloudConnectStatus>;
+    /** Enable/disable cloud connect and optionally set the coordinator agent. */
+    setCloudConnect(opts: {
+        enabled?: boolean;
+        agent?: BrightsyCloudConnectAgent;
+    }): Promise<CloudConnectStatus>;
+    updateBrightsySettings(patch: Partial<BrightsyHarnessSettings> & {
+        cloudConnectAgent?: BrightsyCloudConnectAgent | null;
+    }): Promise<AppSettings>;
+    updateAdvancedSettings(patch: Partial<AdvancedAppSettings>): Promise<AppSettings>;
+    updateIntegrationsSettings(patch: {
+        linearApiKey?: string | null;
+        issueSource?: IssueSource | null;
+    }): Promise<AppSettings>;
+    /** Machine-global GitHub status via `gh`. */
+    getGitHubStatus(): Promise<GitHubStatus>;
+    /**
+     * Unified issues for Create-from / Link issue (Linear API or GitHub Issues,
+     * based on Account preference with Linear→GitHub fallback).
+     */
+    listIssues(repoPath: string): Promise<ListIssuesResult>;
+    listBranches(repoPath: string, opts?: {
+        unmergedOnly?: boolean;
+    }): Promise<BranchInfo[]>;
+    listPrs(repoPath: string): Promise<PrInfo[]>;
+    /** @deprecated Prefer listIssues — agent Linear MCP. */
+    listLinearIssues(agent: AgentKind, repoPath: string): Promise<IssueInfo[]>;
+    resolveRepoRoot(cwd: string): Promise<string>;
+    getThreads(includeArchived?: boolean): Promise<Thread[]>;
+    getThread(idOrRef: string): Promise<Thread | null>;
+    getRuntime(): Promise<OrchestratorRuntime>;
+    setMaxConcurrent(n: number): Promise<void>;
+    createThread(input: CreateThreadInput): Promise<Thread>;
+    createChatTab(input: CreateChatTabInput): Promise<Thread>;
+    forkChatTab(input: ForkChatTabInput): Promise<Thread>;
+    forkThreadWorktree(input: ForkThreadWorktreeInput): Promise<Thread>;
+    renameThread(threadRef: string, title: string): Promise<Thread>;
+    setAttachments(threadRef: string, attachments: ThreadAttachment[]): Promise<Thread>;
+    listWorktreeChats(threadRef: string): Promise<Thread[]>;
+    listWorkspaces(): Promise<Workspace[]>;
+    addWorkspace(repoPath: string): Promise<Workspace>;
+    removeWorkspace(repoPath: string): Promise<void>;
+    adopt(input: AdoptInput): Promise<Thread>;
+    listConductor(): Promise<ConductorWorkspace[]>;
+    adoptFromConductor(workspaceId: string): Promise<Thread>;
+    sendToThread(threadRef: string, prompt: string): Promise<Thread>;
+    setAutonomy(threadRef: string, autonomy: Autonomy): Promise<Thread>;
+    setThreadOptions(threadRef: string, patch: ThreadOptionsPatch): Promise<Thread>;
+    fanOut(threadRefs: string[], prompt: string): Promise<Thread[]>;
+    startOrchestration(opts: {
+        goal: string;
+        agent: AgentKind;
+        /** Omit for Global workspace (home-less). */
+        repoPath?: string;
+        autonomy?: Autonomy;
+        model?: string | null;
+        fast?: boolean;
+        planMode?: boolean;
+        attachments?: ThreadAttachment[];
+    }): Promise<Thread>;
+    createGlobalChat(opts: {
+        title?: string;
+        agent: AgentKind;
+        autonomy?: Autonomy;
+        model?: string | null;
+        fast?: boolean;
+        planMode?: boolean;
+        attachments?: ThreadAttachment[];
+    }): Promise<Thread>;
+    ensureCloudCoordinator(agent: AgentKind): Promise<Thread>;
+    stopThread(threadRef: string): Promise<Thread>;
+    getDiff(threadRef: string, opts?: {
+        scope?: DiffScope;
+        commitSha?: string | null;
+    }): Promise<DiffResult>;
+    /** `git init` in the thread worktree when Changes has no Git repo (Cursor-style). */
+    initializeGit(threadRef: string): Promise<void>;
+    /** CI checks for the thread's linked PR (`gh pr checks`). `null` = no PR. */
+    getPrChecks(threadRef: string): Promise<PrCheckRun[] | null>;
+    /** PR description / commits / reviews for the Review tab. */
+    getPrDetails(threadRef: string): Promise<PrDetails | null>;
+    listFiles(threadRef: string): Promise<string[]>;
+    readFile(threadRef: string, relativePath: string): Promise<{
+        path: string;
+        content: string;
+        truncated: boolean;
+        binary: boolean;
+        encoding: 'utf8' | 'base64';
+    }>;
+    writeFile(threadRef: string, relativePath: string, content: string): Promise<{
+        path: string;
+    }>;
+    /** Watch the open file in the worktree; replaces any previous watch. */
+    watchOpenFile(threadRef: string, relativePath: string): Promise<void>;
+    unwatchOpenFile(): Promise<void>;
+    /** Fired when the watched open file changes on disk. */
+    onOpenFileChanged(listener: (payload: {
+        threadRef: string;
+        path: string;
+    }) => void): () => void;
+    listSkills(threadRef: string): Promise<Array<{
+        id: string;
+        name: string;
+        command: string;
+        description: string;
+        path: string;
+        source: 'workspace' | 'user' | 'cli';
+    }>>;
+    openInEditor(threadRef: string, editor?: string, relativePath?: string): Promise<void>;
+    openWorktree(threadRef: string, target: 'finder' | 'cursor' | 'code' | 'xcode' | 'terminal' | 'datagrip'): Promise<void>;
+    runDevScript(threadRef: string, scriptName?: string): Promise<{
+        port: number;
+        scriptName: string;
+        ports: number[];
+    }>;
+    stopDevScript(threadRef: string, scriptName?: string): Promise<void>;
+    listRunScripts(threadRef: string): Promise<Array<{
+        name: string;
+        command: string;
+        default?: boolean;
+        icon?: string;
+    }>>;
+    getActiveRuns(threadRef: string): Promise<Array<{
+        scriptName: string;
+        port: number;
+        ports: number[];
+        startedAt: string;
+    }>>;
+    previewLand(threadRef: string): Promise<LandPreview>;
+    confirmLand(threadRef: string, opts?: {
+        draft?: boolean;
+        web?: boolean;
+    }): Promise<LandResult>;
+    /** Merge the thread's linked PR on GitHub (`gh pr merge`). */
+    mergePr(threadRef: string): Promise<{
+        url: string;
+        state: string;
+    }>;
+    archiveThread(threadRef: string): Promise<Thread>;
+    purgeThread(threadRef: string, opts?: {
+        deleteBranch?: boolean;
+    }): Promise<void>;
+    restoreThread(threadRef: string): Promise<Thread>;
+    applyIntoMain(threadRef: string, opts?: {
+        method?: 'merge' | 'cherry-pick';
+        targetBranch?: string;
+    }): Promise<{
+        applied: boolean;
+        method: string;
+        targetBranch: string;
+        message: string;
+    }>;
+    cloneRepo(url: string, name?: string): Promise<{
+        repoPath: string;
+        workspace: Workspace;
+    }>;
+    listOrphanWorktrees(repoPath?: string): Promise<Array<{
+        path: string;
+        repoPath: string;
+        mtimeMs: number;
+    }>>;
+    cleanupOrphans(opts?: {
+        dryRun?: boolean;
+        maxCount?: number;
+        repoPath?: string;
+    }): Promise<{
+        removed: string[];
+        kept: string[];
+    }>;
+    bestOfN(opts: {
+        prompt: string;
+        agents: AgentKind[];
+        repoPath: string;
+        sourceType?: 'branch' | 'pr' | 'ticket';
+        sourceRef?: string;
+        title?: string;
+    }): Promise<Thread[]>;
+    /** Attach into the native agent CLI (opens a PTY session when available). */
+    attachThread(threadRef: string): Promise<{
+        file: string;
+        args: string[];
+        cwd: string;
+    }>;
+    /** Embedded terminal (PTY) IPC. */
+    terminal: {
+        start(threadRef: string, cols?: number, rows?: number): Promise<{
+            id: string;
+        }>;
+        /** Start a PTY running the native agent attach command. */
+        attach(threadRef: string, cols?: number, rows?: number): Promise<{
+            id: string;
+        }>;
+        write(id: string, data: string): Promise<void>;
+        resize(id: string, cols: number, rows: number): Promise<void>;
+        kill(id: string): Promise<void>;
+        onData(listener: (payload: {
+            id: string;
+            data: string;
+        }) => void): () => void;
+        onExit(listener: (payload: {
+            id: string;
+            exitCode: number | null;
+        }) => void): () => void;
+    };
+    /** Subscribe to orchestrator events; returns unsubscribe. */
+    onEvent(listener: (event: OrchestratorEvent) => void): () => void;
+    /** Subscribe to store directory changes (CLI threads appear live). */
+    onThreadsChanged(listener: () => void): () => void;
+    getRepoPath(): Promise<string>;
+    setRepoPath(path: string): Promise<string>;
+    pickRepoPath(): Promise<string | null>;
+    /** Native file picker; returns attachments ready for the composer. */
+    pickFiles(): Promise<ThreadAttachment[]>;
+    /** Prefer worktree settings; optional main-repo fallback. */
+    hasConductorHook(worktreePath: string, repoPath?: string | null): Promise<boolean>;
+    getRepoSetupInfo(worktreePath: string, repoPath?: string | null): Promise<{
+        hasConfig: boolean;
+        hasSetupScript: boolean;
+        configLabel: string | null;
+    }>;
+    runSetup(threadRef: string): Promise<{
+        exitCode: number | null;
+    }>;
+    openExternal(url: string): Promise<void>;
+    /** Main-process tsserver for real import/type diagnostics in the file UI. */
+    tsserver: {
+        start(worktreePath?: string): Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        stop(): Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        isRunning(): Promise<boolean>;
+        openFile(absPath: string, content?: string): Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        closeFile(absPath: string): Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        updateFile(absPath: string, content: string): Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        diagnostics(absPath: string): Promise<{
+            success: boolean;
+            error?: string;
+            semanticSeq?: number;
+            syntacticSeq?: number;
+        }>;
+        onMessage(listener: (message: unknown) => void): () => void;
+    };
+}
+
+interface SideboardCloudTask {
+    id: string;
+    user_id: string;
+    account_id: string;
+    device_id: string | null;
+    source_agent_id: string;
+    source_chat_id: string | null;
+    message: {
+        parts?: Array<{
+            kind?: string;
+            text?: string;
+        }>;
+    };
+    messages?: Array<{
+        role: 'cloud' | 'desktop';
+        content: unknown;
+        created_at?: string;
+    }> | null;
+    task_status: string;
+    response: unknown;
+    created_at: string;
+    updated_at: string;
+    expires_at: string | null;
+}
+type FetchLike = typeof fetch;
+type BrightsySideboardApiOptions = {
+    cfg?: BrightsyLocalConfig;
+    /**
+     * Electron main should pass `net.fetch` (Chromium stack). Node's undici
+     * `fetch` often surfaces as opaque "fetch failed" behind system proxies/VPN.
+     */
+    fetchImpl?: FetchLike;
+};
+/** Expand undici/Electron `TypeError: fetch failed` with the underlying cause. */
+declare function formatBrightsyFetchError(err: unknown, url: string): string;
+/**
+ * Minimal Brightsy HTTP client using ~/.brightsy/config.json (same session as CLI).
+ */
+declare class BrightsySideboardApi {
+    private cfg;
+    private readonly fetchImpl;
+    constructor(cfgOrOpts?: BrightsyLocalConfig | BrightsySideboardApiOptions);
+    get accountId(): string;
+    get endpoint(): string;
+    private request;
+    private refreshIfNeeded;
+    getAccess(): Promise<{
+        enabled: boolean;
+        allow_always: boolean;
+    }>;
+    setAccess(enabled: boolean, allow_always?: boolean): Promise<{
+        enabled: boolean;
+        allow_always: boolean;
+    }>;
+    getTasks(status?: string): Promise<SideboardCloudTask[]>;
+    approveTask(taskId: string): Promise<void>;
+    markRunning(taskId: string): Promise<void>;
+    submitResponse(taskId: string, response: string): Promise<void>;
+}
+declare function taskMessageText(task: SideboardCloudTask): string;
+
+/** Title / sourceRef for the singleton Brightsy cloud coordinator chat. */
+declare const CLOUD_ORCHESTRATOR_GOAL = "Cloud-connected Sideboard orchestrator";
+/**
+ * First-line token for a desktop task that force-stops the in-progress
+ * Brightsy-marked orchestration turn. Optional follow-up request may follow
+ * on later lines.
+ */
+declare const SIDEBOARD_FORCE_STOP = "SIDEBOARD_FORCE_STOP";
+/** Fixed non-AI reply when the cloud coordinator is already busy. */
+declare const CLOUD_COORDINATOR_BUSY_REPLY: string;
+/** Fixed non-AI reply when a force-stop task had no follow-up request. */
+declare const CLOUD_COORDINATOR_STOPPED_REPLY: string;
+/** Fixed non-AI reply when wait_for_turn times out. */
+declare const CLOUD_COORDINATOR_TIMEOUT_REPLY: string;
+/**
+ * Detect a force-stop directive on the first line of a desktop task message.
+ * Force-stop is true only when that line (trimmed, case-insensitive) equals
+ * {@link SIDEBOARD_FORCE_STOP}. Remainder is everything after the first line
+ * (trimmed); empty when stop-only. When forceStop is false, remainder is the original message.
+ */
+declare function parseForceStopMessage(message: string): {
+    forceStop: boolean;
+    remainder: string;
+};
+
+type CloudConnectAgent = Exclude<AgentKind, 'brightsy'>;
+interface CloudConnectOptions {
+    agent: CloudConnectAgent;
+    /** @deprecated Ignored — cloud connect uses the Global workspace coordinator. */
+    repoPath?: string;
+    /** Auto-enable Brightsy desktop access if disabled. Default true. */
+    enableAccess?: boolean;
+    /** When enabling access, set allow_always. Default true for connect daemon. */
+    allowAlways?: boolean;
+    pollIntervalMs?: number;
+    onLog?: (line: string) => void;
+    signal?: AbortSignal;
+    /** Prefer Electron `net.fetch` when running in the desktop main process. */
+    fetchImpl?: typeof fetch;
+    /** Optional pre-built API client (tests / custom auth). */
+    api?: BrightsySideboardApi;
+}
+/**
+ * Poll Brightsy desktop inbound tasks and route them to the local
+ * global orchestrator (coordinator chat + MCP across all workspaces).
+ */
+declare function runCloudConnect(opts: CloudConnectOptions): Promise<void>;
+
+declare function listConnectedBrightsyTeams(): ConnectedBrightsyTeamInfo[];
+/**
+ * Connect a team for MCP + CLI: mint/store a team token and make it the
+ * active ~/.brightsy session (Brightsy agent / CLI).
+ */
+declare function connectBrightsyTeam(accountIdOrSlug: string): Promise<ConnectedBrightsyTeamInfo[]>;
+declare function disconnectBrightsyTeam(accountIdOrSlug: string): Promise<ConnectedBrightsyTeamInfo[]>;
+/** Sanitize slug for Claude MCP server / tool name segments. */
+declare function brightsyMcpServerName(slug: string): string;
+
+/** Claude --allowedTools entries for Sideboard MCP. */
+declare const SIDEBOARD_MCP_ALLOWED_TOOLS: readonly ["mcp__sideboard", "mcp__sideboard__*"];
+/** Legacy single-server allow list (CLI ~/.brightsy fallback). */
+declare const BRIGHTSY_MCP_ALLOWED_TOOLS: readonly ["mcp__brightsy", "mcp__brightsy__*"];
+/** True when ~/.brightsy/config.json has a usable login session. */
+declare function isBrightsyConnected(): boolean;
+/** Allow-tool patterns for one or more Brightsy MCP server names. */
+declare function brightsyMcpAllowedTools(serverNames: string[]): string[];
+/**
+ * Write a temp Claude `--mcp-config` JSON for injected Sideboard / Brightsy MCP.
+ * Returns null when there is nothing to inject.
+ */
+declare function writeInjectedMcpConfig(opts: {
+    includeSideboard?: boolean;
+    includeBrightsy?: boolean;
+}): Promise<string | null>;
+
+export { type ActiveRun, type AdoptInput, type AdvancedAppSettings, type AgentAdapter, type AgentEvent, type AgentInstructionFile, type AgentKind, type AgentStatus, type AgentTurnInput, type AnthropicCacheControl, type AppSettings, type ApplyIntoMainResult, type AttachCommand, type Autonomy, BRIGHTSY_MCP_ALLOWED_TOOLS, type BranchInfo, type BrightsyAccount, type BrightsyChatTarget, type BrightsyChatTargets, type BrightsyCloudConnectAgent, type BrightsyHarnessSettings, type BrightsySession, BrightsySideboardApi, type BrightsyTeamTargets, 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, type ClaudeHarnessSettings, type CleanupOrphansResult, type CloudConnectAgent, type CloudConnectOptions, type CloudConnectStatus, type CompactResult, type CompactThresholds, type ConductorSettings, type ConductorWorkspace, type ConnectedBrightsyTeamInfo, type CreateChatTabInput, type CreateGlobalChatOpts, type CreateThreadInput, type CreateWorktreeResult, type CursorSdkStreamMessage, type CursorTurnRequest, type CursorWorktreesConfig, type DevServerHandle, type DiffCommit, type DiffFile, type DiffResult, type DiffScope, type DiffScopeStat, type ExpandResult, FAMOUS_SOCCER_TEAMS, type ForkChatTabInput, type ForkThreadWorktreeInput, GLOBAL_WORKSPACE_ID, type GetDiffOptions, type GitHubStatus, type GitWorktreeStatus, HARNESS_ENV_KEYS, type HarnessId, type IntegrationsSettings, type IpcApi, type IssueInfo, type IssueSource, type LandPreview, type LandResult, type ListIssuesResult, MAX_ANTHROPIC_CACHE_CONTROL_BLOCKS, type McpServerStatus, type MessagePart, Orchestrator, type OrchestratorEvent, type OrchestratorRuntime, type OrphanWorktree, PLAN_MODE_INSTRUCTION, type PrActor, type PrCheckRun, type PrCommentInfo, type PrCommitInfo, type PrDetails, type PrInfo, type PrReviewInfo, type RepoSettings, type RepoSetupInfo, type RunMode, type RunScript, SIDEBOARD_FORCE_STOP, SIDEBOARD_MCP_ALLOWED_TOOLS, type ScriptHandle, type SkillInfo, type SourceType, type SpawnTurnHandle, type SummarizeResult, type TeamName, type Thread, type ThreadAttachment, type ThreadMessage, type ThreadOptionsPatch, type ThreadStatus, type TokenUsage, type TranscriptToolDetail, type TurnCommand, type Workspace, type WorkspaceInventoryEntry, type WorkspaceScriptEnvOpts, 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 };