@sideboard-ai/core 0.1.151 → 0.1.153

package/dist/{chunk-6H4TJ5TA.js → chunk-KMNODRWF.js}

@@ -24,18 +24,19 @@ import {
   stripBrightsyNdjsonNoise,
   sumUsageList,
   toolDescription
-} from "./chunk-UIS7BVCX.js";
+} from "./chunk-QZEZXYVV.js";
 import {
+  SLACK_REPLY_FORMATTING,
   addWorkspace,
-  ensureWorkspace,
-  removeWorkspace,
-  syncWorkspacesFromThreads
-} from "./chunk-HWZWBJWL.js";
-import {
   assertOrchestratorCapableAgent,
   attachmentsFromWorktreePaths,
   coerceOrchestratorAgent,
+  coordinatorSystemPrompt,
+  coordinatorTurnReminder,
   createGlobalChat,
+  enrichWorkspacesWithGithub,
+  ensureGlobalCoordinatorCwd,
+  ensureWorkspace,
   healOrchestrationSoccerTitles,
   isCloudCoordinatorThread,
   isGlobalRepoPath,
@@ -45,16 +46,11 @@ import {
   isSlackCoordinatorThread,
   orchestratorSessionPoisonedByBuiltins,
   persistPendingFileAttachments,
+  removeWorkspace,
   stageAbsolutePathsAsAttachments,
-  stageBuffersAsAttachments
-} from "./chunk-ADCEGG4A.js";
-import {
-  SLACK_REPLY_FORMATTING,
-  coordinatorSystemPrompt,
-  coordinatorTurnReminder,
-  enrichWorkspacesWithGithub,
-  ensureGlobalCoordinatorCwd
-} from "./chunk-77MP647F.js";
+  stageBuffersAsAttachments,
+  syncWorkspacesFromThreads
+} from "./chunk-2F63IMCL.js";
 import {
   addPrStackLayer,
   allocateTeamName,
@@ -102,7 +98,7 @@ import {
   withRepoGitLock,
   worktreeDisplayLabelForGroup,
   worktreeNameFromPath
-} from "./chunk-GE7M3QTE.js";
+} from "./chunk-LQMFCS54.js";
 import {
   ATTACHMENTS_DIR,
   LEGACY_ATTACHMENTS_DIR
@@ -143,13 +139,13 @@ import {
   saveAppSettings,
   updateAdvancedSettings,
   writeSecureJson
-} from "./chunk-4XNSGDXE.js";
+} from "./chunk-3BWVOUQG.js";
 import {
   stripNestedElectronEnv
 } from "./chunk-4TR3HZFT.js";
 import {
   releaseCaffeinateHoldForThread
-} from "./chunk-DCOZABNT.js";
+} from "./chunk-AO35MGOE.js";
 import {
   writePrivateFile
 } from "./chunk-JT7R45JB.js";
@@ -164,7 +160,7 @@ import {
   updateThread,
   withThreadLock,
   writeThread
-} from "./chunk-TUGKX5BD.js";
+} from "./chunk-7UURXPKD.js";
 import {
   appDataDir,
   findConventionSetup,
@@ -174,9 +170,10 @@ import {
   sideboardReposDir,
   sideboardWorkspacesDir,
   threadLivePath,
+  threadsDir,
   workspaceSettingsSourceLabel,
   worktreesRoot
-} from "./chunk-QZQEXME2.js";
+} from "./chunk-EFVFB2AH.js";
 import {
   ensureWorktreeSideboardIgnored
 } from "./chunk-QQKDGPUI.js";
@@ -460,7 +457,7 @@ async function continueSourceThread(threadId, prompt) {
       await continueOnReply(threadId, prompt);
       return;
     }
-    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-DPTRBKEH.js");
+    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-5PSHBLP6.js");
     await getOrchestrator2().send(threadId, prompt);
   } catch {
   }
@@ -720,7 +717,7 @@ async function pollSlackOutboundWatches(opts) {
 }
 
 // src/orchestrator/orchestrator.ts
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 
 // src/agents/spawn.ts
 import { createInterface } from "readline";
@@ -740,9 +737,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-IB2CCEJF.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-2BRRKSDN.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-LWYUZAXR.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-7FHKCWXB.js");
     ensureGlobalCoordinatorCwd2(
       isOrchestratorThread(thread) ? { orchestratorThreadId: thread.id } : void 0
     );
@@ -1619,7 +1616,7 @@ File: src/client/frontends/desktop/core/UserData.ts
 
 ## Growing the rules
 
-If a blocking issue is a missing or ambiguous repo rule that will recur, add one sentence to \`.claude/skills/review/SKILL.md\` (create the skill if it is missing \u2014 that is allowed and should be committed). Do not only patch this diff when the same miss will happen again. Do not write new skills under \`.sideboard/skills/\`. Do not use \`.sideboard/review.md\` for new notes.
+If a blocking issue is a missing or ambiguous repo rule that will recur, add one sentence to \`.claude/skills/review/SKILL.md\` when that skill already exists. Otherwise write it to \`.context/review.md\` (do not create a review skill). Do not only patch this diff when the same miss will happen again. Do not write new skills under \`.sideboard/skills/\`.
 `;
 var REVIEW_SKILL_PATH = ".claude/skills/review/SKILL.md";
 var REVIEW_SKILL_NAME = "review";
@@ -1645,6 +1642,7 @@ function wrapReviewSkillMarkdown(body) {
 // src/review/request-review.ts
 var REPO_REVIEW_PATH = ".sideboard/review.md";
 var REPO_REVIEW_NAME = "review.md";
+var CONTEXT_REVIEW_PATH = ".context/review.md";
 var REVIEW_REQUEST_PATH = `${ATTACHMENTS_DIR}/Review request.md`;
 var LEGACY_REVIEW_REQUEST_PATH = `${LEGACY_ATTACHMENTS_DIR}/Review request.md`;
 var REVIEW_REQUEST_NAME = "Review request.md";
@@ -1691,41 +1689,64 @@ function skillGuidelines(content, source) {
     source
   };
 }
