@sideboard-ai/core 0.1.297 → 0.1.298

package/dist/mcp/run-stdio.js

@@ -14,6 +14,7 @@ import {
   chatBlockedSuffix,
   clampBlockReason,
   clampMcpIssueLimit,
+  connectedOrchestrator,
   createSchedule,
   dedupeBoardIssues,
   dedupeBoardPrs,
@@ -23,6 +24,7 @@ import {
   findBoardPr,
   findLiveThreadForCreate,
   fireSchedule,
+  formatFleetArchive,
   formatGitHubSearchUpdatedSince,
   formatListedIssuesForMcp,
   getOrchestrator,
@@ -31,6 +33,7 @@ import {
   isInjectedNoticeText,
   issueMatchesUpdatedSince,
   issueNeedsWorkspacePick,
+  listFleetArchive,
   listSchedules,
   localhostPreviewUrl,
   mcpIssueUpdatedSinceSchema,
@@ -53,7 +56,7 @@ import {
   updateSchedule,
   workspaceTagTargetRef,
   writeAgentBlock
-} from "../chunk-QT36F4TD.js";
+} from "../chunk-2POLTCSC.js";
 import "../chunk-LX5R5JOR.js";
 import {
   commentAbleTimeTask,
@@ -96,7 +99,7 @@ import {
   sideboardMcpProfile,
   trustSystemCertificates,
   worktreeMcpToolNames
-} from "../chunk-2O3ICR77.js";
+} from "../chunk-RQMLJZ2V.js";
 import "../chunk-WZCPZVUC.js";
 import "../chunk-7IAMHN2N.js";
 import "../chunk-PXMLMBMI.js";
@@ -113,18 +116,18 @@ import {
   waitForDetachedJob,
   waitForTurnToolResult,
   workspaceAgentChatSummaries
-} from "../chunk-ZXWRNA4G.js";
+} from "../chunk-JM5P36PM.js";
 import {
   HUGE_TOOL_RESULT_SUMMARY,
   clipToolResultForStore,
   formatUnknownDetail,
   isInternalAgentStatusText,
   looksLikeHugeToolResultDump
-} from "../chunk-ED4ZXQVO.js";
+} from "../chunk-5XQ43YZU.js";
 import {
   GLOBAL_WORKSPACE_ID,
   isCloudCoordinatorThread
-} from "../chunk-WQREAX35.js";
+} from "../chunk-5FMQU2RU.js";
 import {
   canonicalizeRepoPath,
   formatGhLandError,
@@ -135,7 +138,7 @@ import {
   resolveListPrsOptions,
   resolveRepoRoot,
   warmGithubAgentAuth
-} from "../chunk-VXNZG4J6.js";
+} from "../chunk-3IXGI2FP.js";
 import {
   CLI_DIR
 } from "../chunk-N2WW62LF.js";
