@sideboard-ai/core 0.1.286 → 0.1.288

package/dist/mcp/run-stdio.cjs

@@ -1069,7 +1069,7 @@ function humanizeAgentFailDetail(detail) {
     return "Cursor local file search failed (ripgrep / resource_exhausted). Wait a minute and retry; if it keeps happening, check Cursor usage.";
   }
   if (looksLikeCodexMcpError(raw)) {
-    return `${raw} \u2014 skip that vendor MCP and continue (PostHog: Settings \u2192 Connectors + HTTP API).`;
+    return `${raw} \u2014 skip that vendor MCP and continue (PostHog: Settings \u2192 Connectors and posthog_api).`;
   }
   if (/invalid user api key|invalid api key|not logged in|not authenticated|unauthorized|authentication|please run.*login|codex login|claude auth|cursor api/.test(
     lower
@@ -2313,6 +2313,27 @@ function npmGlobalNodeModules(env = process.env) {
   const dir = process.platform === "win32" ? (0, import_node_path9.join)(prefix, "node_modules") : (0, import_node_path9.join)(prefix, "lib", "node_modules");
   return (0, import_node_fs8.existsSync)(dir) ? dir : null;
 }
+function posixShellSingleQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function resolveCommandBinarySync(command, whichPath) {
+  const trimmed = command.trim();
+  if (!trimmed) return trimmed;
+  const match = /^(\S+)(\s[\s\S]*)?$/.exec(trimmed);
+  if (!match) return trimmed;
+  const bin = match[1];
+  const rest = match[2] ?? "";
+  if (bin.includes("/") || bin.includes("\\")) return trimmed;
+  const abs = whichPath?.trim().split(/\r?\n/).find(Boolean);
+  if (!abs) return trimmed;
+  return `${abs}${rest}`;
+}
+function withExportedPath(command, pathValue) {
+  const trimmed = command.trim();
+  if (!trimmed) return trimmed;
+  if (/^(export\s+PATH=|PATH=)/.test(trimmed)) return trimmed;
+  return `export PATH=${posixShellSingleQuote(pathValue)} && ${trimmed}`;
+}
 var import_node_fs8, import_node_child_process2, import_node_os3, import_node_path9, EXTRA_BIN_DIRS;
 var init_path = __esm({
   "src/agents/path.ts"() {
@@ -6145,22 +6166,21 @@ function applyAppEnvironment(target = process.env, settings = loadAppSettings())
   applyOptionalServiceTokens(target, settings.integrations);
   return target;
 }
-function fillEnvGap(target, key, value) {
+function assignEnv(target, key, value) {
   const v = value?.trim();
   if (!key || !v) return;
-  if (target[key] == null || target[key] === "") target[key] = v;
+  target[key] = v;
+}
+function scrubPosthogAgentEnv(target) {
+  delete target.POSTHOG_PERSONAL_API_KEY;
+  delete target.POSTHOG_HOST;
 }
 function applyOptionalServiceTokens(target, integrations) {
-  fillEnvGap(target, "VERCEL_TOKEN", integrations.vercelToken);
-  fillEnvGap(target, "SUPABASE_ACCESS_TOKEN", integrations.supabaseAccessToken);
-  fillEnvGap(target, "POSTHOG_PERSONAL_API_KEY", integrations.posthogPersonalApiKey);
-  fillEnvGap(
-    target,
-    "POSTHOG_HOST",
-    integrations.posthogPersonalApiKey ? integrations.posthogHost || "https://us.posthog.com" : void 0
-  );
-  fillEnvGap(target, "SENTRY_AUTH_TOKEN", integrations.sentryAuthToken);
-  fillEnvGap(
+  assignEnv(target, "VERCEL_TOKEN", integrations.vercelToken);
+  assignEnv(target, "SUPABASE_ACCESS_TOKEN", integrations.supabaseAccessToken);
+  scrubPosthogAgentEnv(target);
+  assignEnv(target, "SENTRY_AUTH_TOKEN", integrations.sentryAuthToken);
+  assignEnv(
     target,
     "SENTRY_URL",
     integrations.sentryAuthToken ? integrations.sentryHost || "https://sentry.io" : void 0
@@ -6175,6 +6195,7 @@ function childEnvWithAppSettings(extra) {
       if (v != null) env[k] = v;
     }
   }
+  scrubPosthogAgentEnv(env);
   return env;
 }
 function harnessEnvKey(harness) {
@@ -9515,7 +9536,7 @@ function isRemovedWorkspace(repoPath) {
 }
 function archivesWithRemovedWorkspace(threadRepoPath, removedPath) {
   if (!threadRepoPath || isGlobalRepoPath(threadRepoPath)) return false;
-  return isRemovedWorkspace(threadRepoPath) || sameWorkspacePath(threadRepoPath, removedPath);
+  return removedMatches(removedPath, threadRepoPath);
 }
 function rememberRemoved(repoPath) {
   const next = readRemoved();
@@ -9896,7 +9917,7 @@ var init_coordinator_prompt = __esm({
       "- linear_* (when Linear is connected) \u2014 list_teams for team key/states; linear_list_projects for project names; get/search include the project a ticket is on; get/create/update/comment with ENG-123. Worktree agents have the same Account tools \u2014 prefer they comment, update status, and create spin-offs (parent=) on their own ticket when they were asked to do the work. When reviewing a PR or ticket, do not comment or update until the user types a next step \u2014 they should work through the feedback in chat first. Do not tell the child to ask_user after the review. Scope errors: reconnect Linear in Account settings. Prefer these over any Linear MCP the CLI may still list.",
       "- github_* \u2014 get/comment/update/create GitHub issues via Account `gh` (#123). github_list_projects and get/search include GitHub Projects. projectsError or a missing read:project scope \u2192 `gh auth refresh -s read:project`. Worktree agents have these too. Prefer over any vendor GitHub MCP. Pass parent= for spin-offs. When reviewing a PR or ticket, do not comment, submit `gh pr review`, or update the PR/ticket until the user types a next step.",
       "- abletime_* (when AbleTime is connected) \u2014 orientation first; abletime_list_projects lists projects; get/list include the project a task is on; get/comment/update/create (parent= for spin-offs); ensure_task when work has no ticket (or create_workspace from the default branch auto-creates one). Worktree agents have the same Account tools. Same review-write gate as Linear/GitHub.",
-      "- Optional connectors (Vercel, Supabase, PostHog, Sentry) in Settings \u2192 Connectors inject tokens into worktree agent env when connected. Prefer official CLIs (`vercel`, `supabase`, `sentry-cli`) with those env vars. PostHog has no first-class CLI \u2014 use the HTTP API (`POSTHOG_PERSONAL_API_KEY`). If a connector MCP is listed but needsAuth or unauthorized, do not sign in \u2014 check that native CLI or HTTP API. Tell any worktree agent (Claude / Cursor / Codex / OpenCode) to write CLI output to `.context/cli/` (not `.context/attachments/`) and read a slice \u2014 never stream raw `--json` / `--expand` into a tool result (that crashes the turn). They can `stop_job` if a detached fetch hangs. If a CLI is missing, the user can Install CLI on that row (not auto-installed on Connect). Do not add vendor MCPs or ask the user to paste tokens again. Git (`gh`) stays Settings \u2192 Git; issue tracking stays Settings \u2192 Issues. The phone remote is Settings \u2192 Remote \u2014 do not look up Slack users.",
+      "- Optional connectors (Vercel, Supabase, Sentry) in Settings \u2192 Connectors inject tokens into worktree agent env when connected. Prefer official CLIs (`vercel`, `supabase`, `sentry-cli`). PostHog is the Sideboard tool `posthog_api` (GET by default; POST `/api/projects/:id/query/` or `/api/environments/:id/query/` is a read and does not need write=true; other POST and PATCH need write=true only when the user asked to change data). The PostHog key stays in the vault \u2014 do not read it from the environment. If a connector MCP needsAuth or is unauthorized, do not sign in \u2014 use the native CLI or `posthog_api`. Tell any worktree agent (Claude / Cursor / Codex / OpenCode) to write CLI output to `.context/cli/` and read a slice. If a CLI is missing, the user presses Install CLI on that row. Do not add vendor MCPs. Git (`gh`) stays Settings \u2192 Git; issue tracking stays Settings \u2192 Issues. The phone remote is Settings \u2192 Remote \u2014 do not look up Slack users.",
       "- get_pr_stack / open_pr_stack_layers / add_stack_layer / create_pr_stack \u2014 GitHub stacked PRs (`gh stack`); one worktree per layer",
       "- list_models \u2014 only when you need a specific model (rare); otherwise omit model so Account defaults apply",
       "- list_chats / get_chat \u2014 live thread list (parent id + last message preview). get_chat on this orchestration chat lists child worktree agents (status + lastText). blockedReason is why that agent is waiting on a person. Also includes usage / lastTurnUsage.",
@@ -11802,7 +11823,8 @@ var init_injected_mcp = __esm({
       "mcp__sideboard__create_schedule",
       "mcp__sideboard__update_schedule",
       "mcp__sideboard__delete_schedule",
-      "mcp__sideboard__run_schedule"
+      "mcp__sideboard__run_schedule",
+      "mcp__sideboard__posthog_api"
     ];
     SIDEBOARD_GITHUB_MCP_ALLOWED_TOOLS = ["mcp__sideboard__github_*"];
     SIDEBOARD_LINEAR_MCP_ALLOWED_TOOLS = ["mcp__sideboard__linear_*"];
@@ -14468,6 +14490,107 @@ var init_claude_usage_client = __esm({
 });
 
 // src/agents/install.ts
+async function prepareTerminalCommand(command) {
+  enrichPathWithNpmGlobalBin();
+  const trimmed = command.trim();
+  if (!trimmed) return trimmed;
+  if (/^(export\s+PATH=|PATH=)/.test(trimmed)) return trimmed;
+  const match = /^(\S+)(\s[\s\S]*)?$/.exec(trimmed);
+  const bin = match?.[1];
+  let whichPath = null;
+  if (bin && !bin.includes("/") && !bin.includes("\\")) {
+    const which = await run("which", [bin], { reject: false, timeoutMs: 3e3 });
+    whichPath = which.exitCode === 0 ? which.stdout.trim() : null;
+  }
+  const resolved = resolveCommandBinarySync(trimmed, whichPath);
+  return withExportedPath(resolved, process.env.PATH ?? "");
+}
+async function openInSystemTerminal(command) {
+  const trimmed = (await prepareTerminalCommand(command)).trim();
+  if (!trimmed) throw new Error("Command is empty");
+  if (process.platform === "darwin") {
+    const escaped = trimmed.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    const script = `tell application "Terminal" to do script "${escaped}"`;
+    const result = await run("osascript", ["-e", script], { reject: false });
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr.trim() || result.stdout.trim() || "Failed to open Terminal");
+    }
+    await run("osascript", ["-e", 'tell application "Terminal" to activate'], {
+      reject: false
+    });
+    return;
+  }
+  if (process.platform === "win32") {
+    const result = await run(
+      "cmd.exe",
+      ["/c", "start", "cmd.exe", "/k", trimmed],
+      { reject: false }
+    );
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr.trim() || result.stdout.trim() || "Failed to open cmd");
+    }
+    return;
+  }
+  const candidates = [
+    { file: "gnome-terminal", args: ["--", "bash", "-lc", `${trimmed}; exec bash`] },
+    { file: "x-terminal-emulator", args: ["-e", "bash", "-lc", `${trimmed}; exec bash`] },
+    { file: "konsole", args: ["-e", "bash", "-lc", `${trimmed}; exec bash`] },
+    { file: "xterm", args: ["-e", "bash", "-lc", `${trimmed}; exec bash`] }
+  ];
+  for (const c of candidates) {
+    const which = await run("which", [c.file], { reject: false });
+    if (which.exitCode !== 0 || !which.stdout.trim()) continue;
+    const result = await run(c.file, c.args, { reject: false });
+    if (result.exitCode === 0) return;
+  }
+  throw new Error(
+    `No terminal found to run: ${trimmed}. Install gnome-terminal (or similar), or run the command manually.`
+  );
+}
+async function whichOnPath(bin) {
+  const which = await run("which", [bin], { reject: false, timeoutMs: 3e3 });
+  if (which.exitCode !== 0) return null;
+  return which.stdout.trim().split(/\r?\n/).find(Boolean) ?? null;
+}
+async function installNpmGlobalPackage(opts) {
+  enrichPathWithNpmGlobalBin();
+  const result = await run("npm", ["install", "-g", opts.npmPackage], { reject: false });
+  const ok = result.exitCode === 0;
+  if (!ok) {
+    try {
+      await openInSystemTerminal(opts.installCommand);
+      return {
+        ok: false,
+        openedTerminal: true,
+        command: opts.installCommand,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        message: `npm install failed (exit ${result.exitCode}). Opened Terminal with: ${opts.installCommand}`
+      };
+    } catch {
+      return {
+        ok: false,
+        command: opts.installCommand,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        message: result.stderr.trim() || result.stdout.trim() || `npm install failed (exit ${result.exitCode})`
+      };
+    }
+  }
+  enrichPathWithNpmGlobalBin();
+  const binPath = opts.cliBin ? await whichOnPath(opts.cliBin) : null;
+  return {
+    ok: true,
+    command: opts.installCommand,
+    exitCode: 0,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    // Library-only packages (`@cursor/sdk`) have no CLI to look for.
+    message: !opts.cliBin ? `Installed ${opts.npmPackage}` : binPath ? `Installed ${opts.npmPackage} \u2192 ${binPath}` : `Installed ${opts.npmPackage} (CLI not yet on PATH)`
+  };
+}
 var import_node_fs41;
 var init_install = __esm({
   "src/agents/install.ts"() {
@@ -22487,13 +22610,13 @@ function formatStat(files) {
   return `${n} file${n === 1 ? "" : "s"} changed, ${additions} insertions(+), ${deletions} deletions(-)`;
 }
 function emptyScopeStats() {
-  const z10 = emptyStat();
+  const z11 = emptyStat();
   return {
-    commits: z10,
-    uncommitted: z10,
-    staged: z10,
-    unstaged: z10,
-    last_turn: z10
+    commits: z11,
+    uncommitted: z11,
+    staged: z11,
+    unstaged: z11,
+    last_turn: z11
   };
 }
 function filesFromDiff(nameStatus, numstat, combinedDiff, maxHunk) {
@@ -23994,7 +24117,111 @@ var init_instructions = __esm({
   }
 });
 
+// src/integrations/optional-cli.ts
+var optional_cli_exports = {};
+__export(optional_cli_exports, {
+  clearOptionalCliPresenceCache: () => clearOptionalCliPresenceCache,
+  detectOptionalServiceClis: () => detectOptionalServiceClis,
+  installOptionalServiceCli: () => installOptionalServiceCli,
+  optionalCliPresence: () => optionalCliPresence
+});
+async function detectOptionalServiceClis() {
+  enrichPathWithNpmGlobalBin();
+  return Promise.all(
+    OPTIONAL_SERVICES.map(async (spec) => {
+      if (!spec.cli) {
+        return { id: spec.id, cli: null, installed: false, path: null };
+      }
+      const path = await whichOnPath(spec.cli);
+      return {
+        id: spec.id,
+        cli: spec.cli,
+        installed: Boolean(path),
+        path
+      };
+    })
+  );
+}
+function clearOptionalCliPresenceCache() {
+  cliPresenceCache.clear();
+}
+async function optionalCliPresence(ids) {
+  const presence = {};
+  const now = Date.now();
+  await Promise.all(
+    ids.map(async (id) => {
+      const spec = optionalServiceSpec(id);
+      if (!spec.cli) return;
+      const hit = cliPresenceCache.get(id);
+      if (hit && now - hit.at < CLI_PRESENCE_TTL_MS) {
+        presence[id] = hit.installed;
+        return;
+      }
+      const path = await whichOnPath(spec.cli);
+      const installed = Boolean(path);
+      cliPresenceCache.set(id, { at: now, installed });
+      presence[id] = installed;
+    })
+  );
+  return presence;
+}
+async function installOptionalServiceCli(id) {
+  if (!isOptionalServiceId(id)) {
+    return { ok: false, message: "Unknown optional service" };
+  }
+  const spec = optionalServiceSpec(id);
+  if (!spec.cli || !spec.npmPackage) {
+    return {
+      ok: false,
+      message: `${spec.label} has no CLI to install. Agents call posthog_api.`
+    };
+  }
+  enrichPathWithNpmGlobalBin();
+  const existing = await whichOnPath(spec.cli);
+  if (existing) {
+    return {
+      ok: true,
+      command: existing,
+      message: `Already on PATH: ${existing}`
+    };
+  }
+  return installNpmGlobalPackage({
+    npmPackage: spec.npmPackage,
+    installCommand: `npm install -g ${spec.npmPackage}`,
+    cliBin: spec.cli
+  });
+}
+var CLI_PRESENCE_TTL_MS, cliPresenceCache;
+var init_optional_cli = __esm({
+  "src/integrations/optional-cli.ts"() {
+    "use strict";
+    init_install();
+    init_path();
+    init_optional_services();
+    CLI_PRESENCE_TTL_MS = 6e4;
+    cliPresenceCache = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/integrations/optional-services.ts
+function optionalServiceSpec(id) {
+  const spec = OPTIONAL_SERVICES.find((s) => s.id === id);
+  if (!spec) throw new Error(`Unknown optional service: ${id}`);
+  return spec;
+}
+function isOptionalServiceId(value) {
+  return typeof value === "string" && OPTIONAL_SERVICE_IDS.includes(value);
+}
+function normalizeServiceOrigin(raw, fallback) {
+  const trimmed = raw?.trim() || fallback;
+  try {
+    const url = new URL(trimmed.includes("://") ? trimmed : `https://${trimmed}`);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return fallback;
+    return `${url.protocol}//${url.host}`;
+  } catch {
+    return fallback;
+  }
+}
 function optionalServiceConnected(id, integrations) {
   if (id === "vercel") return Boolean(integrations.vercelToken?.trim());
   if (id === "supabase") return Boolean(integrations.supabaseAccessToken?.trim());
@@ -24004,61 +24231,65 @@ function optionalServiceConnected(id, integrations) {
 function connectedOptionalServices(integrations) {
   return OPTIONAL_SERVICES.filter((spec) => optionalServiceConnected(spec.id, integrations));
 }
-function formatOptionalServicesDirective(integrations) {
+function cliPresencePhrase(spec, cli) {
+  if (!spec.cli || !cli || !(spec.id in cli)) return "";
+  return cli[spec.id] ? " (installed)" : " (not installed \u2014 ask the user to press Install CLI in Settings \u2192 Connectors)";
+}
+function connectorDirectiveLine(spec, cli) {
+  const extras = spec.hostEnvKey ? ` / \`${spec.hostEnvKey}\`` : "";
+  if (spec.cli) {
+    return `- ${spec.label}: use \`${spec.cli}\` (\`${spec.envKey}\`${extras})${cliPresencePhrase(spec, cli)}. Do not add a ${spec.label} MCP.`;
+  }
+  return `- ${spec.label}: call \`posthog_api\`. Path must start with \`/api/\`. GET is the default. POST \`/api/projects/:id/query/\` or \`/api/environments/:id/query/\` is a read and does not need \`write=true\`. Other POST and PATCH require \`write=true\` only when the user asked to change data. Do not read the API key from the environment. Do not add a ${spec.label} MCP.`;
+}
+function connectorReminderBit(spec, cli) {
+  if (!spec.cli) return `${spec.label}: \`posthog_api\``;
+  const presence = cliPresencePhrase(spec, cli);
+  return `${spec.label}: \`${spec.cli}\`${presence}`;
+}
+function formatOptionalServicesDirective(integrations, cli) {
   const connected = connectedOptionalServices(integrations);
   if (connected.length === 0) return null;
+  const cliConnected = connected.some((spec) => spec.cli);
   const lines = [
-    "Optional connectors (connected \u2014 tokens are already in this process env):"
+    cliConnected ? "Optional connectors (connected \u2014 CLI tokens are already in this process env):" : "Optional connectors (connected):",
+    ...connected.map((spec) => connectorDirectiveLine(spec, cli)),
+    cliConnected ? "If a connector MCP is listed but needsAuth or returns unauthorized, do not sign in to that MCP. CLI tokens are already in this process. Do not read a PostHog key from the environment." : "If a connector MCP is listed but needsAuth or returns unauthorized, do not sign in to that MCP. Do not read a PostHog key from the environment.",
+    "Do not add a vendor MCP. When a binary is missing, ask the user to press Install CLI in Settings \u2192 Connectors.",
+    "When you shell a connector CLI, write bulky output to `.context/cli/` and read a slice."
   ];
-  for (const spec of connected) {
-    if (spec.cli) {
-      const extras = spec.hostEnvKey ? ` / \`${spec.hostEnvKey}\`` : "";
-      lines.push(
-        `- ${spec.label}: use the \`${spec.cli}\` CLI (\`${spec.envKey}\`${extras}). Do not add a ${spec.label} MCP.`
-      );
-    } else {
-      const extras = spec.hostEnvKey ? ` / \`${spec.hostEnvKey}\`` : "";
-      lines.push(
-        `- ${spec.label}: no first-class CLI \u2014 call the HTTP API with \`${spec.envKey}\`${extras}. Do not add a ${spec.label} MCP.`
-      );
-    }
-  }
-  lines.push(
-    "If a connector MCP is listed but needsAuth or returns unauthorized, do not sign in to that MCP. Check the native CLI (or the HTTP API when there is no CLI) \u2014 the token is already in this process."
-  );
-  lines.push(
-    "If a CLI is missing, say so or use the HTTP API with the same token. The user can Install CLI from Settings \u2192 Connectors. Do not ask the user to install a vendor MCP."
-  );
-  lines.push(
-    "Safe CLI / HTTP (every connector \u2014 `vercel logs`, Supabase inspect, `sentry-cli`, PostHog API):"
-  );
-  lines.push(
-    '- Never put raw `--json` / `--expand` / huge dumps in the tool result. That crashes any worktree agent mid-turn (Claude / Cursor / Codex / OpenCode). Cursor chat fills with `file://\u2026/cursor-runtime/\u2026/@cursor/sdk/dist/esm/index.js` then minified `importas e from"@bufbuild/protobuf"`.'
-  );
-  lines.push(
-    "- Write output to `.context/cli/` (worktree scratch; not `.context/attachments/`). Then read a slice. Tight window first (`--limit`, recent `--since` / last N events); raise only if empty."
-  );
-  lines.push(
-    "- Filter (`jq`) to the fields you need (timestamp, path, status, message) \u2014 not the full request object."
-  );
-  lines.push(
-    "- One query at a time. After you have the error line, stop fetching. Piping to `head` does not help \u2014 the CLI still buffers until you kill it."
-  );
-  lines.push(
-    "- If a call is still running at ~40s with no useful output, stop waiting on the raw shell; detach (`/long-running`) or `stop_job` if it is hanging / doing the wrong thing."
-  );
   return lines.join("\n");
 }
-function formatOptionalServicesReminder(integrations) {
-  if (connectedOptionalServices(integrations).length === 0) return null;
-  return "Settings \u2192 Connectors: official CLIs / PostHog HTTP with injected env. If a connector MCP needsAuth or is unauthorized, check the native CLI or HTTP API instead of signing in. Write output to `.context/cli/` (not `.context/attachments/`) and read a slice \u2014 never dump raw --json/--expand into the tool result (any agent). stop_job if a fetch hangs. Do not add vendor MCPs.";
+function formatOptionalServicesReminder(integrations, cli) {
+  const connected = connectedOptionalServices(integrations);
+  if (connected.length === 0) return null;
+  const bits = connected.map((spec) => connectorReminderBit(spec, cli)).join(". ");
+  const tokenBit = connected.some((spec) => spec.cli) ? "CLI tokens are already in this process. " : "";
+  return `Settings \u2192 Connectors: ${tokenBit}${bits}. If a connector MCP needsAuth or is unauthorized, ignore it and use the CLI or \`posthog_api\`. Do not add vendor MCPs. Do not read a PostHog key from the environment. Shell dumps from those CLIs go in \`.context/cli/\` \u2014 read a slice.`;
+}
+async function connectedCliPresence(integrations) {
+  const ids = connectedOptionalServices(integrations).filter((spec) => spec.cli).map((spec) => spec.id);
+  if (ids.length === 0) return void 0;
+  try {
+    const { optionalCliPresence: optionalCliPresence2 } = await Promise.resolve().then(() => (init_optional_cli(), optional_cli_exports));
+    return await optionalCliPresence2(ids);
+  } catch {
+    return void 0;
+  }
+}
+async function formatOptionalServicesDirectiveForTurn(integrations) {
+  return formatOptionalServicesDirective(integrations, await connectedCliPresence(integrations));
+}
+async function formatOptionalServicesReminderForTurn(integrations) {
+  return formatOptionalServicesReminder(integrations, await connectedCliPresence(integrations));
 }
-var OPTIONAL_SERVICES;
+var OPTIONAL_SERVICE_IDS, OPTIONAL_SERVICES;
 var init_optional_services = __esm({
   "src/integrations/optional-services.ts"() {
     "use strict";
     init_fetch();
     init_app_settings();
+    OPTIONAL_SERVICE_IDS = ["vercel", "supabase", "posthog", "sentry"];
     OPTIONAL_SERVICES = [
       {
         id: "vercel",
@@ -24083,7 +24314,7 @@ var init_optional_services = __esm({
       {
         id: "posthog",
         label: "PostHog",
-        hint: "Product analytics. No first-class CLI \u2014 agents use the HTTP API (`POSTHOG_PERSONAL_API_KEY`).",
+        hint: "Product analytics. Agents call `posthog_api` on the Sideboard MCP server.",
         tokenPlaceholder: "phx_\u2026",
         tokenDocs: "https://app.posthog.com/settings/user-api-keys",
         envKey: "POSTHOG_PERSONAL_API_KEY",
@@ -26377,7 +26608,7 @@ var init_orchestrator = __esm({
           const artifactReminder = thread.agent !== "brightsy" ? formatUiReminder() : null;
           const longRunningReminder = thread.agent !== "brightsy" && !isOrchestratorThread(thread) ? formatLongRunningReminder({ activeRuns: worktreeActiveRuns }) : null;
           const worktreeReminder = thread.agent !== "brightsy" && !isOrchestratorThread(thread) ? formatWorktreeReminder() : null;
-          const optionalServicesReminder = thread.agent !== "brightsy" && !isOrchestratorThread(thread) ? formatOptionalServicesReminder(loadAppSettings().integrations) : null;
+          const optionalServicesReminder = thread.agent !== "brightsy" && !isOrchestratorThread(thread) ? await formatOptionalServicesReminderForTurn(loadAppSettings().integrations) : null;
           const issueTicket = issueTicketFromThread(thread, resolveEffectiveIssueSource());
           const issueToolsReminder = thread.agent !== "brightsy" && !isOrchestratorThread(thread) ? formatIssueToolsReminder({
             linear: isLinearConnected(),
@@ -26448,7 +26679,7 @@ ${formatEnvReminder(projectNameForRepoPath(thread.repoPath || thread.worktreePat
           });
           const artifactDirective = isBrightsy ? null : formatArtifactDirective();
           const longRunningDirective = isBrightsy || isOrchestration ? null : formatLongRunningDirective();
-          const optionalServicesDirective = isBrightsy || isOrchestration ? null : formatOptionalServicesDirective(loadAppSettings().integrations);
+          const optionalServicesDirective = isBrightsy || isOrchestration ? null : await formatOptionalServicesDirectiveForTurn(loadAppSettings().integrations);
           const freshIssueTicket = issueTicketFromThread(fresh, resolveEffectiveIssueSource());
           const issueToolsDirective = isBrightsy || isOrchestration ? null : formatIssueToolsDirective({
             linear: isLinearConnected(),
@@ -26625,7 +26856,7 @@ ${formatEnvReminder(projectNameForRepoPath(thread.repoPath || thread.worktreePat
               }
             } catch {
             }
-            const retryNote = isolateCodexPluginRetry ? "Codex plugin/MCP failed \u2014 continuing without that vendor plugin (Settings \u2192 Connectors + HTTP API)" : looksLikeInvalidAgentSession(detail) ? "Agent session missing \u2014 starting a fresh session" : looksLikeV8Oom(detail) ? "Agent ran out of memory \u2014 starting a fresh session" : "Agent runner crashed \u2014 restarting Node once";
+            const retryNote = isolateCodexPluginRetry ? "Codex plugin/MCP failed \u2014 continuing without that vendor plugin (PostHog: Settings \u2192 Connectors and posthog_api)" : looksLikeInvalidAgentSession(detail) ? "Agent session missing \u2014 starting a fresh session" : looksLikeV8Oom(detail) ? "Agent ran out of memory \u2014 starting a fresh session" : "Agent runner crashed \u2014 restarting Node once";
             pushTurnStderr(stderrTail, retryNote);
             this.emit({
               type: "turn_output",
@@ -28249,7 +28480,7 @@ function createClippedMcpServer() {
 }
 
 // src/mcp/server.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 var import_node_crypto19 = require("crypto");
 var import_node_path65 = require("path");
 init_orchestrator();
@@ -31262,6 +31493,151 @@ function registerConnectedIssueVendorTools(server, settings = loadAppSettings())
   if (isAbleTimeConnected(settings)) registerAbleTimeTools(server);
 }
 
+// src/mcp/posthog-tools.ts
+var import_zod8 = require("zod");
+init_fetch();
+init_optional_services();
+init_app_settings();
+init_issue_list();
+var POSTHOG_METHODS = ["GET", "POST", "PATCH"];
+var POSTHOG_RESPONSE_MAX_CHARS = 256e3;
+var POSTHOG_TIMEOUT_MS = 2e4;
+var POSTHOG_READ_QUERY = /^\/api\/(?:projects|environments)\/[^/]+\/query$/;
+function isPosthogReadQuery(method, path) {
+  if (method !== "POST") return false;
+  return POSTHOG_READ_QUERY.test(path.trim().replace(/\/+$/, ""));
+}
+function withPosthogSlash(method, path) {
+  const raw = path.trim();
+  if ((method === "POST" || method === "PATCH") && raw.startsWith("/api/") && !raw.endsWith("/")) {
+    return `${raw}/`;
+  }
+  return raw;
+}
+function posthogApiUrl(host, path, query) {
+  const raw = path.trim();
+  if (!raw.startsWith("/api/")) {
+    throw new Error("path must start with /api/");
+  }
+  if (raw.includes("://") || raw.startsWith("//") || /[?#\s\\]/.test(raw) || raw.includes("..")) {
+    throw new Error("path must be a PostHog API path, not a URL");
+  }
+  const origin = normalizeServiceOrigin(host, "https://us.posthog.com");
+  const url = new URL(raw, origin);
+  if (url.origin !== new URL(origin).origin || !url.pathname.startsWith("/api/")) {
+    throw new Error("path must stay on the connected PostHog host");
+  }
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      if (!key.trim()) throw new Error("query keys must be non-empty");
+      url.searchParams.set(key, value);
+    }
+  }
+  return url.toString();
+}
+async function runPosthogApi(input) {
+  const method = input.method;
+  if (!POSTHOG_METHODS.includes(method)) {
+    return mcpJson({ ok: false, error: "method must be GET, POST, or PATCH" }, true);
+  }
+  if (method !== "GET" && input.write !== true && !isPosthogReadQuery(method, input.path)) {
+    return mcpJson(
+      {
+        ok: false,
+        error: "POST and PATCH require write=true, and only when the user asked to change PostHog data. POST /api/projects/:id/query/ and POST /api/environments/:id/query/ are reads and do not need write=true."
+      },
+      true
+    );
+  }
+  if (method === "GET" && input.body !== void 0) {
+    return mcpJson({ ok: false, error: "GET does not take a body" }, true);
+  }
+  const integrations = loadAppSettings().integrations;
+  const token = integrations.posthogPersonalApiKey?.trim();
+  if (!token) {
+    return mcpJson(
+      { ok: false, error: "PostHog is not connected (Settings \u2192 Connectors)." },
+      true
+    );
+  }
+  let url;
+  try {
+    url = posthogApiUrl(
+      integrations.posthogHost || "https://us.posthog.com",
+      withPosthogSlash(method, input.path),
+      input.query
+    );
+  } catch (err) {
+    return mcpJson(
+      { ok: false, error: err instanceof Error ? err.message : String(err) },
+      true
+    );
+  }
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/json"
+  };
+  let body;
+  if (input.body !== void 0) {
+    headers["Content-Type"] = "application/json";
+    body = typeof input.body === "string" ? input.body : JSON.stringify(input.body);
+  }
+  try {
+    const res = await httpFetch(url, {
+      method,
+      headers,
+      body,
+      signal: AbortSignal.timeout(POSTHOG_TIMEOUT_MS)
+    });
+    const text7 = await res.text();
+    const truncated = text7.length > POSTHOG_RESPONSE_MAX_CHARS;
+    const slice = truncated ? text7.slice(0, POSTHOG_RESPONSE_MAX_CHARS) : text7;
+    let parsed = slice;
+    if (slice.trim()) {
+      try {
+        parsed = JSON.parse(slice);
+      } catch {
+        parsed = slice;
+      }
+    } else {
+      parsed = null;
+    }
+    return mcpJson(
+      {
+        ok: res.ok,
+        status: res.status,
+        ...truncated ? { truncated: true } : {},
+        body: parsed
+      },
+      !res.ok
+    );
+  } catch (err) {
+    return mcpJson(
+      { ok: false, error: err instanceof Error ? err.message : String(err) },
+      true
+    );
+  }
+}
+var POSTHOG_API_DESCRIPTION = "Call the connected PostHog project (Settings \u2192 Connectors). path must start with /api/ and is joined to the stored host. GET is the default. POST /api/projects/:id/query/ and POST /api/environments/:id/query/ are reads (HogQL and insights) and do not need write=true. Other POST and PATCH require write=true, and only when the user asked to change PostHog data. The API key is not in the environment. Do not sign in to a PostHog MCP.";
+function registerPosthogTools(server) {
+  server.tool(
+    "posthog_api",
+    POSTHOG_API_DESCRIPTION,
+    {
+      method: import_zod8.z.enum(POSTHOG_METHODS).describe(
+        "GET, POST /api/projects|environments/:id/query/ for a read, or POST/PATCH when the user asked for a change"
+      ),
+      path: import_zod8.z.string().describe("PostHog path starting with /api/, not a full URL"),
+      query: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string()).optional().describe("Query string parameters"),
+      body: import_zod8.z.unknown().optional().describe("JSON body for POST or PATCH"),
+      write: import_zod8.z.boolean().optional().describe(
+        "Required true for POST and PATCH that change data. Omit for GET and for POST .../query/."
+      )
+    },
+    async (input) => runPosthogApi(input)
+  );
+}
+
 // src/mcp/server.ts
 init_viewer_context_tools();
 init_issue_list();
@@ -31306,7 +31682,7 @@ init_list_prs();
 init_app_settings();
 
 // src/mcp/schedule-tools.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 init_schedules();
 init_schedule_runner();
 init_issue_list();
@@ -31349,18 +31725,18 @@ function registerScheduleTools(server) {
     "create_schedule",
     "Create a local schedule that, when due, sends a prompt to an existing chat (chatId) or starts a new Global orchestration chat (omit chatId). Pass chatId=self to continue this chat. If that chat is missing or archived when the job fires, Sideboard starts a new Global chat (recurring jobs then continue that chat). Exactly one of at (ISO datetime), every (15m/1h/6h/1d), or cron (5-field). Recurring jobs without chatId open a new Global chat each run. Creating or enabling a future job turns on Settings \u2192 Advanced \u2192 Caffeinate while schedules are enabled so the Mac stays awake until due. Sideboard.app must be running for the job to fire.",
     {
-      prompt: import_zod8.z.string().describe("User message / goal queued when the schedule fires"),
-      name: import_zod8.z.string().optional(),
-      at: import_zod8.z.string().optional().describe("ISO datetime for a one-shot"),
-      every: import_zod8.z.string().optional().describe("Interval such as 15m, 1h, 6h, 1d"),
-      cron: import_zod8.z.string().optional().describe("5-field cron expression"),
-      tz: import_zod8.z.string().optional().describe("IANA timezone for cron (default: system)"),
-      chatId: import_zod8.z.string().optional().describe(
+      prompt: import_zod9.z.string().describe("User message / goal queued when the schedule fires"),
+      name: import_zod9.z.string().optional(),
+      at: import_zod9.z.string().optional().describe("ISO datetime for a one-shot"),
+      every: import_zod9.z.string().optional().describe("Interval such as 15m, 1h, 6h, 1d"),
+      cron: import_zod9.z.string().optional().describe("5-field cron expression"),
+      tz: import_zod9.z.string().optional().describe("IANA timezone for cron (default: system)"),
+      chatId: import_zod9.z.string().optional().describe(
         'Existing chat id (orchestration or workspace), or "self" for this chat. Omit to create a new Global chat on fire.'
       ),
-      threadId: import_zod8.z.string().optional().describe("Legacy alias for chatId."),
-      agent: import_zod8.z.enum(["claude", "cursor", "codex", "opencode"]).optional().describe("Agent for a new Global chat (omit for Account default)"),
-      model: import_zod8.z.string().optional()
+      threadId: import_zod9.z.string().optional().describe("Legacy alias for chatId."),
+      agent: import_zod9.z.enum(["claude", "cursor", "codex", "opencode"]).optional().describe("Agent for a new Global chat (omit for Account default)"),
+      model: import_zod9.z.string().optional()
     },
     async (args) => {
       try {
@@ -31396,20 +31772,20 @@ function registerScheduleTools(server) {
     "update_schedule",
     "Update a local schedule (prompt, cadence, target chat, enabled). Pass id from list_schedules.",
     {
-      id: import_zod8.z.string(),
-      prompt: import_zod8.z.string().optional(),
-      name: import_zod8.z.string().optional(),
-      at: import_zod8.z.string().optional(),
-      every: import_zod8.z.string().optional(),
-      cron: import_zod8.z.string().optional(),
-      tz: import_zod8.z.string().optional(),
-      chatId: import_zod8.z.string().optional().describe(
+      id: import_zod9.z.string(),
+      prompt: import_zod9.z.string().optional(),
+      name: import_zod9.z.string().optional(),
+      at: import_zod9.z.string().optional(),
+      every: import_zod9.z.string().optional(),
+      cron: import_zod9.z.string().optional(),
+      tz: import_zod9.z.string().optional(),
+      chatId: import_zod9.z.string().optional().describe(
         'Existing chat (orchestration or workspace), "self", or empty string to create a new Global chat each run'
       ),
-      threadId: import_zod8.z.string().optional().describe("Legacy alias for chatId."),
-      agent: import_zod8.z.enum(["claude", "cursor", "codex", "opencode"]).optional(),
-      model: import_zod8.z.string().optional(),
-      enabled: import_zod8.z.boolean().optional()
+      threadId: import_zod9.z.string().optional().describe("Legacy alias for chatId."),
+      agent: import_zod9.z.enum(["claude", "cursor", "codex", "opencode"]).optional(),
+      model: import_zod9.z.string().optional(),
+      enabled: import_zod9.z.boolean().optional()
     },
     async (args) => {
       try {
@@ -31450,7 +31826,7 @@ function registerScheduleTools(server) {
   server.tool(
     "delete_schedule",
     "Delete a local schedule. Pass id from list_schedules.",
-    { id: import_zod8.z.string() },
+    { id: import_zod9.z.string() },
     async ({ id }) => {
       try {
         deleteSchedule(id);
@@ -31463,7 +31839,7 @@ function registerScheduleTools(server) {
   server.tool(
     "run_schedule",
     "Fire a schedule now (does not wait for nextRunAt). Queues the prompt on the target chat or starts a new Global chat. If Sideboard.app is running, the desktop drains the turn.",
-    { id: import_zod8.z.string() },
+    { id: import_zod9.z.string() },
     async ({ id }) => {
       try {
         if (!getSchedule(id)) {
@@ -31814,6 +32190,7 @@ async function startMcpServer() {
     }
   };
   registerViewerContextTools(server);
+  registerPosthogTools(server);
   if (worktreeProfile) {
     registerConnectedIssueVendorTools(server);
   }
@@ -31869,16 +32246,16 @@ async function startMcpServer() {
       "list_board",
       "Home Kanban of workspaces (New, Draft, Review, Merged) \u2014 one card per checkout; sibling chats on that card are separate agents. Same cards as desktop Home. Path to merge: no PR \u2192 draft PR \u2192 open PR \u2192 merged. Archive removes the card to Settings \u2192 History. Queued/running are activity on the card, not columns. Orchestration chats are not on the board. Filters: query, repoPath, kind (ticket/PR/branch source), ownership (mine = your PRs / WIP; reviewing = someone else's PR), column, limit (default 40). create_workspace adds a workspace (and a Home card), or returns the live checkout if that ticket/PR/named branch is already checked out. That reuse is one checkout, not one agent \u2014 fork_chat to add another.",
       {
-        query: import_zod9.z.string().optional().describe("Case-insensitive token search across title, id, labels, workspace tags, repo"),
-        repoPath: import_zod9.z.string().optional().describe("Limit to one project path from list_projects"),
-        kind: import_zod9.z.enum(["all", "tickets", "prs", "branches", "threads"]).optional().describe("Filter by worktree source (default all)"),
-        ownership: import_zod9.z.enum(["all", "mine", "reviewing"]).optional().describe(
+        query: import_zod10.z.string().optional().describe("Case-insensitive token search across title, id, labels, workspace tags, repo"),
+        repoPath: import_zod10.z.string().optional().describe("Limit to one project path from list_projects"),
+        kind: import_zod10.z.enum(["all", "tickets", "prs", "branches", "threads"]).optional().describe("Filter by worktree source (default all)"),
+        ownership: import_zod10.z.enum(["all", "mine", "reviewing"]).optional().describe(
           "Mine = PRs you authored or local WIP; reviewing = someone else's PR. Uses the gh login."
         ),
-        column: import_zod9.z.enum(["new", "draft", "review", "done", "needs_you"]).optional().describe(
+        column: import_zod10.z.enum(["new", "draft", "review", "done", "needs_you"]).optional().describe(
           "Return cards for this column only (totals still include the rest). needs_you is a legacy alias for new."
         ),
-        limit: import_zod9.z.number().int().positive().optional().describe("Max cards per column (default 40). hidden counts the remainder.")
+        limit: import_zod10.z.number().int().positive().optional().describe("Max cards per column (default 40). hidden counts the remainder.")
       },
       async ({ query, repoPath, kind, ownership, column, limit }) => {
         const workspaces = orch.listWorkspaces();
@@ -31908,7 +32285,7 @@ async function startMcpServer() {
     server.tool(
       "get_chat",
       "Get a compact chat summary by id/ref. Includes last message preview, parentChatId, and child workspace chats (status + lastText). While running, includes progress (last tool/thinking) and lastActivityAt. Includes usage (billed token + costUsd totals when providers reported cost) and lastTurnUsage. blockedReason is why that agent is waiting on a person (question, plan approval, or a reported block).",
-      { ref: import_zod9.z.string() },
+      { ref: import_zod10.z.string() },
       async ({ ref }) => {
         const t = orch.getThread(ref);
         if (!t) {
@@ -31955,17 +32332,17 @@ async function startMcpServer() {
       "present_artifact",
       "Show a document or live log in Sideboard\u2019s side column. For html/svg/markdown/react, pass the FULL document and do not also fence that same body in chat. For type=log, pass only NEW lines (same artifact_id appends). Prefer type=log for long-running job output \u2014 do not resend HTML. type=react is a single default-export component (JSX/TSX); only react/react-dom imports.",
       {
-        title: import_zod9.z.string().describe("Short title shown in the artifact pane header"),
-        type: import_zod9.z.enum(["html", "svg", "markdown", "react", "log"]).describe(
+        title: import_zod10.z.string().describe("Short title shown in the artifact pane header"),
+        type: import_zod10.z.enum(["html", "svg", "markdown", "react", "log"]).describe(
           "html/svg/markdown/react replace the pane. log appends content to the same artifact_id (new lines only)."
         ),
-        content: import_zod9.z.string().describe(
+        content: import_zod10.z.string().describe(
           "html/svg/markdown/react: full document. log: only the new lines since the last call (empty is ok for a status-only update)."
         ),
-        artifact_id: import_zod9.z.string().optional().describe("Stable id. Required for type=log so later calls append to the same pane."),
-        status: import_zod9.z.enum(["running", "ok", "failed", "idle"]).optional().describe("Log header pill: running (working), ok (done), failed, idle"),
-        phase: import_zod9.z.string().optional().describe("Log subtitle (Signing, Notarizing, \u2026)"),
-        mode: import_zod9.z.enum(["append", "replace"]).optional().describe("log only: append (default) or replace the buffer")
+        artifact_id: import_zod10.z.string().optional().describe("Stable id. Required for type=log so later calls append to the same pane."),
+        status: import_zod10.z.enum(["running", "ok", "failed", "idle"]).optional().describe("Log header pill: running (working), ok (done), failed, idle"),
+        phase: import_zod10.z.string().optional().describe("Log subtitle (Signing, Notarizing, \u2026)"),
+        mode: import_zod10.z.enum(["append", "replace"]).optional().describe("log only: append (default) or replace the buffer")
       },
       async ({ title, type, artifact_id, status, phase, mode }) => {
         return mcpJson(
@@ -31978,15 +32355,15 @@ async function startMcpServer() {
     "ask_user",
     "Ask the user a clarifying multiple-choice question in Sideboard\u2019s composer. Call only when work is blocked on choosing among a few concrete options (approach fork, which API, auth vs cookies). Do not call for greetings, check-ins, \u201Chello\u201D, open-ended how-can-I-help, or to invent a menu of possible next tasks \u2014 reply in chat instead. If one option is the obvious default, proceed without asking. Before calling, write a short chat message explaining the decision and what each option means. Include a description on every option. After calling, stop and wait for answers. Not for \u201Cis the plan ready?\u201D.",
     {
-      questions: import_zod9.z.array(
-        import_zod9.z.object({
-          question: import_zod9.z.string().describe("Full question text ending with ?"),
-          header: import_zod9.z.string().max(24).optional().describe("Short label shown above the question"),
-          multiSelect: import_zod9.z.boolean().optional().describe("Allow selecting multiple options"),
-          options: import_zod9.z.array(
-            import_zod9.z.object({
-              label: import_zod9.z.string(),
-              description: import_zod9.z.string().optional().describe("What this option means / when to choose it (strongly preferred)")
+      questions: import_zod10.z.array(
+        import_zod10.z.object({
+          question: import_zod10.z.string().describe("Full question text ending with ?"),
+          header: import_zod10.z.string().max(24).optional().describe("Short label shown above the question"),
+          multiSelect: import_zod10.z.boolean().optional().describe("Allow selecting multiple options"),
+          options: import_zod10.z.array(
+            import_zod10.z.object({
+              label: import_zod10.z.string(),
+              description: import_zod10.z.string().optional().describe("What this option means / when to choose it (strongly preferred)")
             })
           ).min(2).max(6).describe("2\u20136 choices (Sideboard also offers Other)")
         })
@@ -32012,9 +32389,9 @@ async function startMcpServer() {
       "present_plan",
       PRESENT_PLAN_TOOL_DESCRIPTION,
       {
-        title: import_zod9.z.string().optional().describe("Short plan title (defaults to Plan)"),
-        content: import_zod9.z.string().min(1).describe("Full plan markdown (headings, steps, risks, open questions)"),
-        thread_id: import_zod9.z.string().optional().describe("Sideboard thread id when cwd is not the worktree")
+        title: import_zod10.z.string().optional().describe("Short plan title (defaults to Plan)"),
+        content: import_zod10.z.string().min(1).describe("Full plan markdown (headings, steps, risks, open questions)"),
+        thread_id: import_zod10.z.string().optional().describe("Sideboard thread id when cwd is not the worktree")
       },
       async ({ title, content, thread_id }) => {
         const { writePlanFile: writePlanFile2 } = await Promise.resolve().then(() => (init_plan_file(), plan_file_exports));
@@ -32043,15 +32420,15 @@ async function startMcpServer() {
     "present_schema",
     "Open Sideboard\u2019s schema-driven side column (filterable table and/or form) when the user needs to filter, edit, publish, or persist records. Do not call this just to re-display rows you already wrote as a markdown table. If the user asks for an editable / interactive table, call this even if chat already showed those rows. Pass JSON Schema + optional schemaUi. Prefer datasource=inline with embedded resource/records. Use datasource=brightsy with resource_id only when the user is logged into Brightsy.",
     {
-      title: import_zod9.z.string().describe("Pane title"),
-      mode: import_zod9.z.enum(["table", "form"]).optional().describe("table = list/filter records; form = edit one record"),
-      datasource: import_zod9.z.enum(["brightsy", "inline"]).optional().describe("brightsy resolves via login; inline uses embedded resource/records"),
-      resource_id: import_zod9.z.string().optional().describe("Brightsy record type UUID (or generic resource id)"),
-      record_id: import_zod9.z.string().optional().describe("Record id when opening form mode"),
-      resource: import_zod9.z.record(import_zod9.z.unknown()).optional().describe("Inline { id, title, schema, schemaUi?, slug? }"),
-      record: import_zod9.z.record(import_zod9.z.unknown()).optional().describe("Inline record { id, data, published_at? }"),
-      records: import_zod9.z.array(import_zod9.z.record(import_zod9.z.unknown())).optional().describe("Inline records for table mode"),
-      pane_id: import_zod9.z.string().optional().describe("Stable pane id across updates")
+      title: import_zod10.z.string().describe("Pane title"),
+      mode: import_zod10.z.enum(["table", "form"]).optional().describe("table = list/filter records; form = edit one record"),
+      datasource: import_zod10.z.enum(["brightsy", "inline"]).optional().describe("brightsy resolves via login; inline uses embedded resource/records"),
+      resource_id: import_zod10.z.string().optional().describe("Brightsy record type UUID (or generic resource id)"),
+      record_id: import_zod10.z.string().optional().describe("Record id when opening form mode"),
+      resource: import_zod10.z.record(import_zod10.z.unknown()).optional().describe("Inline { id, title, schema, schemaUi?, slug? }"),
+      record: import_zod10.z.record(import_zod10.z.unknown()).optional().describe("Inline record { id, data, published_at? }"),
+      records: import_zod10.z.array(import_zod10.z.record(import_zod10.z.unknown())).optional().describe("Inline records for table mode"),
+      pane_id: import_zod10.z.string().optional().describe("Stable pane id across updates")
     },
     async (args) => {
       const id = args.pane_id?.trim() || `schema_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
@@ -32072,10 +32449,10 @@ async function startMcpServer() {
     "present_files",
     "Open Sideboard\u2019s Files column (CMS-style file manager: browse, upload, pick). Use datasource=brightsy when the user is logged into Brightsy account storage; datasource=memory for a session-local demo store. Prefer this over claiming a file manager UI is unavailable. Pair with present_schema when editing records that need media.",
     {
-      title: import_zod9.z.string().optional().describe("Pane title (default: Files)"),
-      datasource: import_zod9.z.enum(["brightsy", "memory"]).optional().describe("brightsy = account storage via login; memory = session demo store"),
-      path: import_zod9.z.string().optional().describe("Initial folder path (e.g. public)"),
-      pane_id: import_zod9.z.string().optional().describe("Stable pane id across updates")
+      title: import_zod10.z.string().optional().describe("Pane title (default: Files)"),
+      datasource: import_zod10.z.enum(["brightsy", "memory"]).optional().describe("brightsy = account storage via login; memory = session demo store"),
+      path: import_zod10.z.string().optional().describe("Initial folder path (e.g. public)"),
+      pane_id: import_zod10.z.string().optional().describe("Stable pane id across updates")
     },
     async (args) => {
       const id = args.pane_id?.trim() || `files_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
@@ -32095,8 +32472,8 @@ async function startMcpServer() {
       "wait_for_job",
       "Wait on a detached long job (tests, pack, deploy, connector CLI) started with detached-job.cjs. MCP clients kill tools around 60s, so this returns within 45s. Sideboard opens a type=log pane from this result (artifact_id = job id, content = delta). stillRunning is the source of truth \u2014 if true, call wait_for_job again. If the job is hanging, producing no useful output, or doing the wrong thing, call stop_job instead of looping forever. Do not end the turn or tell the user you will let them know later. If false, ok/failed is the result.",
       {
-        id: import_zod9.z.string().describe("Detached job id (same kebab-case id passed to detached-job.cjs start)"),
-        timeoutMs: import_zod9.z.number().optional()
+        id: import_zod10.z.string().describe("Detached job id (same kebab-case id passed to detached-job.cjs start)"),
+        timeoutMs: import_zod10.z.number().optional()
       },
       async ({ id, timeoutMs }) => {
         const result = await waitForDetachedJob(process.cwd(), id, {
@@ -32109,8 +32486,8 @@ async function startMcpServer() {
       "stop_job",
       "Stop a detached job you started with detached-job.cjs when it is hanging, producing no useful output, buffering forever, or doing the wrong thing (wrong project, infinite watch, huge dump). Do not stop a pack/test/deploy that is clearly making progress. The type=log pane updates to status=failed with the last delta. Then decide the next step.",
       {
-        id: import_zod9.z.string().describe("Detached job id (same kebab-case id passed to detached-job.cjs start)"),
-        reason: import_zod9.z.string().optional().describe("Why you are stopping (hanging, no progress, wrong output, already have the answer)")
+        id: import_zod10.z.string().describe("Detached job id (same kebab-case id passed to detached-job.cjs start)"),
+        reason: import_zod10.z.string().optional().describe("Why you are stopping (hanging, no progress, wrong output, already have the answer)")
       },
       async ({ id, reason }) => {
         const result = await stopDetachedJob(process.cwd(), id, { reason });
@@ -32122,7 +32499,7 @@ async function startMcpServer() {
     "list_run_scripts",
     "List .sideboard/.conductor run scripts for this thread (same menu as the desktop Dev button) and which are active. Each script and active run includes preview: url (open http://localhost:<SIDEBOARD_PORT>) or window (Electron: native window is the app; url is renderer/HMR only). Never guess :3000. Worktree turns may omit ref (uses cwd).",
     {
-      ref: import_zod9.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd).")
+      ref: import_zod10.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd).")
     },
     async ({ ref }) => {
       try {
@@ -32152,8 +32529,8 @@ async function startMcpServer() {
     "run_dev_script",
     "Start a .sideboard/.conductor run script (same as the desktop Dev / play button). Several named scripts can run at once; each gets its own port, and starting one does not stop the others. Logs and Stop appear in the thread UI \u2014 do not detached-job or shell-spawn the same command. Returns {port, ports, url, preview}. preview=url \u2192 open url (browser, curl, Playwright). preview=window \u2192 Electron: the native window is the app; url is renderer/HMR only (no preload/IPC in a browser). The port is allocated SIDEBOARD_PORT, not 3000. Worktree turns may omit ref (uses cwd). Omit name for the default script.",
     {
-      ref: import_zod9.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
-      name: import_zod9.z.string().optional().describe("Script name from list_run_scripts (default script if omitted).")
+      ref: import_zod10.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
+      name: import_zod10.z.string().optional().describe("Script name from list_run_scripts (default script if omitted).")
     },
     async ({ ref, name }) => {
       try {
@@ -32181,8 +32558,8 @@ async function startMcpServer() {
     "stop_dev_script",
     "Stop a run script started with run_dev_script or the desktop Dev button (same as UI Stop). Omit name to stop all scripts on this worktree. Worktree turns may omit ref (uses cwd).",
     {
-      ref: import_zod9.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
-      name: import_zod9.z.string().optional().describe("Script name to stop; omit to stop all active scripts.")
+      ref: import_zod10.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
+      name: import_zod10.z.string().optional().describe("Script name to stop; omit to stop all active scripts.")
     },
     async ({ ref, name }) => {
       try {
@@ -32199,9 +32576,9 @@ async function startMcpServer() {
     "get_run_log",
     "Read the Run-tab terminal for a worktree script (same stdout/stderr as the desktop Dev pane). Default is a tail \u2014 raise `tail` only if the error is missing. Worktree turns may omit ref (uses cwd). Omit name for the default script.",
     {
-      ref: import_zod9.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
-      name: import_zod9.z.string().optional().describe("Script name from list_run_scripts (default script if omitted)."),
-      tail: import_zod9.z.number().int().min(1).max(MAX_RUN_LOG_CHARS).optional().describe(
+      ref: import_zod10.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
+      name: import_zod10.z.string().optional().describe("Script name from list_run_scripts (default script if omitted)."),
+      tail: import_zod10.z.number().int().min(1).max(MAX_RUN_LOG_CHARS).optional().describe(
         `Max characters to return from the end (default ${DEFAULT_RUN_LOG_TAIL_CHARS}). Do not request the full buffer unless the tail is truncated and you still need more.`
       )
     },
@@ -32239,8 +32616,8 @@ async function startMcpServer() {
       "notify_orchestrator",
       "Wake the parent Global orchestrator with a short status so it does not have to poll wait_for_turn. Use when you are blocked and the parent may have moved on (missing access, waiting on something the coordinator must handle). The message is shown on the sidebar and board until the next user message in this chat. ask_user already notifies for input-required \u2014 do not call this for the same question. Information only: never a git command. Do not use this to steer other worktrees.",
       {
-        message: import_zod9.z.string().min(1).max(1500).describe("Why you are blocked / what the parent should know (short)."),
-        reason: import_zod9.z.enum(["input-required", "blocked"]).optional().describe(
+        message: import_zod10.z.string().min(1).max(1500).describe("Why you are blocked / what the parent should know (short)."),
+        reason: import_zod10.z.enum(["input-required", "blocked"]).optional().describe(
           "input-required = waiting on the user in this chat; blocked = need the coordinator (default)."
         )
       },
@@ -32277,11 +32654,11 @@ async function startMcpServer() {
     "set_workspace_tags",
     worktreeProfile ? "Update tags on this workspace (the checkout you are in). Omit ref to use this chat. mode=replace (default), add, or remove. Short labels \u2014 the same ones the orchestrator used for this task. You cannot retag a different checkout." : "Label a project workspace so related checkouts stay recognizable in the sidebar and on the phone. Pass any chat id on that workspace. Use the same tags on every workspace from one task. mode=replace is the default; add and remove change the set. create_workspace tags= sets them at create time. Not for orchestration chats.",
     {
-      ref: import_zod9.z.string().optional().describe(
+      ref: import_zod10.z.string().optional().describe(
         worktreeProfile ? "Omit for this chat. Another chat id only if it is on this same checkout." : "Chat id on the workspace to label."
       ),
-      tags: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.array(import_zod9.z.string())]).describe("Labels to set. A string may be comma-separated."),
-      mode: import_zod9.z.enum(["replace", "add", "remove"]).optional()
+      tags: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.array(import_zod10.z.string())]).describe("Labels to set. A string may be comma-separated."),
+      mode: import_zod10.z.enum(["replace", "add", "remove"]).optional()
     },
     async ({ ref, tags, mode }) => {
       try {
@@ -32315,7 +32692,7 @@ async function startMcpServer() {
       "set_caffeinate",
       "Keep this Mac awake with caffeinate (like Claude Code) across turns \u2014 independent of Settings toggles. Turn ON when the user will be away from the keyboard, is driving work from Slack, or asks you to keep the machine awake. Turn OFF when they say they are done, wrapping up, going to sleep, or no longer need the Mac awake. Closing or archiving this orchestration chat also releases the hold. macOS only.",
       {
-        enabled: import_zod9.z.boolean().describe("true = hold caffeinate on; false = release and let the Mac sleep")
+        enabled: import_zod10.z.boolean().describe("true = hold caffeinate on; false = release and let the Mac sleep")
       },
       async ({ enabled }) => {
         const threadId = process.env.SIDEBOARD_ORCHESTRATOR_THREAD_ID?.trim() || null;
@@ -32341,24 +32718,24 @@ async function startMcpServer() {
       "create_workspace",
       `Create a workspace (isolated git checkout + first chat) from branch, pr, or ticket. A ticket, PR, or named branch has one checkout \u2014 if one already matches, returns it (alreadyStarted=true) instead of a second checkout. That is not one agent: chats lists every agent on that checkout. Add another with fork_chat; send_to_chat only the chat that should do this job. Creating from the default branch still opens a new isolated checkout. Pass repoPath from list_projects. cowboy=true uses the project folder on the default branch (no isolated worktree; land is commit+push). From an orchestration chat, omit parentChatId (Sideboard binds the child to this chat) or pass the exact id from the turn reminder \u2014 never invent a uuid. Omit agent/model \u2014 Sideboard applies ${accountDefaultsHint}. Do not pass your own agent or agent=cursor; those are ignored. Setup (settings.toml, .cursor/worktrees.json, or script/setup) runs in the background in parallel with the first turn (skipped for cowboy). Pass the same tags on every workspace you open for one task (short labels such as "phone-sync") so they still match in the sidebar the next day. Reusing a checkout adds those tags.`,
       {
-        sourceType: import_zod9.z.enum(["branch", "pr", "ticket"]),
-        sourceRef: import_zod9.z.string(),
-        agent: import_zod9.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]).optional().describe(
+        sourceType: import_zod10.z.enum(["branch", "pr", "ticket"]),
+        sourceRef: import_zod10.z.string(),
+        agent: import_zod10.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]).optional().describe(
           `Usually omit. Sideboard uses Account default agent (${accountDefaults.agent}). Passing your own agent or cursor is ignored.`
         ),
-        model: import_zod9.z.string().nullable().optional().describe(
+        model: import_zod10.z.string().nullable().optional().describe(
           `Usually omit to use Account default model (${accountDefaults.model?.trim() || "Auto"}). Pass null only to force Auto / agent-default.`
         ),
-        repoPath: import_zod9.z.string(),
-        title: import_zod9.z.string().optional(),
-        cowboy: import_zod9.z.boolean().optional().describe(
+        repoPath: import_zod10.z.string(),
+        title: import_zod10.z.string().optional(),
+        cowboy: import_zod10.z.boolean().optional().describe(
           "If true, work in the project folder on the default branch (no thread/* worktree). Requires Settings \u2192 Advanced \u2192 Cowboy mode. Land is commit+push to that branch. Archive does not delete the folder."
         ),
-        parentChatId: import_zod9.z.string().optional().describe(
+        parentChatId: import_zod10.z.string().optional().describe(
           "Orchestration: omit (preferred) or pass YOUR chat id from the turn reminder / AGENTS.md. Do not invent uuids."
         ),
-        parentThreadId: import_zod9.z.string().optional().describe("Legacy alias for parentChatId."),
-        tags: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.array(import_zod9.z.string())]).optional().describe(
+        parentThreadId: import_zod10.z.string().optional().describe("Legacy alias for parentChatId."),
+        tags: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.array(import_zod10.z.string())]).optional().describe(
           "Short labels for this workspace (or a comma-separated string). Use the same tags on every checkout for one task. Added when the checkout already exists."
         )
       },
@@ -32374,11 +32751,11 @@ async function startMcpServer() {
       "start_board_card",
       "Same as create_workspace for a ticket, PR, or named branch (attaches issue text when Sideboard can resolve it). Does not create a second checkout when one already matches \u2014 returns that workspace (alreadyStarted) and its chats. A workspace can have many agents. fork_chat to add one; send_to_chat only the chat that should do this job.",
       {
-        kind: import_zod9.z.enum(["ticket", "pr", "branch"]),
-        ref: import_zod9.z.string().describe("Ticket identifier (ENG-12), PR number (44), or branch name from list_board"),
-        repoPath: import_zod9.z.string().describe("Project path from list_projects / list_board"),
-        title: import_zod9.z.string().optional(),
-        tags: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.array(import_zod9.z.string())]).optional().describe(
+        kind: import_zod10.z.enum(["ticket", "pr", "branch"]),
+        ref: import_zod10.z.string().describe("Ticket identifier (ENG-12), PR number (44), or branch name from list_board"),
+        repoPath: import_zod10.z.string().describe("Project path from list_projects / list_board"),
+        title: import_zod10.z.string().optional(),
+        tags: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.array(import_zod10.z.string())]).optional().describe(
           "Short labels for this workspace. Same tags on every checkout for one task. Added when the checkout already exists."
         )
       },
@@ -32483,9 +32860,9 @@ async function startMcpServer() {
       "send_to_chat",
       'Steer a prompt on a workspace chat (Settings \u2192 Follow-up, default steer: interrupt the in-flight turn and start now, same as the workspace composer). Use after create_workspace to start or continue a conversation. For commit/push/PR, prefer ask_git (canonical desktop-button phrases). Send "Merge PR." / ask_git merge only when the user explicitly asked to merge. force_stop=true kills the in-flight turn and clears the queue before this prompt \u2014 only when the current request is wrong and must be replaced. Do not send_to_chat to check in, resume after a halt notice, or because wait_for_turn returned stillRunning; that interrupts the child mid-thought. Call wait_for_turn again instead.',
       {
-        ref: import_zod9.z.string(),
-        prompt: import_zod9.z.string(),
-        force_stop: import_zod9.z.boolean().optional()
+        ref: import_zod10.z.string(),
+        prompt: import_zod10.z.string(),
+        force_stop: import_zod10.z.boolean().optional()
       },
       async ({ ref, prompt, force_stop }) => {
         if (force_stop) {
@@ -32510,8 +32887,8 @@ async function startMcpServer() {
         "wait_for_turn",
         "Wait until the chat finishes its current/queued turn, or return early with a live progress snapshot. MCP clients often kill tools around 60s, so this returns within 45s even while the child is still working. taskState is the A2A-style lifecycle: submitted (queued, not started), working, input-required (ask_user), completed, failed, canceled. stillRunning is true only for submitted/working. blockedReason is why the child is waiting on a person (the question, plan approval, or a reported block) \u2014 read it and do not send_to_chat a check-in. If stillRunning, text and usage are empty (they would be the previous turn) \u2014 read progress and call wait_for_turn again. Do not send_to_chat a check-in (that steers / interrupts). On failed, lastError/text is the failure. On canceled, the child did not finish \u2014 resume with send_to_chat or tell the user. On input-required, wait for the user in that chat. When finished, text is this turn\u2019s assistant reply and usage is that turn\u2019s tokens + costUsd (this turn, not the Claude session total; sessionCostUsd is the provider session total when present).",
         {
-          ref: import_zod9.z.string(),
-          timeoutMs: import_zod9.z.number().optional()
+          ref: import_zod10.z.string(),
+          timeoutMs: import_zod10.z.number().optional()
         },
         async ({ ref, timeoutMs }) => {
           const thread = await orch.waitForTurn(ref, mcpWaitForTurnTimeoutMs(timeoutMs), {
@@ -32539,7 +32916,7 @@ async function startMcpServer() {
     server.tool(
       "get_turn_result",
       "Assistant message and last-turn usage when the turn finished. While stillRunning (submitted/working), text and usage are empty so a previous reply cannot be mistaken for this turn \u2014 use progress for tools/thinking. Not the full transcript. Includes taskState (A2A lifecycle) and blockedReason (why the agent is waiting on a person).",
-      { ref: import_zod9.z.string() },
+      { ref: import_zod10.z.string() },
       async ({ ref }) => {
         const result = orch.getTurnResult(ref);
         const hint = mcpWaitTaskHint(result.taskState, result.status, result.blockedReason);
@@ -32555,9 +32932,9 @@ async function startMcpServer() {
       "stop_chat",
       "Force-stop a thread: kill any in-flight agent turn AND clear queued prompts so drainQueue cannot continue. Does not archive the worktree. Optional force defaults to true. Pass reason \u2014 a short note on why this chat is stopping. It is stored on the thread and kept when the turn unwinds. If you omit it, Sideboard still records that the queue was cleared.",
       {
-        ref: import_zod9.z.string(),
-        force: import_zod9.z.boolean().optional(),
-        reason: import_zod9.z.string().optional().describe("Why this chat is stopping. Stored on the thread for the next session.")
+        ref: import_zod10.z.string(),
+        force: import_zod10.z.boolean().optional(),
+        reason: import_zod10.z.string().optional().describe("Why this chat is stopping. Stored on the thread for the next session.")
       },
       async ({ ref, force, reason }) => {
         const t = orch.getThread(ref);
@@ -32581,7 +32958,7 @@ async function startMcpServer() {
     server.tool(
       "archive_chat",
       "Archive a thread (stops agent/dev, runs archive script, removes worktree when last chat tab). Coordinators commit, push, and open PRs by asking the worktree agent (ask_git). Merge only when the user explicitly asked.",
-      { ref: import_zod9.z.string() },
+      { ref: import_zod10.z.string() },
       async ({ ref }) => {
         const t = orch.getThread(ref);
         if (!t) {
@@ -32607,7 +32984,7 @@ async function startMcpServer() {
     server.tool(
       "restore_chat",
       "Restore an archived thread (recreates worktree from branch when needed)",
-      { ref: import_zod9.z.string() },
+      { ref: import_zod10.z.string() },
       async ({ ref }) => {
         try {
           const restored = await orch.restore(ref);
@@ -32626,8 +33003,8 @@ async function startMcpServer() {
       "get_diff",
       "Compact diff summary (capped hunks, paginated)",
       {
-        ref: import_zod9.z.string(),
-        maxFiles: import_zod9.z.number().optional()
+        ref: import_zod10.z.string(),
+        maxFiles: import_zod10.z.number().optional()
       },
       async ({ ref, maxFiles }) => {
         const summary = await orch.diffSummary(ref);
@@ -32640,7 +33017,7 @@ async function startMcpServer() {
     server.tool(
       "get_pr_checks",
       "Snapshot of GitHub PR checks for a worktree thread (`gh pr checks` plus merge/review gates). null = no PR. If the user gave a goal (Greptile 5/5, CI green), the worktree agent watches with `gh pr checks --watch` via /long-running \u2014 this tool is a snapshot, not a waiter. Coordinators: do not run gh from the orchestration cwd.",
-      { ref: import_zod9.z.string().describe("Worktree thread id/ref") },
+      { ref: import_zod10.z.string().describe("Worktree thread id/ref") },
       async ({ ref }) => {
         try {
           const checks = await orch.getPrChecks(ref);
@@ -32654,7 +33031,7 @@ async function startMcpServer() {
     server.tool(
       "request_review",
       'Start a merge-readiness Review on a worktree agent thread (same as the desktop Review button). If that worktree has a single unused idle agent (no messages), runs the review there; otherwise opens a new Review chat tab. Attaches .claude/skills/review/SKILL.md when present (else copies .sideboard/review.md into .context/review.md, or seeds that file from the stock template), and sends "Review changes in this workspace." Expect Approve / Approve with nits / Request changes / Needs more information in that chat. The review stays there so the user can read it and type next steps \u2014 do not comment on or update the PR or ticket, and do not ask_user after the review, until they ask. Pass a worktree thread ref \u2014 not the orchestrator. Then wait_for_turn (loop while stillRunning) / get_turn_result on the returned review thread id.',
-      { ref: import_zod9.z.string().describe("Worktree thread id/ref to review") },
+      { ref: import_zod10.z.string().describe("Worktree thread id/ref to review") },
       async ({ ref }) => {
         try {
           const tab = await orch.requestReview(ref);
@@ -32676,8 +33053,8 @@ async function startMcpServer() {
       "ask_git",
       "Commit & push, open a draft PR, mark ready for review, resolve conflicts, or merge \u2014 same prompts as the desktop git buttons (including Resolve). Always steers the worktree agent; does not push or open the PR locally. Then wait_for_turn (loop while stillRunning). Do not start a checks loop on a plain push \u2014 only if the user gave a goal (Greptile 5/5, CI green). Pass a worktree thread ref (not the orchestrator). action=ready-for-review and action=merge only when the user explicitly asked (or clicked the desktop button). Do not run git or gh from the orchestration cwd.",
       {
-        ref: import_zod9.z.string().describe("Worktree thread id/ref"),
-        action: import_zod9.z.enum(AGENT_GIT_ACTIONS).describe(
+        ref: import_zod10.z.string().describe("Worktree thread id/ref"),
+        action: import_zod10.z.enum(AGENT_GIT_ACTIONS).describe(
           "commit-push | create-draft | create-web | resolve-conflicts | ready-for-review | merge"
         )
       },
@@ -32706,7 +33083,7 @@ async function startMcpServer() {
         }
       }
     );
-    const agentEnum = import_zod9.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]);
+    const agentEnum = import_zod10.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]);
     server.tool(
       "list_models",
       "List models for an agent. Prefer Auto: do not call this unless you have a reason to pin a specific model (user request, cost/latency, capability). Omit agent to list all.",
@@ -32727,11 +33104,11 @@ async function startMcpServer() {
       "fork_workspace",
       "Fork a worktree agent chat into a NEW git worktree + chat (desktop \u201CFork to new workspace\u201D). Seeds a transcript (through through_index, default all). Optional agent override. Leave model unset for Auto (default) \u2014 only pass model when you have a reason. Not for the orchestrator. Then send_to_chat / wait_for_turn (loop while stillRunning) on the returned id.",
       {
-        ref: import_zod9.z.string().describe("Worktree thread id/ref to fork"),
-        through_index: import_zod9.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
+        ref: import_zod10.z.string().describe("Worktree thread id/ref to fork"),
+        through_index: import_zod10.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
         agent: agentEnum.optional().describe("Agent for the forked chat (default: same as source)"),
-        model: import_zod9.z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
-        title: import_zod9.z.string().optional()
+        model: import_zod10.z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
+        title: import_zod10.z.string().optional()
       },
       async ({ ref, through_index, agent, model, title }) => {
         try {
@@ -32765,11 +33142,11 @@ async function startMcpServer() {
       "fork_chat",
       "Add another agent chat on the SAME workspace (same files, Run, and git). Also forks a Global orchestration chat into a new orchestration tab. Pass agent when the new chat should use a different harness. Leave model unset for Auto unless you have a reason. Orchestration forks require an MCP-capable agent (claude, cursor, codex, opencode \u2014 not brightsy). Use this for a second agent on a checkout (review, another harness, parallel work on the same branch). Do not create_workspace again for that \u2014 it returns the existing checkout. Then send_to_chat / wait_for_turn (loop while stillRunning) on the returned id. Use fork_workspace only when the work needs its own git checkout.",
       {
-        ref: import_zod9.z.string().describe("Thread id/ref to fork (worktree agent or orchestration chat)"),
-        through_index: import_zod9.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
+        ref: import_zod10.z.string().describe("Thread id/ref to fork (worktree agent or orchestration chat)"),
+        through_index: import_zod10.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
         agent: agentEnum.optional().describe("Agent for the forked chat (default: same as source)"),
-        model: import_zod9.z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
-        title: import_zod9.z.string().optional()
+        model: import_zod10.z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
+        title: import_zod10.z.string().optional()
       },
       async ({ ref, through_index, agent, model, title }) => {
         try {
@@ -32807,7 +33184,7 @@ async function startMcpServer() {
     server.tool(
       "run_setup",
       "Re-run workspace setup (Sideboard/Conductor settings, .cursor/worktrees.json, or script/setup). New worktrees already run this automatically.",
-      { ref: import_zod9.z.string() },
+      { ref: import_zod10.z.string() },
       async ({ ref }) => {
         const result = await orch.runSetup(ref);
         return mcpJson(result);
@@ -32816,7 +33193,7 @@ async function startMcpServer() {
     server.tool(
       "add_project",
       "Register a git repo as a Sideboard workspace",
-      { repoPath: import_zod9.z.string() },
+      { repoPath: import_zod10.z.string() },
       async ({ repoPath }) => {
         const ws = await orch.addWorkspace(repoPath);
         return mcpJson(ws);
@@ -32825,7 +33202,7 @@ async function startMcpServer() {
     server.tool(
       "remove_project",
       "Unregister a Sideboard workspace and archive its chats",
-      { repoPath: import_zod9.z.string() },
+      { repoPath: import_zod10.z.string() },
       async ({ repoPath }) => {
         await orch.removeWorkspace(repoPath);
         return { content: [{ type: "text", text: "ok" }] };
@@ -32835,12 +33212,12 @@ async function startMcpServer() {
       "fanout",
       "Best-of-n: create one thread per agent with the same prompt (parallel attempts)",
       {
-        prompt: import_zod9.z.string(),
-        agents: import_zod9.z.array(import_zod9.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"])),
-        repoPath: import_zod9.z.string(),
-        sourceType: import_zod9.z.enum(["branch", "pr", "ticket"]).optional(),
-        sourceRef: import_zod9.z.string().optional(),
-        title: import_zod9.z.string().optional()
+        prompt: import_zod10.z.string(),
+        agents: import_zod10.z.array(import_zod10.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"])),
+        repoPath: import_zod10.z.string(),
+        sourceType: import_zod10.z.enum(["branch", "pr", "ticket"]).optional(),
+        sourceRef: import_zod10.z.string().optional(),
+        title: import_zod10.z.string().optional()
       },
       async (args) => {
         const threads = await orch.bestOfN(args);
@@ -32858,8 +33235,8 @@ async function startMcpServer() {
       "list_branches",
       "List git branches in a registered workspace. Pass repoPath from list_projects (unmerged into the default branch by default \u2014 for create_workspace sourceType=branch).",
       {
-        repoPath: import_zod9.z.string(),
-        unmergedOnly: import_zod9.z.boolean().optional()
+        repoPath: import_zod10.z.string(),
+        unmergedOnly: import_zod10.z.boolean().optional()
       },
       async ({ repoPath, unmergedOnly }) => {
         const root = await resolveRepoRoot(repoPath);
@@ -32880,19 +33257,19 @@ async function startMcpServer() {
       "list_prs",
       `List GitHub PRs for a registered workspace (the review surface for assigned ticket work \u2014 not the tickets). Pass repoPath from list_projects. "Get me N tickets to review" \u2192 queue=review and limit=N: open non-draft PRs labeled with this project's ready-for-review GitHub label (Settings \u2192 Projects; default eng-review) with no individual user reviewer. Prefer teams that match Settings \u2192 Agents / Projects roles for this repo. A team like engineering-team is not a claim (you are on that team). Also: state (open|closed|merged|all|review), label, reviewer (me|unassigned|login), query, limit (default 40, max 250). Then create_workspace with sourceType=pr.`,
       {
-        repoPath: import_zod9.z.string(),
-        query: import_zod9.z.string().optional().describe("GitHub search tokens (title, draft:true, \u2026)"),
-        queue: import_zod9.z.enum(["review", "mine", "approved", "changes"]).optional().describe(
+        repoPath: import_zod10.z.string(),
+        query: import_zod10.z.string().optional().describe("GitHub search tokens (title, draft:true, \u2026)"),
+        queue: import_zod10.z.enum(["review", "mine", "approved", "changes"]).optional().describe(
           "review = unclaimed ready-for-review inbox (Settings \u2192 Projects label, default eng-review). mine = review-requested:@me. approved / changes = eng-approved / eng-requested-changes."
         ),
-        state: import_zod9.z.enum(["open", "closed", "merged", "all", "review"]).optional().describe("GitHub PR state (default open). review is an alias for queue=review."),
-        label: import_zod9.z.string().optional().describe(
+        state: import_zod10.z.enum(["open", "closed", "merged", "all", "review"]).optional().describe("GitHub PR state (default open). review is an alias for queue=review."),
+        label: import_zod10.z.string().optional().describe(
           "GitHub label / workflow tag. Comma-separated AND. Examples: eng-review, eng-approved, eng-requested-changes"
         ),
-        reviewer: import_zod9.z.string().optional().describe(
+        reviewer: import_zod10.z.string().optional().describe(
           "me (review requested of you), unassigned (no individual reviewer; team queues like engineering-team still count), all, or a GitHub login"
         ),
-        limit: import_zod9.z.number().int().positive().max(250).optional().describe("Page size (default 40, max 250). Raise when truncated is true.")
+        limit: import_zod10.z.number().int().positive().max(250).optional().describe("Page size (default 40, max 250). Raise when truncated is true.")
       },
       async ({ repoPath, query, queue, state, label, reviewer, limit }) => {
         const root = await resolveRepoRoot(repoPath);
@@ -32925,7 +33302,7 @@ async function startMcpServer() {
     server.tool(
       "get_pr_stack",
       "Load the GitHub PR stack for a thread worktree (`gh stack view --json`). Returns null JSON when the branch is not stacked. Prefer this before ask_git merge on stacked PRs (and only merge when the user explicitly asked).",
-      { ref: import_zod9.z.string() },
+      { ref: import_zod10.z.string() },
       async ({ ref }) => {
         const stack = await orch.getPrStack(ref);
         return mcpJson(stack);
@@ -32935,8 +33312,8 @@ async function startMcpServer() {
       "open_pr_stack_layers",
       "Materialize one worktree+thread per stack layer (or a single 1-based layer). Pass a thread ref already on the stack.",
       {
-        ref: import_zod9.z.string(),
-        layer: import_zod9.z.number().int().positive().optional()
+        ref: import_zod10.z.string(),
+        layer: import_zod10.z.number().int().positive().optional()
       },
       async ({ ref, layer }) => {
         const result = await orch.openPrStackLayers(ref, { layer });
@@ -32959,9 +33336,9 @@ async function startMcpServer() {
       "add_stack_layer",
       "Add a branch on top of the current stack (`gh stack add`) and open a worktree+thread for it.",
       {
-        ref: import_zod9.z.string(),
-        branchName: import_zod9.z.string(),
-        title: import_zod9.z.string().optional()
+        ref: import_zod10.z.string(),
+        branchName: import_zod10.z.string(),
+        title: import_zod10.z.string().optional()
       },
       async ({ ref, branchName, title }) => {
         const result = await orch.addStackLayer(ref, branchName, { title });
@@ -32979,11 +33356,11 @@ async function startMcpServer() {
       "create_pr_stack",
       "Create a new GitHub PR stack with one Sideboard worktree per layer (bottom\u2192top branch names). Requires `gh extension install github/gh-stack`.",
       {
-        repoPath: import_zod9.z.string(),
-        branches: import_zod9.z.array(import_zod9.z.string()).min(1),
-        agent: import_zod9.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]),
-        base: import_zod9.z.string().optional(),
-        title: import_zod9.z.string().optional()
+        repoPath: import_zod10.z.string(),
+        branches: import_zod10.z.array(import_zod10.z.string()).min(1),
+        agent: import_zod10.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]),
+        base: import_zod10.z.string().optional(),
+        title: import_zod10.z.string().optional()
       },
       async (args) => {
         const result = await orch.createPrStack({
@@ -33011,10 +33388,10 @@ async function startMcpServer() {
       "list_issues",
       "List or search issues (Linear, AbleTime, or GitHub; falls back to GitHub). Use Settings \u2192 Agents / Projects notes and roles to pick tickets relevant to the viewer (query + assignee=me or unassigned as the notes say). Default 40; pass query and/or limit (max 250) when truncated. assignee: me (Linear default), unassigned, all, or a user id. Pass updatedSince for new/updated tickets and new comments (\u201Cany updates since yesterday?\u201D). Then create_workspace with sourceType=ticket.",
       {
-        repoPath: import_zod9.z.string(),
-        query: import_zod9.z.string().optional().describe("Search title, identifier, or description"),
-        assignee: import_zod9.z.string().optional().describe("me (Linear default), unassigned, all, a user id, or a GitHub login"),
-        limit: import_zod9.z.number().int().positive().max(250).optional().describe("Page size (default 40, max 250). Raise when truncated is true."),
+        repoPath: import_zod10.z.string(),
+        query: import_zod10.z.string().optional().describe("Search title, identifier, or description"),
+        assignee: import_zod10.z.string().optional().describe("me (Linear default), unassigned, all, a user id, or a GitHub login"),
+        limit: import_zod10.z.number().int().positive().max(250).optional().describe("Page size (default 40, max 250). Raise when truncated is true."),
         updatedSince: mcpIssueUpdatedSinceSchema
       },
       async ({ repoPath, query, assignee, limit, updatedSince }) => {