@sideboard-ai/core 0.1.45 → 0.1.49

package/dist/chunk-GZXBYHJC.js

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

package/dist/chunk-HBJSHRY2.js

@@ -0,0 +1,494 @@
+#!/usr/bin/env node
+
+import {
+  normalizeThinkingEffort
+} from "./chunk-KGZBYWZ3.js";
+import {
+  appDataDir
+} from "./chunk-7MV3RXSC.js";
+
+// src/store/app-settings.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var HARNESS_ENV_KEYS = {
+  claude: "ANTHROPIC_API_KEY",
+  codex: "CODEX_API_KEY",
+  cursor: "CURSOR_API_KEY",
+  opencode: null,
+  brightsy: null
+};
+var DEFAULT_AGENTS = /* @__PURE__ */ new Set([
+  "claude",
+  "codex",
+  "opencode",
+  "brightsy",
+  "cursor"
+]);
+function appSettingsPath() {
+  return join(appDataDir(), "settings.json");
+}
+function claudeUserSettingsPath() {
+  return join(homedir(), ".claude", "settings.json");
+}
+function normalizeClaude(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const source = raw;
+  const out = {};
+  if (typeof source.executablePath === "string") {
+    const path = source.executablePath.trim();
+    if (path) out.executablePath = path;
+  }
+  if (typeof source.chromeEnabled === "boolean") {
+    out.chromeEnabled = source.chromeEnabled;
+  }
+  return out;
+}
+var CLOUD_CONNECT_AGENTS = /* @__PURE__ */ new Set([
+  "claude",
+  "codex",
+  "opencode",
+  "cursor"
+]);
+function normalizeBrightsy(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const source = raw;
+  const out = {};
+  if (typeof source.cloudConnectEnabled === "boolean") {
+    out.cloudConnectEnabled = source.cloudConnectEnabled;
+  }
+  if (typeof source.cloudConnectAgent === "string" && CLOUD_CONNECT_AGENTS.has(source.cloudConnectAgent)) {
+    out.cloudConnectAgent = source.cloudConnectAgent;
+  }
+  return out;
+}
+var ISSUE_SOURCES = /* @__PURE__ */ new Set(["linear", "github"]);
+function normalizeIntegrations(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const source = raw;
+  const out = {};
+  if (typeof source.linearApiKey === "string") {
+    const key = source.linearApiKey.trim();
+    if (key) out.linearApiKey = key;
+  }
+  if (typeof source.issueSource === "string" && ISSUE_SOURCES.has(source.issueSource)) {
+    out.issueSource = source.issueSource;
+  }
+  return out;
+}
+function normalizeDefaults(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const source = raw;
+  const out = {};
+  if (typeof source.agent === "string" && DEFAULT_AGENTS.has(source.agent)) {
+    out.agent = source.agent;
+  }
+  if (typeof source.model === "string") {
+    const model = source.model.trim();
+    if (model) out.model = model;
+  }
+  if (normalizeThinkingEffort(source.effort)) {
+    out.effort = normalizeThinkingEffort(source.effort);
+  }
+  if (typeof source.fast === "boolean") {
+    out.fast = source.fast;
+  }
+  return out;
+}
+function normalizeAdvanced(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const source = raw;
+  const out = {};
+  if (typeof source.autoRenameBranch === "boolean") {
+    out.autoRenameBranch = source.autoRenameBranch;
+  }
+  if (typeof source.autoRunAfterSetup === "boolean") {
+    out.autoRunAfterSetup = source.autoRunAfterSetup;
+  }
+  if (typeof source.caffeinateWhileRunning === "boolean") {
+    out.caffeinateWhileRunning = source.caffeinateWhileRunning;
+  }
+  if (typeof source.caffeinateWhileCloudConnect === "boolean") {
+    out.caffeinateWhileCloudConnect = source.caffeinateWhileCloudConnect;
+  }
+  if (typeof source.deleteBranchOnPurge === "boolean") {
+    out.deleteBranchOnPurge = source.deleteBranchOnPurge;
+  }
+  if (typeof source.maxConcurrent === "number" && Number.isFinite(source.maxConcurrent)) {
+    out.maxConcurrent = Math.max(1, Math.min(32, Math.floor(source.maxConcurrent)));
+  }
+  if (typeof source.worktreeMaxCount === "number" && Number.isFinite(source.worktreeMaxCount)) {
+    out.worktreeMaxCount = Math.max(1, Math.min(500, Math.floor(source.worktreeMaxCount)));
+  }
+  if (typeof source.worktreeCleanupIntervalHours === "number" && Number.isFinite(source.worktreeCleanupIntervalHours)) {
+    out.worktreeCleanupIntervalHours = Math.max(
+      1,
+      Math.min(168, Math.floor(source.worktreeCleanupIntervalHours))
+    );
+  }
+  if (typeof source.worktreeLastCleanupAt === "string" && source.worktreeLastCleanupAt.trim()) {
+    out.worktreeLastCleanupAt = source.worktreeLastCleanupAt.trim();
+  }
+  if (typeof source.autoCleanupOrphans === "boolean") {
+    out.autoCleanupOrphans = source.autoCleanupOrphans;
+  }
+  if (source.orchestrationQuotaOnLimit === "switch_agent" || source.orchestrationQuotaOnLimit === "wait_reset") {
+    out.orchestrationQuotaOnLimit = source.orchestrationQuotaOnLimit;
+  }
+  if (typeof source.orchestrationQuotaFallbackAgent === "string" && DEFAULT_AGENTS.has(source.orchestrationQuotaFallbackAgent) && source.orchestrationQuotaFallbackAgent !== "brightsy") {
+    out.orchestrationQuotaFallbackAgent = source.orchestrationQuotaFallbackAgent;
+  }
+  return out;
+}
+function normalizeSettings(raw) {
+  const env = {};
+  let claude = {};
+  let brightsy = {};
+  let integrations = {};
+  let defaults = {};
+  let advanced = {};
+  if (raw && typeof raw === "object") {
+    if ("environment" in raw) {
+      const source = raw.environment;
+      if (source && typeof source === "object") {
+        for (const [k, v] of Object.entries(source)) {
+          const key = k.trim();
+          if (!key) continue;
+          if (typeof v === "string" && v.length > 0) env[key] = v;
+        }
+      }
+    }
+    if ("claude" in raw) {
+      claude = normalizeClaude(raw.claude);
+    }
+    if ("brightsy" in raw) {
+      brightsy = normalizeBrightsy(raw.brightsy);
+    }
+    if ("integrations" in raw) {
+      integrations = normalizeIntegrations(
+        raw.integrations
+      );
+    }
+    if ("defaults" in raw) {
+      defaults = normalizeDefaults(raw.defaults);
+    }
+    if ("advanced" in raw) {
+      advanced = normalizeAdvanced(raw.advanced);
+    }
+  }
+  return { environment: env, claude, brightsy, integrations, defaults, advanced };
+}
+var EMPTY_SETTINGS = {
+  environment: {},
+  claude: {},
+  brightsy: {},
+  integrations: {},
+  defaults: {},
+  advanced: {}
+};
+function loadAppSettings() {
+  const path = appSettingsPath();
+  if (!existsSync(path)) {
+    return { ...EMPTY_SETTINGS };
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return normalizeSettings(parsed);
+  } catch {
+    return { ...EMPTY_SETTINGS };
+  }
+}
+function saveAppSettings(settings) {
+  const normalized = normalizeSettings(settings);
+  mkdirSync(appDataDir(), { recursive: true });
+  writeFileSync(appSettingsPath(), `${JSON.stringify(normalized, null, 2)}
+`, "utf8");
+  return normalized;
+}
+function updateAppEnvironment(patch) {
+  const current = loadAppSettings();
+  const environment = { ...current.environment };
+  for (const [key, value] of Object.entries(patch)) {
+    const k = key.trim();
+    if (!k) continue;
+    if (value == null || value === "") {
+      delete environment[k];
+    } else {
+      environment[k] = value;
+    }
+  }
+  return saveAppSettings({ ...current, environment });
+}
+function updateClaudeSettings(patch) {
+  const current = loadAppSettings();
+  const claude = { ...current.claude };
+  if ("executablePath" in patch) {
+    if (patch.executablePath == null || patch.executablePath.trim() === "") {
+      delete claude.executablePath;
+    } else {
+      claude.executablePath = patch.executablePath.trim();
+    }
+  }
+  if (typeof patch.chromeEnabled === "boolean") {
+    claude.chromeEnabled = patch.chromeEnabled;
+  }
+  return saveAppSettings({ ...current, claude });
+}
+function updateBrightsySettings(patch) {
+  const current = loadAppSettings();
+  const brightsy = { ...current.brightsy };
+  if (typeof patch.cloudConnectEnabled === "boolean") {
+    brightsy.cloudConnectEnabled = patch.cloudConnectEnabled;
+  }
+  if ("cloudConnectAgent" in patch) {
+    if (patch.cloudConnectAgent == null) {
+      delete brightsy.cloudConnectAgent;
+    } else if (CLOUD_CONNECT_AGENTS.has(patch.cloudConnectAgent)) {
+      brightsy.cloudConnectAgent = patch.cloudConnectAgent;
+    }
+  }
+  return saveAppSettings({ ...current, brightsy });
+}
+function updateIntegrationsSettings(patch) {
+  const current = loadAppSettings();
+  const integrations = { ...current.integrations };
+  if ("linearApiKey" in patch) {
+    if (patch.linearApiKey == null || patch.linearApiKey.trim() === "") {
+      delete integrations.linearApiKey;
+    } else {
+      integrations.linearApiKey = patch.linearApiKey.trim();
+    }
+  }
+  if ("issueSource" in patch) {
+    if (patch.issueSource == null) {
+      delete integrations.issueSource;
+    } else if (ISSUE_SOURCES.has(patch.issueSource)) {
+      integrations.issueSource = patch.issueSource;
+    }
+  }
+  return saveAppSettings({ ...current, integrations });
+}
+function updateDefaultsSettings(patch) {
+  const current = loadAppSettings();
+  const defaults = { ...current.defaults };
+  if ("agent" in patch) {
+    if (patch.agent == null) {
+      delete defaults.agent;
+    } else if (DEFAULT_AGENTS.has(patch.agent)) {
+      defaults.agent = patch.agent;
+    }
+  }
+  if ("model" in patch) {
+    if (patch.model == null || patch.model.trim() === "") {
+      delete defaults.model;
+    } else {
+      defaults.model = patch.model.trim();
+    }
+  }
+  if ("effort" in patch) {
+    if (patch.effort == null) {
+      delete defaults.effort;
+    } else {
+      const effort = normalizeThinkingEffort(patch.effort);
+      if (effort) defaults.effort = effort;
+    }
+  }
+  if ("fast" in patch) {
+    if (patch.fast == null) {
+      delete defaults.fast;
+    } else {
+      defaults.fast = Boolean(patch.fast);
+    }
+  }
+  return saveAppSettings({ ...current, defaults });
+}
+function getDefaultAgent(settings = loadAppSettings()) {
+  return settings.defaults.agent ?? "claude";
+}
+function getDefaultModel(settings = loadAppSettings()) {
+  const model = settings.defaults.model?.trim();
+  return model || null;
+}
+function getDefaultEffort(settings = loadAppSettings()) {
+  return normalizeThinkingEffort(settings.defaults.effort) ?? "high";
+}
+function getDefaultFast(settings = loadAppSettings()) {
+  return settings.defaults.fast === true;
+}
+function resolveThreadDefaults(settings = loadAppSettings()) {
+  return {
+    agent: getDefaultAgent(settings),
+    model: getDefaultModel(settings),
+    effort: getDefaultEffort(settings),
+    fast: getDefaultFast(settings)
+  };
+}
+function isLinearConnected(settings = loadAppSettings()) {
+  return Boolean(settings.integrations.linearApiKey?.trim());
+}
+function getIssueSource(settings = loadAppSettings()) {
+  return settings.integrations.issueSource ?? "github";
+}
+function resolveEffectiveIssueSource(settings = loadAppSettings()) {
+  const preferred = getIssueSource(settings);
+  if (preferred === "linear" && !isLinearConnected(settings)) return "github";
+  return preferred;
+}
+function getLinearApiKey(settings = loadAppSettings()) {
+  const key = settings.integrations.linearApiKey?.trim();
+  return key || null;
+}
+function brightsyCloudConnectEnabled(settings = loadAppSettings()) {
+  return Boolean(settings.brightsy.cloudConnectEnabled);
+}
+function brightsyCloudConnectAgent(settings = loadAppSettings()) {
+  return settings.brightsy.cloudConnectAgent ?? "claude";
+}
+function updateAdvancedSettings(patch) {
+  const current = loadAppSettings();
+  const advanced = { ...current.advanced };
+  if (typeof patch.autoRenameBranch === "boolean") {
+    advanced.autoRenameBranch = patch.autoRenameBranch;
+  }
+  if (typeof patch.autoRunAfterSetup === "boolean") {
+    advanced.autoRunAfterSetup = patch.autoRunAfterSetup;
+  }
+  if (typeof patch.caffeinateWhileRunning === "boolean") {
+    advanced.caffeinateWhileRunning = patch.caffeinateWhileRunning;
+  }
+  if (typeof patch.caffeinateWhileCloudConnect === "boolean") {
+    advanced.caffeinateWhileCloudConnect = patch.caffeinateWhileCloudConnect;
+  }
+  if (typeof patch.deleteBranchOnPurge === "boolean") {
+    advanced.deleteBranchOnPurge = patch.deleteBranchOnPurge;
+  }
+  if (typeof patch.maxConcurrent === "number" && Number.isFinite(patch.maxConcurrent)) {
+    advanced.maxConcurrent = Math.max(1, Math.min(32, Math.floor(patch.maxConcurrent)));
+  }
+  if (typeof patch.worktreeMaxCount === "number" && Number.isFinite(patch.worktreeMaxCount)) {
+    advanced.worktreeMaxCount = Math.max(1, Math.min(500, Math.floor(patch.worktreeMaxCount)));
+  }
+  if (typeof patch.worktreeCleanupIntervalHours === "number" && Number.isFinite(patch.worktreeCleanupIntervalHours)) {
+    advanced.worktreeCleanupIntervalHours = Math.max(
+      1,
+      Math.min(168, Math.floor(patch.worktreeCleanupIntervalHours))
+    );
+  }
+  if (typeof patch.worktreeLastCleanupAt === "string") {
+    advanced.worktreeLastCleanupAt = patch.worktreeLastCleanupAt;
+  }
+  if (typeof patch.autoCleanupOrphans === "boolean") {
+    advanced.autoCleanupOrphans = patch.autoCleanupOrphans;
+  }
+  if (patch.orchestrationQuotaOnLimit === "switch_agent" || patch.orchestrationQuotaOnLimit === "wait_reset") {
+    advanced.orchestrationQuotaOnLimit = patch.orchestrationQuotaOnLimit;
+  }
+  if (typeof patch.orchestrationQuotaFallbackAgent === "string" && DEFAULT_AGENTS.has(patch.orchestrationQuotaFallbackAgent) && patch.orchestrationQuotaFallbackAgent !== "brightsy") {
+    advanced.orchestrationQuotaFallbackAgent = patch.orchestrationQuotaFallbackAgent;
+  }
+  return saveAppSettings({ ...current, advanced });
+}
+function autoRenameBranchEnabled(settings = loadAppSettings()) {
+  return settings.advanced.autoRenameBranch !== false;
+}
+function autoRunAfterSetupEnabled(settings = loadAppSettings()) {
+  return Boolean(settings.advanced.autoRunAfterSetup);
+}
+function caffeinateWhileRunningEnabled(settings = loadAppSettings()) {
+  return Boolean(settings.advanced.caffeinateWhileRunning);
+}
+function caffeinateWhileCloudConnectEnabled(settings = loadAppSettings()) {
+  return Boolean(settings.advanced.caffeinateWhileCloudConnect);
+}
+function deleteBranchOnPurgeEnabled(settings = loadAppSettings()) {
+  return Boolean(settings.advanced.deleteBranchOnPurge);
+}
+function autoCleanupOrphansEnabled(settings = loadAppSettings()) {
+  return Boolean(settings.advanced.autoCleanupOrphans);
+}
+function orchestrationQuotaOnLimit(settings = loadAppSettings()) {
+  return settings.advanced.orchestrationQuotaOnLimit ?? "switch_agent";
+}
+function orchestrationQuotaFallbackAgent(settings = loadAppSettings()) {
+  const preferred = settings.advanced.orchestrationQuotaFallbackAgent;
+  if (preferred && DEFAULT_AGENTS.has(preferred) && preferred !== "brightsy") {
+    return preferred;
+  }
+  return "cursor";
+}
+function maxConcurrentAgents(settings = loadAppSettings()) {
+  const n = settings.advanced.maxConcurrent;
+  if (typeof n === "number" && Number.isFinite(n)) {
+    return Math.max(1, Math.min(32, Math.floor(n)));
+  }
+  return 3;
+}
+function resolveClaudeExecutable(settings = loadAppSettings()) {
+  const override = settings.claude.executablePath?.trim();
+  return override || "claude";
+}
+function claudeChromeEnabled(settings = loadAppSettings()) {
+  return Boolean(settings.claude.chromeEnabled);
+}
+function applyAppEnvironment(target = process.env, settings = loadAppSettings()) {
+  for (const [key, value] of Object.entries(settings.environment)) {
+    if (!key || value == null || value === "") continue;
+    if (target[key] == null || target[key] === "") {
+      target[key] = value;
+    }
+  }
+  return target;
+}
+function childEnvWithAppSettings(extra) {
+  const settings = loadAppSettings();
+  const env = { ...process.env };
+  applyAppEnvironment(env, settings);
+  if (extra) {
+    for (const [k, v] of Object.entries(extra)) {
+      if (v != null) env[k] = v;
+    }
+  }
+  return env;
+}
+function harnessEnvKey(harness) {
+  return HARNESS_ENV_KEYS[harness];
+}
+
+export {
+  HARNESS_ENV_KEYS,
+  appSettingsPath,
+  claudeUserSettingsPath,
+  loadAppSettings,
+  saveAppSettings,
+  updateAppEnvironment,
+  updateClaudeSettings,
+  updateBrightsySettings,
+  updateIntegrationsSettings,
+  updateDefaultsSettings,
+  getDefaultAgent,
+  getDefaultModel,
+  getDefaultEffort,
+  getDefaultFast,
+  resolveThreadDefaults,
+  isLinearConnected,
+  getIssueSource,
+  resolveEffectiveIssueSource,
+  getLinearApiKey,
+  brightsyCloudConnectEnabled,
+  brightsyCloudConnectAgent,
+  updateAdvancedSettings,
+  autoRenameBranchEnabled,
+  autoRunAfterSetupEnabled,
+  caffeinateWhileRunningEnabled,
+  caffeinateWhileCloudConnectEnabled,
+  deleteBranchOnPurgeEnabled,
+  autoCleanupOrphansEnabled,
+  orchestrationQuotaOnLimit,
+  orchestrationQuotaFallbackAgent,
+  maxConcurrentAgents,
+  resolveClaudeExecutable,
+  claudeChromeEnabled,
+  applyAppEnvironment,
+  childEnvWithAppSettings,
+  harnessEnvKey
+};