@sideboard-ai/core 0.1.152 → 0.1.155

package/dist/{chunk-7BQNSUR2.js → chunk-46ZTBUVJ.js}

@@ -33,18 +33,27 @@ import {
   summarizeTurnStderr,
   toolDescription,
   turnFailChatText
-} from "./chunk-EY6QXPPO.js";
+} from "./chunk-4THE3EY7.js";
 import {
-  addWorkspace,
-  ensureWorkspace,
-  removeWorkspace,
-  syncWorkspacesFromThreads
-} from "./chunk-67TIJ7S5.js";
+  extractPresentedPlan,
+  readPlanFile,
+  writePlanFile
+} from "./chunk-2SDMENAL.js";
+import {
+  releaseCaffeinateHoldForThread
+} from "./chunk-OCQPTUR7.js";
 import {
+  SLACK_REPLY_FORMATTING,
+  addWorkspace,
   assertOrchestratorCapableAgent,
   attachmentsFromWorktreePaths,
   coerceOrchestratorAgent,
+  coordinatorSystemPrompt,
+  coordinatorTurnReminder,
   createGlobalChat,
+  enrichWorkspacesWithGithub,
+  ensureGlobalCoordinatorCwd,
+  ensureWorkspace,
   healOrchestrationSoccerTitles,
   isCloudCoordinatorThread,
   isGlobalRepoPath,
@@ -54,24 +63,11 @@ import {
   isSlackCoordinatorThread,
   orchestratorSessionPoisonedByBuiltins,
   persistPendingFileAttachments,
+  removeWorkspace,
   stageAbsolutePathsAsAttachments,
-  stageBuffersAsAttachments
-} from "./chunk-SN6CMKF6.js";
-import {
-  extractPresentedPlan,
-  readPlanFile,
-  writePlanFile
-} from "./chunk-2SDMENAL.js";
-import {
-  releaseCaffeinateHoldForThread
-} from "./chunk-KLBOWJ74.js";
-import {
-  SLACK_REPLY_FORMATTING,
-  coordinatorSystemPrompt,
-  coordinatorTurnReminder,
-  enrichWorkspacesWithGithub,
-  ensureGlobalCoordinatorCwd
-} from "./chunk-7TIUOYBK.js";
+  stageBuffersAsAttachments,
+  syncWorkspacesFromThreads
+} from "./chunk-RNC3GR6L.js";
 import {
   addPrStackLayer,
   allocateTeamName,
@@ -119,7 +115,7 @@ import {
   withRepoGitLock,
   worktreeDisplayLabelForGroup,
   worktreeNameFromPath
-} from "./chunk-3JBMACYX.js";
+} from "./chunk-CJQLPPEJ.js";
 import {
   ATTACHMENTS_DIR,
   LEGACY_ATTACHMENTS_DIR
@@ -135,7 +131,7 @@ import {
   updateThread,
   withThreadLock,
   writeThread
-} from "./chunk-EUXOHTUK.js";
+} from "./chunk-LZQULFIT.js";
 import {
   ensureWorktreeSideboardIgnored
 } from "./chunk-SYFVUF2C.js";
@@ -162,7 +158,7 @@ import {
   stripNestedElectronEnv,
   updateAdvancedSettings,
   writeSecureJson
-} from "./chunk-CZD4NRDZ.js";
+} from "./chunk-D7EGJ3EI.js";
 import {
   writePrivateFile
 } from "./chunk-NSTQ6QKD.js";
@@ -175,9 +171,10 @@ import {
   sideboardReposDir,
   sideboardWorkspacesDir,
   threadLivePath,
+  threadsDir,
   workspaceSettingsSourceLabel,
   worktreesRoot
-} from "./chunk-BD2ICC4D.js";
+} from "./chunk-JTJHOYCU.js";
 
 // src/orchestrator/orchestrator.ts
 import { EventEmitter } from "events";
@@ -395,7 +392,7 @@ async function continueSourceThread(threadId, prompt) {
       await continueOnReply(threadId, prompt);
       return;
     }
-    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-256DFPSX.js");
+    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-3FWEKDAQ.js");
     await getOrchestrator2().send(threadId, prompt);
   } catch {
   }
