@sideboard-ai/core 0.1.157 → 0.1.158

package/dist/{chunk-SUCJAWV4.js → chunk-FBFIOVDH.js}

@@ -33,12 +33,12 @@ import {
   summarizeTurnStderr,
   toolDescription,
   turnFailChatText
-} from "./chunk-KQ4JOGUH.js";
+} from "./chunk-EPQIOAAY.js";
 import {
   extractPresentedPlan,
   readPlanFile,
   writePlanFile
-} from "./chunk-2SDMENAL.js";
+} from "./chunk-JV4VNFMS.js";
 import {
   releaseCaffeinateHoldForThread
 } from "./chunk-OCQPTUR7.js";
@@ -67,7 +67,7 @@ import {
   stageAbsolutePathsAsAttachments,
   stageBuffersAsAttachments,
   syncWorkspacesFromThreads
-} from "./chunk-4I4VKAPZ.js";
+} from "./chunk-3SUZMPGL.js";
 import {
   addPrStackLayer,
   allocateTeamName,
@@ -115,11 +115,13 @@ import {
   withRepoGitLock,
   worktreeDisplayLabelForGroup,
   worktreeNameFromPath
-} from "./chunk-CJQLPPEJ.js";
+} from "./chunk-A7QXLYBN.js";
 import {
   ATTACHMENTS_DIR,
-  LEGACY_ATTACHMENTS_DIR
-} from "./chunk-NVXVEGGM.js";
+  DETACHED_JOBS_DIR,
+  LEGACY_ATTACHMENTS_DIR,
+  LEGACY_DETACHED_JOBS_DIR
+} from "./chunk-5U4NZLBH.js";
 import {
   appendMessage,
   createEmptyThread,
@@ -394,7 +396,7 @@ async function continueSourceThread(threadId, prompt) {
       await continueOnReply(threadId, prompt);
       return;
     }
-    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-KQO4MXBI.js");
+    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-J727WIJY.js");
     await getOrchestrator2().send(threadId, prompt);
   } catch {
   }
@@ -654,7 +656,7 @@ async function pollSlackOutboundWatches(opts) {
 }
 
 // src/orchestrator/orchestrator.ts
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 
 // src/agents/spawn.ts
 import { createInterface } from "readline";
@@ -735,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-QV7CC7SK.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-REI55FZ6.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-AM47SATF.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-GZESIQNH.js");
     ensureGlobalCoordinatorCwd2(
       isOrchestratorThread(thread) ? { orchestratorThreadId: thread.id } : void 0
     );
@@ -2479,8 +2481,232 @@ function notifyParentOfChildHalt(child, status, send) {
   return true;
 }
 
