@sideboard-ai/core 0.1.172 → 0.1.173

package/dist/{chunk-ZTVBIBLB.js → chunk-SKKEJZEX.js}

@@ -401,7 +401,7 @@ async function continueSourceThread(threadId, prompt) {
       await continueOnReply(threadId, prompt);
       return;
     }
-    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-RW4IVITI.js");
+    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-QBB2RELD.js");
     await getOrchestrator2().send(threadId, prompt);
   } catch {
   }
@@ -661,12 +661,62 @@ async function pollSlackOutboundWatches(opts) {
 }
 
 // src/orchestrator/orchestrator.ts
-import { existsSync as existsSync18 } from "fs";
+import { existsSync as existsSync19 } from "fs";
 
 // src/agents/spawn.ts
 import { createInterface } from "readline";
 import { execa } from "execa";
 
+// src/hook/worktree-pkg-cache.ts
+import { existsSync as existsSync3, mkdirSync } from "fs";
+import { join as join4 } from "path";
+var WORKTREE_PKG_CACHE_REL = ".context/.sideboard/pkg-cache";
+function worktreePkgCacheRoot(worktreePath) {
+  return join4(worktreePath, WORKTREE_PKG_CACHE_REL);
+}
+function worktreePkgCacheEnv(worktreePath) {
+  const root = worktreePkgCacheRoot(worktreePath);
+  const store = join4(root, "pnpm-store");
+  const pnpmCache = join4(root, "pnpm");
+  const npmCache = join4(root, "npm");
+  const nodeGyp = join4(root, "node-gyp");
+  const electron = join4(root, "electron");
+  return {
+    npm_config_store_dir: store,
+    PNPM_STORE_DIR: store,
+    npm_config_cache_dir: pnpmCache,
+    npm_config_cache: npmCache,
+    npm_config_devdir: nodeGyp,
+    // @electron/get — do not set ELECTRON_CACHE (stripNestedElectronEnv).
+    electron_config_cache: electron
+  };
+}
+function isSet(value) {
+  return value != null && value.trim() !== "";
+}
+function fillGroup(env, keys, values) {
+  if (keys.some((key) => isSet(env[key]))) return;
+  for (const key of keys) {
+    const value = values[key];
+    if (value) env[key] = value;
+  }
+}
+function ensureWorktreePkgCacheDirs(worktreePath) {
+  if (!existsSync3(worktreePath)) return;
+  mkdirSync(worktreePkgCacheRoot(worktreePath), { recursive: true });
+}
+function applyWorktreePkgCacheEnv(env, worktreePath) {
+  const cwd = worktreePath.trim();
+  if (!cwd) return;
+  const next = worktreePkgCacheEnv(cwd);
+  fillGroup(env, ["npm_config_store_dir", "PNPM_STORE_DIR"], next);
+  fillGroup(env, ["npm_config_cache_dir"], next);
+  fillGroup(env, ["npm_config_cache"], next);
+  fillGroup(env, ["npm_config_devdir"], next);
+  fillGroup(env, ["electron_config_cache"], next);
+  ensureWorktreePkgCacheDirs(cwd);
+}
+
 // src/agents/cursor-stream-coalesce.ts
 function isTextEvent(event) {
   return event.type === "stdout" || event.type === "thinking";
@@ -764,6 +814,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
   const env = childEnvWithAppSettings(cmd.env);
   applyPromptCacheTtlEnv(thread.agent, env);
   applyAgentRunnerHeapEnv(env);
+  if (!isOrchestratorThread(thread)) {
+    applyWorktreePkgCacheEnv(env, thread.worktreePath);
+  }
   try {
     if (isOrchestratorThread(thread)) {
       mergeAgentGitAuthEnv(env, await resolveAgentGitAuthEnv(env));
@@ -1020,20 +1073,20 @@ function shouldAutoArchiveOnPrMerge(opts) {
 // src/hook/conductor.ts
 import {
   copyFileSync,
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync2,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync3,
   readdirSync,
   readFileSync as readFileSync4
 } from "fs";
 import { createServer } from "net";
-import { basename, dirname as dirname2, join as join5 } from "path";
+import { basename, dirname as dirname2, join as join6 } from "path";
 import { execa as execa2 } from "execa";
 import { createInterface as createInterface2 } from "readline";
 
 // src/review/request-review.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
-import { dirname, join as join4 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { dirname, join as join5 } from "path";
 
 // src/threads/chat-tabs.ts
 import { randomUUID } from "crypto";
@@ -1706,7 +1759,7 @@ function shouldRefreshReviewRequestTemplate(content) {
   return LEGACY_REVIEW_TEMPLATE_MARKERS.every((m) => trimmed.includes(m));
 }
 function readTextIfPresent(abs) {
-  if (!existsSync3(abs)) return null;
+  if (!existsSync4(abs)) return null;
   try {
     const content = readFileSync3(abs, "utf8");
     return content.trim() ? content : null;
@@ -1715,12 +1768,12 @@ function readTextIfPresent(abs) {
   }
 }
 function readLocalGuidelines(worktreePath) {
-  const localAbs = join4(worktreePath, REVIEW_REQUEST_PATH);
+  const localAbs = join5(worktreePath, REVIEW_REQUEST_PATH);
   const localContent = readTextIfPresent(localAbs);
   if (localContent && !shouldRefreshReviewRequestTemplate(localContent)) {
     return { path: REVIEW_REQUEST_PATH, content: localContent };
   }
-  const legacyAbs = join4(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
+  const legacyAbs = join5(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
   const legacyContent = readTextIfPresent(legacyAbs);
   if (legacyContent && !shouldRefreshReviewRequestTemplate(legacyContent)) {
     return { path: LEGACY_REVIEW_REQUEST_PATH, content: legacyContent };
@@ -1744,27 +1797,27 @@ function contextGuidelines(content, source) {
   };
 }
 function writeContextGuidelines(worktreePath, content) {
-  const abs = join4(worktreePath, CONTEXT_REVIEW_PATH);
-  mkdirSync(dirname(abs), { recursive: true });
+  const abs = join5(worktreePath, CONTEXT_REVIEW_PATH);
+  mkdirSync2(dirname(abs), { recursive: true });
   const body = content.endsWith("\n") ? content : `${content}
 `;
   writeFileSync(abs, body, "utf8");
   return body;
 }
 function readSideboardReview(worktreePath, repoPath) {
-  const fromWorktree = readTextIfPresent(join4(worktreePath, REPO_REVIEW_PATH));
+  const fromWorktree = readTextIfPresent(join5(worktreePath, REPO_REVIEW_PATH));
   if (fromWorktree) return fromWorktree;
   const repo = repoPath?.replace(/\/+$/, "");
   const wt = worktreePath.replace(/\/+$/, "");
   if (!repo || repo === wt) return null;
-  return readTextIfPresent(join4(repo, REPO_REVIEW_PATH));
+  return readTextIfPresent(join5(repo, REPO_REVIEW_PATH));
 }
 function ensureReviewGuidelinesFile(worktreePath, repoPath) {
-  const skillContent = readTextIfPresent(join4(worktreePath, REVIEW_SKILL_PATH));
+  const skillContent = readTextIfPresent(join5(worktreePath, REVIEW_SKILL_PATH));
   if (skillContent) {
     return { ...skillGuidelines(skillContent, "skill"), wrote: false };
   }
-  const contextContent = readTextIfPresent(join4(worktreePath, CONTEXT_REVIEW_PATH));
+  const contextContent = readTextIfPresent(join5(worktreePath, CONTEXT_REVIEW_PATH));
   if (contextContent && !shouldRefreshReviewRequestTemplate(contextContent)) {
     return { ...contextGuidelines(contextContent, "local"), wrote: false };
   }
@@ -1827,8 +1880,8 @@ function matchSimpleGlob(pattern, name) {
   return new RegExp(`^${escaped}$`).test(name);
 }
 function readWorktreeInclude(repoPath) {
-  const path = join5(repoPath, ".worktreeinclude");
-  if (!existsSync4(path)) return [];
+  const path = join6(repoPath, ".worktreeinclude");
+  if (!existsSync5(path)) return [];
   return readFileSync4(path, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
 }
 function resolveFilesToCopy(repoPath) {
@@ -1868,10 +1921,10 @@ function copyConfiguredFiles(repoPath, worktreePath) {
   const patterns = resolveFilesToCopy(repoPath);
   const copied = [];
   for (const rel of patterns) {
-    const src = join5(repoPath, rel);
-    if (!existsSync4(src)) continue;
-    const dest = join5(worktreePath, rel);
-    mkdirSync2(dirname2(dest), { recursive: true });
+    const src = join6(repoPath, rel);
+    if (!existsSync5(src)) continue;
+    const dest = join6(worktreePath, rel);
+    mkdirSync3(dirname2(dest), { recursive: true });
     copyFileSync(src, dest);
     copied.push(rel);
   }
@@ -1931,6 +1984,7 @@ function buildWorkspaceScriptEnv(opts, baseEnv) {
       env[`CONDUCTOR_PORT_${i}`] = String(p);
     }
   }
+  applyWorktreePkgCacheEnv(env, opts.worktreePath);
   return env;
 }
 function pipeLines(stream, onLine) {
@@ -2172,8 +2226,8 @@ async function startDevServer(repoPath, worktreePath, onLine, opts) {
 }
 
 // src/store/setup-log.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { join as join7 } from "path";
 var EMPTY = {
   output: "",
   running: false,
@@ -2183,7 +2237,7 @@ var EMPTY = {
 var memory = /* @__PURE__ */ new Map();
 var persistTimers = /* @__PURE__ */ new Map();
 function setupLogPath(threadId) {
-  return join6(threadsDir(), `${threadId}.setup.log.json`);
+  return join7(threadsDir(), `${threadId}.setup.log.json`);
 }
 function emptySetupLog() {
   return { ...EMPTY };
@@ -2217,7 +2271,7 @@ function schedulePersist(threadId) {
 }
 function loadFromDisk(threadId) {
   const path = setupLogPath(threadId);
-  if (!existsSync5(path)) return null;
+  if (!existsSync6(path)) return null;
   try {
     const raw = JSON.parse(readFileSync5(path, "utf8"));
     return {
@@ -2277,8 +2331,8 @@ function finishSetupLog(threadId, exitCode, source) {
 }
 
 // src/git/orphan-cleanup.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, statSync } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync2, statSync } from "fs";
+import { join as join8 } from "path";
 function isSideboardWorktreePath(path) {
   return path.includes("/.sideboard/worktrees/") || path.includes("/sideboard/workspaces/");
 }
@@ -2289,7 +2343,7 @@ async function findOrphanWorktrees(repoPaths) {
     repoPaths?.length ? repoPaths : threads.map((t) => t.repoPath).filter(Boolean)
   );
   const homeRoot = sideboardWorkspacesDir();
-  if (existsSync6(homeRoot)) {
+  if (existsSync7(homeRoot)) {
     try {
       for (const entry of readdirSync2(homeRoot, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
@@ -2301,7 +2355,7 @@ async function findOrphanWorktrees(repoPaths) {
   const orphans = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoPath of repos) {
-    if (!repoPath || !existsSync6(repoPath)) continue;
+    if (!repoPath || !existsSync7(repoPath)) continue;
     try {
       const wts = await listWorktrees(repoPath);
       for (const wt of wts) {
@@ -2322,12 +2376,12 @@ async function findOrphanWorktrees(repoPaths) {
     }
     try {
       const root = worktreesRoot(repoPath);
-      if (existsSync6(root)) {
+      if (existsSync7(root)) {
         for (const entry of readdirSync2(root, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
-          const path = join7(root, entry.name).replace(/\/$/, "");
+          const path = join8(root, entry.name).replace(/\/$/, "");
           if (known.has(path) || seen.has(path)) continue;
-          if (!existsSync6(join7(path, ".git"))) continue;
+          if (!existsSync7(join8(path, ".git"))) continue;
           seen.add(path);
           let mtimeMs = 0;
           try {
@@ -2467,8 +2521,8 @@ async function applyThreadIntoMain(thread, opts) {
 }
 
 // src/git/clone-repo.ts
-import { existsSync as existsSync7 } from "fs";
-import { basename as basename2, join as join8 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { basename as basename2, join as join9 } from "path";
 import { execa as execa4 } from "execa";
 async function cloneRepoIntoSideboard(opts) {
   const url = opts.url.trim();
@@ -2479,8 +2533,8 @@ async function cloneRepoIntoSideboard(opts) {
     name = leaf || "repo";
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
-  const dest = join8(sideboardReposDir(), name);
-  if (existsSync7(dest)) {
+  const dest = join9(sideboardReposDir(), name);
+  if (existsSync8(dest)) {
     const repoPath2 = await resolveRepoRoot(dest);
     const workspace2 = await ensureWorkspace(repoPath2);
     return { repoPath: repoPath2, workspace: workspace2 };
@@ -2498,9 +2552,9 @@ async function cloneRepoIntoSideboard(opts) {
 
 // src/store/desktop-host.ts
 import { readFileSync as readFileSync6, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 function desktopHostPidPath() {
-  return join9(appDataDir(), "desktop-host.pid");
+  return join10(appDataDir(), "desktop-host.pid");
 }
 function readDesktopHostPid() {
   try {
@@ -2573,13 +2627,13 @@ function notifyParentOfChildHalt(child, status, send) {
 // src/mcp/wait-for-job.ts
 import {
   appendFileSync,
-  existsSync as existsSync8,
-  mkdirSync as mkdirSync3,
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync4,
   readdirSync as readdirSync3,
   readFileSync as readFileSync7,
   writeFileSync as writeFileSync4
 } from "fs";
-import { dirname as dirname3, join as join10 } from "path";
+import { dirname as dirname3, join as join11 } from "path";
 
 // src/mcp/wait-for-turn.ts
 var MCP_WAIT_FOR_TURN_MAX_MS = 45e3;
@@ -2642,23 +2696,23 @@ function jobTreeAlive(pid) {
   return jobAlive(pid) || processGroupAlive(pid);
 }
 function readIntFile(file) {
-  if (!existsSync8(file)) return null;
+  if (!existsSync9(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);
+  return join11(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;
+  if (existsSync9(modern)) return modern;
   const legacy = jobDir(root, id, true);
-  if (existsSync8(legacy)) return legacy;
+  if (existsSync9(legacy)) return legacy;
   return modern;
 }
 function listJobIdsIn(root, rel) {
-  const dir = join10(root, rel);
-  if (!existsSync8(dir)) return [];
+  const dir = join11(root, rel);
+  if (!existsSync9(dir)) return [];
   return readdirSync3(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && JOB_ID_RE.test(e.name)).map((e) => e.name);
 }
 function listRunningDetachedJobs(worktreePath) {
@@ -2671,7 +2725,7 @@ function listRunningDetachedJobs(worktreePath) {
   const running = [];
   for (const id of ids) {
     const dir = resolveJobDir(root, id);
-    const pid = readIntFile(join10(dir, "pid"));
+    const pid = readIntFile(join11(dir, "pid"));
     if (pid != null && jobAlive(pid)) running.push(id);
   }
   return running.sort();
@@ -2724,12 +2778,12 @@ function planJobContinue(opts) {
   return { action: "none" };
 }
 function tailProgress(logFile, maxLines = 12) {
-  if (!existsSync8(logFile)) return "(no log yet)";
+  if (!existsSync9(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 [];
+  if (!existsSync9(file)) return [];
   const lines = readFileSync7(file, "utf8").split("\n");
   if (lines.length && lines[lines.length - 1] === "") lines.pop();
   return lines;
@@ -2741,15 +2795,15 @@ function takeDelta(logFile, cursorFile) {
   return { delta: lines.slice(start).join("\n"), nextCursor: lines.length };
 }
 function snapshotJob(dir) {
-  const pid = readIntFile(join10(dir, "pid"));
+  const pid = readIntFile(join11(dir, "pid"));
   const running = jobTreeAlive(pid);
   return {
     pid,
     running,
-    exitCode: readIntFile(join10(dir, "exit")),
-    log: join10(dir, "log"),
-    cursor: join10(dir, "present.cursor"),
-    progress: tailProgress(join10(dir, "log"))
+    exitCode: readIntFile(join11(dir, "exit")),
+    log: join11(dir, "log"),
+    cursor: join11(dir, "present.cursor"),
+    progress: tailProgress(join11(dir, "log"))
   };
 }
 function toResult(id, snap, extra) {
@@ -2758,7 +2812,7 @@ function toResult(id, snap, extra) {
   const stillRunning = snap.running && !ok;
   const { delta, nextCursor } = takeDelta(snap.log, snap.cursor);
   try {
-    mkdirSync3(dirname3(snap.cursor), { recursive: true });
+    mkdirSync4(dirname3(snap.cursor), { recursive: true });
     writeFileSync4(snap.cursor, `${nextCursor}
 `);
   } catch {
@@ -2786,7 +2840,7 @@ async function waitForDetachedJob(cwd, id, opts) {
   const dir = resolveJobDir(root, jobId);
   const timeoutMs = mcpWaitForJobTimeoutMs(opts?.timeoutMs);
   const sleep = opts?.sleep ?? sleepMs;
-  if (!existsSync8(dir)) {
+  if (!existsSync9(dir)) {
     return {
       stillRunning: false,
       ok: false,
@@ -2832,7 +2886,7 @@ function killProcessTree(pid, signal) {
 }
 function appendJobLog(logFile, line) {
   try {
-    mkdirSync3(dirname3(logFile), { recursive: true });
+    mkdirSync4(dirname3(logFile), { recursive: true });
     const body = line.endsWith("\n") ? line : `${line}
 `;
     appendFileSync(logFile, body);
@@ -2845,7 +2899,7 @@ async function stopDetachedJob(cwd, id, opts) {
   const dir = resolveJobDir(root, jobId);
   const sleep = opts?.sleep ?? sleepMs;
   const why = opts?.reason?.trim() ?? "";
-  if (!existsSync8(dir)) {
+  if (!existsSync9(dir)) {
     return {
       stillRunning: false,
       ok: false,
@@ -2881,8 +2935,8 @@ async function stopDetachedJob(cwd, id, opts) {
     killProcessTree(targetPid, "SIGKILL");
     await sleep(100);
   }
-  const exitFile = join10(dir, "exit");
-  if (!existsSync8(exitFile)) {
+  const exitFile = join11(dir, "exit");
+  if (!existsSync9(exitFile)) {
     try {
       writeFileSync4(exitFile, "1\n");
     } catch {
@@ -2906,7 +2960,7 @@ async function stopDetachedJob(cwd, id, opts) {
 }
 
 // src/threads/create.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 
 // src/detect/detect.ts
 var REQUIRE_AGENT_TIMEOUT_MS = 8e3;
@@ -3426,7 +3480,7 @@ function reuseLiveThread(input, repoPath, match) {
 }
 async function createThread(input, _onSetupLine) {
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!existsSync9(repoPath)) {
+  if (!existsSync10(repoPath)) {
     throw new Error(`Repo not found: ${repoPath}`);
   }
   const reused = reuseLiveThread(input, repoPath, {
@@ -3624,7 +3678,7 @@ function shouldRemoveWorktreeOnTeardown(thread) {
 
 // src/store/turn-live.ts
 import {
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   renameSync,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync5,
@@ -3716,7 +3770,7 @@ function writeTurnLive(threadId, progress) {
 }
 function readTurnLive(threadId) {
   const path = threadLivePath(threadId);
-  if (!existsSync10(path)) return null;
+  if (!existsSync11(path)) return null;
   try {
     const raw = JSON.parse(readFileSync8(path, "utf8"));
     if (!raw || typeof raw.summary !== "string") return null;
@@ -3730,7 +3784,7 @@ function clearTurnLive(threadId) {
   if (buf?.timer) clearTimeout(buf.timer);
   buffers.delete(threadId);
   const path = threadLivePath(threadId);
-  if (!existsSync10(path)) return;
+  if (!existsSync11(path)) return;
   try {
     unlinkSync2(path);
   } catch {
@@ -3915,26 +3969,26 @@ function createQuotaFailoverChat(from, fallbackAgent, limitText) {
 import { execFileSync } from "child_process";
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   mkdtempSync,
   readdirSync as readdirSync4,
   readFileSync as readFileSync9,
   rmSync
 } from "fs";
 import { tmpdir } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 import { createRequire } from "module";
-var CONDUCTOR_APP_SUPPORT = join11(
+var CONDUCTOR_APP_SUPPORT = join12(
   process.env.HOME ?? "",
   "Library",
   "Application Support",
   "com.conductor.app"
 );
-var CONDUCTOR_DB = join11(CONDUCTOR_APP_SUPPORT, "conductor.db");
-var CURSOR_SDK_STORE = join11(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+var CONDUCTOR_DB = join12(CONDUCTOR_APP_SUPPORT, "conductor.db");
+var CURSOR_SDK_STORE = join12(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
 function thisModuleFile() {
   const cjsFile = typeof __filename !== "undefined" ? __filename : "";
-  return cjsFile || process.argv[1] || join11(process.cwd(), "package.json");
+  return cjsFile || process.argv[1] || join12(process.cwd(), "package.json");
 }
 function openReadonlySqlite(file) {
   const req = createRequire(thisModuleFile());
@@ -3952,7 +4006,7 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !existsSync11(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !existsSync12(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
@@ -3962,8 +4016,8 @@ function resolveConductorCursorAgentId(workspacePath) {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = join11(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!existsSync11(agentsFile)) continue;
+    const agentsFile = join12(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!existsSync12(agentsFile)) continue;
     let text;
     try {
       text = readFileSync9(agentsFile, "utf8");
@@ -3990,7 +4044,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!existsSync11(input.worktreePath)) {
+  if (!existsSync12(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -4016,16 +4070,16 @@ async function adoptThread(input) {
   return thread;
 }
 function listConductorWorkspaces() {
-  if (!existsSync11(CONDUCTOR_DB)) {
+  if (!existsSync12(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = mkdtempSync(join11(tmpdir(), "sideboard-conductor-"));
-  const snapshot = join11(tmp, "conductor.db");
+  const tmp = mkdtempSync(join12(tmpdir(), "sideboard-conductor-"));
+  const snapshot = join12(tmp, "conductor.db");
   try {
     copyFileSync2(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if (existsSync11(src)) {
+      if (existsSync12(src)) {
         try {
           copyFileSync2(src, `${snapshot}${suffix}`);
         } catch {
@@ -4107,16 +4161,16 @@ function listConductorWorkspaces() {
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!existsSync11(CONDUCTOR_DB)) {
+  if (!existsSync12(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = mkdtempSync(join11(tmpdir(), "sideboard-conductor-"));
-  const snapshot = join11(tmp, "conductor.db");
+  const tmp = mkdtempSync(join12(tmpdir(), "sideboard-conductor-"));
+  const snapshot = join12(tmp, "conductor.db");
   try {
     copyFileSync2(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if (existsSync11(src)) {
+      if (existsSync12(src)) {
         try {
           copyFileSync2(src, `${snapshot}${suffix}`);
         } catch {
@@ -4136,7 +4190,7 @@ function importConductorWorkspace(workspaceId) {
       ).get(workspaceId);
       if (!row) throw new Error(`Conductor workspace not found: ${workspaceId}`);
       const worktreePath = String(row.workspacePath);
-      if (!existsSync11(worktreePath)) {
+      if (!existsSync12(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -4207,7 +4261,7 @@ async function importConductorWorkspaceAsync(workspaceId) {
 }
 
 // src/threads/stack-layers.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 function stackIdFrom(stack) {
   if (stack.stackNumber != null) return `gh-stack-${stack.stackNumber}`;
   const key = stack.layers.map((l) => l.branchName).join("|");
@@ -4270,7 +4324,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 && existsSync12(checkedOut.path)) {
+  if (checkedOut?.path && existsSync13(checkedOut.path)) {
     if (input.reuseExistingWorktree !== false) {
       worktreePath = checkedOut.path;
     } else {
@@ -4412,7 +4466,7 @@ async function initStackFromThread(input, onSetupLine) {
 async function createPrStack(input, onSetupLine) {
   await requireAgent(input.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!existsSync12(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
+  if (!existsSync13(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);
@@ -4479,7 +4533,7 @@ async function createPrStack(input, onSetupLine) {
     }
   }
   const claimed = new Set(threads.map((t) => t.worktreePath));
-  if (!claimed.has(bootstrap.worktreePath) && existsSync12(bootstrap.worktreePath)) {
+  if (!claimed.has(bootstrap.worktreePath) && existsSync13(bootstrap.worktreePath)) {
     try {
       await removeWorktree(repoPath, bootstrap.worktreePath, {
         deleteBranch: bootstrap.branchName
@@ -4491,10 +4545,10 @@ async function createPrStack(input, onSetupLine) {
 }
 
 // src/diff/diff.ts
-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";
+import { existsSync as existsSync14, mkdirSync as mkdirSync5, readFileSync as readFileSync10, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname4, join as join13 } from "path";
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !existsSync13(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !existsSync14(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -4502,7 +4556,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !existsSync13(worktreePath)) {
+  if (!worktreePath || !existsSync14(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -4638,7 +4692,7 @@ new file mode 100644
   };
 }
 async function untrackedPatch(worktreePath, path, maxHunk) {
-  const abs = join12(worktreePath, path);
+  const abs = join13(worktreePath, path);
   try {
     const st = statSync2(abs);
     if (st.isFile() && st.size > maxHunk) {
@@ -5143,7 +5197,7 @@ var DEFAULT_UPLOAD_MAX_BYTES = 5e7;
 function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-  const abs = join12(worktreePath, relativePath);
+  const abs = join13(worktreePath, relativePath);
   const st = statSync2(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
@@ -5163,7 +5217,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = join12(worktreePath, relativePath);
+  const abs = join13(worktreePath, relativePath);
   const st = statSync2(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
@@ -5211,8 +5265,8 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = join12(worktreePath, relativePath);
-  mkdirSync4(dirname4(abs), { recursive: true });
+  const abs = join13(worktreePath, relativePath);
+  mkdirSync5(dirname4(abs), { recursive: true });
   writeFileSync6(abs, content, "utf8");
   return { path: relativePath };
 }
@@ -5338,9 +5392,9 @@ async function confirmLand(thread, opts) {
 }
 
 // src/skills/discover.ts
-import { existsSync as existsSync14, readdirSync as readdirSync5, readFileSync as readFileSync11, statSync as statSync3 } from "fs";
+import { existsSync as existsSync15, readdirSync as readdirSync5, readFileSync as readFileSync11, statSync as statSync3 } from "fs";
 import { homedir } from "os";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 
 // src/skills/bundled/long-running.ts
 var LONG_RUNNING_SKILL_COMMAND = "long-running";
@@ -5496,7 +5550,7 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!existsSync14(dir)) return;
+  if (!existsSync15(dir)) return;
   let entries;
   try {
     entries = readdirSync5(dir);
@@ -5505,8 +5559,8 @@ function scanSkillsDir(dir, source, out) {
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const skillMd = join13(dir, entry, "SKILL.md");
-    if (!existsSync14(skillMd)) continue;
+    const skillMd = join14(dir, entry, "SKILL.md");
+    if (!existsSync15(skillMd)) continue;
     try {
       if (!statSync3(skillMd).isFile()) continue;
     } catch {
@@ -5517,7 +5571,7 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!existsSync14(pluginsRoot)) return;
+  if (!existsSync15(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
@@ -5527,12 +5581,12 @@ function scanClaudePluginSkills(pluginsRoot, out) {
       return;
     }
     if (lookingForSkillsDir && entries.includes("SKILL.md")) {
-      const skill = readSkill(join13(dir, "SKILL.md"), "cli");
+      const skill = readSkill(join14(dir, "SKILL.md"), "cli");
       if (skill) out.push(skill);
     }
     for (const entry of entries) {
       if (entry === "node_modules" || entry === ".git") continue;
-      const full = join13(dir, entry);
+      const full = join14(dir, entry);
       try {
         if (!statSync3(full).isDirectory()) continue;
       } catch {
@@ -5552,17 +5606,17 @@ function discoverSkills(worktreePath) {
   const home = homedir();
   const collected = [];
   for (const rel of [".claude/skills", ".cursor/skills", ".sideboard/skills", ".brightsy/skills", "skills"]) {
-    scanSkillsDir(join13(worktreePath, rel), "workspace", collected);
+    scanSkillsDir(join14(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    join13(home, ".claude/skills"),
-    join13(home, ".cursor/skills"),
-    join13(home, ".sideboard/skills"),
-    join13(home, ".brightsy/skills")
+    join14(home, ".claude/skills"),
+    join14(home, ".cursor/skills"),
+    join14(home, ".sideboard/skills"),
+    join14(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills(join13(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills(join14(home, ".claude/plugins"), collected);
   collected.push(...bundledSkills());
   const rank = {
     workspace: 0,
@@ -5681,18 +5735,18 @@ function expandComposerPrompt(worktreePath, prompt, opts) {
 }
 
 // src/agents/instructions.ts
-import { existsSync as existsSync16 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { join as join16 } from "path";
 
 // src/skills/detached-job-path.ts
-import { existsSync as existsSync15 } from "fs";
-import { dirname as dirname5, join as join14 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { dirname as dirname5, join as join15 } from "path";
 import { fileURLToPath } from "url";
 var DETACHED_JOB_FILENAMES = ["detached-job.cjs", "detached-job.js"];
 function detachedJobScriptIn(dir) {
   for (const name of DETACHED_JOB_FILENAMES) {
-    const script = join14(dir, "scripts", name);
-    if (existsSync15(script)) return script;
+    const script = join15(dir, "scripts", name);
+    if (existsSync16(script)) return script;
   }
   return null;
 }
@@ -5873,11 +5927,13 @@ function formatPrGateDirective() {
 }
 function formatProcessGuideDirective(opts) {
   const worktree = opts?.worktreePath?.trim();
-  const hasGraphSkill = !!worktree && existsSync16(join15(worktree, ".claude/skills/graph-engineering/SKILL.md"));
-  const hasReviewSkill = !!worktree && existsSync16(join15(worktree, ".claude/skills/review/SKILL.md"));
+  const hasGraphSkill = !!worktree && existsSync17(join16(worktree, ".claude/skills/graph-engineering/SKILL.md"));
+  const hasReviewSkill = !!worktree && existsSync17(join16(worktree, ".claude/skills/review/SKILL.md"));
+  const hasInstallSkill = !!worktree && existsSync17(join16(worktree, ".claude/skills/worktree-install/SKILL.md"));
   return [
     "Process guides (recurring work only):",
     hasGraphSkill ? "- Migrations, ports, batch fixes, and other fan-out: follow `.claude/skills/graph-engineering/SKILL.md` (`/graph-engineering`). Judge first; state on disk; grow the rulebook; do not patch around it." : null,
+    hasInstallSkill ? "- After merge-from-main / lockfile change, or a hung `pnpm install`: follow `.claude/skills/worktree-install/SKILL.md` (`/worktree-install`). Use the worktree-local store Sideboard already set; do not share `~/.pnpm-store` across concurrent worktrees." : null,
     "- If this same shape of work will happen again, write `.claude/skills/<kebab-name>/SKILL.md` in this worktree (Claude Code project skill; Sideboard `/name`, Claude Code, and `attach` all load it). Not under `.sideboard/skills/`. Point Codex/OpenCode at it from `AGENTS.md`.",
     hasReviewSkill ? "- Merge-readiness notes go in `.claude/skills/review/SKILL.md` (edit it; do not create another review skill)." : "- Merge-readiness notes go in `.context/review.md` (copied from `.sideboard/review.md` when that file exists). Do not create a review skill.",
     "- Skip a guide for a one-off. If a matching skill exists, follow it. Same miss twice \u2192 edit the skill, do not patch around it."
@@ -6047,8 +6103,8 @@ async function syncThreadBranchFromGit(threadId) {
 
 // src/store/schedules.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync17, readFileSync as readFileSync12 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync12 } from "fs";
+import { join as join17 } from "path";
 import { Cron } from "croner";
 var DURATION_RE = /^(\d+)(s|m|h|d)$/i;
 var UNIT_MS = {
@@ -6058,7 +6114,7 @@ var UNIT_MS = {
   d: 864e5
 };
 function schedulesPath() {
-  return join16(appDataDir(), "schedules.json");
+  return join17(appDataDir(), "schedules.json");
 }
 function parseDurationMs(every) {
   const m = every.trim().match(DURATION_RE);
@@ -6158,7 +6214,7 @@ function normalizeTask(raw) {
 }
 function readAll() {
   const path = schedulesPath();
-  if (!existsSync17(path)) return [];
+  if (!existsSync18(path)) return [];
   try {
     const parsed = JSON.parse(readFileSync12(path, "utf8"));
     if (!Array.isArray(parsed)) return [];
@@ -6283,7 +6339,7 @@ function formatScheduledPrompt(name, prompt) {
 ${prompt}`;
 }
 async function defaultDeps() {
-  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-RW4IVITI.js");
+  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-QBB2RELD.js");
   const orch = getOrchestrator2();
   return {
     findThread: (id) => findThreadByRef(id),
@@ -6526,7 +6582,7 @@ var Orchestrator = class {
         }
         continue;
       }
-      if (!existsSync18(thread.worktreePath)) {
+      if (!existsSync19(thread.worktreePath)) {
         setStatus(thread.id, "broken", "Worktree missing on disk");
         this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
         continue;
@@ -8416,7 +8472,7 @@ var Orchestrator = class {
       this.emit({ type: "status_changed", threadId: restored2.id, status: restored2.status });
       return restored2;
     }
-    if (!existsSync18(thread.worktreePath)) {
+    if (!existsSync19(thread.worktreePath)) {
       if (isCowboyThread(thread) || isPrimaryCheckoutThread(thread)) {
         throw new Error(
           `Cowboy checkout missing: ${thread.worktreePath}. Re-add the project folder, then restore.`