@@ -655,7 +652,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";
@@ -736,9 +733,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-BHLUJ46D.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-4LHCZ2DC.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-TBX4MOFM.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-KX2FVVYT.js");
     ensureGlobalCoordinatorCwd2(
       isOrchestratorThread(thread) ? { orchestratorThreadId: thread.id } : void 0
     );
@@ -1940,6 +1937,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,
@@ -1950,7 +1949,7 @@ async function runSetupScript(repoPath, worktreePath, onLine, opts) {
   return {
     ran: true,
     exitCode,
-    source: workspaceSettingsSourceLabel(worktreePath, repoPath),
+    source,
     kill: handle.kill
   };
 }
@@ -2079,9 +2078,114 @@ 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 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/");
 }
@@ -2092,7 +2196,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;
@@ -2104,7 +2208,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) {
@@ -2125,12 +2229,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 {
@@ -2270,8 +2374,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();
@@ -2282,8 +2386,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 };
@@ -2300,14 +2404,14 @@ 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 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 {
@@ -2374,7 +2478,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
 var REQUIRE_AGENT_TIMEOUT_MS = 8e3;
@@ -2540,12 +2644,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();
@@ -2598,19 +2709,32 @@ 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;
 }
@@ -2836,42 +2960,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,
@@ -2880,7 +3015,7 @@ async function createThread(input, _onSetupLine) {
   });
   await requireAgent(resolved.agent);
   if (input.cowboy) {
-    const { cowboyModeEnabled } = await import("./app-settings-J3JBCUOT.js");
+    const { cowboyModeEnabled } = await import("./app-settings-VRQI3FIE.js");
     if (!cowboyModeEnabled()) {
       throw new Error(
         "Cowboy mode is off. Enable it in Settings \u2192 Advanced."
@@ -2938,7 +3073,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-CLC5UJC2.js");
+      const { ensureAbleTimeTask, issueAttachmentForAbleTimeTask } = await import("./abletime-JSTJLXAW.js");
       const task = await ensureAbleTimeTask({
         title: title?.trim() || "Untitled work",
         description: input.prompt?.trim() || void 0
@@ -2948,6 +3083,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;
@@ -2957,6 +3098,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}`;
@@ -2969,9 +3118,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") {
@@ -3010,15 +3169,6 @@ async function createThread(input, _onSetupLine) {
   await ensureWorkspace(repoPath);
   return readThread(thread.id) ?? thread;
 }
-async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("./agents-CUKWIM34.js");
-  await requireAgent(agent, { requireLinear: true });
-  const adapter = getAdapter2(agent);
-  if (!adapter.listLinearIssues) {
-    throw new Error(`${agent} does not support Linear issue listing`);
-  }
-  return adapter.listLinearIssues(repoPath);
-}
 
 // src/threads/cowboy.ts
 function isCowboyThread(thread) {
@@ -3034,11 +3184,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;
@@ -3115,7 +3265,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 {
@@ -3126,9 +3276,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 {
@@ -3140,7 +3290,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 {
@@ -3165,7 +3315,8 @@ function shouldReadThreadToHealReconcile(eventType, lastCheckAt, now) {
 // src/orchestrator/setup-last-error.ts
 function shouldStampSetupLastError(opts) {
   if (opts.turnInFlight) return false;
-  if (opts.status === "running") return false;
+  if (opts.status === "running" || opts.status === "queued") return false;
+  if (opts.hasQueuedPrompt) return false;
   return true;
 }
 function isStaleLastErrorDuringTurn(err) {
@@ -3324,26 +3475,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());
@@ -3361,7 +3512,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;
@@ -3371,11 +3522,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;
     }
@@ -3399,7 +3550,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);
@@ -3418,23 +3569,23 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-NECIQTAO.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-MQYNZXUK.js");
   await ensureWorkspace2(repoPath);
   const { ensureWorktreeSideboardIgnored: ensureWorktreeSideboardIgnored2 } = await import("./worktree-exclude-N5X5I422.js");
   await ensureWorktreeSideboardIgnored2(input.worktreePath);
   return thread;
 }
 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 {
@@ -3516,16 +3667,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 {
@@ -3545,7 +3696,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;
@@ -3616,7 +3767,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("|");
@@ -3679,7 +3830,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 {
@@ -3821,7 +3972,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);
@@ -3888,7 +4039,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
@@ -3900,10 +4051,10 @@ async function createPrStack(input, onSetupLine) {
 }
 
 // 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
   });
@@ -3911,7 +4062,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);
@@ -4047,11 +4198,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 {
@@ -4552,7 +4703,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}`);
@@ -4562,7 +4713,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"),
@@ -4572,12 +4723,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;
@@ -4620,9 +4771,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) {
@@ -4747,9 +4898,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";
@@ -4878,7 +5029,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;
@@ -4897,7 +5048,7 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!existsSync12(dir)) return;
+  if (!existsSync13(dir)) return;
   let entries;
   try {
     entries = readdirSync4(dir);
@@ -4906,8 +5057,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 {
@@ -4918,7 +5069,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;
@@ -4928,12 +5079,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 {
@@ -4953,17 +5104,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,
@@ -4989,7 +5140,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) {
@@ -5082,26 +5233,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;
@@ -5403,8 +5554,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 = {
@@ -5414,7 +5565,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);
@@ -5514,9 +5665,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 {
@@ -5639,7 +5790,7 @@ function formatScheduledPrompt(name, prompt) {
 ${prompt}`;
 }
 async function defaultDeps() {
-  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-256DFPSX.js");
+  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-3FWEKDAQ.js");
   const orch = getOrchestrator2();
   return {
     findThread: (id) => findThreadByRef(id),
@@ -5879,7 +6030,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;
@@ -5898,7 +6049,7 @@ var Orchestrator = class {
           orphans: orphans.map((o) => ({ path: o.path, repoPath: o.repoPath }))
         });
       }
-      const { autoCleanupOrphansEnabled } = await import("./app-settings-J3JBCUOT.js");
+      const { autoCleanupOrphansEnabled } = await import("./app-settings-VRQI3FIE.js");
       if (autoCleanupOrphansEnabled() && shouldRunWorktreeCleanup() && orphans.length > 0) {
         await cleanupOrphanWorktrees({ repoPaths });
       }
@@ -6138,7 +6289,7 @@ var Orchestrator = class {
     }
     await setup;
     if (skipSetup) return;
-    const { autoRunAfterSetupEnabled } = await import("./app-settings-J3JBCUOT.js");
+    const { autoRunAfterSetupEnabled } = await import("./app-settings-VRQI3FIE.js");
     if (autoRunAfterSetupEnabled()) {
       try {
         await this.startDev(threadId);
@@ -6149,21 +6300,11 @@ var Orchestrator = class {
   /** Run workspace setup after a new worktree is created (no-op if none configured). */
   async runSetupAfterCreate(threadId) {
     try {
-      await this.runSetup(threadId);
+      await this.runSetup(threadId, { stampLastError: false });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       if (/no setup script/i.test(message)) return;
       if (/already running/i.test(message)) return;
-      const live = readThread(threadId);
-      if (!shouldStampSetupLastError({
-        turnInFlight: this.activeTurns.has(threadId) || this.startingTurns.has(threadId),
-        status: live?.status
-      })) {
-        return;
-      }
-      updateThread(threadId, {
-        lastError: `Setup failed: ${message}`
-      });
     }
   }
   listWorkspaces() {
@@ -6446,7 +6587,7 @@ var Orchestrator = class {
     }
     const isBrightsy = fresh.agent === "brightsy";
     const isOrchestration = isOrchestratorThread(fresh);
-    const { autoRenameBranchEnabled, getGithubGitAuthMode } = await import("./app-settings-J3JBCUOT.js");
+    const { autoRenameBranchEnabled, getGithubGitAuthMode } = await import("./app-settings-VRQI3FIE.js");
     const gitAuthMode = getGithubGitAuthMode();
     const worktreeDirective = isBrightsy || isOrchestration ? null : formatWorktreeDirective(fresh, {
       githubSlug: await resolveGithubRepoSlug(fresh.worktreePath).catch(
@@ -6552,7 +6693,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-NOQYOFRF.js");
+          const { recoverFinishedCursorRun } = await import("./cursor-recover-L5MD6MBO.js");
           for (let i = 0; i < 8; i++) {
             const recovered = recoverFinishedCursorRun({
               agentId: sessionId,
@@ -6942,7 +7083,16 @@ var Orchestrator = class {
   getActiveRuns(threadRef) {
     return this.requireThread(threadRef).activeRuns ?? [];
   }
-  async runSetup(threadRef) {
+  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, opts) {
     const thread = this.requireThread(threadRef);
     this.assertNotGlobal(thread, "Setup");
     const key = `${thread.id}:setup`;
@@ -6955,34 +7105,49 @@ 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);
-        if (shouldStampSetupLastError({
+        if ((opts?.stampLastError ?? true) && shouldStampSetupLastError({
           turnInFlight: this.activeTurns.has(thread.id) || this.startingTurns.has(thread.id),
-          status: live?.status
+          status: live?.status,
+          hasQueuedPrompt: Boolean(live?.queue?.length)
         })) {
           updateThread(thread.id, {
             lastError: `Setup exited ${setup.exitCode}`
           });
         }
       }
-      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);
     }
@@ -7309,7 +7474,7 @@ var Orchestrator = class {
         updateThread(thread.id, { title: meta.title });
       }
     }
-    const { autoArchiveOnMergeEnabled } = await import("./app-settings-J3JBCUOT.js");
+    const { autoArchiveOnMergeEnabled } = await import("./app-settings-VRQI3FIE.js");
     const latest = this.requireThread(thread.id);
     if (!shouldAutoArchiveOnPrMerge({
       previousPrState: prevState || null,
@@ -7626,7 +7791,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-NECIQTAO.js");
+        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-MQYNZXUK.js");
         await ensureWorkspace2(thread.repoPath);
       } catch {
       }
@@ -7653,7 +7818,7 @@ var Orchestrator = class {
           await runArchiveScript(thread.repoPath, thread.worktreePath);
         } catch {
         }
-        const { deleteBranchOnPurgeEnabled } = await import("./app-settings-J3JBCUOT.js");
+        const { deleteBranchOnPurgeEnabled } = await import("./app-settings-VRQI3FIE.js");
         const deleteBranch = opts?.deleteBranch ?? deleteBranchOnPurgeEnabled();
         await removeWorktree(thread.repoPath, thread.worktreePath, {
           deleteBranch: deleteBranch ? thread.branchName : void 0
@@ -7668,19 +7833,19 @@ var Orchestrator = class {
       throw new Error("Thread is not archived");
     }
     if (isGlobalThread(thread)) {
-      const { globalAgentCwd } = await import("./paths-QCI3MTO5.js");
+      const { globalAgentCwd } = await import("./paths-RRCLNSJB.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-HTUM35NT.js");
+      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-PEWDAX5O.js");
       const slug = thread.worktreePath.split("/").pop();
       const dest = thread.worktreePath;
       await withRepoGitLock(thread.repoPath, async () => {
@@ -7790,7 +7955,7 @@ async function startOrchestration(opts) {
     sourceRef: "default",
     ...createOpts
   }).catch(async () => {
-    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-HTUM35NT.js");
+    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-PEWDAX5O.js");
     const repo = await resolveRepoRoot2(repoPath);
     const def = await resolveDefaultBranch2(repo);
     return orch.createThread({
@@ -7800,7 +7965,7 @@ async function startOrchestration(opts) {
       repoPath: repo
     });
   });
-  const { updateThread: upd } = await import("./thread-store-57ZLHR3A.js");
+  const { updateThread: upd } = await import("./thread-store-MVQU6HPJ.js");
   const updated = upd(thread.id, {
     sourceType: "orchestration",
     sourceRef: goal
@@ -7833,7 +7998,6 @@ export {
   findBoardPr,
   assembleHomeBoard,
   HOME_BOARD_AGENT_HINT,
-  listLinearIssues,
   readTurnLive,
   resolveScheduleThreadId,
   listSchedules,