+// src/mcp/wait-for-job.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readdirSync as readdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname3, join as join10 } from "path";
+
+// src/mcp/wait-for-turn.ts
+var MCP_WAIT_FOR_TURN_MAX_MS = 45e3;
+function mcpWaitForTurnTimeoutMs(requested) {
+  const n = requested ?? MCP_WAIT_FOR_TURN_MAX_MS;
+  if (!Number.isFinite(n)) return MCP_WAIT_FOR_TURN_MAX_MS;
+  return Math.min(Math.max(1e3, Math.floor(n)), MCP_WAIT_FOR_TURN_MAX_MS);
+}
+var MCP_WAIT_STILL_RUNNING_HINT = "Child is still working. Call wait_for_turn again. Do not send a check-in prompt or assume a hang while progress is updating.";
+var MCP_WAIT_QUEUED_HINT = "Child is queued waiting for a concurrency slot \u2014 it has not started yet. Call wait_for_turn again. Do not send a check-in prompt, force_stop, or assume it failed to start.";
+function mcpWaitStillRunningHint(status) {
+  return status === "queued" ? MCP_WAIT_QUEUED_HINT : MCP_WAIT_STILL_RUNNING_HINT;
+}
+var MCP_WAIT_STOPPED_HINT = "Child was stopped before the turn finished. Do not treat this as success. send_to_thread to resume, or tell the user.";
+var MCP_WAIT_BROKEN_HINT = "Child worktree is broken (missing on disk). Tell the user \u2014 do not treat this as success.";
+var MCP_WAIT_ERROR_HINT = "Child turn failed. lastError/text is the failure \u2014 switch agent, tell the user, or retry. Do not treat empty text as success.";
+function mcpWaitFinishedHint(status) {
+  if (status === "stopped") return MCP_WAIT_STOPPED_HINT;
+  if (status === "broken") return MCP_WAIT_BROKEN_HINT;
+  if (status === "error") return MCP_WAIT_ERROR_HINT;
+  return void 0;
+}
+
+// src/mcp/wait-for-job.ts
+var MAX_JOB_CONTINUES = 8;
+var MCP_WAIT_JOB_STILL_RUNNING_HINT = "Job is still running. present_artifact type=log with the same artifact_id and content=delta (new lines only). Then call wait_for_job again. Do not end the turn or tell the user you will let them know later.";
+var JOB_ID_RE = /^[a-zA-Z0-9._-]{1,64}$/;
+function mcpWaitForJobTimeoutMs(requested) {
+  return mcpWaitForTurnTimeoutMs(requested);
+}
+function sanitizeDetachedJobId(id) {
+  const s = id.trim();
+  if (!JOB_ID_RE.test(s)) {
+    throw new Error(`detached-job id must be 1\u201364 chars [A-Za-z0-9._-], got ${JSON.stringify(id)}`);
+  }
+  return s;
+}
+function jobAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readIntFile(file) {
+  if (!existsSync8(file)) return null;
+  const n = Number.parseInt(readFileSync7(file, "utf8").trim(), 10);
+  return Number.isInteger(n) ? n : null;
+}
+function jobDir(root, id, legacy = false) {
+  return join10(root, legacy ? LEGACY_DETACHED_JOBS_DIR : DETACHED_JOBS_DIR, id);
+}
+function resolveJobDir(root, id) {
+  const modern = jobDir(root, id, false);
+  if (existsSync8(modern)) return modern;
+  const legacy = jobDir(root, id, true);
+  if (existsSync8(legacy)) return legacy;
+  return modern;
+}
+function listJobIdsIn(root, rel) {
+  const dir = join10(root, rel);
+  if (!existsSync8(dir)) return [];
+  return readdirSync3(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && JOB_ID_RE.test(e.name)).map((e) => e.name);
+}
+function listRunningDetachedJobs(worktreePath) {
+  const root = worktreePath.trim();
+  if (!root) return [];
+  const ids = /* @__PURE__ */ new Set([
+    ...listJobIdsIn(root, DETACHED_JOBS_DIR),
+    ...listJobIdsIn(root, LEGACY_DETACHED_JOBS_DIR)
+  ]);
+  const running = [];
+  for (const id of ids) {
+    const dir = resolveJobDir(root, id);
+    const pid = readIntFile(join10(dir, "pid"));
+    if (pid != null && jobAlive(pid)) running.push(id);
+  }
+  return running.sort();
+}
+function looksLikeDeferredDonePromise(text) {
+  const t = (text ?? "").trim();
+  if (!t) return false;
+  return /\b(i['’]?ll|i will)\s+let you know\b/i.test(t) || /\blet you know when\b/i.test(t) || /\b(check back|ping me)\s+when\b/i.test(t) || /\bi(?:['’]ll| will)\s+(report|update you)\s+when\b/i.test(t);
+}
+function formatJobStillRunningContinuePrompt(jobIds) {
+  const ids = jobIds.join(", ");
+  return [
+    `Detached job still running: ${ids}.`,
+    "Do not end this turn. Loop wait_for_job (same id) and present_artifact type=log with content=delta until stillRunning is false.",
+    "Then report the result. Do not tell the user you will let them know later."
+  ].join(" ");
+}
+function formatDeferredDoneContinuePrompt() {
+  return [
+    "You ended the turn after promising to report later, but no detached job is running.",
+    "If tests/pack/deploy still need to run: start once with detached-job.js, present_artifact type=log, then loop wait_for_job until stillRunning is false.",
+    "Do not say you will let the user know later."
+  ].join(" ");
+}
+function turnWatchedDetachedJob(parts) {
+  return parts.some((p) => {
+    if (p.type !== "tool") return false;
+    if (/wait_for_job$/i.test(p.name ?? "")) return true;
+    const blob = [p.name, p.detail, p.description, p.input ? JSON.stringify(p.input) : ""].filter(Boolean).join(" ");
+    return /detached-job\.js\b/i.test(blob);
+  });
+}
+function planJobContinue(opts) {
+  if (opts.isOrchestrator) return { action: "none" };
+  if (opts.agent === "brightsy") return { action: "none" };
+  if (opts.queueLength > 0) return { action: "none" };
+  if (opts.continueCount >= MAX_JOB_CONTINUES) return { action: "none" };
+  const farewell = looksLikeDeferredDonePromise(opts.chatText);
+  if (opts.runningJobIds.length > 0 && (farewell || opts.watchedJob)) {
+    return {
+      action: "wait",
+      jobIds: opts.runningJobIds,
+      prompt: formatJobStillRunningContinuePrompt(opts.runningJobIds)
+    };
+  }
+  if (looksLikeDeferredDonePromise(opts.chatText) && !opts.alreadyNudged) {
+    return { action: "nudge", prompt: formatDeferredDoneContinuePrompt() };
+  }
+  return { action: "none" };
+}
+function tailProgress(logFile, maxLines = 12) {
+  if (!existsSync8(logFile)) return "(no log yet)";
+  const lines = readFileSync7(logFile, "utf8").split("\n");
+  return lines.slice(-maxLines).join("\n");
+}
+function readLogLines(file) {
+  if (!existsSync8(file)) return [];
+  const lines = readFileSync7(file, "utf8").split("\n");
+  if (lines.length && lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+function takeDelta(logFile, cursorFile) {
+  const lines = readLogLines(logFile);
+  const cursor = readIntFile(cursorFile) ?? 0;
+  const start = Math.min(Math.max(0, cursor), lines.length);
+  return { delta: lines.slice(start).join("\n"), nextCursor: lines.length };
+}
+function snapshotJob(dir) {
+  const pid = readIntFile(join10(dir, "pid"));
+  const running = pid != null && jobAlive(pid);
+  return {
+    pid,
+    running,
+    exitCode: readIntFile(join10(dir, "exit")),
+    log: join10(dir, "log"),
+    cursor: join10(dir, "present.cursor"),
+    progress: tailProgress(join10(dir, "log"))
+  };
+}
+function toResult(id, snap, extra) {
+  const failed = extra?.failed === true || !snap.running && snap.exitCode != null && snap.exitCode !== 0;
+  const ok = !snap.running && snap.exitCode === 0;
+  const stillRunning = snap.running && !ok;
+  const { delta, nextCursor } = takeDelta(snap.log, snap.cursor);
+  try {
+    mkdirSync3(dirname3(snap.cursor), { recursive: true });
+    writeFileSync4(snap.cursor, `${nextCursor}
+`);
+  } catch {
+  }
+  const status = ok ? "ok" : failed && !stillRunning ? "failed" : stillRunning ? "running" : "idle";
+  return {
+    stillRunning,
+    ok,
+    failed: Boolean(failed && !stillRunning && !ok),
+    status,
+    id,
+    pid: snap.pid,
+    exitCode: snap.exitCode ?? void 0,
+    delta,
+    progress: extra?.progress ?? snap.progress,
+    hint: stillRunning ? MCP_WAIT_JOB_STILL_RUNNING_HINT : void 0
+  };
+}
+async function sleepMs(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForDetachedJob(cwd, id, opts) {
+  const jobId = sanitizeDetachedJobId(id);
+  const root = cwd.trim() || process.cwd();
+  const dir = resolveJobDir(root, jobId);
+  const timeoutMs = mcpWaitForJobTimeoutMs(opts?.timeoutMs);
+  const sleep = opts?.sleep ?? sleepMs;
+  if (!existsSync8(dir)) {
+    return {
+      stillRunning: false,
+      ok: false,
+      failed: true,
+      status: "failed",
+      id: jobId,
+      delta: "",
+      progress: "No detached job. Start one first.",
+      hint: "Start with detached-job.js start <id> -- <command>, then call wait_for_job again."
+    };
+  }
+  const deadline = Date.now() + timeoutMs;
+  let snap = snapshotJob(dir);
+  if (snap.exitCode === 0 && !snap.running) return toResult(jobId, snap);
+  if (!snap.running && snap.pid == null && snap.progress === "(no log yet)") {
+    return toResult(jobId, snap, {
+      failed: true,
+      progress: "No detached job. Start one first."
+    });
+  }
+  while (Date.now() < deadline) {
+    snap = snapshotJob(dir);
+    if (snap.exitCode === 0 && !snap.running) return toResult(jobId, snap);
+    if (!snap.running) return toResult(jobId, snap, { failed: true });
+    await sleep(Math.min(2e3, Math.max(50, deadline - Date.now())));
+  }
+  snap = snapshotJob(dir);
+  return toResult(jobId, snap);
+}
+
 // src/threads/create.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 
 // src/detect/detect.ts
 var REQUIRE_AGENT_TIMEOUT_MS = 8e3;
@@ -3000,7 +3226,7 @@ function reuseLiveThread(input, repoPath, match) {
 }
 async function createThread(input, _onSetupLine) {
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!existsSync8(repoPath)) {
+  if (!existsSync9(repoPath)) {
     throw new Error(`Repo not found: ${repoPath}`);
   }
   const reused = reuseLiveThread(input, repoPath, {
@@ -3186,11 +3412,11 @@ function shouldRemoveWorktreeOnTeardown(thread) {
 
 // src/store/turn-live.ts
 import {
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   renameSync,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync4,
-  readFileSync as readFileSync7
+  writeFileSync as writeFileSync5,
+  readFileSync as readFileSync8
 } from "fs";
 var buffers = /* @__PURE__ */ new Map();
 var FLUSH_MS = 800;
@@ -3267,7 +3493,7 @@ function writeTurnLive(threadId, progress) {
   const path = threadLivePath(threadId);
   const tmp = `${path}.${process.pid}.tmp`;
   try {
-    writeFileSync4(tmp, JSON.stringify(progress), "utf8");
+    writeFileSync5(tmp, JSON.stringify(progress), "utf8");
     renameSync(tmp, path);
   } catch {
     try {
@@ -3278,9 +3504,9 @@ function writeTurnLive(threadId, progress) {
 }
 function readTurnLive(threadId) {
   const path = threadLivePath(threadId);
-  if (!existsSync9(path)) return null;
+  if (!existsSync10(path)) return null;
   try {
-    const raw = JSON.parse(readFileSync7(path, "utf8"));
+    const raw = JSON.parse(readFileSync8(path, "utf8"));
     if (!raw || typeof raw.summary !== "string") return null;
     return raw;
   } catch {
@@ -3292,7 +3518,7 @@ function clearTurnLive(threadId) {
   if (buf?.timer) clearTimeout(buf.timer);
   buffers.delete(threadId);
   const path = threadLivePath(threadId);
-  if (!existsSync9(path)) return;
+  if (!existsSync10(path)) return;
   try {
     unlinkSync2(path);
   } catch {
@@ -3477,26 +3703,26 @@ function createQuotaFailoverChat(from, fallbackAgent, limitText) {
 import { execFileSync } from "child_process";
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   mkdtempSync,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync8,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync9,
   rmSync
 } from "fs";
 import { tmpdir } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import { createRequire } from "module";
-var CONDUCTOR_APP_SUPPORT = join10(
+var CONDUCTOR_APP_SUPPORT = join11(
   process.env.HOME ?? "",
   "Library",
   "Application Support",
   "com.conductor.app"
 );
-var CONDUCTOR_DB = join10(CONDUCTOR_APP_SUPPORT, "conductor.db");
-var CURSOR_SDK_STORE = join10(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+var CONDUCTOR_DB = join11(CONDUCTOR_APP_SUPPORT, "conductor.db");
+var CURSOR_SDK_STORE = join11(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
 function thisModuleFile() {
   const cjsFile = typeof __filename !== "undefined" ? __filename : "";
-  return cjsFile || process.argv[1] || join10(process.cwd(), "package.json");
+  return cjsFile || process.argv[1] || join11(process.cwd(), "package.json");
 }
 function openReadonlySqlite(file) {
   const req = createRequire(thisModuleFile());
@@ -3514,21 +3740,21 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !existsSync10(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !existsSync11(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
   try {
-    hashes = readdirSync3(CURSOR_SDK_STORE);
+    hashes = readdirSync4(CURSOR_SDK_STORE);
   } catch {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = join10(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!existsSync10(agentsFile)) continue;
+    const agentsFile = join11(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!existsSync11(agentsFile)) continue;
     let text;
     try {
-      text = readFileSync8(agentsFile, "utf8");
+      text = readFileSync9(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -3552,7 +3778,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!existsSync10(input.worktreePath)) {
+  if (!existsSync11(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -3571,23 +3797,23 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-Q2VCHIAS.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-OCEPZXFD.js");
   await ensureWorkspace2(repoPath);
   const { ensureWorktreeSideboardIgnored: ensureWorktreeSideboardIgnored2 } = await import("./worktree-exclude-N5X5I422.js");
   await ensureWorktreeSideboardIgnored2(input.worktreePath);
   return thread;
 }
 function listConductorWorkspaces() {
-  if (!existsSync10(CONDUCTOR_DB)) {
+  if (!existsSync11(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = mkdtempSync(join10(tmpdir(), "sideboard-conductor-"));
-  const snapshot = join10(tmp, "conductor.db");
+  const tmp = mkdtempSync(join11(tmpdir(), "sideboard-conductor-"));
+  const snapshot = join11(tmp, "conductor.db");
   try {
     copyFileSync2(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if (existsSync10(src)) {
+      if (existsSync11(src)) {
         try {
           copyFileSync2(src, `${snapshot}${suffix}`);
         } catch {
@@ -3669,16 +3895,16 @@ function listConductorWorkspaces() {
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!existsSync10(CONDUCTOR_DB)) {
+  if (!existsSync11(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = mkdtempSync(join10(tmpdir(), "sideboard-conductor-"));
-  const snapshot = join10(tmp, "conductor.db");
+  const tmp = mkdtempSync(join11(tmpdir(), "sideboard-conductor-"));
+  const snapshot = join11(tmp, "conductor.db");
   try {
     copyFileSync2(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if (existsSync10(src)) {
+      if (existsSync11(src)) {
         try {
           copyFileSync2(src, `${snapshot}${suffix}`);
         } catch {
@@ -3698,7 +3924,7 @@ function importConductorWorkspace(workspaceId) {
       ).get(workspaceId);
       if (!row) throw new Error(`Conductor workspace not found: ${workspaceId}`);
       const worktreePath = String(row.workspacePath);
-      if (!existsSync10(worktreePath)) {
+      if (!existsSync11(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -3769,7 +3995,7 @@ async function importConductorWorkspaceAsync(workspaceId) {
 }
 
 // src/threads/stack-layers.ts
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 function stackIdFrom(stack) {
   if (stack.stackNumber != null) return `gh-stack-${stack.stackNumber}`;
   const key = stack.layers.map((l) => l.branchName).join("|");
@@ -3832,7 +4058,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 && existsSync11(checkedOut.path)) {
+  if (checkedOut?.path && existsSync12(checkedOut.path)) {
     if (input.reuseExistingWorktree !== false) {
       worktreePath = checkedOut.path;
     } else {
@@ -3974,7 +4200,7 @@ async function initStackFromThread(input, onSetupLine) {
 async function createPrStack(input, onSetupLine) {
   await requireAgent(input.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!existsSync11(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
+  if (!existsSync12(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);
@@ -4041,7 +4267,7 @@ async function createPrStack(input, onSetupLine) {
     }
   }
   const claimed = new Set(threads.map((t) => t.worktreePath));
-  if (!claimed.has(bootstrap.worktreePath) && existsSync11(bootstrap.worktreePath)) {
+  if (!claimed.has(bootstrap.worktreePath) && existsSync12(bootstrap.worktreePath)) {
     try {
       await removeWorktree(repoPath, bootstrap.worktreePath, {
         deleteBranch: bootstrap.branchName
@@ -4053,10 +4279,10 @@ async function createPrStack(input, onSetupLine) {
 }
 
 // src/diff/diff.ts
-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";
+import { existsSync as existsSync13, mkdirSync as mkdirSync4, readFileSync as readFileSync10, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname4, join as join12 } from "path";
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !existsSync12(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !existsSync13(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -4064,7 +4290,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !existsSync12(worktreePath)) {
+  if (!worktreePath || !existsSync13(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -4200,11 +4426,11 @@ new file mode 100644
   };
 }
 async function untrackedPatch(worktreePath, path, maxHunk) {
-  const abs = join11(worktreePath, path);
+  const abs = join12(worktreePath, path);
   try {
     const st = statSync2(abs);
     if (st.isFile() && st.size > maxHunk) {
-      const buf = readFileSync9(abs).subarray(0, maxHunk);
+      const buf = readFileSync10(abs).subarray(0, maxHunk);
       return syntheticAddPatch(path, buf.toString("utf8"), maxHunk);
     }
   } catch {
@@ -4705,7 +4931,7 @@ var DEFAULT_UPLOAD_MAX_BYTES = 5e7;
 function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-  const abs = join11(worktreePath, relativePath);
+  const abs = join12(worktreePath, relativePath);
   const st = statSync2(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
@@ -4715,7 +4941,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = readFileSync9(abs);
+  const buf = readFileSync10(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -4725,12 +4951,12 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = join11(worktreePath, relativePath);
+  const abs = join12(worktreePath, relativePath);
   const st = statSync2(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = readFileSync9(abs);
+  const buf = readFileSync10(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -4773,9 +4999,9 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = join11(worktreePath, relativePath);
-  mkdirSync3(dirname3(abs), { recursive: true });
-  writeFileSync5(abs, content, "utf8");
+  const abs = join12(worktreePath, relativePath);
+  mkdirSync4(dirname4(abs), { recursive: true });
+  writeFileSync6(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getDiffSummary(worktreePath, repoPath, opts) {
@@ -4900,9 +5126,9 @@ async function confirmLand(thread, opts) {
 }
 
 // src/skills/discover.ts
-import { existsSync as existsSync13, readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync3 } from "fs";
+import { existsSync as existsSync14, readdirSync as readdirSync5, readFileSync as readFileSync11, statSync as statSync3 } from "fs";
 import { homedir } from "os";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 
 // src/skills/bundled/long-running.ts
 var LONG_RUNNING_SKILL_COMMAND = "long-running";
@@ -4913,7 +5139,7 @@ var LONG_RUNNING_SKILL_BODY = `# Long-running jobs
 
 A Sideboard or Cursor **worktree turn** SIGTERMs the agent shell (and its process group) when the user sends another message or the turn is interrupted. \`block_until_ms: 0\` is not enough \u2014 the child stays in that group.
 
-Do **not** ask the human to check back. Detach, then **wait** in 45s slices (same idea as MCP \`wait_for_turn\`) until \`stillRunning\` is false.
+Do **not** ask the human to check back. Detach, then **wait** in 45s slices (MCP \`wait_for_job\`, same idea as \`wait_for_turn\`) until \`stillRunning\` is false. Do not end the turn with \u201CI\u2019ll let you know.\u201D
 
 ## Tool
 
@@ -4923,7 +5149,8 @@ Use the helper from the Sideboard playbook \u2014 an absolute \`node "\u2026" st
 # Start (exits in ~1s; job survives this turn)
 node <detached-job.js> start <id> -- <command> [args...]
 
-# Wait \u2014 returns within ~45s even if the job is still going
+# Wait \u2014 prefer MCP wait_for_job (same 45s / stillRunning contract).
+# Shell fallback:
 node <detached-job.js> wait <id>
 
 # Block until the process exits (humans / a turn that will not be interrupted)
@@ -4936,7 +5163,7 @@ node <detached-job.js> status <id>
 
 Wait JSON:
 
-- \`stillRunning: true\` \u2192 exit 2 \u2192 **call wait again**. Progress is in \`progress\` / \`phase\`. Do not start a second job. Do not ping the user.
+- \`stillRunning: true\` \u2192 **call wait_for_job again** (or shell wait). Progress is in \`progress\` / \`phase\`. Do not start a second job. Do not ping the user.
 - \`ok: true\` \u2192 exit 0 \u2192 continue the rest of the task.
 - \`failed: true\` \u2192 exit 1 \u2192 read \`progress\`, fix, start **once**.
 
@@ -4966,7 +5193,7 @@ node <detached-job.js> wait --pid-file FILE --log-file FILE [--ok-pattern TEXT]
 
 1. \`start\` once. If JSON says \`already-running\`, do not start again.
 2. Immediately \`present_artifact\` \`type=log\` (same \`artifact_id\`, \`status=running\`) \u2014 the human should see **working** in the side column, not a \u201Ccheck back later\u201D message.
-3. Loop \`wait\` (use \`--timeout-ms 15000\` for a livelier pane). After each slice, \`present_artifact\` the same id with \`content=delta\` only.
+3. Loop \`wait_for_job\` (or shell \`wait\`). After each slice, \`present_artifact\` the same id with \`content=delta\` only.
 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.
@@ -5031,7 +5258,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = readFileSync10(skillMd, "utf8");
+    const content = readFileSync11(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -5050,17 +5277,17 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!existsSync13(dir)) return;
+  if (!existsSync14(dir)) return;
   let entries;
   try {
-    entries = readdirSync4(dir);
+    entries = readdirSync5(dir);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const skillMd = join12(dir, entry, "SKILL.md");
-    if (!existsSync13(skillMd)) continue;
+    const skillMd = join13(dir, entry, "SKILL.md");
+    if (!existsSync14(skillMd)) continue;
     try {
       if (!statSync3(skillMd).isFile()) continue;
     } catch {
@@ -5071,22 +5298,22 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!existsSync13(pluginsRoot)) return;
+  if (!existsSync14(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
     try {
-      entries = readdirSync4(dir);
+      entries = readdirSync5(dir);
     } catch {
       return;
     }
     if (lookingForSkillsDir && entries.includes("SKILL.md")) {
-      const skill = readSkill(join12(dir, "SKILL.md"), "cli");
+      const skill = readSkill(join13(dir, "SKILL.md"), "cli");
       if (skill) out.push(skill);
     }
     for (const entry of entries) {
       if (entry === "node_modules" || entry === ".git") continue;
-      const full = join12(dir, entry);
+      const full = join13(dir, entry);
       try {
         if (!statSync3(full).isDirectory()) continue;
       } catch {
@@ -5106,17 +5333,17 @@ function discoverSkills(worktreePath) {
   const home = homedir();
   const collected = [];
   for (const rel of [".claude/skills", ".cursor/skills", ".sideboard/skills", ".brightsy/skills", "skills"]) {
-    scanSkillsDir(join12(worktreePath, rel), "workspace", collected);
+    scanSkillsDir(join13(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    join12(home, ".claude/skills"),
-    join12(home, ".cursor/skills"),
-    join12(home, ".sideboard/skills"),
-    join12(home, ".brightsy/skills")
+    join13(home, ".claude/skills"),
+    join13(home, ".cursor/skills"),
+    join13(home, ".sideboard/skills"),
+    join13(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills(join12(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills(join13(home, ".claude/plugins"), collected);
   collected.push(...bundledSkills());
   const rank = {
     workspace: 0,
@@ -5142,7 +5369,7 @@ function readSkillBody(skillPath, maxChars = 12e3) {
 \u2026(truncated)` : body;
     }
   }
-  const raw = readFileSync10(skillPath, "utf8");
+  const raw = readFileSync11(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -5235,27 +5462,27 @@ function expandComposerPrompt(worktreePath, prompt, opts) {
 }
 
 // src/agents/instructions.ts
-import { existsSync as existsSync15, readFileSync as readFileSync11, statSync as statSync4 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync12, statSync as statSync4 } from "fs";
+import { join as join15 } from "path";
 
 // src/skills/detached-job-path.ts
-import { existsSync as existsSync14 } from "fs";
-import { dirname as dirname4, join as join13 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { dirname as dirname5, join as join14 } from "path";
 import { fileURLToPath } from "url";
 function packagedDetachedJobPath() {
   const dir = packagedMcpDir();
   if (!dir) return null;
-  const script = join13(dir, "scripts", "detached-job.js");
-  return existsSync14(script) ? script : null;
+  const script = join14(dir, "scripts", "detached-job.js");
+  return existsSync15(script) ? script : null;
 }
 function resolveDetachedJobScript() {
   const packaged = packagedDetachedJobPath();
   if (packaged) return packaged;
-  let dir = dirname4(fileURLToPath(import.meta.url));
+  let dir = dirname5(fileURLToPath(import.meta.url));
   for (let i = 0; i < 8; i++) {
-    const candidate = join13(dir, "scripts", "detached-job.js");
-    if (existsSync14(candidate)) return candidate;
-    const parent = dirname4(dir);
+    const candidate = join14(dir, "scripts", "detached-job.js");
+    if (existsSync15(candidate)) return candidate;
+    const parent = dirname5(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -5461,14 +5688,15 @@ function formatLongRunningDirective(opts) {
     `Helper (same tool as \`scripts/detached-job.js\` when that file exists in the worktree): \`${invoke}\``,
     `- Start once: \`${invoke} start <id> -- <command> [args...]\` (cwd = this worktree). If JSON says already-running, do not start again.`,
     "- Immediately `present_artifact` `type=log` with `artifact_id=<id>` and `status=running` \u2014 the side column is the live view.",
-    `- Loop \`${invoke} wait <id>\` (returns in ~45s). stillRunning \u2192 present the same id with \`content=delta\` only \u2192 wait again. Do not resend the full log or HTML.`,
+    `- Loop Sideboard MCP \`wait_for_job\` with the same id (returns in ~45s). stillRunning \u2192 present the same id with \`content=delta\` only \u2192 wait_for_job again. Shell fallback: \`${invoke} wait <id>\`. Do not resend the full log or HTML.`,
+    "- Do not end the turn with \u201CI\u2019ll let you know when it\u2019s done.\u201D Stay in the loop until stillRunning is false.",
     "- ok \u2192 finish the task. failed \u2192 read the log, fix, start once.",
     "State: `.context/.sideboard/detached-jobs/<id>/` (local scratch). Full guide: `/long-running` (always available)."
   ].join("\n");
 }
 function formatLongRunningReminder(opts) {
   const invoke = formatDetachedJobInvoke(opts?.scriptPath);
-  return `Long jobs: \`${invoke} start <id> -- <cmd>\`, loop wait, present_artifact type=log (delta). Do not ask the human to poll.`;
+  return `Long jobs: \`${invoke} start <id> -- <cmd>\`, loop wait_for_job (or detached-job wait), present_artifact type=log (delta). Do not say you will let the user know later \u2014 stay in the turn.`;
 }
 function formatArtifactDirective() {
   return [
@@ -5616,8 +5844,8 @@ async function syncThreadBranchFromGit(threadId) {
 
 // src/store/schedules.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync16, readFileSync as readFileSync12 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync13 } from "fs";
+import { join as join16 } from "path";
 import { Cron } from "croner";
 var DURATION_RE = /^(\d+)(s|m|h|d)$/i;
 var UNIT_MS = {
@@ -5627,7 +5855,7 @@ var UNIT_MS = {
   d: 864e5
 };
 function schedulesPath() {
-  return join15(appDataDir(), "schedules.json");
+  return join16(appDataDir(), "schedules.json");
 }
 function parseDurationMs(every) {
   const m = every.trim().match(DURATION_RE);
@@ -5727,9 +5955,9 @@ function normalizeTask(raw) {
 }
 function readAll() {
   const path = schedulesPath();
-  if (!existsSync16(path)) return [];
+  if (!existsSync17(path)) return [];
   try {
-    const parsed = JSON.parse(readFileSync12(path, "utf8"));
+    const parsed = JSON.parse(readFileSync13(path, "utf8"));
     if (!Array.isArray(parsed)) return [];
     return parsed.map((row) => {
       try {
@@ -5852,7 +6080,7 @@ function formatScheduledPrompt(name, prompt) {
 ${prompt}`;
 }
 async function defaultDeps() {
-  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-KQO4MXBI.js");
+  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-J727WIJY.js");
   const orch = getOrchestrator2();
   return {
     findThread: (id) => findThreadByRef(id),
@@ -6009,6 +6237,9 @@ var Orchestrator = class {
    * finish or a user send so a later crash can recover again.
    */
   crashContinued = /* @__PURE__ */ new Set();
+  /** Auto-continues after a worktree turn ended while a detached job still runs. */
+  jobContinueCount = /* @__PURE__ */ new Map();
+  jobContinueNudged = /* @__PURE__ */ new Set();
   maxConcurrent;
   runningCount = 0;
   constructor(opts) {
@@ -6092,7 +6323,7 @@ var Orchestrator = class {
         }
         continue;
       }
-      if (!existsSync17(thread.worktreePath)) {
+      if (!existsSync18(thread.worktreePath)) {
         setStatus(thread.id, "broken", "Worktree missing on disk");
         this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
         continue;
@@ -6307,6 +6538,37 @@ var Orchestrator = class {
     this.emit({ type: "queue_changed", threadId, queue });
     this.haltDrain.delete(threadId);
   }
+  /**
+   * Worktree agent ended the turn after “I’ll let you know” (or left a
+   * detached test/pack job running). Queue a continue so the chat does not
+   * go idle with nobody watching the log.
+   */
+  maybeEnqueueJobContinue(threadId, chatText, parts = []) {
+    if (this.haltDrain.has(threadId)) return;
+    const thread = readThread(threadId);
+    if (!thread || thread.status === "archived") return;
+    const runningJobIds = listRunningDetachedJobs(thread.worktreePath ?? "");
+    const decision = planJobContinue({
+      runningJobIds,
+      chatText,
+      queueLength: thread.queue.length,
+      continueCount: this.jobContinueCount.get(threadId) ?? 0,
+      alreadyNudged: this.jobContinueNudged.has(threadId),
+      isOrchestrator: isOrchestratorThread(thread),
+      agent: thread.agent,
+      watchedJob: turnWatchedDetachedJob(parts)
+    });
+    if (decision.action === "none") {
+      if (runningJobIds.length === 0) this.jobContinueCount.delete(threadId);
+      return;
+    }
+    if (decision.action === "nudge") this.jobContinueNudged.add(threadId);
+    else this.jobContinueCount.set(threadId, (this.jobContinueCount.get(threadId) ?? 0) + 1);
+    const queue = [decision.prompt, ...thread.queue];
+    updateThread(threadId, { queue });
+    this.emit({ type: "queue_changed", threadId, queue });
+    this.haltDrain.delete(threadId);
+  }
   getThreads(includeArchived = false) {
     return listThreads({ includeArchived });
   }
@@ -6406,6 +6668,8 @@ var Orchestrator = class {
       }
       const queue = [...current.queue, prompt];
       this.crashContinued.delete(thread.id);
+      this.jobContinueCount.delete(thread.id);
+      this.jobContinueNudged.delete(thread.id);
       this.haltDrain.delete(thread.id);
       const inFlight = this.activeTurns.has(thread.id) || this.startingTurns.has(thread.id) || current.status === "running";
       shouldSteer = followUp === "steer" && (inFlight || current.queue.length > 0);
@@ -6920,6 +7184,7 @@ var Orchestrator = class {
         this.emit({ type: "turn_finished", threadId, exitCode });
         if (exitCode === 0) {
           this.crashContinued.delete(threadId);
+          this.maybeEnqueueJobContinue(threadId, chatText, parts);
         } else {
           const blob = [chatText, detail].filter(Boolean).join("\n");
           void this.maybeHandleOrchestrationQuotaFailover(threadId, blob);
@@ -7872,7 +8137,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-Q2VCHIAS.js");
+        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-OCEPZXFD.js");
         await ensureWorkspace2(thread.repoPath);
       } catch {
       }
@@ -7920,13 +8185,13 @@ var Orchestrator = class {
       this.emit({ type: "status_changed", threadId: restored2.id, status: restored2.status });
       return restored2;
     }
-    if (!existsSync17(thread.worktreePath)) {
+    if (!existsSync18(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-PEWDAX5O.js");
+      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-VTMBZKY6.js");
       const slug = thread.worktreePath.split("/").pop();
       const dest = thread.worktreePath;
       await withRepoGitLock(thread.repoPath, async () => {
@@ -8036,7 +8301,7 @@ async function startOrchestration(opts) {
     sourceRef: "default",
     ...createOpts
   }).catch(async () => {
-    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-PEWDAX5O.js");
+    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-VTMBZKY6.js");
     const repo = await resolveRepoRoot2(repoPath);
     const def = await resolveDefaultBranch2(repo);
     return orch.createThread({
@@ -8066,6 +8331,11 @@ export {
   recordSlackOutboundWatch,
   pollSlackOutboundWatches,
   AGENT_GIT_ACTIONS,
+  mcpWaitForTurnTimeoutMs,
+  mcpWaitStillRunningHint,
+  mcpWaitFinishedHint,
+  mcpWaitForJobTimeoutMs,
+  waitForDetachedJob,
   BOARD_COLUMN_DEFS,
   HOME_BOARD_CACHE_TTL_MS,
   dedupeBoardIssues,