@sideboard-ai/core 0.1.157 → 0.1.158

package/dist/index.cjs

@@ -9763,6 +9763,9 @@ function toolDescription(name, input) {
   if (/present_files$/i.test(name)) {
     return str2(input?.title) ? `Files ${str2(input?.title)}` : "Present files";
   }
+  if (/wait_for_job$/i.test(name)) {
+    return str2(input?.id) ? `Wait for ${str2(input?.id)}` : "Wait for job";
+  }
   if (isSubagentToolName(name)) {
     const desc = str2(input?.description);
     const sub = asRecord(input?.subagentType);
@@ -10250,7 +10253,8 @@ var init_profile = __esm({
       "ask_user",
       "present_plan",
       "present_schema",
-      "present_files"
+      "present_files",
+      "wait_for_job"
     ];
     WORKTREE_GITHUB_MCP_TOOLS = [
       "github_get_issue",
@@ -10842,7 +10846,8 @@ var init_injected_mcp = __esm({
       "mcp__sideboard__present_schema",
       "mcp__sideboard__present_files",
       "mcp__sideboard__ask_user",
-      "mcp__sideboard__present_plan"
+      "mcp__sideboard__present_plan",
+      "mcp__sideboard__wait_for_job"
     ];
     SIDEBOARD_GITHUB_MCP_ALLOWED_TOOLS = ["mcp__sideboard__github_*"];
     SIDEBOARD_LINEAR_MCP_ALLOWED_TOOLS = ["mcp__sideboard__linear_*"];
@@ -15321,6 +15326,242 @@ var init_child_halt = __esm({
   }
 });
 
+// src/mcp/wait-for-turn.ts
+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);
+}
+function mcpWaitStillRunningHint(status) {
+  return status === "queued" ? MCP_WAIT_QUEUED_HINT : MCP_WAIT_STILL_RUNNING_HINT;
+}
+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;
+}
+var MCP_WAIT_FOR_TURN_MAX_MS, MCP_WAIT_STILL_RUNNING_HINT, MCP_WAIT_QUEUED_HINT, MCP_WAIT_STOPPED_HINT, MCP_WAIT_BROKEN_HINT, MCP_WAIT_ERROR_HINT;
+var init_wait_for_turn = __esm({
+  "src/mcp/wait-for-turn.ts"() {
+    "use strict";
+    MCP_WAIT_FOR_TURN_MAX_MS = 45e3;
+    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.";
+    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.";
+    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.";
+    MCP_WAIT_BROKEN_HINT = "Child worktree is broken (missing on disk). Tell the user \u2014 do not treat this as success.";
+    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.";
+  }
+});
+
+// src/mcp/wait-for-job.ts
+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 (!(0, import_node_fs40.existsSync)(file)) return null;
+  const n = Number.parseInt((0, import_node_fs40.readFileSync)(file, "utf8").trim(), 10);
+  return Number.isInteger(n) ? n : null;
+}
+function jobDir(root, id, legacy = false) {
+  return (0, import_node_path40.join)(root, legacy ? LEGACY_DETACHED_JOBS_DIR : DETACHED_JOBS_DIR, id);
+}
+function resolveJobDir(root, id) {
+  const modern = jobDir(root, id, false);
+  if ((0, import_node_fs40.existsSync)(modern)) return modern;
+  const legacy = jobDir(root, id, true);
+  if ((0, import_node_fs40.existsSync)(legacy)) return legacy;
+  return modern;
+}
+function listJobIdsIn(root, rel) {
+  const dir = (0, import_node_path40.join)(root, rel);
+  if (!(0, import_node_fs40.existsSync)(dir)) return [];
+  return (0, import_node_fs40.readdirSync)(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((0, import_node_path40.join)(dir, "pid"));
+    if (pid != null && jobAlive(pid)) running.push(id);
+  }
+  return running.sort();
+}
+function looksLikeDeferredDonePromise(text6) {
+  const t = (text6 ?? "").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 (!(0, import_node_fs40.existsSync)(logFile)) return "(no log yet)";
+  const lines = (0, import_node_fs40.readFileSync)(logFile, "utf8").split("\n");
+  return lines.slice(-maxLines).join("\n");
+}
+function readLogLines(file) {
+  if (!(0, import_node_fs40.existsSync)(file)) return [];
+  const lines = (0, import_node_fs40.readFileSync)(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((0, import_node_path40.join)(dir, "pid"));
+  const running = pid != null && jobAlive(pid);
+  return {
+    pid,
+    running,
+    exitCode: readIntFile((0, import_node_path40.join)(dir, "exit")),
+    log: (0, import_node_path40.join)(dir, "log"),
+    cursor: (0, import_node_path40.join)(dir, "present.cursor"),
+    progress: tailProgress((0, import_node_path40.join)(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 {
+    (0, import_node_fs40.mkdirSync)((0, import_node_path40.dirname)(snap.cursor), { recursive: true });
+    (0, import_node_fs40.writeFileSync)(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 sleep2 = opts?.sleep ?? sleepMs;
+  if (!(0, import_node_fs40.existsSync)(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 sleep2(Math.min(2e3, Math.max(50, deadline - Date.now())));
+  }
+  snap = snapshotJob(dir);
+  return toResult(jobId, snap);
+}
+var import_node_fs40, import_node_path40, MAX_JOB_CONTINUES, MCP_WAIT_JOB_STILL_RUNNING_HINT, JOB_ID_RE;
+var init_wait_for_job = __esm({
+  "src/mcp/wait-for-job.ts"() {
+    "use strict";
+    import_node_fs40 = require("fs");
+    import_node_path40 = require("path");
+    init_workspace_scratch();
+    init_wait_for_turn();
+    MAX_JOB_CONTINUES = 8;
+    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.";
+    JOB_ID_RE = /^[a-zA-Z0-9._-]{1,64}$/;
+  }
+});
+
 // src/detect/detect.ts
 async function detectAgents() {
   ensureAgentPath();
@@ -16447,7 +16688,7 @@ function reuseLiveThread(input, repoPath, match) {
 }
 async function createThread(input, _onSetupLine) {
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!(0, import_node_fs40.existsSync)(repoPath)) {
+  if (!(0, import_node_fs41.existsSync)(repoPath)) {
     throw new Error(`Repo not found: ${repoPath}`);
   }
   const reused = reuseLiveThread(input, repoPath, {
@@ -16627,11 +16868,11 @@ async function listLinearIssues(agent, repoPath) {
   }
   return adapter.listLinearIssues(repoPath);
 }
-var import_node_fs40;
+var import_node_fs41;
 var init_create = __esm({
   "src/threads/create.ts"() {
     "use strict";
-    import_node_fs40 = require("fs");
+    import_node_fs41 = require("fs");
     init_detect();
     init_worktree();
     init_home_board();
@@ -16734,20 +16975,20 @@ function writeTurnLive(threadId, progress) {
   const path2 = threadLivePath(threadId);
   const tmp = `${path2}.${process.pid}.tmp`;
   try {
-    (0, import_node_fs41.writeFileSync)(tmp, JSON.stringify(progress), "utf8");
-    (0, import_node_fs41.renameSync)(tmp, path2);
+    (0, import_node_fs42.writeFileSync)(tmp, JSON.stringify(progress), "utf8");
+    (0, import_node_fs42.renameSync)(tmp, path2);
   } catch {
     try {
-      (0, import_node_fs41.unlinkSync)(tmp);
+      (0, import_node_fs42.unlinkSync)(tmp);
     } catch {
     }
   }
 }
 function readTurnLive(threadId) {
   const path2 = threadLivePath(threadId);
-  if (!(0, import_node_fs41.existsSync)(path2)) return null;
+  if (!(0, import_node_fs42.existsSync)(path2)) return null;
   try {
-    const raw = JSON.parse((0, import_node_fs41.readFileSync)(path2, "utf8"));
+    const raw = JSON.parse((0, import_node_fs42.readFileSync)(path2, "utf8"));
     if (!raw || typeof raw.summary !== "string") return null;
     return raw;
   } catch {
@@ -16759,17 +17000,17 @@ function clearTurnLive(threadId) {
   if (buf?.timer) clearTimeout(buf.timer);
   buffers.delete(threadId);
   const path2 = threadLivePath(threadId);
-  if (!(0, import_node_fs41.existsSync)(path2)) return;
+  if (!(0, import_node_fs42.existsSync)(path2)) return;
   try {
-    (0, import_node_fs41.unlinkSync)(path2);
+    (0, import_node_fs42.unlinkSync)(path2);
   } catch {
   }
 }
-var import_node_fs41, buffers, FLUSH_MS, MAX_PARTS;
+var import_node_fs42, buffers, FLUSH_MS, MAX_PARTS;
 var init_turn_live = __esm({
   "src/store/turn-live.ts"() {
     "use strict";
-    import_node_fs41 = require("fs");
+    import_node_fs42 = require("fs");
     init_message_parts();
     init_paths();
     buffers = /* @__PURE__ */ new Map();
@@ -16989,7 +17230,7 @@ var init_quota_failover = __esm({
 // src/threads/adopt.ts
 function thisModuleFile() {
   const cjsFile = typeof __filename !== "undefined" ? __filename : "";
-  return cjsFile || process.argv[1] || (0, import_node_path40.join)(process.cwd(), "package.json");
+  return cjsFile || process.argv[1] || (0, import_node_path41.join)(process.cwd(), "package.json");
 }
 function openReadonlySqlite(file) {
   const req = (0, import_node_module4.createRequire)(thisModuleFile());
@@ -17007,21 +17248,21 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !(0, import_node_fs42.existsSync)(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !(0, import_node_fs43.existsSync)(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
   try {
-    hashes = (0, import_node_fs42.readdirSync)(CURSOR_SDK_STORE);
+    hashes = (0, import_node_fs43.readdirSync)(CURSOR_SDK_STORE);
   } catch {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = (0, import_node_path40.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!(0, import_node_fs42.existsSync)(agentsFile)) continue;
+    const agentsFile = (0, import_node_path41.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!(0, import_node_fs43.existsSync)(agentsFile)) continue;
     let text6;
     try {
-      text6 = (0, import_node_fs42.readFileSync)(agentsFile, "utf8");
+      text6 = (0, import_node_fs43.readFileSync)(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -17045,7 +17286,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!(0, import_node_fs42.existsSync)(input.worktreePath)) {
+  if (!(0, import_node_fs43.existsSync)(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -17074,18 +17315,18 @@ function conductorDbPath() {
   return CONDUCTOR_DB;
 }
 function listConductorWorkspaces() {
-  if (!(0, import_node_fs42.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs43.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs42.mkdtempSync)((0, import_node_path40.join)((0, import_node_os13.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path40.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs43.mkdtempSync)((0, import_node_path41.join)((0, import_node_os13.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path41.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs42.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs43.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs42.existsSync)(src)) {
+      if ((0, import_node_fs43.existsSync)(src)) {
         try {
-          (0, import_node_fs42.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs43.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -17161,22 +17402,22 @@ function listConductorWorkspaces() {
       db.close();
     }
   } finally {
-    (0, import_node_fs42.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs43.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!(0, import_node_fs42.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs43.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs42.mkdtempSync)((0, import_node_path40.join)((0, import_node_os13.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path40.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs43.mkdtempSync)((0, import_node_path41.join)((0, import_node_os13.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path41.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs42.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs43.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs42.existsSync)(src)) {
+      if ((0, import_node_fs43.existsSync)(src)) {
         try {
-          (0, import_node_fs42.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs43.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -17194,7 +17435,7 @@ function importConductorWorkspace(workspaceId) {
       ).get(workspaceId);
       if (!row) throw new Error(`Conductor workspace not found: ${workspaceId}`);
       const worktreePath = String(row.workspacePath);
-      if (!(0, import_node_fs42.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs43.existsSync)(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -17257,31 +17498,31 @@ function importConductorWorkspace(workspaceId) {
       db.close();
     }
   } finally {
-    (0, import_node_fs42.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs43.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 async function importConductorWorkspaceAsync(workspaceId) {
   return importConductorWorkspace(workspaceId);
 }
-var import_node_child_process4, import_node_fs42, import_node_os13, import_node_path40, import_node_module4, CONDUCTOR_APP_SUPPORT, CONDUCTOR_DB, CURSOR_SDK_STORE;
+var import_node_child_process4, import_node_fs43, import_node_os13, import_node_path41, import_node_module4, CONDUCTOR_APP_SUPPORT, CONDUCTOR_DB, CURSOR_SDK_STORE;
 var init_adopt = __esm({
   "src/threads/adopt.ts"() {
     "use strict";
     import_node_child_process4 = require("child_process");
-    import_node_fs42 = require("fs");
+    import_node_fs43 = require("fs");
     import_node_os13 = require("os");
-    import_node_path40 = require("path");
+    import_node_path41 = require("path");
     import_node_module4 = require("module");
     init_worktree();
     init_thread_store();
-    CONDUCTOR_APP_SUPPORT = (0, import_node_path40.join)(
+    CONDUCTOR_APP_SUPPORT = (0, import_node_path41.join)(
       process.env.HOME ?? "",
       "Library",
       "Application Support",
       "com.conductor.app"
     );
-    CONDUCTOR_DB = (0, import_node_path40.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
-    CURSOR_SDK_STORE = (0, import_node_path40.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+    CONDUCTOR_DB = (0, import_node_path41.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
+    CURSOR_SDK_STORE = (0, import_node_path41.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
   }
 });
 
@@ -17348,7 +17589,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 && (0, import_node_fs43.existsSync)(checkedOut.path)) {
+  if (checkedOut?.path && (0, import_node_fs44.existsSync)(checkedOut.path)) {
     if (input.reuseExistingWorktree !== false) {
       worktreePath = checkedOut.path;
     } else {
@@ -17490,7 +17731,7 @@ async function initStackFromThread(input, onSetupLine) {
 async function createPrStack(input, onSetupLine) {
   await requireAgent(input.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!(0, import_node_fs43.existsSync)(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
+  if (!(0, import_node_fs44.existsSync)(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);
@@ -17557,7 +17798,7 @@ async function createPrStack(input, onSetupLine) {
     }
   }
   const claimed = new Set(threads.map((t) => t.worktreePath));
-  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs43.existsSync)(bootstrap.worktreePath)) {
+  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs44.existsSync)(bootstrap.worktreePath)) {
     try {
       await removeWorktree(repoPath, bootstrap.worktreePath, {
         deleteBranch: bootstrap.branchName
@@ -17577,11 +17818,11 @@ function stackAgentDefaultsFrom(input) {
     planMode: input.planMode
   };
 }
-var import_node_fs43;
+var import_node_fs44;
 var init_stack_layers = __esm({
   "src/threads/stack-layers.ts"() {
     "use strict";
-    import_node_fs43 = require("fs");
+    import_node_fs44 = require("fs");
     init_detect();
     init_run();
     init_stack();
@@ -17594,7 +17835,7 @@ var init_stack_layers = __esm({
 
 // src/diff/diff.ts
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs44.existsSync)(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !(0, import_node_fs45.existsSync)(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -17602,7 +17843,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs44.existsSync)(worktreePath)) {
+  if (!worktreePath || !(0, import_node_fs45.existsSync)(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -17736,11 +17977,11 @@ new file mode 100644
   };
 }
 async function untrackedPatch(worktreePath, path2, maxHunk) {
-  const abs = (0, import_node_path41.join)(worktreePath, path2);
+  const abs = (0, import_node_path42.join)(worktreePath, path2);
   try {
-    const st = (0, import_node_fs44.statSync)(abs);
+    const st = (0, import_node_fs45.statSync)(abs);
     if (st.isFile() && st.size > maxHunk) {
-      const buf = (0, import_node_fs44.readFileSync)(abs).subarray(0, maxHunk);
+      const buf = (0, import_node_fs45.readFileSync)(abs).subarray(0, maxHunk);
       return syntheticAddPatch(path2, buf.toString("utf8"), maxHunk);
     }
   } catch {
@@ -18229,8 +18470,8 @@ function isImageRelativePath(relativePath) {
 function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-  const abs = (0, import_node_path41.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs44.statSync)(abs);
+  const abs = (0, import_node_path42.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs45.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
@@ -18239,7 +18480,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = (0, import_node_fs44.readFileSync)(abs);
+  const buf = (0, import_node_fs45.readFileSync)(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -18249,12 +18490,12 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = (0, import_node_path41.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs44.statSync)(abs);
+  const abs = (0, import_node_path42.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs45.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = (0, import_node_fs44.readFileSync)(abs);
+  const buf = (0, import_node_fs45.readFileSync)(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -18297,9 +18538,9 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = (0, import_node_path41.join)(worktreePath, relativePath);
-  (0, import_node_fs44.mkdirSync)((0, import_node_path41.dirname)(abs), { recursive: true });
-  (0, import_node_fs44.writeFileSync)(abs, content, "utf8");
+  const abs = (0, import_node_path42.join)(worktreePath, relativePath);
+  (0, import_node_fs45.mkdirSync)((0, import_node_path42.dirname)(abs), { recursive: true });
+  (0, import_node_fs45.writeFileSync)(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getDiffSummary(worktreePath, repoPath, opts) {
@@ -18316,12 +18557,12 @@ async function getDiffSummary(worktreePath, repoPath, opts) {
     truncated: full.files.length > maxFiles
   };
 }
-var import_node_fs44, import_node_path41, mergeBaseCache, MERGE_BASE_TTL_MS, SHA_RE, IMAGE_EXTENSIONS2, DEFAULT_UPLOAD_MAX_BYTES;
+var import_node_fs45, import_node_path42, mergeBaseCache, MERGE_BASE_TTL_MS, SHA_RE, IMAGE_EXTENSIONS2, DEFAULT_UPLOAD_MAX_BYTES;
 var init_diff = __esm({
   "src/diff/diff.ts"() {
     "use strict";
-    import_node_fs44 = require("fs");
-    import_node_path41 = require("path");
+    import_node_fs45 = require("fs");
+    import_node_path42 = require("path");
     init_run();
     init_worktree();
     mergeBaseCache = /* @__PURE__ */ new Map();
@@ -18470,7 +18711,7 @@ var init_long_running = __esm({
 
 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
 
@@ -18480,7 +18721,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)
@@ -18493,7 +18735,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**.
 
@@ -18523,7 +18765,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.
@@ -18589,7 +18831,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = (0, import_node_fs45.readFileSync)(skillMd, "utf8");
+    const content = (0, import_node_fs46.readFileSync)(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -18608,19 +18850,19 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!(0, import_node_fs45.existsSync)(dir)) return;
+  if (!(0, import_node_fs46.existsSync)(dir)) return;
   let entries;
   try {
-    entries = (0, import_node_fs45.readdirSync)(dir);
+    entries = (0, import_node_fs46.readdirSync)(dir);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const skillMd = (0, import_node_path42.join)(dir, entry, "SKILL.md");
-    if (!(0, import_node_fs45.existsSync)(skillMd)) continue;
+    const skillMd = (0, import_node_path43.join)(dir, entry, "SKILL.md");
+    if (!(0, import_node_fs46.existsSync)(skillMd)) continue;
     try {
-      if (!(0, import_node_fs45.statSync)(skillMd).isFile()) continue;
+      if (!(0, import_node_fs46.statSync)(skillMd).isFile()) continue;
     } catch {
       continue;
     }
@@ -18629,24 +18871,24 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!(0, import_node_fs45.existsSync)(pluginsRoot)) return;
+  if (!(0, import_node_fs46.existsSync)(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
     try {
-      entries = (0, import_node_fs45.readdirSync)(dir);
+      entries = (0, import_node_fs46.readdirSync)(dir);
     } catch {
       return;
     }
     if (lookingForSkillsDir && entries.includes("SKILL.md")) {
-      const skill = readSkill((0, import_node_path42.join)(dir, "SKILL.md"), "cli");
+      const skill = readSkill((0, import_node_path43.join)(dir, "SKILL.md"), "cli");
       if (skill) out.push(skill);
     }
     for (const entry of entries) {
       if (entry === "node_modules" || entry === ".git") continue;
-      const full = (0, import_node_path42.join)(dir, entry);
+      const full = (0, import_node_path43.join)(dir, entry);
       try {
-        if (!(0, import_node_fs45.statSync)(full).isDirectory()) continue;
+        if (!(0, import_node_fs46.statSync)(full).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -18664,17 +18906,17 @@ function discoverSkills(worktreePath) {
   const home = (0, import_node_os14.homedir)();
   const collected = [];
   for (const rel of [".claude/skills", ".cursor/skills", ".sideboard/skills", ".brightsy/skills", "skills"]) {
-    scanSkillsDir((0, import_node_path42.join)(worktreePath, rel), "workspace", collected);
+    scanSkillsDir((0, import_node_path43.join)(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    (0, import_node_path42.join)(home, ".claude/skills"),
-    (0, import_node_path42.join)(home, ".cursor/skills"),
-    (0, import_node_path42.join)(home, ".sideboard/skills"),
-    (0, import_node_path42.join)(home, ".brightsy/skills")
+    (0, import_node_path43.join)(home, ".claude/skills"),
+    (0, import_node_path43.join)(home, ".cursor/skills"),
+    (0, import_node_path43.join)(home, ".sideboard/skills"),
+    (0, import_node_path43.join)(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills((0, import_node_path42.join)(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills((0, import_node_path43.join)(home, ".claude/plugins"), collected);
   collected.push(...bundledSkills());
   const rank = {
     workspace: 0,
@@ -18700,7 +18942,7 @@ function readSkillBody(skillPath, maxChars = 12e3) {
 \u2026(truncated)` : body;
     }
   }
-  const raw = (0, import_node_fs45.readFileSync)(skillPath, "utf8");
+  const raw = (0, import_node_fs46.readFileSync)(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -18714,13 +18956,13 @@ function readSkillBody(skillPath, maxChars = 12e3) {
 
 \u2026(truncated)` : raw;
 }
-var import_node_fs45, import_node_os14, import_node_path42, BUNDLED_SKILL_PREFIX;
+var import_node_fs46, import_node_os14, import_node_path43, BUNDLED_SKILL_PREFIX;
 var init_discover = __esm({
   "src/skills/discover.ts"() {
     "use strict";
-    import_node_fs45 = require("fs");
+    import_node_fs46 = require("fs");
     import_node_os14 = require("os");
-    import_node_path42 = require("path");
+    import_node_path43 = require("path");
     init_long_running();
     BUNDLED_SKILL_PREFIX = "bundled:";
   }
@@ -18815,17 +19057,17 @@ var init_expand = __esm({
 function packagedDetachedJobPath() {
   const dir = packagedMcpDir();
   if (!dir) return null;
-  const script = (0, import_node_path43.join)(dir, "scripts", "detached-job.js");
-  return (0, import_node_fs46.existsSync)(script) ? script : null;
+  const script = (0, import_node_path44.join)(dir, "scripts", "detached-job.js");
+  return (0, import_node_fs47.existsSync)(script) ? script : null;
 }
 function resolveDetachedJobScript() {
   const packaged = packagedDetachedJobPath();
   if (packaged) return packaged;
-  let dir = (0, import_node_path43.dirname)((0, import_node_url3.fileURLToPath)(import_meta3.url));
+  let dir = (0, import_node_path44.dirname)((0, import_node_url3.fileURLToPath)(import_meta3.url));
   for (let i = 0; i < 8; i++) {
-    const candidate = (0, import_node_path43.join)(dir, "scripts", "detached-job.js");
-    if ((0, import_node_fs46.existsSync)(candidate)) return candidate;
-    const parent = (0, import_node_path43.dirname)(dir);
+    const candidate = (0, import_node_path44.join)(dir, "scripts", "detached-job.js");
+    if ((0, import_node_fs47.existsSync)(candidate)) return candidate;
+    const parent = (0, import_node_path44.dirname)(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -18836,12 +19078,12 @@ function formatDetachedJobInvoke(scriptPath) {
   if (resolved) return `node ${JSON.stringify(resolved)}`;
   return "node scripts/detached-job.js";
 }
-var import_node_fs46, import_node_path43, import_node_url3, import_meta3;
+var import_node_fs47, import_node_path44, import_node_url3, import_meta3;
 var init_detached_job_path = __esm({
   "src/skills/detached-job-path.ts"() {
     "use strict";
-    import_node_fs46 = require("fs");
-    import_node_path43 = require("path");
+    import_node_fs47 = require("fs");
+    import_node_path44 = require("path");
     import_node_url3 = require("url");
     init_packaged_runtime();
     import_meta3 = {};
@@ -19062,14 +19304,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 [
@@ -19106,11 +19349,11 @@ function loadAgentInstructions(worktreePath, agent) {
   const out = [];
   for (const rel of candidates) {
     if (seenPaths.has(rel)) continue;
-    const abs = (0, import_node_path44.join)(worktreePath, rel);
-    if (!(0, import_node_fs47.existsSync)(abs)) continue;
+    const abs = (0, import_node_path45.join)(worktreePath, rel);
+    if (!(0, import_node_fs48.existsSync)(abs)) continue;
     try {
-      if (!(0, import_node_fs47.statSync)(abs).isFile()) continue;
-      let content = (0, import_node_fs47.readFileSync)(abs, "utf8");
+      if (!(0, import_node_fs48.statSync)(abs).isFile()) continue;
+      let content = (0, import_node_fs48.readFileSync)(abs, "utf8");
       if (!content.trim()) continue;
       if (content.length > MAX_CHARS_PER_FILE) {
         content = `${content.slice(0, MAX_CHARS_PER_FILE)}
@@ -19150,12 +19393,12 @@ function withAgentInstructions(prompt, files) {
 
 ${prompt}`;
 }
-var import_node_fs47, import_node_path44, GITHUB_TICKET_REF, KEYED_TICKET_REF, FILES_BY_AGENT, MAX_CHARS_PER_FILE;
+var import_node_fs48, import_node_path45, GITHUB_TICKET_REF, KEYED_TICKET_REF, FILES_BY_AGENT, MAX_CHARS_PER_FILE;
 var init_instructions = __esm({
   "src/agents/instructions.ts"() {
     "use strict";
-    import_node_fs47 = require("fs");
-    import_node_path44 = require("path");
+    import_node_fs48 = require("fs");
+    import_node_path45 = require("path");
     init_git_auth_mode();
     init_worktree_labels();
     init_detached_job_path();
@@ -19503,40 +19746,40 @@ __export(plan_file_exports, {
   writePlanFile: () => writePlanFile
 });
 function ensureAttachmentsGitignore(worktreePath) {
-  const gitignoreAbs = (0, import_node_path45.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
-  if ((0, import_node_fs48.existsSync)(gitignoreAbs)) return;
-  (0, import_node_fs48.mkdirSync)((0, import_node_path45.dirname)(gitignoreAbs), { recursive: true });
-  (0, import_node_fs48.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+  const gitignoreAbs = (0, import_node_path46.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if ((0, import_node_fs49.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs49.mkdirSync)((0, import_node_path46.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs49.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function planFileAbs(worktreePath) {
-  return (0, import_node_path45.join)(worktreePath, PLAN_FILE_REL);
+  return (0, import_node_path46.join)(worktreePath, PLAN_FILE_REL);
 }
 function readTextIfPresent2(abs) {
-  if (!(0, import_node_fs48.existsSync)(abs)) return null;
+  if (!(0, import_node_fs49.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs48.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs49.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function readPlanFile(worktreePath) {
-  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path45.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path45.join)(worktreePath, LEGACY_PLAN_FILE_REL));
+  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path46.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path46.join)(worktreePath, LEGACY_PLAN_FILE_REL));
 }
 function writePlanFile(worktreePath, content) {
   ensureAttachmentsGitignore(worktreePath);
   const abs = planFileAbs(worktreePath);
-  (0, import_node_fs48.mkdirSync)((0, import_node_path45.dirname)(abs), { recursive: true });
+  (0, import_node_fs49.mkdirSync)((0, import_node_path46.dirname)(abs), { recursive: true });
   const body = content.trimEnd() + (content.endsWith("\n") ? "" : "\n");
-  (0, import_node_fs48.writeFileSync)(abs, body, "utf8");
+  (0, import_node_fs49.writeFileSync)(abs, body, "utf8");
   return PLAN_FILE_REL;
 }
-var import_node_fs48, import_node_path45;
+var import_node_fs49, import_node_path46;
 var init_plan_file = __esm({
   "src/plan/plan-file.ts"() {
     "use strict";
-    import_node_fs48 = require("fs");
-    import_node_path45 = require("path");
+    import_node_fs49 = require("fs");
+    import_node_path46 = require("path");
     init_workspace_scratch();
     init_plan_present();
     init_plan_present();
@@ -19584,13 +19827,13 @@ var init_sync_branch = __esm({
 
 // src/agents/cursor-store.ts
 function cursorSdkStoreDir(threadId) {
-  const root = (0, import_node_path46.join)(appDataDir(), CURSOR_SDK_STORE_DIR);
+  const root = (0, import_node_path47.join)(appDataDir(), CURSOR_SDK_STORE_DIR);
   const id = sanitizeCursorStoreSegment(threadId);
   if (!id) return root;
-  return (0, import_node_path46.join)(root, "threads", id);
+  return (0, import_node_path47.join)(root, "threads", id);
 }
 function cursorSdkRunsNdjsonPath(threadId) {
-  return (0, import_node_path46.join)(cursorSdkStoreDir(threadId), "runs.ndjson");
+  return (0, import_node_path47.join)(cursorSdkStoreDir(threadId), "runs.ndjson");
 }
 function cursorSdkRunsNdjsonSearchPaths(threadId) {
   const scoped = cursorSdkRunsNdjsonPath(threadId);
@@ -19603,11 +19846,11 @@ function cursorSdkRunsNdjsonSearchPaths(threadId) {
 function sanitizeCursorStoreSegment(threadId) {
   return (threadId ?? "").trim().replace(/[^a-zA-Z0-9._-]/g, "_");
 }
-var import_node_path46, CURSOR_SDK_STORE_DIR;
+var import_node_path47, CURSOR_SDK_STORE_DIR;
 var init_cursor_store = __esm({
   "src/agents/cursor-store.ts"() {
     "use strict";
-    import_node_path46 = require("path");
+    import_node_path47 = require("path");
     init_paths();
     CURSOR_SDK_STORE_DIR = "cursor-sdk-store";
   }
@@ -19629,9 +19872,9 @@ function recoverFinishedCursorRun(opts) {
   return best;
 }
 function scanFinishedCursorRuns(runsPath, agentId, startedAfterMs) {
-  if (!(0, import_node_fs49.existsSync)(runsPath)) return null;
+  if (!(0, import_node_fs50.existsSync)(runsPath)) return null;
   try {
-    const lines = (0, import_node_fs49.readFileSync)(runsPath, "utf8").split("\n");
+    const lines = (0, import_node_fs50.readFileSync)(runsPath, "utf8").split("\n");
     let best = null;
     for (const line of lines) {
       const trimmed = line.trim();
@@ -19657,11 +19900,11 @@ function scanFinishedCursorRuns(runsPath, agentId, startedAfterMs) {
     return null;
   }
 }
-var import_node_fs49;
+var import_node_fs50;
 var init_cursor_recover = __esm({
   "src/agents/cursor-recover.ts"() {
     "use strict";
-    import_node_fs49 = require("fs");
+    import_node_fs50 = require("fs");
     init_cursor_store();
   }
 });
@@ -19793,13 +20036,13 @@ async function startOrchestration(opts) {
   }
   return updated;
 }
-var import_node_events, import_node_fs50, LIVE_TURN_SPAWN_GRACE_MS, STALE_AGENT_PID_WAIT_MS, Orchestrator, singleton;
+var import_node_events, import_node_fs51, LIVE_TURN_SPAWN_GRACE_MS, STALE_AGENT_PID_WAIT_MS, Orchestrator, singleton;
 var init_orchestrator = __esm({
   "src/orchestrator/orchestrator.ts"() {
     "use strict";
     import_node_events = require("events");
     init_outbound_watch();
-    import_node_fs50 = require("fs");
+    import_node_fs51 = require("fs");
     init_error_detail();
     init_run();
     init_stale_lock();
@@ -19820,6 +20063,7 @@ var init_orchestrator = __esm({
     init_thread_store();
     init_desktop_host();
     init_child_halt();
+    init_wait_for_job();
     init_create();
     init_cowboy();
     init_orchestrator_capable();
@@ -19884,6 +20128,9 @@ var init_orchestrator = __esm({
        * 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) {
@@ -19967,7 +20214,7 @@ var init_orchestrator = __esm({
             }
             continue;
           }
-          if (!(0, import_node_fs50.existsSync)(thread.worktreePath)) {
+          if (!(0, import_node_fs51.existsSync)(thread.worktreePath)) {
             setStatus(thread.id, "broken", "Worktree missing on disk");
             this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
             continue;
@@ -20182,6 +20429,37 @@ var init_orchestrator = __esm({
         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 });
       }
@@ -20281,6 +20559,8 @@ var init_orchestrator = __esm({
           }
           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);
@@ -20795,6 +21075,7 @@ var init_orchestrator = __esm({
             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);
@@ -21795,7 +22076,7 @@ var init_orchestrator = __esm({
           this.emit({ type: "status_changed", threadId: restored2.id, status: restored2.status });
           return restored2;
         }
-        if (!(0, import_node_fs50.existsSync)(thread.worktreePath)) {
+        if (!(0, import_node_fs51.existsSync)(thread.worktreePath)) {
           if (isCowboyThread(thread) || isPrimaryCheckoutThread(thread)) {
             throw new Error(
               `Cowboy checkout missing: ${thread.worktreePath}. Re-add the project folder, then restore.`
@@ -24415,7 +24696,7 @@ var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_zod6 = require("zod");
 var import_node_crypto13 = require("crypto");
-var import_node_path49 = require("path");
+var import_node_path50 = require("path");
 init_orchestrator();
 init_worktree();
 init_global_workspace();
@@ -24432,30 +24713,8 @@ function mcpArchiveBlockedReason(thread) {
 
 // src/mcp/server.ts
 init_profile();
-
-// 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/server.ts
+init_wait_for_turn();
+init_wait_for_job();
 init_message_parts();
 init_turn_live();
 
@@ -25606,27 +25865,27 @@ init_gh_errors();
 init_git_auth_mode();
 
 // src/board/load-home-board.ts
-var import_node_fs52 = require("fs");
-var import_node_path48 = require("path");
+var import_node_fs53 = require("fs");
+var import_node_path49 = require("path");
 init_worktree();
 init_paths();
 
 // src/board/board-pins.ts
 var import_node_crypto12 = require("crypto");
-var import_node_fs51 = require("fs");
-var import_node_path47 = require("path");
+var import_node_fs52 = require("fs");
+var import_node_path48 = require("path");
 init_paths();
 init_home_board();
 var FILE = "home-board-pins.json";
 var VERSION = 1;
 function pinsFile() {
-  return (0, import_node_path47.join)(appDataDir(), FILE);
+  return (0, import_node_path48.join)(appDataDir(), FILE);
 }
 function readDisk() {
   const path2 = pinsFile();
-  if (!(0, import_node_fs51.existsSync)(path2)) return [];
+  if (!(0, import_node_fs52.existsSync)(path2)) return [];
   try {
-    const raw = JSON.parse((0, import_node_fs51.readFileSync)(path2, "utf8"));
+    const raw = JSON.parse((0, import_node_fs52.readFileSync)(path2, "utf8"));
     if (raw?.version !== VERSION || !Array.isArray(raw.items)) return [];
     return raw.items.filter((item) => item?.id && item.kind && item.ref);
   } catch {
@@ -25634,8 +25893,8 @@ function readDisk() {
   }
 }
 function writeDisk(items) {
-  (0, import_node_fs51.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs51.writeFileSync)(pinsFile(), JSON.stringify({ version: VERSION, items }, null, 2), "utf8");
+  (0, import_node_fs52.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs52.writeFileSync)(pinsFile(), JSON.stringify({ version: VERSION, items }, null, 2), "utf8");
 }
 function listBoardPins() {
   return readDisk();
@@ -25687,7 +25946,7 @@ function replaceBoardPins(items) {
 }
 function clearBoardPins() {
   try {
-    (0, import_node_fs51.unlinkSync)(pinsFile());
+    (0, import_node_fs52.unlinkSync)(pinsFile());
   } catch {
   }
 }
@@ -25704,7 +25963,7 @@ function homeBoardWorkspaceKey(workspaces) {
   return workspaces.map((w) => w.path).filter(Boolean).sort().join("\n");
 }
 function cacheFile() {
-  return (0, import_node_path48.join)(appDataDir(), "home-board-cache.json");
+  return (0, import_node_path49.join)(appDataDir(), "home-board-cache.json");
 }
 function emptyInputs() {
   return {
@@ -25730,9 +25989,9 @@ function shouldCacheHomeBoardInputs(inputs) {
 }
 function readDiskCache() {
   const path2 = cacheFile();
-  if (!(0, import_node_fs52.existsSync)(path2)) return null;
+  if (!(0, import_node_fs53.existsSync)(path2)) return null;
   try {
-    const raw = JSON.parse((0, import_node_fs52.readFileSync)(path2, "utf8"));
+    const raw = JSON.parse((0, import_node_fs53.readFileSync)(path2, "utf8"));
     if (raw?.version !== CACHE_VERSION || typeof raw.fetchedAt !== "number") {
       return null;
     }
@@ -25746,14 +26005,14 @@ function readDiskCache() {
 }
 function writeDiskCache(entry) {
   try {
-    (0, import_node_fs52.mkdirSync)(appDataDir(), { recursive: true });
-    (0, import_node_fs52.writeFileSync)(cacheFile(), JSON.stringify(entry), "utf8");
+    (0, import_node_fs53.mkdirSync)(appDataDir(), { recursive: true });
+    (0, import_node_fs53.writeFileSync)(cacheFile(), JSON.stringify(entry), "utf8");
   } catch {
   }
 }
 function deleteDiskCache() {
   try {
-    (0, import_node_fs52.unlinkSync)(cacheFile());
+    (0, import_node_fs53.unlinkSync)(cacheFile());
   } catch {
   }
 }
@@ -26060,7 +26319,7 @@ async function startMcpServer() {
       async () => {
         const threads = orch.getThreads(true);
         const lines = threads.map((t) => {
-          const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path49.basename)(t.repoPath) || t.repoPath;
+          const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path50.basename)(t.repoPath) || t.repoPath;
           const live = orch.threadLooksLive(t) ? readTurnLive(t.id) : null;
           const parent = t.parentThreadId ? `  parent:${t.parentThreadId.slice(0, 8)}` : "";
           const preview = lastMessagePreview(t.messages, 80);
@@ -26294,6 +26553,20 @@ async function startMcpServer() {
       return { content: [{ type: "text", text: JSON.stringify(payload) }] };
     }
   );
+  server.tool(
+    "wait_for_job",
+    "Wait on a detached long job (tests, pack, deploy) started with detached-job.js. MCP clients kill tools around 60s, so this returns within 45s. stillRunning is the source of truth \u2014 if true, present_artifact type=log with content=delta (same artifact_id) and call wait_for_job again. Do not end the turn or tell the user you will let them know later. If false, ok/failed is the result.",
+    {
+      id: import_zod6.z.string().describe("Detached job id (same kebab-case id passed to detached-job.js start)"),
+      timeoutMs: import_zod6.z.number().optional()
+    },
+    async ({ id, timeoutMs }) => {
+      const result = await waitForDetachedJob(process.cwd(), id, {
+        timeoutMs: mcpWaitForJobTimeoutMs(timeoutMs)
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+  );
   if (!worktreeProfile) {
     registerSlackTools(server);
     registerConnectedIssueVendorTools(server);
@@ -29156,9 +29429,9 @@ var import_node_http3 = require("http");
 var import_ws3 = require("ws");
 
 // src/slack/relay-static.ts
-var import_node_fs53 = require("fs");
+var import_node_fs54 = require("fs");
 var import_promises = require("fs/promises");
-var import_node_path50 = __toESM(require("path"), 1);
+var import_node_path51 = __toESM(require("path"), 1);
 var TYPES = {
   ".css": "text/css; charset=utf-8",
   ".html": "text/html; charset=utf-8",
@@ -29189,9 +29462,9 @@ function resolveStaticPath(root, requestUrl) {
     return null;
   }
   if (!pathname.startsWith("/") || pathname.includes("\0")) return null;
-  const rootResolved = import_node_path50.default.resolve(root);
-  const candidate = import_node_path50.default.resolve(rootResolved, `.${pathname}`);
-  if (candidate !== rootResolved && !candidate.startsWith(rootResolved + import_node_path50.default.sep)) {
+  const rootResolved = import_node_path51.default.resolve(root);
+  const candidate = import_node_path51.default.resolve(rootResolved, `.${pathname}`);
+  if (candidate !== rootResolved && !candidate.startsWith(rootResolved + import_node_path51.default.sep)) {
     return null;
   }
   return candidate;
@@ -29205,7 +29478,7 @@ async function fileSize(file) {
   }
 }
 function sendFile(req, res, file, size) {
-  const ext = import_node_path50.default.extname(file).toLowerCase();
+  const ext = import_node_path51.default.extname(file).toLowerCase();
   res.writeHead(200, {
     "Content-Type": TYPES[ext] ?? "application/octet-stream",
     "Content-Length": size,
@@ -29215,7 +29488,7 @@ function sendFile(req, res, file, size) {
     res.end();
     return true;
   }
-  (0, import_node_fs53.createReadStream)(file).pipe(res);
+  (0, import_node_fs54.createReadStream)(file).pipe(res);
   return true;
 }
 async function tryServeStatic(req, res, root) {
@@ -29224,7 +29497,7 @@ async function tryServeStatic(req, res, root) {
   if (!candidate) return false;
   const direct = await fileSize(candidate);
   if (direct != null) return sendFile(req, res, candidate, direct);
-  const asIndex = import_node_path50.default.join(candidate, "index.html");
+  const asIndex = import_node_path51.default.join(candidate, "index.html");
   const indexSize = await fileSize(asIndex);
   if (indexSize != null) return sendFile(req, res, asIndex, indexSize);
   return false;