@sideboard-ai/core 0.1.124 → 0.1.127

package/dist/index.js

@@ -1,9 +1,12 @@
 import {
   AGENT_GIT_ACTIONS,
+  BOARD_COLUMN_DEFS,
   CONTEXT_COMPACT_CHARS,
   CONTEXT_KEEP_RECENT_CHARS,
   CONTEXT_KEEP_RECENT_MESSAGES,
   CONTEXT_MIN_MESSAGES,
+  HOME_BOARD_AGENT_HINT,
+  HOME_BOARD_CACHE_TTL_MS,
   LEGACY_REVIEW_REQUEST_PATH,
   Orchestrator,
   REPO_REVIEW_NAME,
@@ -25,9 +28,11 @@ import {
   applyPromptCacheTtlEnv,
   applyThreadIntoMain,
   armSchedules,
+  assembleHomeBoard,
   attachmentFromAbsolutePath,
   attachmentsFromBuffers,
   attachmentsFromWorktreePaths,
+  boardPinIdentity,
   buildForkTranscriptAttachment,
   buildReviewRequestAttachment,
   buildSessionSeed,
@@ -35,6 +40,7 @@ import {
   captureLoginEnv,
   captureTurnBaseline,
   claimDesktopHost,
+  classifyWorktreeColumn,
   cleanupOrphanWorktrees,
   cloneRepoIntoSideboard,
   computeNextRunAt,
@@ -46,19 +52,24 @@ import {
   createPrStack,
   createSchedule,
   createThread,
+  dedupeBoardIssues,
+  dedupeBoardPrs,
   defaultScheduleName,
   deleteSchedule,
   desktopHostPidPath,
   detectAgents,
   disconnectSlackWorkspace,
   discoverSkills,
-  dismissSlackReplyBadge,
   ensureReviewRequestFile,
   ensureReviewSkillFile,
   estimateMessageChars,
   estimateThreadChars,
   expandComposerPrompt,
   extractiveSummary,
+  findBoardIssue,
+  findBoardPin,
+  findBoardPr,
+  findLiveThreadForCreate,
   findOrphanWorktrees,
   findThreadForStackLayer,
   fireSchedule,
@@ -88,6 +99,7 @@ import {
   getSchedule,
   getSlackReplyTarget,
   getSlackWorkspace,
+  groupHomeBoardWorktrees,
   hasEnabledSchedules,
   importConductorWorkspace,
   importConductorWorkspaceAsync,
@@ -96,11 +108,13 @@ import {
   inspectGitWorktree,
   isCowboyThread,
   isDesktopHostAlive,
+  isHomeBoardThread,
   isImageFilePath,
   isPidAlive,
   isPrimaryCheckoutThread,
   isSlackExternalReplyPrompt,
   isThisProcessDesktopHost,
+  issueNeedsWorkspacePick,
   lastRequestOccupancy,
   listBranchCommits,
   listConductorWorkspaces,
@@ -108,7 +122,6 @@ import {
   listRunScripts,
   listSchedules,
   listSlackOutboundWatches,
-  listSlackReplyBadges,
   listSlackWorkspaces,
   listSlackWorkspacesRaw,
   listWorktreeFiles,
@@ -118,7 +131,7 @@ import {
   openStackLayer,
   parseDurationMs,
   pendingSlackExternalReplies,
-  permalinkForSlackReplyBadge,
+  pollSlackOutboundWatches,
   previewLand,
   readExistingReviewRequestFile,
   readSkillBody,
@@ -128,7 +141,6 @@ import {
   readWorktreeInclude,
   recordScheduleRun,
   recordSlackOutboundWatch,
-  refreshSlackReplyBadges,
   releaseDesktopHost,
   requestReview,
   requireAgent,
@@ -161,6 +173,7 @@ import {
   startDevServer,
   startOrchestration,
   summarizeConversation,
+  syncBoardPins,
   takenTeamSlugsForChatTab,
   thisProcessShouldDrainAgentQueues,
   threadsSharingWorktree,
@@ -168,10 +181,11 @@ import {
   upsertSlackWorkspace,
   waitForPidExit,
   withAgentInstructions,
+  worktreeBoardStatus,
   worktreeCleanupSettings,
   wrapReviewSkillMarkdown,
   writeWorktreeFile
-} from "./chunk-MZDAEI3Y.js";
+} from "./chunk-T7KJQJAX.js";
 import {
   BRIGHTSY_MCP_ALLOWED_TOOLS,
   CLAUDE_MODEL_CATALOG,
@@ -250,7 +264,7 @@ import {
   withEventParentId,
   withEventsParentId,
   writeInjectedMcpConfig
-} from "./chunk-7Y3AYQWT.js";
+} from "./chunk-NV73AO7Q.js";
 import {
   brightsyConfigPath,
   brightsyMcpServerName,
@@ -269,7 +283,7 @@ import {
   listWorkspaces,
   removeWorkspace,
   syncWorkspacesFromThreads
-} from "./chunk-HZLE6LJJ.js";
+} from "./chunk-VE22NWBD.js";
 import {
   CLOUD_COORDINATOR_BUSY_REPLY,
   CLOUD_COORDINATOR_STOPPED_REPLY,
@@ -297,7 +311,7 @@ import {
   parseForceStopMessage,
   slackCoordinatorSourceRef,
   takenTeamSlugsForOrchestration
-} from "./chunk-KWGP6RZM.js";
+} from "./chunk-HULESWLI.js";
 import {
   COORDINATOR_TOOL_PLAYBOOK,
   SLACK_REPLY_FORMATTING,
@@ -306,7 +320,7 @@ import {
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd,
   formatWorkspaceInventory
-} from "./chunk-2X7I6MDW.js";
+} from "./chunk-HZPO3SSZ.js";
 import {
   LEGACY_PLAN_FILE_REL,
   PLAN_FILE_NAME,
@@ -343,6 +357,7 @@ import {
   appendIndexedGitConfig,
   applyGithubGitAuthEnv,
   branchDisplayLabel,
+  canonicalizeRepoPath,
   checkoutPrStackLayer,
   codexSandboxWritableRootsArgs,
   codexUnattendedGitConfigArgs,
@@ -415,7 +430,7 @@ import {
   worktreeDisplayLabel,
   worktreeDisplayLabelForGroup,
   worktreeNameFromPath
-} from "./chunk-UAVZ2JSO.js";
+} from "./chunk-UDQI3N47.js";
 import {
   ATTACHMENTS_DIR,
   LEGACY_ATTACHMENTS_DIR,
@@ -425,6 +440,7 @@ import {
 import {
   GITHUB_GIT_AUTH_MODES,
   HARNESS_ENV_KEYS,
+  ISSUE_SOURCE_LABELS,
   appSettingsPath,
   applyAppEnvironment,
   autoArchiveOnMergeEnabled,
@@ -454,7 +470,9 @@ import {
   getIssueSource,
   getLinearApiKey,
   harnessEnvKey,
+  isIssueSourceConnected,
   isLinearConnected,
+  issueSourceLabel,
   loadAppSettings,
   maxConcurrentAgents,
   orchestrationQuotaFallbackAgent,
@@ -484,7 +502,7 @@ import {
   updateDefaultsSettings,
   updateIntegrationsSettings,
   updateOpencodeSettings
-} from "./chunk-FXQPY2KU.js";
+} from "./chunk-HUYEU4GS.js";
 import {
   stripNestedElectronEnv
 } from "./chunk-4TR3HZFT.js";
@@ -503,7 +521,7 @@ import {
   updateThread,
   withThreadLock,
   writeThread
-} from "./chunk-HPAWHIZ3.js";
+} from "./chunk-HLJUNJBF.js";
 import {
   THINKING_EFFORTS,
   isThinkingEffort,
@@ -912,10 +930,13 @@ var ISSUE_FIELDS = `
   assignee { id name }
   team { id key name states { nodes { id name type } } }
   labels { nodes { name } }
+  cycle { id name number startsAt endsAt completedAt }
 `;
 var ASSIGNED_ISSUES_QUERY = `
 query SideboardAssignedIssues($first: Int!) {
   viewer {
+    id
+    name
     assignedIssues(
       first: $first
       orderBy: updatedAt
@@ -1018,6 +1039,25 @@ function mapState(node) {
     type: String(node.type ?? "")
   };
 }
+function linearCycleIsActive(cycle, now = Date.now()) {
+  if (!cycle) return false;
+  if (cycle.completedAt) return false;
+  const start = cycle.startsAt ? Date.parse(cycle.startsAt) : Number.NaN;
+  const end = cycle.endsAt ? Date.parse(cycle.endsAt) : Number.NaN;
+  if (Number.isFinite(start) && now < start) return false;
+  if (Number.isFinite(end) && now > end) return false;
+  return true;
+}
+function mapCycle(node) {
+  if (!node?.name && node?.number == null) return null;
+  const name = String(node.name ?? (node.number != null ? `Cycle ${node.number}` : "")).trim();
+  if (!name) return null;
+  return {
+    name,
+    number: typeof node.number === "number" ? node.number : void 0,
+    isActive: linearCycleIsActive(node)
+  };
+}
 function mapIssue(node) {
   const team = node.team;
   return {
@@ -1035,7 +1075,8 @@ function mapIssue(node) {
       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))
+    labels: (node.labels?.nodes ?? []).map((l) => l.name).filter((n) => Boolean(n)),
+    cycle: mapCycle(node.cycle)
   };
 }
 function toIssueInfo(issue) {
@@ -1045,7 +1086,11 @@ function toIssueInfo(issue) {
     title: issue.title,
     url: issue.url,
     labels: issue.labels,
-    provider: "linear"
+    provider: "linear",
+    assignee: issue.assignee?.name,
+    assignees: issue.assignee?.name ? [issue.assignee.name] : void 0,
+    cycle: issue.cycle ?? null,
+    teamKey: issue.team?.key || void 0
   };
 }
 function mapTeam(node) {
@@ -1087,10 +1132,21 @@ function normalizePriority(priority) {
   }
   return priority;
 }
-async function listLinearIssuesDirect(opts) {
-  const first = Math.max(1, Math.min(100, opts?.limit ?? 50));
+async function listLinearAssignedIssues(opts) {
+  const first = Math.max(1, Math.min(250, opts?.limit ?? 200));
   const json = await linearGraphql(ASSIGNED_ISSUES_QUERY, { first }, opts);
-  return (json.viewer?.assignedIssues?.nodes ?? []).map((node) => toIssueInfo(mapIssue(node)));
+  return {
+    viewer: {
+      id: String(json.viewer?.id ?? ""),
+      name: String(json.viewer?.name ?? "")
+    },
+    issues: (json.viewer?.assignedIssues?.nodes ?? []).map(
+      (node) => toIssueInfo(mapIssue(node))
+    )
+  };
+}
+async function listLinearIssuesDirect(opts) {
+  return (await listLinearAssignedIssues(opts)).issues;
 }
 async function listLinearTeams(opts) {
   const json = await linearGraphql(TEAMS_QUERY, void 0, opts);
@@ -1209,13 +1265,13 @@ async function validateLinearApiKey(apiKey) {
 
 // src/integrations/issues.ts
 async function listGitHubIssues(repoPath, opts) {
-  const limit = Math.max(1, Math.min(100, opts?.limit ?? 50));
+  const limit = Math.max(1, Math.min(1e3, opts?.limit ?? 200));
   const slug = await resolveGithubRepoSlug(repoPath);
   const args = [
     "issue",
     "list",
     "--json",
-    "number,title,url,labels",
+    "number,title,url,labels,assignees",
     "--limit",
     String(limit),
     "--state",
@@ -1238,27 +1294,55 @@ async function listGitHubIssues(repoPath, opts) {
     const labels = (item.labels ?? []).map(
       (l) => typeof l === "string" ? l : String(l?.name ?? "")
     ).filter(Boolean);
+    const assignees = (item.assignees ?? []).map((a) => typeof a === "string" ? a : String(a?.login ?? "")).map((login) => login.trim()).filter(Boolean);
     return {
       id: Number.isFinite(number) ? `gh-${number}` : identifier,
       identifier,
       title: String(item.title ?? ""),
       url: String(item.url ?? ""),
       labels,
-      provider: "github"
+      provider: "github",
+      assignee: assignees[0],
+      assignees
     };
   });
 }
+async function githubViewerLogin(repoPath) {
+  const { stdout, exitCode } = await gh(["api", "user", "--jq", ".login"], repoPath, {
+    reject: false
+  });
+  if (exitCode !== 0) return "";
+  return stdout.trim();
+}
 async function listIssues(repoPath) {
   const settings = loadAppSettings();
   const preferredSource = settings.integrations.issueSource ?? "github";
   const linearConnected = isLinearConnected(settings);
   const source = resolveEffectiveIssueSource(settings);
   if (source === "linear") {
-    const issues2 = await listLinearIssuesDirect();
-    return { source, preferredSource, linearConnected, issues: issues2 };
+    const listed = await listLinearAssignedIssues();
+    return {
+      source,
+      preferredSource,
+      linearConnected,
+      issues: listed.issues,
+      viewer: {
+        login: listed.viewer.name,
+        name: listed.viewer.name
+      }
+    };
   }
-  const issues = await listGitHubIssues(repoPath);
-  return { source, preferredSource, linearConnected, issues };
+  const [issues, login] = await Promise.all([
+    listGitHubIssues(repoPath),
+    githubViewerLogin(repoPath)
+  ]);
+  return {
+    source,
+    preferredSource,
+    linearConnected,
+    issues,
+    viewer: login ? { login } : void 0
+  };
 }
 
 // src/composer/diff-comment.ts
@@ -1346,6 +1430,12 @@ function buildPastedTextAttachment(text4, opts) {
 }
 
 // src/plan/ask-user.ts
+function planQuestionsSignature(questions) {
+  return questions.map((q) => {
+    const opts = q.options.map((o) => o.label).join("");
+    return `${q.question}${opts}`;
+  }).join("");
+}
 function asRecord(v) {
   return v != null && typeof v === "object" && !Array.isArray(v) ? v : null;
 }
@@ -1403,12 +1493,22 @@ function extractPendingPlanQuestions(parts) {
     if (!questions.length) continue;
     return {
       id: p.id || `ask-${i}`,
+      signature: planQuestionsSignature(questions),
       questions,
       source: p.name || "ask_user"
     };
   }
   return null;
 }
+function latestPendingPlanQuestions(input) {
+  if (input.userReplied) return null;
+  const fromLive = extractPendingPlanQuestions(input.liveParts);
+  if (fromLive) return fromLive;
+  const last = input.messages[input.messages.length - 1];
+  if (last?.role === "user") return null;
+  if (last?.role === "agent") return extractPendingPlanQuestions(last.parts);
+  return null;
+}
 function formatPlanQuestionAnswers(questions, answers) {
   const lines = ["Answers to your questions:"];
   for (let i = 0; i < questions.length; i++) {
@@ -1447,6 +1547,7 @@ function formatPlanQuestionsForChat(questions) {
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z as z4 } from "zod";
+import { randomUUID as randomUUID3 } from "crypto";
 import { basename } from "path";
 
 // src/mcp/archive-guard.ts
@@ -1941,7 +2042,7 @@ function registerSlackTools(server) {
     },
     async ({ team_id }) => {
       try {
-        await refreshSlackReplyBadges({ force: true });
+        await pollSlackOutboundWatches({ force: true });
         const team = team_id?.trim();
         const watches = listSlackOutboundWatches().filter(
           (w) => !team || w.teamId === team
@@ -2229,6 +2330,283 @@ function registerScheduleTools(server) {
   );
 }
 
+// src/board/load-home-board.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/board/board-pins.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { join } from "path";
+var FILE = "home-board-pins.json";
+var VERSION = 1;
+function pinsFile() {
+  return join(appDataDir(), FILE);
+}
+function readDisk() {
+  const path2 = pinsFile();
+  if (!existsSync(path2)) return [];
+  try {
+    const raw = JSON.parse(readFileSync(path2, "utf8"));
+    if (raw?.version !== VERSION || !Array.isArray(raw.items)) return [];
+    return raw.items.filter((item) => item?.id && item.kind && item.ref);
+  } catch {
+    return [];
+  }
+}
+function writeDisk(items) {
+  mkdirSync(appDataDir(), { recursive: true });
+  writeFileSync(pinsFile(), JSON.stringify({ version: VERSION, items }, null, 2), "utf8");
+}
+function listBoardPins() {
+  return readDisk();
+}
+function addBoardPin(input) {
+  const ref = input.ref.trim();
+  if (!ref) throw new Error("Board item needs a ref");
+  const pin = {
+    id: randomUUID2(),
+    kind: input.kind,
+    ref,
+    repoPath: input.repoPath.trim(),
+    addedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    title: input.title?.trim() || ref,
+    url: input.url,
+    labels: input.labels,
+    provider: input.provider,
+    assignee: input.assignee,
+    cycle: input.cycle,
+    teamKey: input.teamKey,
+    headRefName: input.headRefName,
+    author: input.author,
+    remoteState: "open",
+    needsWorkspacePick: issueNeedsWorkspacePick(
+      input.provider,
+      input.workspaceCount ?? 1
+    )
+  };
+  const items = listBoardPins();
+  const identity = boardPinIdentity(pin);
+  const existing = items.find((item) => boardPinIdentity(item) === identity);
+  if (existing) {
+    const merged = { ...existing, ...pin, id: existing.id, addedAt: existing.addedAt };
+    writeDisk(items.map((item) => item.id === existing.id ? merged : item));
+    return merged;
+  }
+  writeDisk([...items, pin]);
+  return pin;
+}
+function removeBoardPin(id) {
+  const items = listBoardPins();
+  const next = items.filter((item) => item.id !== id);
+  if (next.length === items.length) return false;
+  writeDisk(next);
+  return true;
+}
+function replaceBoardPins(items) {
+  writeDisk(items);
+}
+function clearBoardPins() {
+  try {
+    unlinkSync(pinsFile());
+  } catch {
+  }
+}
+
+// src/board/load-home-board.ts
+var CACHE_VERSION = 1;
+var memory = null;
+var inflight = null;
+function errText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function homeBoardWorkspaceKey(workspaces) {
+  return workspaces.map((w) => w.path).filter(Boolean).sort().join("\n");
+}
+function cacheFile() {
+  return join2(appDataDir(), "home-board-cache.json");
+}
+function emptyInputs() {
+  return {
+    issues: [],
+    prs: [],
+    issueSource: "github",
+    viewerLogin: void 0,
+    issueErrors: [],
+    prErrors: []
+  };
+}
+function asLoaded(entry, fromCache) {
+  const pins = syncBoardPins(listBoardPins(), entry.inputs.issues, entry.inputs.prs);
+  return { ...entry.inputs, fetchedAt: entry.fetchedAt, fromCache, pins };
+}
+function cacheStillFresh(entry, key, now) {
+  return entry.workspaceKey === key && now - entry.fetchedAt < HOME_BOARD_CACHE_TTL_MS;
+}
+function shouldCacheHomeBoardInputs(inputs) {
+  const issuesFailed = inputs.issues.length === 0 && inputs.issueErrors.length > 0;
+  const prsFailed = inputs.prs.length === 0 && inputs.prErrors.length > 0;
+  return !(issuesFailed && prsFailed);
+}
+function readDiskCache() {
+  const path2 = cacheFile();
+  if (!existsSync2(path2)) return null;
+  try {
+    const raw = JSON.parse(readFileSync2(path2, "utf8"));
+    if (raw?.version !== CACHE_VERSION || typeof raw.fetchedAt !== "number") {
+      return null;
+    }
+    if (!raw.inputs || !Array.isArray(raw.inputs.issues) || !Array.isArray(raw.inputs.prs)) {
+      return null;
+    }
+    return raw;
+  } catch {
+    return null;
+  }
+}
+function writeDiskCache(entry) {
+  try {
+    mkdirSync2(appDataDir(), { recursive: true });
+    writeFileSync2(cacheFile(), JSON.stringify(entry), "utf8");
+  } catch {
+  }
+}
+function deleteDiskCache() {
+  try {
+    unlinkSync2(cacheFile());
+  } catch {
+  }
+}
+function resetHomeBoardMemory() {
+  memory = null;
+  inflight = null;
+}
+function clearHomeBoardCache() {
+  resetHomeBoardMemory();
+  deleteDiskCache();
+}
+async function loadHomeBoardInputs(workspaces) {
+  const paths = workspaces.map((w) => w.path).filter(Boolean);
+  if (paths.length === 0) return emptyInputs();
+  const issueErrors = [];
+  const prErrors = [];
+  let issueSource = "github";
+  let viewerLogin;
+  let issues = [];
+  try {
+    const first = await listIssues(paths[0]);
+    issueSource = first.source;
+    viewerLogin = first.viewer?.login || first.viewer?.name || void 0;
+    if (first.source === "linear") {
+      const repoPath = paths[0] ?? "";
+      issues = first.issues.map((issue) => ({
+        ...issue,
+        repoPath,
+        needsWorkspacePick: issueNeedsWorkspacePick(
+          issue.provider ?? first.source,
+          paths.length
+        )
+      }));
+    } else {
+      const settled = await Promise.allSettled(
+        paths.map(async (path2) => {
+          const result = path2 === paths[0] ? first : await listIssues(path2);
+          return result.issues.map((issue) => ({
+            ...issue,
+            repoPath: path2,
+            needsWorkspacePick: issueNeedsWorkspacePick(
+              issue.provider ?? result.source,
+              1
+            )
+          }));
+        })
+      );
+      const collected = [];
+      for (const item of settled) {
+        if (item.status === "fulfilled") collected.push(...item.value);
+        else issueErrors.push(errText(item.reason));
+      }
+      issues = collected;
+      if (collected.length === 0 && issueErrors[0]) {
+        throw new Error(issueErrors[0]);
+      }
+    }
+    issues = dedupeBoardIssues(issues);
+  } catch (err) {
+    issueErrors.push(errText(err));
+    issues = [];
+  }
+  let prs = [];
+  try {
+    const settled = await Promise.allSettled(
+      paths.map(async (path2) => {
+        const list = await listPrs(path2);
+        return list.map((pr) => ({ ...pr, repoPath: path2 }));
+      })
+    );
+    const collected = [];
+    for (const item of settled) {
+      if (item.status === "fulfilled") collected.push(...item.value);
+      else prErrors.push(errText(item.reason));
+    }
+    if (collected.length === 0 && prErrors[0]) {
+      throw new Error(prErrors[0]);
+    }
+    prs = dedupeBoardPrs(collected);
+  } catch (err) {
+    prErrors.push(errText(err));
+    prs = [];
+  }
+  return { issues, prs, issueSource, viewerLogin, issueErrors, prErrors };
+}
+async function getHomeBoardInputs(workspaces, opts) {
+  const key = homeBoardWorkspaceKey(workspaces);
+  const now = opts?.now ?? Date.now();
+  if (!key) {
+    return {
+      ...emptyInputs(),
+      fetchedAt: now,
+      fromCache: false,
+      pins: listBoardPins()
+    };
+  }
+  if (!opts?.refresh) {
+    const disk = readDiskCache();
+    const best = memory && disk ? disk.fetchedAt >= memory.fetchedAt ? disk : memory : memory ?? disk;
+    if (best && cacheStillFresh(best, key, now)) {
+      memory = best;
+      return asLoaded(best, true);
+    }
+  }
+  if (inflight && inflight.key === key) {
+    return inflight.promise;
+  }
+  const promise = (async () => {
+    const inputs = await loadHomeBoardInputs(workspaces);
+    const fetchedAt = opts?.now ?? Date.now();
+    const pins = syncBoardPins(listBoardPins(), inputs.issues, inputs.prs);
+    replaceBoardPins(pins);
+    const loaded = { ...inputs, fetchedAt, fromCache: false, pins };
+    if (shouldCacheHomeBoardInputs(inputs)) {
+      const entry = {
+        version: CACHE_VERSION,
+        workspaceKey: key,
+        fetchedAt,
+        inputs
+      };
+      memory = entry;
+      writeDiskCache(entry);
+    }
+    return loaded;
+  })();
+  inflight = { key, promise };
+  try {
+    return await promise;
+  } finally {
+    if (inflight?.promise === promise) inflight = null;
+  }
+}
+
 // src/mcp/server.ts
 var MAX_ORCH_THREADS = 5;
 var CREATE_THREAD_TIMEOUT_MS = 9e4;
@@ -2249,6 +2627,93 @@ function withTimeout(promise, ms, label) {
     );
   });
 }
+async function createOrchChildThread(orch, args, resolveNewThreadOptions2) {
+  const envParentId = process.env.SIDEBOARD_ORCHESTRATOR_THREAD_ID?.trim() || "";
+  let parentId = args.parentThreadId?.trim() || "";
+  let parent = parentId ? orch.getThread(parentId) : null;
+  let parentCorrectedFrom;
+  if (envParentId) {
+    const envParent = orch.getThread(envParentId);
+    if (envParent) {
+      if (parentId && parentId !== envParentId) parentCorrectedFrom = parentId;
+      else if (!parentId) parentCorrectedFrom = void 0;
+      parentId = envParentId;
+      parent = envParent;
+    }
+  }
+  if (parentId && !parent) {
+    parentCorrectedFrom = parentId;
+    parentId = "";
+    parent = null;
+  }
+  if (parentId) {
+    const children = orch.getThreads(false).filter((t) => t.parentThreadId === parentId);
+    if (children.length >= MAX_ORCH_THREADS) {
+      return {
+        ok: false,
+        text: `Thread-creation cap (${MAX_ORCH_THREADS}) reached for this orchestration session`
+      };
+    }
+  }
+  let agentArg = args.agent;
+  let agentCoercedFrom;
+  const resolvedProbe = resolveNewThreadOptions2({ agent: agentArg }).agent;
+  if (resolvedProbe === "codex") {
+    agentCoercedFrom = agentArg ?? "codex";
+    const accountAgent = resolveNewThreadOptions2({}).agent;
+    agentArg = accountAgent !== "codex" ? accountAgent : "cursor";
+  }
+  const opts = resolveNewThreadOptions2({
+    agent: agentArg,
+    model: args.model
+  });
+  try {
+    const priorIds = new Set(orch.getThreads(false).map((t) => t.id));
+    const thread = await withTimeout(
+      orch.createThread({
+        sourceType: args.sourceType,
+        sourceRef: args.sourceRef,
+        agent: opts.agent,
+        model: opts.model,
+        effort: opts.effort,
+        fast: opts.fast,
+        repoPath: args.repoPath,
+        title: args.title,
+        parentThreadId: parentId || null,
+        cowboy: args.cowboy || void 0,
+        attachments: args.attachments
+      }),
+      CREATE_THREAD_TIMEOUT_MS,
+      "create_thread"
+    );
+    const alreadyStarted = priorIds.has(thread.id);
+    const parentNote = parentCorrectedFrom ? parentId ? `Ignored unknown/stale parentThreadId ${parentCorrectedFrom}; nested under ${parentId}` : `Ignored unknown/stale parentThreadId ${parentCorrectedFrom}; created without parent` : void 0;
+    return {
+      ok: true,
+      text: JSON.stringify({
+        id: thread.id,
+        title: thread.title,
+        branchName: thread.branchName,
+        worktreePath: thread.worktreePath,
+        agent: thread.agent,
+        model: thread.model,
+        status: thread.status,
+        cowboy: Boolean(thread.cowboy),
+        link: `sideboard://thread/${thread.id}`,
+        parentThreadId: thread.parentThreadId,
+        ...alreadyStarted ? { alreadyStarted: true } : {},
+        ...agentCoercedFrom ? {
+          agentCoercedFrom,
+          note: `Avoid nested Codex under a Codex orchestrator \u2014 used Account default agent=${thread.agent}`
+        } : {},
+        ...parentCorrectedFrom ? { parentCorrectedFrom, parentNote } : {}
+      })
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, text: `create_thread failed: ${message}` };
+  }
+}
 async function startMcpServer() {
   const orch = getOrchestrator();
   try {
@@ -2260,7 +2725,7 @@ async function startMcpServer() {
     );
   }
   try {
-    const { maxConcurrentAgents: maxConcurrentAgents2 } = await import("./app-settings-YFWV7MOG.js");
+    const { maxConcurrentAgents: maxConcurrentAgents2 } = await import("./app-settings-6RPALX4J.js");
     orch.setMaxConcurrent(maxConcurrentAgents2());
   } catch {
   }
@@ -2280,7 +2745,7 @@ async function startMcpServer() {
   if (!worktreeProfile) {
     server.tool(
       "list_workspaces",
-      "List registered Sideboard workspaces (repos). Each line is name, path, and github:owner/repo when resolvable \u2014 use path as repoPath for list_branches/list_prs/list_issues/create_thread.",
+      "List registered Sideboard workspaces (repos). Each line is name, path, and github:owner/repo when resolvable \u2014 use path as repoPath for list_board/list_branches/list_prs/list_issues/create_thread.",
       {},
       async () => {
         const workspaces = orch.listWorkspaces();
@@ -2314,6 +2779,51 @@ async function startMcpServer() {
         };
       }
     );
+    server.tool(
+      "list_board",
+      "Home Kanban of worktrees (New, Draft, Review, Merged) \u2014 one card per checkout; sibling chat tabs nest as inner cards. 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), column, limit (default 40). create_thread adds a worktree (and a Home card), or returns the live one if that ticket/PR/named branch is already checked out.",
+      {
+        query: z4.string().optional().describe("Case-insensitive token search across title, id, labels, repo"),
+        repoPath: z4.string().optional().describe("Limit to one workspace path from list_workspaces"),
+        kind: z4.enum(["all", "tickets", "prs", "branches", "threads"]).optional().describe("Filter by worktree source (default all)"),
+        column: z4.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: z4.number().int().positive().optional().describe("Max cards per column (default 40). hidden counts the remainder.")
+      },
+      async ({ query, repoPath, kind, column, limit }) => {
+        const workspaces = orch.listWorkspaces();
+        const all = orch.getThreads(true);
+        const names = new Map(workspaces.map((w) => [w.path, w.name]));
+        const snap = assembleHomeBoard({
+          threads: all.filter((t) => t.status !== "archived"),
+          query,
+          repoPath,
+          kind: kind ?? "all",
+          column: column === "needs_you" ? "new" : column,
+          limit,
+          workspaceName: (path2) => names.get(path2) ?? ""
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  columns: snap.columns,
+                  hidden: snap.hidden,
+                  totals: snap.totals,
+                  columnDefs: BOARD_COLUMN_DEFS,
+                  hint: HOME_BOARD_AGENT_HINT
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    );
     server.tool(
       "get_thread",
       "Get a compact thread summary by id/ref. While running, includes progress (last tool/thinking) and lastActivityAt. Includes usage (thread billed token + costUsd totals when providers reported cost) and lastTurnUsage.",
@@ -2483,7 +2993,7 @@ async function startMcpServer() {
     registerLinearTools(server);
     registerScheduleTools(server);
     const { getCaffeinateHold: getCaffeinateHold2, setCaffeinateHold: setCaffeinateHold2 } = await import("./caffeinate-hold-X3JNPR42.js");
-    const { resolveNewThreadOptions: resolveNewThreadOptions2, resolveThreadDefaults: resolveThreadDefaults2 } = await import("./app-settings-YFWV7MOG.js");
+    const { resolveNewThreadOptions: resolveNewThreadOptions2, resolveThreadDefaults: resolveThreadDefaults2 } = await import("./app-settings-6RPALX4J.js");
     const accountDefaults = resolveThreadDefaults2();
     const accountDefaultsHint = `Account defaults: agent=${accountDefaults.agent}, model=${accountDefaults.model?.trim() || "Auto"}, effort=${accountDefaults.effort}`;
     server.tool(
@@ -2526,7 +3036,7 @@ async function startMcpServer() {
     );
     server.tool(
       "create_thread",
-      `Create a new worktree thread (chat) from branch, pr, or ticket. Pass repoPath from list_workspaces. cowboy=true uses the project folder on the default branch (no isolated worktree; land is commit+push). 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}. Setup (settings.toml, .cursor/worktrees.json, or script/setup) runs in the background in parallel with the first turn (skipped for cowboy). Then use send_to_thread to chat.`,
+      `Create a worktree thread (chat) from branch, pr, or ticket. If a live worktree already matches that ticket, PR, or named branch, returns it (alreadyStarted=true) instead of a second checkout. Creating from the default branch still opens a new isolated worktree. Pass repoPath from list_workspaces. cowboy=true uses the project folder on the default branch (no isolated worktree; land is commit+push). 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}. Setup (settings.toml, .cursor/worktrees.json, or script/setup) runs in the background in parallel with the first turn (skipped for cowboy). Then use send_to_thread to chat.`,
       {
         sourceType: z4.enum(["branch", "pr", "ticket"]),
         sourceRef: z4.string(),
@@ -2544,104 +3054,118 @@ async function startMcpServer() {
         )
       },
       async (args) => {
-        const envParentId = process.env.SIDEBOARD_ORCHESTRATOR_THREAD_ID?.trim() || "";
-        let parentId = args.parentThreadId?.trim() || "";
-        let parent = parentId ? orch.getThread(parentId) : null;
-        let parentCorrectedFrom;
-        if (envParentId) {
-          const envParent = orch.getThread(envParentId);
-          if (envParent) {
-            if (parentId && parentId !== envParentId) parentCorrectedFrom = parentId;
-            else if (!parentId) parentCorrectedFrom = void 0;
-            parentId = envParentId;
-            parent = envParent;
-          }
-        }
-        if (parentId && !parent) {
-          parentCorrectedFrom = parentId;
-          parentId = "";
-          parent = null;
-        }
-        if (parentId) {
-          const children = orch.getThreads(false).filter((t) => t.parentThreadId === parentId);
-          if (children.length >= MAX_ORCH_THREADS) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Thread-creation cap (${MAX_ORCH_THREADS}) reached for this orchestration session`
-                }
-              ],
-              isError: true
-            };
-          }
-        }
-        let agentArg = args.agent;
-        let agentCoercedFrom;
-        const resolvedProbe = resolveNewThreadOptions2({ agent: agentArg }).agent;
-        if (resolvedProbe === "codex") {
-          agentCoercedFrom = agentArg ?? "codex";
-          const accountAgent = resolveNewThreadOptions2({}).agent;
-          agentArg = accountAgent !== "codex" ? accountAgent : "cursor";
-        }
-        const opts = resolveNewThreadOptions2({
-          agent: agentArg,
-          model: args.model
-        });
-        try {
-          const thread = await withTimeout(
-            orch.createThread({
-              sourceType: args.sourceType,
-              sourceRef: args.sourceRef,
-              agent: opts.agent,
-              model: opts.model,
-              effort: opts.effort,
-              fast: opts.fast,
-              repoPath: args.repoPath,
-              title: args.title,
-              parentThreadId: parentId || null,
-              cowboy: args.cowboy || void 0
-            }),
-            CREATE_THREAD_TIMEOUT_MS,
-            "create_thread"
-          );
-          const parentNote = parentCorrectedFrom ? parentId ? `Ignored unknown/stale parentThreadId ${parentCorrectedFrom}; nested under ${parentId}` : `Ignored unknown/stale parentThreadId ${parentCorrectedFrom}; created without parent` : void 0;
+        const result = await createOrchChildThread(orch, args, resolveNewThreadOptions2);
+        return {
+          content: [{ type: "text", text: result.text }],
+          ...result.ok ? {} : { isError: true }
+        };
+      }
+    );
+    server.tool(
+      "start_board_card",
+      "Same as create_thread for a ticket, PR, or named branch (attaches issue text when Sideboard can resolve it). Reuses the live worktree if one already matches. Then send_to_thread.",
+      {
+        kind: z4.enum(["ticket", "pr", "branch"]),
+        ref: z4.string().describe("Ticket identifier (ENG-12), PR number (44), or branch name from list_board"),
+        repoPath: z4.string().describe("Workspace path from list_workspaces / list_board"),
+        title: z4.string().optional()
+      },
+      async ({ kind, ref, repoPath, title }) => {
+        const root = await resolveRepoRoot(repoPath);
+        const existing = findLiveThreadForCreate(
+          {
+            sourceType: kind,
+            sourceRef: ref.trim(),
+            repoPath: canonicalizeRepoPath(root),
+            title: title?.trim()
+          },
+          orch.getThreads(false).map((t) => ({
+            ...t,
+            repoPath: canonicalizeRepoPath(t.repoPath)
+          }))
+        );
+        if (existing) {
           return {
             content: [
               {
                 type: "text",
                 text: JSON.stringify({
-                  id: thread.id,
-                  title: thread.title,
-                  branchName: thread.branchName,
-                  worktreePath: thread.worktreePath,
-                  agent: thread.agent,
-                  model: thread.model,
-                  status: thread.status,
-                  cowboy: Boolean(thread.cowboy),
-                  link: `sideboard://thread/${thread.id}`,
-                  parentThreadId: thread.parentThreadId,
-                  ...agentCoercedFrom ? {
-                    agentCoercedFrom,
-                    note: `Avoid nested Codex under a Codex orchestrator \u2014 used Account default agent=${thread.agent}`
-                  } : {},
-                  ...parentCorrectedFrom ? { parentCorrectedFrom, parentNote } : {}
+                  alreadyStarted: true,
+                  id: existing.id,
+                  title: existing.title,
+                  status: existing.status,
+                  link: `sideboard://thread/${existing.id}`
                 })
               }
             ]
           };
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
+        }
+        const workspaces = orch.listWorkspaces();
+        const loaded = await getHomeBoardInputs(workspaces);
+        const pin = findBoardPin(loaded.pins, kind, ref, root);
+        if (kind === "branch") {
+          const sourceRef = pin?.ref === "default" ? "default" : pin?.ref ?? ref.trim();
+          const result2 = await createOrchChildThread(
+            orch,
+            {
+              sourceType: "branch",
+              sourceRef,
+              repoPath: root,
+              title: title?.trim() || pin?.title || (sourceRef === "default" ? void 0 : sourceRef)
+            },
+            resolveNewThreadOptions2
+          );
           return {
-            content: [
-              {
-                type: "text",
-                text: `create_thread failed: ${message}`
-              }
-            ],
-            isError: true
+            content: [{ type: "text", text: result2.text }],
+            ...result2.ok ? {} : { isError: true }
           };
         }
+        if (kind === "ticket") {
+          const issue = findBoardIssue(loaded.issues, ref, root);
+          const ident = issue?.identifier ?? ref.trim();
+          const attachments = issue ? [
+            {
+              id: randomUUID3(),
+              name: issue.identifier,
+              kind: "issue",
+              content: [
+                `Linked issue: ${issue.identifier} \u2014 ${issue.title}`,
+                issue.url ? `URL: ${issue.url}` : null
+              ].filter(Boolean).join("\n")
+            }
+          ] : void 0;
+          const result2 = await createOrchChildThread(
+            orch,
+            {
+              sourceType: "ticket",
+              sourceRef: ident,
+              repoPath: root,
+              title: title?.trim() || issue?.title,
+              attachments
+            },
+            resolveNewThreadOptions2
+          );
+          return {
+            content: [{ type: "text", text: result2.text }],
+            ...result2.ok ? {} : { isError: true }
+          };
+        }
+        const pr = findBoardPr(loaded.prs, ref, root);
+        const number = pr ? String(pr.number) : ref.trim().replace(/^#/, "");
+        const result = await createOrchChildThread(
+          orch,
+          {
+            sourceType: "pr",
+            sourceRef: number,
+            repoPath: root,
+            title: title?.trim() || pr?.title
+          },
+          resolveNewThreadOptions2
+        );
+        return {
+          content: [{ type: "text", text: result.text }],
+          ...result.ok ? {} : { isError: true }
+        };
       }
     );
     server.tool(
@@ -3288,7 +3812,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.",
+      "List issues from Sideboard Account connections (Linear API or GitHub Issues; Linear\u2192GitHub fallback when Linear is not connected). Linear returns issues assigned to you (includes cycle). Pass repoPath from list_workspaces \u2014 GitHub Issues are scoped to that repo. Prefer list_board for Home columns + current-cycle filter. Then create_thread with sourceType=ticket.",
       { repoPath: z4.string() },
       async ({ repoPath }) => {
         const root = await resolveRepoRoot(repoPath);
@@ -3630,14 +4154,14 @@ async function runCloudConnect(opts) {
 }
 
 // src/agents/user-mcp-config.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import { homedir } from "os";
-import { dirname, join } from "path";
+import { dirname, join as join3 } from "path";
 function userCursorMcpConfigPath() {
-  return join(homedir(), ".cursor", "mcp.json");
+  return join3(homedir(), ".cursor", "mcp.json");
 }
 function userClaudeMcpConfigPath() {
-  return join(homedir(), ".claude.json");
+  return join3(homedir(), ".claude.json");
 }
 function asObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return {};
@@ -3664,16 +4188,16 @@ function mergeSideboardIntoMcpServersJson(existing, sideboard) {
 }
 function writeMergedMcpServersJson(configPath, sideboard) {
   let existing = {};
-  if (existsSync(configPath)) {
+  if (existsSync3(configPath)) {
     try {
-      existing = JSON.parse(readFileSync(configPath, "utf8"));
+      existing = JSON.parse(readFileSync3(configPath, "utf8"));
     } catch {
       existing = {};
     }
   }
   const next = mergeSideboardIntoMcpServersJson(existing, sideboard);
-  mkdirSync(dirname(configPath), { recursive: true });
-  writeFileSync(configPath, `${JSON.stringify(next, null, 2)}
+  mkdirSync3(dirname(configPath), { recursive: true });
+  writeFileSync3(configPath, `${JSON.stringify(next, null, 2)}
 `);
 }
 function launchFromResolved(server) {
@@ -3691,7 +4215,7 @@ async function registerPackagedUserMcpClients() {
   const cursor = userCursorMcpConfigPath();
   writeMergedMcpServersJson(cursor, launch);
   const claude = userClaudeMcpConfigPath();
-  if (existsSync(claude)) {
+  if (existsSync3(claude)) {
     writeMergedMcpServersJson(claude, launch);
     return { cursor, claude };
   }
@@ -5620,6 +6144,8 @@ export {
   GITHUB_GIT_AUTH_MODES,
   GLOBAL_WORKSPACE_ID,
   HARNESS_ENV_KEYS,
+  HOME_BOARD_CACHE_TTL_MS,
+  ISSUE_SOURCE_LABELS,
   LEGACY_ATTACHMENTS_DIR,
   LEGACY_PLAN_FILE_REL,
   LEGACY_REVIEW_REQUEST_PATH,
@@ -5661,6 +6187,7 @@ export {
   THINKING_EFFORTS,
   WORKTREE_MCP_TOOLS,
   ackSlackInboundSeen,
+  addBoardPin,
   addPrStackLayer,
   addStackLayerFromThread,
   addWorkspace,
@@ -5714,15 +6241,19 @@ export {
   caffeinateWhileRunningEnabled,
   caffeinateWhileSchedulesEnabled,
   caffeinateWhileSlackListenEnabled,
+  canonicalizeRepoPath,
   captureLoginEnv,
   captureTurnBaseline,
   checkoutPrStackLayer,
   childEnvWithAppSettings,
   claimDesktopHost,
+  classifyWorktreeColumn,
   claudeAdapter,
   claudeChromeEnabled,
   claudeUserSettingsPath,
   cleanupOrphanWorktrees,
+  clearBoardPins,
+  clearHomeBoardCache,
   cloneRepoIntoSideboard,
   codexAdapter,
   codexSandboxWritableRootsArgs,
@@ -5771,7 +6302,6 @@ export {
   disconnectLinearConnection,
   disconnectSlackWorkspace,
   discoverSkills,
-  dismissSlackReplyBadge,
   dropCachedPrefixOnResume,
   encodeBrightsyTarget,
   enrichPathWithNpmGlobalBin,
@@ -5796,6 +6326,7 @@ export {
   finalizeParts,
   findConventionSetup,
   findInvalidCacheControlTtlOrder,
+  findLiveThreadForCreate,
   findOrphanWorktrees,
   findSlackCoordinator,
   findThreadByRef,
@@ -5847,6 +6378,7 @@ export {
   getGitHubStatus,
   getGithubGitAuthMode,
   getGithubPat,
+  getHomeBoardInputs,
   getIssueSource,
   getLinearApiKey,
   getLinearAuthToken,
@@ -5869,6 +6401,7 @@ export {
   git,
   githubAgentGitEnv,
   globalAgentCwd,
+  groupHomeBoardWorktrees,
   handleSlackInbound,
   harnessEnvKey,
   hasBakedLinearOAuth,
@@ -5902,9 +6435,11 @@ export {
   isGhRateLimitError,
   isGlobalRepoPath,
   isGlobalThread,
+  isHomeBoardThread,
   isImageFilePath,
   isInPrStack,
   isInboundForThisDesktop,
+  isIssueSourceConnected,
   isLinearConnected,
   isLinearOAuthCancelled,
   isOrchestratorCapableAgent,
@@ -5927,12 +6462,16 @@ export {
   isThreadCaffeinated,
   isThreadRecordFile,
   isWorkspaceScratchPath,
+  issueSourceLabel,
   lastRequestOccupancy,
+  latestPendingPlanQuestions,
   linearAuthorizationHeader,
+  linearCycleIsActive,
   linearGraphql,
   linearOAuthAuthorizeUrl,
   linearOAuthCredentials,
   listAgentSetupInfo,
+  listBoardPins,
   listBranchCommits,
   listBranches,
   listBrightsyAccounts,
@@ -5944,6 +6483,7 @@ export {
   listGitHubIssues,
   listGlobalThreads,
   listIssues,
+  listLinearAssignedIssues,
   listLinearIssues,
   listLinearIssuesDirect,
   listLinearTeams,
@@ -5953,7 +6493,6 @@ export {
   listRunScripts,
   listSchedules,
   listSlackOutboundWatches,
-  listSlackReplyBadges,
   listSlackWorkspaces,
   listThreads,
   listWorkspaces,
@@ -5964,6 +6503,7 @@ export {
   loadAppSettings,
   loadBrightsyConfig,
   loadConductorSettings,
+  loadHomeBoardInputs,
   loadRepoSettings,
   loadWorkspaceSettings,
   locksDir,
@@ -6009,10 +6549,11 @@ export {
   partsToAssistantText,
   pastedTextStats,
   pendingSlackExternalReplies,
-  permalinkForSlackReplyBadge,
   permissionMode,
   persistVaultKeyInKeychain,
   planFileAbs,
+  planQuestionsSignature,
+  pollSlackOutboundWatches,
   posixShellSingleQuote,
   preferredCursorCostCents,
   prepareTerminalCommand,
@@ -6030,10 +6571,10 @@ export {
   recordScheduleRun,
   recordSlackOutboundWatch,
   refreshGitHubAuth,
-  refreshSlackReplyBadges,
   registerPackagedUserMcpClients,
   releaseCaffeinateHoldForThread,
   releaseDesktopHost,
+  removeBoardPin,
   removeWorkspace,
   removeWorktree,
   repoSlug,
@@ -6180,6 +6721,7 @@ export {
   withMaxOldSpaceSize,
   withThreadLock,
   workspaceSettingsSourceLabel,
+  worktreeBoardStatus,
   worktreeCleanupSettings,
   worktreeDisplayLabel,
   worktreeDisplayLabelForGroup,