@sideboard-ai/core 0.1.262 → 0.1.264

package/dist/index.js

@@ -1,66 +1,3 @@
-import {
-  ABLETIME_OAUTH_CALLBACK_PATH,
-  ABLETIME_OAUTH_CANCELLED,
-  ABLETIME_OAUTH_LOCAL_CALLBACK,
-  ABLETIME_OAUTH_PORT,
-  ABLETIME_OAUTH_REDIRECT,
-  ABLETIME_OAUTH_RESOURCE,
-  AbleTimeOAuthCancelledError,
-  BAKED_ABLETIME_OAUTH_CLIENT_ID,
-  ableTimeOAuthAuthorizeUrl,
-  ableTimeOAuthBouncePage,
-  ableTimeOAuthClientId,
-  ableTimeOAuthLocalBounceUrl,
-  ableTimeOAuthRedirectUri,
-  ableTimeOAuthResource,
-  createAbleTimePkce,
-  ensureAbleTimeAccessToken,
-  hasBakedAbleTimeOAuth,
-  isAbleTimeOAuthCancelled,
-  parseAbleTimeOAuthCallbackUrl,
-  resolveAbleTimeOAuthHost,
-  startAbleTimeOAuth
-} from "./chunk-YFTO7U2A.js";
-import {
-  ableTimeDependencyTarget,
-  commentAbleTimeTask,
-  createAbleTimeTask,
-  ensureAbleTimeTask,
-  getAbleTimeOrientation,
-  getAbleTimeTask,
-  issueAttachmentForAbleTimeTask,
-  listAbleTimeAssignedIssues,
-  listAbleTimeProjects,
-  listAbleTimeTasks,
-  mapAbleTimeTask,
-  searchAbleTimeTasks,
-  taskUrl,
-  toAbleTimeIssueInfo,
-  updateAbleTimeTask,
-  verifyAbleTimeConnection
-} from "./chunk-KVQX62XI.js";
-import "./chunk-D554YCHG.js";
-import {
-  ABLETIME_MCP_PATH,
-  ABLETIME_MCP_PM_PATH,
-  ABLETIME_OAUTH_TOKEN_PREFIX,
-  ABLETIME_ORG_KEY_PREFIX,
-  ABLETIME_PAT_PREFIX,
-  ABLETIME_PM_TOOL_NAMES,
-  DEFAULT_ABLETIME_HOST,
-  ableTimeCredentialKind,
-  ableTimeUsesRest,
-  abletimeMcpRequest,
-  abletimeMcpUrl,
-  abletimeToolUsesPm,
-  assertAbleTimeCredential,
-  assertAbleTimeMcpCredential,
-  callAbleTimeTool,
-  isAbleTimeRejectedCredential,
-  normalizeAbleTimeCredential,
-  normalizeAbleTimeHost,
-  rewriteAbleTimeError
-} from "./chunk-J6ONZP74.js";
 import {
   AGENT_GIT_ACTIONS,
   BOARD_COLUMN_DEFS,
@@ -335,15 +272,19 @@ import {
   verifyOptionalService,
   waitForDetachedJob,
   waitForPidExit,
+  waitForTurnToolResult,
   worktreeBoardStatus,
   worktreeCleanupSettings,
   worktreeRunPortsPath,
   wrapReviewSkillMarkdown,
   writeWorktreeFile
-} from "./chunk-GIZQAOHZ.js";
+} from "./chunk-QX6QUZVD.js";
 import {
+  BASE_ALLOWED_TOOLS,
   BRIGHTSY_MCP_ALLOWED_TOOLS,
+  CLAUDE_CHROME_ALLOWED_TOOLS,
   CLAUDE_MODEL_CATALOG,
+  CLAUDE_PRINT_BG_WAIT_CEILING_MS,
   MAX_ANTHROPIC_CACHE_CONTROL_BLOCKS,
   PLAN_MODE_INSTRUCTION,
   PLAN_MODE_OFF_INSTRUCTION,
@@ -445,6 +386,7 @@ import {
   resolveQuotaFallbackAgent,
   sanitizeMcpServerName,
   shouldInjectBrightsyMcp,
+  shouldRegisterMcpWaitForTurn,
   sideboardMcpProfile,
   skillCommandFromBody,
   skillCommandFromInput,
@@ -464,9 +406,83 @@ import {
   whichOnPath,
   withEventParentId,
   withEventsParentId,
+  worktreeMcpToolNames,
   writeInjectedMcpConfig
-} from "./chunk-ABPNIYRS.js";
+} from "./chunk-3H7O27X2.js";
+import {
+  brightsyMcpServerName,
+  connectBrightsyTeam,
+  disconnectBrightsyTeam,
+  ensureConnectedBrightsyTeamTokens,
+  getBrightsySession,
+  listBrightsyAccounts,
+  listConnectedBrightsyTeams,
+  switchBrightsyAccount
+} from "./chunk-GWFVCCJZ.js";
 import "./chunk-7H655NEW.js";
+import {
+  ABLETIME_OAUTH_CALLBACK_PATH,
+  ABLETIME_OAUTH_CANCELLED,
+  ABLETIME_OAUTH_LOCAL_CALLBACK,
+  ABLETIME_OAUTH_PORT,
+  ABLETIME_OAUTH_REDIRECT,
+  ABLETIME_OAUTH_RESOURCE,
+  AbleTimeOAuthCancelledError,
+  BAKED_ABLETIME_OAUTH_CLIENT_ID,
+  ableTimeOAuthAuthorizeUrl,
+  ableTimeOAuthBouncePage,
+  ableTimeOAuthClientId,
+  ableTimeOAuthLocalBounceUrl,
+  ableTimeOAuthRedirectUri,
+  ableTimeOAuthResource,
+  createAbleTimePkce,
+  ensureAbleTimeAccessToken,
+  hasBakedAbleTimeOAuth,
+  isAbleTimeOAuthCancelled,
+  parseAbleTimeOAuthCallbackUrl,
+  resolveAbleTimeOAuthHost,
+  startAbleTimeOAuth
+} from "./chunk-6YOXQVJ7.js";
+import {
+  ableTimeDependencyTarget,
+  commentAbleTimeTask,
+  createAbleTimeTask,
+  ensureAbleTimeTask,
+  getAbleTimeOrientation,
+  getAbleTimeTask,
+  issueAttachmentForAbleTimeTask,
+  listAbleTimeAssignedIssues,
+  listAbleTimeProjects,
+  listAbleTimeTasks,
+  mapAbleTimeTask,
+  searchAbleTimeTasks,
+  taskUrl,
+  toAbleTimeIssueInfo,
+  updateAbleTimeTask,
+  verifyAbleTimeConnection
+} from "./chunk-K7B25HO4.js";
+import "./chunk-YKYEHDMX.js";
+import {
+  ABLETIME_MCP_PATH,
+  ABLETIME_MCP_PM_PATH,
+  ABLETIME_OAUTH_TOKEN_PREFIX,
+  ABLETIME_ORG_KEY_PREFIX,
+  ABLETIME_PAT_PREFIX,
+  ABLETIME_PM_TOOL_NAMES,
+  DEFAULT_ABLETIME_HOST,
+  ableTimeCredentialKind,
+  ableTimeUsesRest,
+  abletimeMcpRequest,
+  abletimeMcpUrl,
+  abletimeToolUsesPm,
+  assertAbleTimeCredential,
+  assertAbleTimeMcpCredential,
+  callAbleTimeTool,
+  isAbleTimeRejectedCredential,
+  normalizeAbleTimeCredential,
+  normalizeAbleTimeHost,
+  rewriteAbleTimeError
+} from "./chunk-6YY7XPPL.js";
 import {
   LEGACY_PLAN_FILE_REL,
   PLAN_FILE_NAME,
@@ -527,7 +543,7 @@ import {
   stageBuffersAsAttachments,
   syncWorkspacesFromThreads,
   takenTeamSlugsForOrchestration
-} from "./chunk-X2OTZ36G.js";
+} from "./chunk-RKPBIB2U.js";
 import {
   FAMOUS_SOCCER_TEAMS,
   GITHUB_PR_BODY_MAX_CHARS,
@@ -627,18 +643,26 @@ import {
   worktreeDisplayLabelForGroup,
   worktreeNameFromPath,
   worktreeSlugForTicket
-} from "./chunk-U3AOJLH3.js";
-import "./chunk-2P4XKWV2.js";
+} from "./chunk-5ZPT5YAV.js";
 import {
-  brightsyMcpServerName,
-  connectBrightsyTeam,
-  disconnectBrightsyTeam,
-  ensureConnectedBrightsyTeamTokens,
-  getBrightsySession,
-  listBrightsyAccounts,
-  listConnectedBrightsyTeams,
-  switchBrightsyAccount
-} from "./chunk-LDXSAVWO.js";
+  appendMessage,
+  createEmptyThread,
+  deleteThreadRecord,
+  findThreadByRef,
+  invalidateThreadListCache,
+  invalidateThreadRecord,
+  isSelfWrittenRecord,
+  isThreadRecordFile,
+  listThreads,
+  normalizeThread,
+  readThread,
+  resolveThreadEffort,
+  setStatus,
+  updateThread,
+  withThreadLock,
+  writeThread
+} from "./chunk-FWNL62VA.js";
+import "./chunk-2P4XKWV2.js";
 import {
   BRIGHTSY_OAUTH_CLIENT_ID,
   BRIGHTSY_OAUTH_REDIRECT,
@@ -659,7 +683,7 @@ import {
 } from "./chunk-N7WZ6NIN.js";
 import {
   clipMcpToolResult
-} from "./chunk-HHEKVR6C.js";
+} from "./chunk-F5MFNUAA.js";
 import "./chunk-AXQ4ZWHK.js";
 import {
   AGENT_RUNNER_MAX_OLD_SPACE_MB,
@@ -675,7 +699,7 @@ import {
   trustSystemCertificates,
   turnCostUsdFromCursorUsage,
   withMaxOldSpaceSize
-} from "./chunk-WV7KJH2E.js";
+} from "./chunk-A5SAYFJ4.js";
 import {
   ATTACHMENTS_DIR,
   CLI_DIR,
@@ -685,6 +709,7 @@ import {
   attachmentsGitignoreBody,
   isWorkspaceScratchPath
 } from "./chunk-6K64FJDD.js";
+import "./chunk-UWQ6UCIB.js";
 import {
   conductorBundledBinDir,
   enrichPathWithNpmGlobalBin,
@@ -701,6 +726,28 @@ import {
   run,
   withExportedPath
 } from "./chunk-QVN2WOKJ.js";
+import {
+  AGENT_RPC_JOB_HOLD_MAX_MS,
+  AGENT_RPC_JOB_SLICE_MS,
+  AGENT_RPC_NATIVE_ENV,
+  AGENT_RPC_PATH,
+  AGENT_RPC_PROTOCOL_VERSION,
+  AGENT_RPC_TOKEN_QUERY,
+  RPC_INTERNAL_ERROR,
+  RPC_INVALID_REQUEST,
+  RPC_METHOD_NOT_FOUND,
+  RPC_PARSE_ERROR,
+  RPC_UNAUTHORIZED,
+  agentRpcConnectFromMetadata,
+  clearAgentRuntimeMetadataIfOwned,
+  isJsonRpcRequest,
+  parseRpcFrame,
+  readAgentRuntimeMetadata,
+  rpcError,
+  rpcNotify,
+  rpcResult,
+  writeAgentRuntimeMetadata
+} from "./chunk-NYBFYFK7.js";
 import {
   AGENT_DONE_SOUNDS,
   CHAT_TEXT_SCALES,
@@ -794,6 +841,7 @@ import {
   persistVaultKeyInKeychain,
   planHistoryAgePurge,
   planHistoryRetention,
+  previousCostBaseline,
   readKeychainVaultKey,
   readSecureJson,
   readViewerContext,
@@ -826,6 +874,7 @@ import {
   sumUsageList,
   toPublicAppSettings,
   totalTokens,
+  turnCostUsdFromProviderSnapshot,
   updateAdvancedSettings,
   updateAgentExecutable,
   updateAppEnvironment,
@@ -837,9 +886,18 @@ import {
   updateOpencodeSettings,
   updateProjectProfileSettings,
   usageOnLimit,
+  withTurnScopedCost,
   writeSecureJson,
   writeViewerContext
-} from "./chunk-6PFZ6XO7.js";
+} from "./chunk-2QUQH2SZ.js";
+import {
+  THINKING_EFFORTS,
+  isThinkingEffort,
+  nextThinkingEffort,
+  normalizeThinkingEffort,
+  thinkingEffortBars,
+  thinkingEffortLabel
+} from "./chunk-77WWLBCI.js";
 import {
   stripNestedElectronEnv
 } from "./chunk-4TR3HZFT.js";
@@ -877,33 +935,6 @@ import {
 import {
   writePrivateFile
 } from "./chunk-JT7R45JB.js";
-import {
-  appendMessage,
-  createEmptyThread,
-  deleteThreadRecord,
-  findThreadByRef,
-  invalidateThreadListCache,
-  invalidateThreadRecord,
-  isSelfWrittenRecord,
-  isThreadRecordFile,
-  listThreads,
-  normalizeThread,
-  readThread,
-  resolveThreadEffort,
-  setStatus,
-  updateThread,
-  withThreadLock,
-  writeThread
-} from "./chunk-FWNL62VA.js";
-import "./chunk-UWQ6UCIB.js";
-import {
-  THINKING_EFFORTS,
-  isThinkingEffort,
-  nextThinkingEffort,
-  normalizeThinkingEffort,
-  thinkingEffortBars,
-  thinkingEffortLabel
-} from "./chunk-77WWLBCI.js";
 import {
   CONVENTION_SETUP_RELPATHS,
   activeRunPreview,
@@ -3235,6 +3266,31 @@ function buildPastedTextAttachment(text7, opts) {
   };
 }
 
+// src/threads/chat-link.ts
+var CHAT_LINK_PREFIX = "sideboard://chat/";
+var LEGACY_THREAD_LINK_PREFIX = "sideboard://thread/";
+var ID = "[A-Za-z0-9_-]+";
+var CHAT_LINK_RE = new RegExp(`^sideboard://(?:chat|thread)/(${ID})/?$`, "i");
+var BARE_CHAT_LINK_RE = new RegExp(
+  `(?<!\\]\\()(?<!href=["'])sideboard://(?:chat|thread)/${ID}/?`,
+  "gi"
+);
+function chatLinkUrl(chatId) {
+  return `${CHAT_LINK_PREFIX}${chatId.trim()}`;
+}
+function parseChatLink(href) {
+  const match = CHAT_LINK_RE.exec(href.trim());
+  return match?.[1] ?? null;
+}
+function linkifyChatUrls(text7) {
+  return text7.replace(BARE_CHAT_LINK_RE, (url) => {
+    const id = parseChatLink(url);
+    if (!id) return url;
+    const label = id.length > 8 ? id.slice(0, 8) : id;
+    return `[${label}](${chatLinkUrl(id)})`;
+  });
+}
+
 // src/orchestrator/outbound-turn-reply.ts
 function outboundReplyFromTurn(result, copy) {
   switch (result.taskState) {
@@ -3271,10 +3327,10 @@ function formatAskUserNotifyMessage(questions) {
 }
 function formatNotifyOrchestratorPrompt(input) {
   const title = input.child.title?.trim() || "Untitled";
-  const link = `[${title}](sideboard://thread/${input.child.id})`;
+  const link = `[${title}](sideboard://chat/${input.child.id})`;
   const body = clampMessage(input.message) || "(no details)";
   const state = input.reason === "input-required" ? "is input-required (waiting for the user in that chat)" : "is blocked";
-  const next = input.reason === "input-required" ? "Wait for the user in that chat. Do not send_to_thread a check-in." : "Help if this is your child; otherwise briefly tell the user. Do not send_to_thread a check-in.";
+  const next = input.reason === "input-required" ? "Wait for the user in that chat. Do not send_to_chat a check-in." : "Help if this is your child; otherwise briefly tell the user. Do not send_to_chat a check-in.";
   return [
     `Sideboard: child worktree ${link} ${state}.`,
     body,
@@ -3299,13 +3355,13 @@ function resolveNotifyCallerThread(opts) {
     return thread;
   }
   const siblings = threadsSharingWorktree(cwd);
-  const running = siblings.find((t) => t.status === "running") ?? siblings[0];
-  if (!running) {
+  const running2 = siblings.find((t) => t.status === "running") ?? siblings[0];
+  if (!running2) {
     throw new Error(
       "No Sideboard thread for this cwd. Call notify_orchestrator from a worktree chat."
     );
   }
-  return running;
+  return running2;
 }
 function skipReason(opts) {
   if (!opts.child.parentThreadId) {
@@ -3508,7 +3564,7 @@ function createClippedMcpServer() {
 
 // src/mcp/server.ts
 import { z as z9 } from "zod";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { basename as basename2 } from "path";
 
 // src/mcp/archive-guard.ts
@@ -4039,7 +4095,7 @@ async function continueSourceThread(threadId, prompt) {
       await continueOnReply(threadId, prompt);
       return;
     }
-    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-OCG4QVA5.js");
+    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-5YU46YNS.js");
     await getOrchestrator2().send(threadId, prompt);
   } catch {
   }
@@ -5128,7 +5184,7 @@ function registerAbleTimeTools(server) {
   );
   server.tool(
     "abletime_ensure_task",
-    "Find or create an AbleTime task for this work, then create_thread with sourceType=ticket.",
+    "Find or create an AbleTime task for this work, then create_workspace with sourceType=ticket.",
     {
       title: z4.string(),
       description: z4.string().optional(),
@@ -5452,11 +5508,11 @@ async function resolveProjectRepoPath(repoPath) {
   }
   return matchRegisteredWorkspace(root) ?? matchRegisteredWorkspace(hint);
 }
-var PROJECT_PATH_HINT = "Pass repoPath from list_workspaces. Orchestration cwd is synthetic and empty \u2014 do not omit repoPath for project context.";
+var PROJECT_PATH_HINT = "Pass repoPath from list_projects. Orchestration cwd is synthetic and empty \u2014 do not omit repoPath for project context.";
 function registerViewerContextTools(server) {
   server.tool(
     "get_viewer_context",
-    "Read account and project user context (Settings \u2192 Agents / Projects): roles, tickets, and review queues as freeform text. Orchestration must pass repoPath from list_workspaces for project context. Worktree turns may omit repoPath (uses cwd).",
+    "Read account and project user context (Settings \u2192 Agents / Projects): roles, tickets, and review queues as freeform text. Orchestration must pass repoPath from list_projects for project context. Worktree turns may omit repoPath (uses cwd).",
     {
       repoPath: z7.string().optional().describe(
         "Registered workspace or worktree path. Required from orchestration for a project. Omit on a worktree turn (uses cwd)."
@@ -5482,7 +5538,7 @@ function registerViewerContextTools(server) {
       context: z7.string().describe("Full replacement text (roles, tickets, review queues). Empty clears."),
       confirmed: z7.boolean().optional().describe("Must be true after the user confirmed via ask_user. False/omit is rejected."),
       repoPath: z7.string().optional().describe(
-        "Required for scope=project from orchestration (path from list_workspaces). Worktree turns may omit it (cwd)."
+        "Required for scope=project from orchestration (path from list_projects). Worktree turns may omit it (cwd)."
       )
     },
     async ({ scope, context, confirmed, repoPath }) => {
@@ -5596,7 +5652,7 @@ function registerScheduleTools(server) {
   );
   server.tool(
     "create_schedule",
-    "Create a local schedule that, when due, sends a prompt to an existing chat (threadId) or starts a new Global orchestration chat (omit threadId). Pass threadId=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 threadId 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.",
+    "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: z8.string().describe("User message / goal queued when the schedule fires"),
       name: z8.string().optional(),
@@ -5604,20 +5660,22 @@ function registerScheduleTools(server) {
       every: z8.string().optional().describe("Interval such as 15m, 1h, 6h, 1d"),
       cron: z8.string().optional().describe("5-field cron expression"),
       tz: z8.string().optional().describe("IANA timezone for cron (default: system)"),
-      threadId: z8.string().optional().describe(
-        'Existing chat id (orchestration or worktree), or "self" for this chat. Omit to create a new Global chat on fire.'
+      chatId: z8.string().optional().describe(
+        'Existing chat id (orchestration or workspace), or "self" for this chat. Omit to create a new Global chat on fire.'
       ),
+      threadId: z8.string().optional().describe("Legacy alias for chatId."),
       agent: z8.enum(["claude", "cursor", "codex", "opencode"]).optional().describe("Agent for a new Global chat (omit for Account default)"),
       model: z8.string().optional()
     },
     async (args) => {
       try {
         const when = parseWhen(args);
-        const threadId = resolveScheduleThreadId(args.threadId);
-        if (args.threadId?.trim().toLowerCase() === "self" && !threadId) {
+        const rawChatId = args.chatId ?? args.threadId;
+        const threadId = resolveScheduleThreadId(rawChatId);
+        if (rawChatId?.trim().toLowerCase() === "self" && !threadId) {
           return fail5(
             new Error(
-              "threadId=self needs this chat id (SIDEBOARD_THREAD_ID or SIDEBOARD_ORCHESTRATOR_THREAD_ID)"
+              "chatId=self needs this chat id (SIDEBOARD_THREAD_ID or SIDEBOARD_ORCHESTRATOR_THREAD_ID)"
             )
           );
         }
@@ -5632,7 +5690,7 @@ function registerScheduleTools(server) {
         });
         return text6({
           schedule,
-          hint: scheduleNeedsCaffeinate(schedule) ? "Fires while Sideboard.app is running. Recurring jobs without threadId create a new orchestration chat each run. Caffeinate while schedules are enabled is now on so the Mac can stay awake until this job is due." : "Fires while Sideboard.app is running. Recurring jobs without threadId create a new orchestration chat each run."
+          hint: scheduleNeedsCaffeinate(schedule) ? "Fires while Sideboard.app is running. Recurring jobs without chatId create a new orchestration chat each run. Caffeinate while schedules are enabled is now on so the Mac can stay awake until this job is due." : "Fires while Sideboard.app is running. Recurring jobs without chatId create a new orchestration chat each run."
         });
       } catch (err) {
         return fail5(err);
@@ -5641,7 +5699,7 @@ function registerScheduleTools(server) {
   );
   server.tool(
     "update_schedule",
-    "Update a local schedule (prompt, cadence, target thread, enabled). Pass id from list_schedules.",
+    "Update a local schedule (prompt, cadence, target chat, enabled). Pass id from list_schedules.",
     {
       id: z8.string(),
       prompt: z8.string().optional(),
@@ -5650,9 +5708,10 @@ function registerScheduleTools(server) {
       every: z8.string().optional(),
       cron: z8.string().optional(),
       tz: z8.string().optional(),
-      threadId: z8.string().optional().describe(
-        'Existing chat (orchestration or worktree), "self", or empty string to create a new Global chat each run'
+      chatId: z8.string().optional().describe(
+        'Existing chat (orchestration or workspace), "self", or empty string to create a new Global chat each run'
       ),
+      threadId: z8.string().optional().describe("Legacy alias for chatId."),
       agent: z8.enum(["claude", "cursor", "codex", "opencode"]).optional(),
       model: z8.string().optional(),
       enabled: z8.boolean().optional()
@@ -5667,12 +5726,13 @@ function registerScheduleTools(server) {
           tz: args.tz
         }) : void 0;
         let threadId;
-        if (args.threadId !== void 0) {
-          threadId = resolveScheduleThreadId(args.threadId);
-          if (args.threadId.trim().toLowerCase() === "self" && !threadId) {
+        const rawChatId = args.chatId ?? args.threadId;
+        if (rawChatId !== void 0) {
+          threadId = resolveScheduleThreadId(rawChatId);
+          if (rawChatId.trim().toLowerCase() === "self" && !threadId) {
             return fail5(
               new Error(
-                "threadId=self needs this chat id (SIDEBOARD_THREAD_ID or SIDEBOARD_ORCHESTRATOR_THREAD_ID)"
+                "chatId=self needs this chat id (SIDEBOARD_THREAD_ID or SIDEBOARD_ORCHESTRATOR_THREAD_ID)"
               )
             );
           }
@@ -5723,12 +5783,163 @@ function registerScheduleTools(server) {
   );
 }
 
+// src/agent-rpc/handlers.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { isAbsolute } from "path";
+function presentArtifactResult(input) {
+  const id = input.artifact_id?.trim() || `artifact_${Date.now().toString(36)}_${randomUUID2().slice(0, 8)}`;
+  return {
+    ok: true,
+    artifact_id: id,
+    title: input.title,
+    type: input.type,
+    status: input.status,
+    phase: input.phase,
+    mode: input.type === "log" ? input.mode ?? "append" : void 0,
+    message: input.type === "log" ? "Log accepted. Same artifact_id appends; send only new lines next time." : "Artifact accepted. Sideboard desktop opens it in the side column beside chat."
+  };
+}
+function asRecord2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return value;
+}
+function str(value) {
+  return typeof value === "string" ? value : "";
+}
+function invalidParams(message) {
+  return Object.assign(new Error(message), { rpcCode: -32602 });
+}
+function jobCwd(rec) {
+  const raw = str(rec.cwd).trim();
+  if (!raw) throw invalidParams("cwd is required");
+  if (!isAbsolute(raw)) throw invalidParams("cwd must be an absolute path");
+  return raw;
+}
+async function handleRuntimePing(_params, _ctx) {
+  return {
+    ok: true,
+    protocolVersion: AGENT_RPC_PROTOCOL_VERSION,
+    pid: process.pid
+  };
+}
+async function handlePresentArtifact(params, _ctx) {
+  const rec = asRecord2(params);
+  const title = str(rec.title).trim();
+  const type = str(rec.type).trim();
+  const allowed = ["html", "svg", "markdown", "react", "log"];
+  if (!title) throw invalidParams("title is required");
+  if (!allowed.includes(type)) {
+    throw invalidParams("type must be html, svg, markdown, react, or log");
+  }
+  const statusRaw = str(rec.status).trim();
+  const status = ["running", "ok", "failed", "idle"].includes(
+    statusRaw
+  ) ? statusRaw : void 0;
+  const modeRaw = str(rec.mode).trim();
+  const mode = modeRaw === "append" || modeRaw === "replace" ? modeRaw : void 0;
+  return presentArtifactResult({
+    title,
+    type,
+    artifact_id: str(rec.artifact_id) || void 0,
+    status,
+    phase: str(rec.phase) || void 0,
+    mode
+  });
+}
+async function handleJobWait(params, ctx, waitFn = waitForDetachedJob) {
+  const rec = asRecord2(params);
+  const id = str(rec.id).trim();
+  if (!id) throw invalidParams("id is required");
+  const cwd = jobCwd(rec);
+  const deadline = Date.now() + AGENT_RPC_JOB_HOLD_MAX_MS;
+  let last;
+  while (Date.now() < deadline) {
+    const slice = Math.min(AGENT_RPC_JOB_SLICE_MS, Math.max(50, deadline - Date.now()));
+    last = await waitFn(cwd, id, { timeoutMs: slice });
+    if (!last.stillRunning) return last;
+    ctx.notify("runtime.progress", last);
+  }
+  return last ?? {
+    stillRunning: true,
+    ok: false,
+    failed: false,
+    status: "running",
+    id,
+    delta: "",
+    progress: "Job still running after max hold. Call wait_for_job again.",
+    hint: "The RPC hold cap was reached. Call wait_for_job again \u2014 do not assume success."
+  };
+}
+async function handleJobStop(params, _ctx) {
+  const rec = asRecord2(params);
+  const id = str(rec.id).trim();
+  if (!id) throw invalidParams("id is required");
+  const reason = str(rec.reason).trim() || void 0;
+  return stopDetachedJob(jobCwd(rec), id, reason ? { reason } : void 0);
+}
+async function defaultTurnWait(ref, timeoutMs) {
+  const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-5YU46YNS.js");
+  const orch = getOrchestrator2();
+  const thread = await orch.waitForTurn(ref, timeoutMs, {
+    resolveIfStillRunning: true
+  });
+  const result = orch.getTurnResult(thread.id);
+  return waitForTurnToolResult({
+    id: thread.id,
+    status: result.status,
+    taskState: result.taskState,
+    text: result.text,
+    lastError: result.lastError,
+    stillRunning: result.stillRunning,
+    progress: result.progress,
+    lastActivityAt: result.lastActivityAt,
+    usage: result.usage
+  });
+}
+async function handleTurnWait(params, ctx, waitFn = defaultTurnWait) {
+  const rec = asRecord2(params);
+  const ref = str(rec.ref).trim();
+  if (!ref) throw invalidParams("ref is required");
+  const requested = typeof rec.timeoutMs === "number" && Number.isFinite(rec.timeoutMs) ? rec.timeoutMs : void 0;
+  const holdMax = requested !== void 0 ? Math.min(Math.max(1e3, Math.floor(requested)), AGENT_RPC_JOB_HOLD_MAX_MS) : AGENT_RPC_JOB_HOLD_MAX_MS;
+  const deadline = Date.now() + holdMax;
+  let last;
+  while (Date.now() < deadline) {
+    const slice = Math.min(AGENT_RPC_JOB_SLICE_MS, Math.max(50, deadline - Date.now()));
+    last = await waitFn(ref, slice);
+    if (!last.stillRunning) return last;
+    ctx.notify("runtime.progress", last);
+  }
+  return last ?? {
+    id: ref,
+    status: "running",
+    taskState: "working",
+    text: "",
+    lastError: null,
+    stillRunning: true,
+    progress: null,
+    lastActivityAt: null,
+    usage: null,
+    hint: "Child is still working after max hold. Call wait_for_turn again. Do not send_to_chat a check-in (that steers / interrupts).",
+    incomplete: false
+  };
+}
+function createAgentRpcDispatcher() {
+  return {
+    "runtime.ping": handleRuntimePing,
+    "ui.presentArtifact": handlePresentArtifact,
+    "job.wait": handleJobWait,
+    "job.stop": handleJobStop,
+    "turn.wait": handleTurnWait
+  };
+}
+
 // src/board/load-home-board.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "fs";
 import { join as join6 } from "path";
 
 // src/board/board-pins.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, unlinkSync as unlinkSync2, writeFileSync } from "fs";
 import { join as join5 } from "path";
 var FILE = "home-board-pins.json";
@@ -5758,7 +5969,7 @@ function addBoardPin(input) {
   const ref = input.ref.trim();
   if (!ref) throw new Error("Board item needs a ref");
   const pin = {
-    id: randomUUID2(),
+    id: randomUUID3(),
     kind: input.kind,
     ref,
     repoPath: input.repoPath.trim(),
@@ -6067,7 +6278,7 @@ function withTimeout(promise, ms, label) {
 }
 async function createOrchChildThread(orch, args, resolveNewThreadOptions2) {
   const envParentId = process.env.SIDEBOARD_ORCHESTRATOR_THREAD_ID?.trim() || "";
-  let parentId = args.parentThreadId?.trim() || "";
+  let parentId = args.parentChatId?.trim() || args.parentThreadId?.trim() || "";
   let parent = parentId ? orch.getThread(parentId) : null;
   let parentCorrectedFrom;
   if (envParentId) {
@@ -6117,7 +6328,7 @@ async function createOrchChildThread(orch, args, resolveNewThreadOptions2) {
         attachments: args.attachments
       }),
       CREATE_THREAD_TIMEOUT_MS,
-      "create_thread"
+      "create_workspace"
     );
     const alreadyStarted = priorIds.has(thread.id);
     const parentNote = parentCorrectedFrom ? parentId ? `Ignored unknown/stale parentThreadId ${parentCorrectedFrom}; nested under ${parentId}` : `Ignored unknown/stale parentThreadId ${parentCorrectedFrom}; created without parent` : void 0;
@@ -6132,7 +6343,8 @@ async function createOrchChildThread(orch, args, resolveNewThreadOptions2) {
         model: thread.model,
         status: thread.status,
         cowboy: Boolean(thread.cowboy),
-        link: `sideboard://thread/${thread.id}`,
+        link: `sideboard://chat/${thread.id}`,
+        parentChatId: thread.parentThreadId,
         parentThreadId: thread.parentThreadId,
         ...alreadyStarted ? { alreadyStarted: true } : {},
         ...opts.coercedFrom ? { agentCoercedFrom: opts.coercedFrom } : {},
@@ -6143,7 +6355,7 @@ async function createOrchChildThread(orch, args, resolveNewThreadOptions2) {
     };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    return { ok: false, text: `create_thread failed: ${message}` };
+    return { ok: false, text: `create_workspace failed: ${message}` };
   }
 }
 function previewHint(preview) {
@@ -6160,7 +6372,7 @@ async function startMcpServer() {
     );
   }
   try {
-    const { maxConcurrentAgents: maxConcurrentAgents2 } = await import("./app-settings-VQEUCONM.js");
+    const { maxConcurrentAgents: maxConcurrentAgents2 } = await import("./app-settings-RKFFUIFQ.js");
     orch.setMaxConcurrent(maxConcurrentAgents2());
   } catch {
   }
@@ -6193,8 +6405,8 @@ async function startMcpServer() {
   }
   if (!worktreeProfile) {
     server.tool(
-      "list_workspaces",
-      "List registered Sideboard workspaces (repos). Each line is name, path, github:owner/repo when resolvable, and project context when set \u2014 use path as repoPath for list_board/list_branches/list_prs/list_issues/create_thread. Account / project context (Settings \u2192 Agents / Projects) says which tickets and review PRs belong to the user.",
+      "list_projects",
+      "List registered projects (git repos). Each line is name, path, github:owner/repo when resolvable, and project context when set \u2014 use path as repoPath for list_board/list_branches/list_prs/list_issues/create_workspace. Account / project context (Settings \u2192 Agents / Projects) says which tickets and review PRs belong to the user.",
       {},
       async () => {
         const workspaces = orch.listWorkspaces();
@@ -6213,14 +6425,14 @@ async function startMcpServer() {
         );
         return {
           content: [
-            { type: "text", text: lines.join("\n") || "(no workspaces)" }
+            { type: "text", text: lines.join("\n") || "(no projects)" }
           ]
         };
       }
     );
     server.tool(
-      "list_threads",
-      "List Sideboard threads across all workspaces (one summary line each \u2014 token-frugal). Includes parent id, last message preview, and live progress so you can see worktree children. Each line ends with sideboard://thread/<id> \u2014 use that URL in markdown links so the UI can open the chat.",
+      "list_chats",
+      "List chats across all projects (one summary line each \u2014 token-frugal). Includes parent id, last message preview, 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.",
       {},
       async () => {
         const threads = orch.getThreads(true);
@@ -6232,19 +6444,19 @@ async function startMcpServer() {
           const previewBit = preview ? `  ${preview}` : "";
           const err = t.lastError ? `  error:${t.lastError.replace(/\s+/g, " ").slice(0, 60)}` : "";
           const progress = live?.summary && !isInternalAgentStatusText(live.summary) ? `  ${live.summary}` : "";
-          return `${t.id.slice(0, 8)}  ${t.status.padEnd(9)}  ${t.agent.padEnd(8)}  ${repo}  ${t.sourceType}:${t.sourceRef}  ${t.title}${parent}${previewBit}${err}  sideboard://thread/${t.id}${t.devPort ? `  http://localhost:${t.devPort}` : ""}${progress}`;
+          return `${t.id.slice(0, 8)}  ${t.status.padEnd(9)}  ${t.agent.padEnd(8)}  ${repo}  ${t.sourceType}:${t.sourceRef}  ${t.title}${parent}${previewBit}${err}  sideboard://chat/${t.id}${t.devPort ? `  http://localhost:${t.devPort}` : ""}${progress}`;
         });
         return {
-          content: [{ type: "text", text: lines.join("\n") || "(no threads)" }]
+          content: [{ type: "text", text: lines.join("\n") || "(no chats)" }]
         };
       }
     );
     server.tool(
       "list_board",
-      "Home Kanban of worktrees (New, Draft, Review, Merged) \u2014 one card per checkout; sibling chat tabs nest as inner cards. Same cards as desktop Home. Path to merge: no PR \u2192 draft PR \u2192 open PR \u2192 merged. Archive removes the card to Settings \u2192 History. Queued/running are activity on the card, not columns. Orchestration chats are not on the board. Filters: query, repoPath, kind (ticket/PR/branch source), ownership (mine = your PRs / WIP; reviewing = someone else's PR), column, limit (default 40). create_thread adds a worktree (and a Home card), or returns the live one if that ticket/PR/named branch is already checked out.",
+      "Home Kanban of worktrees (New, Draft, Review, Merged) \u2014 one card per checkout; sibling chat tabs nest as inner cards. Same cards as desktop Home. Path to merge: no PR \u2192 draft PR \u2192 open PR \u2192 merged. Archive removes the card to Settings \u2192 History. Queued/running are activity on the card, not columns. Orchestration chats are not on the board. Filters: query, repoPath, kind (ticket/PR/branch source), 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 one if that ticket/PR/named branch is already checked out.",
       {
         query: z9.string().optional().describe("Case-insensitive token search across title, id, labels, repo"),
-        repoPath: z9.string().optional().describe("Limit to one workspace path from list_workspaces"),
+        repoPath: z9.string().optional().describe("Limit to one project path from list_projects"),
         kind: z9.enum(["all", "tickets", "prs", "branches", "threads"]).optional().describe("Filter by worktree source (default all)"),
         ownership: z9.enum(["all", "mine", "reviewing"]).optional().describe(
           "Mine = PRs you authored or local WIP; reviewing = someone else's PR. Uses the gh login."
@@ -6280,13 +6492,13 @@ async function startMcpServer() {
       }
     );
     server.tool(
-      "get_thread",
-      "Get a compact thread summary by id/ref. Includes last message preview, parentThreadId, and child worktree threads (status + lastText). While running, includes progress (last tool/thinking) and lastActivityAt. Includes usage (thread billed token + costUsd totals when providers reported cost) and lastTurnUsage.",
+      "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.",
       { ref: z9.string() },
       async ({ ref }) => {
         const t = orch.getThread(ref);
         if (!t) {
-          return { content: [{ type: "text", text: `Thread not found: ${ref}` }], isError: true };
+          return { content: [{ type: "text", text: `Chat not found: ${ref}` }], isError: true };
         }
         const stillRunning = orch.threadLooksLive(t);
         const live = stillRunning ? readTurnLive(t.id) : null;
@@ -6302,6 +6514,7 @@ async function startMcpServer() {
           branchName: t.branchName,
           worktreePath: t.worktreePath,
           sessionId: t.sessionId,
+          parentChatId: t.parentThreadId,
           parentThreadId: t.parentThreadId,
           children: childThreadRefs(t.id, orch.getThreads(false)),
           queueLength: t.queue.length,
@@ -6320,37 +6533,31 @@ async function startMcpServer() {
       }
     );
   }
-  server.tool(
-    "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: z9.string().describe("Short title shown in the artifact pane header"),
-      type: z9.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: z9.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: z9.string().optional().describe("Stable id. Required for type=log so later calls append to the same pane."),
-      status: z9.enum(["running", "ok", "failed", "idle"]).optional().describe("Log header pill: running (working), ok (done), failed, idle"),
-      phase: z9.string().optional().describe("Log subtitle (Signing, Notarizing, \u2026)"),
-      mode: z9.enum(["append", "replace"]).optional().describe("log only: append (default) or replace the buffer")
-    },
-    async ({ title, type, artifact_id, status, phase, mode }) => {
-      const id = artifact_id?.trim() || `artifact_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
-      const payload = {
-        ok: true,
-        artifact_id: id,
-        title,
-        type,
-        status,
-        phase,
-        mode: type === "log" ? mode ?? "append" : void 0,
-        message: type === "log" ? "Log accepted. Same artifact_id appends; send only new lines next time." : "Artifact accepted. Sideboard desktop opens it in the side column beside chat."
-      };
-      return mcpJson(payload);
-    }
-  );
+  const mcpCatalog = new Set(worktreeMcpToolNames());
+  if (mcpCatalog.has("present_artifact")) {
+    server.tool(
+      "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: z9.string().describe("Short title shown in the artifact pane header"),
+        type: z9.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: z9.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: z9.string().optional().describe("Stable id. Required for type=log so later calls append to the same pane."),
+        status: z9.enum(["running", "ok", "failed", "idle"]).optional().describe("Log header pill: running (working), ok (done), failed, idle"),
+        phase: z9.string().optional().describe("Log subtitle (Signing, Notarizing, \u2026)"),
+        mode: z9.enum(["append", "replace"]).optional().describe("log only: append (default) or replace the buffer")
+      },
+      async ({ title, type, artifact_id, status, phase, mode }) => {
+        return mcpJson(
+          presentArtifactResult({ title, type, artifact_id, status, phase, mode })
+        );
+      }
+    );
+  }
   server.tool(
     "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.",
@@ -6467,32 +6674,34 @@ async function startMcpServer() {
       return mcpJson(payload);
     }
   );
-  server.tool(
-    "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: z9.string().describe("Detached job id (same kebab-case id passed to detached-job.cjs start)"),
-      timeoutMs: z9.number().optional()
-    },
-    async ({ id, timeoutMs }) => {
-      const result = await waitForDetachedJob(process.cwd(), id, {
-        timeoutMs: mcpWaitForJobTimeoutMs(timeoutMs)
-      });
-      return mcpJson(result);
-    }
-  );
-  server.tool(
-    "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: z9.string().describe("Detached job id (same kebab-case id passed to detached-job.cjs start)"),
-      reason: z9.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 });
-      return mcpJson(result);
-    }
-  );
+  if (mcpCatalog.has("wait_for_job")) {
+    server.tool(
+      "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: z9.string().describe("Detached job id (same kebab-case id passed to detached-job.cjs start)"),
+        timeoutMs: z9.number().optional()
+      },
+      async ({ id, timeoutMs }) => {
+        const result = await waitForDetachedJob(process.cwd(), id, {
+          timeoutMs: mcpWaitForJobTimeoutMs(timeoutMs)
+        });
+        return mcpJson(result);
+      }
+    );
+    server.tool(
+      "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: z9.string().describe("Detached job id (same kebab-case id passed to detached-job.cjs start)"),
+        reason: z9.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 });
+        return mcpJson(result);
+      }
+    );
+  }
   server.tool(
     "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).",
@@ -6652,7 +6861,7 @@ async function startMcpServer() {
     registerSlackTools(server);
     registerConnectedIssueVendorTools(server);
     const { getCaffeinateHold: getCaffeinateHold2, setCaffeinateHold: setCaffeinateHold2 } = await import("./caffeinate-hold-DYJGWK6Y.js");
-    const { resolveNewThreadOptions: resolveNewThreadOptions2, resolveThreadDefaults: resolveThreadDefaults2 } = await import("./app-settings-VQEUCONM.js");
+    const { resolveNewThreadOptions: resolveNewThreadOptions2, resolveThreadDefaults: resolveThreadDefaults2 } = await import("./app-settings-RKFFUIFQ.js");
     const accountDefaults = resolveThreadDefaults2();
     const accountDefaultsHint = `Account defaults: agent=${accountDefaults.agent}, model=${accountDefaults.model?.trim() || "Auto"}, effort=${accountDefaults.effort}`;
     server.tool(
@@ -6682,8 +6891,8 @@ async function startMcpServer() {
       }
     );
     server.tool(
-      "create_thread",
-      `Create a worktree thread (chat) from branch, pr, or ticket. A ticket, PR, or named branch may have only one live worktree \u2014 if one already matches, returns it (alreadyStarted=true) instead of a second checkout. Creating from the default branch still opens a new isolated worktree. Pass repoPath from list_workspaces. cowboy=true uses the project folder on the default branch (no isolated worktree; land is commit+push). From an orchestration chat, omit parentThreadId (Sideboard binds the child to this chat) or pass the exact id from the turn reminder \u2014 never invent a uuid. 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). Then use send_to_thread to chat.`,
+      "create_workspace",
+      `Create a workspace (isolated git worktree + first chat) from branch, pr, or ticket. A ticket, PR, or named branch may have only one live worktree \u2014 if one already matches, returns it (alreadyStarted=true) instead of a second checkout. Creating from the default branch still opens a new isolated worktree. 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). Then use send_to_chat to chat.`,
       {
         sourceType: z9.enum(["branch", "pr", "ticket"]),
         sourceRef: z9.string(),
@@ -6698,9 +6907,10 @@ async function startMcpServer() {
         cowboy: z9.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."
         ),
-        parentThreadId: z9.string().optional().describe(
+        parentChatId: z9.string().optional().describe(
           "Orchestration: omit (preferred) or pass YOUR chat id from the turn reminder / AGENTS.md. Do not invent uuids."
-        )
+        ),
+        parentThreadId: z9.string().optional().describe("Legacy alias for parentChatId.")
       },
       async (args) => {
         const result = await createOrchChildThread(orch, args, resolveNewThreadOptions2);
@@ -6712,11 +6922,11 @@ async function startMcpServer() {
     );
     server.tool(
       "start_board_card",
-      "Same as create_thread for a ticket, PR, or named branch (attaches issue text when Sideboard can resolve it). Does not create a second worktree when one already matches \u2014 returns that thread (alreadyStarted). Then send_to_thread.",
+      "Same as create_workspace for a ticket, PR, or named branch (attaches issue text when Sideboard can resolve it). Does not create a second worktree when one already matches \u2014 returns that thread (alreadyStarted). Then send_to_chat.",
       {
         kind: z9.enum(["ticket", "pr", "branch"]),
         ref: z9.string().describe("Ticket identifier (ENG-12), PR number (44), or branch name from list_board"),
-        repoPath: z9.string().describe("Workspace path from list_workspaces / list_board"),
+        repoPath: z9.string().describe("Project path from list_projects / list_board"),
         title: z9.string().optional()
       },
       async ({ kind, ref, repoPath, title }) => {
@@ -6739,7 +6949,7 @@ async function startMcpServer() {
             id: existing.id,
             title: existing.title,
             status: existing.status,
-            link: `sideboard://thread/${existing.id}`
+            link: `sideboard://chat/${existing.id}`
           });
         }
         const workspaces = orch.listWorkspaces();
@@ -6767,7 +6977,7 @@ async function startMcpServer() {
           const ident = issue?.identifier ?? ref.trim();
           const attachments = issue ? [
             {
-              id: randomUUID3(),
+              id: randomUUID4(),
               name: issue.identifier,
               kind: "issue",
               content: [
@@ -6811,8 +7021,8 @@ async function startMcpServer() {
       }
     );
     server.tool(
-      "send_to_thread",
-      'Steer a prompt on a worktree thread chat (Settings \u2192 Follow-up, default steer: front of the queue, skips the inbox; while the desktop board is running it starts as soon as the in-flight turn yields). Use after create_thread 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_thread 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.',
+      "send_to_chat",
+      'Steer a prompt on a workspace chat (Settings \u2192 Follow-up, default steer: front of the queue, skips the inbox; while the desktop board is running it starts as soon as the in-flight turn yields). 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: z9.string(),
         prompt: z9.string(),
@@ -6836,36 +7046,38 @@ async function startMcpServer() {
         });
       }
     );
-    server.tool(
-      "wait_for_turn",
-      "Wait until the thread 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. If stillRunning, call wait_for_turn again \u2014 do not send_to_thread 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_thread or tell the user. On input-required, wait for the user in that chat. When finished, usage is the last agent turn\u2019s tokens + costUsd (when the provider reported cost).",
-      {
-        ref: z9.string(),
-        timeoutMs: z9.number().optional()
-      },
-      async ({ ref, timeoutMs }) => {
-        const thread = await orch.waitForTurn(ref, mcpWaitForTurnTimeoutMs(timeoutMs), {
-          resolveIfStillRunning: true
-        });
-        const result = orch.getTurnResult(thread.id);
-        const hint = mcpWaitTaskHint(result.taskState, result.status);
-        return mcpJson({
-          id: thread.id,
-          status: result.status,
-          taskState: result.taskState,
-          text: result.text,
-          lastError: result.lastError,
-          stillRunning: result.stillRunning,
-          progress: result.progress,
-          lastActivityAt: result.lastActivityAt,
-          hint,
-          incomplete: needsCoordinatorAction(result.taskState)
-        });
-      }
-    );
+    if (shouldRegisterMcpWaitForTurn()) {
+      server.tool(
+        "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. 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: z9.string(),
+          timeoutMs: z9.number().optional()
+        },
+        async ({ ref, timeoutMs }) => {
+          const thread = await orch.waitForTurn(ref, mcpWaitForTurnTimeoutMs(timeoutMs), {
+            resolveIfStillRunning: true
+          });
+          const result = orch.getTurnResult(thread.id);
+          return mcpJson(
+            waitForTurnToolResult({
+              id: thread.id,
+              status: result.status,
+              taskState: result.taskState,
+              text: result.text,
+              lastError: result.lastError,
+              stillRunning: result.stillRunning,
+              progress: result.progress,
+              lastActivityAt: result.lastActivityAt,
+              usage: result.usage
+            })
+          );
+        }
+      );
+    }
     server.tool(
       "get_turn_result",
-      "Assistant message when the turn finished, or live progress while stillRunning. Not the full transcript. Includes taskState (A2A lifecycle) and usage for the last agent turn (tokens + costUsd when reported).",
+      "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).",
       { ref: z9.string() },
       async ({ ref }) => {
         const result = orch.getTurnResult(ref);
@@ -6878,7 +7090,7 @@ async function startMcpServer() {
       }
     );
     server.tool(
-      "stop_thread",
+      "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.",
       {
         ref: z9.string(),
@@ -6888,7 +7100,7 @@ async function startMcpServer() {
         const t = orch.getThread(ref);
         if (!t) {
           return {
-            content: [{ type: "text", text: `Thread not found: ${ref}` }],
+            content: [{ type: "text", text: `Chat not found: ${ref}` }],
             isError: true
           };
         }
@@ -6903,14 +7115,14 @@ async function startMcpServer() {
       }
     );
     server.tool(
-      "archive_thread",
+      "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: z9.string() },
       async ({ ref }) => {
         const t = orch.getThread(ref);
         if (!t) {
           return {
-            content: [{ type: "text", text: `Thread not found: ${ref}` }],
+            content: [{ type: "text", text: `Chat not found: ${ref}` }],
             isError: true
           };
         }
@@ -6929,7 +7141,7 @@ async function startMcpServer() {
       }
     );
     server.tool(
-      "restore_thread",
+      "restore_chat",
       "Restore an archived thread (recreates worktree from branch when needed)",
       { ref: z9.string() },
       async ({ ref }) => {
@@ -6988,7 +7200,7 @@ async function startMcpServer() {
             title: tab.title,
             status: tab.status,
             fromThreadId: from?.id ?? ref,
-            link: `sideboard://thread/${tab.id}`
+            link: `sideboard://chat/${tab.id}`
           });
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
@@ -7013,7 +7225,7 @@ async function startMcpServer() {
             status: thread.status,
             queueLength: thread.queue.length,
             action,
-            link: `sideboard://thread/${thread.id}`
+            link: `sideboard://chat/${thread.id}`
           });
         } catch (err) {
           const raw = err instanceof Error ? err.message : String(err);
@@ -7023,7 +7235,7 @@ async function startMcpServer() {
               error: true,
               action,
               lastError: message,
-              hint: /body is too long/i.test(message) ? "Branch is already pushed. send_to_thread so the worktree agent runs gh pr create --draft --assignee @me -R <origin> --body-file <short.md>. Keep the description short." : void 0
+              hint: /body is too long/i.test(message) ? "Branch is already pushed. send_to_chat so the worktree agent runs gh pr create --draft --assignee @me -R <origin> --body-file <short.md>. Keep the description short." : void 0
             },
             true
           );
@@ -7048,8 +7260,8 @@ async function startMcpServer() {
       }
     );
     server.tool(
-      "fork_worktree",
-      "Fork a worktree agent chat into a NEW git worktree + chat (desktop \u201CFork to new workspace\u201D). Seeds a transcript (through through_index, default all). Optional agent override. Leave model unset for Auto (default) \u2014 only pass model when you have a reason. Not for the orchestrator. Then send_to_thread / wait_for_turn (loop while stillRunning) on the returned id.",
+      "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: z9.string().describe("Worktree thread id/ref to fork"),
         through_index: z9.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
@@ -7077,7 +7289,7 @@ async function startMcpServer() {
             branchName: thread.branchName,
             worktreePath: thread.worktreePath,
             fromThreadId: source?.id ?? ref,
-            link: `sideboard://thread/${thread.id}`
+            link: `sideboard://chat/${thread.id}`
           });
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
@@ -7087,7 +7299,7 @@ async function startMcpServer() {
     );
     server.tool(
       "fork_chat",
-      "Fork a chat into a NEW tab on the SAME workspace: worktree agent \u2192 same worktree tab; Global orchestration chat \u2192 new orchestration chat (same synthetic home). Seeds a transcript; optional agent override. Leave model unset for Auto unless you have a reason. Orchestration forks require an MCP-capable agent (claude, cursor, codex, opencode \u2014 not brightsy). Slack / Global orchestrators use this to continue an orchestration chat on another agent after session limits. Then send_to_thread / wait_for_turn (loop while stillRunning) on the returned id. Use fork_worktree only for worktree agents that need a new git worktree.",
+      "Fork a chat into a NEW tab on the SAME workspace: worktree agent \u2192 same worktree tab; Global orchestration chat \u2192 new orchestration chat (same synthetic home). Seeds a transcript; optional agent override. Leave model unset for Auto unless you have a reason. Orchestration forks require an MCP-capable agent (claude, cursor, codex, opencode \u2014 not brightsy). Slack / Global orchestrators use this to continue an orchestration chat on another agent after session limits. Then send_to_chat / wait_for_turn (loop while stillRunning) on the returned id. Use fork_workspace only for worktree agents that need a new git worktree.",
       {
         ref: z9.string().describe("Thread id/ref to fork (worktree agent or orchestration chat)"),
         through_index: z9.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
@@ -7100,7 +7312,7 @@ async function startMcpServer() {
           const source = orch.getThread(ref);
           if (!source) {
             return {
-              content: [{ type: "text", text: `Thread not found: ${ref}` }],
+              content: [{ type: "text", text: `Chat not found: ${ref}` }],
               isError: true
             };
           }
@@ -7120,7 +7332,7 @@ async function startMcpServer() {
             sourceType: tab.sourceType,
             worktreePath: tab.worktreePath,
             fromThreadId: source.id,
-            link: `sideboard://thread/${tab.id}`
+            link: `sideboard://chat/${tab.id}`
           });
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
@@ -7138,7 +7350,7 @@ async function startMcpServer() {
       }
     );
     server.tool(
-      "add_workspace",
+      "add_project",
       "Register a git repo as a Sideboard workspace",
       { repoPath: z9.string() },
       async ({ repoPath }) => {
@@ -7147,7 +7359,7 @@ async function startMcpServer() {
       }
     );
     server.tool(
-      "remove_workspace",
+      "remove_project",
       "Unregister a Sideboard workspace (does not archive threads)",
       { repoPath: z9.string() },
       async ({ repoPath }) => {
@@ -7180,7 +7392,7 @@ async function startMcpServer() {
     );
     server.tool(
       "list_branches",
-      "List git branches in a registered workspace. Pass repoPath from list_workspaces (unmerged into the default branch by default \u2014 for create_thread sourceType=branch).",
+      "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: z9.string(),
         unmergedOnly: z9.boolean().optional()
@@ -7202,7 +7414,7 @@ async function startMcpServer() {
     );
     server.tool(
       "list_prs",
-      `List GitHub PRs for a registered workspace (the review surface for assigned ticket work \u2014 not the tickets). Pass repoPath from list_workspaces. "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_thread with sourceType=pr.`,
+      `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: z9.string(),
         query: z9.string().optional().describe("GitHub search tokens (title, draft:true, \u2026)"),
@@ -7274,7 +7486,7 @@ async function startMcpServer() {
             stackLayer: t.stackLayer,
             worktreePath: t.worktreePath,
             prUrl: t.prUrl,
-            link: `sideboard://thread/${t.id}`
+            link: `sideboard://chat/${t.id}`
           }))
         });
       }
@@ -7295,7 +7507,7 @@ async function startMcpServer() {
           branchName: result.thread.branchName,
           stackLayer: result.thread.stackLayer,
           worktreePath: result.thread.worktreePath,
-          link: `sideboard://thread/${result.thread.id}`
+          link: `sideboard://chat/${result.thread.id}`
         });
       }
     );
@@ -7326,14 +7538,14 @@ async function startMcpServer() {
             branchName: t.branchName,
             stackLayer: t.stackLayer,
             worktreePath: t.worktreePath,
-            link: `sideboard://thread/${t.id}`
+            link: `sideboard://chat/${t.id}`
           }))
         });
       }
     );
     server.tool(
       "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_thread with sourceType=ticket.",
+      "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: z9.string(),
         query: z9.string().optional().describe("Search title, identifier, or description"),
@@ -7358,6 +7570,184 @@ async function startMcpServer() {
   await server.connect(transport);
 }
 
+// src/agent-rpc/server.ts
+import { randomBytes as randomBytes2, randomUUID as randomUUID5, timingSafeEqual } from "crypto";
+import { createServer as createServer2 } from "http";
+import { WebSocketServer } from "ws";
+function tokensEqual(a, b) {
+  const left = Buffer.from(a);
+  const right = Buffer.from(b);
+  if (left.length !== right.length) return false;
+  return timingSafeEqual(left, right);
+}
+function authTokenFromUpgrade(req) {
+  try {
+    const url = new URL(req.url ?? "", "http://127.0.0.1");
+    return url.searchParams.get(AGENT_RPC_TOKEN_QUERY) ?? "";
+  } catch {
+    return "";
+  }
+}
+function sendJson(ws, value) {
+  if (ws.readyState !== ws.OPEN) return;
+  ws.send(JSON.stringify(value));
+}
+var AgentRpcServer = class {
+  http = null;
+  wss = null;
+  meta = null;
+  handlers;
+  cwd;
+  constructor(opts = {}) {
+    this.handlers = opts.handlers ?? createAgentRpcDispatcher();
+    this.cwd = opts.cwd ?? (() => process.cwd());
+  }
+  get metadata() {
+    return this.meta;
+  }
+  get url() {
+    return this.meta?.transports[0]?.url ?? null;
+  }
+  async listen(opts = {}) {
+    const host = opts.host ?? "127.0.0.1";
+    const port = opts.port ?? 0;
+    const authToken = randomBytes2(24).toString("base64url");
+    this.meta = {
+      runtimeId: randomUUID5(),
+      pid: process.pid,
+      protocolVersion: AGENT_RPC_PROTOCOL_VERSION,
+      authToken,
+      startedAt: Date.now(),
+      transports: []
+    };
+    const http = createServer2((_req, res) => {
+      res.statusCode = 404;
+      res.end();
+    });
+    const wss = new WebSocketServer({
+      server: http,
+      path: AGENT_RPC_PATH,
+      verifyClient: (info) => this.authorizeUpgrade(info.req)
+    });
+    wss.on("connection", (ws) => this.attach(ws));
+    try {
+      await new Promise((resolve, reject) => {
+        http.once("error", reject);
+        http.listen(port, host, () => {
+          http.off("error", reject);
+          resolve();
+        });
+      });
+    } catch (err) {
+      this.meta = null;
+      throw err;
+    }
+    const addr = http.address();
+    if (!addr || typeof addr === "string") {
+      this.meta = null;
+      http.close();
+      throw new Error("Agent RPC failed to bind a TCP port");
+    }
+    this.http = http;
+    this.wss = wss;
+    const url = `ws://${host}:${addr.port}${AGENT_RPC_PATH}`;
+    this.meta = {
+      ...this.meta,
+      transports: [{ kind: "websocket", url }]
+    };
+    writeAgentRuntimeMetadata(this.meta);
+    return this.meta;
+  }
+  authorizeUpgrade(req) {
+    const expected = this.meta?.authToken ?? "";
+    const got = authTokenFromUpgrade(req);
+    return Boolean(expected && got && tokensEqual(got, expected));
+  }
+  attach(ws) {
+    ws.on("message", (data) => {
+      void this.onMessage(ws, data.toString());
+    });
+    ws.on("error", () => {
+    });
+  }
+  async onMessage(ws, raw) {
+    const parsed = parseRpcFrame(raw);
+    if (parsed === void 0) {
+      sendJson(ws, rpcError(null, RPC_PARSE_ERROR, "Parse error"));
+      return;
+    }
+    if (!isJsonRpcRequest(parsed)) {
+      sendJson(ws, rpcError(null, RPC_INVALID_REQUEST, "Invalid request"));
+      return;
+    }
+    const id = parsed.id;
+    const expected = this.meta?.authToken ?? "";
+    const got = typeof parsed.authToken === "string" ? parsed.authToken : "";
+    if (!expected || !got || !tokensEqual(got, expected)) {
+      sendJson(ws, rpcError(id, RPC_UNAUTHORIZED, "Unauthorized"));
+      return;
+    }
+    const handler = this.handlers[parsed.method];
+    if (!handler) {
+      sendJson(ws, rpcError(id, RPC_METHOD_NOT_FOUND, `Method not found: ${parsed.method}`));
+      return;
+    }
+    const ctx = {
+      cwd: this.cwd(),
+      notify: (method, params) => sendJson(ws, rpcNotify(method, params))
+    };
+    try {
+      const result = await handler(parsed.params, ctx);
+      sendJson(ws, rpcResult(id, result));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const code = err && typeof err === "object" && "rpcCode" in err && typeof err.rpcCode === "number" ? err.rpcCode : RPC_INTERNAL_ERROR;
+      sendJson(ws, rpcError(id, code, message));
+    }
+  }
+  async close() {
+    clearAgentRuntimeMetadataIfOwned();
+    this.meta = null;
+    const wss = this.wss;
+    this.wss = null;
+    if (wss) {
+      for (const client of wss.clients) {
+        try {
+          client.close();
+        } catch {
+        }
+      }
+      await new Promise((resolve) => wss.close(() => resolve()));
+    }
+    const http = this.http;
+    this.http = null;
+    if (http) {
+      await new Promise((resolve) => http.close(() => resolve()));
+    }
+  }
+};
+var running = null;
+async function startAgentRpcServer(opts = {}) {
+  if (running) return running;
+  const server = new AgentRpcServer(opts);
+  try {
+    await server.listen({ host: opts.host, port: opts.port });
+  } catch (err) {
+    await server.close().catch(() => void 0);
+    throw err;
+  }
+  running = server;
+  return server;
+}
+async function stopAgentRpcServer() {
+  const server = running;
+  running = null;
+  if (server) await server.close();
+}
+function getAgentRpcServer() {
+  return running;
+}
+
 // src/brightsy/api.ts
 var formatBrightsyFetchError = formatFetchError;
 var BrightsySideboardApi = class {
@@ -7636,14 +8026,14 @@ async function runCloudConnect(opts) {
   while (!opts.signal?.aborted) {
     try {
       const hadFailures = consecutivePollFailures > 0;
-      const [pending, awaiting, running] = await Promise.all([
+      const [pending, awaiting, running2] = await Promise.all([
         api.getTasks("pending"),
         api.getTasks("awaiting_confirmation"),
         api.getTasks("running")
       ]);
       consecutivePollFailures = 0;
       if (hadFailures) log("poll recovered");
-      const tasks = [...awaiting, ...pending, ...running];
+      const tasks = [...awaiting, ...pending, ...running2];
       for (const task of tasks) {
         if (inFlight.has(task.id)) continue;
         if (task.task_status === "running") continue;
@@ -7689,7 +8079,7 @@ async function runCloudConnect(opts) {
 }
 
 // src/slack/oauth.ts
-import { randomBytes as randomBytes2 } from "crypto";
+import { randomBytes as randomBytes3 } from "crypto";
 
 // src/slack/baked-app.ts
 var BAKED_SLACK_CLIENT_ID = "7592788819232.11813536272562";
@@ -7911,7 +8301,7 @@ async function startSlackOAuth(opts) {
     throw new SlackOAuthCancelledError();
   }
   const { clientId } = slackOAuthCredentials();
-  const state = randomBytes2(16).toString("hex");
+  const state = randomBytes3(16).toString("hex");
   const authorizeUrl = slackOAuthAuthorizeUrl(clientId, state);
   const timeoutMs = opts?.timeoutMs ?? 5 * 6e4;
   const pollIntervalMs = opts?.pollIntervalMs ?? 400;
@@ -8178,7 +8568,7 @@ function connectSession(ws, opts, log) {
 }
 
 // src/slack/relay-protocol.ts
-import { randomBytes as randomBytes3 } from "crypto";
+import { randomBytes as randomBytes4 } from "crypto";
 var SLACK_RELAY_PING_INTERVAL_MS = 2e4;
 var SLACK_RELAY_PONG_TIMEOUT_MS = 15e3;
 function slackRelaySessionKey(teamId, userId, deviceId) {
@@ -8188,7 +8578,7 @@ function slackRelayUserKey(teamId, userId) {
   return `${teamId.trim()}:${userId.trim()}`;
 }
 function newSlackRelayEventId() {
-  return randomBytes3(12).toString("hex");
+  return randomBytes4(12).toString("hex");
 }
 function parseSlackRelayClientMessage(raw) {
   try {
@@ -9317,8 +9707,8 @@ var SlackRelayHub = class {
 };
 
 // src/slack/relay-server.ts
-import { createServer as createServer2 } from "http";
-import { WebSocketServer } from "ws";
+import { createServer as createServer3 } from "http";
+import { WebSocketServer as WebSocketServer2 } from "ws";
 
 // src/slack/relay-static.ts
 import { createReadStream } from "fs";
@@ -9400,7 +9790,7 @@ function sendHtml(res, status, title, body) {
   res.writeHead(status, { "Content-Type": "text/html; charset=utf-8" });
   res.end(slackOAuthHtmlPage(title, body));
 }
-function sendJson(res, status, body) {
+function sendJson2(res, status, body) {
   res.writeHead(status, { "Content-Type": "application/json" });
   res.end(JSON.stringify(body));
 }
@@ -9479,17 +9869,17 @@ async function startSlackRelayServer(opts) {
     const state = url2.searchParams.get("state")?.trim() ?? "";
     const value = pending.take(state);
     if (!value) {
-      sendJson(res, 404, { ok: false, error: "pending" });
+      sendJson2(res, 404, { ok: false, error: "pending" });
       return true;
     }
     if (!value.ok) {
-      sendJson(res, 400, { ok: false, error: value.error });
+      sendJson2(res, 400, { ok: false, error: value.error });
       return true;
     }
-    sendJson(res, 200, { ok: true, ...value.payload });
+    sendJson2(res, 200, { ok: true, ...value.payload });
     return true;
   };
-  const httpServer = createServer2((req, res) => {
+  const httpServer = createServer3((req, res) => {
     void (async () => {
       const reqUrl = req.url || "/";
       if (await handleCallback(reqUrl, res)) return;
@@ -9505,7 +9895,7 @@ async function startSlackRelayServer(opts) {
         return;
       }
       if (req.url === "/health") {
-        sendJson(res, 200, {
+        sendJson2(res, 200, {
           ok: true,
           service: "sideboard-slack-relay",
           sessions: hub.listSessions().length,
@@ -9524,7 +9914,7 @@ async function startSlackRelayServer(opts) {
         return;
       }
       if (req.url === "/") {
-        sendJson(res, 200, {
+        sendJson2(res, 200, {
           ok: true,
           service: "sideboard-slack-relay",
           sessions: hub.listSessions().length,
@@ -9542,7 +9932,7 @@ async function startSlackRelayServer(opts) {
       }
     });
   });
-  const wss = new WebSocketServer({ server: httpServer, path: SLACK_RELAY_DESKTOP_PATH });
+  const wss = new WebSocketServer2({ server: httpServer, path: SLACK_RELAY_DESKTOP_PATH });
   wss.on("connection", (ws, _req) => {
     const socket = {
       send: (data) => {
@@ -9646,11 +10036,14 @@ export {
   AGENT_DONE_CUSTOM_SOUND_MAX_BYTES,
   AGENT_DONE_SOUNDS,
   AGENT_GIT_ACTIONS,
+  AGENT_RPC_NATIVE_ENV,
+  AGENT_RPC_PROTOCOL_VERSION,
   AGENT_RUNNER_MAX_OLD_SPACE_MB,
   ATTACHMENTS_DIR,
   AbleTimeOAuthCancelledError,
   BAKED_ABLETIME_OAUTH_CLIENT_ID,
   BAKED_SLACK_RELAY_URL,
+  BASE_ALLOWED_TOOLS,
   BRIGHTSY_MCP_ALLOWED_TOOLS,
   BRIGHTSY_OAUTH_CLIENT_ID,
   BRIGHTSY_OAUTH_REDIRECT,
@@ -9659,9 +10052,12 @@ export {
   BUNDLED_SKILL_PREFIX,
   BrightsySideboardApi,
   CHARS_PER_CONTEXT_TOKEN,
+  CHAT_LINK_PREFIX,
   CHAT_TEXT_SCALES,
   CHAT_TEXT_SCALE_DEFAULT,
+  CLAUDE_CHROME_ALLOWED_TOOLS,
   CLAUDE_MODEL_CATALOG,
+  CLAUDE_PRINT_BG_WAIT_CEILING_MS,
   CLAUDE_SUMMARY_TIMEOUT_MS,
   CLI_DIR,
   CLOUD_COORDINATOR_BUSY_REPLY,
@@ -9703,6 +10099,7 @@ export {
   LEGACY_DETACHED_JOBS_DIR,
   LEGACY_PLAN_FILE_REL,
   LEGACY_REVIEW_REQUEST_PATH,
+  LEGACY_THREAD_LINK_PREFIX,
   LIGHT_RECONCILE_THROTTLE_MS,
   LINEAR_OAUTH_CANCELLED,
   LINEAR_OAUTH_PORT,
@@ -9791,6 +10188,7 @@ export {
   agentDoneSound,
   agentDoneSoundsDir,
   agentGitPrompt,
+  agentRpcConnectFromMetadata,
   alignQueueAttachments,
   allAdapters,
   allocatePort,
@@ -9859,6 +10257,7 @@ export {
   canonicalizeRepoPath,
   captureLoginEnv,
   captureTurnBaseline,
+  chatLinkUrl,
   chatTextScale,
   checkoutPrStackLayer,
   childEnvWithAppSettings,
@@ -10069,6 +10468,7 @@ export {
   getAbleTimeOrientation,
   getAbleTimeTask,
   getAdapter,
+  getAgentRpcServer,
   getAgentSetupInfo,
   getBrightsySession,
   getCaffeinateHold,
@@ -10233,6 +10633,7 @@ export {
   linearOAuthCredentials,
   linearRelationCreateInput,
   linearTicketIdFromThread,
+  linkifyChatUrls,
   listAbleTimeAssignedIssues,
   listAbleTimeProjects,
   listAbleTimeTasks,
@@ -10345,6 +10746,7 @@ export {
   outboundReplyFromTurn,
   packagedDetachedJobPath,
   parseAbleTimeOAuthCallbackUrl,
+  parseChatLink,
   parseClaudeUsagePayload,
   parseCursorRunnerLine,
   parseDevPreview,
@@ -10378,10 +10780,12 @@ export {
   prepareTerminalCommand,
   prependQueuedItem,
   previewLand,
+  previousCostBaseline,
   primaryCheckoutFromLinkedWorktree,
   promptMentionsBrightsy,
   pushBranch,
   readAgentDoneCustomSound,
+  readAgentRuntimeMetadata,
   readExistingReviewRequestFile,
   readKeychainVaultKey,
   readPlanFile,
@@ -10538,6 +10942,7 @@ export {
   stageAbsolutePathsAsAttachments,
   stageBuffersAsAttachments,
   startAbleTimeOAuth,
+  startAgentRpcServer,
   startDevServer,
   startLinearOAuth,
   startMcpServer,
@@ -10545,6 +10950,7 @@ export {
   startSlackOAuth,
   startSlackRelayServer,
   statWorktreePath,
+  stopAgentRpcServer,
   stripBrightsyNdjsonNoise,
   stripNestedElectronEnv,
   submitPrStack,
@@ -10585,6 +10991,7 @@ export {
   tryReservePort,
   tryReservePorts,
   turnCostUsdFromCursorUsage,
+  turnCostUsdFromProviderSnapshot,
   updateAbleTimeTask,
   updateAdvancedSettings,
   updateAgentExecutable,
@@ -10620,6 +11027,7 @@ export {
   withRemovedAccount,
   withSelectedAccount,
   withThreadLock,
+  withTurnScopedCost,
   workspaceSettingsSourceLabel,
   worktreeBoardStatus,
   worktreeCleanupSettings,