@sideboard-ai/core 0.1.43 → 0.1.44

package/dist/mcp/run-stdio.cjs

@@ -3235,8 +3235,9 @@ var init_coordinator_prompt = __esm({
       "Setup / run:",
       "- run_setup \u2014 re-run worktree setup",
       "- list_run_scripts / run_dev_script / stop_dev_script \u2014 start/stop named run scripts",
-      "Inspect / PRs:",
+      "Inspect / review / PRs:",
       "- get_diff \u2014 compact diff summary",
+      "- request_review \u2014 open a Review chat tab on a worktree thread (merge-readiness recommendation); then wait_for_turn / get_turn_result on the returned id",
       "- Ask the worktree agent via send_to_thread to open a draft PR with `gh pr create --draft -R <origin-owner/name>` (workspace `github:` slug / that worktree's origin \u2014 never upstream). Do not open PRs from the orchestrator yourself.",
       "Human-only (do not attempt): merge, ready-for-review land, purge_thread.",
       "Thread links in replies: when mentioning a chat/thread for the user, include a markdown link `[Title](sideboard://thread/<id>)` using the full id (or the link field from create_thread / list_threads). Sideboard renders these as clickable opens.",
@@ -5690,10 +5691,10 @@ __export(cursor_recover_exports, {
 function recoverFinishedCursorRun(opts) {
   const agentId = opts.agentId.trim();
   if (!agentId) return null;
-  const runsPath = (0, import_node_path23.join)(appDataDir(), "cursor-sdk-store", "runs.ndjson");
-  if (!(0, import_node_fs24.existsSync)(runsPath)) return null;
+  const runsPath = (0, import_node_path24.join)(appDataDir(), "cursor-sdk-store", "runs.ndjson");
+  if (!(0, import_node_fs25.existsSync)(runsPath)) return null;
   try {
-    const lines = (0, import_node_fs24.readFileSync)(runsPath, "utf8").split("\n");
+    const lines = (0, import_node_fs25.readFileSync)(runsPath, "utf8").split("\n");
     let best = null;
     for (const line of lines) {
       const trimmed = line.trim();
@@ -5719,12 +5720,12 @@ function recoverFinishedCursorRun(opts) {
     return null;
   }
 }
-var import_node_fs24, import_node_path23;
+var import_node_fs25, import_node_path24;
 var init_cursor_recover = __esm({
   "src/agents/cursor-recover.ts"() {
     "use strict";
-    import_node_fs24 = require("fs");
-    import_node_path23 = require("path");
+    import_node_fs25 = require("fs");
+    import_node_path24 = require("path");
     init_paths();
   }
 });
@@ -5733,11 +5734,11 @@ var init_cursor_recover = __esm({
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_zod = require("zod");
-var import_node_path24 = require("path");
+var import_node_path25 = require("path");
 
 // src/orchestrator/orchestrator.ts
 var import_node_events = require("events");
-var import_node_fs25 = require("fs");
+var import_node_fs26 = require("fs");
 init_error_detail();
 
 // src/agents/spawn.ts
@@ -7182,6 +7183,58 @@ function forkChatTab(input) {
   });
 }
 
+// src/review/request-review.ts
+var import_node_crypto3 = require("crypto");
+var import_node_fs19 = require("fs");
+var import_node_path18 = require("path");
+init_global_workspace();
+init_thread_store();
+var REVIEW_REQUEST_PATH = ".sideboard/attachments/Review request.md";
+var REVIEW_REQUEST_NAME = "Review request.md";
+var REVIEW_REQUEST_PREFILL = `Please review the changes in this workspace and recommend whether they are ready to merge.
+
+Start with a **Recommendation**: Approve, Approve with nits, Request changes, or Needs more information \u2014 and say why in 1\u20133 sentences. Then list blocking findings vs nits (findings may be empty).`;
+function buildReviewRequestAttachment(content) {
+  return {
+    id: (0, import_node_crypto3.randomUUID)(),
+    name: REVIEW_REQUEST_NAME,
+    kind: "file",
+    path: REVIEW_REQUEST_PATH,
+    content
+  };
+}
+function readExistingReviewRequestFile(worktreePath) {
+  const abs = (0, import_node_path18.join)(worktreePath, REVIEW_REQUEST_PATH);
+  if (!(0, import_node_fs19.existsSync)(abs)) return null;
+  try {
+    const content = (0, import_node_fs19.readFileSync)(abs, "utf8");
+    return content.trim() ? content : null;
+  } catch {
+    return null;
+  }
+}
+async function requestReview(threadRef, send) {
+  const from = findThreadByRef(threadRef);
+  if (!from) throw new Error(`Thread not found: ${threadRef}`);
+  if (isOrchestratorThread(from)) {
+    throw new Error(
+      "request_review targets a worktree agent thread (not the orchestrator). Pass a child/worktree thread ref."
+    );
+  }
+  if (from.status === "archived") {
+    throw new Error(`Thread is archived: ${from.id}`);
+  }
+  const existing = readExistingReviewRequestFile(from.worktreePath);
+  const attachments = existing ? [buildReviewRequestAttachment(existing)] : [];
+  const tab = createChatTab({
+    fromThreadId: from.id,
+    title: "Review",
+    attachments
+  });
+  const started = await send(tab.id, REVIEW_REQUEST_PREFILL);
+  return { tab: started, from };
+}
+
 // src/threads/fork-worktree.ts
 init_thread_store();
 function requireThread2(idOrRef) {
@@ -7215,20 +7268,20 @@ async function forkThreadWorktree(input, onSetupLine) {
 
 // src/threads/adopt.ts
 var import_node_child_process = require("child_process");
-var import_node_fs19 = require("fs");
+var import_node_fs20 = require("fs");
 var import_node_os8 = require("os");
-var import_node_path18 = require("path");
+var import_node_path19 = require("path");
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
 init_worktree();
 init_thread_store();
-var CONDUCTOR_APP_SUPPORT = (0, import_node_path18.join)(
+var CONDUCTOR_APP_SUPPORT = (0, import_node_path19.join)(
   process.env.HOME ?? "",
   "Library",
   "Application Support",
   "com.conductor.app"
 );
-var CONDUCTOR_DB = (0, import_node_path18.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
-var CURSOR_SDK_STORE = (0, import_node_path18.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+var CONDUCTOR_DB = (0, import_node_path19.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
+var CURSOR_SDK_STORE = (0, import_node_path19.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
 function mapAgentType(raw) {
   if (!raw) return null;
   const v = raw.toLowerCase();
@@ -7240,21 +7293,21 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !(0, import_node_fs19.existsSync)(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !(0, import_node_fs20.existsSync)(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
   try {
-    hashes = (0, import_node_fs19.readdirSync)(CURSOR_SDK_STORE);
+    hashes = (0, import_node_fs20.readdirSync)(CURSOR_SDK_STORE);
   } catch {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = (0, import_node_path18.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!(0, import_node_fs19.existsSync)(agentsFile)) continue;
+    const agentsFile = (0, import_node_path19.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!(0, import_node_fs20.existsSync)(agentsFile)) continue;
     let text;
     try {
-      text = (0, import_node_fs19.readFileSync)(agentsFile, "utf8");
+      text = (0, import_node_fs20.readFileSync)(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -7278,7 +7331,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!(0, import_node_fs19.existsSync)(input.worktreePath)) {
+  if (!(0, import_node_fs20.existsSync)(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -7302,18 +7355,18 @@ async function adoptThread(input) {
   return thread;
 }
 function listConductorWorkspaces() {
-  if (!(0, import_node_fs19.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs20.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs19.mkdtempSync)((0, import_node_path18.join)((0, import_node_os8.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path18.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs20.mkdtempSync)((0, import_node_path19.join)((0, import_node_os8.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path19.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs19.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs20.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs19.existsSync)(src)) {
+      if ((0, import_node_fs20.existsSync)(src)) {
         try {
-          (0, import_node_fs19.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs20.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -7389,22 +7442,22 @@ function listConductorWorkspaces() {
       db.close();
     }
   } finally {
-    (0, import_node_fs19.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs20.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!(0, import_node_fs19.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs20.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs19.mkdtempSync)((0, import_node_path18.join)((0, import_node_os8.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path18.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs20.mkdtempSync)((0, import_node_path19.join)((0, import_node_os8.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path19.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs19.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs20.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs19.existsSync)(src)) {
+      if ((0, import_node_fs20.existsSync)(src)) {
         try {
-          (0, import_node_fs19.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs20.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -7422,7 +7475,7 @@ function importConductorWorkspace(workspaceId) {
       ).get(workspaceId);
       if (!row) throw new Error(`Conductor workspace not found: ${workspaceId}`);
       const worktreePath = String(row.workspacePath);
-      if (!(0, import_node_fs19.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs20.existsSync)(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -7485,7 +7538,7 @@ function importConductorWorkspace(workspaceId) {
       db.close();
     }
   } finally {
-    (0, import_node_fs19.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs20.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 async function importConductorWorkspaceAsync(workspaceId) {
@@ -7496,12 +7549,12 @@ async function importConductorWorkspaceAsync(workspaceId) {
 init_worktree();
 
 // src/diff/diff.ts
-var import_node_fs20 = require("fs");
-var import_node_path19 = require("path");
+var import_node_fs21 = require("fs");
+var import_node_path20 = require("path");
 init_run();
 init_worktree();
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs20.existsSync)(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !(0, import_node_fs21.existsSync)(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -7509,7 +7562,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs20.existsSync)(worktreePath)) {
+  if (!worktreePath || !(0, import_node_fs21.existsSync)(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -7941,8 +7994,8 @@ var DEFAULT_UPLOAD_MAX_BYTES = 5e7;
 function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-  const abs = (0, import_node_path19.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs20.statSync)(abs);
+  const abs = (0, import_node_path20.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs21.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
@@ -7951,7 +8004,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = (0, import_node_fs20.readFileSync)(abs);
+  const buf = (0, import_node_fs21.readFileSync)(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -7961,12 +8014,12 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = (0, import_node_path19.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs20.statSync)(abs);
+  const abs = (0, import_node_path20.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs21.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = (0, import_node_fs20.readFileSync)(abs);
+  const buf = (0, import_node_fs21.readFileSync)(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -8009,9 +8062,9 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = (0, import_node_path19.join)(worktreePath, relativePath);
-  (0, import_node_fs20.mkdirSync)((0, import_node_path19.dirname)(abs), { recursive: true });
-  (0, import_node_fs20.writeFileSync)(abs, content, "utf8");
+  const abs = (0, import_node_path20.join)(worktreePath, relativePath);
+  (0, import_node_fs21.mkdirSync)((0, import_node_path20.dirname)(abs), { recursive: true });
+  (0, import_node_fs21.writeFileSync)(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getDiffSummary(worktreePath, repoPath, opts) {
@@ -8190,9 +8243,9 @@ async function confirmLand(thread, opts) {
 }
 
 // src/skills/discover.ts
-var import_node_fs21 = require("fs");
+var import_node_fs22 = require("fs");
 var import_node_os9 = require("os");
-var import_node_path20 = require("path");
+var import_node_path21 = require("path");
 function toCommand(name) {
   return name.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -8224,7 +8277,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = (0, import_node_fs21.readFileSync)(skillMd, "utf8");
+    const content = (0, import_node_fs22.readFileSync)(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -8243,19 +8296,19 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!(0, import_node_fs21.existsSync)(dir)) return;
+  if (!(0, import_node_fs22.existsSync)(dir)) return;
   let entries;
   try {
-    entries = (0, import_node_fs21.readdirSync)(dir);
+    entries = (0, import_node_fs22.readdirSync)(dir);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const skillMd = (0, import_node_path20.join)(dir, entry, "SKILL.md");
-    if (!(0, import_node_fs21.existsSync)(skillMd)) continue;
+    const skillMd = (0, import_node_path21.join)(dir, entry, "SKILL.md");
+    if (!(0, import_node_fs22.existsSync)(skillMd)) continue;
     try {
-      if (!(0, import_node_fs21.statSync)(skillMd).isFile()) continue;
+      if (!(0, import_node_fs22.statSync)(skillMd).isFile()) continue;
     } catch {
       continue;
     }
@@ -8264,24 +8317,24 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!(0, import_node_fs21.existsSync)(pluginsRoot)) return;
+  if (!(0, import_node_fs22.existsSync)(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
     try {
-      entries = (0, import_node_fs21.readdirSync)(dir);
+      entries = (0, import_node_fs22.readdirSync)(dir);
     } catch {
       return;
     }
     if (lookingForSkillsDir && entries.includes("SKILL.md")) {
-      const skill = readSkill((0, import_node_path20.join)(dir, "SKILL.md"), "cli");
+      const skill = readSkill((0, import_node_path21.join)(dir, "SKILL.md"), "cli");
       if (skill) out.push(skill);
     }
     for (const entry of entries) {
       if (entry === "node_modules" || entry === ".git") continue;
-      const full = (0, import_node_path20.join)(dir, entry);
+      const full = (0, import_node_path21.join)(dir, entry);
       try {
-        if (!(0, import_node_fs21.statSync)(full).isDirectory()) continue;
+        if (!(0, import_node_fs22.statSync)(full).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -8299,17 +8352,17 @@ function discoverSkills(worktreePath) {
   const home = (0, import_node_os9.homedir)();
   const collected = [];
   for (const rel of [".claude/skills", ".cursor/skills", ".sideboard/skills", ".brightsy/skills", "skills"]) {
-    scanSkillsDir((0, import_node_path20.join)(worktreePath, rel), "workspace", collected);
+    scanSkillsDir((0, import_node_path21.join)(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    (0, import_node_path20.join)(home, ".claude/skills"),
-    (0, import_node_path20.join)(home, ".cursor/skills"),
-    (0, import_node_path20.join)(home, ".sideboard/skills"),
-    (0, import_node_path20.join)(home, ".brightsy/skills")
+    (0, import_node_path21.join)(home, ".claude/skills"),
+    (0, import_node_path21.join)(home, ".cursor/skills"),
+    (0, import_node_path21.join)(home, ".sideboard/skills"),
+    (0, import_node_path21.join)(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills((0, import_node_path20.join)(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills((0, import_node_path21.join)(home, ".claude/plugins"), collected);
   const rank = { workspace: 0, user: 1, cli: 2 };
   const byCommand = /* @__PURE__ */ new Map();
   for (const skill of collected) {
@@ -8321,7 +8374,7 @@ function discoverSkills(worktreePath) {
   return [...byCommand.values()].sort((a, b) => a.command.localeCompare(b.command));
 }
 function readSkillBody(skillPath, maxChars = 12e3) {
-  const raw = (0, import_node_fs21.readFileSync)(skillPath, "utf8");
+  const raw = (0, import_node_fs22.readFileSync)(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -8414,9 +8467,9 @@ function expandComposerPrompt(worktreePath, prompt, opts) {
 }
 
 // src/composer/stage-files.ts
-var import_node_fs22 = require("fs");
-var import_node_path21 = require("path");
-var import_node_crypto3 = require("crypto");
+var import_node_fs23 = require("fs");
+var import_node_path22 = require("path");
+var import_node_crypto4 = require("crypto");
 var IMAGE_EXTENSIONS2 = /* @__PURE__ */ new Set([
   "png",
   "jpg",
@@ -8445,7 +8498,7 @@ var ATTACHMENTS_GITIGNORE = `# Sideboard review / composer attachments (local on
 var MAX_INLINE_BYTES = 4e5;
 var MAX_PREVIEW_BYTES = 5e6;
 function fileExtension(filePath) {
-  const base = (0, import_node_path21.basename)(filePath).toLowerCase();
+  const base = (0, import_node_path22.basename)(filePath).toLowerCase();
   return base.includes(".") ? base.split(".").pop() || "" : "";
 }
 function isImageFilePath(filePath) {
@@ -8455,24 +8508,24 @@ function imageMimeType(filePath) {
   return IMAGE_MIME_BY_EXT[fileExtension(filePath)] || "image/png";
 }
 function ensureAttachmentsDir(worktreePath) {
-  const dir = (0, import_node_path21.join)(worktreePath, ATTACHMENTS_DIR);
-  (0, import_node_fs22.mkdirSync)(dir, { recursive: true });
-  const gi = (0, import_node_path21.join)(dir, ".gitignore");
-  if (!(0, import_node_fs22.existsSync)(gi)) {
-    (0, import_node_fs22.writeFileSync)(gi, ATTACHMENTS_GITIGNORE, "utf8");
+  const dir = (0, import_node_path22.join)(worktreePath, ATTACHMENTS_DIR);
+  (0, import_node_fs23.mkdirSync)(dir, { recursive: true });
+  const gi = (0, import_node_path22.join)(dir, ".gitignore");
+  if (!(0, import_node_fs23.existsSync)(gi)) {
+    (0, import_node_fs23.writeFileSync)(gi, ATTACHMENTS_GITIGNORE, "utf8");
   }
   return dir;
 }
 function uniqueAttachmentName(dir, originalName) {
   const safe = originalName.replace(/[/\\]/g, "_") || "file";
-  if (!(0, import_node_fs22.existsSync)((0, import_node_path21.join)(dir, safe))) return safe;
-  const ext = (0, import_node_path21.extname)(safe);
+  if (!(0, import_node_fs23.existsSync)((0, import_node_path22.join)(dir, safe))) return safe;
+  const ext = (0, import_node_path22.extname)(safe);
   const stem = ext ? safe.slice(0, -ext.length) : safe;
   for (let i = 1; i < 1e4; i++) {
     const candidate = `${stem}-${i}${ext}`;
-    if (!(0, import_node_fs22.existsSync)((0, import_node_path21.join)(dir, candidate))) return candidate;
+    if (!(0, import_node_fs23.existsSync)((0, import_node_path22.join)(dir, candidate))) return candidate;
   }
-  return `${stem}-${(0, import_node_crypto3.randomUUID)()}${ext}`;
+  return `${stem}-${(0, import_node_crypto4.randomUUID)()}${ext}`;
 }
 function previewDataUrlFromBuf(filePath, buf) {
   if (!isImageFilePath(filePath)) return void 0;
@@ -8484,7 +8537,7 @@ function attachmentFromBuffer(name, buf, opts) {
   if (isImageFilePath(name)) {
     const pathHint = opts.path ? `\`${opts.path}\`` : opts.sourceLabel || name;
     return {
-      id: (0, import_node_crypto3.randomUUID)(),
+      id: (0, import_node_crypto4.randomUUID)(),
       name,
       kind: "file",
       path: opts.path,
@@ -8497,7 +8550,7 @@ function attachmentFromBuffer(name, buf, opts) {
   }
   if (buf.length > MAX_INLINE_BYTES) {
     return {
-      id: (0, import_node_crypto3.randomUUID)(),
+      id: (0, import_node_crypto4.randomUUID)(),
       name,
       kind: "file",
       path: opts.path,
@@ -8506,7 +8559,7 @@ function attachmentFromBuffer(name, buf, opts) {
   }
   if (buf.includes(0)) {
     return {
-      id: (0, import_node_crypto3.randomUUID)(),
+      id: (0, import_node_crypto4.randomUUID)(),
       name,
       kind: "file",
       path: opts.path,
@@ -8514,7 +8567,7 @@ function attachmentFromBuffer(name, buf, opts) {
     };
   }
   return {
-    id: (0, import_node_crypto3.randomUUID)(),
+    id: (0, import_node_crypto4.randomUUID)(),
     name,
     kind: "file",
     path: opts.path,
@@ -8526,19 +8579,19 @@ function stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
   const dir = ensureAttachmentsDir(worktreePath);
   const out = [];
   for (const abs of absolutePaths) {
-    const originalName = (0, import_node_path21.basename)(abs);
+    const originalName = (0, import_node_path22.basename)(abs);
     try {
-      const st = (0, import_node_fs22.statSync)(abs);
+      const st = (0, import_node_fs23.statSync)(abs);
       if (!st.isFile()) continue;
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = (0, import_node_path21.join)(dir, name);
-      (0, import_node_fs22.copyFileSync)(abs, destAbs);
+      const destAbs = (0, import_node_path22.join)(dir, name);
+      (0, import_node_fs23.copyFileSync)(abs, destAbs);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
-      const buf = (0, import_node_fs22.readFileSync)(destAbs);
+      const buf = (0, import_node_fs23.readFileSync)(destAbs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
-        id: (0, import_node_crypto3.randomUUID)(),
+        id: (0, import_node_crypto4.randomUUID)(),
         name: originalName,
         kind: "file",
         content: `(could not attach ${abs}: ${err instanceof Error ? err.message : String(err)})`
@@ -8556,13 +8609,13 @@ function stageBuffersAsAttachments(worktreePath, buffers) {
     try {
       const buf = Buffer.from(item.dataBase64, "base64");
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = (0, import_node_path21.join)(dir, name);
-      (0, import_node_fs22.writeFileSync)(destAbs, buf);
+      const destAbs = (0, import_node_path22.join)(dir, name);
+      (0, import_node_fs23.writeFileSync)(destAbs, buf);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
       out.push(attachmentFromBuffer(name, buf, { path: rel }));
     } catch (err) {
       out.push({
-        id: (0, import_node_crypto3.randomUUID)(),
+        id: (0, import_node_crypto4.randomUUID)(),
         name: originalName,
         kind: "file",
         content: `(could not attach ${originalName}: ${err instanceof Error ? err.message : String(err)})`
@@ -8576,23 +8629,23 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
   for (const rel of relativePaths) {
     if (!rel || rel.includes("..") || rel.startsWith("/")) {
       out.push({
-        id: (0, import_node_crypto3.randomUUID)(),
-        name: (0, import_node_path21.basename)(rel) || "file",
+        id: (0, import_node_crypto4.randomUUID)(),
+        name: (0, import_node_path22.basename)(rel) || "file",
         kind: "file",
         content: `(invalid path: ${rel})`
       });
       continue;
     }
-    const name = (0, import_node_path21.basename)(rel);
+    const name = (0, import_node_path22.basename)(rel);
     try {
-      const abs = (0, import_node_path21.join)(worktreePath, rel);
-      const st = (0, import_node_fs22.statSync)(abs);
+      const abs = (0, import_node_path22.join)(worktreePath, rel);
+      const st = (0, import_node_fs23.statSync)(abs);
       if (!st.isFile()) continue;
-      const buf = (0, import_node_fs22.readFileSync)(abs);
+      const buf = (0, import_node_fs23.readFileSync)(abs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
-        id: (0, import_node_crypto3.randomUUID)(),
+        id: (0, import_node_crypto4.randomUUID)(),
         name,
         kind: "file",
         content: `(could not read ${rel}: ${err instanceof Error ? err.message : String(err)})`
@@ -8603,8 +8656,8 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
 }
 
 // src/agents/instructions.ts
-var import_node_fs23 = require("fs");
-var import_node_path22 = require("path");
+var import_node_fs24 = require("fs");
+var import_node_path23 = require("path");
 init_worktree_labels();
 function normPath2(p) {
   return p.replace(/\/+$/, "");
@@ -8743,11 +8796,11 @@ function loadAgentInstructions(worktreePath, agent) {
   const out = [];
   for (const rel of candidates) {
     if (seen.has(rel)) continue;
-    const abs = (0, import_node_path22.join)(worktreePath, rel);
-    if (!(0, import_node_fs23.existsSync)(abs)) continue;
+    const abs = (0, import_node_path23.join)(worktreePath, rel);
+    if (!(0, import_node_fs24.existsSync)(abs)) continue;
     try {
-      if (!(0, import_node_fs23.statSync)(abs).isFile()) continue;
-      let content = (0, import_node_fs23.readFileSync)(abs, "utf8");
+      if (!(0, import_node_fs24.statSync)(abs).isFile()) continue;
+      let content = (0, import_node_fs24.readFileSync)(abs, "utf8");
       if (!content.trim()) continue;
       if (content.length > MAX_CHARS_PER_FILE) {
         content = `${content.slice(0, MAX_CHARS_PER_FILE)}
@@ -8897,7 +8950,7 @@ var Orchestrator = class {
         }
         continue;
       }
-      if (!(0, import_node_fs25.existsSync)(thread.worktreePath)) {
+      if (!(0, import_node_fs26.existsSync)(thread.worktreePath)) {
         setStatus(thread.id, "broken", "Worktree missing on disk");
         this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
         continue;
@@ -9795,6 +9848,15 @@ var Orchestrator = class {
   setAutonomy(threadRef, autonomy) {
     return this.setThreadOptions(threadRef, { autonomy });
   }
+  /**
+   * Open a Review chat tab on a worktree thread (same as the desktop Review button)
+   * and send the merge-readiness prefill.
+   */
+  async requestReview(threadRef) {
+    const { tab } = await requestReview(threadRef, (ref, prompt) => this.send(ref, prompt));
+    this.emit({ type: "status_changed", threadId: tab.id, status: tab.status });
+    return tab;
+  }
   setThreadOptions(threadRef, patch) {
     const thread = this.requireThread(threadRef);
     const next = {};
@@ -9919,7 +9981,7 @@ var Orchestrator = class {
       updateThread(thread.id, { worktreePath: globalAgentCwd2() });
       return setStatus(thread.id, "idle");
     }
-    if (!(0, import_node_fs25.existsSync)(thread.worktreePath)) {
+    if (!(0, import_node_fs26.existsSync)(thread.worktreePath)) {
       const { createThreadWorktree: createThreadWorktree2 } = await Promise.resolve().then(() => (init_worktree(), worktree_exports));
       const { execa: execa7 } = await import("execa");
       const slug = thread.worktreePath.split("/").pop();
@@ -10137,7 +10199,7 @@ async function startMcpServer() {
     async () => {
       const threads = orch.getThreads(true);
       const lines = threads.map((t) => {
-        const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path24.basename)(t.repoPath) || t.repoPath;
+        const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path25.basename)(t.repoPath) || t.repoPath;
         return `${t.id.slice(0, 8)}  ${t.status.padEnd(9)}  ${t.agent.padEnd(8)}  ${repo}  ${t.sourceType}:${t.sourceRef}  ${t.title}  sideboard://thread/${t.id}${t.devPort ? `  http://localhost:${t.devPort}` : ""}`;
       });
       return {
@@ -10480,6 +10542,34 @@ async function startMcpServer() {
       };
     }
   );
+  server.tool(
+    "request_review",
+    "Start a merge-readiness Review on a worktree agent thread (same as the desktop Review button). Opens a new Review chat tab, optionally attaches .sideboard/attachments/Review request.md when present, and asks for Approve / Approve with nits / Request changes / Needs more information. Pass a worktree thread ref \u2014 not the orchestrator. Then wait_for_turn / get_turn_result on the returned review tab id.",
+    { ref: import_zod.z.string().describe("Worktree thread id/ref to review") },
+    async ({ ref }) => {
+      try {
+        const tab = await orch.requestReview(ref);
+        const from = orch.getThread(ref);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                id: tab.id,
+                title: tab.title,
+                status: tab.status,
+                fromThreadId: from?.id ?? ref,
+                link: `sideboard://thread/${tab.id}`
+              })
+            }
+          ]
+        };
+      } 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 for a thread (default script if name omitted); returns port",