@@ -168,7 +171,7 @@ import {
   normalizeWorkspaceTags,
   readThread,
   updateThread
-} from "../chunk-TVN4TDFB.js";
+} from "../chunk-HTL4FBTP.js";
 import "../chunk-4RZRHTSZ.js";
 import "../chunk-KGZBYWZ3.js";
 import {
@@ -282,7 +285,7 @@ function createClippedMcpServer() {
 }
 
 // src/mcp/server.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 import { randomUUID as randomUUID3 } from "crypto";
 import { basename } from "path";
 
@@ -2161,14 +2164,6 @@ function commentsFromAbleTimeIssues(tasks, issues, sinceIso) {
   return out;
 }
 
-// src/mcp/archive-guard.ts
-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/run-script-ref.ts
 function resolveRunScriptThreadRef(ref) {
   const explicit = ref?.trim();
@@ -3395,8 +3390,137 @@ function formatMcpPrList(input) {
   };
 }
 
-// src/mcp/schedule-tools.ts
+// src/mcp/archive-tools.ts
 import { z as z6 } from "zod";
+
+// src/mcp/archive-guard.ts
+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
+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: z6.string().optional().describe("Title, branch, repo, agent, ticket, or PR"),
+      kind: z6.enum(["all", "workspace", "agent"]).optional().describe("all (default), workspace, or agent"),
+      limit: z6.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: z6.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: z6.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: z6.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: z6.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
+import { z as z7 } from "zod";
 function text4(payload, isError = false) {
   return mcpJson(payload, isError);
 }
@@ -3436,18 +3560,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: z6.string().describe("User message / goal queued when the schedule fires"),
-      name: z6.string().optional(),
-      at: z6.string().optional().describe("ISO datetime for a one-shot"),
-      every: z6.string().optional().describe("Interval such as 15m, 1h, 6h, 1d"),
-      cron: z6.string().optional().describe("5-field cron expression"),
-      tz: z6.string().optional().describe("IANA timezone for cron (default: system)"),
-      chatId: z6.string().optional().describe(
+      prompt: z7.string().describe("User message / goal queued when the schedule fires"),
+      name: z7.string().optional(),
+      at: z7.string().optional().describe("ISO datetime for a one-shot"),
+      every: z7.string().optional().describe("Interval such as 15m, 1h, 6h, 1d"),
+      cron: z7.string().optional().describe("5-field cron expression"),
+      tz: z7.string().optional().describe("IANA timezone for cron (default: system)"),
+      chatId: z7.string().optional().describe(
         'Existing chat id (orchestration or workspace), or "self" for this chat. Omit to create a new Global chat on fire.'
       ),
-      threadId: z6.string().optional().describe("Legacy alias for chatId."),
-      agent: z6.enum(["claude", "cursor", "codex", "opencode"]).optional().describe("Agent for a new Global chat (omit for Account default)"),
-      model: z6.string().optional()
+      threadId: z7.string().optional().describe("Legacy alias for chatId."),
+      agent: z7.enum(["claude", "cursor", "codex", "opencode"]).optional().describe("Agent for a new Global chat (omit for Account default)"),
+      model: z7.string().optional()
     },
     async (args) => {
       try {
@@ -3483,20 +3607,20 @@ function registerScheduleTools(server) {
     "update_schedule",
     "Update a local schedule (prompt, cadence, target chat, enabled). Pass id from list_schedules.",
     {
-      id: z6.string(),
-      prompt: z6.string().optional(),
-      name: z6.string().optional(),
-      at: z6.string().optional(),
-      every: z6.string().optional(),
-      cron: z6.string().optional(),
-      tz: z6.string().optional(),
-      chatId: z6.string().optional().describe(
+      id: z7.string(),
+      prompt: z7.string().optional(),
+      name: z7.string().optional(),
+      at: z7.string().optional(),
+      every: z7.string().optional(),
+      cron: z7.string().optional(),
+      tz: z7.string().optional(),
+      chatId: z7.string().optional().describe(
         'Existing chat (orchestration or workspace), "self", or empty string to create a new Global chat each run'
       ),
-      threadId: z6.string().optional().describe("Legacy alias for chatId."),
-      agent: z6.enum(["claude", "cursor", "codex", "opencode"]).optional(),
-      model: z6.string().optional(),
-      enabled: z6.boolean().optional()
+      threadId: z7.string().optional().describe("Legacy alias for chatId."),
+      agent: z7.enum(["claude", "cursor", "codex", "opencode"]).optional(),
+      model: z7.string().optional(),
+      enabled: z7.boolean().optional()
     },
     async (args) => {
       try {
@@ -3537,7 +3661,7 @@ function registerScheduleTools(server) {
   server.tool(
     "delete_schedule",
     "Delete a local schedule. Pass id from list_schedules.",
-    { id: z6.string() },
+    { id: z7.string() },
     async ({ id }) => {
       try {
         deleteSchedule(id);
@@ -3550,7 +3674,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: z6.string() },
+    { id: z7.string() },
     async ({ id }) => {
       try {
         if (!getSchedule(id)) {
@@ -3950,10 +4074,10 @@ 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_ID ? "Orchestration" : basename(t.repoPath) || t.repoPath;
           const live = orch.threadLooksLive(t) ? readTurnLive(t.id) : null;
@@ -3971,18 +4095,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, 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 (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: z7.string().optional().describe("Case-insensitive token search across title, id, labels, workspace tags, repo"),
-        repoPath: z7.string().optional().describe("Limit to one project path from list_projects"),
-        kind: z7.enum(["all", "tickets", "prs", "branches", "threads"]).optional().describe("Filter by worktree source (default all)"),
-        ownership: z7.enum(["all", "mine", "reviewing"]).optional().describe(
+        query: z8.string().optional().describe("Case-insensitive token search across title, id, labels, workspace tags, repo"),
+        repoPath: z8.string().optional().describe("Limit to one project path from list_projects"),
+        kind: z8.enum(["all", "tickets", "prs", "branches", "threads"]).optional().describe("Filter by worktree source (default all)"),
+        ownership: z8.enum(["all", "mine", "reviewing"]).optional().describe(
           "Mine = PRs you authored or local WIP; reviewing = someone else's PR. Uses the gh login."
         ),
-        column: z7.enum(["new", "draft", "review", "done", "needs_you"]).optional().describe(
+        column: z8.enum(["new", "draft", "review", "done", "needs_you"]).optional().describe(
           "Return cards for this column only (totals still include the rest). needs_you is a legacy alias for new."
         ),
-        limit: z7.number().int().positive().optional().describe("Max cards per column (default 40). hidden counts the remainder.")
+        limit: z8.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();
@@ -4012,7 +4136,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: z7.string() },
+      { ref: z8.string() },
       async ({ ref }) => {
         const t = orch.getThread(ref);
         if (!t) {
@@ -4059,17 +4183,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: z7.string().describe("Short title shown in the artifact pane header"),
-        type: z7.enum(["html", "svg", "markdown", "react", "log"]).describe(
+        title: z8.string().describe("Short title shown in the artifact pane header"),
+        type: z8.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: z7.string().describe(
+        content: z8.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: z7.string().optional().describe("Stable id. Required for type=log so later calls append to the same pane."),
-        status: z7.enum(["running", "ok", "failed", "idle"]).optional().describe("Log header pill: running (working), ok (done), failed, idle"),
-        phase: z7.string().optional().describe("Log subtitle (Signing, Notarizing, \u2026)"),
-        mode: z7.enum(["append", "replace"]).optional().describe("log only: append (default) or replace the buffer")
+        artifact_id: z8.string().optional().describe("Stable id. Required for type=log so later calls append to the same pane."),
+        status: z8.enum(["running", "ok", "failed", "idle"]).optional().describe("Log header pill: running (working), ok (done), failed, idle"),
+        phase: z8.string().optional().describe("Log subtitle (Signing, Notarizing, \u2026)"),
+        mode: z8.enum(["append", "replace"]).optional().describe("log only: append (default) or replace the buffer")
       },
       async ({ title, type, artifact_id, status, phase, mode }) => {
         return mcpJson(
@@ -4082,15 +4206,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: z7.array(
-        z7.object({
-          question: z7.string().describe("Full question text ending with ?"),
-          header: z7.string().max(24).optional().describe("Short label shown above the question"),
-          multiSelect: z7.boolean().optional().describe("Allow selecting multiple options"),
-          options: z7.array(
-            z7.object({
-              label: z7.string(),
-              description: z7.string().optional().describe("What this option means / when to choose it (strongly preferred)")
+      questions: z8.array(
+        z8.object({
+          question: z8.string().describe("Full question text ending with ?"),
+          header: z8.string().max(24).optional().describe("Short label shown above the question"),
+          multiSelect: z8.boolean().optional().describe("Allow selecting multiple options"),
+          options: z8.array(
+            z8.object({
+              label: z8.string(),
+              description: z8.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)")
         })
@@ -4116,9 +4240,9 @@ async function startMcpServer() {
       "present_plan",
       PRESENT_PLAN_TOOL_DESCRIPTION,
       {
-        title: z7.string().optional().describe("Short plan title (defaults to Plan)"),
-        content: z7.string().min(1).describe("Full plan markdown (headings, steps, risks, open questions)"),
-        thread_id: z7.string().optional().describe("Sideboard thread id when cwd is not the worktree")
+        title: z8.string().optional().describe("Short plan title (defaults to Plan)"),
+        content: z8.string().min(1).describe("Full plan markdown (headings, steps, risks, open questions)"),
+        thread_id: z8.string().optional().describe("Sideboard thread id when cwd is not the worktree")
       },
       async ({ title, content, thread_id }) => {
         const { writePlanFile } = await import("../plan-file-VAHV5WBB.js");
@@ -4147,15 +4271,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: z7.string().describe("Pane title"),
-      mode: z7.enum(["table", "form"]).optional().describe("table = list/filter records; form = edit one record"),
-      datasource: z7.enum(["brightsy", "inline"]).optional().describe("brightsy resolves via login; inline uses embedded resource/records"),
-      resource_id: z7.string().optional().describe("Brightsy record type UUID (or generic resource id)"),
-      record_id: z7.string().optional().describe("Record id when opening form mode"),
-      resource: z7.record(z7.unknown()).optional().describe("Inline { id, title, schema, schemaUi?, slug? }"),
-      record: z7.record(z7.unknown()).optional().describe("Inline record { id, data, published_at? }"),
-      records: z7.array(z7.record(z7.unknown())).optional().describe("Inline records for table mode"),
-      pane_id: z7.string().optional().describe("Stable pane id across updates")
+      title: z8.string().describe("Pane title"),
+      mode: z8.enum(["table", "form"]).optional().describe("table = list/filter records; form = edit one record"),
+      datasource: z8.enum(["brightsy", "inline"]).optional().describe("brightsy resolves via login; inline uses embedded resource/records"),
+      resource_id: z8.string().optional().describe("Brightsy record type UUID (or generic resource id)"),
+      record_id: z8.string().optional().describe("Record id when opening form mode"),
+      resource: z8.record(z8.unknown()).optional().describe("Inline { id, title, schema, schemaUi?, slug? }"),
+      record: z8.record(z8.unknown()).optional().describe("Inline record { id, data, published_at? }"),
+      records: z8.array(z8.record(z8.unknown())).optional().describe("Inline records for table mode"),
+      pane_id: z8.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)}`;
@@ -4176,10 +4300,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: z7.string().optional().describe("Pane title (default: Files)"),
-      datasource: z7.enum(["brightsy", "memory"]).optional().describe("brightsy = account storage via login; memory = session demo store"),
-      path: z7.string().optional().describe("Initial folder path (e.g. public)"),
-      pane_id: z7.string().optional().describe("Stable pane id across updates")
+      title: z8.string().optional().describe("Pane title (default: Files)"),
+      datasource: z8.enum(["brightsy", "memory"]).optional().describe("brightsy = account storage via login; memory = session demo store"),
+      path: z8.string().optional().describe("Initial folder path (e.g. public)"),
+      pane_id: z8.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)}`;
@@ -4199,8 +4323,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: z7.string().describe("Detached job id (same kebab-case id passed to detached-job.cjs start)"),
-        timeoutMs: z7.number().optional()
+        id: z8.string().describe("Detached job id (same kebab-case id passed to detached-job.cjs start)"),
+        timeoutMs: z8.number().optional()
       },
       async ({ id, timeoutMs }) => {
         const result = await waitForDetachedJob(process.cwd(), id, {
@@ -4213,8 +4337,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: z7.string().describe("Detached job id (same kebab-case id passed to detached-job.cjs start)"),
-        reason: z7.string().optional().describe("Why you are stopping (hanging, no progress, wrong output, already have the answer)")
+        id: z8.string().describe("Detached job id (same kebab-case id passed to detached-job.cjs start)"),
+        reason: z8.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 });
@@ -4226,7 +4350,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: z7.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd).")
+      ref: z8.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd).")
     },
     async ({ ref }) => {
       try {
@@ -4256,8 +4380,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: z7.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
-      name: z7.string().optional().describe("Script name from list_run_scripts (default script if omitted).")
+      ref: z8.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
+      name: z8.string().optional().describe("Script name from list_run_scripts (default script if omitted).")
     },
     async ({ ref, name }) => {
       try {
@@ -4285,8 +4409,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: z7.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
-      name: z7.string().optional().describe("Script name to stop; omit to stop all active scripts.")
+      ref: z8.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
+      name: z8.string().optional().describe("Script name to stop; omit to stop all active scripts.")
     },
     async ({ ref, name }) => {
       try {
@@ -4303,9 +4427,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: z7.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
-      name: z7.string().optional().describe("Script name from list_run_scripts (default script if omitted)."),
-      tail: z7.number().int().min(1).max(MAX_RUN_LOG_CHARS).optional().describe(
+      ref: z8.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
+      name: z8.string().optional().describe("Script name from list_run_scripts (default script if omitted)."),
+      tail: z8.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.`
       )
     },
@@ -4339,12 +4463,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 text5 = err instanceof Error ? err.message : String(err);
+          return { content: [{ type: "text", text: text5 }], 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: z7.string().min(1).max(1500).describe("Why you are blocked / what the parent should know (short)."),
-        reason: z7.enum(["input-required", "blocked"]).optional().describe(
+        message: z8.string().min(1).max(1500).describe("Why you are blocked / what the parent should know (short)."),
+        reason: z8.enum(["input-required", "blocked"]).optional().describe(
           "input-required = waiting on the user in this chat; blocked = need the coordinator (default)."
         )
       },
@@ -4381,11 +4530,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: z7.string().optional().describe(
+      ref: z8.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: z7.union([z7.string(), z7.array(z7.string())]).describe("Labels to set. A string may be comma-separated."),
-      mode: z7.enum(["replace", "add", "remove"]).optional()
+      tags: z8.union([z8.string(), z8.array(z8.string())]).describe("Labels to set. A string may be comma-separated."),
+      mode: z8.enum(["replace", "add", "remove"]).optional()
     },
     async ({ ref, tags, mode }) => {
       try {
@@ -4419,7 +4568,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: z7.boolean().describe("true = hold caffeinate on; false = release and let the Mac sleep")
+        enabled: z8.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;
@@ -4445,24 +4594,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: z7.enum(["branch", "pr", "ticket"]),
-        sourceRef: z7.string(),
-        agent: z7.enum(["claude", "codex", "opencode", "brightsy", "cursor"]).optional().describe(
+        sourceType: z8.enum(["branch", "pr", "ticket"]),
+        sourceRef: z8.string(),
+        agent: z8.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: z7.string().nullable().optional().describe(
+        model: z8.string().nullable().optional().describe(
           `Usually omit to use Account default model (${accountDefaults.model?.trim() || "Auto"}). Pass null only to force Auto / agent-default.`
         ),
-        repoPath: z7.string(),
-        title: z7.string().optional(),
-        cowboy: z7.boolean().optional().describe(
+        repoPath: z8.string(),
+        title: z8.string().optional(),
+        cowboy: z8.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: z7.string().optional().describe(
+        parentChatId: z8.string().optional().describe(
           "Orchestration: omit (preferred) or pass YOUR chat id from the turn reminder / AGENTS.md. Do not invent uuids."
         ),
-        parentThreadId: z7.string().optional().describe("Legacy alias for parentChatId."),
-        tags: z7.union([z7.string(), z7.array(z7.string())]).optional().describe(
+        parentThreadId: z8.string().optional().describe("Legacy alias for parentChatId."),
+        tags: z8.union([z8.string(), z8.array(z8.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."
         )
       },
@@ -4478,11 +4627,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: z7.enum(["ticket", "pr", "branch"]),
-        ref: z7.string().describe("Ticket identifier (ENG-12), PR number (44), or branch name from list_board"),
-        repoPath: z7.string().describe("Project path from list_projects / list_board"),
-        title: z7.string().optional(),
-        tags: z7.union([z7.string(), z7.array(z7.string())]).optional().describe(
+        kind: z8.enum(["ticket", "pr", "branch"]),
+        ref: z8.string().describe("Ticket identifier (ENG-12), PR number (44), or branch name from list_board"),
+        repoPath: z8.string().describe("Project path from list_projects / list_board"),
+        title: z8.string().optional(),
+        tags: z8.union([z8.string(), z8.array(z8.string())]).optional().describe(
           "Short labels for this workspace. Same tags on every checkout for one task. Added when the checkout already exists."
         )
       },
@@ -4587,9 +4736,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: z7.string(),
-        prompt: z7.string(),
-        force_stop: z7.boolean().optional()
+        ref: z8.string(),
+        prompt: z8.string(),
+        force_stop: z8.boolean().optional()
       },
       async ({ ref, prompt, force_stop }) => {
         if (force_stop) {
@@ -4614,8 +4763,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: z7.string(),
-          timeoutMs: z7.number().optional()
+          ref: z8.string(),
+          timeoutMs: z8.number().optional()
         },
         async ({ ref, timeoutMs }) => {
           const thread = await orch.waitForTurn(ref, mcpWaitForTurnTimeoutMs(timeoutMs), {
@@ -4643,7 +4792,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: z7.string() },
+      { ref: z8.string() },
       async ({ ref }) => {
         const result = orch.getTurnResult(ref);
         const hint = mcpWaitTaskHint(result.taskState, result.status, result.blockedReason);
@@ -4659,9 +4808,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: z7.string(),
-        force: z7.boolean().optional(),
-        reason: z7.string().optional().describe("Why this chat is stopping. Stored on the thread for the next session.")
+        ref: z8.string(),
+        force: z8.boolean().optional(),
+        reason: z8.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);
@@ -4682,56 +4831,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: z7.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: z7.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: z7.string(),
-        maxFiles: z7.number().optional()
+        ref: z8.string(),
+        maxFiles: z8.number().optional()
       },
       async ({ ref, maxFiles }) => {
         const summary = await orch.diffSummary(ref);
@@ -4744,7 +4850,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: z7.string().describe("Worktree thread id/ref") },
+      { ref: z8.string().describe("Worktree thread id/ref") },
       async ({ ref }) => {
         try {
           const checks = await orch.getPrChecks(ref);
@@ -4758,7 +4864,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: z7.string().describe("Worktree thread id/ref to review") },
+      { ref: z8.string().describe("Worktree thread id/ref to review") },
       async ({ ref }) => {
         try {
           const tab = await orch.requestReview(ref);
@@ -4780,8 +4886,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: z7.string().describe("Worktree thread id/ref"),
-        action: z7.enum(AGENT_GIT_ACTIONS).describe(
+        ref: z8.string().describe("Worktree thread id/ref"),
+        action: z8.enum(AGENT_GIT_ACTIONS).describe(
           "commit-push | create-draft | create-web | resolve-conflicts | ready-for-review | merge"
         )
       },
@@ -4810,7 +4916,7 @@ async function startMcpServer() {
         }
       }
     );
-    const agentEnum = z7.enum(["claude", "codex", "opencode", "brightsy", "cursor"]);
+    const agentEnum = z8.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.",
@@ -4831,11 +4937,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: z7.string().describe("Worktree thread id/ref to fork"),
-        through_index: z7.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
+        ref: z8.string().describe("Worktree thread id/ref to fork"),
+        through_index: z8.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: z7.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
-        title: z7.string().optional()
+        model: z8.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
+        title: z8.string().optional()
       },
       async ({ ref, through_index, agent, model, title }) => {
         try {
@@ -4869,11 +4975,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: z7.string().describe("Thread id/ref to fork (worktree agent or orchestration chat)"),
-        through_index: z7.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
+        ref: z8.string().describe("Thread id/ref to fork (worktree agent or orchestration chat)"),
+        through_index: z8.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: z7.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
-        title: z7.string().optional()
+        model: z8.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
+        title: z8.string().optional()
       },
       async ({ ref, through_index, agent, model, title }) => {
         try {
@@ -4911,7 +5017,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: z7.string() },
+      { ref: z8.string() },
       async ({ ref }) => {
         const result = await orch.runSetup(ref);
         return mcpJson(result);
@@ -4920,7 +5026,7 @@ async function startMcpServer() {
     server.tool(
       "add_project",
       "Register a git repo as a Sideboard workspace",
-      { repoPath: z7.string() },
+      { repoPath: z8.string() },
       async ({ repoPath }) => {
         const ws = await orch.addWorkspace(repoPath);
         return mcpJson(ws);
@@ -4929,7 +5035,7 @@ async function startMcpServer() {
     server.tool(
       "remove_project",
       "Unregister a Sideboard workspace and archive its chats",
-      { repoPath: z7.string() },
+      { repoPath: z8.string() },
       async ({ repoPath }) => {
         await orch.removeWorkspace(repoPath);
         return { content: [{ type: "text", text: "ok" }] };
@@ -4939,12 +5045,12 @@ async function startMcpServer() {
       "fanout",
       "Best-of-n: create one thread per agent with the same prompt (parallel attempts)",
       {
-        prompt: z7.string(),
-        agents: z7.array(z7.enum(["claude", "codex", "opencode", "brightsy", "cursor"])),
-        repoPath: z7.string(),
-        sourceType: z7.enum(["branch", "pr", "ticket"]).optional(),
-        sourceRef: z7.string().optional(),
-        title: z7.string().optional()
+        prompt: z8.string(),
+        agents: z8.array(z8.enum(["claude", "codex", "opencode", "brightsy", "cursor"])),
+        repoPath: z8.string(),
+        sourceType: z8.enum(["branch", "pr", "ticket"]).optional(),
+        sourceRef: z8.string().optional(),
+        title: z8.string().optional()
       },
       async (args) => {
         const threads = await orch.bestOfN(args);
@@ -4962,8 +5068,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: z7.string(),
-        unmergedOnly: z7.boolean().optional()
+        repoPath: z8.string(),
+        unmergedOnly: z8.boolean().optional()
       },
       async ({ repoPath, unmergedOnly }) => {
         const root = await resolveRepoRoot(repoPath);
@@ -4984,19 +5090,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: z7.string(),
-        query: z7.string().optional().describe("GitHub search tokens (title, draft:true, \u2026)"),
-        queue: z7.enum(["review", "mine", "approved", "changes"]).optional().describe(
+        repoPath: z8.string(),
+        query: z8.string().optional().describe("GitHub search tokens (title, draft:true, \u2026)"),
+        queue: z8.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: z7.enum(["open", "closed", "merged", "all", "review"]).optional().describe("GitHub PR state (default open). review is an alias for queue=review."),
-        label: z7.string().optional().describe(
+        state: z8.enum(["open", "closed", "merged", "all", "review"]).optional().describe("GitHub PR state (default open). review is an alias for queue=review."),
+        label: z8.string().optional().describe(
           "GitHub label / workflow tag. Comma-separated AND. Examples: eng-review, eng-approved, eng-requested-changes"
         ),
-        reviewer: z7.string().optional().describe(
+        reviewer: z8.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: z7.number().int().positive().max(250).optional().describe("Page size (default 40, max 250). Raise when truncated is true.")
+        limit: z8.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);
@@ -5029,7 +5135,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: z7.string() },
+      { ref: z8.string() },
       async ({ ref }) => {
         const stack = await orch.getPrStack(ref);
         return mcpJson(stack);
@@ -5039,8 +5145,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: z7.string(),
-        layer: z7.number().int().positive().optional()
+        ref: z8.string(),
+        layer: z8.number().int().positive().optional()
       },
       async ({ ref, layer }) => {
         const result = await orch.openPrStackLayers(ref, { layer });
@@ -5063,9 +5169,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: z7.string(),
-        branchName: z7.string(),
-        title: z7.string().optional()
+        ref: z8.string(),
+        branchName: z8.string(),
+        title: z8.string().optional()
       },
       async ({ ref, branchName, title }) => {
         const result = await orch.addStackLayer(ref, branchName, { title });
@@ -5083,11 +5189,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: z7.string(),
-        branches: z7.array(z7.string()).min(1),
-        agent: z7.enum(["claude", "codex", "opencode", "brightsy", "cursor"]),
-        base: z7.string().optional(),
-        title: z7.string().optional()
+        repoPath: z8.string(),
+        branches: z8.array(z8.string()).min(1),
+        agent: z8.enum(["claude", "codex", "opencode", "brightsy", "cursor"]),
+        base: z8.string().optional(),
+        title: z8.string().optional()
       },
       async (args) => {
         const result = await orch.createPrStack({
@@ -5115,10 +5221,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: z7.string(),
-        query: z7.string().optional().describe("Search title, identifier, or description"),
-        assignee: z7.string().optional().describe("me (Linear default), unassigned, all, a user id, or a GitHub login"),
-        limit: z7.number().int().positive().max(250).optional().describe("Page size (default 40, max 250). Raise when truncated is true."),
+        repoPath: z8.string(),
+        query: z8.string().optional().describe("Search title, identifier, or description"),
+        assignee: z8.string().optional().describe("me (Linear default), unassigned, all, a user id, or a GitHub login"),
+        limit: z8.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 }) => {