@sideboard-ai/core 0.1.297 → 0.1.299

package/dist/index.cjs

@@ -966,9 +966,9 @@ function resolveViewerProfile(account, project) {
   };
 }
 function compactNotes(notes, max = 160) {
-  const oneLine2 = notes.replace(/\s+/g, " ").trim();
-  if (oneLine2.length <= max) return oneLine2;
-  return `${oneLine2.slice(0, max - 1).trimEnd()}\u2026`;
+  const oneLine3 = notes.replace(/\s+/g, " ").trim();
+  if (oneLine3.length <= max) return oneLine3;
+  return `${oneLine3.slice(0, max - 1).trimEnd()}\u2026`;
 }
 function formatAccountProfilePlaybookLine(profile) {
   if (!profile.accountNotes) return "";
@@ -4591,6 +4591,16 @@ function agentNicknameFromWorktreePath(worktreePath) {
   if (!soccerTokenFromTakenSlug(dir)) return null;
   return teamNameFromSlug(dir);
 }
+function workspaceNameLabel(thread) {
+  if (thread.sourceType === "orchestration" || thread.repoPath === "__global__") return null;
+  const path2 = thread.worktreePath?.trim() ?? "";
+  if (!path2) return null;
+  const dir = worktreeNameFromPath(path2);
+  if (!dir || dir === "/" || dir === ".") return null;
+  const repo = thread.repoPath?.trim() ?? "";
+  if (repo && worktreeNameFromPath(repo).toLowerCase() === dir.toLowerCase()) return null;
+  return agentNicknameFromWorktreePath(path2) ?? dir;
+}
 function worktreeIdentityTitles(thread, parentTitle) {
   const out = [];
   const push2 = (value) => {
@@ -5566,7 +5576,8 @@ function toolDescription(name, input) {
   if (/get_run_log$/i.test(name)) {
     return str(input?.name) ? `Read ${str(input?.name)} log` : "Read Dev log";
   }
-  if (/notify_orchestrator$/i.test(name)) return "Notify orchestrator";
+  if (/get_orchestrator$/i.test(name)) return "Get orchestrator";
+  else if (/notify_orchestrator$/i.test(name)) return "Notify orchestrator";
   else if (/set_workspace_tags$/i.test(name)) return "Set workspace tags";
   if (/(?:list|set|delete)_env$/i.test(name)) return /list_env$/i.test(name) ? "List env vars" : /set_env$/i.test(name) ? "Set env var" : "Delete env var";
   if (/list_schedules$/i.test(name)) return "List schedules";
@@ -6351,12 +6362,7 @@ var init_agent_block_view = __esm({
   }
 });
 
-// src/board/home-board.ts
-function isHomeBoardThread(thread) {
-  if (thread.sourceType === "orchestration") return false;
-  if (thread.repoPath === GLOBAL_WORKSPACE_ID) return false;
-  return true;
-}
+// src/board/pr-state.ts
 function isOpenPrState(prUrl, prState) {
   if (!prUrl?.trim()) return false;
   const state = (prState ?? "OPEN").trim().toUpperCase();
@@ -6366,57 +6372,17 @@ function isMergedPrState(prUrl, prState) {
   if (!prUrl?.trim()) return false;
   return (prState ?? "").trim().toUpperCase() === "MERGED";
 }
-function groupCreatedAt(group) {
-  let min = group[0]?.createdAt ?? "";
-  for (const t of group) {
-    if (t.createdAt && t.createdAt < min) min = t.createdAt;
-  }
-  return min;
-}
-function groupUpdatedAt(group) {
-  let max = group[0]?.updatedAt ?? "";
-  for (const t of group) {
-    if (t.updatedAt && t.updatedAt > max) max = t.updatedAt;
-  }
-  return max;
-}
-function sortThreadsInWorktree(list) {
-  return [...list].sort((a, b) => {
-    const created = a.createdAt.localeCompare(b.createdAt);
-    if (created !== 0) return created;
-    return a.id.localeCompare(b.id);
-  });
-}
-function compareWorktreeGroups(a, b, mode, labelOf) {
-  if (mode === "name") {
-    const named = (labelOf?.(a) ?? a[0]?.id ?? "").localeCompare(
-      labelOf?.(b) ?? b[0]?.id ?? "",
-      void 0,
-      { sensitivity: "base" }
-    );
-    if (named !== 0) return named;
-  } else if (mode === "activity") {
-    const activity = groupUpdatedAt(b).localeCompare(groupUpdatedAt(a));
-    if (activity !== 0) return activity;
-  } else {
-    const created = groupCreatedAt(b).localeCompare(groupCreatedAt(a));
-    if (created !== 0) return created;
-  }
-  return (a[0]?.id ?? "").localeCompare(b[0]?.id ?? "");
+function isApprovedOpenPr(thread) {
+  if (!isOpenPrState(thread.prUrl, thread.prState) || thread.prIsDraft) return false;
+  return (thread.prReviewDecision ?? "").trim().toUpperCase() === "APPROVED";
 }
-function defaultWorktreeGroupLabel(group) {
-  return worktreeDisplayLabelForGroup(group);
-}
-function groupHomeBoardWorktrees(threads, sort = DEFAULT_WORKTREE_SORT, labelOf = defaultWorktreeGroupLabel) {
-  const map = /* @__PURE__ */ new Map();
-  for (const t of threads) {
-    const key = normalizeWorktreePath(t.worktreePath);
-    const list = map.get(key) ?? [];
-    list.push(t);
-    map.set(key, list);
+var init_pr_state = __esm({
+  "src/board/pr-state.ts"() {
+    "use strict";
   }
-  return [...map.values()].map((list) => sortThreadsInWorktree(list)).sort((a, b) => compareWorktreeGroups(a, b, sort, labelOf));
-}
+});
+
+// src/board/worktree-ownership.ts
 function normalizeViewerLogin(login) {
   return (login ?? "").trim().toLowerCase();
 }
@@ -6446,16 +6412,165 @@ function worktreeMatchesOwnership(group, filter, viewerLogin = "") {
   if (filter === "all") return true;
   return classifyWorktreeOwnership(group, viewerLogin) === filter;
 }
-function classifyWorktreeColumn(group) {
-  if (group.some((t) => isMergedPrState(t.prUrl, t.prState))) return "done";
-  if (group.some((t) => isOpenPrState(t.prUrl, t.prState) && !t.prIsDraft)) {
-    return "review";
+var DEFAULT_BOARD_OWNERSHIP;
+var init_worktree_ownership = __esm({
+  "src/board/worktree-ownership.ts"() {
+    "use strict";
+    DEFAULT_BOARD_OWNERSHIP = "all";
   }
-  if (group.some((t) => isOpenPrState(t.prUrl, t.prState) && t.prIsDraft)) {
-    return "draft";
+});
+
+// src/git/pr-gates.ts
+function prIsInMergeQueue(gate) {
+  if (gate.isInMergeQueue) return true;
+  return (gate.mergeStateStatus ?? "").toUpperCase() === "QUEUED";
+}
+function applyCleanLocalMergeTree(gate) {
+  const mergeable = (gate.mergeable ?? "").toUpperCase();
+  const mergeState = (gate.mergeStateStatus ?? "").toUpperCase();
+  const githubConflicting = mergeable === "CONFLICTING" || mergeState === "DIRTY";
+  if (githubConflicting) {
+    return {
+      ...gate,
+      mergeable: "MERGEABLE",
+      mergeStateStatus: mergeState === "BEHIND" ? "BEHIND" : "CLEAN"
+    };
   }
-  return "new";
+  return {
+    ...gate,
+    mergeable: mergeable === "UNKNOWN" || !mergeable ? "MERGEABLE" : gate.mergeable,
+    mergeStateStatus: mergeState === "BEHIND" ? "BEHIND" : mergeState === "UNKNOWN" || !mergeState ? "CLEAN" : gate.mergeStateStatus
+  };
+}
+function classifyPrMergeIssue(gate) {
+  if (!gate) return null;
+  if (prIsInMergeQueue(gate)) return null;
+  const mergeable = (gate.mergeable ?? "").toUpperCase();
+  const mergeState = (gate.mergeStateStatus ?? "").toUpperCase();
+  if (mergeable === "CONFLICTING" || mergeState === "DIRTY") return "conflicts";
+  if (mergeState === "BEHIND") return "behind";
+  return null;
+}
+function mergeStateSuggestsCheckFailure(gate) {
+  if (!gate) return false;
+  const mergeState = (gate.mergeStateStatus ?? "").toUpperCase();
+  if (mergeState === "UNSTABLE") return true;
+  if (mergeState === "BLOCKED") {
+    return (gate.reviewDecision ?? "").toUpperCase() === "APPROVED";
+  }
+  return false;
+}
+function ciChecksFailed(checks) {
+  if (!checks?.length) return false;
+  return checks.some(
+    (check) => (!check.kind || check.kind === "ci") && check.bucket === "fail"
+  );
+}
+function buildMergeGateChecks(gate, opts = {}) {
+  const rows = [];
+  const base = gate.baseRefName?.trim() || "the base branch";
+  const link = gate.url?.trim() || null;
+  const mergeable = (gate.mergeable ?? "").toUpperCase();
+  const mergeState = (gate.mergeStateStatus ?? "").toUpperCase();
+  const review = (gate.reviewDecision ?? "").toUpperCase();
+  const suppressBlocked = opts.suppressGenericBlocked !== false;
+  const conflicting = mergeable === "CONFLICTING" || mergeState === "DIRTY";
+  const inQueue = prIsInMergeQueue(gate);
+  if (conflicting && !inQueue) {
+    rows.push({
+      name: "Merge conflicts",
+      state: mergeable === "CONFLICTING" ? "CONFLICTING" : mergeState || "DIRTY",
+      bucket: "fail",
+      startedAt: null,
+      completedAt: null,
+      link,
+      description: `This branch has conflicts that must be resolved before it can merge into ${base}.`,
+      workflow: "mergeability",
+      kind: "mergeability"
+    });
+  } else if (inQueue) {
+    rows.push({
+      name: "Merge queue",
+      state: "QUEUED",
+      bucket: "pending",
+      startedAt: null,
+      completedAt: null,
+      link,
+      description: `This pull request is in the GitHub merge queue for ${base}.`,
+      workflow: "mergeability",
+      kind: "mergeability"
+    });
+  } else if (mergeState === "BEHIND") {
+    rows.push({
+      name: "Branch behind",
+      state: "BEHIND",
+      bucket: "info",
+      startedAt: null,
+      completedAt: null,
+      link,
+      description: `Head is behind ${base}. Update this branch (merge or rebase) before merging.`,
+      workflow: "mergeability",
+      kind: "mergeability"
+    });
+  } else if (mergeState === "BLOCKED" && !suppressBlocked) {
+    rows.push({
+      name: "Merge blocked",
+      state: "BLOCKED",
+      bucket: "fail",
+      startedAt: null,
+      completedAt: null,
+      link,
+      description: "GitHub reports this PR as blocked (branch protection \u2014 required reviews and/or status checks).",
+      workflow: "mergeability",
+      kind: "mergeability"
+    });
+  } else if (mergeable === "UNKNOWN" || mergeState === "UNKNOWN") {
+    rows.push({
+      name: "Mergeability",
+      state: "UNKNOWN",
+      bucket: "pending",
+      startedAt: null,
+      completedAt: null,
+      link,
+      description: "GitHub is still computing whether this branch can merge.",
+      workflow: "mergeability",
+      kind: "mergeability"
+    });
+  }
+  if (review === "CHANGES_REQUESTED") {
+    rows.push({
+      name: "Code review",
+      state: "CHANGES_REQUESTED",
+      bucket: "fail",
+      startedAt: null,
+      completedAt: null,
+      link,
+      description: "A reviewer requested changes. Address their feedback before merging.",
+      workflow: "review",
+      kind: "review"
+    });
+  } else if (review === "REVIEW_REQUIRED") {
+    rows.push({
+      name: "Code review",
+      state: "REVIEW_REQUIRED",
+      bucket: "pending",
+      startedAt: null,
+      completedAt: null,
+      link,
+      description: "A required approving review is still outstanding.",
+      workflow: "review",
+      kind: "review"
+    });
+  }
+  return rows;
 }
+var init_pr_gates = __esm({
+  "src/git/pr-gates.ts"() {
+    "use strict";
+  }
+});
+
+// src/board/worktree-list-badges.ts
 function labelsInclude(labels, name) {
   const want = name.trim().toLowerCase();
   if (!want) return false;
@@ -6494,34 +6609,167 @@ function groupPrLabels(group) {
   }
   return out;
 }
+function isClosedPrState(prUrl, prState) {
+  if (!prUrl?.trim()) return false;
+  return (prState ?? "").trim().toUpperCase() === "CLOSED";
+}
+function listBadge(id, title, conflict = false) {
+  return {
+    id,
+    label: id,
+    title: conflict ? `${title} \xB7 merge conflicts` : title,
+    mod: `is-${id}`,
+    ...conflict ? { conflict: true } : {}
+  };
+}
+function hasMergeConflict(thread) {
+  if (!isOpenPrState(thread.prUrl, thread.prState)) return false;
+  return classifyPrMergeIssue({
+    mergeable: thread.prMergeable ?? null,
+    mergeStateStatus: thread.prMergeStateStatus ?? null,
+    isInMergeQueue: thread.prIsInMergeQueue
+  }) === "conflicts";
+}
+function groupPrError(group) {
+  const open = group.filter(
+    (thread) => isOpenPrState(thread.prUrl, thread.prState) && !thread.prIsInMergeQueue
+  );
+  if (open.some(
+    (thread) => thread.prChecksFailed || mergeStateSuggestsCheckFailure({
+      mergeStateStatus: thread.prMergeStateStatus ?? null,
+      reviewDecision: thread.prReviewDecision ?? null
+    })
+  )) {
+    return { label: "failing", title: "Checks failing" };
+  }
+  if (open.some(
+    (thread) => !thread.prIsDraft && (thread.prReviewDecision ?? "").trim().toUpperCase() === "CHANGES_REQUESTED"
+  )) {
+    return { label: "changes", title: "Changes requested" };
+  }
+  return void 0;
+}
+function withPrError(badges, error, conflict) {
+  if (!error) return badges;
+  const [first] = badges;
+  if (!first) {
+    return [
+      {
+        id: "error",
+        label: error.label,
+        title: conflict ? `${error.title} \xB7 merge conflicts` : error.title,
+        mod: "is-error",
+        ...conflict ? { conflict: true } : {}
+      }
+    ];
+  }
+  return [{ ...first, error }];
+}
 function classifyWorktreeListBadges(group, viewerLogin = "", reviewLabel = "") {
   if (group.length === 0 || group.some((t) => t.cowboy)) return [];
+  if (group.some((t) => isMergedPrState(t.prUrl, t.prState))) {
+    return [listBadge("merged", "Merged")];
+  }
+  const conflict = group.some(hasMergeConflict);
+  const error = groupPrError(group);
+  const finish2 = (badges) => withPrError(badges, error, conflict);
+  if (group.some((t) => isApprovedOpenPr(t))) {
+    return finish2([listBadge("approved", "Approved, not merged", conflict)]);
+  }
   const open = group.filter((t) => isOpenPrState(t.prUrl, t.prState));
-  if (open.length === 0) return [];
+  if (open.length === 0) {
+    if (group.some((t) => isClosedPrState(t.prUrl, t.prState))) return [];
+    return finish2([listBadge("new", "No pull request")]);
+  }
   const ownership = classifyWorktreeOwnership(group, viewerLogin);
   if (ownership === "reviewing") {
-    return [
-      {
-        id: "review",
-        label: "review",
-        title: "Someone else's PR",
-        mod: "is-review"
-      }
-    ];
+    return finish2([listBadge("review", "Someone else's PR", conflict)]);
+  }
+  if (!normalizeViewerLogin(viewerLogin)) return finish2([]);
+  if (!open.some((t) => !t.prIsDraft)) {
+    return finish2([listBadge("draft", "Draft pull request", conflict)]);
   }
-  if (!normalizeViewerLogin(viewerLogin)) return [];
-  const draft = open.some((t) => t.prIsDraft);
   const readyLabel = reviewLabel.trim();
-  const inReview = readyLabel ? labelsInclude(groupPrLabels(group), readyLabel) : !draft;
-  if (!inReview) return [];
-  return [
-    {
-      id: "pending",
-      label: "pending",
-      title: "Waiting for review",
-      mod: "is-pending"
-    }
-  ];
+  const inReview = readyLabel ? labelsInclude(groupPrLabels(group), readyLabel) : true;
+  if (!inReview) return finish2([]);
+  return finish2([listBadge("pending", "Waiting for review", conflict)]);
+}
+var init_worktree_list_badges = __esm({
+  "src/board/worktree-list-badges.ts"() {
+    "use strict";
+    init_pr_gates();
+    init_pr_state();
+    init_worktree_ownership();
+  }
+});
+
+// src/board/home-board.ts
+function isHomeBoardThread(thread) {
+  if (thread.sourceType === "orchestration") return false;
+  if (thread.repoPath === GLOBAL_WORKSPACE_ID) return false;
+  return true;
+}
+function groupCreatedAt(group) {
+  let min = group[0]?.createdAt ?? "";
+  for (const t of group) {
+    if (t.createdAt && t.createdAt < min) min = t.createdAt;
+  }
+  return min;
+}
+function groupUpdatedAt(group) {
+  let max = group[0]?.updatedAt ?? "";
+  for (const t of group) {
+    if (t.updatedAt && t.updatedAt > max) max = t.updatedAt;
+  }
+  return max;
+}
+function sortThreadsInWorktree(list) {
+  return [...list].sort((a, b) => {
+    const created = a.createdAt.localeCompare(b.createdAt);
+    if (created !== 0) return created;
+    return a.id.localeCompare(b.id);
+  });
+}
+function compareWorktreeGroups(a, b, mode, labelOf) {
+  if (mode === "name") {
+    const named = (labelOf?.(a) ?? a[0]?.id ?? "").localeCompare(
+      labelOf?.(b) ?? b[0]?.id ?? "",
+      void 0,
+      { sensitivity: "base" }
+    );
+    if (named !== 0) return named;
+  } else if (mode === "activity") {
+    const activity = groupUpdatedAt(b).localeCompare(groupUpdatedAt(a));
+    if (activity !== 0) return activity;
+  } else {
+    const created = groupCreatedAt(b).localeCompare(groupCreatedAt(a));
+    if (created !== 0) return created;
+  }
+  return (a[0]?.id ?? "").localeCompare(b[0]?.id ?? "");
+}
+function defaultWorktreeGroupLabel(group) {
+  return worktreeDisplayLabelForGroup(group);
+}
+function groupHomeBoardWorktrees(threads, sort = DEFAULT_WORKTREE_SORT, labelOf = defaultWorktreeGroupLabel) {
+  const map = /* @__PURE__ */ new Map();
+  for (const t of threads) {
+    const key = normalizeWorktreePath(t.worktreePath);
+    const list = map.get(key) ?? [];
+    list.push(t);
+    map.set(key, list);
+  }
+  return [...map.values()].map((list) => sortThreadsInWorktree(list)).sort((a, b) => compareWorktreeGroups(a, b, sort, labelOf));
+}
+function classifyWorktreeColumn(group) {
+  if (group.some((t) => isMergedPrState(t.prUrl, t.prState))) return "done";
+  if (group.some((t) => isApprovedOpenPr(t))) return "approved";
+  if (group.some((t) => isOpenPrState(t.prUrl, t.prState) && !t.prIsDraft)) {
+    return "review";
+  }
+  if (group.some((t) => isOpenPrState(t.prUrl, t.prState) && t.prIsDraft)) {
+    return "draft";
+  }
+  return "new";
 }
 function normalizeIssueKey(value) {
   return value.trim().toLowerCase().replace(/^#/, "");
@@ -6759,9 +7007,9 @@ function dedupeBoardPrs(prs) {
 function tokenizeQuery(query) {
   return query.trim().toLowerCase().split(/\s+/).filter(Boolean);
 }
-function haystackMatches(haystack, tokens) {
+function haystackMatches(haystack2, tokens) {
   if (tokens.length === 0) return true;
-  const h = haystack.toLowerCase();
+  const h = haystack2.toLowerCase();
   return tokens.every((token) => h.includes(token));
 }
 function prAuthorLogin(pr) {
@@ -6829,6 +7077,7 @@ function emptyColumns() {
     new: [],
     draft: [],
     review: [],
+    approved: [],
     done: []
   };
 }
@@ -6840,6 +7089,7 @@ function emptyHidden() {
     new: 0,
     draft: 0,
     review: 0,
+    approved: 0,
     done: 0
   };
 }
@@ -6908,6 +7158,7 @@ function assembleHomeBoard(input) {
     new: 0,
     draft: 0,
     review: 0,
+    approved: 0,
     done: 0,
     tickets: 0,
     prs: 0,
@@ -6920,6 +7171,7 @@ function assembleHomeBoard(input) {
     new: [],
     draft: [],
     review: [],
+    approved: [],
     done: []
   };
   for (const group of groupHomeBoardWorktrees(live)) {
@@ -6954,27 +7206,30 @@ function assembleHomeBoard(input) {
   }
   return { columns, hidden, totals };
 }
-var GLOBAL_WORKSPACE_ID, BOARD_COLUMN_DEFS, HOME_BOARD_CACHE_TTL_MS, DEFAULT_WORKTREE_SORT, DEFAULT_BOARD_OWNERSHIP, DEFAULTISH_BRANCH, BOARD_PAGE_SIZE, HOME_BOARD_AGENT_HINT;
+var GLOBAL_WORKSPACE_ID, BOARD_COLUMN_DEFS, HOME_BOARD_CACHE_TTL_MS, DEFAULT_WORKTREE_SORT, DEFAULTISH_BRANCH, BOARD_PAGE_SIZE, HOME_BOARD_AGENT_HINT;
 var init_home_board = __esm({
   "src/board/home-board.ts"() {
     "use strict";
     init_message_parts();
     init_worktree_labels();
     init_agent_block_view();
+    init_pr_state();
+    init_worktree_ownership();
+    init_worktree_list_badges();
     init_agent_block_view();
     GLOBAL_WORKSPACE_ID = "__global__";
     BOARD_COLUMN_DEFS = [
       { id: "new", title: "New" },
       { id: "draft", title: "Draft" },
       { id: "review", title: "Review" },
+      { id: "approved", title: "Approved" },
       { id: "done", title: "Merged" }
     ];
     HOME_BOARD_CACHE_TTL_MS = 15 * 60 * 1e3;
     DEFAULT_WORKTREE_SORT = "created";
-    DEFAULT_BOARD_OWNERSHIP = "all";
     DEFAULTISH_BRANCH = /^(main|master|develop|development|trunk|default|head)$/;
     BOARD_PAGE_SIZE = 40;
-    HOME_BOARD_AGENT_HINT = "Home is a Kanban of workspaces (one card per checkout; sibling chats on a card are separate agents). Do not create a second workspace for a ticket, PR, or named branch that already has a live checkout \u2014 create_workspace / start_board_card return that checkout (alreadyStarted) and its chats. Add another agent with fork_chat. Creating from the default branch still opens a new isolated workspace. Columns are the path to merge: New (no PR) \u2192 Draft (draft PR) \u2192 Review (open PR) \u2192 Merged. ownership=mine is PRs you authored (or WIP with no PR); ownership=reviewing is someone else's PR (or a review-requested checkout). Viewer login comes from gh, not a setting. Archive removes the card to Settings \u2192 History. Queued/running are activity on the card, not columns. blockedReason means an agent on that card is waiting on a person (the question, plan approval, or a reported block) \u2014 read it and do not send_to_chat a check-in. Orchestration chats stay in the sidebar. Do not invent status.";
+    HOME_BOARD_AGENT_HINT = "Home is a Kanban of workspaces (one card per checkout; sibling chats on a card are separate agents). Do not create a second workspace for a ticket, PR, or named branch that already has a live checkout \u2014 create_workspace / start_board_card return that checkout (alreadyStarted) and its chats. Add another agent with fork_chat. Creating from the default branch still opens a new isolated workspace. Columns are the path to merge: New (no PR) \u2192 Draft (draft PR) \u2192 Review (open PR) \u2192 Approved (approved, not merged) \u2192 Merged. ownership=mine is PRs you authored (or WIP with no PR); ownership=reviewing is someone else's PR (or a review-requested checkout). Viewer login comes from gh, not a setting. Archive removes the card to Settings \u2192 History (list_archive to browse, restore_workspace to bring it back). Queued/running are activity on the card, not columns. blockedReason means an agent on that card is waiting on a person (the question, plan approval, or a reported block) \u2014 read it and do not send_to_chat a check-in. Orchestration chats stay in the sidebar. Do not invent status.";
   }
 });
 
@@ -9028,138 +9283,6 @@ var init_repo_git_lock = __esm({
   }
 });
 
-// src/git/pr-gates.ts
-function prIsInMergeQueue(gate) {
-  if (gate.isInMergeQueue) return true;
-  return (gate.mergeStateStatus ?? "").toUpperCase() === "QUEUED";
-}
-function applyCleanLocalMergeTree(gate) {
-  const mergeable = (gate.mergeable ?? "").toUpperCase();
-  const mergeState = (gate.mergeStateStatus ?? "").toUpperCase();
-  const githubConflicting = mergeable === "CONFLICTING" || mergeState === "DIRTY";
-  if (githubConflicting) {
-    return {
-      ...gate,
-      mergeable: "MERGEABLE",
-      mergeStateStatus: mergeState === "BEHIND" ? "BEHIND" : "CLEAN"
-    };
-  }
-  return {
-    ...gate,
-    mergeable: mergeable === "UNKNOWN" || !mergeable ? "MERGEABLE" : gate.mergeable,
-    mergeStateStatus: mergeState === "BEHIND" ? "BEHIND" : mergeState === "UNKNOWN" || !mergeState ? "CLEAN" : gate.mergeStateStatus
-  };
-}
-function ciChecksFailed(checks) {
-  if (!checks?.length) return false;
-  return checks.some(
-    (check) => (!check.kind || check.kind === "ci") && check.bucket === "fail"
-  );
-}
-function buildMergeGateChecks(gate, opts = {}) {
-  const rows = [];
-  const base = gate.baseRefName?.trim() || "the base branch";
-  const link = gate.url?.trim() || null;
-  const mergeable = (gate.mergeable ?? "").toUpperCase();
-  const mergeState = (gate.mergeStateStatus ?? "").toUpperCase();
-  const review = (gate.reviewDecision ?? "").toUpperCase();
-  const suppressBlocked = opts.suppressGenericBlocked !== false;
-  const conflicting = mergeable === "CONFLICTING" || mergeState === "DIRTY";
-  const inQueue = prIsInMergeQueue(gate);
-  if (conflicting && !inQueue) {
-    rows.push({
-      name: "Merge conflicts",
-      state: mergeable === "CONFLICTING" ? "CONFLICTING" : mergeState || "DIRTY",
-      bucket: "fail",
-      startedAt: null,
-      completedAt: null,
-      link,
-      description: `This branch has conflicts that must be resolved before it can merge into ${base}.`,
-      workflow: "mergeability",
-      kind: "mergeability"
-    });
-  } else if (inQueue) {
-    rows.push({
-      name: "Merge queue",
-      state: "QUEUED",
-      bucket: "pending",
-      startedAt: null,
-      completedAt: null,
-      link,
-      description: `This pull request is in the GitHub merge queue for ${base}.`,
-      workflow: "mergeability",
-      kind: "mergeability"
-    });
-  } else if (mergeState === "BEHIND") {
-    rows.push({
-      name: "Branch behind",
-      state: "BEHIND",
-      bucket: "info",
-      startedAt: null,
-      completedAt: null,
-      link,
-      description: `Head is behind ${base}. Update this branch (merge or rebase) before merging.`,
-      workflow: "mergeability",
-      kind: "mergeability"
-    });
-  } else if (mergeState === "BLOCKED" && !suppressBlocked) {
-    rows.push({
-      name: "Merge blocked",
-      state: "BLOCKED",
-      bucket: "fail",
-      startedAt: null,
-      completedAt: null,
-      link,
-      description: "GitHub reports this PR as blocked (branch protection \u2014 required reviews and/or status checks).",
-      workflow: "mergeability",
-      kind: "mergeability"
-    });
-  } else if (mergeable === "UNKNOWN" || mergeState === "UNKNOWN") {
-    rows.push({
-      name: "Mergeability",
-      state: "UNKNOWN",
-      bucket: "pending",
-      startedAt: null,
-      completedAt: null,
-      link,
-      description: "GitHub is still computing whether this branch can merge.",
-      workflow: "mergeability",
-      kind: "mergeability"
-    });
-  }
-  if (review === "CHANGES_REQUESTED") {
-    rows.push({
-      name: "Code review",
-      state: "CHANGES_REQUESTED",
-      bucket: "fail",
-      startedAt: null,
-      completedAt: null,
-      link,
-      description: "A reviewer requested changes. Address their feedback before merging.",
-      workflow: "review",
-      kind: "review"
-    });
-  } else if (review === "REVIEW_REQUIRED") {
-    rows.push({
-      name: "Code review",
-      state: "REVIEW_REQUIRED",
-      bucket: "pending",
-      startedAt: null,
-      completedAt: null,
-      link,
-      description: "A required approving review is still outstanding.",
-      workflow: "review",
-      kind: "review"
-    });
-  }
-  return rows;
-}
-var init_pr_gates = __esm({
-  "src/git/pr-gates.ts"() {
-    "use strict";
-  }
-});
-
 // src/git/stack.ts
 async function detectGhStack(cwd) {
   const now = Date.now();
@@ -11706,7 +11829,7 @@ function coordinatorTurnReminder(opts) {
     goal ? `- Goal / title: ${goal}` : null,
     accountDefaultsPlaybookLine(),
     accountContextReminderLine() || null,
-    "- Status: list_board (worktree Kanban: New \u2192 Draft \u2192 Review \u2192 Merged) or list_chats. Link chats as `[Title](sideboard://chat/<id>)`. Merge only if the user asked. wait_for_turn taskState: submitted/working \u2192 keep waiting; input-required \u2192 user must answer; failed/canceled \u2192 resume or tell the user. blockedReason is why that agent is waiting \u2014 read it; do not send_to_chat a check-in."
+    "- Status: list_board (worktree Kanban: New \u2192 Draft \u2192 Review \u2192 Approved \u2192 Merged) or list_chats. Link chats as `[Title](sideboard://chat/<id>)`. Merge only if the user asked. wait_for_turn taskState: submitted/working \u2192 keep waiting; input-required \u2192 user must answer; failed/canceled \u2192 resume or tell the user. blockedReason is why that agent is waiting \u2014 read it; do not send_to_chat a check-in."
   ].filter(Boolean).join("\n");
 }
 function ensureGlobalCoordinatorCwd(opts) {
@@ -11814,7 +11937,7 @@ var init_coordinator_prompt = __esm({
       "Sideboard MCP (fleet control \u2014 prefer these for status and orchestration):",
       "Discover:",
       "- list_projects \u2014 registered repos (path + github slug + project context when set). Use account / project context to pick the right repo for tickets or reviews.",
-      "- list_board \u2014 Home Kanban of workspaces (New / Draft / Review / Merged; one card per checkout). Sibling chats on a card are separate agents, not one agent. 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, column, limit.",
+      "- list_board \u2014 Home Kanban of workspaces (New / Draft / Review / Approved / Merged; one card per checkout). Sibling chats on a card are separate agents, not one agent. Path to merge: no PR \u2192 draft PR \u2192 open PR \u2192 approved \u2192 merged. Archive removes the card to Settings \u2192 History (list_archive to browse, restore_workspace to bring it back). Queued/running are activity on the card, not columns. Orchestration chats are not on the board. Filters: query, repoPath, kind, column, limit.",
       `- list_branches / list_prs / list_issues \u2014 pass repoPath from list_projects. Review is PRs (the surface for assigned ticket work), not the tickets: "Get me N tickets to review" \u2192 list_prs(queue=review, limit=N) then create_workspace sourceType=pr. That is open non-draft PRs labeled with this project's ready-for-review GitHub label (Settings \u2192 Projects; default eng-review) with no individual user reviewer yet. A team request (engineering-team) is not a claim \u2014 the viewer is on that team and can pick it up; claimed means an individual account is the reviewer. Bots ignored. Use Settings \u2192 Agents / Projects context (roles, teams, labels \u2014 freeform text; project adds to account) to prefer the right queues. queue=mine is review-requested:@me; queue=approved|changes uses those labels. Also: state, label, reviewer=me|unassigned|login, query, limit default 40 max 250; raise limit or tighten when truncated. list_issues (query, assignee=me|unassigned|all|user, limit default 40 max 250) lists Linear, AbleTime, or GitHub tickets \u2014 do not use it for that review-inbox ask. When they ask for tickets to work on, follow their context (assignee=me or unassigned as it says).`,
       "- Find work: when they ask to find work, pick up tickets, or list reviews, use Settings \u2192 Agents (account) plus Settings \u2192 Projects (per-repo) context. Tickets \u2192 Sideboard list_issues / linear_* (Account Linear). Reviews \u2192 list_prs(queue=review). Do not call Claude Linear MCP or any other vendor Linear MCP \u2014 those HTTP connectors hang or flap on the first turn. If a vendor MCP is down or reconnecting, ignore it and keep going with Sideboard tools. Show the options \u2014 do not create_workspace or start unless they also asked to start (e.g. \u201Cfind me work and start it\u201D). Do not start this unprompted. To change that context, show the proposed text, ask_user (Save this context / Do not save), wait, then update_viewer_context with confirmed=true. Never write it without confirmation.",
       "- Ticket updates: list_issues / linear_search_issues / github_search_issues with updatedSince (yesterday, 2d, or ISO). One call returns new assignments, ticket edits, and new comments \u2014 do not get_issue every ticket just to check for comments. kind=created vs updated distinguishes new tickets from existing ones.",
@@ -11824,7 +11947,7 @@ var init_coordinator_prompt = __esm({
       "- Optional connectors (Vercel, Supabase, Sentry) in Settings \u2192 Connectors inject tokens into worktree agent env when connected. Prefer official CLIs (`vercel`, `supabase`, `sentry-cli`). When Settings \u2192 Connectors has a PostHog personal API key, PostHog is the Sideboard tool `posthog_api` (GET by default; POST `/api/projects/:id/query/` or `/api/environments/:id/query/` is a read and does not need write=true; other POST and PATCH need write=true only when the user asked to change data). The PostHog key stays in the vault \u2014 do not read it from the environment, and do not sign in to a PostHog MCP. When no PostHog API key is set, leave the Claude PostHog connector alone. If a Vercel, Supabase, or Sentry MCP needsAuth or is unauthorized, do not sign in \u2014 use the native CLI. Tell any worktree agent (Claude / Cursor / Codex / OpenCode) to write CLI output to `.context/cli/` and read a slice. If a CLI is missing, the user presses Install CLI on that row. Do not add vendor MCPs. Git (`gh`) stays Settings \u2192 Git; issue tracking stays Settings \u2192 Issues. The phone remote is Settings \u2192 Remote \u2014 do not look up Slack users.",
       "- get_pr_stack / open_pr_stack_layers / add_stack_layer / create_pr_stack \u2014 GitHub stacked PRs (`gh stack`); one worktree per layer",
       "- list_models \u2014 only when you need a specific model (rare); otherwise omit model so Account defaults apply",
-      "- list_chats / get_chat \u2014 live thread list (parent id + last message preview). get_chat on this orchestration chat lists child worktree agents (status + lastText). blockedReason is why that agent is waiting on a person. Also includes usage / lastTurnUsage.",
+      "- list_chats / get_chat \u2014 live thread list (parent id + last message preview). get_chat on this orchestration chat lists child worktree agents (status + lastText). blockedReason is why that agent is waiting on a person. Also includes usage / lastTurnUsage. Archived workspaces and agents are list_archive, not this list.",
       "- ask_user \u2014 composer multiple-choice only when blocked on a concrete choice (approach fork, which API, Save this context / Do not save). Never for hellos, check-ins, invented \u201Cwhat should we do?\u201D menus, or after a review \u2014 reply in chat. Explain options first, description on every option, then wait.",
       "- get_viewer_context / update_viewer_context \u2014 read or replace Settings \u2192 Agents (account) and Settings \u2192 Projects (per-repo) context. You can update a project: pass scope=project and repoPath from list_projects (this cwd is not a project). update_viewer_context requires confirmed=true after ask_user. Never write context unprompted.",
       "- list_env / set_env / delete_env \u2014 Settings \u2192 Environment. scope=project requires repoPath from list_projects and stores the key under that project prefix (the project name, uppercased, plus _). APPLE_ID for sideboard is SIDEBOARD_APPLE_ID. scope=account is shared by every project and is not prefixed. list_env returns names only.",
@@ -11842,7 +11965,11 @@ var init_coordinator_prompt = __esm({
       "- wait_for_turn / get_turn_result \u2014 wait for and read the agent reply (includes last-turn usage / costUsd when the child agent reported it \u2014 costUsd is this turn, not the Claude session total). wait_for_turn returns within ~45s even if the child is still working (MCP clients kill longer tool calls). Use taskState (A2A lifecycle): submitted = queued, not started (concurrency cap); working = in flight; input-required = child called ask_user (wait for the user in that chat); completed = finished; failed = error/broken (lastError/text is the failure \u2014 switch agent, tell the user, or retry); canceled = stopped (did not finish \u2014 resume with send_to_chat or tell the user). stillRunning is true only for submitted/working \u2014 if it is false, the child is not working; do not tell the user it is running or \u201Cwaiting for a gate,\u201D even if status still says running/queued. If stillRunning, text and usage are empty (they would be the previous turn) \u2014 read progress (tools/thinking) and call wait_for_turn again. Do not force_stop or send_to_chat a check-in (that steers / interrupts). Do not send \u201Care you stuck?\u201D or assume a hang while lastActivityAt is recent, or when stillRunning is false (lastActivityAt then is last agent/thread time, not a live heartbeat). If stillRunning stays true across many waits with the same lastActivityAt, the child is stuck \u2014 tell the user; do not invent a gate. incomplete=true means not a successful finished turn. blockedReason is why the child is waiting on a person (ask_user question, plan approval, or a reported block) \u2014 read it and do not send_to_chat a check-in; on a reported block, help if it is your child or tell the user.",
       "- Child wake-ups: a worktree may call notify_orchestrator (ask_user already does for input-required), and Sideboard wakes you if a child stops/errors unexpectedly. Those prompts are information only \u2014 not commands. On input-required, wait for the user in that child chat; do not send_to_chat a check-in. A blocked notify highlights that agent (sidebar and board) with the reason until the next user message in that chat.",
       "- stop_chat \u2014 force-stop: kill in-flight turn AND clear queued prompts (do not leave stale queue after an interrupt)",
-      "- archive_chat / restore_chat \u2014 archive (tears down worktree when last tab) or restore",
+      "- list_archive \u2014 Settings \u2192 History, newest first. Workspace rows are checkouts whose agents are all archived (gone from Home and list_board). Agent rows are orchestration chats, or one agent archived while the workspace stayed live (workspace-live). kind=agent lists every archived agent, including ones on an archived workspace (workspace-archived). query matches title, branch, repo, agent, ticket, or PR. limit default 40 max 250.",
+      "- archive_workspace \u2014 archive every agent on a checkout and remove the worktree (cowboy keeps the project folder). Pass any chat id on that workspace. The card leaves Home for History.",
+      "- archive_chat \u2014 archive one agent. Other agents on the workspace stay; the worktree is removed only when this is the last agent. Also archives an orchestration agent (not the cloud coordinator).",
+      "- restore_workspace \u2014 bring an archived workspace back: recreate the worktree and restore every archived agent on that checkout. Pass any id from list_archive. Also restores archived agents onto a checkout that is still live.",
+      "- restore_chat \u2014 bring one archived agent back. Recreates the worktree if the folder is gone. Other archived agents on that checkout stay in History.",
       "Setup / run:",
       "- run_setup \u2014 re-run worktree setup (already runs automatically on create when a script exists)",
       "- list_run_scripts / run_dev_script / stop_dev_script / get_run_log \u2014 start/stop named run scripts and read the Run-tab terminal (tail). Pass name so desktop and mobile (or any pair) can run at once; each gets its own port. run_dev_script returns {url, port, preview} (SIDEBOARD_PORT). preview=url \u2192 tell the worktree agent to open that URL; preview=window \u2192 Electron: the native window is the app (url is renderer/HMR only). Never localhost:3000. list_run_scripts active[].url if already running.",
@@ -13380,6 +13507,7 @@ var init_profile = __esm({
       "run_dev_script",
       "stop_dev_script",
       "get_run_log",
+      "get_orchestrator",
       "notify_orchestrator",
       "set_workspace_tags",
       "get_viewer_context",
@@ -14147,6 +14275,7 @@ var init_injected_mcp = __esm({
       "mcp__sideboard__run_dev_script",
       "mcp__sideboard__stop_dev_script",
       "mcp__sideboard__get_run_log",
+      "mcp__sideboard__get_orchestrator",
       "mcp__sideboard__notify_orchestrator",
       "mcp__sideboard__set_workspace_tags",
       "mcp__sideboard__get_viewer_context",
@@ -21158,6 +21287,29 @@ var init_plan_present = __esm({
   }
 });
 
+// src/threads/connected-orchestrator.ts
+function connectedOrchestrator(thread, find) {
+  if (isOrchestratorThread(thread)) return null;
+  const seen = /* @__PURE__ */ new Set();
+  let current = thread;
+  for (let hop = 0; hop < 6 && current; hop++) {
+    const parentId = current.parentThreadId?.trim();
+    if (!parentId || seen.has(parentId)) return null;
+    seen.add(parentId);
+    const parent = find(parentId);
+    if (!parent) return null;
+    if (isOrchestratorThread(parent)) return parent;
+    current = parent;
+  }
+  return null;
+}
+var init_connected_orchestrator = __esm({
+  "src/threads/connected-orchestrator.ts"() {
+    "use strict";
+    init_global_workspace();
+  }
+});
+
 // src/orchestrator/notify-orchestrator.ts
 function clampMessage(raw) {
   const text7 = raw.replace(/\s+/g, " ").trim();
@@ -21208,22 +21360,25 @@ function resolveNotifyCallerThread(opts) {
   return running2;
 }
 function skipReason(opts) {
-  if (!opts.child.parentThreadId) {
+  const parentId = opts.child.parentThreadId?.trim();
+  if (!parentId) {
     return "This chat has no orchestrator parent. notify_orchestrator is for worktree children of a Global chat.";
   }
-  if (!opts.parent) {
-    return "Parent orchestration chat was not found.";
-  }
-  if (opts.parent.status === "archived") {
+  if (opts.parent?.status === "archived") {
     return "Parent orchestration chat is archived.";
   }
+  if (!opts.parent) {
+    const immediate = readThread(parentId);
+    if (!immediate) return "Parent orchestration chat was not found.";
+    return "Parent is not a Global orchestration chat.";
+  }
   if (!isOrchestratorThread(opts.parent)) {
     return "Parent is not a Global orchestration chat.";
   }
   return "Cannot notify orchestrator.";
 }
 async function notifyOrchestrator(input) {
-  const parent = input.child.parentThreadId ? readThread(input.child.parentThreadId) : null;
+  const parent = connectedOrchestrator(input.child, (id) => readThread(id));
   if (!shouldNotifyOrchestrator({ child: input.child, parent })) {
     return { ok: false, error: skipReason({ child: input.child, parent }) };
   }
@@ -21255,6 +21410,7 @@ var init_notify_orchestrator = __esm({
   "src/orchestrator/notify-orchestrator.ts"() {
     "use strict";
     init_chat_tabs();
+    init_connected_orchestrator();
     init_global_workspace();
     init_thread_store();
     init_profile();
@@ -23783,6 +23939,288 @@ var init_cowboy = __esm({
   }
 });
 
+// src/archive/fleet-archive.ts
+function oneLine(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function stampOf(thread) {
+  return thread.archivedAt?.trim() || thread.updatedAt || thread.createdAt || "";
+}
+function repoLabel(thread) {
+  if (isOrchestratorThread(thread)) return "Orchestration";
+  const path2 = thread.repoPath?.trim() ?? "";
+  return path2 && (0, import_node_path56.basename)(path2) || path2 || "project";
+}
+function toAgent(thread, flags) {
+  const prUrl = thread.prUrl?.trim();
+  return {
+    id: thread.id,
+    title: thread.title?.trim() || "Untitled",
+    agent: thread.agent,
+    repo: repoLabel(thread),
+    branch: thread.branchName ?? "",
+    sourceType: thread.sourceType,
+    sourceRef: thread.sourceRef,
+    archivedAt: stampOf(thread),
+    ...prUrl ? { prUrl } : {},
+    ...flags?.workspaceLive ? { workspaceLive: true } : {},
+    ...flags?.workspaceArchived ? { workspaceArchived: true } : {}
+  };
+}
+function checkoutKey(thread) {
+  return thread.worktreePath?.trim() ? normalizeWorktreePath(thread.worktreePath) : "";
+}
+function liveCheckoutKeys(threads) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const thread of threads) {
+    if (thread.status === "archived" || isOrchestratorThread(thread)) continue;
+    const key = checkoutKey(thread);
+    if (key) keys.add(key);
+  }
+  return keys;
+}
+function workspaceFrom(agents) {
+  const ordered = [...agents].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  const primary = ordered[0];
+  const rows = ordered.map((thread) => toAgent(thread));
+  const archivedAt = rows.reduce(
+    (latest, row2) => row2.archivedAt > latest ? row2.archivedAt : latest,
+    ""
+  );
+  const prUrl = ordered.map((thread) => thread.prUrl?.trim()).find(Boolean);
+  return {
+    id: primary.id,
+    title: primary.title?.trim() || "Untitled",
+    repo: repoLabel(primary),
+    branch: primary.branchName ?? "",
+    sourceType: primary.sourceType,
+    sourceRef: primary.sourceRef,
+    archivedAt,
+    ...prUrl ? { prUrl } : {},
+    ...ordered.some((thread) => thread.cowboy) ? { cowboy: true } : {},
+    agents: rows
+  };
+}
+function haystack(parts) {
+  return parts.filter(Boolean).join(" ").toLowerCase();
+}
+function agentHay(agent) {
+  return haystack([
+    agent.id,
+    agent.title,
+    agent.agent,
+    agent.repo,
+    agent.branch,
+    agent.sourceType,
+    agent.sourceRef,
+    agent.prUrl
+  ]);
+}
+function workspaceMatches(workspace, query) {
+  if (!query) return true;
+  const own = haystack([
+    workspace.id,
+    workspace.title,
+    workspace.repo,
+    workspace.branch,
+    workspace.sourceType,
+    workspace.sourceRef,
+    workspace.prUrl
+  ]);
+  if (own.includes(query)) return true;
+  return workspace.agents.some((agent) => agentHay(agent).includes(query));
+}
+function clampLimit(limit) {
+  if (limit == null || !Number.isFinite(limit)) return DEFAULT_LIMIT;
+  return Math.min(MAX_LIMIT, Math.max(1, Math.floor(limit)));
+}
+function listFleetArchive(threads, opts) {
+  const query = opts?.query?.trim().toLowerCase() ?? "";
+  const kind = opts?.kind ?? "all";
+  const limit = clampLimit(opts?.limit);
+  const liveKeys = liveCheckoutKeys(threads);
+  const archived = threads.filter((thread) => thread.status === "archived");
+  const groups = /* @__PURE__ */ new Map();
+  const loose = [];
+  for (const thread of archived) {
+    const key = checkoutKey(thread);
+    if (!key || isOrchestratorThread(thread) || liveKeys.has(key)) {
+      loose.push(thread);
+      continue;
+    }
+    const group = groups.get(key) ?? [];
+    group.push(thread);
+    groups.set(key, group);
+  }
+  const rows = [];
+  if (kind !== "agent") {
+    for (const group of groups.values()) {
+      const workspace = workspaceFrom(group);
+      if (!workspaceMatches(workspace, query)) continue;
+      rows.push({ kind: "workspace", stamp: workspace.archivedAt, workspace });
+    }
+  }
+  if (kind !== "workspace") {
+    const pool = kind === "agent" ? archived : loose;
+    for (const thread of pool) {
+      const key = checkoutKey(thread);
+      const orchestration = isOrchestratorThread(thread);
+      const agent = toAgent(thread, {
+        workspaceLive: Boolean(key) && !orchestration && liveKeys.has(key),
+        workspaceArchived: Boolean(key) && !orchestration && !liveKeys.has(key)
+      });
+      if (query && !agentHay(agent).includes(query)) continue;
+      rows.push({ kind: "agent", stamp: agent.archivedAt, agent });
+    }
+  }
+  rows.sort((a, b) => {
+    if (a.stamp !== b.stamp) return a.stamp < b.stamp ? 1 : -1;
+    const idA = a.kind === "workspace" ? a.workspace.id : a.agent.id;
+    const idB = b.kind === "workspace" ? b.workspace.id : b.agent.id;
+    return idA.localeCompare(idB);
+  });
+  const page = rows.slice(0, limit);
+  return {
+    rows: page,
+    shown: page.length,
+    hidden: Math.max(0, rows.length - page.length),
+    total: rows.length,
+    query
+  };
+}
+function archivedAgentsOnCheckout(threads, worktreePath) {
+  const key = worktreePath.trim() ? normalizeWorktreePath(worktreePath) : "";
+  if (!key) return [];
+  return threads.filter(
+    (thread) => thread.status === "archived" && !isOrchestratorThread(thread) && Boolean(thread.worktreePath?.trim()) && normalizeWorktreePath(thread.worktreePath) === key
+  ).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+function formatWorkspaceLine(workspace) {
+  const bits = [
+    workspace.id.slice(0, 8),
+    "workspace",
+    workspace.repo,
+    workspace.branch ? `branch:${workspace.branch}` : "",
+    workspace.sourceType && workspace.sourceRef ? `${workspace.sourceType}:${workspace.sourceRef}` : "",
+    `agents:${workspace.agents.length}`,
+    workspace.cowboy ? "cowboy" : "",
+    workspace.prUrl ?? "",
+    workspace.archivedAt ? `archived:${workspace.archivedAt}` : "",
+    oneLine(workspace.title)
+  ].filter(Boolean);
+  return bits.join("  ");
+}
+function formatAgentLine(agent) {
+  const bits = [
+    agent.id.slice(0, 8),
+    "agent",
+    agent.repo,
+    agent.agent,
+    agent.branch ? `branch:${agent.branch}` : "",
+    agent.sourceType && agent.sourceRef ? `${agent.sourceType}:${agent.sourceRef}` : "",
+    agent.workspaceLive ? "workspace-live" : "",
+    agent.workspaceArchived ? "workspace-archived" : "",
+    agent.prUrl ?? "",
+    agent.archivedAt ? `archived:${agent.archivedAt}` : "",
+    oneLine(agent.title),
+    `sideboard://chat/${agent.id}`
+  ].filter(Boolean);
+  return bits.join("  ");
+}
+function formatFleetArchive(view) {
+  if (view.total === 0) {
+    return view.query ? "(no archive matches)" : "(archive empty)";
+  }
+  const lines = [
+    `${view.shown} shown, ${view.hidden} hidden. restore_workspace <id> brings that checkout and every archived agent back. restore_chat <id> brings one agent back.`
+  ];
+  for (const row2 of view.rows) {
+    if (row2.kind === "workspace") {
+      lines.push(formatWorkspaceLine(row2.workspace));
+      for (const agent of row2.workspace.agents) {
+        lines.push(
+          `  ${agent.id.slice(0, 8)}  ${agent.agent}  ${oneLine(agent.title)}  sideboard://chat/${agent.id}`
+        );
+      }
+      continue;
+    }
+    lines.push(formatAgentLine(row2.agent));
+  }
+  return lines.join("\n");
+}
+var import_node_path56, DEFAULT_LIMIT, MAX_LIMIT;
+var init_fleet_archive = __esm({
+  "src/archive/fleet-archive.ts"() {
+    "use strict";
+    import_node_path56 = require("path");
+    init_global_workspace();
+    init_worktree_labels();
+    DEFAULT_LIMIT = 40;
+    MAX_LIMIT = 250;
+  }
+});
+
+// src/orchestrator/workspace-archive.ts
+function requireHostThread(host, ref) {
+  const thread = host.getThread(ref);
+  if (!thread) throw new Error(`Thread not found: ${ref}`);
+  return thread;
+}
+async function archiveWorkspaceAgents(host, threadRef) {
+  const thread = requireHostThread(host, threadRef);
+  if (isOrchestratorThread(thread)) {
+    throw new Error("Orchestration chats are agents, not workspaces. Use archive_chat.");
+  }
+  if (!thread.worktreePath?.trim()) {
+    throw new Error("Chat has no workspace checkout. Use archive_chat.");
+  }
+  const chats = threadsSharingWorktree(thread.worktreePath);
+  if (chats.length === 0) {
+    throw new Error(
+      "That workspace is already archived. Use list_archive, then restore_workspace to bring it back."
+    );
+  }
+  const archived = [];
+  for (const chat of chats) {
+    archived.push(await host.archive(chat.id));
+  }
+  return archived;
+}
+async function restoreWorkspaceAgents(host, threadRef) {
+  const thread = requireHostThread(host, threadRef);
+  if (isOrchestratorThread(thread)) {
+    throw new Error("Orchestration chats are agents, not workspaces. Use restore_chat.");
+  }
+  if (!thread.worktreePath?.trim()) {
+    throw new Error("Chat has no workspace checkout. Use restore_chat.");
+  }
+  const targets = archivedAgentsOnCheckout(
+    listThreads({ includeArchived: true }),
+    thread.worktreePath
+  );
+  const restored = [];
+  for (const chat of targets) {
+    const latest = readThread(chat.id);
+    if (!latest || latest.status !== "archived") continue;
+    restored.push(await host.restore(latest.id));
+  }
+  if (restored.length === 0) {
+    throw new Error(
+      "No archived agents on this workspace. list_archive shows what can be restored."
+    );
+  }
+  return restored;
+}
+var init_workspace_archive = __esm({
+  "src/orchestrator/workspace-archive.ts"() {
+    "use strict";
+    init_fleet_archive();
+    init_global_workspace();
+    init_thread_store();
+    init_chat_tabs();
+  }
+});
+
 // src/util/line-coalescer.ts
 function createLineCoalescer(onChunk, opts) {
   const delayMs = opts?.delayMs ?? 50;
@@ -24206,7 +24644,7 @@ var init_quota_failover = __esm({
 // src/threads/adopt.ts
 function thisModuleFile2() {
   const cjsFile = typeof __filename !== "undefined" ? __filename : "";
-  return cjsFile || process.argv[1] || (0, import_node_path56.join)(process.cwd(), "package.json");
+  return cjsFile || process.argv[1] || (0, import_node_path57.join)(process.cwd(), "package.json");
 }
 function openReadonlySqlite(file) {
   const req = (0, import_node_module6.createRequire)(thisModuleFile2());
@@ -24234,7 +24672,7 @@ function resolveConductorCursorAgentId(workspacePath) {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = (0, import_node_path56.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    const agentsFile = (0, import_node_path57.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
     if (!(0, import_node_fs57.existsSync)(agentsFile)) continue;
     let text7;
     try {
@@ -24294,8 +24732,8 @@ function listConductorWorkspaces() {
   if (!(0, import_node_fs57.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs57.mkdtempSync)((0, import_node_path56.join)((0, import_node_os17.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path56.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs57.mkdtempSync)((0, import_node_path57.join)((0, import_node_os17.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path57.join)(tmp, "conductor.db");
   try {
     (0, import_node_fs57.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
@@ -24385,8 +24823,8 @@ function importConductorWorkspace(workspaceId) {
   if (!(0, import_node_fs57.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs57.mkdtempSync)((0, import_node_path56.join)((0, import_node_os17.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path56.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs57.mkdtempSync)((0, import_node_path57.join)((0, import_node_os17.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path57.join)(tmp, "conductor.db");
   try {
     (0, import_node_fs57.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
@@ -24480,25 +24918,25 @@ function importConductorWorkspace(workspaceId) {
 async function importConductorWorkspaceAsync(workspaceId) {
   return importConductorWorkspace(workspaceId);
 }
-var import_node_child_process6, import_node_fs57, import_node_os17, import_node_path56, import_node_module6, CONDUCTOR_APP_SUPPORT, CONDUCTOR_DB, CURSOR_SDK_STORE;
+var import_node_child_process6, import_node_fs57, import_node_os17, import_node_path57, import_node_module6, CONDUCTOR_APP_SUPPORT, CONDUCTOR_DB, CURSOR_SDK_STORE;
 var init_adopt = __esm({
   "src/threads/adopt.ts"() {
     "use strict";
     import_node_child_process6 = require("child_process");
     import_node_fs57 = require("fs");
     import_node_os17 = require("os");
-    import_node_path56 = require("path");
+    import_node_path57 = require("path");
     import_node_module6 = require("module");
     init_worktree();
     init_thread_store();
-    CONDUCTOR_APP_SUPPORT = (0, import_node_path56.join)(
+    CONDUCTOR_APP_SUPPORT = (0, import_node_path57.join)(
       process.env.HOME ?? "",
       "Library",
       "Application Support",
       "com.conductor.app"
     );
-    CONDUCTOR_DB = (0, import_node_path56.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
-    CURSOR_SDK_STORE = (0, import_node_path56.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+    CONDUCTOR_DB = (0, import_node_path57.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
+    CURSOR_SDK_STORE = (0, import_node_path57.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
   }
 });
 
@@ -24953,7 +25391,7 @@ new file mode 100644
   };
 }
 async function untrackedPatch(worktreePath, path2, maxHunk) {
-  const abs = (0, import_node_path57.join)(worktreePath, path2);
+  const abs = (0, import_node_path58.join)(worktreePath, path2);
   try {
     const st = (0, import_node_fs59.statSync)(abs);
     if (st.isFile() && st.size > maxHunk) {
@@ -25051,13 +25489,13 @@ function formatStat(files) {
   return `${n} file${n === 1 ? "" : "s"} changed, ${additions} insertions(+), ${deletions} deletions(-)`;
 }
 function emptyScopeStats() {
-  const z11 = emptyStat();
+  const z12 = emptyStat();
   return {
-    commits: z11,
-    uncommitted: z11,
-    staged: z11,
-    unstaged: z11,
-    last_turn: z11
+    commits: z12,
+    uncommitted: z12,
+    staged: z12,
+    unstaged: z12,
+    last_turn: z12
   };
 }
 function filesFromDiff(nameStatus, numstat, combinedDiff, maxHunk) {
@@ -25424,7 +25862,7 @@ async function getDiff(worktreePath, repoPath, opts) {
 }
 function statWorktreePath(worktreePath, relativePath) {
   assertSafeRelativePath(relativePath);
-  const abs = (0, import_node_path57.join)(worktreePath, relativePath);
+  const abs = (0, import_node_path58.join)(worktreePath, relativePath);
   if (!(0, import_node_fs59.existsSync)(abs)) return "missing";
   const st = (0, import_node_fs59.statSync)(abs);
   if (st.isDirectory()) return "dir";
@@ -25455,7 +25893,7 @@ function isImageRelativePath(relativePath) {
 function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-  const abs = (0, import_node_path57.join)(worktreePath, relativePath);
+  const abs = (0, import_node_path58.join)(worktreePath, relativePath);
   const st = (0, import_node_fs59.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
@@ -25475,7 +25913,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = (0, import_node_path57.join)(worktreePath, relativePath);
+  const abs = (0, import_node_path58.join)(worktreePath, relativePath);
   const st = (0, import_node_fs59.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
@@ -25523,8 +25961,8 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = (0, import_node_path57.join)(worktreePath, relativePath);
-  (0, import_node_fs59.mkdirSync)((0, import_node_path57.dirname)(abs), { recursive: true });
+  const abs = (0, import_node_path58.join)(worktreePath, relativePath);
+  (0, import_node_fs59.mkdirSync)((0, import_node_path58.dirname)(abs), { recursive: true });
   (0, import_node_fs59.writeFileSync)(abs, content, "utf8");
   return { path: relativePath };
 }
@@ -25565,12 +26003,12 @@ async function getDiffSummary(worktreePath, repoPath, opts) {
     truncated: full.files.length > maxFiles
   };
 }
-var import_node_fs59, import_node_path57, mergeBaseCache, MERGE_BASE_TTL_MS, SHA_RE, IMAGE_EXTENSIONS2, DEFAULT_UPLOAD_MAX_BYTES;
+var import_node_fs59, import_node_path58, mergeBaseCache, MERGE_BASE_TTL_MS, SHA_RE, IMAGE_EXTENSIONS2, DEFAULT_UPLOAD_MAX_BYTES;
 var init_diff = __esm({
   "src/diff/diff.ts"() {
     "use strict";
     import_node_fs59 = require("fs");
-    import_node_path57 = require("path");
+    import_node_path58 = require("path");
     init_run();
     init_worktree();
     mergeBaseCache = /* @__PURE__ */ new Map();
@@ -25792,7 +26230,7 @@ function readWorktreeFileTail(worktreePath, relativePath, maxBytes = WORKTREE_TA
   if (!relativePath || relativePath.includes("..") || relativePath.startsWith("/")) {
     throw new Error("Invalid path");
   }
-  const abs = (0, import_node_path58.join)(worktreePath, relativePath);
+  const abs = (0, import_node_path59.join)(worktreePath, relativePath);
   const fd = (0, import_node_fs60.openSync)(abs, "r");
   try {
     const st = (0, import_node_fs60.fstatSync)(fd);
@@ -25822,12 +26260,12 @@ function readWorktreeFileTail(worktreePath, relativePath, maxBytes = WORKTREE_TA
     (0, import_node_fs60.closeSync)(fd);
   }
 }
-var import_node_fs60, import_node_path58, WORKTREE_TAIL_BYTES;
+var import_node_fs60, import_node_path59, WORKTREE_TAIL_BYTES;
 var init_read_worktree_tail = __esm({
   "src/diff/read-worktree-tail.ts"() {
     "use strict";
     import_node_fs60 = require("fs");
-    import_node_path58 = require("path");
+    import_node_path59 = require("path");
     WORKTREE_TAIL_BYTES = 2e5;
   }
 });
@@ -26004,7 +26442,7 @@ function scanSkillsDir(dir, source, out) {
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const skillMd = (0, import_node_path59.join)(dir, entry, "SKILL.md");
+    const skillMd = (0, import_node_path60.join)(dir, entry, "SKILL.md");
     if (!(0, import_node_fs61.existsSync)(skillMd)) continue;
     try {
       if (!(0, import_node_fs61.statSync)(skillMd).isFile()) continue;
@@ -26026,12 +26464,12 @@ function scanClaudePluginSkills(pluginsRoot, out) {
       return;
     }
     if (lookingForSkillsDir && entries.includes("SKILL.md")) {
-      const skill = readSkill((0, import_node_path59.join)(dir, "SKILL.md"), "cli");
+      const skill = readSkill((0, import_node_path60.join)(dir, "SKILL.md"), "cli");
       if (skill) out.push(skill);
     }
     for (const entry of entries) {
       if (entry === "node_modules" || entry === ".git") continue;
-      const full = (0, import_node_path59.join)(dir, entry);
+      const full = (0, import_node_path60.join)(dir, entry);
       try {
         if (!(0, import_node_fs61.statSync)(full).isDirectory()) continue;
       } catch {
@@ -26051,17 +26489,17 @@ function discoverSkills(worktreePath) {
   const home = (0, import_node_os18.homedir)();
   const collected = [];
   for (const rel of [".claude/skills", ".cursor/skills", ".sideboard/skills", ".brightsy/skills", "skills"]) {
-    scanSkillsDir((0, import_node_path59.join)(worktreePath, rel), "workspace", collected);
+    scanSkillsDir((0, import_node_path60.join)(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    (0, import_node_path59.join)(home, ".claude/skills"),
-    (0, import_node_path59.join)(home, ".cursor/skills"),
-    (0, import_node_path59.join)(home, ".sideboard/skills"),
-    (0, import_node_path59.join)(home, ".brightsy/skills")
+    (0, import_node_path60.join)(home, ".claude/skills"),
+    (0, import_node_path60.join)(home, ".cursor/skills"),
+    (0, import_node_path60.join)(home, ".sideboard/skills"),
+    (0, import_node_path60.join)(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills((0, import_node_path59.join)(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills((0, import_node_path60.join)(home, ".claude/plugins"), collected);
   collected.push(...bundledSkills());
   const rank = {
     workspace: 0,
@@ -26101,13 +26539,13 @@ function readSkillBody(skillPath, maxChars = 12e3) {
 
 \u2026(truncated)` : raw;
 }
-var import_node_fs61, import_node_os18, import_node_path59, BUNDLED_SKILL_PREFIX;
+var import_node_fs61, import_node_os18, import_node_path60, BUNDLED_SKILL_PREFIX;
 var init_discover = __esm({
   "src/skills/discover.ts"() {
     "use strict";
     import_node_fs61 = require("fs");
     import_node_os18 = require("os");
-    import_node_path59 = require("path");
+    import_node_path60 = require("path");
     init_long_running();
     BUNDLED_SKILL_PREFIX = "bundled:";
   }
@@ -26262,7 +26700,7 @@ function compiledModuleDir() {
   try {
     const url = import_meta5.url;
     if (typeof url === "string" && url.length > 0) {
-      return (0, import_node_path60.dirname)((0, import_node_url5.fileURLToPath)(url));
+      return (0, import_node_path61.dirname)((0, import_node_url5.fileURLToPath)(url));
     }
   } catch {
   }
@@ -26270,7 +26708,7 @@ function compiledModuleDir() {
 }
 function detachedJobScriptIn(dir) {
   for (const name of DETACHED_JOB_FILENAMES) {
-    const script = (0, import_node_path60.join)(dir, "scripts", name);
+    const script = (0, import_node_path61.join)(dir, "scripts", name);
     if ((0, import_node_fs62.existsSync)(script)) return script;
   }
   return null;
@@ -26288,7 +26726,7 @@ function resolveDetachedJobScript() {
   for (let i = 0; i < 8; i++) {
     const candidate = detachedJobScriptIn(dir);
     if (candidate) return candidate;
-    const parent = (0, import_node_path60.dirname)(dir);
+    const parent = (0, import_node_path61.dirname)(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -26299,12 +26737,12 @@ function formatDetachedJobInvoke(scriptPath) {
   if (resolved) return `node ${JSON.stringify(resolved)}`;
   return "node scripts/detached-job.cjs";
 }
-var import_node_fs62, import_node_path60, import_node_url5, import_meta5, DETACHED_JOB_FILENAMES;
+var import_node_fs62, import_node_path61, import_node_url5, import_meta5, DETACHED_JOB_FILENAMES;
 var init_detached_job_path = __esm({
   "src/skills/detached-job-path.ts"() {
     "use strict";
     import_node_fs62 = require("fs");
-    import_node_path60 = require("path");
+    import_node_path61 = require("path");
     import_node_url5 = require("url");
     init_packaged_runtime();
     import_meta5 = {};
@@ -26426,6 +26864,16 @@ function formatWorktreeDirective(thread, opts) {
   lines.push(formatProcessGuideDirective({ worktreePath: thread.worktreePath }));
   return lines.join("\n");
 }
+function formatConnectedOrchestratorReminder(parent) {
+  if (!parent) return null;
+  const title = parent.title?.trim() || "Orchestration";
+  const archived = parent.status === "archived" ? " This orchestrator is archived." : "";
+  return `Connected orchestrator: "${title}" (${parent.agent}, ${parent.status}). Open [${title}](sideboard://chat/${parent.id}). notify_orchestrator wakes that chat. You are not the orchestrator.${archived}`;
+}
+function connectedOrchestratorTurnReminder(thread, find) {
+  if (thread.agent === "brightsy" || isOrchestratorThread(thread)) return null;
+  return formatConnectedOrchestratorReminder(connectedOrchestrator(thread, find));
+}
 function formatWorktreeReminder() {
   return "Sideboard workspace: stay in this cwd for all file and git work. Push and open PRs against origin, never upstream. Do not edit the main repo checkout. If a goal is given (Greptile 5/5, CI green), watch-fix-push until it lands \u2014 do not watch after every push. Schedules: create_schedule (at / every / cron; chatId=self for this chat). set_workspace_tags updates labels on this workspace (omit ref).";
 }
@@ -26523,9 +26971,9 @@ function formatPrGateDirective() {
 }
 function formatProcessGuideDirective(opts) {
   const worktree = opts?.worktreePath?.trim();
-  const hasGraphSkill = !!worktree && (0, import_node_fs63.existsSync)((0, import_node_path61.join)(worktree, ".claude/skills/graph-engineering/SKILL.md"));
-  const hasReviewSkill = !!worktree && (0, import_node_fs63.existsSync)((0, import_node_path61.join)(worktree, ".claude/skills/review/SKILL.md"));
-  const hasInstallSkill = !!worktree && (0, import_node_fs63.existsSync)((0, import_node_path61.join)(worktree, ".claude/skills/worktree-install/SKILL.md"));
+  const hasGraphSkill = !!worktree && (0, import_node_fs63.existsSync)((0, import_node_path62.join)(worktree, ".claude/skills/graph-engineering/SKILL.md"));
+  const hasReviewSkill = !!worktree && (0, import_node_fs63.existsSync)((0, import_node_path62.join)(worktree, ".claude/skills/review/SKILL.md"));
+  const hasInstallSkill = !!worktree && (0, import_node_fs63.existsSync)((0, import_node_path62.join)(worktree, ".claude/skills/worktree-install/SKILL.md"));
   return [
     "Process guides (recurring work only):",
     hasGraphSkill ? "- Migrations, ports, batch fixes, and other fan-out: follow `.claude/skills/graph-engineering/SKILL.md` (`/graph-engineering`). Judge first; state on disk; grow the rulebook; do not patch around it." : null,
@@ -26565,16 +27013,18 @@ function formatArtifactDirective() {
 function formatUiReminder() {
   return "Sideboard UI: markdown table is enough to read data; present_schema if they ask to edit/filter (even after markdown); present_files for the file manager. html fence or present_artifact, not both for the same document. type=log appends (same artifact_id, new lines only). Chat links: `[name](sideboard://artifact/<id-or-title>)` opens that pane; `[name](sideboard://file/path#L12-L40)` opens a file. ask_user only for a real multiple-choice (not hellos, \u201Cwhat next?\u201D, or after a review) \u2014 reply in chat. ask_user wakes the parent orchestrator; notify_orchestrator if blocked without a picker. Do not say artifacts/CMS UI are unavailable. Dev / preview: run_dev_script (same as the Dev button; pass name \u2014 several scripts can run at once) returns {url, port, preview} (SIDEBOARD_PORT \u2014 never guess :3000). preview=url \u2192 open url; preview=window \u2192 Electron window is the app, url is renderer/HMR only. list_run_scripts active[].url if already running; get_run_log for that script\u2019s Run-tab terminal; stop_dev_script to stop one.";
 }
-var import_node_fs63, import_node_path61, PR_GOAL_RE, GITHUB_TICKET_REF, KEYED_TICKET_REF;
+var import_node_fs63, import_node_path62, PR_GOAL_RE, GITHUB_TICKET_REF, KEYED_TICKET_REF;
 var init_instructions = __esm({
   "src/agents/instructions.ts"() {
     "use strict";
     import_node_fs63 = require("fs");
-    import_node_path61 = require("path");
+    import_node_path62 = require("path");
     init_git_auth_mode();
     init_branch_prefix();
     init_worktree_labels();
     init_detached_job_path();
+    init_global_workspace();
+    init_connected_orchestrator();
     PR_GOAL_RE = /greptile|\bci\b.*\b(green|pass)|checks?\s+(pass|green)|until\s+.*\b(pass|green|merge|clean)|\bfix ci\b|watch[- ]fix[- ]push/i;
     GITHUB_TICKET_REF = /^(?:#?\d+|gh-\d+)$/i;
     KEYED_TICKET_REF = /^(?:[A-Z][A-Z0-9]{0,9}-\d+|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i;
@@ -27452,13 +27902,13 @@ __export(plan_file_exports, {
   writePlanFile: () => writePlanFile
 });
 function ensureAttachmentsGitignore(worktreePath) {
-  const gitignoreAbs = (0, import_node_path62.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  const gitignoreAbs = (0, import_node_path63.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
   if ((0, import_node_fs64.existsSync)(gitignoreAbs)) return;
-  (0, import_node_fs64.mkdirSync)((0, import_node_path62.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs64.mkdirSync)((0, import_node_path63.dirname)(gitignoreAbs), { recursive: true });
   (0, import_node_fs64.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function planFileAbs(worktreePath) {
-  return (0, import_node_path62.join)(worktreePath, PLAN_FILE_REL);
+  return (0, import_node_path63.join)(worktreePath, PLAN_FILE_REL);
 }
 function readTextIfPresent2(abs) {
   if (!(0, import_node_fs64.existsSync)(abs)) return null;
@@ -27470,22 +27920,22 @@ function readTextIfPresent2(abs) {
   }
 }
 function readPlanFile(worktreePath) {
-  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path62.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path62.join)(worktreePath, LEGACY_PLAN_FILE_REL));
+  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path63.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path63.join)(worktreePath, LEGACY_PLAN_FILE_REL));
 }
 function writePlanFile(worktreePath, content) {
   ensureAttachmentsGitignore(worktreePath);
   const abs = planFileAbs(worktreePath);
-  (0, import_node_fs64.mkdirSync)((0, import_node_path62.dirname)(abs), { recursive: true });
+  (0, import_node_fs64.mkdirSync)((0, import_node_path63.dirname)(abs), { recursive: true });
   const body = content.trimEnd() + (content.endsWith("\n") ? "" : "\n");
   (0, import_node_fs64.writeFileSync)(abs, body, "utf8");
   return PLAN_FILE_REL;
 }
-var import_node_fs64, import_node_path62;
+var import_node_fs64, import_node_path63;
 var init_plan_file = __esm({
   "src/plan/plan-file.ts"() {
     "use strict";
     import_node_fs64 = require("fs");
-    import_node_path62 = require("path");
+    import_node_path63 = require("path");
     init_workspace_scratch();
     init_plan_present();
     init_plan_present();
@@ -27738,6 +28188,7 @@ var init_orchestrator = __esm({
     init_orchestrator_capable();
     init_chat_tabs();
     init_enqueue_by_key();
+    init_workspace_archive();
     init_line_coalescer();
     init_run();
     init_repo_git_lock();
@@ -28707,6 +29158,7 @@ ${formatEnvReminder(projectNameForRepoPath(thread.repoPath || thread.worktreePat
           );
           const turnReminders = [
             worktreeReminder,
+            connectedOrchestratorTurnReminder(thread, (id) => readThread(id)),
             optionalServicesReminder,
             issueToolsReminder,
             reviewWriteGateReminder,
@@ -30304,14 +30756,16 @@ ${formatEnvReminder(projectNameForRepoPath(thread.repoPath || thread.worktreePat
         const thread = this.requireThread(threadRef);
         return threadsSharingWorktree(thread.worktreePath);
       }
-      /**
-       * Last-tab teardown must see siblings already archived. Serialize per
-       * worktree so parallel archive/purge of sibling tabs still removes once.
-       */
       enqueueWorktreeTeardown(thread, fn) {
         const key = isGlobalThread(thread) ? `archive:global:${thread.id}` : `archive:wt:${normalizeWorktreePath(thread.worktreePath)}`;
         return enqueueByKey(key, fn);
       }
+      archiveWorkspace(threadRef) {
+        return archiveWorkspaceAgents(this, threadRef);
+      }
+      restoreWorkspace(threadRef) {
+        return restoreWorkspaceAgents(this, threadRef);
+      }
       async archive(threadRef) {
         const thread = this.requireThread(threadRef);
         return this.enqueueWorktreeTeardown(thread, () => this.archiveUnlocked(threadRef));
@@ -30882,6 +31336,7 @@ __export(index_exports, {
   connectOptionalService: () => connectOptionalService,
   connectSlackToken: () => connectSlackToken,
   connectedOptionalServices: () => connectedOptionalServices,
+  connectedOrchestratorTurnReminder: () => connectedOrchestratorTurnReminder,
   connectedPrSelectors: () => connectedPrSelectors,
   consumeComposerAttachments: () => consumeComposerAttachments,
   contextTokens: () => contextTokens,
@@ -31005,6 +31460,7 @@ __export(index_exports, {
   formatClaudeUsageResetClock: () => formatClaudeUsageResetClock,
   formatClaudeUsageTooltip: () => formatClaudeUsageTooltip,
   formatCloudTurnReply: () => formatCloudTurnReply,
+  formatConnectedOrchestratorReminder: () => formatConnectedOrchestratorReminder,
   formatDetachedJobInvoke: () => formatDetachedJobInvoke,
   formatDevAccessHint: () => formatDevAccessHint,
   formatFetchError: () => formatFetchError,
@@ -34336,20 +34792,20 @@ init_cursor_stream_cutoff();
 
 // src/agents/tool-result-clip.ts
 var import_node_fs67 = require("fs");
-var import_node_path63 = require("path");
+var import_node_path64 = require("path");
 init_workspace_scratch();
 init_error_detail();
 function spillPath(cwd, prefix) {
   const stamp = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
   const safe = prefix.replace(/[^a-zA-Z0-9_-]+/g, "-").slice(0, 40) || "tool";
-  return (0, import_node_path63.join)(cwd, CLI_DIR, `${safe}-${stamp}.txt`);
+  return (0, import_node_path64.join)(cwd, CLI_DIR, `${safe}-${stamp}.txt`);
 }
 function spillToolResultToCli(content, opts) {
   const cwd = opts?.cwd?.trim();
   if (!cwd || !content) return null;
   const file = spillPath(cwd, opts?.prefix ?? "tool-result");
   try {
-    (0, import_node_fs67.mkdirSync)((0, import_node_path63.join)(cwd, CLI_DIR), { recursive: true });
+    (0, import_node_fs67.mkdirSync)((0, import_node_path64.join)(cwd, CLI_DIR), { recursive: true });
     (0, import_node_fs67.writeFileSync)(file, content, "utf8");
     return file;
   } catch {
@@ -34435,25 +34891,14 @@ function createClippedMcpServer() {
 }
 
 // src/mcp/server.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var import_node_crypto22 = require("crypto");
-var import_node_path67 = require("path");
+var import_node_path68 = require("path");
 init_orchestrator();
 init_task_state();
 init_worktree();
 init_global_workspace();
 init_list_models();
-
-// src/mcp/archive-guard.ts
-init_global_workspace();
-function mcpArchiveBlockedReason(thread) {
-  if (isCloudCoordinatorThread(thread)) {
-    return "Refusing to archive the cloud coordinator via MCP. Archive it from the Sideboard UI if needed.";
-  }
-  return null;
-}
-
-// src/mcp/server.ts
 init_profile();
 init_plan_present();
 
@@ -34474,6 +34919,7 @@ function resolveRunScriptThreadRef(ref) {
 
 // src/mcp/server.ts
 init_chat_tabs();
+init_connected_orchestrator();
 init_workspace_tags();
 
 // src/mcp/create-orch-child.ts
@@ -35731,8 +36177,141 @@ function formatMcpPrList(input) {
 init_list_prs();
 init_app_settings();
 
-// src/mcp/schedule-tools.ts
+// src/mcp/archive-tools.ts
 var import_zod9 = require("zod");
+init_fleet_archive();
+init_chat_tabs();
+
+// src/mcp/archive-guard.ts
+init_global_workspace();
+function mcpArchiveBlockedReason(thread) {
+  if (isCloudCoordinatorThread(thread)) {
+    return "Refusing to archive the cloud coordinator via MCP. Archive it from the Sideboard UI if needed.";
+  }
+  return null;
+}
+
+// src/mcp/archive-tools.ts
+init_issue_list();
+function registerArchiveTools(server, orch) {
+  server.tool(
+    "list_archive",
+    "Browse Settings \u2192 History (archived workspaces and agents), newest first. A workspace row is a checkout with no live agents \u2014 it is off Home and list_board. Nested lines are that workspace's agents; any of those ids restores the whole checkout. An agent row is an orchestration chat, or one agent archived while its workspace stayed live (workspace-live). kind=agent lists every archived agent, including agents on an archived workspace (workspace-archived). query matches title, branch, repo, agent, ticket, or PR. limit default 40, max 250. Then restore_workspace (whole checkout) or restore_chat (one agent).",
+    {
+      query: import_zod9.z.string().optional().describe("Title, branch, repo, agent, ticket, or PR"),
+      kind: import_zod9.z.enum(["all", "workspace", "agent"]).optional().describe("all (default), workspace, or agent"),
+      limit: import_zod9.z.number().int().positive().max(250).optional().describe("Page size (default 40, max 250)")
+    },
+    async ({ query, kind, limit }) => {
+      const view = listFleetArchive(orch.getThreads(true), { query, kind, limit });
+      return { content: [{ type: "text", text: formatFleetArchive(view) }] };
+    }
+  );
+  server.tool(
+    "archive_workspace",
+    "Archive a workspace: every live agent on that checkout, then remove the worktree when the last agent archives (cowboy keeps the project folder). The Home card moves to Settings \u2192 History. Pass any chat id on the workspace. Orchestration chats are agents \u2014 use archive_chat. To archive one agent and leave the checkout up, use archive_chat.",
+    { ref: import_zod9.z.string().describe("Any chat id on the workspace") },
+    async ({ ref }) => {
+      const thread = orch.getThread(ref);
+      if (!thread) {
+        return { content: [{ type: "text", text: `Chat not found: ${ref}` }], isError: true };
+      }
+      for (const chat of threadsSharingWorktree(thread.worktreePath)) {
+        const blocked = mcpArchiveBlockedReason(chat);
+        if (blocked) {
+          return { content: [{ type: "text", text: blocked }], isError: true };
+        }
+      }
+      try {
+        const archived = await orch.archiveWorkspace(ref);
+        return mcpJson({
+          worktreePath: thread.worktreePath,
+          archived: archived.map((chat) => ({
+            id: chat.id,
+            title: chat.title,
+            agent: chat.agent,
+            status: chat.status,
+            link: `sideboard://chat/${chat.id}`
+          }))
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: message }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "archive_chat",
+    "Archive one agent chat: stop the turn and move that chat to Settings \u2192 History. Other agents on the workspace stay, and the worktree is removed only when this is the last agent. Orchestration chats archive without removing a project checkout. Refuses the cloud coordinator. To archive every agent on a checkout, use archive_workspace. Commit, push, and open PRs via ask_git before archiving when the work should be kept. Merge only when the user explicitly asked.",
+    { ref: import_zod9.z.string().describe("Chat id to archive") },
+    async ({ ref }) => {
+      const t = orch.getThread(ref);
+      if (!t) {
+        return {
+          content: [{ type: "text", text: `Chat not found: ${ref}` }],
+          isError: true
+        };
+      }
+      const blocked = mcpArchiveBlockedReason(t);
+      if (blocked) {
+        return {
+          content: [{ type: "text", text: blocked }],
+          isError: true
+        };
+      }
+      const archived = await orch.archive(ref);
+      return mcpJson({
+        id: archived.id,
+        status: archived.status
+      });
+    }
+  );
+  server.tool(
+    "restore_workspace",
+    "Restore a workspace from Settings \u2192 History: recreate the worktree if it was removed and bring every archived agent on that checkout back. Pass any chat id from list_archive. If some agents are still live, only the archived ones return to that checkout. One agent only: restore_chat. Orchestration agents: restore_chat.",
+    { ref: import_zod9.z.string().describe("Any chat id from list_archive on that workspace") },
+    async ({ ref }) => {
+      try {
+        const restored = await orch.restoreWorkspace(ref);
+        return mcpJson({
+          worktreePath: restored[0]?.worktreePath ?? null,
+          restored: restored.map((chat) => ({
+            id: chat.id,
+            title: chat.title,
+            agent: chat.agent,
+            status: chat.status,
+            worktreePath: chat.worktreePath,
+            link: `sideboard://chat/${chat.id}`
+          }))
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: message }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "restore_chat",
+    "Restore one archived agent from list_archive. Recreates the worktree when that checkout was fully archived and the folder is gone. Other archived agents on the checkout stay in History until restore_workspace or another restore_chat. Orchestration agents come back as Global chats.",
+    { ref: import_zod9.z.string().describe("Archived chat id from list_archive") },
+    async ({ ref }) => {
+      try {
+        const restored = await orch.restore(ref);
+        return mcpJson({
+          id: restored.id,
+          status: restored.status,
+          worktreePath: restored.worktreePath
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: message }], isError: true };
+      }
+    }
+  );
+}
+
+// src/mcp/schedule-tools.ts
+var import_zod10 = require("zod");
 init_schedules();
 init_schedule_runner();
 init_issue_list();
@@ -35775,18 +36354,18 @@ function registerScheduleTools(server) {
     "create_schedule",
     "Create a local schedule that, when due, sends a prompt to an existing chat (chatId) or starts a new Global orchestration chat (omit chatId). Pass chatId=self to continue this chat. If that chat is missing or archived when the job fires, Sideboard starts a new Global chat (recurring jobs then continue that chat). Exactly one of at (ISO datetime), every (15m/1h/6h/1d), or cron (5-field). Recurring jobs without chatId open a new Global chat each run. Creating or enabling a future job turns on Settings \u2192 Advanced \u2192 Caffeinate while schedules are enabled so the Mac stays awake until due. Sideboard.app must be running for the job to fire.",
     {
-      prompt: import_zod9.z.string().describe("User message / goal queued when the schedule fires"),
-      name: import_zod9.z.string().optional(),
-      at: import_zod9.z.string().optional().describe("ISO datetime for a one-shot"),
-      every: import_zod9.z.string().optional().describe("Interval such as 15m, 1h, 6h, 1d"),
-      cron: import_zod9.z.string().optional().describe("5-field cron expression"),
-      tz: import_zod9.z.string().optional().describe("IANA timezone for cron (default: system)"),
-      chatId: import_zod9.z.string().optional().describe(
+      prompt: import_zod10.z.string().describe("User message / goal queued when the schedule fires"),
+      name: import_zod10.z.string().optional(),
+      at: import_zod10.z.string().optional().describe("ISO datetime for a one-shot"),
+      every: import_zod10.z.string().optional().describe("Interval such as 15m, 1h, 6h, 1d"),
+      cron: import_zod10.z.string().optional().describe("5-field cron expression"),
+      tz: import_zod10.z.string().optional().describe("IANA timezone for cron (default: system)"),
+      chatId: import_zod10.z.string().optional().describe(
         'Existing chat id (orchestration or workspace), or "self" for this chat. Omit to create a new Global chat on fire.'
       ),
-      threadId: import_zod9.z.string().optional().describe("Legacy alias for chatId."),
-      agent: import_zod9.z.enum(["claude", "cursor", "codex", "opencode"]).optional().describe("Agent for a new Global chat (omit for Account default)"),
-      model: import_zod9.z.string().optional()
+      threadId: import_zod10.z.string().optional().describe("Legacy alias for chatId."),
+      agent: import_zod10.z.enum(["claude", "cursor", "codex", "opencode"]).optional().describe("Agent for a new Global chat (omit for Account default)"),
+      model: import_zod10.z.string().optional()
     },
     async (args) => {
       try {
@@ -35822,20 +36401,20 @@ function registerScheduleTools(server) {
     "update_schedule",
     "Update a local schedule (prompt, cadence, target chat, enabled). Pass id from list_schedules.",
     {
-      id: import_zod9.z.string(),
-      prompt: import_zod9.z.string().optional(),
-      name: import_zod9.z.string().optional(),
-      at: import_zod9.z.string().optional(),
-      every: import_zod9.z.string().optional(),
-      cron: import_zod9.z.string().optional(),
-      tz: import_zod9.z.string().optional(),
-      chatId: import_zod9.z.string().optional().describe(
+      id: import_zod10.z.string(),
+      prompt: import_zod10.z.string().optional(),
+      name: import_zod10.z.string().optional(),
+      at: import_zod10.z.string().optional(),
+      every: import_zod10.z.string().optional(),
+      cron: import_zod10.z.string().optional(),
+      tz: import_zod10.z.string().optional(),
+      chatId: import_zod10.z.string().optional().describe(
         'Existing chat (orchestration or workspace), "self", or empty string to create a new Global chat each run'
       ),
-      threadId: import_zod9.z.string().optional().describe("Legacy alias for chatId."),
-      agent: import_zod9.z.enum(["claude", "cursor", "codex", "opencode"]).optional(),
-      model: import_zod9.z.string().optional(),
-      enabled: import_zod9.z.boolean().optional()
+      threadId: import_zod10.z.string().optional().describe("Legacy alias for chatId."),
+      agent: import_zod10.z.enum(["claude", "cursor", "codex", "opencode"]).optional(),
+      model: import_zod10.z.string().optional(),
+      enabled: import_zod10.z.boolean().optional()
     },
     async (args) => {
       try {
@@ -35876,7 +36455,7 @@ function registerScheduleTools(server) {
   server.tool(
     "delete_schedule",
     "Delete a local schedule. Pass id from list_schedules.",
-    { id: import_zod9.z.string() },
+    { id: import_zod10.z.string() },
     async ({ id }) => {
       try {
         deleteSchedule(id);
@@ -35889,7 +36468,7 @@ function registerScheduleTools(server) {
   server.tool(
     "run_schedule",
     "Fire a schedule now (does not wait for nextRunAt). Queues the prompt on the target chat or starts a new Global chat. If Sideboard.app is running, the desktop drains the turn.",
-    { id: import_zod9.z.string() },
+    { id: import_zod10.z.string() },
     async ({ id }) => {
       try {
         if (!getSchedule(id)) {
@@ -35906,7 +36485,7 @@ function registerScheduleTools(server) {
 
 // src/agent-rpc/handlers.ts
 var import_node_crypto20 = require("crypto");
-var import_node_path64 = require("path");
+var import_node_path65 = require("path");
 init_wait_for_job();
 init_wait_for_turn();
 
@@ -36061,7 +36640,7 @@ function invalidParams2(message) {
 function jobCwd(rec) {
   const raw = str5(rec.cwd).trim();
   if (!raw) throw invalidParams2("cwd is required");
-  if (!(0, import_node_path64.isAbsolute)(raw)) throw invalidParams2("cwd must be an absolute path");
+  if (!(0, import_node_path65.isAbsolute)(raw)) throw invalidParams2("cwd must be an absolute path");
   return raw;
 }
 async function handleRuntimePing(_params, _ctx) {
@@ -36195,20 +36774,20 @@ init_git_auth_mode();
 
 // src/board/load-home-board.ts
 var import_node_fs69 = require("fs");
-var import_node_path66 = require("path");
+var import_node_path67 = require("path");
 init_worktree();
 init_paths();
 
 // src/board/board-pins.ts
 var import_node_crypto21 = require("crypto");
 var import_node_fs68 = require("fs");
-var import_node_path65 = require("path");
+var import_node_path66 = require("path");
 init_paths();
 init_home_board();
 var FILE = "home-board-pins.json";
 var VERSION = 1;
 function pinsFile() {
-  return (0, import_node_path65.join)(appDataDir(), FILE);
+  return (0, import_node_path66.join)(appDataDir(), FILE);
 }
 function readDisk() {
   const path2 = pinsFile();
@@ -36292,7 +36871,7 @@ function homeBoardWorkspaceKey(workspaces) {
   return workspaces.map((w) => w.path).filter(Boolean).sort().join("\n");
 }
 function cacheFile() {
-  return (0, import_node_path66.join)(appDataDir(), "home-board-cache.json");
+  return (0, import_node_path67.join)(appDataDir(), "home-board-cache.json");
 }
 function emptyInputs() {
   return {
@@ -36552,12 +37131,12 @@ async function startMcpServer() {
     );
     server.tool(
       "list_chats",
-      "List chats across all projects (one summary line each \u2014 token-frugal). Includes parent id, last message preview, blocked: when an agent is waiting on a person, and live progress so you can see workspace children. Each line ends with sideboard://chat/<id> \u2014 use that URL in markdown links so the UI can open the chat.",
+      "List live chats across all projects (one summary line each \u2014 token-frugal). Includes parent id, last message preview, blocked: when an agent is waiting on a person, and live progress so you can see workspace children. Each line ends with sideboard://chat/<id> \u2014 use that URL in markdown links so the UI can open the chat. Archived workspaces and agents are list_archive, not this list.",
       {},
       async () => {
-        const threads = orch.getThreads(true);
+        const threads = orch.getThreads();
         const lines = threads.map((t) => {
-          const repo = t.repoPath === GLOBAL_WORKSPACE_ID2 ? "Orchestration" : (0, import_node_path67.basename)(t.repoPath) || t.repoPath;
+          const repo = t.repoPath === GLOBAL_WORKSPACE_ID2 ? "Orchestration" : (0, import_node_path68.basename)(t.repoPath) || t.repoPath;
           const live = orch.threadLooksLive(t) ? readTurnLive(t.id) : null;
           const parent = t.parentThreadId ? `  parent:${t.parentThreadId.slice(0, 8)}` : "";
           const preview = lastMessagePreview(t.messages, 80);
@@ -36573,18 +37152,18 @@ async function startMcpServer() {
     );
     server.tool(
       "list_board",
-      "Home Kanban of workspaces (New, Draft, Review, Merged) \u2014 one card per checkout; sibling chats on that card are separate agents. Same cards as desktop Home. Path to merge: no PR \u2192 draft PR \u2192 open PR \u2192 merged. Archive removes the card to Settings \u2192 History. Queued/running are activity on the card, not columns. Orchestration chats are not on the board. Filters: query, repoPath, kind (ticket/PR/branch source), ownership (mine = your PRs / WIP; reviewing = someone else's PR), column, limit (default 40). create_workspace adds a workspace (and a Home card), or returns the live checkout if that ticket/PR/named branch is already checked out. That reuse is one checkout, not one agent \u2014 fork_chat to add another.",
+      "Home Kanban of workspaces (New, Draft, Review, Approved, Merged) \u2014 one card per checkout; sibling chats on that card are separate agents. Same cards as desktop Home. Path to merge: no PR \u2192 draft PR \u2192 open PR \u2192 approved \u2192 merged. Archive removes the card to Settings \u2192 History (list_archive to browse, restore_workspace to bring it back). Queued/running are activity on the card, not columns. Orchestration chats are not on the board. Filters: query, repoPath, kind (ticket/PR/branch source), ownership (mine = your PRs / WIP; reviewing = someone else's PR), column, limit (default 40). create_workspace adds a workspace (and a Home card), or returns the live checkout if that ticket/PR/named branch is already checked out. That reuse is one checkout, not one agent \u2014 fork_chat to add another.",
       {
-        query: import_zod10.z.string().optional().describe("Case-insensitive token search across title, id, labels, workspace tags, repo"),
-        repoPath: import_zod10.z.string().optional().describe("Limit to one project path from list_projects"),
-        kind: import_zod10.z.enum(["all", "tickets", "prs", "branches", "threads"]).optional().describe("Filter by worktree source (default all)"),
-        ownership: import_zod10.z.enum(["all", "mine", "reviewing"]).optional().describe(
+        query: import_zod11.z.string().optional().describe("Case-insensitive token search across title, id, labels, workspace tags, repo"),
+        repoPath: import_zod11.z.string().optional().describe("Limit to one project path from list_projects"),
+        kind: import_zod11.z.enum(["all", "tickets", "prs", "branches", "threads"]).optional().describe("Filter by worktree source (default all)"),
+        ownership: import_zod11.z.enum(["all", "mine", "reviewing"]).optional().describe(
           "Mine = PRs you authored or local WIP; reviewing = someone else's PR. Uses the gh login."
         ),
-        column: import_zod10.z.enum(["new", "draft", "review", "done", "needs_you"]).optional().describe(
-          "Return cards for this column only (totals still include the rest). needs_you is a legacy alias for new."
+        column: import_zod11.z.enum(["new", "draft", "review", "approved", "done", "needs_you"]).optional().describe(
+          "Return cards for this column only (totals still include the rest). approved is an open PR GitHub has approved. needs_you is a legacy alias for new."
         ),
-        limit: import_zod10.z.number().int().positive().optional().describe("Max cards per column (default 40). hidden counts the remainder.")
+        limit: import_zod11.z.number().int().positive().optional().describe("Max cards per column (default 40). hidden counts the remainder.")
       },
       async ({ query, repoPath, kind, ownership, column, limit }) => {
         const workspaces = orch.listWorkspaces();
@@ -36614,7 +37193,7 @@ async function startMcpServer() {
     server.tool(
       "get_chat",
       "Get a compact chat summary by id/ref. Includes last message preview, parentChatId, and child workspace chats (status + lastText). While running, includes progress (last tool/thinking) and lastActivityAt. Includes usage (billed token + costUsd totals when providers reported cost) and lastTurnUsage. blockedReason is why that agent is waiting on a person (question, plan approval, or a reported block).",
-      { ref: import_zod10.z.string() },
+      { ref: import_zod11.z.string() },
       async ({ ref }) => {
         const t = orch.getThread(ref);
         if (!t) {
@@ -36661,17 +37240,17 @@ async function startMcpServer() {
       "present_artifact",
       "Show a document or live log in Sideboard\u2019s side column. For html/svg/markdown/react, pass the FULL document and do not also fence that same body in chat. For type=log, pass only NEW lines (same artifact_id appends). Prefer type=log for long-running job output \u2014 do not resend HTML. type=react is a single default-export component (JSX/TSX); only react/react-dom imports.",
       {
-        title: import_zod10.z.string().describe("Short title shown in the artifact pane header"),
-        type: import_zod10.z.enum(["html", "svg", "markdown", "react", "log"]).describe(
+        title: import_zod11.z.string().describe("Short title shown in the artifact pane header"),
+        type: import_zod11.z.enum(["html", "svg", "markdown", "react", "log"]).describe(
           "html/svg/markdown/react replace the pane. log appends content to the same artifact_id (new lines only)."
         ),
-        content: import_zod10.z.string().describe(
+        content: import_zod11.z.string().describe(
           "html/svg/markdown/react: full document. log: only the new lines since the last call (empty is ok for a status-only update)."
         ),
-        artifact_id: import_zod10.z.string().optional().describe("Stable id. Required for type=log so later calls append to the same pane."),
-        status: import_zod10.z.enum(["running", "ok", "failed", "idle"]).optional().describe("Log header pill: running (working), ok (done), failed, idle"),
-        phase: import_zod10.z.string().optional().describe("Log subtitle (Signing, Notarizing, \u2026)"),
-        mode: import_zod10.z.enum(["append", "replace"]).optional().describe("log only: append (default) or replace the buffer")
+        artifact_id: import_zod11.z.string().optional().describe("Stable id. Required for type=log so later calls append to the same pane."),
+        status: import_zod11.z.enum(["running", "ok", "failed", "idle"]).optional().describe("Log header pill: running (working), ok (done), failed, idle"),
+        phase: import_zod11.z.string().optional().describe("Log subtitle (Signing, Notarizing, \u2026)"),
+        mode: import_zod11.z.enum(["append", "replace"]).optional().describe("log only: append (default) or replace the buffer")
       },
       async ({ title, type, artifact_id, status, phase, mode }) => {
         return mcpJson(
@@ -36684,15 +37263,15 @@ async function startMcpServer() {
     "ask_user",
     "Ask the user a clarifying multiple-choice question in Sideboard\u2019s composer. Call only when work is blocked on choosing among a few concrete options (approach fork, which API, auth vs cookies). Do not call for greetings, check-ins, \u201Chello\u201D, open-ended how-can-I-help, or to invent a menu of possible next tasks \u2014 reply in chat instead. If one option is the obvious default, proceed without asking. Before calling, write a short chat message explaining the decision and what each option means. Include a description on every option. After calling, stop and wait for answers. Not for \u201Cis the plan ready?\u201D.",
     {
-      questions: import_zod10.z.array(
-        import_zod10.z.object({
-          question: import_zod10.z.string().describe("Full question text ending with ?"),
-          header: import_zod10.z.string().max(24).optional().describe("Short label shown above the question"),
-          multiSelect: import_zod10.z.boolean().optional().describe("Allow selecting multiple options"),
-          options: import_zod10.z.array(
-            import_zod10.z.object({
-              label: import_zod10.z.string(),
-              description: import_zod10.z.string().optional().describe("What this option means / when to choose it (strongly preferred)")
+      questions: import_zod11.z.array(
+        import_zod11.z.object({
+          question: import_zod11.z.string().describe("Full question text ending with ?"),
+          header: import_zod11.z.string().max(24).optional().describe("Short label shown above the question"),
+          multiSelect: import_zod11.z.boolean().optional().describe("Allow selecting multiple options"),
+          options: import_zod11.z.array(
+            import_zod11.z.object({
+              label: import_zod11.z.string(),
+              description: import_zod11.z.string().optional().describe("What this option means / when to choose it (strongly preferred)")
             })
           ).min(2).max(6).describe("2\u20136 choices (Sideboard also offers Other)")
         })
@@ -36718,9 +37297,9 @@ async function startMcpServer() {
       "present_plan",
       PRESENT_PLAN_TOOL_DESCRIPTION,
       {
-        title: import_zod10.z.string().optional().describe("Short plan title (defaults to Plan)"),
-        content: import_zod10.z.string().min(1).describe("Full plan markdown (headings, steps, risks, open questions)"),
-        thread_id: import_zod10.z.string().optional().describe("Sideboard thread id when cwd is not the worktree")
+        title: import_zod11.z.string().optional().describe("Short plan title (defaults to Plan)"),
+        content: import_zod11.z.string().min(1).describe("Full plan markdown (headings, steps, risks, open questions)"),
+        thread_id: import_zod11.z.string().optional().describe("Sideboard thread id when cwd is not the worktree")
       },
       async ({ title, content, thread_id }) => {
         const { writePlanFile: writePlanFile2 } = await Promise.resolve().then(() => (init_plan_file(), plan_file_exports));
@@ -36749,15 +37328,15 @@ async function startMcpServer() {
     "present_schema",
     "Open Sideboard\u2019s schema-driven side column (filterable table and/or form) when the user needs to filter, edit, publish, or persist records. Do not call this just to re-display rows you already wrote as a markdown table. If the user asks for an editable / interactive table, call this even if chat already showed those rows. Pass JSON Schema + optional schemaUi. Prefer datasource=inline with embedded resource/records. Use datasource=brightsy with resource_id only when the user is logged into Brightsy.",
     {
-      title: import_zod10.z.string().describe("Pane title"),
-      mode: import_zod10.z.enum(["table", "form"]).optional().describe("table = list/filter records; form = edit one record"),
-      datasource: import_zod10.z.enum(["brightsy", "inline"]).optional().describe("brightsy resolves via login; inline uses embedded resource/records"),
-      resource_id: import_zod10.z.string().optional().describe("Brightsy record type UUID (or generic resource id)"),
-      record_id: import_zod10.z.string().optional().describe("Record id when opening form mode"),
-      resource: import_zod10.z.record(import_zod10.z.unknown()).optional().describe("Inline { id, title, schema, schemaUi?, slug? }"),
-      record: import_zod10.z.record(import_zod10.z.unknown()).optional().describe("Inline record { id, data, published_at? }"),
-      records: import_zod10.z.array(import_zod10.z.record(import_zod10.z.unknown())).optional().describe("Inline records for table mode"),
-      pane_id: import_zod10.z.string().optional().describe("Stable pane id across updates")
+      title: import_zod11.z.string().describe("Pane title"),
+      mode: import_zod11.z.enum(["table", "form"]).optional().describe("table = list/filter records; form = edit one record"),
+      datasource: import_zod11.z.enum(["brightsy", "inline"]).optional().describe("brightsy resolves via login; inline uses embedded resource/records"),
+      resource_id: import_zod11.z.string().optional().describe("Brightsy record type UUID (or generic resource id)"),
+      record_id: import_zod11.z.string().optional().describe("Record id when opening form mode"),
+      resource: import_zod11.z.record(import_zod11.z.unknown()).optional().describe("Inline { id, title, schema, schemaUi?, slug? }"),
+      record: import_zod11.z.record(import_zod11.z.unknown()).optional().describe("Inline record { id, data, published_at? }"),
+      records: import_zod11.z.array(import_zod11.z.record(import_zod11.z.unknown())).optional().describe("Inline records for table mode"),
+      pane_id: import_zod11.z.string().optional().describe("Stable pane id across updates")
     },
     async (args) => {
       const id = args.pane_id?.trim() || `schema_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
@@ -36778,10 +37357,10 @@ async function startMcpServer() {
     "present_files",
     "Open Sideboard\u2019s Files column (CMS-style file manager: browse, upload, pick). Use datasource=brightsy when the user is logged into Brightsy account storage; datasource=memory for a session-local demo store. Prefer this over claiming a file manager UI is unavailable. Pair with present_schema when editing records that need media.",
     {
-      title: import_zod10.z.string().optional().describe("Pane title (default: Files)"),
-      datasource: import_zod10.z.enum(["brightsy", "memory"]).optional().describe("brightsy = account storage via login; memory = session demo store"),
-      path: import_zod10.z.string().optional().describe("Initial folder path (e.g. public)"),
-      pane_id: import_zod10.z.string().optional().describe("Stable pane id across updates")
+      title: import_zod11.z.string().optional().describe("Pane title (default: Files)"),
+      datasource: import_zod11.z.enum(["brightsy", "memory"]).optional().describe("brightsy = account storage via login; memory = session demo store"),
+      path: import_zod11.z.string().optional().describe("Initial folder path (e.g. public)"),
+      pane_id: import_zod11.z.string().optional().describe("Stable pane id across updates")
     },
     async (args) => {
       const id = args.pane_id?.trim() || `files_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
@@ -36801,8 +37380,8 @@ async function startMcpServer() {
       "wait_for_job",
       "Wait on a detached long job (tests, pack, deploy, connector CLI) started with detached-job.cjs. MCP clients kill tools around 60s, so this returns within 45s. Sideboard opens a type=log pane from this result (artifact_id = job id, content = delta). stillRunning is the source of truth \u2014 if true, call wait_for_job again. If the job is hanging, producing no useful output, or doing the wrong thing, call stop_job instead of looping forever. Do not end the turn or tell the user you will let them know later. If false, ok/failed is the result.",
       {
-        id: import_zod10.z.string().describe("Detached job id (same kebab-case id passed to detached-job.cjs start)"),
-        timeoutMs: import_zod10.z.number().optional()
+        id: import_zod11.z.string().describe("Detached job id (same kebab-case id passed to detached-job.cjs start)"),
+        timeoutMs: import_zod11.z.number().optional()
       },
       async ({ id, timeoutMs }) => {
         const result = await waitForDetachedJob(process.cwd(), id, {
@@ -36815,8 +37394,8 @@ async function startMcpServer() {
       "stop_job",
       "Stop a detached job you started with detached-job.cjs when it is hanging, producing no useful output, buffering forever, or doing the wrong thing (wrong project, infinite watch, huge dump). Do not stop a pack/test/deploy that is clearly making progress. The type=log pane updates to status=failed with the last delta. Then decide the next step.",
       {
-        id: import_zod10.z.string().describe("Detached job id (same kebab-case id passed to detached-job.cjs start)"),
-        reason: import_zod10.z.string().optional().describe("Why you are stopping (hanging, no progress, wrong output, already have the answer)")
+        id: import_zod11.z.string().describe("Detached job id (same kebab-case id passed to detached-job.cjs start)"),
+        reason: import_zod11.z.string().optional().describe("Why you are stopping (hanging, no progress, wrong output, already have the answer)")
       },
       async ({ id, reason }) => {
         const result = await stopDetachedJob(process.cwd(), id, { reason });
@@ -36828,7 +37407,7 @@ async function startMcpServer() {
     "list_run_scripts",
     "List .sideboard/.conductor run scripts for this thread (same menu as the desktop Dev button) and which are active. Each script and active run includes preview: url (open http://localhost:<SIDEBOARD_PORT>) or window (Electron: native window is the app; url is renderer/HMR only). Never guess :3000. Worktree turns may omit ref (uses cwd).",
     {
-      ref: import_zod10.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd).")
+      ref: import_zod11.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd).")
     },
     async ({ ref }) => {
       try {
@@ -36858,8 +37437,8 @@ async function startMcpServer() {
     "run_dev_script",
     "Start a .sideboard/.conductor run script (same as the desktop Dev / play button). Several named scripts can run at once; each gets its own port, and starting one does not stop the others. Logs and Stop appear in the thread UI \u2014 do not detached-job or shell-spawn the same command. Returns {port, ports, url, preview}. preview=url \u2192 open url (browser, curl, Playwright). preview=window \u2192 Electron: the native window is the app; url is renderer/HMR only (no preload/IPC in a browser). The port is allocated SIDEBOARD_PORT, not 3000. Worktree turns may omit ref (uses cwd). Omit name for the default script.",
     {
-      ref: import_zod10.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
-      name: import_zod10.z.string().optional().describe("Script name from list_run_scripts (default script if omitted).")
+      ref: import_zod11.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
+      name: import_zod11.z.string().optional().describe("Script name from list_run_scripts (default script if omitted).")
     },
     async ({ ref, name }) => {
       try {
@@ -36887,8 +37466,8 @@ async function startMcpServer() {
     "stop_dev_script",
     "Stop a run script started with run_dev_script or the desktop Dev button (same as UI Stop). Omit name to stop all scripts on this worktree. Worktree turns may omit ref (uses cwd).",
     {
-      ref: import_zod10.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
-      name: import_zod10.z.string().optional().describe("Script name to stop; omit to stop all active scripts.")
+      ref: import_zod11.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
+      name: import_zod11.z.string().optional().describe("Script name to stop; omit to stop all active scripts.")
     },
     async ({ ref, name }) => {
       try {
@@ -36905,9 +37484,9 @@ async function startMcpServer() {
     "get_run_log",
     "Read the Run-tab terminal for a worktree script (same stdout/stderr as the desktop Dev pane). Default is a tail \u2014 raise `tail` only if the error is missing. Worktree turns may omit ref (uses cwd). Omit name for the default script.",
     {
-      ref: import_zod10.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
-      name: import_zod10.z.string().optional().describe("Script name from list_run_scripts (default script if omitted)."),
-      tail: import_zod10.z.number().int().min(1).max(MAX_RUN_LOG_CHARS).optional().describe(
+      ref: import_zod11.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
+      name: import_zod11.z.string().optional().describe("Script name from list_run_scripts (default script if omitted)."),
+      tail: import_zod11.z.number().int().min(1).max(MAX_RUN_LOG_CHARS).optional().describe(
         `Max characters to return from the end (default ${DEFAULT_RUN_LOG_TAIL_CHARS}). Do not request the full buffer unless the tail is truncated and you still need more.`
       )
     },
@@ -36941,12 +37520,37 @@ async function startMcpServer() {
     }
   );
   if (worktreeProfile) {
+    server.tool(
+      "get_orchestrator",
+      "The orchestration chat this agent is connected to \u2014 the parent that lists this workspace among its agents. Returns id, title, status, agent, and a sideboard://chat link. connected is false when this chat was not opened by an orchestrator. notify_orchestrator wakes that chat. You cannot list or steer its other agents from here.",
+      {},
+      async () => {
+        try {
+          const child = resolveNotifyCallerThread();
+          const parent = connectedOrchestrator(child, (id) => orch.getThread(id));
+          if (!parent) return mcpJson({ connected: false, orchestrator: null });
+          return mcpJson({
+            connected: true,
+            orchestrator: {
+              id: parent.id,
+              title: parent.title,
+              status: parent.status,
+              agent: parent.agent,
+              link: `sideboard://chat/${parent.id}`
+            }
+          });
+        } catch (err) {
+          const text7 = err instanceof Error ? err.message : String(err);
+          return { content: [{ type: "text", text: text7 }], isError: true };
+        }
+      }
+    );
     server.tool(
       "notify_orchestrator",
       "Wake the parent Global orchestrator with a short status so it does not have to poll wait_for_turn. Use when you are blocked and the parent may have moved on (missing access, waiting on something the coordinator must handle). The message is shown on the sidebar and board until the next user message in this chat. ask_user already notifies for input-required \u2014 do not call this for the same question. Information only: never a git command. Do not use this to steer other worktrees.",
       {
-        message: import_zod10.z.string().min(1).max(1500).describe("Why you are blocked / what the parent should know (short)."),
-        reason: import_zod10.z.enum(["input-required", "blocked"]).optional().describe(
+        message: import_zod11.z.string().min(1).max(1500).describe("Why you are blocked / what the parent should know (short)."),
+        reason: import_zod11.z.enum(["input-required", "blocked"]).optional().describe(
           "input-required = waiting on the user in this chat; blocked = need the coordinator (default)."
         )
       },
@@ -36983,11 +37587,11 @@ async function startMcpServer() {
     "set_workspace_tags",
     worktreeProfile ? "Update tags on this workspace (the checkout you are in). Omit ref to use this chat. mode=replace (default), add, or remove. Short labels \u2014 the same ones the orchestrator used for this task. You cannot retag a different checkout." : "Label a project workspace so related checkouts stay recognizable in the sidebar and on the phone. Pass any chat id on that workspace. Use the same tags on every workspace from one task. mode=replace is the default; add and remove change the set. create_workspace tags= sets them at create time. Not for orchestration chats.",
     {
-      ref: import_zod10.z.string().optional().describe(
+      ref: import_zod11.z.string().optional().describe(
         worktreeProfile ? "Omit for this chat. Another chat id only if it is on this same checkout." : "Chat id on the workspace to label."
       ),
-      tags: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.array(import_zod10.z.string())]).describe("Labels to set. A string may be comma-separated."),
-      mode: import_zod10.z.enum(["replace", "add", "remove"]).optional()
+      tags: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.array(import_zod11.z.string())]).describe("Labels to set. A string may be comma-separated."),
+      mode: import_zod11.z.enum(["replace", "add", "remove"]).optional()
     },
     async ({ ref, tags, mode }) => {
       try {
@@ -37021,7 +37625,7 @@ async function startMcpServer() {
       "set_caffeinate",
       "Keep this Mac awake with caffeinate (like Claude Code) across turns \u2014 independent of Settings toggles. Turn ON when the user will be away from the keyboard, is driving work from Slack, or asks you to keep the machine awake. Turn OFF when they say they are done, wrapping up, going to sleep, or no longer need the Mac awake. Closing or archiving this orchestration chat also releases the hold. macOS only.",
       {
-        enabled: import_zod10.z.boolean().describe("true = hold caffeinate on; false = release and let the Mac sleep")
+        enabled: import_zod11.z.boolean().describe("true = hold caffeinate on; false = release and let the Mac sleep")
       },
       async ({ enabled }) => {
         const threadId = process.env.SIDEBOARD_ORCHESTRATOR_THREAD_ID?.trim() || null;
@@ -37047,24 +37651,24 @@ async function startMcpServer() {
       "create_workspace",
       `Create a workspace (isolated git checkout + first chat) from branch, pr, or ticket. A ticket, PR, or named branch has one checkout \u2014 if one already matches, returns it (alreadyStarted=true) instead of a second checkout. That is not one agent: chats lists every agent on that checkout. Add another with fork_chat; send_to_chat only the chat that should do this job. Creating from the default branch still opens a new isolated checkout. Pass repoPath from list_projects. cowboy=true uses the project folder on the default branch (no isolated worktree; land is commit+push). From an orchestration chat, omit parentChatId (Sideboard binds the child to this chat) or pass the exact id from the turn reminder \u2014 never invent a uuid. Omit agent/model \u2014 Sideboard applies ${accountDefaultsHint}. Do not pass your own agent or agent=cursor; those are ignored. Setup (settings.toml, .cursor/worktrees.json, or script/setup) runs in the background in parallel with the first turn (skipped for cowboy). Pass the same tags on every workspace you open for one task (short labels such as "phone-sync") so they still match in the sidebar the next day. Reusing a checkout adds those tags.`,
       {
-        sourceType: import_zod10.z.enum(["branch", "pr", "ticket"]),
-        sourceRef: import_zod10.z.string(),
-        agent: import_zod10.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]).optional().describe(
+        sourceType: import_zod11.z.enum(["branch", "pr", "ticket"]),
+        sourceRef: import_zod11.z.string(),
+        agent: import_zod11.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]).optional().describe(
           `Usually omit. Sideboard uses Account default agent (${accountDefaults.agent}). Passing your own agent or cursor is ignored.`
         ),
-        model: import_zod10.z.string().nullable().optional().describe(
+        model: import_zod11.z.string().nullable().optional().describe(
           `Usually omit to use Account default model (${accountDefaults.model?.trim() || "Auto"}). Pass null only to force Auto / agent-default.`
         ),
-        repoPath: import_zod10.z.string(),
-        title: import_zod10.z.string().optional(),
-        cowboy: import_zod10.z.boolean().optional().describe(
+        repoPath: import_zod11.z.string(),
+        title: import_zod11.z.string().optional(),
+        cowboy: import_zod11.z.boolean().optional().describe(
           "If true, work in the project folder on the default branch (no thread/* worktree). Requires Settings \u2192 Advanced \u2192 Cowboy mode. Land is commit+push to that branch. Archive does not delete the folder."
         ),
-        parentChatId: import_zod10.z.string().optional().describe(
+        parentChatId: import_zod11.z.string().optional().describe(
           "Orchestration: omit (preferred) or pass YOUR chat id from the turn reminder / AGENTS.md. Do not invent uuids."
         ),
-        parentThreadId: import_zod10.z.string().optional().describe("Legacy alias for parentChatId."),
-        tags: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.array(import_zod10.z.string())]).optional().describe(
+        parentThreadId: import_zod11.z.string().optional().describe("Legacy alias for parentChatId."),
+        tags: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.array(import_zod11.z.string())]).optional().describe(
           "Short labels for this workspace (or a comma-separated string). Use the same tags on every checkout for one task. Added when the checkout already exists."
         )
       },
@@ -37080,11 +37684,11 @@ async function startMcpServer() {
       "start_board_card",
       "Same as create_workspace for a ticket, PR, or named branch (attaches issue text when Sideboard can resolve it). Does not create a second checkout when one already matches \u2014 returns that workspace (alreadyStarted) and its chats. A workspace can have many agents. fork_chat to add one; send_to_chat only the chat that should do this job.",
       {
-        kind: import_zod10.z.enum(["ticket", "pr", "branch"]),
-        ref: import_zod10.z.string().describe("Ticket identifier (ENG-12), PR number (44), or branch name from list_board"),
-        repoPath: import_zod10.z.string().describe("Project path from list_projects / list_board"),
-        title: import_zod10.z.string().optional(),
-        tags: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.array(import_zod10.z.string())]).optional().describe(
+        kind: import_zod11.z.enum(["ticket", "pr", "branch"]),
+        ref: import_zod11.z.string().describe("Ticket identifier (ENG-12), PR number (44), or branch name from list_board"),
+        repoPath: import_zod11.z.string().describe("Project path from list_projects / list_board"),
+        title: import_zod11.z.string().optional(),
+        tags: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.array(import_zod11.z.string())]).optional().describe(
           "Short labels for this workspace. Same tags on every checkout for one task. Added when the checkout already exists."
         )
       },
@@ -37189,9 +37793,9 @@ async function startMcpServer() {
       "send_to_chat",
       'Steer a prompt on a workspace chat (Settings \u2192 Follow-up, default steer: interrupt the in-flight turn and start now, same as the workspace composer). Use after create_workspace to start or continue a conversation. For commit/push/PR, prefer ask_git (canonical desktop-button phrases). Send "Merge PR." / ask_git merge only when the user explicitly asked to merge. force_stop=true kills the in-flight turn and clears the queue before this prompt \u2014 only when the current request is wrong and must be replaced. Do not send_to_chat to check in, resume after a halt notice, or because wait_for_turn returned stillRunning; that interrupts the child mid-thought. Call wait_for_turn again instead.',
       {
-        ref: import_zod10.z.string(),
-        prompt: import_zod10.z.string(),
-        force_stop: import_zod10.z.boolean().optional()
+        ref: import_zod11.z.string(),
+        prompt: import_zod11.z.string(),
+        force_stop: import_zod11.z.boolean().optional()
       },
       async ({ ref, prompt, force_stop }) => {
         if (force_stop) {
@@ -37216,8 +37820,8 @@ async function startMcpServer() {
         "wait_for_turn",
         "Wait until the chat finishes its current/queued turn, or return early with a live progress snapshot. MCP clients often kill tools around 60s, so this returns within 45s even while the child is still working. taskState is the A2A-style lifecycle: submitted (queued, not started), working, input-required (ask_user), completed, failed, canceled. stillRunning is true only for submitted/working. blockedReason is why the child is waiting on a person (the question, plan approval, or a reported block) \u2014 read it and do not send_to_chat a check-in. If stillRunning, text and usage are empty (they would be the previous turn) \u2014 read progress and call wait_for_turn again. Do not send_to_chat a check-in (that steers / interrupts). On failed, lastError/text is the failure. On canceled, the child did not finish \u2014 resume with send_to_chat or tell the user. On input-required, wait for the user in that chat. When finished, text is this turn\u2019s assistant reply and usage is that turn\u2019s tokens + costUsd (this turn, not the Claude session total; sessionCostUsd is the provider session total when present).",
         {
-          ref: import_zod10.z.string(),
-          timeoutMs: import_zod10.z.number().optional()
+          ref: import_zod11.z.string(),
+          timeoutMs: import_zod11.z.number().optional()
         },
         async ({ ref, timeoutMs }) => {
           const thread = await orch.waitForTurn(ref, mcpWaitForTurnTimeoutMs(timeoutMs), {
@@ -37245,7 +37849,7 @@ async function startMcpServer() {
     server.tool(
       "get_turn_result",
       "Assistant message and last-turn usage when the turn finished. While stillRunning (submitted/working), text and usage are empty so a previous reply cannot be mistaken for this turn \u2014 use progress for tools/thinking. Not the full transcript. Includes taskState (A2A lifecycle) and blockedReason (why the agent is waiting on a person).",
-      { ref: import_zod10.z.string() },
+      { ref: import_zod11.z.string() },
       async ({ ref }) => {
         const result = orch.getTurnResult(ref);
         const hint = mcpWaitTaskHint(result.taskState, result.status, result.blockedReason);
@@ -37261,9 +37865,9 @@ async function startMcpServer() {
       "stop_chat",
       "Force-stop a thread: kill any in-flight agent turn AND clear queued prompts so drainQueue cannot continue. Does not archive the worktree. Optional force defaults to true. Pass reason \u2014 a short note on why this chat is stopping. It is stored on the thread and kept when the turn unwinds. If you omit it, Sideboard still records that the queue was cleared.",
       {
-        ref: import_zod10.z.string(),
-        force: import_zod10.z.boolean().optional(),
-        reason: import_zod10.z.string().optional().describe("Why this chat is stopping. Stored on the thread for the next session.")
+        ref: import_zod11.z.string(),
+        force: import_zod11.z.boolean().optional(),
+        reason: import_zod11.z.string().optional().describe("Why this chat is stopping. Stored on the thread for the next session.")
       },
       async ({ ref, force, reason }) => {
         const t = orch.getThread(ref);
@@ -37284,56 +37888,13 @@ async function startMcpServer() {
         });
       }
     );
-    server.tool(
-      "archive_chat",
-      "Archive a thread (stops agent/dev, runs archive script, removes worktree when last chat tab). Coordinators commit, push, and open PRs by asking the worktree agent (ask_git). Merge only when the user explicitly asked.",
-      { ref: import_zod10.z.string() },
-      async ({ ref }) => {
-        const t = orch.getThread(ref);
-        if (!t) {
-          return {
-            content: [{ type: "text", text: `Chat not found: ${ref}` }],
-            isError: true
-          };
-        }
-        const blocked = mcpArchiveBlockedReason(t);
-        if (blocked) {
-          return {
-            content: [{ type: "text", text: blocked }],
-            isError: true
-          };
-        }
-        const archived = await orch.archive(ref);
-        return mcpJson({
-          id: archived.id,
-          status: archived.status
-        });
-      }
-    );
-    server.tool(
-      "restore_chat",
-      "Restore an archived thread (recreates worktree from branch when needed)",
-      { ref: import_zod10.z.string() },
-      async ({ ref }) => {
-        try {
-          const restored = await orch.restore(ref);
-          return mcpJson({
-            id: restored.id,
-            status: restored.status,
-            worktreePath: restored.worktreePath
-          });
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
-          return { content: [{ type: "text", text: message }], isError: true };
-        }
-      }
-    );
+    registerArchiveTools(server, orch);
     server.tool(
       "get_diff",
       "Compact diff summary (capped hunks, paginated)",
       {
-        ref: import_zod10.z.string(),
-        maxFiles: import_zod10.z.number().optional()
+        ref: import_zod11.z.string(),
+        maxFiles: import_zod11.z.number().optional()
       },
       async ({ ref, maxFiles }) => {
         const summary = await orch.diffSummary(ref);
@@ -37346,7 +37907,7 @@ async function startMcpServer() {
     server.tool(
       "get_pr_checks",
       "Snapshot of GitHub PR checks for a worktree thread (`gh pr checks` plus merge/review gates). null = no PR. If the user gave a goal (Greptile 5/5, CI green), the worktree agent watches with `gh pr checks --watch` via /long-running \u2014 this tool is a snapshot, not a waiter. Coordinators: do not run gh from the orchestration cwd.",
-      { ref: import_zod10.z.string().describe("Worktree thread id/ref") },
+      { ref: import_zod11.z.string().describe("Worktree thread id/ref") },
       async ({ ref }) => {
         try {
           const checks = await orch.getPrChecks(ref);
@@ -37360,7 +37921,7 @@ async function startMcpServer() {
     server.tool(
       "request_review",
       'Start a merge-readiness Review on a worktree agent thread (same as the desktop Review button). If that worktree has a single unused idle agent (no messages), runs the review there; otherwise opens a new Review chat tab. Attaches .claude/skills/review/SKILL.md when present (else copies .sideboard/review.md into .context/review.md, or seeds that file from the stock template), and sends "Review changes in this workspace." Expect Approve / Approve with nits / Request changes / Needs more information in that chat. The review stays there so the user can read it and type next steps \u2014 do not comment on or update the PR or ticket, and do not ask_user after the review, until they ask. Pass a worktree thread ref \u2014 not the orchestrator. Then wait_for_turn (loop while stillRunning) / get_turn_result on the returned review thread id.',
-      { ref: import_zod10.z.string().describe("Worktree thread id/ref to review") },
+      { ref: import_zod11.z.string().describe("Worktree thread id/ref to review") },
       async ({ ref }) => {
         try {
           const tab = await orch.requestReview(ref);
@@ -37382,8 +37943,8 @@ async function startMcpServer() {
       "ask_git",
       "Commit & push, open a draft PR, mark ready for review, resolve conflicts, or merge \u2014 same prompts as the desktop git buttons (including Resolve). Always steers the worktree agent; does not push or open the PR locally. Then wait_for_turn (loop while stillRunning). Do not start a checks loop on a plain push \u2014 only if the user gave a goal (Greptile 5/5, CI green). Pass a worktree thread ref (not the orchestrator). action=ready-for-review and action=merge only when the user explicitly asked (or clicked the desktop button). Do not run git or gh from the orchestration cwd.",
       {
-        ref: import_zod10.z.string().describe("Worktree thread id/ref"),
-        action: import_zod10.z.enum(AGENT_GIT_ACTIONS).describe(
+        ref: import_zod11.z.string().describe("Worktree thread id/ref"),
+        action: import_zod11.z.enum(AGENT_GIT_ACTIONS).describe(
           "commit-push | create-draft | create-web | resolve-conflicts | ready-for-review | merge"
         )
       },
@@ -37412,7 +37973,7 @@ async function startMcpServer() {
         }
       }
     );
-    const agentEnum = import_zod10.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]);
+    const agentEnum = import_zod11.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]);
     server.tool(
       "list_models",
       "List models for an agent. Prefer Auto: do not call this unless you have a reason to pin a specific model (user request, cost/latency, capability). Omit agent to list all.",
@@ -37433,11 +37994,11 @@ async function startMcpServer() {
       "fork_workspace",
       "Fork a worktree agent chat into a NEW git worktree + chat (desktop \u201CFork to new workspace\u201D). Seeds a transcript (through through_index, default all). Optional agent override. Leave model unset for Auto (default) \u2014 only pass model when you have a reason. Not for the orchestrator. Then send_to_chat / wait_for_turn (loop while stillRunning) on the returned id.",
       {
-        ref: import_zod10.z.string().describe("Worktree thread id/ref to fork"),
-        through_index: import_zod10.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
+        ref: import_zod11.z.string().describe("Worktree thread id/ref to fork"),
+        through_index: import_zod11.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
         agent: agentEnum.optional().describe("Agent for the forked chat (default: same as source)"),
-        model: import_zod10.z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
-        title: import_zod10.z.string().optional()
+        model: import_zod11.z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
+        title: import_zod11.z.string().optional()
       },
       async ({ ref, through_index, agent, model, title }) => {
         try {
@@ -37471,11 +38032,11 @@ async function startMcpServer() {
       "fork_chat",
       "Add another agent chat on the SAME workspace (same files, Run, and git). Also forks a Global orchestration chat into a new orchestration tab. Pass agent when the new chat should use a different harness. Leave model unset for Auto unless you have a reason. Orchestration forks require an MCP-capable agent (claude, cursor, codex, opencode \u2014 not brightsy). Use this for a second agent on a checkout (review, another harness, parallel work on the same branch). Do not create_workspace again for that \u2014 it returns the existing checkout. Then send_to_chat / wait_for_turn (loop while stillRunning) on the returned id. Use fork_workspace only when the work needs its own git checkout.",
       {
-        ref: import_zod10.z.string().describe("Thread id/ref to fork (worktree agent or orchestration chat)"),
-        through_index: import_zod10.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
+        ref: import_zod11.z.string().describe("Thread id/ref to fork (worktree agent or orchestration chat)"),
+        through_index: import_zod11.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
         agent: agentEnum.optional().describe("Agent for the forked chat (default: same as source)"),
-        model: import_zod10.z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
-        title: import_zod10.z.string().optional()
+        model: import_zod11.z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
+        title: import_zod11.z.string().optional()
       },
       async ({ ref, through_index, agent, model, title }) => {
         try {
@@ -37513,7 +38074,7 @@ async function startMcpServer() {
     server.tool(
       "run_setup",
       "Re-run workspace setup (Sideboard/Conductor settings, .cursor/worktrees.json, or script/setup). New worktrees already run this automatically.",
-      { ref: import_zod10.z.string() },
+      { ref: import_zod11.z.string() },
       async ({ ref }) => {
         const result = await orch.runSetup(ref);
         return mcpJson(result);
@@ -37522,7 +38083,7 @@ async function startMcpServer() {
     server.tool(
       "add_project",
       "Register a git repo as a Sideboard workspace",
-      { repoPath: import_zod10.z.string() },
+      { repoPath: import_zod11.z.string() },
       async ({ repoPath }) => {
         const ws = await orch.addWorkspace(repoPath);
         return mcpJson(ws);
@@ -37531,7 +38092,7 @@ async function startMcpServer() {
     server.tool(
       "remove_project",
       "Unregister a Sideboard workspace and archive its chats",
-      { repoPath: import_zod10.z.string() },
+      { repoPath: import_zod11.z.string() },
       async ({ repoPath }) => {
         await orch.removeWorkspace(repoPath);
         return { content: [{ type: "text", text: "ok" }] };
@@ -37541,12 +38102,12 @@ async function startMcpServer() {
       "fanout",
       "Best-of-n: create one thread per agent with the same prompt (parallel attempts)",
       {
-        prompt: import_zod10.z.string(),
-        agents: import_zod10.z.array(import_zod10.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"])),
-        repoPath: import_zod10.z.string(),
-        sourceType: import_zod10.z.enum(["branch", "pr", "ticket"]).optional(),
-        sourceRef: import_zod10.z.string().optional(),
-        title: import_zod10.z.string().optional()
+        prompt: import_zod11.z.string(),
+        agents: import_zod11.z.array(import_zod11.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"])),
+        repoPath: import_zod11.z.string(),
+        sourceType: import_zod11.z.enum(["branch", "pr", "ticket"]).optional(),
+        sourceRef: import_zod11.z.string().optional(),
+        title: import_zod11.z.string().optional()
       },
       async (args) => {
         const threads = await orch.bestOfN(args);
@@ -37564,8 +38125,8 @@ async function startMcpServer() {
       "list_branches",
       "List git branches in a registered workspace. Pass repoPath from list_projects (unmerged into the default branch by default \u2014 for create_workspace sourceType=branch).",
       {
-        repoPath: import_zod10.z.string(),
-        unmergedOnly: import_zod10.z.boolean().optional()
+        repoPath: import_zod11.z.string(),
+        unmergedOnly: import_zod11.z.boolean().optional()
       },
       async ({ repoPath, unmergedOnly }) => {
         const root = await resolveRepoRoot(repoPath);
@@ -37586,19 +38147,19 @@ async function startMcpServer() {
       "list_prs",
       `List GitHub PRs for a registered workspace (the review surface for assigned ticket work \u2014 not the tickets). Pass repoPath from list_projects. "Get me N tickets to review" \u2192 queue=review and limit=N: open non-draft PRs labeled with this project's ready-for-review GitHub label (Settings \u2192 Projects; default eng-review) with no individual user reviewer. Prefer teams that match Settings \u2192 Agents / Projects roles for this repo. A team like engineering-team is not a claim (you are on that team). Also: state (open|closed|merged|all|review), label, reviewer (me|unassigned|login), query, limit (default 40, max 250). Then create_workspace with sourceType=pr.`,
       {
-        repoPath: import_zod10.z.string(),
-        query: import_zod10.z.string().optional().describe("GitHub search tokens (title, draft:true, \u2026)"),
-        queue: import_zod10.z.enum(["review", "mine", "approved", "changes"]).optional().describe(
+        repoPath: import_zod11.z.string(),
+        query: import_zod11.z.string().optional().describe("GitHub search tokens (title, draft:true, \u2026)"),
+        queue: import_zod11.z.enum(["review", "mine", "approved", "changes"]).optional().describe(
           "review = unclaimed ready-for-review inbox (Settings \u2192 Projects label, default eng-review). mine = review-requested:@me. approved / changes = eng-approved / eng-requested-changes."
         ),
-        state: import_zod10.z.enum(["open", "closed", "merged", "all", "review"]).optional().describe("GitHub PR state (default open). review is an alias for queue=review."),
-        label: import_zod10.z.string().optional().describe(
+        state: import_zod11.z.enum(["open", "closed", "merged", "all", "review"]).optional().describe("GitHub PR state (default open). review is an alias for queue=review."),
+        label: import_zod11.z.string().optional().describe(
           "GitHub label / workflow tag. Comma-separated AND. Examples: eng-review, eng-approved, eng-requested-changes"
         ),
-        reviewer: import_zod10.z.string().optional().describe(
+        reviewer: import_zod11.z.string().optional().describe(
           "me (review requested of you), unassigned (no individual reviewer; team queues like engineering-team still count), all, or a GitHub login"
         ),
-        limit: import_zod10.z.number().int().positive().max(250).optional().describe("Page size (default 40, max 250). Raise when truncated is true.")
+        limit: import_zod11.z.number().int().positive().max(250).optional().describe("Page size (default 40, max 250). Raise when truncated is true.")
       },
       async ({ repoPath, query, queue, state, label, reviewer, limit }) => {
         const root = await resolveRepoRoot(repoPath);
@@ -37631,7 +38192,7 @@ async function startMcpServer() {
     server.tool(
       "get_pr_stack",
       "Load the GitHub PR stack for a thread worktree (`gh stack view --json`). Returns null JSON when the branch is not stacked. Prefer this before ask_git merge on stacked PRs (and only merge when the user explicitly asked).",
-      { ref: import_zod10.z.string() },
+      { ref: import_zod11.z.string() },
       async ({ ref }) => {
         const stack = await orch.getPrStack(ref);
         return mcpJson(stack);
@@ -37641,8 +38202,8 @@ async function startMcpServer() {
       "open_pr_stack_layers",
       "Materialize one worktree+thread per stack layer (or a single 1-based layer). Pass a thread ref already on the stack.",
       {
-        ref: import_zod10.z.string(),
-        layer: import_zod10.z.number().int().positive().optional()
+        ref: import_zod11.z.string(),
+        layer: import_zod11.z.number().int().positive().optional()
       },
       async ({ ref, layer }) => {
         const result = await orch.openPrStackLayers(ref, { layer });
@@ -37665,9 +38226,9 @@ async function startMcpServer() {
       "add_stack_layer",
       "Add a branch on top of the current stack (`gh stack add`) and open a worktree+thread for it.",
       {
-        ref: import_zod10.z.string(),
-        branchName: import_zod10.z.string(),
-        title: import_zod10.z.string().optional()
+        ref: import_zod11.z.string(),
+        branchName: import_zod11.z.string(),
+        title: import_zod11.z.string().optional()
       },
       async ({ ref, branchName, title }) => {
         const result = await orch.addStackLayer(ref, branchName, { title });
@@ -37685,11 +38246,11 @@ async function startMcpServer() {
       "create_pr_stack",
       "Create a new GitHub PR stack with one Sideboard worktree per layer (bottom\u2192top branch names). Requires `gh extension install github/gh-stack`.",
       {
-        repoPath: import_zod10.z.string(),
-        branches: import_zod10.z.array(import_zod10.z.string()).min(1),
-        agent: import_zod10.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]),
-        base: import_zod10.z.string().optional(),
-        title: import_zod10.z.string().optional()
+        repoPath: import_zod11.z.string(),
+        branches: import_zod11.z.array(import_zod11.z.string()).min(1),
+        agent: import_zod11.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]),
+        base: import_zod11.z.string().optional(),
+        title: import_zod11.z.string().optional()
       },
       async (args) => {
         const result = await orch.createPrStack({
@@ -37717,10 +38278,10 @@ async function startMcpServer() {
       "list_issues",
       "List or search issues (Linear, AbleTime, or GitHub; falls back to GitHub). Use Settings \u2192 Agents / Projects notes and roles to pick tickets relevant to the viewer (query + assignee=me or unassigned as the notes say). Default 40; pass query and/or limit (max 250) when truncated. assignee: me (Linear default), unassigned, all, or a user id. Pass updatedSince for new/updated tickets and new comments (\u201Cany updates since yesterday?\u201D). Then create_workspace with sourceType=ticket.",
       {
-        repoPath: import_zod10.z.string(),
-        query: import_zod10.z.string().optional().describe("Search title, identifier, or description"),
-        assignee: import_zod10.z.string().optional().describe("me (Linear default), unassigned, all, a user id, or a GitHub login"),
-        limit: import_zod10.z.number().int().positive().max(250).optional().describe("Page size (default 40, max 250). Raise when truncated is true."),
+        repoPath: import_zod11.z.string(),
+        query: import_zod11.z.string().optional().describe("Search title, identifier, or description"),
+        assignee: import_zod11.z.string().optional().describe("me (Linear default), unassigned, all, a user id, or a GitHub login"),
+        limit: import_zod11.z.number().int().positive().max(250).optional().describe("Page size (default 40, max 250). Raise when truncated is true."),
         updatedSince: mcpIssueUpdatedSinceSchema
       },
       async ({ repoPath, query, assignee, limit, updatedSince }) => {
@@ -38284,7 +38845,7 @@ init_user_mcp_config();
 init_orch_mcp_isolation();
 
 // src/slack/workspaces.ts
-var import_node_path68 = require("path");
+var import_node_path69 = require("path");
 init_paths();
 init_secure_file();
 
@@ -38329,7 +38890,7 @@ async function slackAuthTest(token) {
 
 // src/slack/workspaces.ts
 function storePath2() {
-  return (0, import_node_path68.join)(appDataDir(), "slack-workspaces.json");
+  return (0, import_node_path69.join)(appDataDir(), "slack-workspaces.json");
 }
 function readStore2() {
   try {
@@ -38943,12 +39504,12 @@ function connectSession(ws, opts, log) {
 
 // src/slack/reply-target.ts
 var import_node_fs70 = require("fs");
-var import_node_path69 = require("path");
+var import_node_path70 = require("path");
 init_paths();
 init_private_file();
 init_secure_file();
 function storePath3() {
-  return (0, import_node_path69.join)(appDataDir(), "slack-reply-to.json");
+  return (0, import_node_path70.join)(appDataDir(), "slack-reply-to.json");
 }
 function readStore3() {
   const path2 = storePath3();
@@ -40376,7 +40937,7 @@ init_turn_live();
 
 // src/remote/phone-media.ts
 var import_node_fs71 = require("fs");
-var import_node_path70 = require("path");
+var import_node_path71 = require("path");
 init_diff();
 var PHONE_IMAGE_MAX_BYTES = 15e5;
 var PHONE_TEXT_MAX_BYTES = 18e4;
@@ -40429,7 +40990,7 @@ function phoneImageDataUrl(worktreePath, raw) {
 }
 function phoneDirectoryListing(worktreePath, relative) {
   try {
-    const entries = (0, import_node_fs71.readdirSync)((0, import_node_path70.join)(worktreePath, relative), { withFileTypes: true });
+    const entries = (0, import_node_fs71.readdirSync)((0, import_node_path71.join)(worktreePath, relative), { withFileTypes: true });
     const dirs = new Set(entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name));
     const names = entries.map((entry) => entry.name).filter((name) => name && !name.includes("/") && !name.includes("\0")).sort((a, b) => a.localeCompare(b));
     const shown = names.slice(0, PHONE_DIR_MAX);
@@ -40455,7 +41016,7 @@ function phoneFilePreview(worktreePath, relative, kind) {
   }
   if (relative.toLowerCase().endsWith(".svg")) {
     try {
-      const buf = (0, import_node_fs71.readFileSync)((0, import_node_path70.join)(worktreePath, relative));
+      const buf = (0, import_node_fs71.readFileSync)((0, import_node_path71.join)(worktreePath, relative));
       const truncated = buf.length > PHONE_TEXT_MAX_BYTES;
       return {
         content: buf.subarray(0, PHONE_TEXT_MAX_BYTES).toString("utf8"),
@@ -40501,7 +41062,7 @@ var FENCE_RE = /```([a-zA-Z0-9_+-]*)[^\n]*\n([\s\S]*?)(?:```|$)/g;
 var DOC_LANGS = /* @__PURE__ */ new Set(["html", "htm", "xhtml", "svg", "markdown", "md", "mdx", "jsx", "tsx", "react"]);
 var MIN_FENCE_CHARS = 40;
 var MIN_MD_CHARS = 120;
-function oneLine(value, max) {
+function oneLine2(value, max) {
   return value.replace(/[`\r\n]/g, " ").replace(/\s+/g, " ").trim().slice(0, max);
 }
 function asRecord15(value) {
@@ -40555,11 +41116,11 @@ function kindFor(language, content) {
 function titleFor(kind, content) {
   if (kind === "html" || kind === "svg") {
     const title = /<title[^>]*>([^<]+)<\/title>/i.exec(content)?.[1]?.trim();
-    if (title) return oneLine(title, 80);
+    if (title) return oneLine2(title, 80);
   }
   if (kind === "markdown") {
     const heading = /^#\s+(.+)$/m.exec(content)?.[1]?.trim();
-    if (heading) return oneLine(heading, 80);
+    if (heading) return oneLine2(heading, 80);
   }
   if (kind === "react") {
     const name = /export\s+default\s+(?:function|class)\s+([A-Za-z_$][\w$]*)/.exec(content)?.[1];
@@ -40610,7 +41171,7 @@ function phoneArtifactText(text7, parts, limit = Number.POSITIVE_INFINITY) {
     const hint = artifactHint(content);
     if (hint && hints.has(hint)) continue;
     const kind = kindFor("", content);
-    const title = oneLine(str7(input?.title), 80) || (kind ? titleFor(kind, content) : "Artifact");
+    const title = oneLine2(str7(input?.title), 80) || (kind ? titleFor(kind, content) : "Artifact");
     if (!str7(input?.title) && content.trim().length < MIN_FENCE_CHARS) continue;
     if (hint) hints.add(hint);
     extras.push(marker(title, hint));
@@ -40626,9 +41187,9 @@ ${tail}` : tail;
 function parseOpenArtifact(value, chatId) {
   const record = asRecord15(value);
   if (!record) return "invalid";
-  const title = oneLine(str7(record.title), 200);
+  const title = oneLine2(str7(record.title), 200);
   if (!title) return "invalid";
-  const hint = oneLine(str7(record.hint), 200);
+  const hint = oneLine2(str7(record.hint), 200);
   return { op: "open-artifact", chatId, title, ...hint ? { hint } : {} };
 }
 var PHONE_ARTIFACT_MAX_CHARS = 18e4;
@@ -40652,7 +41213,7 @@ function phoneArtifactDocuments(sources) {
       const hint = artifactHint(content);
       if (hint && hints.has(hint)) continue;
       const typed = kindFor(str7(input?.type), content) ?? kindFor("", content);
-      const title = oneLine(str7(input?.title), 80) || (typed ? titleFor(typed, content) : "Artifact");
+      const title = oneLine2(str7(input?.title), 80) || (typed ? titleFor(typed, content) : "Artifact");
       if (!str7(input?.title) && content.trim().length < MIN_FENCE_CHARS) continue;
       if (hint) hints.add(hint);
       docs.push({ title, content, kind: typed ?? "text" });
@@ -41106,6 +41667,7 @@ function listPhoneMessages(thread) {
 }
 
 // src/remote/phone-history.ts
+init_worktree_labels();
 init_global_workspace();
 init_thread_store();
 var PREVIEW_LIMIT = 90;
@@ -41133,16 +41695,20 @@ function historyCursor(chat) {
 function listPhoneHistory(opts) {
   const query = opts?.query?.trim().toLowerCase() ?? "";
   const after = opts?.after?.trim() ?? "";
-  const all = listThreads({ includeArchived: true }).filter((thread) => thread.status === "archived").filter((thread) => isGlobalThread(thread) || isProjectPath(thread.repoPath)).sort((a, b) => historyStamp(a) < historyStamp(b) ? 1 : historyStamp(a) > historyStamp(b) ? -1 : 0).map((thread) => ({
-    id: thread.id,
-    title: thread.title?.trim() || "Untitled",
-    preview: previewOf(thread),
-    updatedAt: historyStamp(thread),
-    where: isGlobalThread(thread) ? "Orchestration" : repoName(thread.repoPath),
-    agent: thread.agent
-  })).filter((chat) => {
+  const all = listThreads({ includeArchived: true }).filter((thread) => thread.status === "archived").filter((thread) => isGlobalThread(thread) || isProjectPath(thread.repoPath)).sort((a, b) => historyStamp(a) < historyStamp(b) ? 1 : historyStamp(a) > historyStamp(b) ? -1 : 0).map((thread) => {
+    const workspace = workspaceNameLabel(thread);
+    return {
+      id: thread.id,
+      title: thread.title?.trim() || "Untitled",
+      preview: previewOf(thread),
+      updatedAt: historyStamp(thread),
+      where: isGlobalThread(thread) ? "Orchestration" : repoName(thread.repoPath),
+      agent: thread.agent,
+      ...workspace ? { workspace } : {}
+    };
+  }).filter((chat) => {
     if (!query) return true;
-    return `${chat.title} ${chat.where} ${chat.agent} ${chat.preview}`.toLowerCase().includes(query);
+    return `${chat.title} ${chat.where} ${chat.agent} ${chat.workspace ?? ""} ${chat.preview}`.toLowerCase().includes(query);
   });
   let start = 0;
   if (after) {
@@ -41447,7 +42013,7 @@ function listPhoneSidebar(viewerLogin = phoneViewerLogin()) {
         label: worktreeDisplayLabelForGroup(group),
         chats: group.map(summarize),
         ...tags.length > 0 ? { tags } : {},
-        ...badge ? { badge: { id: badge.id, label: badge.label, title: badge.title } } : {}
+        ...badge ? { badge: { id: badge.id, label: badge.label, title: badge.title, ...badge.conflict ? { conflict: true } : {}, ...badge.error ? { error: badge.error } : {} } } : {}
       };
     })
   }));
@@ -42433,7 +42999,7 @@ function handleRemoteInbound(text7, opts) {
 }
 
 // src/remote/phone-board-sync.ts
-var import_node_path71 = require("path");
+var import_node_path72 = require("path");
 var import_chokidar = require("chokidar");
 init_orchestrator();
 init_paths();
@@ -42478,7 +43044,7 @@ function subscribePhoneBoard(notify) {
   threads.on("error", () => void 0);
   const data = (0, import_chokidar.watch)(appDataDir(), { ignoreInitial: true, depth: 0 });
   const onData = (changed) => {
-    const name = (0, import_node_path71.basename)(changed);
+    const name = (0, import_node_path72.basename)(changed);
     if (name !== "workspaces.json" && name !== "removed-workspaces.json" && name !== "settings.json") return;
     notify();
   };
@@ -42795,12 +43361,12 @@ init_fetch();
 var import_node_crypto28 = require("crypto");
 var import_node_fs72 = require("fs");
 var import_node_module7 = require("module");
-var import_node_path72 = require("path");
+var import_node_path73 = require("path");
 var GITHUB_ACCOUNT_ISSUER = "https://github.com";
 var RELAY_DEVICE_CAP = 3;
 function thisModuleFile3() {
   const cjsFile = typeof __filename !== "undefined" ? __filename : "";
-  return cjsFile || process.argv[1] || (0, import_node_path72.join)(process.cwd(), "package.json");
+  return cjsFile || process.argv[1] || (0, import_node_path73.join)(process.cwd(), "package.json");
 }
 function openDatabase(filePath) {
   const req = (0, import_node_module7.createRequire)(thisModuleFile3());
@@ -42837,7 +43403,7 @@ function assertRelayAccountsDurable(filePath) {
   if (process.env.SIDEBOARD_RELAY_ACCOUNTS_EPHEMERAL === "1") return;
   if (process.env.NODE_ENV !== "production") return;
   if (process.platform !== "linux") return;
-  const dir = (0, import_node_fs72.realpathSync)((0, import_node_path72.dirname)(filePath));
+  const dir = (0, import_node_fs72.realpathSync)((0, import_node_path73.dirname)(filePath));
   const mounts = (0, import_node_fs72.readFileSync)("/proc/mounts", "utf8");
   const point = longestMountPoint(dir, mounts);
   if (point === "/") {
@@ -42849,7 +43415,7 @@ function assertRelayAccountsDurable(filePath) {
 var RelayAccountStore = class {
   db;
   constructor(filePath) {
-    (0, import_node_fs72.mkdirSync)((0, import_node_path72.dirname)(filePath), { recursive: true });
+    (0, import_node_fs72.mkdirSync)((0, import_node_path73.dirname)(filePath), { recursive: true });
     this.db = openDatabase(filePath);
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS accounts (
@@ -43885,7 +44451,7 @@ var import_ws6 = require("ws");
 // src/relay/static.ts
 var import_node_fs73 = require("fs");
 var import_promises = require("fs/promises");
-var import_node_path73 = __toESM(require("path"), 1);
+var import_node_path74 = __toESM(require("path"), 1);
 var TYPES = {
   ".css": "text/css; charset=utf-8",
   ".html": "text/html; charset=utf-8",
@@ -43916,9 +44482,9 @@ function resolveStaticPath(root, requestUrl) {
     return null;
   }
   if (!pathname.startsWith("/") || pathname.includes("\0")) return null;
-  const rootResolved = import_node_path73.default.resolve(root);
-  const candidate = import_node_path73.default.resolve(rootResolved, `.${pathname}`);
-  if (candidate !== rootResolved && !candidate.startsWith(rootResolved + import_node_path73.default.sep)) {
+  const rootResolved = import_node_path74.default.resolve(root);
+  const candidate = import_node_path74.default.resolve(rootResolved, `.${pathname}`);
+  if (candidate !== rootResolved && !candidate.startsWith(rootResolved + import_node_path74.default.sep)) {
     return null;
   }
   return candidate;
@@ -43932,7 +44498,7 @@ async function fileSize(file) {
   }
 }
 function sendFile(req, res, file, size) {
-  const ext = import_node_path73.default.extname(file).toLowerCase();
+  const ext = import_node_path74.default.extname(file).toLowerCase();
   res.writeHead(200, {
     "Content-Type": TYPES[ext] ?? "application/octet-stream",
     "Content-Length": size,
@@ -43951,7 +44517,7 @@ async function tryServeStatic(req, res, root) {
   if (!candidate) return false;
   const direct = await fileSize(candidate);
   if (direct != null) return sendFile(req, res, candidate, direct);
-  const asIndex = import_node_path73.default.join(candidate, "index.html");
+  const asIndex = import_node_path74.default.join(candidate, "index.html");
   const indexSize = await fileSize(asIndex);
   if (indexSize != null) return sendFile(req, res, asIndex, indexSize);
   return false;
@@ -44317,7 +44883,7 @@ async function startRelayServer(opts) {
 
 // src/slack/outbound-watch.ts
 var import_node_fs74 = require("fs");
-var import_node_path74 = require("path");
+var import_node_path75 = require("path");
 init_paths();
 init_private_file();
 init_secure_file();
@@ -44330,7 +44896,7 @@ var POLL_INTERVAL_MS = 12e3;
 var lastPollMs = 0;
 var nameCache = /* @__PURE__ */ new Map();
 function storePath4() {
-  return (0, import_node_path74.join)(appDataDir(), "slack-outbound-watch.json");
+  return (0, import_node_path75.join)(appDataDir(), "slack-outbound-watch.json");
 }
 function watchId(teamId, channelId, ts) {
   return `${teamId}:${channelId}:${ts}`;
@@ -44953,6 +45519,7 @@ async function pollSlackOutboundWatches(opts) {
   connectOptionalService,
   connectSlackToken,
   connectedOptionalServices,
+  connectedOrchestratorTurnReminder,
   connectedPrSelectors,
   consumeComposerAttachments,
   contextTokens,
@@ -45076,6 +45643,7 @@ async function pollSlackOutboundWatches(opts) {
   formatClaudeUsageResetClock,
   formatClaudeUsageTooltip,
   formatCloudTurnReply,
+  formatConnectedOrchestratorReminder,
   formatDetachedJobInvoke,
   formatDevAccessHint,
   formatFetchError,