@sideboard-ai/core 0.1.228 → 0.1.230

package/dist/mcp/run-stdio.cjs

@@ -861,6 +861,22 @@ function resolveThreadEffort(raw) {
   if (raw.fast) return "low";
   return "high";
 }
+function normalizeRunScriptRequest(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const req = raw;
+  if (req.op !== "start" && req.op !== "stop") return void 0;
+  if (typeof req.requestId !== "string" || !req.requestId.trim()) return void 0;
+  if (typeof req.requestedAt !== "string" || !req.requestedAt.trim()) return void 0;
+  return {
+    op: req.op,
+    scriptName: req.scriptName ?? null,
+    requestId: req.requestId,
+    requestedAt: req.requestedAt,
+    claimedAt: req.claimedAt ?? null,
+    fulfilledAt: req.fulfilledAt ?? null,
+    error: req.error ?? null
+  };
+}
 function normalizeThread(raw) {
   return {
     ...raw,
@@ -884,6 +900,7 @@ function normalizeThread(raw) {
     stackLayer: raw.stackLayer ?? null,
     userSetTitle: Boolean(raw.userSetTitle),
     activeRuns: Array.isArray(raw.activeRuns) ? raw.activeRuns : [],
+    runScriptRequest: normalizeRunScriptRequest(raw.runScriptRequest),
     quotaResumeAt: raw.quotaResumeAt ?? null,
     quotaContinuedFromId: raw.quotaContinuedFromId ?? null,
     archivedAt: typeof raw.archivedAt === "string" && raw.archivedAt.trim() ? raw.archivedAt.trim() : void 0
@@ -3787,12 +3804,14 @@ var init_issue_source_labels = __esm({
 // src/store/app-settings.ts
 var app_settings_exports = {};
 __export(app_settings_exports, {
+  AGENT_DONE_SOUNDS: () => AGENT_DONE_SOUNDS,
   FOLLOW_UP_BEHAVIORS: () => FOLLOW_UP_BEHAVIORS,
   GITHUB_GIT_AUTH_MODES: () => GITHUB_GIT_AUTH_MODES,
   HARNESS_ENV_KEYS: () => HARNESS_ENV_KEYS,
   ISSUE_SOURCE_LABELS: () => ISSUE_SOURCE_LABELS,
   PROFILE_NOTES_MAX: () => PROFILE_NOTES_MAX,
   USAGE_ON_LIMIT_VALUES: () => USAGE_ON_LIMIT_VALUES,
+  agentDoneSound: () => agentDoneSound,
   appSettingsPath: () => appSettingsPath,
   applyAppEnvironment: () => applyAppEnvironment,
   autoArchiveOnMergeEnabled: () => autoArchiveOnMergeEnabled,
@@ -3840,6 +3859,7 @@ __export(app_settings_exports, {
   historyMaxCount: () => historyMaxCount,
   historyMaxDays: () => historyMaxDays,
   isAbleTimeConnected: () => isAbleTimeConnected,
+  isAgentDoneSound: () => isAgentDoneSound,
   isIssueSourceConnected: () => isIssueSourceConnected,
   isLinearConnected: () => isLinearConnected,
   isUsageOnLimit: () => isUsageOnLimit,
@@ -3881,6 +3901,9 @@ __export(app_settings_exports, {
   usageOnLimit: () => usageOnLimit,
   writeViewerContext: () => writeViewerContext
 });
+function isAgentDoneSound(value) {
+  return AGENT_DONE_SOUNDS.includes(value);
+}
 function emptyPublicIntegrations() {
   return {
     hasLinearApiKey: false,
@@ -4311,6 +4334,13 @@ function normalizeAdvanced(raw) {
   if (source.followUpBehavior === "queue" || source.followUpBehavior === "steer") {
     out.followUpBehavior = source.followUpBehavior;
   }
+  if (isAgentDoneSound(source.agentDoneSound)) {
+    out.agentDoneSound = source.agentDoneSound;
+  }
+  if (typeof source.agentDoneCustomSoundName === "string") {
+    const name = source.agentDoneCustomSoundName.trim();
+    if (name) out.agentDoneCustomSoundName = name.slice(0, 200);
+  }
   return out;
 }
 function normalizeSettings(raw) {
@@ -5221,6 +5251,16 @@ function updateAdvancedSettings(patch) {
   if (patch.followUpBehavior === "queue" || patch.followUpBehavior === "steer") {
     advanced.followUpBehavior = patch.followUpBehavior;
   }
+  if (isAgentDoneSound(patch.agentDoneSound)) {
+    advanced.agentDoneSound = patch.agentDoneSound;
+  }
+  if (patch.agentDoneCustomSoundName === null || patch.agentDoneCustomSoundName === "") {
+    delete advanced.agentDoneCustomSoundName;
+  } else if (typeof patch.agentDoneCustomSoundName === "string") {
+    const name = patch.agentDoneCustomSoundName.trim();
+    if (name) advanced.agentDoneCustomSoundName = name.slice(0, 200);
+    else delete advanced.agentDoneCustomSoundName;
+  }
   return saveAppSettings({ ...current, advanced });
 }
 function autoRenameBranchEnabled(settings = loadAppSettings()) {
@@ -5288,6 +5328,9 @@ function orchestrationQuotaFallbackAgent(settings = loadAppSettings()) {
 function followUpBehavior(settings = loadAppSettings()) {
   return settings.advanced.followUpBehavior === "queue" ? "queue" : "steer";
 }
+function agentDoneSound(settings = loadAppSettings()) {
+  return isAgentDoneSound(settings.advanced.agentDoneSound) ? settings.advanced.agentDoneSound : "none";
+}
 function maxConcurrentAgents(settings = loadAppSettings()) {
   const n = settings.advanced.maxConcurrent;
   if (typeof n === "number" && Number.isFinite(n)) {
@@ -5375,7 +5418,7 @@ function childEnvWithAppSettings(extra) {
 function harnessEnvKey(harness) {
   return HARNESS_ENV_KEYS[harness];
 }
-var import_node_crypto3, import_node_fs15, import_node_os5, import_node_path18, HARNESS_ENV_KEYS, DEFAULT_AGENTS, GITHUB_GIT_AUTH_MODES, FOLLOW_UP_BEHAVIORS, CLOUD_CONNECT_AGENTS, ISSUE_SOURCES, GIT_AUTH_MODES, EMPTY_SETTINGS, CONFIRM_ACCOUNT, CONFIRM_PROJECT, DEFAULT_CLI_BIN;
+var import_node_crypto3, import_node_fs15, import_node_os5, import_node_path18, HARNESS_ENV_KEYS, DEFAULT_AGENTS, GITHUB_GIT_AUTH_MODES, FOLLOW_UP_BEHAVIORS, AGENT_DONE_SOUNDS, CLOUD_CONNECT_AGENTS, ISSUE_SOURCES, GIT_AUTH_MODES, EMPTY_SETTINGS, CONFIRM_ACCOUNT, CONFIRM_PROJECT, DEFAULT_CLI_BIN;
 var init_app_settings = __esm({
   "src/store/app-settings.ts"() {
     "use strict";
@@ -5412,6 +5455,18 @@ var init_app_settings = __esm({
     ]);
     GITHUB_GIT_AUTH_MODES = ["auto", "gh", "ssh", "token"];
     FOLLOW_UP_BEHAVIORS = ["steer", "queue"];
+    AGENT_DONE_SOUNDS = [
+      "none",
+      "goal",
+      "bell",
+      "level",
+      "coin",
+      "fanfare",
+      "magic",
+      "rooster",
+      "whistle",
+      "custom"
+    ];
     CLOUD_CONNECT_AGENTS = /* @__PURE__ */ new Set([
       "claude",
       "codex",
@@ -10242,6 +10297,9 @@ var init_injected_mcp = __esm({
       "mcp__sideboard__present_plan",
       "mcp__sideboard__wait_for_job",
       "mcp__sideboard__stop_job",
+      "mcp__sideboard__list_run_scripts",
+      "mcp__sideboard__run_dev_script",
+      "mcp__sideboard__stop_dev_script",
       "mcp__sideboard__get_viewer_context",
       "mcp__sideboard__update_viewer_context"
     ];
@@ -10451,6 +10509,13 @@ function toolDescription(name, input) {
   if (/stop_job$/i.test(name)) {
     return str2(input?.id) ? `Stop ${str2(input?.id)}` : "Stop job";
   }
+  if (/list_run_scripts$/i.test(name)) return "List run scripts";
+  if (/run_dev_script$/i.test(name)) {
+    return str2(input?.name) ? `Start ${str2(input?.name)}` : "Start Dev script";
+  }
+  if (/stop_dev_script$/i.test(name)) {
+    return str2(input?.name) ? `Stop ${str2(input?.name)}` : "Stop Dev script";
+  }
   if (isSubagentToolName(name)) {
     const desc = str2(input?.description);
     const sub = asRecord(input?.subagentType);
@@ -15211,6 +15276,16 @@ var init_clone_repo = __esm({
   }
 });
 
+// src/types/thread.ts
+function isUnclaimedRunScriptRequest(req) {
+  return Boolean(req && !req.claimedAt && !req.fulfilledAt && !req.error);
+}
+var init_thread = __esm({
+  "src/types/thread.ts"() {
+    "use strict";
+  }
+});
+
 // src/store/desktop-host.ts
 function desktopHostPidPath() {
   return (0, import_node_path43.join)(appDataDir(), "desktop-host.pid");
@@ -20529,12 +20604,13 @@ function formatLongRunningDirective(opts) {
     "- Loop Sideboard MCP `wait_for_job` (returns in ~45s). The desktop opens a `type=log` pane from wait/stop (and shell detached-job JSON) automatically \u2014 you may still `present_artifact` with `artifact_id=<id>` for a custom title. stillRunning \u2192 wait again. Shell fallback: the same helper with `wait <id>`.",
     "- Hanging, no useful output, or the wrong thing \u2192 `stop_job` (or the helper with `stop <id>`). Do not stop a pack/test/deploy that is clearly making progress.",
     "- Stay in the loop until stillRunning is false (or you stopped it). ok \u2192 finish the task. failed / stopped \u2192 read the log, fix or narrow the command, start once.",
-    "State: `.context/.sideboard/detached-jobs/<id>/` (local scratch). Full guide: `/long-running` (always available)."
+    "State: `.context/.sideboard/detached-jobs/<id>/` (local scratch). Full guide: `/long-running` (always available).",
+    "Project Dev / run scripts (`.sideboard` `[scripts.run.*]`, same as the desktop Dev button): use MCP `list_run_scripts` / `run_dev_script` / `stop_dev_script` \u2014 logs and Stop live in the thread UI. Do not detached-job or shell-spawn that same command."
   ].join("\n");
 }
 function formatLongRunningReminder(opts) {
   const invoke = formatDetachedJobInvoke(opts?.scriptPath);
-  return `Long jobs: \`${invoke} start <id> -- <cmd>\`, loop wait_for_job (or detached-job wait). The log pane updates from wait JSON; present_artifact type=log is optional. stop_job if hanging or wrong. Do not say you will let the user know later \u2014 stay in the turn.`;
+  return `Long jobs: \`${invoke} start <id> -- <cmd>\`, loop wait_for_job (or detached-job wait). The log pane updates from wait JSON; present_artifact type=log is optional. stop_job if hanging or wrong. Do not say you will let the user know later \u2014 stay in the turn. Project Dev button: list_run_scripts / run_dev_script / stop_dev_script (UI-connected \u2014 not detached-job).`;
 }
 function formatArtifactDirective() {
   return [
@@ -20546,7 +20622,7 @@ function formatArtifactDirective() {
   ].join("\n");
 }
 function formatUiReminder() {
-  return "Sideboard UI: markdown table is enough to read data; present_schema if they ask to edit/filter (even after markdown); present_files for the file manager. html fence or present_artifact, not both for the same document. type=log appends (same artifact_id, new lines only). ask_user only for a real multiple-choice (not hellos, \u201Cwhat next?\u201D, or after a review) \u2014 reply in chat. Do not say artifacts/CMS UI are unavailable.";
+  return "Sideboard UI: markdown table is enough to read data; present_schema if they ask to edit/filter (even after markdown); present_files for the file manager. html fence or present_artifact, not both for the same document. type=log appends (same artifact_id, new lines only). ask_user only for a real multiple-choice (not hellos, \u201Cwhat next?\u201D, or after a review) \u2014 reply in chat. Do not say artifacts/CMS UI are unavailable. Dev / preview: run_dev_script (same as the Dev button); stop_dev_script to stop.";
 }
 var import_node_fs50, import_node_path49, PR_GOAL_RE, GITHUB_TICKET_REF, KEYED_TICKET_REF;
 var init_instructions = __esm({
@@ -21478,6 +21554,7 @@ __export(orchestrator_exports, {
   LIGHT_RECONCILE_THROTTLE_MS: () => LIGHT_RECONCILE_THROTTLE_MS,
   LIVE_TURN_SPAWN_GRACE_MS: () => LIVE_TURN_SPAWN_GRACE_MS,
   Orchestrator: () => Orchestrator,
+  RUN_SCRIPT_DESKTOP_ADOPT_MS: () => RUN_SCRIPT_DESKTOP_ADOPT_MS,
   getOrchestrator: () => getOrchestrator,
   isPidAlive: () => isPidAlive,
   resolveOrchChildFollowUp: () => resolveOrchChildFollowUp,
@@ -21589,12 +21666,13 @@ async function startOrchestration(opts) {
   }
   return updated;
 }
-var import_node_events, import_node_fs55, LIVE_TURN_SPAWN_GRACE_MS, STALE_AGENT_PID_WAIT_MS, LIGHT_RECONCILE_THROTTLE_MS, Orchestrator, singleton;
+var import_node_events, import_node_crypto12, import_node_fs55, LIVE_TURN_SPAWN_GRACE_MS, RUN_SCRIPT_DESKTOP_ADOPT_MS, STALE_AGENT_PID_WAIT_MS, LIGHT_RECONCILE_THROTTLE_MS, Orchestrator, singleton;
 var init_orchestrator = __esm({
   "src/orchestrator/orchestrator.ts"() {
     "use strict";
     import_node_events = require("events");
     init_outbound_watch();
+    import_node_crypto12 = require("crypto");
     import_node_fs55 = require("fs");
     init_error_detail();
     init_run();
@@ -21612,6 +21690,7 @@ var init_orchestrator = __esm({
     init_history_cleanup();
     init_apply_into_main();
     init_clone_repo();
+    init_thread();
     init_message_parts();
     init_usage();
     init_thread_store();
@@ -21657,6 +21736,7 @@ var init_orchestrator = __esm({
     init_schedule_runner();
     init_coordinator_prompt();
     LIVE_TURN_SPAWN_GRACE_MS = 15e3;
+    RUN_SCRIPT_DESKTOP_ADOPT_MS = 2e4;
     STALE_AGENT_PID_WAIT_MS = 2500;
     LIGHT_RECONCILE_THROTTLE_MS = 1e4;
     Orchestrator = class {
@@ -21695,6 +21775,11 @@ var init_orchestrator = __esm({
       jobContinueNudged = /* @__PURE__ */ new Set();
       /** In-flight startDev per worktree run key — agent MCP + UI Start must not double-spawn. */
       startingDev = /* @__PURE__ */ new Map();
+      /**
+       * MCP/CLI poll budget while Electron main adopts `runScriptRequest`.
+       * Tests shorten this so a missing desktop does not wait 20s.
+       */
+      runScriptAdoptTimeoutMs = RUN_SCRIPT_DESKTOP_ADOPT_MS;
       maxConcurrent;
       runningCount = 0;
       constructor(opts) {
@@ -21864,6 +21949,58 @@ var init_orchestrator = __esm({
             this.armDrain(thread.id);
           }
         }
+        this.adoptPersistedRunScripts();
+      }
+      /**
+       * Adopt run-script start/stop persisted by MCP/CLI while this process owns
+       * live children (desktop host). Spawning in stdio leaves the Run tab on
+       * "Starting…" with no logs — `run_output` never reaches the renderer.
+       */
+      adoptPersistedRunScripts() {
+        if (!this.shouldOwnRunScripts()) return;
+        for (const thread of listThreads()) {
+          if (thread.status === "archived") continue;
+          const req = thread.runScriptRequest;
+          if (!isUnclaimedRunScriptRequest(req) || !req) continue;
+          const claimedAt = (/* @__PURE__ */ new Date()).toISOString();
+          const claimed = { ...req, claimedAt };
+          updateThread(thread.id, { runScriptRequest: claimed });
+          void this.applyRunScriptRequest(thread.id, claimed);
+        }
+      }
+      async applyRunScriptRequest(threadId, req) {
+        try {
+          if (req.op === "start") {
+            await this.startDev(threadId, req.scriptName ?? void 0);
+          } else {
+            await this.stopDev(threadId, req.scriptName ?? void 0);
+          }
+          const latest = readThread(threadId);
+          const current = latest?.runScriptRequest;
+          if (current?.requestId === req.requestId && !current.error) {
+            updateThread(threadId, {
+              runScriptRequest: {
+                ...current,
+                fulfilledAt: (/* @__PURE__ */ new Date()).toISOString()
+              }
+            });
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          const latest = readThread(threadId);
+          const current = latest?.runScriptRequest;
+          if (!current || current.requestId !== req.requestId) return;
+          updateThread(threadId, {
+            runScriptRequest: { ...current, error: message }
+          });
+        }
+      }
+      /**
+       * Same rule as agent-queue drain: MCP stdio must not own Electron children
+       * while Sideboard.app is alive.
+       */
+      shouldOwnRunScripts() {
+        return thisProcessShouldDrainAgentQueues();
       }
       /**
        * Mid-session: a worktree can sit at `running` after the agent process dies
@@ -22912,6 +23049,13 @@ var init_orchestrator = __esm({
             "No run script found for this worktree. Add [scripts.run.*] in the worktree\u2019s .sideboard/settings.toml or .conductor/settings.toml (or settings.local.toml on the main repo)."
           );
         }
+        if (!this.shouldOwnRunScripts()) {
+          const result = await this.requestDesktopRunScript(thread, "start", resolvedName);
+          if (!result) {
+            throw new Error("Desktop did not return a run script port.");
+          }
+          return result;
+        }
         const runKey = worktreeRunProcessKey(thread.worktreePath, resolvedName);
         const inFlight = this.startingDev.get(runKey);
         if (inFlight) return inFlight;
@@ -23034,8 +23178,65 @@ var init_orchestrator = __esm({
         });
         return { port: handle.port, scriptName: resolvedName, ports: handle.ports };
       }
-      stopDev(threadRef, scriptName) {
+      /**
+       * Persist a run-script intent for the desktop host (MCP/CLI while the board
+       * is alive). Polls until Electron main adopts and fulfills it.
+       */
+      async requestDesktopRunScript(thread, op, scriptName) {
+        const latest = readThread(thread.id) ?? thread;
+        const pending = latest.runScriptRequest;
+        const claimedAt = pending?.claimedAt;
+        const staleClaim = typeof claimedAt === "string" && Date.now() - Date.parse(claimedAt) > this.runScriptAdoptTimeoutMs;
+        const sameIntent = pending && pending.op === op && (pending.scriptName ?? null) === (scriptName ?? null) && !pending.error && !pending.fulfilledAt && !staleClaim;
+        const request = sameIntent ? pending : {
+          op,
+          scriptName: scriptName ?? null,
+          requestId: (0, import_node_crypto12.randomUUID)(),
+          requestedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        if (!sameIntent) {
+          updateThread(thread.id, { runScriptRequest: request });
+        }
+        return this.waitForDesktopRunScript(thread.id, request, op, scriptName);
+      }
+      async waitForDesktopRunScript(threadId, request, op, scriptName) {
+        const deadline = Date.now() + this.runScriptAdoptTimeoutMs;
+        while (Date.now() < deadline) {
+          const latest = readThread(threadId);
+          if (!latest) {
+            throw new Error("Thread disappeared while waiting for the desktop run script.");
+          }
+          const req = latest.runScriptRequest;
+          if (req?.requestId === request.requestId && req.error) {
+            throw new Error(req.error);
+          }
+          const shared = mergeWorktreeActiveRuns(threadsSharingWorktree(latest.worktreePath));
+          const run2 = scriptName ? shared.activeRuns.find((r) => r.scriptName === scriptName) : shared.activeRuns[0];
+          const fulfilled = req?.requestId === request.requestId && Boolean(req.fulfilledAt);
+          const requestGone = !req || req.requestId !== request.requestId;
+          if (op === "start") {
+            if (run2 && (fulfilled || requestGone || run2.startedAt >= request.requestedAt)) {
+              return { port: run2.port, scriptName: run2.scriptName, ports: run2.ports };
+            }
+            if (fulfilled && !run2) {
+              throw new Error("Desktop reported the run script started, but it is not active.");
+            }
+          } else {
+            const gone = scriptName ? !run2 : shared.activeRuns.length === 0;
+            if (fulfilled || gone) return null;
+          }
+          await new Promise((r) => setTimeout(r, 40));
+        }
+        throw new Error(
+          op === "start" ? "Desktop did not start the run script in time. Is Sideboard.app running this worktree?" : "Desktop did not stop the run script in time."
+        );
+      }
+      async stopDev(threadRef, scriptName) {
         const thread = this.requireThread(threadRef);
+        if (!this.shouldOwnRunScripts()) {
+          await this.requestDesktopRunScript(thread, "stop", scriptName);
+          return;
+        }
         const siblings = threadsSharingWorktree(thread.worktreePath);
         const shared = mergeWorktreeActiveRuns(siblings);
         if (scriptName) {
@@ -24029,7 +24230,7 @@ init_system_ca();
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_zod9 = require("zod");
-var import_node_crypto14 = require("crypto");
+var import_node_crypto15 = require("crypto");
 var import_node_path55 = require("path");
 init_orchestrator();
 init_worktree();
@@ -24456,7 +24657,7 @@ async function createGitHubIssue(input, opts) {
 init_fetch();
 
 // src/integrations/linear-oauth.ts
-var import_node_crypto12 = require("crypto");
+var import_node_crypto13 = require("crypto");
 var import_node_http2 = require("http");
 init_app_settings();
 init_fetch();
@@ -25730,6 +25931,23 @@ function mcpArchiveBlockedReason(thread) {
 
 // src/mcp/server.ts
 init_profile();
+
+// src/mcp/run-script-ref.ts
+init_chat_tabs();
+function resolveRunScriptThreadRef(ref) {
+  const explicit = ref?.trim();
+  if (explicit) return explicit;
+  const siblings = threadsSharingWorktree(process.cwd());
+  const thread = siblings[0];
+  if (!thread) {
+    throw new Error(
+      "No Sideboard thread for this cwd. Pass ref (thread id), or call from a worktree chat."
+    );
+  }
+  return thread.id;
+}
+
+// src/mcp/server.ts
 init_wait_for_turn();
 init_wait_for_job();
 init_message_parts();
@@ -27439,7 +27657,7 @@ init_worktree();
 init_paths();
 
 // src/board/board-pins.ts
-var import_node_crypto13 = require("crypto");
+var import_node_crypto14 = require("crypto");
 var import_node_fs56 = require("fs");
 var import_node_path53 = require("path");
 init_paths();
@@ -28161,13 +28379,73 @@ async function startMcpServer() {
     "Stop a detached job you started with detached-job.cjs when it is hanging, producing no useful output, buffering forever, or doing the wrong thing (wrong project, infinite watch, huge dump). Do not stop a pack/test/deploy that is clearly making progress. The type=log pane updates to status=failed with the last delta. Then decide the next step.",
     {
       id: import_zod9.z.string().describe("Detached job id (same kebab-case id passed to detached-job.cjs start)"),
-      reason: import_zod9.z.string().optional().describe("Why you are stopping (hanging, no progress, wrong output, already have the error)")
+      reason: import_zod9.z.string().optional().describe("Why you are stopping (hanging, no progress, wrong output, already have the answer)")
     },
     async ({ id, reason }) => {
       const result = await stopDetachedJob(process.cwd(), id, { reason });
       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. Worktree turns may omit ref (uses cwd).",
+    {
+      ref: import_zod9.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd).")
+    },
+    async ({ ref }) => {
+      try {
+        const threadRef = resolveRunScriptThreadRef(ref);
+        const scripts = orch.listThreadRunScripts(threadRef);
+        const active = orch.getActiveRuns(threadRef);
+        return mcpJson({ scripts, active, ref: threadRef });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: message }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "run_dev_script",
+    "Start a .sideboard/.conductor run script (same as the desktop Dev / play button). Logs and Stop appear in the thread UI \u2014 do not detached-job or shell-spawn the same command. Returns the allocated port. Worktree turns may omit ref (uses cwd). Omit name for the default script.",
+    {
+      ref: import_zod9.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
+      name: import_zod9.z.string().optional().describe("Script name from list_run_scripts (default script if omitted).")
+    },
+    async ({ ref, name }) => {
+      try {
+        const threadRef = resolveRunScriptThreadRef(ref);
+        const result = await orch.startDev(threadRef, name);
+        return mcpJson({
+          port: result.port,
+          scriptName: result.scriptName,
+          ports: result.ports,
+          url: `http://localhost:${result.port}`,
+          ref: threadRef
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: message }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "stop_dev_script",
+    "Stop a run script started with run_dev_script or the desktop Dev button (same as UI Stop). Omit name to stop all scripts on this worktree. Worktree turns may omit ref (uses cwd).",
+    {
+      ref: import_zod9.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
+      name: import_zod9.z.string().optional().describe("Script name to stop; omit to stop all active scripts.")
+    },
+    async ({ ref, name }) => {
+      try {
+        const threadRef = resolveRunScriptThreadRef(ref);
+        await orch.stopDev(threadRef, name);
+        return mcpJson({ ok: true, ref: threadRef, stopped: name ?? "all" });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: message }], isError: true };
+      }
+    }
+  );
   if (!worktreeProfile) {
     registerSlackTools(server);
     registerConnectedIssueVendorTools(server);
@@ -28288,7 +28566,7 @@ async function startMcpServer() {
           const ident = issue?.identifier ?? ref.trim();
           const attachments = issue ? [
             {
-              id: (0, import_node_crypto14.randomUUID)(),
+              id: (0, import_node_crypto15.randomUUID)(),
               name: issue.identifier,
               kind: "issue",
               content: [
@@ -28646,45 +28924,6 @@ async function startMcpServer() {
         }
       }
     );
-    server.tool(
-      "run_dev_script",
-      "Start a .sideboard/.conductor run script for a thread (default script if name omitted); returns port",
-      {
-        ref: import_zod9.z.string(),
-        name: import_zod9.z.string().optional()
-      },
-      async ({ ref, name }) => {
-        const result = await orch.startDev(ref, name);
-        return mcpJson({
-          port: result.port,
-          scriptName: result.scriptName,
-          ports: result.ports,
-          url: `http://localhost:${result.port}`
-        });
-      }
-    );
-    server.tool(
-      "list_run_scripts",
-      "List named run scripts available for a thread",
-      { ref: import_zod9.z.string() },
-      async ({ ref }) => {
-        const scripts = orch.listThreadRunScripts(ref);
-        const active = orch.getActiveRuns(ref);
-        return mcpJson({ scripts, active });
-      }
-    );
-    server.tool(
-      "stop_dev_script",
-      "Stop a running script for a thread (all scripts if name omitted)",
-      {
-        ref: import_zod9.z.string(),
-        name: import_zod9.z.string().optional()
-      },
-      async ({ ref, name }) => {
-        orch.stopDev(ref, name);
-        return { content: [{ type: "text", text: "ok" }] };
-      }
-    );
     server.tool(
       "run_setup",
       "Re-run workspace setup (Sideboard/Conductor settings, .cursor/worktrees.json, or script/setup). New worktrees already run this automatically.",