@sideboard-ai/core 0.1.74 → 0.1.77

package/dist/mcp/run-stdio.js

@@ -16,19 +16,22 @@ import {
   resolveQuotaFallbackAgent,
   sideboardMcpProfile,
   summarizeTurnStderr
-} from "../chunk-KBKPVKYZ.js";
+} from "../chunk-2FJI5JXX.js";
 import "../chunk-VROPG6QF.js";
 import {
   addWorkspace,
   ensureWorkspace,
   removeWorkspace,
   syncWorkspacesFromThreads
-} from "../chunk-GJ2LZQJI.js";
+} from "../chunk-2ZIPJRJE.js";
 import {
   extractPresentedPlan,
   readPlanFile,
   writePlanFile
 } from "../chunk-N5PM7HGQ.js";
+import {
+  releaseCaffeinateHoldForThread
+} from "../chunk-RV6DBEDQ.js";
 import {
   GLOBAL_WORKSPACE_ID,
   assertOrchestratorCapableAgent,
@@ -38,14 +41,14 @@ import {
   isGlobalThread,
   isOrchestratorThread,
   orchestratorSessionPoisonedByBuiltins
-} from "../chunk-2NKSHIRI.js";
+} from "../chunk-GWTLKXXP.js";
 import {
   SLACK_REPLY_FORMATTING,
   coordinatorSystemPrompt,
   coordinatorTurnReminder,
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd
-} from "../chunk-XA2FQJTN.js";
+} from "../chunk-XJNCWYFR.js";
 import {
   addPrStackLayer,
   allocateTeamName,
@@ -140,7 +143,7 @@ import {
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 import { basename as basename4 } from "path";
 
 // src/orchestrator/orchestrator.ts
@@ -341,8 +344,8 @@ ${input.permalink}` : "";
 
 ${body}${link}`;
 }
-function isSlackExternalReplyPrompt(text2) {
-  return text2.startsWith("Slack reply from ") && text2.includes("not a command");
+function isSlackExternalReplyPrompt(text3) {
+  return text3.startsWith("Slack reply from ") && text3.includes("not a command");
 }
 function pendingSlackExternalReplies(messages) {
   let i = messages.length - 1;
@@ -366,9 +369,9 @@ function formatSlackRepliesForTurn(replies) {
 function listSlackOutboundWatches() {
   return pruneWatches(readStore3());
 }
-function formatOwnerSlackFyi(userName, text2) {
+function formatOwnerSlackFyi(userName, text3) {
   const who = userName.trim() || "Someone";
-  const body = text2.trim() || "(no text)";
+  const body = text3.trim() || "(no text)";
   return `${who} replied in Slack:
 ${body}`;
 }
@@ -383,7 +386,7 @@ async function relayExternalReply(opts) {
   const thread = readThread(threadId);
   if (!thread || thread.status === "archived") return true;
   try {
-    const text2 = formatSlackExternalReplyPrompt({
+    const text3 = formatSlackExternalReplyPrompt({
       userName: opts.reply.userName,
       kind: opts.watch.kind,
       toLabel: opts.watch.toLabel,
@@ -392,7 +395,7 @@ async function relayExternalReply(opts) {
     });
     appendMessage(threadId, {
       role: "agent",
-      text: text2,
+      text: text3,
       ts: (/* @__PURE__ */ new Date()).toISOString()
     });
   } catch {
@@ -576,7 +579,7 @@ async function refreshSlackReplyBadges(opts) {
     const messages = await fetchMessages(token, watch, opts?.fetchImpl);
     const replies = messages.filter((m) => isHumanReply(m, watch)).sort((a, b) => Number(a.ts) - Number(b.ts));
     if (replies.length === 0) continue;
-    const injected = new Set(watch.injectedReplyTs ?? []);
+    const injected2 = new Set(watch.injectedReplyTs ?? []);
     const collected = [...watch.replies ?? []];
     let lastSeenTs = watch.lastSeenTs;
     let latestUser;
@@ -610,7 +613,7 @@ async function refreshSlackReplyBadges(opts) {
       latestName = replyUserName;
       latestText = reply.text;
       latestPermalink = permalink;
-      if (injected.has(ts)) {
+      if (injected2.has(ts)) {
         lastSeenTs = ts;
         continue;
       }
@@ -621,7 +624,7 @@ async function refreshSlackReplyBadges(opts) {
         fetchImpl: opts?.fetchImpl
       });
       if (!delivered) break;
-      injected.add(ts);
+      injected2.add(ts);
       lastSeenTs = ts;
     }
     watches[i] = {
@@ -633,7 +636,7 @@ async function refreshSlackReplyBadges(opts) {
       replyTs: lastSeenTs,
       replyPreview: latestText.slice(0, 140),
       permalink: latestPermalink,
-      injectedReplyTs: [...injected],
+      injectedReplyTs: [...injected2],
       replies: collected.slice(-MAX_REPLIES_PER_WATCH)
     };
     changed = true;
@@ -723,9 +726,9 @@ function toolFilePath(input) {
   if (!input) return void 0;
   return str(input.file_path) ?? str(input.path) ?? str(input.filePath) ?? str(input.filename);
 }
-function countLines(text2) {
-  if (!text2) return 0;
-  return text2.split("\n").length;
+function countLines(text3) {
+  if (!text3) return 0;
+  return text3.split("\n").length;
 }
 function diffFromInput(input) {
   if (!input) return {};
@@ -852,9 +855,9 @@ function applyAgentEvent(parts, event) {
 function partsToAssistantText(parts) {
   return parts.filter((p) => p.type === "text").map((p) => p.text).join("").trim();
 }
-function stripBrightsyNdjsonNoise(text2) {
-  if (!text2 || !text2.includes('"type"')) return text2;
-  let out = text2;
+function stripBrightsyNdjsonNoise(text3) {
+  if (!text3 || !text3.includes('"type"')) return text3;
+  let out = text3;
   out = out.replace(
     /\{"type":"(?:tool_use|tool_result|tool|thinking|usage|done|error)"[\s\S]*?\}\s*(?=\{"type":"|$|(?=[A-Za-z*#]))/g,
     ""
@@ -913,9 +916,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("../global-workspace-PJU6HISJ.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("../global-workspace-TWHMYLTZ.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("../coordinator-prompt-RTUCCPCI.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("../coordinator-prompt-MRCMMRSF.js");
     ensureGlobalCoordinatorCwd2(
       isOrchestratorThread(thread) ? { orchestratorThreadId: thread.id } : void 0
     );
@@ -1002,8 +1005,8 @@ async function spawnAgentTurn(thread, input, onEvent) {
     onEvent({ type: "exit", data: exitCode });
     const finalized = finalizeParts(parts);
     const rawText = assistantText.trim() || partsToAssistantText(finalized);
-    const text2 = thread.agent === "brightsy" ? stripBrightsyNdjsonNoise(rawText) : rawText;
-    return { exitCode, sessionId, assistantText: text2, parts: finalized, usage };
+    const text3 = thread.agent === "brightsy" ? stripBrightsyNdjsonNoise(rawText) : rawText;
+    return { exitCode, sessionId, assistantText: text3, parts: finalized, usage };
   });
   return {
     pid: child.pid,
@@ -1756,7 +1759,7 @@ async function createThread(input, _onSetupLine) {
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("../agents-2S2JVLZ6.js");
+  const { getAdapter: getAdapter2 } = await import("../agents-LKUHPPEQ.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -1812,9 +1815,9 @@ async function tryClaudeSummary(transcript, opts) {
       { cwd: opts?.cwd, reject: false }
     );
     if (exitCode !== 0) return null;
-    const text2 = stdout.trim();
-    if (text2.length < 40) return null;
-    return text2;
+    const text3 = stdout.trim();
+    if (text3.length < 40) return null;
+    return text3;
   } catch {
     return null;
   }
@@ -1863,9 +1866,9 @@ function extractiveSummary(transcript) {
   );
   return parts.join("\n");
 }
-function clipSummary(text2) {
-  if (text2.length <= MAX_SUMMARY_CHARS) return text2;
-  return `${text2.slice(0, MAX_SUMMARY_CHARS)}
+function clipSummary(text3) {
+  if (text3.length <= MAX_SUMMARY_CHARS) return text3;
+  return `${text3.slice(0, MAX_SUMMARY_CHARS)}
 
 [\u2026summary truncated\u2026]`;
 }
@@ -2478,8 +2481,8 @@ function buildQuotaHandoffAttachment(from, limitText, fallbackAgent) {
   );
   const recent = from.messages.slice(-8).map((m) => {
     const role = m.role === "user" ? "User" : m.role === "agent" ? "Agent" : "Summary";
-    const text2 = m.text.trim().replace(/\s+/g, " ").slice(0, 280);
-    return text2 ? `- ${role}: ${text2}` : null;
+    const text3 = m.text.trim().replace(/\s+/g, " ").slice(0, 280);
+    return text3 ? `- ${role}: ${text3}` : null;
   }).filter(Boolean);
   const body = [
     `# Orchestration handoff`,
@@ -2575,13 +2578,13 @@ function resolveConductorCursorAgentId(workspacePath) {
   for (const hash of hashes) {
     const agentsFile = join9(CURSOR_SDK_STORE, hash, "agents.ndjson");
     if (!existsSync9(agentsFile)) continue;
-    let text2;
+    let text3;
     try {
-      text2 = readFileSync6(agentsFile, "utf8");
+      text3 = readFileSync6(agentsFile, "utf8");
     } catch {
       continue;
     }
-    for (const line of text2.split("\n")) {
+    for (const line of text3.split("\n")) {
       const trimmed = line.trim();
       if (!trimmed) continue;
       try {
@@ -2620,7 +2623,7 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-L4TXMUNM.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-GQ4XKBD3.js");
   await ensureWorkspace2(repoPath);
   return thread;
 }
@@ -3344,13 +3347,13 @@ function formatStat(files) {
   return `${n} file${n === 1 ? "" : "s"} changed, ${additions} insertions(+), ${deletions} deletions(-)`;
 }
 function emptyScopeStats() {
-  const z3 = emptyStat();
+  const z4 = emptyStat();
   return {
-    commits: z3,
-    uncommitted: z3,
-    staged: z3,
-    unstaged: z3,
-    last_turn: z3
+    commits: z4,
+    uncommitted: z4,
+    staged: z4,
+    unstaged: z4,
+    last_turn: z4
   };
 }
 function filesFromDiff(nameStatus, numstat, combinedDiff, maxHunk) {
@@ -4897,11 +4900,11 @@ var Orchestrator = class {
     return results;
   }
   /** Edit the text of a not-yet-started queued message. */
-  async editQueuedMessage(threadRef, index, text2) {
+  async editQueuedMessage(threadRef, index, text3) {
     const thread = this.requireThread(threadRef);
     return withThreadLock(thread.id, async () => {
       const current = this.requireThread(thread.id);
-      const trimmed = text2.trim();
+      const trimmed = text3.trim();
       if (!trimmed || index < 0 || index >= current.queue.length) {
         return current;
       }
@@ -5661,6 +5664,14 @@ var Orchestrator = class {
       throw new Error(`${action} is not available on the global coordinator`);
     }
   }
+  /** MCP set_caffeinate is a detached hold — closing the chat must not leave the Mac awake. */
+  releaseOrchestratorCaffeinate(thread) {
+    if (!isOrchestratorThread(thread)) return;
+    try {
+      releaseCaffeinateHoldForThread(thread.id);
+    } catch {
+    }
+  }
   async diff(threadRef, opts) {
     const thread = this.requireThread(threadRef);
     this.assertNotGlobal(thread, "Diff");
@@ -6030,6 +6041,7 @@ var Orchestrator = class {
   async archive(threadRef) {
     const thread = this.requireThread(threadRef);
     this.stop(thread.id);
+    this.releaseOrchestratorCaffeinate(thread);
     if (isGlobalThread(thread)) {
       const archived2 = setStatus(thread.id, "archived");
       this.emit({ type: "status_changed", threadId: archived2.id, status: "archived" });
@@ -6054,7 +6066,7 @@ var Orchestrator = class {
     this.emit({ type: "status_changed", threadId: archived.id, status: "archived" });
     if (thread.repoPath && !isGlobalRepoPath(thread.repoPath)) {
       try {
-        const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-L4TXMUNM.js");
+        const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-GQ4XKBD3.js");
         await ensureWorkspace2(thread.repoPath);
       } catch {
       }
@@ -6064,6 +6076,7 @@ var Orchestrator = class {
   async purge(threadRef, opts) {
     const thread = this.requireThread(threadRef);
     this.stop(thread.id);
+    this.releaseOrchestratorCaffeinate(thread);
     if (isGlobalThread(thread)) {
       deleteThreadRecord(thread.id);
       return;
@@ -6168,13 +6181,36 @@ function getOrchestrator() {
   return singleton;
 }
 
+// src/http/fetch.ts
+var injected = null;
+function formatFetchError(err, url) {
+  if (!(err instanceof Error)) return `${String(err)} (${url})`;
+  const cause = err.cause;
+  let detail = "";
+  if (cause instanceof Error) {
+    const code = typeof cause.code === "string" ? cause.code : void 0;
+    detail = code ? ` [${code}: ${cause.message}]` : ` [${cause.message}]`;
+  } else if (cause != null) {
+    detail = ` [${String(cause)}]`;
+  }
+  return `${err.message}${detail} (${url})`;
+}
+async function httpFetch(input, init) {
+  const url = typeof input === "string" ? input : input.href;
+  const fn = injected ?? globalThis.fetch.bind(globalThis);
+  try {
+    return await fn(url, init);
+  } catch (err) {
+    throw new Error(formatFetchError(err, url));
+  }
+}
+
 // src/integrations/linear-oauth.ts
 import { createHash, randomBytes } from "crypto";
 import { createServer as createServer2 } from "http";
 
 // src/integrations/linear-app.ts
 var BAKED_LINEAR_CLIENT_ID = "39a15abc7ea5bea17c47f47f85ff5fd0";
-var BAKED_LINEAR_CLIENT_SECRET = "";
 
 // src/integrations/linear-oauth.ts
 var LINEAR_OAUTH_PORT = 19848;
@@ -6184,7 +6220,7 @@ var REFRESH_SKEW_MS = 5 * 6e4;
 function linearOAuthCredentials() {
   const settings = loadAppSettings();
   const clientId = process.env.SIDEBOARD_LINEAR_CLIENT_ID?.trim() || settings.integrations.linearClientId?.trim() || BAKED_LINEAR_CLIENT_ID.trim();
-  const clientSecret = process.env.SIDEBOARD_LINEAR_CLIENT_SECRET?.trim() || settings.integrations.linearClientSecret?.trim() || BAKED_LINEAR_CLIENT_SECRET.trim();
+  const clientSecret = process.env.SIDEBOARD_LINEAR_CLIENT_SECRET?.trim() || settings.integrations.linearClientSecret?.trim() || "";
   if (!clientId) {
     throw new Error(
       `Linear browser sign-in needs a Linear OAuth app Client ID. Create one at linear.app/settings/api/applications/new with callback ${LINEAR_OAUTH_REDIRECT}, then set SIDEBOARD_LINEAR_CLIENT_ID (PKCE does not require a secret). You can still paste a personal API key.`
@@ -6200,7 +6236,7 @@ function linearAuthorizationHeader(token) {
   return `Bearer ${t}`;
 }
 async function exchangeLinearToken(body) {
-  const res = await fetch(LINEAR_TOKEN, {
+  const res = await httpFetch(LINEAR_TOKEN, {
     method: "POST",
     headers: { "Content-Type": "application/x-www-form-urlencoded" },
     body
@@ -6267,6 +6303,18 @@ async function getLinearAuthToken(settings = loadAppSettings()) {
 
 // src/integrations/linear.ts
 var LINEAR_GRAPHQL = "https://api.linear.app/graphql";
+var ISSUE_FIELDS = `
+  id
+  identifier
+  title
+  description
+  url
+  priority
+  state { id name type }
+  assignee { id name }
+  team { id key name states { nodes { id name type } } }
+  labels { nodes { name } }
+`;
 var ASSIGNED_ISSUES_QUERY = `
 query SideboardAssignedIssues($first: Int!) {
   viewer {
@@ -6275,53 +6323,280 @@ query SideboardAssignedIssues($first: Int!) {
       orderBy: updatedAt
       filter: { state: { type: { nin: ["completed", "canceled"] } } }
     ) {
-      nodes {
-        id
-        identifier
-        title
-        url
-        labels { nodes { name } }
-      }
+      nodes { ${ISSUE_FIELDS} }
     }
   }
 }
 `;
-async function listLinearIssuesDirect(opts) {
-  const apiKey = (opts?.apiKey ?? await getLinearAuthToken())?.trim();
-  if (!apiKey) {
+var TEAMS_QUERY = `
+query SideboardTeams {
+  viewer { id name }
+  teams(first: 50) {
+    nodes {
+      id
+      key
+      name
+      states { nodes { id name type } }
+    }
+  }
+}
+`;
+var ISSUE_QUERY = `
+query SideboardIssue($id: String!) {
+  issue(id: $id) { ${ISSUE_FIELDS} }
+}
+`;
+var ISSUE_CREATE = `
+mutation SideboardIssueCreate($input: IssueCreateInput!) {
+  issueCreate(input: $input) {
+    success
+    issue { ${ISSUE_FIELDS} }
+  }
+}
+`;
+var ISSUE_UPDATE = `
+mutation SideboardIssueUpdate($id: String!, $input: IssueUpdateInput!) {
+  issueUpdate(id: $id, input: $input) {
+    success
+    issue { ${ISSUE_FIELDS} }
+  }
+}
+`;
+var COMMENT_CREATE = `
+mutation SideboardCommentCreate($input: CommentCreateInput!) {
+  commentCreate(input: $input) {
+    success
+    comment { id body url }
+  }
+}
+`;
+function rewriteLinearError(message) {
+  if (/scope|permission|not (authorized|allowed)|unauthorized|insufficient/i.test(message)) {
+    return `${message} \u2014 Disconnect and Connect Linear in Account settings to grant write access.`;
+  }
+  return message;
+}
+async function requireLinearToken(apiKey) {
+  const token = (apiKey ?? await getLinearAuthToken())?.trim();
+  if (!token) {
     throw new Error("Linear is not connected \u2014 sign in from Account settings");
   }
-  const first = Math.max(1, Math.min(100, opts?.limit ?? 50));
-  const res = await fetch(LINEAR_GRAPHQL, {
+  return token;
+}
+async function linearGraphql(query, variables, opts) {
+  const apiKey = await requireLinearToken(opts?.apiKey);
+  const res = await httpFetch(LINEAR_GRAPHQL, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
       Authorization: linearAuthorizationHeader(apiKey)
     },
-    body: JSON.stringify({
-      query: ASSIGNED_ISSUES_QUERY,
-      variables: { first }
-    })
+    body: JSON.stringify({ query, variables })
   });
   if (!res.ok) {
     const body = await res.text().catch(() => "");
     throw new Error(
-      `Linear API error ${res.status}${body ? `: ${body.slice(0, 200)}` : ""}`
+      rewriteLinearError(
+        `Linear API error ${res.status}${body ? `: ${body.slice(0, 200)}` : ""}`
+      )
     );
   }
   const json = await res.json();
   if (json.errors?.length) {
-    throw new Error(json.errors.map((e) => e.message ?? "Linear error").join("; "));
+    throw new Error(
+      rewriteLinearError(json.errors.map((e) => e.message ?? "Linear error").join("; "))
+    );
   }
-  const nodes = json.data?.viewer?.assignedIssues?.nodes ?? [];
-  return nodes.map((node) => ({
+  if (json.data == null) {
+    throw new Error("Linear API returned no data");
+  }
+  return json.data;
+}
+function mapState(node) {
+  if (!node?.id) return void 0;
+  return {
+    id: String(node.id),
+    name: String(node.name ?? ""),
+    type: String(node.type ?? "")
+  };
+}
+function mapIssue(node) {
+  const team = node.team;
+  return {
     id: String(node.id ?? node.identifier ?? ""),
     identifier: String(node.identifier ?? node.id ?? ""),
     title: String(node.title ?? ""),
     url: String(node.url ?? ""),
-    labels: (node.labels?.nodes ?? []).map((l) => l.name).filter((n) => Boolean(n)),
+    description: node.description?.trim() || void 0,
+    priority: typeof node.priority === "number" ? node.priority : void 0,
+    state: mapState(node.state),
+    assignee: node.assignee?.id ? { id: String(node.assignee.id), name: String(node.assignee.name ?? "") } : void 0,
+    team: team?.id ? {
+      id: String(team.id),
+      key: String(team.key ?? ""),
+      name: String(team.name ?? ""),
+      states: (team.states?.nodes ?? []).map((s) => mapState(s)).filter((s) => Boolean(s))
+    } : void 0,
+    labels: (node.labels?.nodes ?? []).map((l) => l.name).filter((n) => Boolean(n))
+  };
+}
+function toIssueInfo(issue) {
+  return {
+    id: issue.id,
+    identifier: issue.identifier,
+    title: issue.title,
+    url: issue.url,
+    labels: issue.labels,
     provider: "linear"
-  }));
+  };
+}
+function mapTeam(node) {
+  return {
+    id: String(node.id ?? ""),
+    key: String(node.key ?? ""),
+    name: String(node.name ?? ""),
+    states: (node.states?.nodes ?? []).map((s) => mapState(s)).filter((s) => Boolean(s))
+  };
+}
+function resolveLinearTeam(teams, team) {
+  const t = team.trim();
+  if (!t) throw new Error("Linear team is required (id, key, or name from linear_list_teams)");
+  const lower = t.toLowerCase();
+  const found = teams.find(
+    (x) => x.id === t || x.key.toLowerCase() === lower || x.name.toLowerCase() === lower
+  );
+  if (!found) {
+    const keys = teams.map((x) => x.key).filter(Boolean).join(", ") || "(none)";
+    throw new Error(`Linear team not found: ${team}. Known keys: ${keys}`);
+  }
+  return found;
+}
+function resolveLinearState(team, state) {
+  const s = state.trim();
+  if (!s) throw new Error("Linear state is empty");
+  const lower = s.toLowerCase();
+  const found = team.states.find((x) => x.id === s) || team.states.find((x) => x.name.toLowerCase() === lower) || team.states.find((x) => x.type.toLowerCase() === lower);
+  if (!found) {
+    const available = team.states.map((x) => `${x.name} (${x.type})`).join(", ") || "(none)";
+    throw new Error(`Linear state not found on ${team.key}: ${state}. Available: ${available}`);
+  }
+  return found;
+}
+function normalizePriority(priority) {
+  if (priority == null) return void 0;
+  if (!Number.isInteger(priority) || priority < 0 || priority > 4) {
+    throw new Error("Linear priority must be 0 (none), 1 (urgent), 2 (high), 3 (medium), or 4 (low)");
+  }
+  return priority;
+}
+async function listLinearIssuesDirect(opts) {
+  const first = Math.max(1, Math.min(100, opts?.limit ?? 50));
+  const json = await linearGraphql(ASSIGNED_ISSUES_QUERY, { first }, opts);
+  return (json.viewer?.assignedIssues?.nodes ?? []).map((node) => toIssueInfo(mapIssue(node)));
+}
+async function listLinearTeams(opts) {
+  const json = await linearGraphql(TEAMS_QUERY, void 0, opts);
+  return {
+    viewer: {
+      id: String(json.viewer?.id ?? ""),
+      name: String(json.viewer?.name ?? "")
+    },
+    teams: (json.teams?.nodes ?? []).map(mapTeam)
+  };
+}
+async function getLinearIssue(id, opts) {
+  const issueId = id.trim();
+  if (!issueId) throw new Error("Linear issue id is required (uuid or ENG-123)");
+  const json = await linearGraphql(
+    ISSUE_QUERY,
+    { id: issueId },
+    opts
+  );
+  if (!json.issue) {
+    throw new Error(`Linear issue not found: ${issueId}`);
+  }
+  return mapIssue(json.issue);
+}
+async function createLinearIssue(input, opts) {
+  const title = input.title.trim();
+  if (!title) throw new Error("Linear issue title is required");
+  const { viewer, teams } = await listLinearTeams(opts);
+  const team = resolveLinearTeam(teams, input.team);
+  const mutationInput = {
+    teamId: team.id,
+    title
+  };
+  const description = input.description?.trim();
+  if (description) mutationInput.description = description;
+  if (input.state?.trim()) {
+    mutationInput.stateId = resolveLinearState(team, input.state).id;
+  }
+  const assignee = input.assignee === void 0 ? void 0 : input.assignee?.trim() || null;
+  if (assignee === "me") mutationInput.assigneeId = viewer.id;
+  else if (assignee) mutationInput.assigneeId = assignee;
+  const priority = normalizePriority(input.priority);
+  if (priority != null) mutationInput.priority = priority;
+  const json = await linearGraphql(ISSUE_CREATE, { input: mutationInput }, opts);
+  if (!json.issueCreate?.success || !json.issueCreate.issue) {
+    throw new Error("Linear issueCreate failed");
+  }
+  return mapIssue(json.issueCreate.issue);
+}
+async function updateLinearIssue(input, opts) {
+  const issueId = input.id.trim();
+  if (!issueId) throw new Error("Linear issue id is required (uuid or ENG-123)");
+  const mutationInput = {};
+  if (input.title !== void 0) {
+    const title = input.title.trim();
+    if (!title) throw new Error("Linear issue title cannot be empty");
+    mutationInput.title = title;
+  }
+  if (input.description !== void 0) {
+    mutationInput.description = input.description;
+  }
+  if (input.state?.trim()) {
+    const existing = await getLinearIssue(issueId, opts);
+    const team = existing.team;
+    if (!team?.states.length) {
+      throw new Error(`Linear issue ${existing.identifier} has no workflow states to resolve "${input.state}"`);
+    }
+    mutationInput.stateId = resolveLinearState(team, input.state).id;
+  }
+  if (input.assignee !== void 0) {
+    const assignee = input.assignee?.trim() || null;
+    if (assignee === "me") {
+      const { viewer } = await listLinearTeams(opts);
+      mutationInput.assigneeId = viewer.id;
+    } else {
+      mutationInput.assigneeId = assignee;
+    }
+  }
+  if (input.priority !== void 0) {
+    mutationInput.priority = normalizePriority(input.priority);
+  }
+  if (Object.keys(mutationInput).length === 0) {
+    throw new Error("linear_update_issue needs at least one of title, description, state, assignee, priority");
+  }
+  const json = await linearGraphql(ISSUE_UPDATE, { id: issueId, input: mutationInput }, opts);
+  if (!json.issueUpdate?.success || !json.issueUpdate.issue) {
+    throw new Error("Linear issueUpdate failed");
+  }
+  return mapIssue(json.issueUpdate.issue);
+}
+async function commentLinearIssue(input, opts) {
+  const issueId = input.id.trim();
+  const body = input.body.trim();
+  if (!issueId) throw new Error("Linear issue id is required (uuid or ENG-123)");
+  if (!body) throw new Error("Linear comment body is required");
+  const json = await linearGraphql(COMMENT_CREATE, { input: { issueId, body } }, opts);
+  if (!json.commentCreate?.success || !json.commentCreate.comment?.id) {
+    throw new Error("Linear commentCreate failed");
+  }
+  return {
+    id: String(json.commentCreate.comment.id),
+    body: String(json.commentCreate.comment.body ?? body),
+    url: json.commentCreate.comment.url?.trim() || void 0
+  };
 }
 
 // src/integrations/issues.ts
@@ -6603,8 +6878,8 @@ function labelGithubUrl(url) {
   }
   return { kind: "other", label: "GitHub", url: raw };
 }
-function appendGithubLink(text2, githubUrl) {
-  const body = text2.trimEnd();
+function appendGithubLink(text3, githubUrl) {
+  const body = text3.trimEnd();
   if (!githubUrl?.trim()) return body;
   const labeled = labelGithubUrl(githubUrl);
   if (!labeled) {
@@ -6887,6 +7162,101 @@ function registerSlackTools(server) {
   );
 }
 
+// src/mcp/linear-tools.ts
+import { z as z2 } from "zod";
+function text2(payload, isError = false) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    ...isError ? { isError: true } : {}
+  };
+}
+function fail2(err) {
+  return text2(
+    { error: err instanceof Error ? err.message : String(err) },
+    true
+  );
+}
+var prioritySchema = z2.number().int().min(0).max(4).optional().describe("0 none, 1 urgent, 2 high, 3 medium, 4 low");
+function registerLinearTools(server) {
+  server.tool(
+    "linear_list_teams",
+    "List Linear teams (id, key, name) and workflow states for the connected Account. Use team key (e.g. ENG) on linear_create_issue; use state name or type (started, completed) on create/update. Viewer id is for assignee=me.",
+    {},
+    async () => {
+      try {
+        return text2(await listLinearTeams());
+      } catch (err) {
+        return fail2(err);
+      }
+    }
+  );
+  server.tool(
+    "linear_get_issue",
+    "Get a Linear issue by uuid or identifier (ENG-123).",
+    { id: z2.string() },
+    async ({ id }) => {
+      try {
+        return text2(await getLinearIssue(id));
+      } catch (err) {
+        return fail2(err);
+      }
+    }
+  );
+  server.tool(
+    "linear_create_issue",
+    'Create a Linear issue. Call linear_list_teams first. team is id, key, or name. state is name, type (unstarted/started/completed/canceled/backlog), or id. assignee is "me" or a user id.',
+    {
+      team: z2.string(),
+      title: z2.string(),
+      description: z2.string().optional(),
+      state: z2.string().optional(),
+      assignee: z2.string().nullable().optional(),
+      priority: prioritySchema
+    },
+    async (args) => {
+      try {
+        return text2(await createLinearIssue(args));
+      } catch (err) {
+        return fail2(err);
+      }
+    }
+  );
+  server.tool(
+    "linear_update_issue",
+    'Update a Linear issue (uuid or ENG-123). Pass at least one of title, description, state, assignee, priority. state is name, type, or id. assignee is "me", a user id, or null to unassign.',
+    {
+      id: z2.string(),
+      title: z2.string().optional(),
+      description: z2.string().optional(),
+      state: z2.string().optional(),
+      assignee: z2.string().nullable().optional(),
+      priority: prioritySchema
+    },
+    async (args) => {
+      try {
+        return text2(await updateLinearIssue(args));
+      } catch (err) {
+        return fail2(err);
+      }
+    }
+  );
+  server.tool(
+    "linear_comment",
+    "Add a markdown comment on a Linear issue (uuid or ENG-123).",
+    {
+      id: z2.string(),
+      body: z2.string()
+    },
+    async (args) => {
+      try {
+        return text2(await commentLinearIssue(args));
+      } catch (err) {
+        return fail2(err);
+      }
+    }
+  );
+}
+
 // src/mcp/server.ts
 var MAX_ORCH_THREADS = 5;
 var CREATE_THREAD_TIMEOUT_MS = 9e4;
@@ -6963,7 +7333,7 @@ async function startMcpServer() {
   server.tool(
     "get_thread",
     "Get a compact thread summary by id/ref",
-    { ref: z2.string() },
+    { ref: z3.string() },
     async ({ ref }) => {
       const t = orch.getThread(ref);
       if (!t) {
@@ -6992,14 +7362,14 @@ async function startMcpServer() {
     "present_artifact",
     "Show an HTML, SVG, markdown, or React document in Sideboard\u2019s Claude-style side column (desktop). Use instead of claude.ai\u2019s artifact tool \u2014 pass the full document content. Prefer type=html for interactive pages. For type=react, pass a single component module that `export default`s a component (JSX/TSX ok) \u2014 Sideboard bootstraps React/ReactDOM/Babel and renders it; only `react`/`react-dom` imports are available, no other npm packages.",
     {
-      title: z2.string().describe("Short title shown in the artifact pane header"),
-      type: z2.enum(["html", "svg", "markdown", "react"]).describe(
+      title: z3.string().describe("Short title shown in the artifact pane header"),
+      type: z3.enum(["html", "svg", "markdown", "react"]).describe(
         "Artifact kind \u2014 html opens an iframe preview; react transpiles and renders a default-exported component in a sandboxed iframe"
       ),
-      content: z2.string().describe(
+      content: z3.string().describe(
         "Full document body (complete HTML page, SVG markup, markdown, or a React component module with a default export)"
       ),
-      artifact_id: z2.string().optional().describe("Stable id when updating the same artifact across turns")
+      artifact_id: z3.string().optional().describe("Stable id when updating the same artifact across turns")
     },
     async ({ title, type, artifact_id }) => {
       const id = artifact_id?.trim() || `artifact_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
@@ -7017,15 +7387,15 @@ async function startMcpServer() {
     "ask_user",
     "Ask the user clarifying multiple-choice questions in Sideboard\u2019s composer (plan mode). Before calling, write a short chat message explaining the decision and what each option means. Include a description on every option. Use for approach forks and requirements \u2014 not for \u201Cis the plan ready?\u201D. After calling, stop and wait for their next message with answers.",
     {
-      questions: z2.array(
-        z2.object({
-          question: z2.string().describe("Full question text ending with ?"),
-          header: z2.string().max(24).optional().describe("Short label shown above the question"),
-          multiSelect: z2.boolean().optional().describe("Allow selecting multiple options"),
-          options: z2.array(
-            z2.object({
-              label: z2.string(),
-              description: z2.string().optional().describe("What this option means / when to choose it (strongly preferred)")
+      questions: z3.array(
+        z3.object({
+          question: z3.string().describe("Full question text ending with ?"),
+          header: z3.string().max(24).optional().describe("Short label shown above the question"),
+          multiSelect: z3.boolean().optional().describe("Allow selecting multiple options"),
+          options: z3.array(
+            z3.object({
+              label: z3.string(),
+              description: z3.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)")
         })
@@ -7044,9 +7414,9 @@ async function startMcpServer() {
     "present_plan",
     "Save the implementation plan as markdown to .context/attachments/plan.md and show it in Sideboard chat for user approval (Copy / Hand off / Approve). Call this when the plan is ready \u2014 required in plan mode. Pass the full plan body in content. Then Claude should call ExitPlanMode.",
     {
-      title: z2.string().optional().describe("Short plan title (defaults to Plan)"),
-      content: z2.string().min(1).describe("Full plan markdown (headings, steps, risks, open questions)"),
-      thread_id: z2.string().optional().describe("Sideboard thread id when cwd is not the worktree")
+      title: z3.string().optional().describe("Short plan title (defaults to Plan)"),
+      content: z3.string().min(1).describe("Full plan markdown (headings, steps, risks, open questions)"),
+      thread_id: z3.string().optional().describe("Sideboard thread id when cwd is not the worktree")
     },
     async ({ title, content, thread_id }) => {
       const { writePlanFile: writePlanFile2 } = await import("../plan-file-PHVKUAEE.js");
@@ -7069,15 +7439,15 @@ async function startMcpServer() {
     "present_schema",
     "Open Sideboard\u2019s schema-driven side column (filterable table and/or form). 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: z2.string().describe("Pane title"),
-      mode: z2.enum(["table", "form"]).optional().describe("table = list/filter records; form = edit one record"),
-      datasource: z2.enum(["brightsy", "inline"]).optional().describe("brightsy resolves via login; inline uses embedded resource/records"),
-      resource_id: z2.string().optional().describe("Brightsy record type UUID (or generic resource id)"),
-      record_id: z2.string().optional().describe("Record id when opening form mode"),
-      resource: z2.record(z2.unknown()).optional().describe("Inline { id, title, schema, schemaUi?, slug? }"),
-      record: z2.record(z2.unknown()).optional().describe("Inline record { id, data, published_at? }"),
-      records: z2.array(z2.record(z2.unknown())).optional().describe("Inline records for table mode"),
-      pane_id: z2.string().optional().describe("Stable pane id across updates")
+      title: z3.string().describe("Pane title"),
+      mode: z3.enum(["table", "form"]).optional().describe("table = list/filter records; form = edit one record"),
+      datasource: z3.enum(["brightsy", "inline"]).optional().describe("brightsy resolves via login; inline uses embedded resource/records"),
+      resource_id: z3.string().optional().describe("Brightsy record type UUID (or generic resource id)"),
+      record_id: z3.string().optional().describe("Record id when opening form mode"),
+      resource: z3.record(z3.unknown()).optional().describe("Inline { id, title, schema, schemaUi?, slug? }"),
+      record: z3.record(z3.unknown()).optional().describe("Inline record { id, data, published_at? }"),
+      records: z3.array(z3.record(z3.unknown())).optional().describe("Inline records for table mode"),
+      pane_id: z3.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)}`;
@@ -7098,10 +7468,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: z2.string().optional().describe("Pane title (default: Files)"),
-      datasource: z2.enum(["brightsy", "memory"]).optional().describe("brightsy = account storage via login; memory = session demo store"),
-      path: z2.string().optional().describe("Initial folder path (e.g. public)"),
-      pane_id: z2.string().optional().describe("Stable pane id across updates")
+      title: z3.string().optional().describe("Pane title (default: Files)"),
+      datasource: z3.enum(["brightsy", "memory"]).optional().describe("brightsy = account storage via login; memory = session demo store"),
+      path: z3.string().optional().describe("Initial folder path (e.g. public)"),
+      pane_id: z3.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)}`;
@@ -7117,19 +7487,21 @@ async function startMcpServer() {
     }
   );
   registerSlackTools(server);
+  registerLinearTools(server);
   if (sideboardMcpProfile() !== "worktree") {
-    const { getCaffeinateHold, setCaffeinateHold } = await import("../caffeinate-hold-BEJIYPJ7.js");
+    const { getCaffeinateHold, setCaffeinateHold } = await import("../caffeinate-hold-OHAUWOA6.js");
     const { resolveNewThreadOptions: resolveNewThreadOptions2, resolveThreadDefaults } = await import("../app-settings-P42Z3VOB.js");
     const accountDefaults = resolveThreadDefaults();
     const accountDefaultsHint = `Account defaults: agent=${accountDefaults.agent}, model=${accountDefaults.model?.trim() || "Auto"}, effort=${accountDefaults.effort}`;
     server.tool(
       "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. macOS only.",
+      "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: z2.boolean().describe("true = hold caffeinate on; false = release and let the Mac sleep")
+        enabled: z3.boolean().describe("true = hold caffeinate on; false = release and let the Mac sleep")
       },
       async ({ enabled }) => {
-        const state = setCaffeinateHold(enabled);
+        const threadId = process.env.SIDEBOARD_ORCHESTRATOR_THREAD_ID?.trim() || null;
+        const state = setCaffeinateHold(enabled, { threadId });
         if (enabled && !state.held) {
           return {
             content: [
@@ -7152,7 +7524,7 @@ async function startMcpServer() {
               text: JSON.stringify({
                 ...getCaffeinateHold(),
                 ok: true,
-                message: state.held ? "Mac will stay awake until you call set_caffeinate with enabled=false (or the user says they are done)." : "Caffeinate hold released. The Mac can sleep (unless Settings caffeinate toggles are on)."
+                message: state.held ? "Mac will stay awake until you call set_caffeinate with enabled=false, the user says they are done, or this orchestration chat is closed." : "Caffeinate hold released. The Mac can sleep (unless Settings caffeinate toggles are on)."
               })
             }
           ]
@@ -7163,15 +7535,15 @@ async function startMcpServer() {
       "create_thread",
       `Create a new worktree thread (chat) from branch, pr, or ticket. Pass repoPath from list_workspaces. From an orchestration chat, omit parentThreadId (Sideboard binds the child to this chat) or pass the exact id from the turn reminder \u2014 never invent a uuid. Prefer omitting agent/model so Sideboard applies ${accountDefaultsHint}. Then use send_to_thread to chat.`,
       {
-        sourceType: z2.enum(["branch", "pr", "ticket"]),
-        sourceRef: z2.string(),
-        agent: z2.enum(["claude", "codex", "opencode", "brightsy", "cursor"]).optional().describe(`Omit to use Account default agent (${accountDefaults.agent})`),
-        model: z2.string().nullable().optional().describe(
+        sourceType: z3.enum(["branch", "pr", "ticket"]),
+        sourceRef: z3.string(),
+        agent: z3.enum(["claude", "codex", "opencode", "brightsy", "cursor"]).optional().describe(`Omit to use Account default agent (${accountDefaults.agent})`),
+        model: z3.string().nullable().optional().describe(
           `Usually omit to use Account default model (${accountDefaults.model?.trim() || "Auto"}). Pass null only to force Auto / agent-default.`
         ),
-        repoPath: z2.string(),
-        title: z2.string().optional(),
-        parentThreadId: z2.string().optional().describe(
+        repoPath: z3.string(),
+        title: z3.string().optional(),
+        parentThreadId: z3.string().optional().describe(
           "Orchestration: omit (preferred) or pass YOUR chat id from the turn reminder / AGENTS.md. Do not invent uuids."
         )
       },
@@ -7278,9 +7650,9 @@ async function startMcpServer() {
       "send_to_thread",
       "Queue a prompt on a worktree thread chat (runs under concurrency cap). Use after create_thread to start or continue a conversation. For commit/push/PR/merge, prefer ask_git (canonical desktop-button phrases). Set force_stop=true to interrupt an in-flight/queued turn (kill + clear queue) before queueing this prompt \u2014 use when the thread is mid-turn or has stale queued prompts you need to replace.",
       {
-        ref: z2.string(),
-        prompt: z2.string(),
-        force_stop: z2.boolean().optional()
+        ref: z3.string(),
+        prompt: z3.string(),
+        force_stop: z3.boolean().optional()
       },
       async ({ ref, prompt, force_stop }) => {
         if (force_stop) {
@@ -7309,8 +7681,8 @@ async function startMcpServer() {
       "wait_for_turn",
       "Block until the thread finishes its current/queued turn (avoids polling). Use after send_to_thread or ask_git to read the agent reply.",
       {
-        ref: z2.string(),
-        timeoutMs: z2.number().optional()
+        ref: z3.string(),
+        timeoutMs: z3.number().optional()
       },
       async ({ ref, timeoutMs }) => {
         const thread = await orch.waitForTurn(ref, timeoutMs ?? 6e5);
@@ -7332,7 +7704,7 @@ async function startMcpServer() {
     server.tool(
       "get_turn_result",
       "Final assistant message only (not full transcript)",
-      { ref: z2.string() },
+      { ref: z3.string() },
       async ({ ref }) => {
         const result = orch.getTurnResult(ref);
         return { content: [{ type: "text", text: JSON.stringify(result) }] };
@@ -7342,8 +7714,8 @@ async function startMcpServer() {
       "stop_thread",
       "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.",
       {
-        ref: z2.string(),
-        force: z2.boolean().optional()
+        ref: z3.string(),
+        force: z3.boolean().optional()
       },
       async ({ ref, force }) => {
         const t = orch.getThread(ref);
@@ -7373,7 +7745,7 @@ async function startMcpServer() {
     server.tool(
       "archive_thread",
       "Archive a thread (stops agent/dev, runs archive script, removes worktree when last chat tab). Coordinators commit, push, open PRs, and merge only by asking the worktree agent (ask_git).",
-      { ref: z2.string() },
+      { ref: z3.string() },
       async ({ ref }) => {
         const t = orch.getThread(ref);
         if (!t) {
@@ -7406,7 +7778,7 @@ async function startMcpServer() {
     server.tool(
       "restore_thread",
       "Restore an archived thread (recreates worktree from branch when needed)",
-      { ref: z2.string() },
+      { ref: z3.string() },
       async ({ ref }) => {
         try {
           const restored = await orch.restore(ref);
@@ -7432,8 +7804,8 @@ async function startMcpServer() {
       "get_diff",
       "Compact diff summary (capped hunks, paginated)",
       {
-        ref: z2.string(),
-        maxFiles: z2.number().optional()
+        ref: z3.string(),
+        maxFiles: z3.number().optional()
       },
       async ({ ref, maxFiles }) => {
         const summary = await orch.diffSummary(ref);
@@ -7453,7 +7825,7 @@ async function startMcpServer() {
     server.tool(
       "request_review",
       'Start a merge-readiness Review on a worktree agent thread (same as the desktop Review button). Opens a new Review chat tab, attaches .sideboard/review.md when present (else local Review request.md / stock template), and sends "Review changes in this workspace." Expect Approve / Approve with nits / Request changes / Needs more information. Pass a worktree thread ref \u2014 not the orchestrator. Then wait_for_turn / get_turn_result on the returned review tab id.',
-      { ref: z2.string().describe("Worktree thread id/ref to review") },
+      { ref: z3.string().describe("Worktree thread id/ref to review") },
       async ({ ref }) => {
         try {
           const tab = await orch.requestReview(ref);
@@ -7482,8 +7854,8 @@ async function startMcpServer() {
       "ask_git",
       "Tell a worktree agent to commit & push, open a draft PR, resolve conflicts, or merge the linked PR \u2014 same short prompts as the desktop git buttons. The worktree agent runs git/gh (`gh pr merge`); this only queues the prompt. Pass a worktree thread ref (not the orchestrator). Then wait_for_turn / get_turn_result. Do not run git or gh from the orchestration cwd.",
       {
-        ref: z2.string().describe("Worktree thread id/ref"),
-        action: z2.enum(AGENT_GIT_ACTIONS).describe(
+        ref: z3.string().describe("Worktree thread id/ref"),
+        action: z3.enum(AGENT_GIT_ACTIONS).describe(
           "commit-push | create-draft | create-web | resolve-conflicts | merge"
         )
       },
@@ -7510,7 +7882,7 @@ async function startMcpServer() {
         }
       }
     );
-    const agentEnum = z2.enum(["claude", "codex", "opencode", "brightsy", "cursor"]);
+    const agentEnum = z3.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.",
@@ -7533,11 +7905,11 @@ async function startMcpServer() {
       "fork_worktree",
       "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_thread / wait_for_turn on the returned id.",
       {
-        ref: z2.string().describe("Worktree thread id/ref to fork"),
-        through_index: z2.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
+        ref: z3.string().describe("Worktree thread id/ref to fork"),
+        through_index: z3.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: z2.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
-        title: z2.string().optional()
+        model: z3.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
+        title: z3.string().optional()
       },
       async ({ ref, through_index, agent, model, title }) => {
         try {
@@ -7578,11 +7950,11 @@ async function startMcpServer() {
       "fork_chat",
       "Fork a chat into a NEW tab on the SAME workspace: worktree agent \u2192 same worktree tab; Global orchestration chat \u2192 new orchestration chat (same synthetic home). Seeds a transcript; optional agent override. Leave model unset for Auto unless you have a reason. Orchestration forks require an MCP-capable agent (claude, cursor, codex, opencode \u2014 not brightsy). Slack / Global orchestrators use this to continue an orchestration chat on another agent after session limits. Then send_to_thread / wait_for_turn on the returned id. Use fork_worktree only for worktree agents that need a new git worktree.",
       {
-        ref: z2.string().describe("Thread id/ref to fork (worktree agent or orchestration chat)"),
-        through_index: z2.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
+        ref: z3.string().describe("Thread id/ref to fork (worktree agent or orchestration chat)"),
+        through_index: z3.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: z2.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
-        title: z2.string().optional()
+        model: z3.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
+        title: z3.string().optional()
       },
       async ({ ref, through_index, agent, model, title }) => {
         try {
@@ -7628,8 +8000,8 @@ async function startMcpServer() {
       "run_dev_script",
       "Start a .sideboard/.conductor run script for a thread (default script if name omitted); returns port",
       {
-        ref: z2.string(),
-        name: z2.string().optional()
+        ref: z3.string(),
+        name: z3.string().optional()
       },
       async ({ ref, name }) => {
         const result = await orch.startDev(ref, name);
@@ -7651,7 +8023,7 @@ async function startMcpServer() {
     server.tool(
       "list_run_scripts",
       "List named run scripts available for a thread",
-      { ref: z2.string() },
+      { ref: z3.string() },
       async ({ ref }) => {
         const scripts = orch.listThreadRunScripts(ref);
         const active = orch.getActiveRuns(ref);
@@ -7669,8 +8041,8 @@ async function startMcpServer() {
       "stop_dev_script",
       "Stop a running script for a thread (all scripts if name omitted)",
       {
-        ref: z2.string(),
-        name: z2.string().optional()
+        ref: z3.string(),
+        name: z3.string().optional()
       },
       async ({ ref, name }) => {
         orch.stopDev(ref, name);
@@ -7680,7 +8052,7 @@ async function startMcpServer() {
     server.tool(
       "run_setup",
       "Re-run workspace setup (Sideboard/Conductor settings or .cursor/worktrees.json)",
-      { ref: z2.string() },
+      { ref: z3.string() },
       async ({ ref }) => {
         const result = await orch.runSetup(ref);
         return {
@@ -7691,7 +8063,7 @@ async function startMcpServer() {
     server.tool(
       "add_workspace",
       "Register a git repo as a Sideboard workspace",
-      { repoPath: z2.string() },
+      { repoPath: z3.string() },
       async ({ repoPath }) => {
         const ws = await orch.addWorkspace(repoPath);
         return { content: [{ type: "text", text: JSON.stringify(ws) }] };
@@ -7700,7 +8072,7 @@ async function startMcpServer() {
     server.tool(
       "remove_workspace",
       "Unregister a Sideboard workspace (does not archive threads)",
-      { repoPath: z2.string() },
+      { repoPath: z3.string() },
       async ({ repoPath }) => {
         orch.removeWorkspace(repoPath);
         return { content: [{ type: "text", text: "ok" }] };
@@ -7710,12 +8082,12 @@ async function startMcpServer() {
       "fanout",
       "Best-of-n: create one thread per agent with the same prompt (parallel attempts)",
       {
-        prompt: z2.string(),
-        agents: z2.array(z2.enum(["claude", "codex", "opencode", "brightsy", "cursor"])),
-        repoPath: z2.string(),
-        sourceType: z2.enum(["branch", "pr", "ticket"]).optional(),
-        sourceRef: z2.string().optional(),
-        title: z2.string().optional()
+        prompt: z3.string(),
+        agents: z3.array(z3.enum(["claude", "codex", "opencode", "brightsy", "cursor"])),
+        repoPath: z3.string(),
+        sourceType: z3.enum(["branch", "pr", "ticket"]).optional(),
+        sourceRef: z3.string().optional(),
+        title: z3.string().optional()
       },
       async (args) => {
         const threads = await orch.bestOfN(args);
@@ -7742,8 +8114,8 @@ async function startMcpServer() {
       "list_branches",
       "List git branches in a registered workspace. Pass repoPath from list_workspaces (unmerged into the default branch by default \u2014 for create_thread sourceType=branch).",
       {
-        repoPath: z2.string(),
-        unmergedOnly: z2.boolean().optional()
+        repoPath: z3.string(),
+        unmergedOnly: z3.boolean().optional()
       },
       async ({ repoPath, unmergedOnly }) => {
         const root = await resolveRepoRoot(repoPath);
@@ -7763,7 +8135,7 @@ async function startMcpServer() {
     server.tool(
       "list_prs",
       "List open GitHub PRs for a registered workspace. Pass repoPath from list_workspaces (uses gh against that repo remote). Then create_thread with sourceType=pr.",
-      { repoPath: z2.string() },
+      { repoPath: z3.string() },
       async ({ repoPath }) => {
         const root = await resolveRepoRoot(repoPath);
         const prs = await listPrs(root);
@@ -7782,7 +8154,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.",
-      { ref: z2.string() },
+      { ref: z3.string() },
       async ({ ref }) => {
         const stack = await orch.getPrStack(ref);
         return {
@@ -7794,8 +8166,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: z2.string(),
-        layer: z2.number().int().positive().optional()
+        ref: z3.string(),
+        layer: z3.number().int().positive().optional()
       },
       async ({ ref, layer }) => {
         const result = await orch.openPrStackLayers(ref, { layer });
@@ -7829,9 +8201,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: z2.string(),
-        branchName: z2.string(),
-        title: z2.string().optional()
+        ref: z3.string(),
+        branchName: z3.string(),
+        title: z3.string().optional()
       },
       async ({ ref, branchName, title }) => {
         const result = await orch.addStackLayer(ref, branchName, { title });
@@ -7860,11 +8232,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: z2.string(),
-        branches: z2.array(z2.string()).min(1),
-        agent: z2.enum(["claude", "codex", "opencode", "brightsy", "cursor"]),
-        base: z2.string().optional(),
-        title: z2.string().optional()
+        repoPath: z3.string(),
+        branches: z3.array(z3.string()).min(1),
+        agent: z3.enum(["claude", "codex", "opencode", "brightsy", "cursor"]),
+        base: z3.string().optional(),
+        title: z3.string().optional()
       },
       async (args) => {
         const result = await orch.createPrStack({
@@ -7902,7 +8274,7 @@ async function startMcpServer() {
     server.tool(
       "list_issues",
       "List issues from Sideboard Account connections (Linear API or GitHub Issues; Linear\u2192GitHub fallback when Linear is not connected). Pass repoPath from list_workspaces \u2014 GitHub Issues are scoped to that repo. Then create_thread with sourceType=ticket.",
-      { repoPath: z2.string() },
+      { repoPath: z3.string() },
       async ({ repoPath }) => {
         const root = await resolveRepoRoot(repoPath);
         const result = await listIssues(root);
@@ -7913,8 +8285,8 @@ async function startMcpServer() {
       "list_linear_issues",
       "Deprecated: prefer list_issues. Lists assigned Linear issues via the chosen agent MCP connector",
       {
-        agent: z2.enum(["claude", "codex", "opencode"]),
-        repoPath: z2.string()
+        agent: z3.enum(["claude", "codex", "opencode"]),
+        repoPath: z3.string()
       },
       async ({ agent, repoPath }) => {
         const issues = await listLinearIssues(agent, repoPath);