-function ensureReviewSkillFile(worktreePath) {
-  const abs = join4(worktreePath, REVIEW_SKILL_PATH);
-  const existing = readTextIfPresent(abs);
-  if (existing) {
-    return { path: REVIEW_SKILL_PATH, content: existing, wrote: false };
-  }
-  const fromRepo = readTextIfPresent(join4(worktreePath, REPO_REVIEW_PATH));
-  const fromLocal = readLocalGuidelines(worktreePath)?.content ?? null;
-  const content = wrapReviewSkillMarkdown(fromRepo ?? fromLocal ?? REVIEW_REQUEST_TEMPLATE);
+function contextGuidelines(content, source) {
+  return {
+    path: CONTEXT_REVIEW_PATH,
+    name: REPO_REVIEW_NAME,
+    content,
+    source
+  };
+}
+function writeContextGuidelines(worktreePath, content) {
+  const abs = join4(worktreePath, CONTEXT_REVIEW_PATH);
   mkdirSync(dirname(abs), { recursive: true });
-  writeFileSync(abs, content, "utf8");
-  return { path: REVIEW_SKILL_PATH, content, wrote: true };
+  const body = content.endsWith("\n") ? content : `${content}
+`;
+  writeFileSync(abs, body, "utf8");
+  return body;
 }
-function resolveReviewGuidelines(worktreePath) {
+function readSideboardReview(worktreePath, repoPath) {
+  const fromWorktree = readTextIfPresent(join4(worktreePath, REPO_REVIEW_PATH));
+  if (fromWorktree) return fromWorktree;
+  const repo = repoPath?.replace(/\/+$/, "");
+  const wt = worktreePath.replace(/\/+$/, "");
+  if (!repo || repo === wt) return null;
+  return readTextIfPresent(join4(repo, REPO_REVIEW_PATH));
+}
+function ensureReviewGuidelinesFile(worktreePath, repoPath) {
   const skillContent = readTextIfPresent(join4(worktreePath, REVIEW_SKILL_PATH));
-  if (skillContent) return skillGuidelines(skillContent, "skill");
-  const local = readLocalGuidelines(worktreePath);
-  if (local) {
-    return {
-      path: local.path,
-      name: REVIEW_REQUEST_NAME,
-      content: local.content,
-      source: "local"
-    };
+  if (skillContent) {
+    return { ...skillGuidelines(skillContent, "skill"), wrote: false };
+  }
+  const contextContent = readTextIfPresent(join4(worktreePath, CONTEXT_REVIEW_PATH));
+  if (contextContent && !shouldRefreshReviewRequestTemplate(contextContent)) {
+    return { ...contextGuidelines(contextContent, "local"), wrote: false };
   }
-  const seeded = ensureReviewSkillFile(worktreePath);
-  return skillGuidelines(seeded.content, seeded.wrote ? "stock" : "skill");
+  const fromSideboard = readSideboardReview(worktreePath, repoPath);
+  if (fromSideboard && !shouldRefreshReviewRequestTemplate(fromSideboard)) {
+    const body2 = writeContextGuidelines(worktreePath, fromSideboard);
+    return { ...contextGuidelines(body2, "repo"), wrote: true };
+  }
+  const local = readLocalGuidelines(worktreePath);
+  const body = writeContextGuidelines(worktreePath, local?.content ?? REVIEW_REQUEST_TEMPLATE);
+  return {
+    ...contextGuidelines(body, local ? "local" : "stock"),
+    wrote: true
+  };
 }
-function ensureReviewRequestFile(worktreePath) {
-  const seeded = ensureReviewSkillFile(worktreePath);
-  return skillGuidelines(seeded.content, "skill");
+function ensureReviewSkillFile(worktreePath, repoPath) {
+  const g = ensureReviewGuidelinesFile(worktreePath, repoPath);
+  return { path: g.path, content: g.content, wrote: g.wrote };
+}
+function resolveReviewGuidelines(worktreePath, repoPath) {
+  return ensureReviewGuidelinesFile(worktreePath, repoPath);
+}
+function ensureReviewRequestFile(worktreePath, repoPath) {
+  return ensureReviewGuidelinesFile(worktreePath, repoPath);
 }
 function buildReviewRequestAttachment(content, opts) {
   const path = opts?.path ?? REVIEW_SKILL_PATH;
-  const name = opts?.name ?? (path === REVIEW_SKILL_PATH ? REVIEW_SKILL_NAME : path === REPO_REVIEW_PATH ? REPO_REVIEW_NAME : REVIEW_REQUEST_NAME);
+  const name = opts?.name ?? (path === REVIEW_SKILL_PATH ? REVIEW_SKILL_NAME : path === REPO_REVIEW_PATH || path === CONTEXT_REVIEW_PATH ? REPO_REVIEW_NAME : REVIEW_REQUEST_NAME);
   return {
     id: randomUUID2(),
     name,
@@ -1735,7 +1756,7 @@ function buildReviewRequestAttachment(content, opts) {
   };
 }
 function readExistingReviewRequestFile(worktreePath) {
-  return readTextIfPresent(join4(worktreePath, REVIEW_SKILL_PATH)) ?? readTextIfPresent(join4(worktreePath, REPO_REVIEW_PATH)) ?? readTextIfPresent(join4(worktreePath, REVIEW_REQUEST_PATH)) ?? readTextIfPresent(join4(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
+  return readTextIfPresent(join4(worktreePath, REVIEW_SKILL_PATH)) ?? readTextIfPresent(join4(worktreePath, CONTEXT_REVIEW_PATH)) ?? readTextIfPresent(join4(worktreePath, REPO_REVIEW_PATH)) ?? readTextIfPresent(join4(worktreePath, REVIEW_REQUEST_PATH)) ?? readTextIfPresent(join4(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
 }
 async function requestReview(threadRef, send) {
   const from = findThreadByRef(threadRef);
@@ -1748,7 +1769,7 @@ async function requestReview(threadRef, send) {
   if (from.status === "archived") {
     throw new Error(`Thread is archived: ${from.id}`);
   }
-  const guidelines = resolveReviewGuidelines(from.worktreePath);
+  const guidelines = resolveReviewGuidelines(from.worktreePath, from.repoPath);
   const tab = createChatTab({
     fromThreadId: from.id,
     title: "Review",
@@ -1973,6 +1994,8 @@ async function attachAbort(handle, signal) {
 async function runSetupScript(repoPath, worktreePath, onLine, opts) {
   const settings = loadWorkspaceSettings(worktreePath, repoPath);
   if (!settings?.setup) return { ran: false, exitCode: null, source: null };
+  const source = workspaceSettingsSourceLabel(worktreePath, repoPath);
+  onLine?.(`[setup] ${source ?? "settings.toml"}`);
   const handle = await spawnWorkspaceScript(settings.setup, {
     worktreePath,
     repoPath,
@@ -1983,7 +2006,7 @@ async function runSetupScript(repoPath, worktreePath, onLine, opts) {
   return {
     ran: true,
     exitCode,
-    source: workspaceSettingsSourceLabel(worktreePath, repoPath),
+    source,
     kill: handle.kill
   };
 }
@@ -2007,11 +2030,9 @@ async function runConventionSetup(repoPath, worktreePath, onLine, opts) {
 }
 async function runWorkspaceSetup(repoPath, worktreePath, onLine, opts) {
   await ensureWorktreeSideboardIgnored(worktreePath);
-  const reviewSkill = ensureReviewSkillFile(worktreePath);
-  if (reviewSkill.wrote) {
-    onLine?.(
-      `[setup] wrote ${REVIEW_SKILL_PATH} \u2014 commit it so later worktrees inherit Review guidelines`
-    );
+  const review = ensureReviewGuidelinesFile(worktreePath, repoPath);
+  if (review.wrote) {
+    onLine?.(`[setup] wrote ${review.path} \u2014 local Review guidelines`);
   }
   let setup = await runSetupScript(repoPath, worktreePath, onLine, opts);
   if (!setup.ran) {
@@ -2114,9 +2135,122 @@ async function startDevServer(repoPath, worktreePath, onLine, opts) {
   };
 }
 
-// src/git/orphan-cleanup.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, statSync } from "fs";
+// src/store/setup-log.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
 import { join as join6 } from "path";
+var EMPTY = {
+  output: "",
+  running: false,
+  exitCode: null,
+  source: null
+};
+var memory = /* @__PURE__ */ new Map();
+var persistTimers = /* @__PURE__ */ new Map();
+function setupLogPath(threadId) {
+  return join6(threadsDir(), `${threadId}.setup.log.json`);
+}
+function emptySetupLog() {
+  return { ...EMPTY };
+}
+function mergeSetupOutput(prev, incoming) {
+  if (!prev) return incoming;
+  if (!incoming) return prev;
+  if (prev === incoming) return prev;
+  if (prev.startsWith(incoming) || prev.endsWith(incoming)) return prev;
+  if (incoming.startsWith(prev) || incoming.endsWith(prev)) return incoming;
+  return incoming.length >= prev.length ? incoming : prev;
+}
+function clone(snap) {
+  return { ...snap };
+}
+function persistNow(threadId) {
+  const timer = persistTimers.get(threadId);
+  if (timer) {
+    clearTimeout(timer);
+    persistTimers.delete(threadId);
+  }
+  const snap = memory.get(threadId);
+  if (!snap) return;
+  try {
+    writeFileSync2(setupLogPath(threadId), `${JSON.stringify(snap)}
+`, "utf8");
+  } catch {
+  }
+}
+function schedulePersist(threadId) {
+  if (persistTimers.has(threadId)) return;
+  persistTimers.set(
+    threadId,
+    setTimeout(() => {
+      persistTimers.delete(threadId);
+      persistNow(threadId);
+    }, 100)
+  );
+}
+function loadFromDisk(threadId) {
+  const path = setupLogPath(threadId);
+  if (!existsSync5(path)) return null;
+  try {
+    const raw = JSON.parse(readFileSync5(path, "utf8"));
+    return {
+      output: typeof raw.output === "string" ? raw.output : "",
+      running: Boolean(raw.running),
+      exitCode: typeof raw.exitCode === "number" ? raw.exitCode : null,
+      source: typeof raw.source === "string" ? raw.source : null
+    };
+  } catch {
+    return null;
+  }
+}
+function readSetupLog(threadId) {
+  const cached = memory.get(threadId);
+  if (cached) return clone(cached);
+  const disk = loadFromDisk(threadId);
+  if (disk) {
+    memory.set(threadId, disk);
+    return clone(disk);
+  }
+  return emptySetupLog();
+}
+function beginSetupLog(threadId) {
+  const snap = {
+    output: "",
+    running: true,
+    exitCode: null,
+    source: null
+  };
+  memory.set(threadId, snap);
+  persistNow(threadId);
+  return clone(snap);
+}
+function appendSetupLog(threadId, line) {
+  const current = memory.get(threadId) ?? readSetupLog(threadId);
+  const snap = {
+    ...current,
+    output: current.output ? `${current.output}
+${line}` : line,
+    running: true
+  };
+  memory.set(threadId, snap);
+  schedulePersist(threadId);
+  return clone(snap);
+}
+function finishSetupLog(threadId, exitCode, source) {
+  const current = memory.get(threadId) ?? readSetupLog(threadId);
+  const snap = {
+    ...current,
+    running: false,
+    exitCode,
+    source: source ?? current.source
+  };
+  memory.set(threadId, snap);
+  persistNow(threadId);
+  return clone(snap);
+}
+
+// src/git/orphan-cleanup.ts
+import { existsSync as existsSync6, readdirSync as readdirSync2, statSync } from "fs";
+import { join as join7 } from "path";
 function isSideboardWorktreePath(path) {
   return path.includes("/.sideboard/worktrees/") || path.includes("/sideboard/workspaces/");
 }
@@ -2127,7 +2261,7 @@ async function findOrphanWorktrees(repoPaths) {
     repoPaths?.length ? repoPaths : threads.map((t) => t.repoPath).filter(Boolean)
   );
   const homeRoot = sideboardWorkspacesDir();
-  if (existsSync5(homeRoot)) {
+  if (existsSync6(homeRoot)) {
     try {
       for (const entry of readdirSync2(homeRoot, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
@@ -2139,7 +2273,7 @@ async function findOrphanWorktrees(repoPaths) {
   const orphans = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoPath of repos) {
-    if (!repoPath || !existsSync5(repoPath)) continue;
+    if (!repoPath || !existsSync6(repoPath)) continue;
     try {
       const wts = await listWorktrees(repoPath);
       for (const wt of wts) {
@@ -2160,12 +2294,12 @@ async function findOrphanWorktrees(repoPaths) {
     }
     try {
       const root = worktreesRoot(repoPath);
-      if (existsSync5(root)) {
+      if (existsSync6(root)) {
         for (const entry of readdirSync2(root, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
-          const path = join6(root, entry.name).replace(/\/$/, "");
+          const path = join7(root, entry.name).replace(/\/$/, "");
           if (known.has(path) || seen.has(path)) continue;
-          if (!existsSync5(join6(path, ".git"))) continue;
+          if (!existsSync6(join7(path, ".git"))) continue;
           seen.add(path);
           let mtimeMs = 0;
           try {
@@ -2314,8 +2448,8 @@ async function applyThreadIntoMain(thread, opts) {
 }
 
 // src/git/clone-repo.ts
-import { existsSync as existsSync6 } from "fs";
-import { basename as basename2, join as join7 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { basename as basename2, join as join8 } from "path";
 import { execa as execa4 } from "execa";
 async function cloneRepoIntoSideboard(opts) {
   const url = opts.url.trim();
@@ -2326,8 +2460,8 @@ async function cloneRepoIntoSideboard(opts) {
     name = leaf || "repo";
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
-  const dest = join7(sideboardReposDir(), name);
-  if (existsSync6(dest)) {
+  const dest = join8(sideboardReposDir(), name);
+  if (existsSync7(dest)) {
     const repoPath2 = await resolveRepoRoot(dest);
     const workspace2 = await ensureWorkspace(repoPath2);
     return { repoPath: repoPath2, workspace: workspace2 };
@@ -2344,13 +2478,13 @@ async function cloneRepoIntoSideboard(opts) {
 }
 
 // src/store/desktop-host.ts
-import { readFileSync as readFileSync5, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join8 } from "path";
+import { readFileSync as readFileSync6, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { join as join9 } from "path";
 function desktopHostPidPath() {
-  return join8(appDataDir(), "desktop-host.pid");
+  return join9(appDataDir(), "desktop-host.pid");
 }
 function claimDesktopHost(pid = process.pid) {
-  writeFileSync2(desktopHostPidPath(), `${pid}
+  writeFileSync3(desktopHostPidPath(), `${pid}
 `, "utf8");
 }
 function releaseDesktopHost(pid = process.pid) {
@@ -2362,7 +2496,7 @@ function releaseDesktopHost(pid = process.pid) {
 }
 function readDesktopHostPid() {
   try {
-    const pid = Number.parseInt(readFileSync5(desktopHostPidPath(), "utf8").trim(), 10);
+    const pid = Number.parseInt(readFileSync6(desktopHostPidPath(), "utf8").trim(), 10);
     if (!Number.isFinite(pid) || pid <= 0) return null;
     return pid;
   } catch {
@@ -2429,7 +2563,7 @@ function notifyParentOfChildHalt(child, status, send) {
 }
 
 // src/threads/create.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 
 // src/detect/detect.ts
 async function detectAgents() {
@@ -2600,12 +2734,19 @@ function urlsMatch(a, b) {
   const norm = (u) => u.trim().replace(/\/+$/, "").toLowerCase();
   return Boolean(a && b && norm(a) === norm(b));
 }
+function threadPrUrlMatchesNumber(thread, number) {
+  if (!Number.isFinite(number) || number < 1) return false;
+  const url = (thread.prUrl ?? "").trim();
+  if (!url) return false;
+  return new RegExp(`/pull/${number}(?:/|$|[?#])`, "i").test(url);
+}
 function threadMatchesPr(thread, pr) {
   const num = String(pr.number);
   if (thread.sourceType === "pr" && normalizeIssueKey(thread.sourceRef ?? "") === num) {
     return true;
   }
   if (thread.prUrl && pr.url && urlsMatch(thread.prUrl, pr.url)) return true;
+  if (threadPrUrlMatchesNumber(thread, pr.number)) return true;
   const head = pr.headRefName.trim().toLowerCase();
   if (!head) return false;
   const branch = (thread.branchName ?? "").trim().toLowerCase();
@@ -2658,22 +2799,65 @@ function findLiveThreadForCreate(input, threads) {
       (t) => threadMatchesPr(t, {
         number: Number.isFinite(number) ? number : -1,
         title: input.title ?? "",
-        url: "",
-        headRefName: ""
+        url: input.prUrl ?? "",
+        headRefName: input.headRefName ?? ""
       })
     );
   }
   if (input.sourceType === "branch") {
     if (isDefaultBranchCreateRef(input.sourceRef)) return void 0;
-    return live.find(
+    const byBranch = live.find(
       (t) => threadMatchesBranch(t, {
         ref: input.sourceRef,
         repoPath: input.repoPath
       })
     );
+    if (byBranch) return byBranch;
+    if (input.prUrl || input.headRefName) {
+      const number = Number(normalizeIssueKey(input.sourceRef));
+      return live.find(
+        (t) => threadMatchesPr(t, {
+          number: Number.isFinite(number) ? number : -1,
+          title: input.title ?? "",
+          url: input.prUrl ?? "",
+          headRefName: input.headRefName ?? input.sourceRef
+        })
+      );
+    }
+    return void 0;
   }
   return void 0;
 }
+function findLiveThreadForCreateSource(source, threads, prs) {
+  const found = findLiveThreadForCreate(
+    {
+      sourceType: source.kind,
+      sourceRef: source.ref,
+      repoPath: source.repoPath,
+      title: source.title,
+      prUrl: source.url,
+      headRefName: source.headRefName
+    },
+    threads
+  );
+  if (found) return found;
+  if (source.kind !== "branch" || !prs?.length) return void 0;
+  if (isDefaultBranchCreateRef(source.ref)) return void 0;
+  const head = normalizeBranchRef(source.ref);
+  const pr = prs.find((p) => normalizeBranchRef(p.headRefName) === head);
+  if (!pr) return void 0;
+  return findLiveThreadForCreate(
+    {
+      sourceType: "pr",
+      sourceRef: String(pr.number),
+      repoPath: source.repoPath,
+      title: pr.title,
+      prUrl: pr.url,
+      headRefName: pr.headRefName
+    },
+    threads
+  );
+}
 function boardPinIdentity(pin) {
   const ref = normalizeIssueKey(pin.ref);
   if (pin.kind === "ticket" && (pin.provider === "linear" || !pin.repoPath)) {
@@ -2903,42 +3087,53 @@ function assembleHomeBoard(input) {
   }
   return { columns, hidden, totals };
 }
-var HOME_BOARD_AGENT_HINT = "Home is a Kanban of worktrees (one card per checkout; sibling chat tabs nest as inner cards). create_thread reuses a live worktree for the same ticket, PR, or named branch \u2014 do not recreate it. Columns are the path to merge: New (no PR) \u2192 Draft (draft PR) \u2192 Review (open PR) \u2192 Merged. Archive removes the card to Settings \u2192 History. Queued/running are activity on the card, not columns. Orchestration chats stay in the sidebar. Do not invent status.";
+var HOME_BOARD_AGENT_HINT = "Home is a Kanban of worktrees (one card per checkout; sibling chat tabs nest as inner cards). Do not create a second worktree for a ticket, PR, or named branch that already has a live checkout \u2014 create_thread / start_board_card return that thread (alreadyStarted). Creating from the default branch still opens a new isolated worktree. Columns are the path to merge: New (no PR) \u2192 Draft (draft PR) \u2192 Review (open PR) \u2192 Merged. Archive removes the card to Settings \u2192 History. Queued/running are activity on the card, not columns. Orchestration chats stay in the sidebar. Do not invent status.";
 
 // src/threads/create.ts
 function persistCreateAttachments(worktreePath, attachments) {
   return persistPendingFileAttachments(worktreePath, attachments ?? []);
 }
+function liveThreadsForCreate() {
+  return listThreads({ includeArchived: false }).map((t) => ({
+    ...t,
+    repoPath: canonicalizeRepoPath(t.repoPath)
+  }));
+}
+function reuseLiveThread(input, repoPath, match) {
+  if (input.reuseExisting === false) return void 0;
+  const existing = findLiveThreadForCreate(
+    {
+      sourceType: match.sourceType,
+      sourceRef: match.sourceRef,
+      repoPath,
+      title: match.title ?? input.title,
+      cowboy: input.cowboy,
+      prUrl: match.prUrl,
+      headRefName: match.headRefName
+    },
+    liveThreadsForCreate()
+  );
+  if (!existing) return void 0;
+  const thread = readThread(existing.id) ?? existing;
+  if (!input.attachments?.length) return thread;
+  return updateThread(thread.id, {
+    attachments: persistCreateAttachments(thread.worktreePath, [
+      ...thread.attachments,
+      ...input.attachments
+    ])
+  });
+}
 async function createThread(input, _onSetupLine) {
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!existsSync7(repoPath)) {
+  if (!existsSync8(repoPath)) {
     throw new Error(`Repo not found: ${repoPath}`);
   }
-  if (input.reuseExisting !== false) {
-    const existing = findLiveThreadForCreate(
-      {
-        sourceType: input.sourceType,
-        sourceRef: input.sourceRef,
-        repoPath,
-        title: input.title,
-        cowboy: input.cowboy
-      },
-      listThreads({ includeArchived: false }).map((t) => ({
-        ...t,
-        repoPath: canonicalizeRepoPath(t.repoPath)
-      }))
-    );
-    if (existing) {
-      const thread2 = readThread(existing.id) ?? existing;
-      if (!input.attachments?.length) return thread2;
-      return updateThread(thread2.id, {
-        attachments: persistCreateAttachments(thread2.worktreePath, [
-          ...thread2.attachments,
-          ...input.attachments
-        ])
-      });
-    }
-  }
+  const reused = reuseLiveThread(input, repoPath, {
+    sourceType: input.sourceType,
+    sourceRef: input.sourceRef,
+    title: input.title
+  });
+  if (reused) return reused;
   const resolved = resolveNewThreadOptions({
     agent: input.agent,
     model: input.model,
@@ -2947,7 +3142,7 @@ async function createThread(input, _onSetupLine) {
   });
   await requireAgent(resolved.agent);
   if (input.cowboy) {
-    const { cowboyModeEnabled } = await import("./app-settings-3CHCNIMD.js");
+    const { cowboyModeEnabled } = await import("./app-settings-H3INSR67.js");
     if (!cowboyModeEnabled()) {
       throw new Error(
         "Cowboy mode is off. Enable it in Settings \u2192 Advanced."
@@ -3005,7 +3200,7 @@ async function createThread(input, _onSetupLine) {
   let sourceIsFork = false;
   if (!input.cowboy && sourceType === "branch" && (!sourceRef || sourceRef === "HEAD" || sourceRef === "default")) {
     if (isAbleTimeConnected() && getIssueSource() === "abletime") {
-      const { ensureAbleTimeTask, issueAttachmentForAbleTimeTask } = await import("./abletime-223A3LY6.js");
+      const { ensureAbleTimeTask, issueAttachmentForAbleTimeTask } = await import("./abletime-H7LPGIP2.js");
       const task = await ensureAbleTimeTask({
         title: title?.trim() || "Untitled work",
         description: input.prompt?.trim() || void 0
@@ -3015,6 +3210,12 @@ async function createThread(input, _onSetupLine) {
       persistedSourceRef = task.identifier;
       title = title?.trim() || task.title;
       attachments = [...attachments, issueAttachmentForAbleTimeTask(task)];
+      const reusedTicket = reuseLiveThread(
+        { ...input, sourceType: "ticket", sourceRef, title, attachments },
+        repoPath,
+        { sourceType: "ticket", sourceRef, title }
+      );
+      if (reusedTicket) return reusedTicket;
     }
   }
   let prUrl = null;
@@ -3024,6 +3225,14 @@ async function createThread(input, _onSetupLine) {
     if (!Number.isFinite(num)) throw new Error(`Invalid PR number: ${input.sourceRef}`);
     const pr = await getPr(repoPath, num);
     if (!pr) throw new Error(`PR #${num} not found`);
+    const reusedPr = reuseLiveThread(input, repoPath, {
+      sourceType: "pr",
+      sourceRef: String(pr.number),
+      title: input.title ?? pr.title,
+      prUrl: pr.url,
+      headRefName: pr.headRefName
+    });
+    if (reusedPr) return reusedPr;
     sourceIsFork = pr.isCrossRepository;
     prUrl = pr.url;
     const localFetchBranch = `sideboard-pr-${pr.number}`;
@@ -3036,9 +3245,19 @@ async function createThread(input, _onSetupLine) {
       sourceRef = await resolveDefaultBranch(repoPath);
     } else {
       const existing = await getPrForHeadBranch(repoPath, sourceRef);
-      if (existing?.url) {
-        prUrl = existing.url;
-        prTitle = existing.title;
+      if (existing) {
+        const reusedPr = reuseLiveThread(input, repoPath, {
+          sourceType: "pr",
+          sourceRef: String(existing.number),
+          title: input.title ?? existing.title,
+          prUrl: existing.url,
+          headRefName: existing.headRefName
+        });
+        if (reusedPr) return reusedPr;
+        if (existing.url) {
+          prUrl = existing.url;
+          prTitle = existing.title;
+        }
       }
     }
   } else if (sourceType === "adopt") {
@@ -3078,7 +3297,7 @@ async function createThread(input, _onSetupLine) {
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("./agents-U2JCFXW4.js");
+  const { getAdapter: getAdapter2 } = await import("./agents-YVW75KBO.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -3101,11 +3320,11 @@ function shouldRemoveWorktreeOnTeardown(thread) {
 
 // src/store/turn-live.ts
 import {
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   renameSync,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync3,
-  readFileSync as readFileSync6
+  writeFileSync as writeFileSync4,
+  readFileSync as readFileSync7
 } from "fs";
 var buffers = /* @__PURE__ */ new Map();
 var FLUSH_MS = 800;
@@ -3182,7 +3401,7 @@ function writeTurnLive(threadId, progress) {
   const path = threadLivePath(threadId);
   const tmp = `${path}.${process.pid}.tmp`;
   try {
-    writeFileSync3(tmp, JSON.stringify(progress), "utf8");
+    writeFileSync4(tmp, JSON.stringify(progress), "utf8");
     renameSync(tmp, path);
   } catch {
     try {
@@ -3193,9 +3412,9 @@ function writeTurnLive(threadId, progress) {
 }
 function readTurnLive(threadId) {
   const path = threadLivePath(threadId);
-  if (!existsSync8(path)) return null;
+  if (!existsSync9(path)) return null;
   try {
-    const raw = JSON.parse(readFileSync6(path, "utf8"));
+    const raw = JSON.parse(readFileSync7(path, "utf8"));
     if (!raw || typeof raw.summary !== "string") return null;
     return raw;
   } catch {
@@ -3207,7 +3426,7 @@ function clearTurnLive(threadId) {
   if (buf?.timer) clearTimeout(buf.timer);
   buffers.delete(threadId);
   const path = threadLivePath(threadId);
-  if (!existsSync8(path)) return;
+  if (!existsSync9(path)) return;
   try {
     unlinkSync2(path);
   } catch {
@@ -3391,26 +3610,26 @@ function createQuotaFailoverChat(from, fallbackAgent, limitText) {
 import { execFileSync } from "child_process";
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   mkdtempSync,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   rmSync
 } from "fs";
 import { tmpdir } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import { createRequire } from "module";
-var CONDUCTOR_APP_SUPPORT = join9(
+var CONDUCTOR_APP_SUPPORT = join10(
   process.env.HOME ?? "",
   "Library",
   "Application Support",
   "com.conductor.app"
 );
-var CONDUCTOR_DB = join9(CONDUCTOR_APP_SUPPORT, "conductor.db");
-var CURSOR_SDK_STORE = join9(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+var CONDUCTOR_DB = join10(CONDUCTOR_APP_SUPPORT, "conductor.db");
+var CURSOR_SDK_STORE = join10(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
 function thisModuleFile() {
   const cjsFile = typeof __filename !== "undefined" ? __filename : "";
-  return cjsFile || process.argv[1] || join9(process.cwd(), "package.json");
+  return cjsFile || process.argv[1] || join10(process.cwd(), "package.json");
 }
 function openReadonlySqlite(file) {
   const req = createRequire(thisModuleFile());
@@ -3428,7 +3647,7 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !existsSync9(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !existsSync10(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
@@ -3438,11 +3657,11 @@ function resolveConductorCursorAgentId(workspacePath) {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = join9(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!existsSync9(agentsFile)) continue;
+    const agentsFile = join10(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!existsSync10(agentsFile)) continue;
     let text;
     try {
-      text = readFileSync7(agentsFile, "utf8");
+      text = readFileSync8(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -3466,7 +3685,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!existsSync9(input.worktreePath)) {
+  if (!existsSync10(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -3485,7 +3704,7 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-ZXCUVCZC.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-5UNDTN4G.js");
   await ensureWorkspace2(repoPath);
   const { ensureWorktreeSideboardIgnored: ensureWorktreeSideboardIgnored2 } = await import("./worktree-exclude-X54WSOXM.js");
   await ensureWorktreeSideboardIgnored2(input.worktreePath);
@@ -3495,16 +3714,16 @@ function conductorDbPath() {
   return CONDUCTOR_DB;
 }
 function listConductorWorkspaces() {
-  if (!existsSync9(CONDUCTOR_DB)) {
+  if (!existsSync10(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = mkdtempSync(join9(tmpdir(), "sideboard-conductor-"));
-  const snapshot = join9(tmp, "conductor.db");
+  const tmp = mkdtempSync(join10(tmpdir(), "sideboard-conductor-"));
+  const snapshot = join10(tmp, "conductor.db");
   try {
     copyFileSync2(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if (existsSync9(src)) {
+      if (existsSync10(src)) {
         try {
           copyFileSync2(src, `${snapshot}${suffix}`);
         } catch {
@@ -3586,16 +3805,16 @@ function listConductorWorkspaces() {
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!existsSync9(CONDUCTOR_DB)) {
+  if (!existsSync10(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = mkdtempSync(join9(tmpdir(), "sideboard-conductor-"));
-  const snapshot = join9(tmp, "conductor.db");
+  const tmp = mkdtempSync(join10(tmpdir(), "sideboard-conductor-"));
+  const snapshot = join10(tmp, "conductor.db");
   try {
     copyFileSync2(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if (existsSync9(src)) {
+      if (existsSync10(src)) {
         try {
           copyFileSync2(src, `${snapshot}${suffix}`);
         } catch {
@@ -3615,7 +3834,7 @@ function importConductorWorkspace(workspaceId) {
       ).get(workspaceId);
       if (!row) throw new Error(`Conductor workspace not found: ${workspaceId}`);
       const worktreePath = String(row.workspacePath);
-      if (!existsSync9(worktreePath)) {
+      if (!existsSync10(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -3686,7 +3905,7 @@ async function importConductorWorkspaceAsync(workspaceId) {
 }
 
 // src/threads/stack-layers.ts
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 function stackIdFrom(stack) {
   if (stack.stackNumber != null) return `gh-stack-${stack.stackNumber}`;
   const key = stack.layers.map((l) => l.branchName).join("|");
@@ -3749,7 +3968,7 @@ async function openStackLayer(input, _onSetupLine) {
   let createdWorktree = false;
   const trees = await listWorktrees(repoPath);
   const checkedOut = trees.find((w) => w.branch === branchName);
-  if (checkedOut?.path && existsSync10(checkedOut.path)) {
+  if (checkedOut?.path && existsSync11(checkedOut.path)) {
     if (input.reuseExistingWorktree !== false) {
       worktreePath = checkedOut.path;
     } else {
@@ -3891,7 +4110,7 @@ async function initStackFromThread(input, onSetupLine) {
 async function createPrStack(input, onSetupLine) {
   await requireAgent(input.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!existsSync10(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
+  if (!existsSync11(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
   if (!input.branches.length) throw new Error("At least one branch name required");
   const status = await detectGhStack(repoPath);
   if (!status.available) throw new Error(status.reason);
@@ -3958,7 +4177,7 @@ async function createPrStack(input, onSetupLine) {
     }
   }
   const claimed = new Set(threads.map((t) => t.worktreePath));
-  if (!claimed.has(bootstrap.worktreePath) && existsSync10(bootstrap.worktreePath)) {
+  if (!claimed.has(bootstrap.worktreePath) && existsSync11(bootstrap.worktreePath)) {
     try {
       await removeWorktree(repoPath, bootstrap.worktreePath, {
         deleteBranch: bootstrap.branchName
@@ -3980,10 +4199,10 @@ function stackAgentDefaultsFrom(input) {
 }
 
 // src/diff/diff.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync8, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname3, join as join10 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync3, readFileSync as readFileSync9, statSync as statSync2, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname3, join as join11 } from "path";
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !existsSync11(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !existsSync12(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -3991,7 +4210,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !existsSync11(worktreePath)) {
+  if (!worktreePath || !existsSync12(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -4127,11 +4346,11 @@ new file mode 100644
   };
 }
 async function untrackedPatch(worktreePath, path, maxHunk) {
-  const abs = join10(worktreePath, path);
+  const abs = join11(worktreePath, path);
   try {
     const st = statSync2(abs);
     if (st.isFile() && st.size > maxHunk) {
-      const buf = readFileSync8(abs).subarray(0, maxHunk);
+      const buf = readFileSync9(abs).subarray(0, maxHunk);
       return syntheticAddPatch(path, buf.toString("utf8"), maxHunk);
     }
   } catch {
@@ -4632,7 +4851,7 @@ var DEFAULT_UPLOAD_MAX_BYTES = 5e7;
 function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-  const abs = join10(worktreePath, relativePath);
+  const abs = join11(worktreePath, relativePath);
   const st = statSync2(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
@@ -4642,7 +4861,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = readFileSync8(abs);
+  const buf = readFileSync9(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -4652,12 +4871,12 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = join10(worktreePath, relativePath);
+  const abs = join11(worktreePath, relativePath);
   const st = statSync2(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = readFileSync8(abs);
+  const buf = readFileSync9(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -4700,9 +4919,9 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = join10(worktreePath, relativePath);
+  const abs = join11(worktreePath, relativePath);
   mkdirSync3(dirname3(abs), { recursive: true });
-  writeFileSync4(abs, content, "utf8");
+  writeFileSync5(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getDiffSummary(worktreePath, repoPath, opts) {
@@ -4827,9 +5046,9 @@ async function confirmLand(thread, opts) {
 }
 
 // src/skills/discover.ts
-import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync9, statSync as statSync3 } from "fs";
+import { existsSync as existsSync13, readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync3 } from "fs";
 import { homedir } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 
 // src/skills/bundled/long-running.ts
 var LONG_RUNNING_SKILL_COMMAND = "long-running";
@@ -4897,6 +5116,16 @@ node <detached-job.js> wait --pid-file FILE --log-file FILE [--ok-pattern TEXT]
 4. On \`ok\`, present once more (\`status=ok\`, last \`delta\`) and finish the task. On \`failed\`, fix from the log.
 
 Never tell the user \u201Csay status when it\u2019s done.\u201D You wait.
+
+## PR checks (only if a goal is given)
+
+Do **not** watch after every push. If the user gave a goal (Greptile 5/5, CI green, until checks pass), wait the same way:
+
+\`\`\`bash
+node <detached-job.js> start pr-checks -- gh pr checks --watch
+\`\`\`
+
+On miss, fix, commit, push, and watch again until the goal is met or you are blocked. Do not ask the human to poll. Do not merge unless asked.
 `;
 
 // src/skills/discover.ts
@@ -4948,7 +5177,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = readFileSync9(skillMd, "utf8");
+    const content = readFileSync10(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -4967,7 +5196,7 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!existsSync12(dir)) return;
+  if (!existsSync13(dir)) return;
   let entries;
   try {
     entries = readdirSync4(dir);
@@ -4976,8 +5205,8 @@ function scanSkillsDir(dir, source, out) {
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const skillMd = join11(dir, entry, "SKILL.md");
-    if (!existsSync12(skillMd)) continue;
+    const skillMd = join12(dir, entry, "SKILL.md");
+    if (!existsSync13(skillMd)) continue;
     try {
       if (!statSync3(skillMd).isFile()) continue;
     } catch {
@@ -4988,7 +5217,7 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!existsSync12(pluginsRoot)) return;
+  if (!existsSync13(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
@@ -4998,12 +5227,12 @@ function scanClaudePluginSkills(pluginsRoot, out) {
       return;
     }
     if (lookingForSkillsDir && entries.includes("SKILL.md")) {
-      const skill = readSkill(join11(dir, "SKILL.md"), "cli");
+      const skill = readSkill(join12(dir, "SKILL.md"), "cli");
       if (skill) out.push(skill);
     }
     for (const entry of entries) {
       if (entry === "node_modules" || entry === ".git") continue;
-      const full = join11(dir, entry);
+      const full = join12(dir, entry);
       try {
         if (!statSync3(full).isDirectory()) continue;
       } catch {
@@ -5023,17 +5252,17 @@ function discoverSkills(worktreePath) {
   const home = homedir();
   const collected = [];
   for (const rel of [".claude/skills", ".cursor/skills", ".sideboard/skills", ".brightsy/skills", "skills"]) {
-    scanSkillsDir(join11(worktreePath, rel), "workspace", collected);
+    scanSkillsDir(join12(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    join11(home, ".claude/skills"),
-    join11(home, ".cursor/skills"),
-    join11(home, ".sideboard/skills"),
-    join11(home, ".brightsy/skills")
+    join12(home, ".claude/skills"),
+    join12(home, ".cursor/skills"),
+    join12(home, ".sideboard/skills"),
+    join12(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills(join11(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills(join12(home, ".claude/plugins"), collected);
   collected.push(...bundledSkills());
   const rank = {
     workspace: 0,
@@ -5059,7 +5288,7 @@ function readSkillBody(skillPath, maxChars = 12e3) {
 \u2026(truncated)` : body;
     }
   }
-  const raw = readFileSync9(skillPath, "utf8");
+  const raw = readFileSync10(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -5152,26 +5381,26 @@ function expandComposerPrompt(worktreePath, prompt, opts) {
 }
 
 // src/agents/instructions.ts
-import { existsSync as existsSync14, readFileSync as readFileSync10, statSync as statSync4 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync11, statSync as statSync4 } from "fs";
+import { join as join14 } from "path";
 
 // src/skills/detached-job-path.ts
-import { existsSync as existsSync13 } from "fs";
-import { dirname as dirname4, join as join12 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { dirname as dirname4, join as join13 } from "path";
 import { fileURLToPath } from "url";
 function packagedDetachedJobPath() {
   const dir = packagedMcpDir();
   if (!dir) return null;
-  const script = join12(dir, "scripts", "detached-job.js");
-  return existsSync13(script) ? script : null;
+  const script = join13(dir, "scripts", "detached-job.js");
+  return existsSync14(script) ? script : null;
 }
 function resolveDetachedJobScript() {
   const packaged = packagedDetachedJobPath();
   if (packaged) return packaged;
   let dir = dirname4(fileURLToPath(import.meta.url));
   for (let i = 0; i < 8; i++) {
-    const candidate = join12(dir, "scripts", "detached-job.js");
-    if (existsSync13(candidate)) return candidate;
+    const candidate = join13(dir, "scripts", "detached-job.js");
+    if (existsSync14(candidate)) return candidate;
     const parent = dirname4(dir);
     if (parent === dir) break;
     dir = parent;
@@ -5262,7 +5491,7 @@ function formatWorktreeDirective(thread, opts) {
     "Short git requests from the Sideboard UI are complete instructions \u2014 expand them using the rules above without asking for clarification:"
   );
   lines.push(
-    '- "Commit and push." \u2192 commit any uncommitted work with a purpose-stating message, then push to origin (updates an existing PR if one is linked).'
+    '- "Commit and push." \u2192 commit any uncommitted work with a purpose-stating message, then push to origin (updates an existing PR if one is linked). Do not start a checks loop unless they gave a goal.'
   );
   lines.push(
     '- "Commit, push, and open a draft PR." \u2192 commit, push, then create a draft PR with `gh pr create --draft -R \u2026` (title/body from the change purpose).'
@@ -5271,7 +5500,7 @@ function formatWorktreeDirective(thread, opts) {
     '- "Commit, push, and open a PR in the browser." \u2192 commit, push, then `gh pr create --web -R \u2026`.'
   );
   lines.push(
-    '- "Fix CI: <name>." \u2192 investigate that failing check, fix it, commit, and push.'
+    '- "Fix CI: <name>." \u2192 investigate that failing check, fix it, commit, and push. Loop only if they gave a goal to keep going until it passes.'
   );
   lines.push(
     '- "Merge the remote branch (<base>) into your branch and resolve conflicts. Then, commit and push your changes." \u2192 fetch the PR base, merge it into this branch, resolve conflicts carefully, commit, and push until the PR is mergeable.'
@@ -5283,11 +5512,21 @@ function formatWorktreeDirective(thread, opts) {
     '- "Merge PR." \u2192 merge this thread\'s open pull request on GitHub (this phrase is the explicit ask). If `gh stack view` shows a stack, use `gh stack merge`; otherwise `gh pr merge` (respect repo defaults / squash vs merge). Do not force-push main/master or merge locally into the main checkout.'
   );
   lines.push("");
+  lines.push(formatPrGateDirective());
+  lines.push("");
   lines.push(formatProcessGuideDirective());
   return lines.join("\n");
 }
 function formatWorktreeReminder() {
-  return "Sideboard worktree: stay in this cwd for all file and git work. Push and open PRs against origin, never upstream. Do not edit the main repo checkout.";
+  return "Sideboard worktree: stay in this cwd for all file and git work. Push and open PRs against origin, never upstream. Do not edit the main repo checkout. If a goal is given (Greptile 5/5, CI green), watch-fix-push until it lands \u2014 do not watch after every push.";
+}
+function formatPrGateDirective() {
+  return [
+    "If a goal is given (not after every push):",
+    "- Enter a watch-fix-push loop and stay in it until that goal is met or you are blocked (examples: \u201CGreptile 5/5\u201D, \u201CCI green\u201D, \u201Cuntil checks pass\u201D). Do not stop after one red run or one review cycle.",
+    "- Wait with `/long-running`: `gh pr checks --watch` (add `-R <origin>` when needed). Present the log. Do not ask the human to poll.",
+    "- Greptile 5/5: wait for the greptile check; read the latest `N/5` from the PR body or Greptile\u2019s most recently *updated* issue comment; also fetch unresolved review comments / the \u201CPrompt to fix all with AI\u201D block. Done = **5/5 and zero unresolved Greptile comments**. If Greptile is idle, comment `@greptile review`. Cap about 5 iterations, then report leftovers. Do not merge unless asked."
+  ].join("\n");
 }
 function formatProcessGuideDirective() {
   return [
@@ -5295,7 +5534,7 @@ function formatProcessGuideDirective() {
     "- Long jobs (pack, test, deploy, anything that may run more than ~30s): Sideboard always provides `/long-running`. Detach and wait \u2014 do not ask the human to poll.",
     "- If `.claude/skills/graph-engineering/SKILL.md` exists, follow it (`/graph-engineering`) for migrations, ports, batch fixes, and other fan-out. Judge first; state on disk; grow the rulebook; do not patch around it.",
     "- If this same shape of work will happen again, write `.claude/skills/<kebab-name>/SKILL.md` in this worktree (Claude Code project skill). Sideboard `/name`, Claude Code, and `attach` all load that path. Do not leave the method only in chat.",
-    "- Merge-readiness notes: create or edit `.claude/skills/review/SKILL.md` and commit it. That file is allowed. Do not use `.sideboard/review.md` for new notes (legacy; setup copies it into the skill).",
+    "- Merge-readiness notes: if `.claude/skills/review/SKILL.md` already exists, edit it. Otherwise write them to `.context/review.md` (copied from `.sideboard/review.md` when that file exists). Do not create a review skill.",
     "- Do not write new skills under `.sideboard/skills/` (that folder only \u2014 other `.sideboard/` files such as settings.toml are fine). Point Codex/OpenCode at the Claude skill from `AGENTS.md`. Optional: symlink `.cursor/skills/<name>` to the Claude skill.",
     "- Skip a guide for a one-off. If a matching skill exists, follow it. Same miss twice \u2192 edit the skill, do not patch around it."
   ].join("\n");
@@ -5366,11 +5605,11 @@ function loadAgentInstructions(worktreePath, agent) {
   const out = [];
   for (const rel of candidates) {
     if (seenPaths.has(rel)) continue;
-    const abs = join13(worktreePath, rel);
-    if (!existsSync14(abs)) continue;
+    const abs = join14(worktreePath, rel);
+    if (!existsSync15(abs)) continue;
     try {
       if (!statSync4(abs).isFile()) continue;
-      let content = readFileSync10(abs, "utf8");
+      let content = readFileSync11(abs, "utf8");
       if (!content.trim()) continue;
       if (content.length > MAX_CHARS_PER_FILE) {
         content = `${content.slice(0, MAX_CHARS_PER_FILE)}
@@ -5690,8 +5929,8 @@ async function syncThreadBranchFromGit(threadId) {
 
 // src/store/schedules.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync15, readFileSync as readFileSync11 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync12 } from "fs";
+import { join as join15 } from "path";
 import { Cron } from "croner";
 var DURATION_RE = /^(\d+)(s|m|h|d)$/i;
 var UNIT_MS = {
@@ -5701,7 +5940,7 @@ var UNIT_MS = {
   d: 864e5
 };
 function schedulesPath() {
-  return join14(appDataDir(), "schedules.json");
+  return join15(appDataDir(), "schedules.json");
 }
 function parseDurationMs(every) {
   const m = every.trim().match(DURATION_RE);
@@ -5807,9 +6046,9 @@ function normalizeTask(raw) {
 }
 function readAll() {
   const path = schedulesPath();
-  if (!existsSync15(path)) return [];
+  if (!existsSync16(path)) return [];
   try {
-    const parsed = JSON.parse(readFileSync11(path, "utf8"));
+    const parsed = JSON.parse(readFileSync12(path, "utf8"));
     if (!Array.isArray(parsed)) return [];
     return parsed.map((row) => {
       try {
@@ -5935,7 +6174,7 @@ function formatScheduledPrompt(name, prompt) {
 ${prompt}`;
 }
 async function defaultDeps() {
-  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-DPTRBKEH.js");
+  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-5PSHBLP6.js");
   const orch = getOrchestrator2();
   return {
     findThread: (id) => findThreadByRef(id),
@@ -6175,7 +6414,7 @@ var Orchestrator = class {
         }
         continue;
       }
-      if (!existsSync16(thread.worktreePath)) {
+      if (!existsSync17(thread.worktreePath)) {
         setStatus(thread.id, "broken", "Worktree missing on disk");
         this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
         continue;
@@ -6194,7 +6433,7 @@ var Orchestrator = class {
           orphans: orphans.map((o) => ({ path: o.path, repoPath: o.repoPath }))
         });
       }
-      const { autoCleanupOrphansEnabled } = await import("./app-settings-3CHCNIMD.js");
+      const { autoCleanupOrphansEnabled } = await import("./app-settings-H3INSR67.js");
       if (autoCleanupOrphansEnabled() && shouldRunWorktreeCleanup() && orphans.length > 0) {
         await cleanupOrphanWorktrees({ repoPaths });
       }
@@ -6434,7 +6673,7 @@ var Orchestrator = class {
     }
     await setup;
     if (skipSetup) return;
-    const { autoRunAfterSetupEnabled } = await import("./app-settings-3CHCNIMD.js");
+    const { autoRunAfterSetupEnabled } = await import("./app-settings-H3INSR67.js");
     if (autoRunAfterSetupEnabled()) {
       try {
         await this.startDev(threadId);
@@ -6742,7 +6981,7 @@ var Orchestrator = class {
     }
     const isBrightsy = fresh.agent === "brightsy";
     const isOrchestration = isOrchestratorThread(fresh);
-    const { autoRenameBranchEnabled, getGithubGitAuthMode } = await import("./app-settings-3CHCNIMD.js");
+    const { autoRenameBranchEnabled, getGithubGitAuthMode } = await import("./app-settings-H3INSR67.js");
     const gitAuthMode = getGithubGitAuthMode();
     const worktreeDirective = isBrightsy || isOrchestration ? null : formatWorktreeDirective(fresh, {
       githubSlug: await resolveGithubRepoSlug(fresh.worktreePath).catch(
@@ -6848,7 +7087,7 @@ var Orchestrator = class {
       if (!this.stoppedTurns.has(threadId) && this.requireThread(threadId).agent === "cursor" && exitCode !== 0 && !assistantText && parts.length === 0) {
         const sessionId = result.sessionId || this.requireThread(threadId).sessionId || "";
         if (sessionId) {
-          const { recoverFinishedCursorRun } = await import("./cursor-recover-QSLWEZNA.js");
+          const { recoverFinishedCursorRun } = await import("./cursor-recover-NDMLLNYX.js");
           for (let i = 0; i < 8; i++) {
             const recovered = recoverFinishedCursorRun({
               agentId: sessionId,
@@ -7238,6 +7477,15 @@ var Orchestrator = class {
   getActiveRuns(threadRef) {
     return this.requireThread(threadRef).activeRuns ?? [];
   }
+  getSetupLog(threadRef) {
+    const thread = this.getThread(threadRef);
+    if (!thread) return readSetupLog(threadRef);
+    const snap = readSetupLog(thread.id);
+    if (snap.running && !this.processes.has(`${thread.id}:setup`)) {
+      return { ...snap, running: false };
+    }
+    return snap;
+  }
   async runSetup(threadRef) {
     const thread = this.requireThread(threadRef);
     this.assertNotGlobal(thread, "Setup");
@@ -7251,20 +7499,31 @@ var Orchestrator = class {
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       kill: () => abort.abort()
     });
+    beginSetupLog(thread.id);
     this.emit({ type: "setup_started", threadId: thread.id });
+    let finished = false;
+    const finish = (exitCode, source) => {
+      if (finished) return;
+      finished = true;
+      finishSetupLog(thread.id, exitCode, source);
+      this.emit({ type: "setup_finished", threadId: thread.id, exitCode });
+    };
     try {
       const setup = await runWorkspaceSetup(
         thread.repoPath,
         thread.worktreePath,
         (line) => {
+          appendSetupLog(thread.id, line);
           this.emit({ type: "setup_output", threadId: thread.id, line });
         },
         { signal: abort.signal }
       );
       if (!setup.ran) {
-        throw new Error(
-          "No setup script in .sideboard/settings.toml, .conductor/settings.toml, .cursor/worktrees.json, or script/setup (bin/setup, scripts/setup)"
-        );
+        const line = "No setup script in .sideboard/settings.toml, .conductor/settings.toml, .cursor/worktrees.json, or script/setup (bin/setup, scripts/setup)";
+        appendSetupLog(thread.id, line);
+        this.emit({ type: "setup_output", threadId: thread.id, line });
+        finish(null, null);
+        throw new Error(line);
       }
       if (setup.exitCode !== 0 && setup.exitCode !== null) {
         const live = readThread(thread.id);
@@ -7277,8 +7536,11 @@ var Orchestrator = class {
           });
         }
       }
-      this.emit({ type: "setup_finished", threadId: thread.id, exitCode: setup.exitCode });
+      finish(setup.exitCode, setup.source);
       return { exitCode: setup.exitCode, source: setup.source };
+    } catch (err) {
+      finish(null, null);
+      throw err;
     } finally {
       this.processes.delete(key);
     }
@@ -7605,7 +7867,7 @@ var Orchestrator = class {
         updateThread(thread.id, { title: meta.title });
       }
     }
-    const { autoArchiveOnMergeEnabled } = await import("./app-settings-3CHCNIMD.js");
+    const { autoArchiveOnMergeEnabled } = await import("./app-settings-H3INSR67.js");
     const latest = this.requireThread(thread.id);
     if (!shouldAutoArchiveOnPrMerge({
       previousPrState: prevState || null,
@@ -7922,7 +8184,7 @@ var Orchestrator = class {
     this.emit({ type: "status_changed", threadId: archived.id, status: "archived" });
     if (thread.repoPath && !isGlobalRepoPath(thread.repoPath)) {
       try {
-        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-ZXCUVCZC.js");
+        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-5UNDTN4G.js");
         await ensureWorkspace2(thread.repoPath);
       } catch {
       }
@@ -7949,7 +8211,7 @@ var Orchestrator = class {
           await runArchiveScript(thread.repoPath, thread.worktreePath);
         } catch {
         }
-        const { deleteBranchOnPurgeEnabled } = await import("./app-settings-3CHCNIMD.js");
+        const { deleteBranchOnPurgeEnabled } = await import("./app-settings-H3INSR67.js");
         const deleteBranch = opts?.deleteBranch ?? deleteBranchOnPurgeEnabled();
         await removeWorktree(thread.repoPath, thread.worktreePath, {
           deleteBranch: deleteBranch ? thread.branchName : void 0
@@ -7964,19 +8226,19 @@ var Orchestrator = class {
       throw new Error("Thread is not archived");
     }
     if (isGlobalThread(thread)) {
-      const { globalAgentCwd } = await import("./paths-UMEDHOS5.js");
+      const { globalAgentCwd } = await import("./paths-53TLA7VQ.js");
       updateThread(thread.id, { worktreePath: globalAgentCwd() });
       const restored2 = setStatus(thread.id, "idle");
       this.emit({ type: "status_changed", threadId: restored2.id, status: restored2.status });
       return restored2;
     }
-    if (!existsSync16(thread.worktreePath)) {
+    if (!existsSync17(thread.worktreePath)) {
       if (isCowboyThread(thread) || isPrimaryCheckoutThread(thread)) {
         throw new Error(
           `Cowboy checkout missing: ${thread.worktreePath}. Re-add the project folder, then restore.`
         );
       }
-      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-DPIREDFR.js");
+      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-T4SWFSTT.js");
       const slug = thread.worktreePath.split("/").pop();
       const dest = thread.worktreePath;
       await withRepoGitLock(thread.repoPath, async () => {
@@ -8086,7 +8348,7 @@ async function startOrchestration(opts) {
     sourceRef: "default",
     ...createOpts
   }).catch(async () => {
-    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-DPIREDFR.js");
+    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-T4SWFSTT.js");
     const repo = await resolveRepoRoot2(repoPath);
     const def = await resolveDefaultBranch2(repo);
     return orch.createThread({
@@ -8096,7 +8358,7 @@ async function startOrchestration(opts) {
       repoPath: repo
     });
   });
-  const { updateThread: upd } = await import("./thread-store-WGASXXXR.js");
+  const { updateThread: upd } = await import("./thread-store-KBFBHT5G.js");
   const updated = upd(thread.id, {
     sourceType: "orchestration",
     sourceRef: goal
@@ -8108,6 +8370,9 @@ async function startOrchestration(opts) {
 }
 
 export {
+  emptySetupLog,
+  mergeSetupOutput,
+  readSetupLog,
   schedulesPath,
   parseDurationMs,
   defaultScheduleName,
@@ -8194,11 +8459,13 @@ export {
   wrapReviewSkillMarkdown,
   REPO_REVIEW_PATH,
   REPO_REVIEW_NAME,
+  CONTEXT_REVIEW_PATH,
   REVIEW_REQUEST_PATH,
   LEGACY_REVIEW_REQUEST_PATH,
   REVIEW_REQUEST_NAME,
   REVIEW_REQUEST_PREFILL,
   shouldRefreshReviewRequestTemplate,
+  ensureReviewGuidelinesFile,
   ensureReviewSkillFile,
   resolveReviewGuidelines,
   ensureReviewRequestFile,
@@ -8240,6 +8507,7 @@ export {
   issueNeedsWorkspacePick,
   isAccountWideIssueSource,
   findLiveThreadForCreate,
+  findLiveThreadForCreateSource,
   boardPinIdentity,
   findBoardPin,
   syncBoardPins,
@@ -8293,6 +8561,7 @@ export {
   formatRenameBranchDirective,
   formatWorktreeDirective,
   formatWorktreeReminder,
+  formatPrGateDirective,
   formatProcessGuideDirective,
   formatLongRunningDirective,
   formatLongRunningReminder,