@tablation/crew 0.106.0 → 0.107.0

package/dist/cli.js

@@ -2185,6 +2185,12 @@ function parseSandbox(raw, file) {
   const r = raw;
   const packages = stringList(r.packages, "sandbox.packages", file);
   const setup = stringList(r.setup, "sandbox.setup", file);
+  const warm = stringList(r.warm, "sandbox.warm", file);
+  for (const w of warm) {
+    if (w.startsWith("/") || w.split("/").some((seg) => seg === ".." || seg === "" || seg === ".") || /[\\\s]/.test(w)) {
+      throw new RepoConfigError(`${file}: sandbox.warm entry "${w}" must be a repo-relative path or glob with no "..", empty segments, backslashes or whitespace`);
+    }
+  }
   for (const p of packages) {
     if (!PACKAGE_NAME.test(p)) throw new RepoConfigError(`${file}: sandbox.packages entry "${p}" is not a package name (lowercase letters, digits, + . - and an optional =version)`);
   }
@@ -2198,7 +2204,7 @@ function parseSandbox(raw, file) {
       throw new RepoConfigError(`${file}: sandbox.image and sandbox.packages are alternatives \u2014 a published image already carries its packages; put the rest in sandbox.setup`);
     }
   }
-  return { ...image ? { image } : {}, packages, setup };
+  return { ...image ? { image } : {}, packages, setup, warm };
 }
 function parseRepoConfig(text2, file) {
   let raw;
@@ -2218,7 +2224,7 @@ function parseRepoConfig(text2, file) {
   rejectUnknown(raw.branch, BRANCH_KEYS, "branch", file);
   rejectUnknown(raw.worktrees, /* @__PURE__ */ new Set(["copy", "prefix", "name"]), "worktrees", file);
   rejectUnknown(raw.docs, /* @__PURE__ */ new Set(["triagePolicy", "designGuide"]), "docs", file);
-  rejectUnknown(raw.sandbox, /* @__PURE__ */ new Set(["image", "packages", "setup"]), "sandbox", file);
+  rejectUnknown(raw.sandbox, /* @__PURE__ */ new Set(["image", "packages", "setup", "warm"]), "sandbox", file);
   if (raw.version === void 0) throw new RepoConfigError(`${file}: version is required`);
   if (raw.version !== SPEC_VERSION) {
     throw new RepoConfigError(
@@ -5367,8 +5373,9 @@ function attentionProblems(items, already) {
 // src/sandbox-image.ts
 import { createHash as createHash5 } from "crypto";
 import { spawn as spawn2 } from "child_process";
+import { execFileSync as execFileSync4 } from "child_process";
 import { mkdirSync as mkdirSync9, readFileSync as readFileSync14, renameSync as renameSync3, writeFileSync as writeFileSync10, rmSync as rmSync9 } from "fs";
-import { join as join15 } from "path";
+import { dirname as dirname7, join as join15 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 
 // src/passenger-containers.ts
@@ -5628,7 +5635,25 @@ function crewLayer(base) {
   ].join("\n");
   return { name: "crew", tag: `crew-sandbox-crew:${hash({ base: base.tag, dockerfile, files })}`, dockerfile, files };
 }
-function repoLayer(repo, decl, crew) {
+var WARM_DIR = "/tmp/crew-warm";
+var WARM_MAX_BYTES = 64 * 1024 * 1024;
+var globToRegExp = (glob) => new RegExp(`^${glob.split("*").map((p) => p.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join("[^/]*")}$`);
+function readWarmFiles(dir, ref, patterns) {
+  if (patterns.length === 0) return {};
+  const git2 = (args) => execFileSync4("git", ["-C", dir, ...args], { encoding: "utf8", maxBuffer: WARM_MAX_BYTES, stdio: ["ignore", "pipe", "pipe"] });
+  const all = git2(["ls-tree", "-r", "--name-only", ref]).split("\n").filter(Boolean);
+  const res = patterns.map(globToRegExp);
+  const out = {};
+  let total = 0;
+  for (const path of all.filter((f) => res.some((re) => re.test(f))).sort()) {
+    const content = git2(["show", `${ref}:${path}`]);
+    total += content.length;
+    if (total > WARM_MAX_BYTES) throw new Error(`sandbox.warm files exceed ${WARM_MAX_BYTES} bytes`);
+    out[path] = content;
+  }
+  return out;
+}
+function repoLayer(repo, decl, crew, warm) {
   const env = Object.entries(CREW_ENV).map(([k, v]) => `${k}=${v}`).join(" ");
   const lines2 = [];
   if (decl.image) {
@@ -5650,15 +5675,22 @@ function repoLayer(repo, decl, crew) {
     `USER ${SANDBOX_UID}`,
     "WORKDIR /sandbox"
   );
+  const files = {};
+  const warming = Object.keys(warm).length > 0;
+  if (warming) {
+    for (const [path, content] of Object.entries(warm)) files[`warm/${path}`] = content;
+    lines2.push(`COPY --chown=${SANDBOX_UID}:${SANDBOX_UID} warm/ ${WARM_DIR}/`, `WORKDIR ${WARM_DIR}`);
+  }
   for (const step of decl.setup) lines2.push(run(step));
+  if (warming) lines2.push("WORKDIR /sandbox", run(`rm -rf ${WARM_DIR}`));
   lines2.push(`LABEL io.crew.sandbox.layer="repo" io.crew.sandbox.repo=${JSON.stringify(repo)}`, "");
   const dockerfile = lines2.join("\n");
-  return { name: "repo", tag: `crew-sandbox/${slug(repo)}:${hash({ crew: crew.tag, dockerfile })}`, dockerfile, files: {} };
+  return { name: "repo", tag: `crew-sandbox/${slug(repo)}:${hash({ crew: crew.tag, dockerfile, files })}`, dockerfile, files };
 }
-function planSandbox(repo, decl) {
+function planSandbox(repo, decl, warm = {}) {
   const base = baseLayer();
   const crew = crewLayer(base);
-  const layer = repoLayer(repo, decl, crew);
+  const layer = repoLayer(repo, decl, crew, warm);
   return { repo, tag: layer.tag, layers: [base, crew, layer] };
 }
 var sandboxStatePath = (stateDir) => join15(stateDir, "sandbox-images.json");
@@ -5733,7 +5765,10 @@ async function buildSandboxImage(plan, deps) {
     mkdirSync9(ctx, { recursive: true });
     try {
       writeFileSync10(join15(ctx, "Dockerfile"), layer.dockerfile);
-      for (const [name, content] of Object.entries(layer.files)) writeFileSync10(join15(ctx, name), content);
+      for (const [name, content] of Object.entries(layer.files)) {
+        mkdirSync9(dirname7(join15(ctx, name)), { recursive: true });
+        writeFileSync10(join15(ctx, name), content);
+      }
       const code = await deps.run(["build", "--tag", layer.tag, "--file", join15(ctx, "Dockerfile"), ctx], logPath);
       if (code !== 0) {
         state[plan.repo] = { ...entry, failure: { tag: plan.tag, at: now().toISOString(), logPath } };
@@ -5764,7 +5799,7 @@ function sandboxFailedItem(repo, tag, layer, logPath, nowIso = (/* @__PURE__ */
 async function sandboxBuildTick(repos, deps, force = false) {
   const nowMs = (deps.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
   for (const r of repos) {
-    const plan = planSandbox(r.name, r.decl);
+    const plan = planSandbox(r.name, r.decl, r.warm);
     const state = readSandboxState(deps.stateDir)[r.name];
     const upToDate = state?.tags[0]?.tag === plan.tag && deps.hasImage(plan.tag);
     if (upToDate) {
@@ -5787,10 +5822,10 @@ async function sandboxBuildTick(repos, deps, force = false) {
 }
 
 // src/doctor-checks.ts
-import { execFileSync as execFileSync4 } from "child_process";
+import { execFileSync as execFileSync5 } from "child_process";
 var PROBE_BRANCH = "crew-probe-branch";
 var realGit = (cwd, args, env) => {
-  execFileSync4("git", args, { cwd, env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
+  execFileSync5("git", args, { cwd, env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
 };
 function isSshRemote(url) {
   return /^ssh:\/\//.test(url) || /^[\w.-]+@[\w.-]+:/.test(url);
@@ -5921,7 +5956,7 @@ import { spawnSync as spawnSync6 } from "child_process";
 import { readFileSync as readFileSync21, existsSync as existsSync24, statSync as statSync7, mkdirSync as mkdirSync13, writeFileSync as writeFileSync15, createWriteStream, openSync as openSync3, closeSync as closeSync3, readSync } from "fs";
 import { StringDecoder } from "string_decoder";
 import { finished } from "stream/promises";
-import { join as join26, dirname as dirname8, basename as basename8 } from "path";
+import { join as join26, dirname as dirname9, basename as basename8 } from "path";
 import { createHash as createHash6 } from "crypto";
 
 // src/state.ts
@@ -8531,15 +8566,15 @@ function holdWarnings(tickets, ships, contract, humanHolds, now = Date.now()) {
 
 // src/run-worktree.ts
 import { existsSync as existsSync17 } from "fs";
-import { dirname as dirname7, join as join19 } from "path";
+import { dirname as dirname8, join as join19 } from "path";
 
 // src/ports.ts
-import { execFileSync as execFileSync5 } from "child_process";
+import { execFileSync as execFileSync6 } from "child_process";
 import { existsSync as existsSync16 } from "fs";
 import { join as join18 } from "path";
 var run2 = (cmd, args) => {
   try {
-    return execFileSync5(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return execFileSync6(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
   } catch {
     return "";
   }
@@ -8680,7 +8715,7 @@ function planRunWorktree(dir, cfg, t, role, opts = {}) {
     if (countCommits(existing.path, `${baseRef}..HEAD`) > 0) return { action: "leave-unpushed", path: existing.path, branch };
     return { action: "recut", path: existing.path, branch, base: baseRef };
   }
-  const path = join19(dirname7(dir), worktreeForTicket(dir, cfg, t, role));
+  const path = join19(dirname8(dir), worktreeForTicket(dir, cfg, t, role));
   if (located?.where === "remote" || located && hasRemote && remoteBranchExists(dir, remote, located.branch)) {
     return { action: "cut-remote", path, branch: located.branch };
   }
@@ -9951,7 +9986,7 @@ function skillMarkerWarnings(promptsDir, personaPrompts) {
 }
 
 // src/runner.ts
-import { spawn as spawn3, execFile as execFile2, execFileSync as execFileSync6 } from "child_process";
+import { spawn as spawn3, execFile as execFile2, execFileSync as execFileSync7 } from "child_process";
 import { mkdtempSync, writeFileSync as writeFileSync14, rmSync as rmSync13 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
 import { basename as basename7, join as join25 } from "path";
@@ -10932,7 +10967,7 @@ function describeExecError(e) {
 }
 function gitOrigin(cwd) {
   try {
-    return execFileSync6("git", ["-C", cwd, "remote", "get-url", "origin"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    return execFileSync7("git", ["-C", cwd, "remote", "get-url", "origin"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
   } catch {
     return null;
   }
@@ -10943,7 +10978,7 @@ function runnerFor(kind, sandbox) {
 function runnerOfSidecar(sc) {
   return sc.runner === "sandbox" ? new SandboxRunner(sc.sandboxBin ? { bin: sc.sandboxBin } : {}) : new HostRunner();
 }
-function checkSandboxRunner(cfg = {}, run3 = (b, a) => execFileSync6(b, a, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 15e3 })) {
+function checkSandboxRunner(cfg = {}, run3 = (b, a) => execFileSync7(b, a, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 15e3 })) {
   const bin = cfg.bin ?? DEFAULT_SANDBOX_CONFIG.bin;
   let version;
   try {
@@ -11219,7 +11254,7 @@ async function killForDeadline(kill, pid, emit, role, ticket, spawnedAt, limitMi
 var withoutKey = ({ apiKey: _apiKey, ...rest }) => rest;
 function openSink(path) {
   try {
-    mkdirSync13(dirname8(path), { recursive: true });
+    mkdirSync13(dirname9(path), { recursive: true });
     return createWriteStream(path, { flags: "a" });
   } catch {
     return void 0;
@@ -11561,7 +11596,7 @@ function spawnAgent(plan, emit, hintMoved) {
   const id = identityOf(plan, adapter.harness);
   let streamFd;
   try {
-    mkdirSync13(dirname8(plan.streamPath), { recursive: true });
+    mkdirSync13(dirname9(plan.streamPath), { recursive: true });
     streamFd = openSync3(plan.streamPath, "a");
   } catch (e) {
     void endSink(eventsSink);
@@ -11933,7 +11968,7 @@ function doctorSelftestLines(stored, toolchains) {
 }
 
 // src/cli.ts
-import { resolve as resolve6, dirname as dirname25, join as join49, basename as basename15 } from "path";
+import { resolve as resolve6, dirname as dirname26, join as join49, basename as basename15 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname4, homedir as homedir11 } from "os";
 import { spawnSync as spawnSync10 } from "child_process";
@@ -12131,7 +12166,7 @@ function rosterMarkdown(roster, meId) {
 
 // src/connect-resume.ts
 import { mkdirSync as mkdirSync15, readFileSync as readFileSync23, rmSync as rmSync15, writeFileSync as writeFileSync17 } from "fs";
-import { dirname as dirname9, join as join28 } from "path";
+import { dirname as dirname10, join as join28 } from "path";
 function lastSessionFile(stateDir) {
   return join28(stateDir, "connect-session.json");
 }
@@ -12151,7 +12186,7 @@ function readPointers(stateDir) {
 }
 function writePointers(stateDir, pointers) {
   const file = lastSessionFile(stateDir);
-  mkdirSync15(dirname9(file), { recursive: true });
+  mkdirSync15(dirname10(file), { recursive: true });
   writeFileSync17(file, `${JSON.stringify(pointers, null, 2)}
 `, { mode: 384 });
 }
@@ -12238,7 +12273,7 @@ async function signOutSessions(o) {
 
 // src/reset.ts
 import { existsSync as existsSync26, mkdirSync as mkdirSync16, readFileSync as readFileSync24, readdirSync as readdirSync12, rmSync as rmSync16, statSync as statSync8, writeFileSync as writeFileSync18 } from "fs";
-import { dirname as dirname10, join as join29 } from "path";
+import { dirname as dirname11, join as join29 } from "path";
 import { hostFromUrl as hostFromUrl3 } from "@tablation/client";
 function clonedCheckoutsFile(stateDir) {
   return join29(stateDir, "cloned-checkouts.json");
@@ -12255,7 +12290,7 @@ function recordClonedCheckout(stateDir, dir) {
   const known = readClonedCheckouts(stateDir);
   if (known.includes(dir)) return;
   const file = clonedCheckoutsFile(stateDir);
-  mkdirSync16(dirname10(file), { recursive: true });
+  mkdirSync16(dirname11(file), { recursive: true });
   writeFileSync18(file, `${JSON.stringify([...known, dir], null, 2)}
 `);
 }
@@ -12438,7 +12473,7 @@ async function runDeprovision(o, fx, deps) {
 // src/pool-member.ts
 import { mkdirSync as mkdirSync17, readFileSync as readFileSync25, renameSync as renameSync4, writeFileSync as writeFileSync19 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname11, join as join30 } from "path";
+import { dirname as dirname12, join as join30 } from "path";
 var POOL_EXIT = { ok: 0, failed: 1, credential: 2 };
 function backoffMs(attempt) {
   return Math.min(6e4, 5e3 * 2 ** Math.max(0, attempt));
@@ -12640,7 +12675,7 @@ function fileMemberStore(dir) {
       }
     },
     write(f) {
-      mkdirSync17(dirname11(file), { recursive: true, mode: 448 });
+      mkdirSync17(dirname12(file), { recursive: true, mode: 448 });
       const tmp = `${file}.tmp`;
       writeFileSync19(tmp, `${JSON.stringify(f)}
 `, { mode: 384 });
@@ -12698,10 +12733,10 @@ import { existsSync as existsSync30 } from "fs";
 import { hostname as hostname3 } from "os";
 
 // src/machine-id.ts
-import { execFileSync as execFileSync7 } from "child_process";
+import { execFileSync as execFileSync8 } from "child_process";
 import { createHash as createHash7 } from "crypto";
 import { existsSync as existsSync27, mkdirSync as mkdirSync18, readFileSync as readFileSync26, writeFileSync as writeFileSync20 } from "fs";
-import { dirname as dirname12, join as join31 } from "path";
+import { dirname as dirname13, join as join31 } from "path";
 function machineIdPathFor(stateDir) {
   return join31(stateDir, "machine-id");
 }
@@ -12709,7 +12744,7 @@ var sha256 = (s) => createHash7("sha256").update(s).digest("hex");
 function readRawMachineId(platform2 = process.platform) {
   try {
     if (platform2 === "darwin") {
-      const out = execFileSync7("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], {
+      const out = execFileSync8("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], {
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"]
       });
@@ -12735,7 +12770,7 @@ function ensureMachineId(stateDir, opts = {}) {
   const raw = (opts.read ?? readRawMachineId)();
   if (!raw) return void 0;
   const hashed = sha256(raw);
-  mkdirSync18(dirname12(path), { recursive: true });
+  mkdirSync18(dirname13(path), { recursive: true });
   writeFileSync20(path, `${hashed}
 `, { mode: 384 });
   return hashed;
@@ -14931,7 +14966,7 @@ async function resolveOne(tracker, t, seat, approvedStatus, buildingStatus, affi
 
 // src/repo-refresh.ts
 import { existsSync as existsSync31, mkdirSync as mkdirSync20, readFileSync as readFileSync29, writeFileSync as writeFileSync24 } from "fs";
-import { dirname as dirname14 } from "path";
+import { dirname as dirname15 } from "path";
 var REFRESH_COOLDOWN_MS = 2 * 6e4;
 var UNSERVABLE_PASSES_BEFORE_ATTENTION = 3;
 var lastAsked = /* @__PURE__ */ new Map();
@@ -14963,7 +14998,7 @@ function persistRepoRows(stateDir, routeName, rows) {
   if (!existsSync31(path)) return;
   const raw = JSON.parse(readFileSync29(path, "utf8"));
   applyRepoRows(raw, rows);
-  mkdirSync20(dirname14(path), { recursive: true });
+  mkdirSync20(dirname15(path), { recursive: true });
   writeFileSync24(path, `${JSON.stringify(raw, null, 2)}
 `);
 }
@@ -15414,7 +15449,7 @@ Ship ${shipName2} found: ${problem}. The release refuses to squash a ref nobody
 var localRefSkipReported = (ticket, problem, events) => events.some((e) => e.record_id === ticket.id && e.event_type === "local_ref_skip" && (e.message ?? "").includes(problem));
 
 // src/connect-wizard.ts
-import { delimiter, dirname as dirname15, join as join35 } from "path";
+import { delimiter, dirname as dirname16, join as join35 } from "path";
 import { accessSync as accessSync3, constants as constants3, existsSync as existsSync32, mkdirSync as mkdirSync21, writeFileSync as writeFileSync25 } from "fs";
 import { stringify as stringify2 } from "yaml";
 var HOST_PASSENGERS_DOCS_URL = "https://crew.tablation.dev/host-passengers";
@@ -15463,9 +15498,9 @@ async function runWizard(p, env) {
     if (entered && isExec(entered)) agentBin = entered;
     else p.say(entered ? `${entered} is not an executable file.` : "A path is required.");
   }
-  const nodeDir = dirname15(env.nodePath);
+  const nodeDir = dirname16(env.nodePath);
   const pnpmPath = findOnPath2("pnpm", env.pathEnv, isExec);
-  const baseDirs = [nodeDir, pnpmPath ? dirname15(pnpmPath) : void 0];
+  const baseDirs = [nodeDir, pnpmPath ? dirname16(pnpmPath) : void 0];
   p.say(
     `
 Host Passengers lets this machine run the agent sessions that other people's
@@ -15476,7 +15511,7 @@ Tablation workspaces ask for, in a container. More: ${HOST_PASSENGERS_DOCS_URL}`
     p.say("Docker is not available here, so nothing will be hosted until it is. Your answer is recorded anyway.");
   }
   const dockerPath = hostPassengers ? findOnPath2("docker", env.pathEnv, isExec) : void 0;
-  const extraPath = deriveExtraPath([...baseDirs, dockerPath ? dirname15(dockerPath) : void 0]);
+  const extraPath = deriveExtraPath([...baseDirs, dockerPath ? dirname16(dockerPath) : void 0]);
   if (extraPath) {
     p.say(`Hooks will get ${extraPath} on their PATH (where node, pnpm${dockerPath ? " and docker" : ""} live).`);
   }
@@ -15498,7 +15533,7 @@ routes:
 ${routeBlock}`;
 }
 function writeNewConfig(path, text2) {
-  mkdirSync21(dirname15(path), { recursive: true });
+  mkdirSync21(dirname16(path), { recursive: true });
   try {
     writeFileSync25(path, text2, { mode: 384, flag: "wx" });
     return true;
@@ -15534,7 +15569,7 @@ Wrote ${o.configPath}.
 // src/connect-json.ts
 import { accessSync as accessSync4, constants as constants4 } from "fs";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname16, join as join36 } from "path";
+import { dirname as dirname17, join as join36 } from "path";
 import { delimiter as delimiter2 } from "path";
 var CHOICE_EXIT_CODE = 3;
 function createEmitter(json2, write) {
@@ -15600,7 +15635,7 @@ function flagWizardAnswers(f, env) {
   const agentBin = f.agentBin ?? found?.bin;
   const pnpmPath = findOnPath2("pnpm", env.pathEnv, isExec);
   const dockerPath = f.hostPassengers ? findOnPath2("docker", env.pathEnv, isExec) : void 0;
-  const extraPath = f.extraPath ?? deriveExtraPath([dirname16(env.nodePath), pnpmPath ? dirname16(pnpmPath) : void 0, dockerPath ? dirname16(dockerPath) : void 0]);
+  const extraPath = f.extraPath ?? deriveExtraPath([dirname17(env.nodePath), pnpmPath ? dirname17(pnpmPath) : void 0, dockerPath ? dirname17(dockerPath) : void 0]);
   return {
     answers: {
       name: f.shipName?.trim() || env.hostname,
@@ -15615,7 +15650,7 @@ function flagWizardAnswers(f, env) {
 
 // src/release-run.ts
 import { readFileSync as readFileSync30, writeFileSync as writeFileSync26, existsSync as existsSync33, copyFileSync, mkdirSync as mkdirSync22, mkdtempSync as mkdtempSync3, rmSync as rmSync17 } from "fs";
-import { dirname as dirname17, join as join37 } from "path";
+import { dirname as dirname18, join as join37 } from "path";
 import { tmpdir as tmpdir5 } from "os";
 
 // src/release.ts
@@ -16501,7 +16536,7 @@ function openReleaseCheckout(o) {
   for (const f of o.repo.worktrees.copy) {
     const src = join37(o.cwd, f);
     if (!existsSync33(src)) continue;
-    mkdirSync22(dirname17(join37(dir, f)), { recursive: true });
+    mkdirSync22(dirname18(join37(dir, f)), { recursive: true });
     copyFileSync(src, join37(dir, f));
   }
   return { dir, branch, close };
@@ -17821,7 +17856,7 @@ function nextRoles(decision, ran) {
 
 // src/ship-name.ts
 import { existsSync as existsSync35, mkdirSync as mkdirSync23, readFileSync as readFileSync31, renameSync as renameSync5, writeFileSync as writeFileSync27 } from "fs";
-import { dirname as dirname18 } from "path";
+import { dirname as dirname19 } from "path";
 import { parseDocument as parseDocument5 } from "yaml";
 var ShipNameError = class extends Error {
 };
@@ -17900,7 +17935,7 @@ function writeSyncedName(resolvedFile, name) {
   }
   if (raw.shipName === name) return;
   raw.shipName = name;
-  mkdirSync23(dirname18(resolvedFile), { recursive: true });
+  mkdirSync23(dirname19(resolvedFile), { recursive: true });
   const tmp = `${resolvedFile}.tmp${process.pid}`;
   writeFileSync27(tmp, `${JSON.stringify(raw, null, 2)}
 `);
@@ -18594,7 +18629,7 @@ function describeCapability(i) {
 
 // src/agents-sync-run.ts
 import { existsSync as existsSync36, mkdirSync as mkdirSync24, readFileSync as readFileSync32, writeFileSync as writeFileSync28 } from "fs";
-import { dirname as dirname19 } from "path";
+import { dirname as dirname20 } from "path";
 async function runAgentsSync(target, o) {
   const dryRun = o.dryRun ?? false;
   const force = o.force ?? false;
@@ -18631,7 +18666,7 @@ async function runAgentsSync(target, o) {
     raw.agentPersonas = personaResult.agentPersonas;
     if (skillResult) raw.agentSkills = skillResult.agentSkills;
     if (personaResult.releaseAgentId) raw.releaseAgentId = personaResult.releaseAgentId;
-    mkdirSync24(dirname19(resolvedPath), { recursive: true });
+    mkdirSync24(dirname20(resolvedPath), { recursive: true });
     writeFileSync28(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
     if (target.resolved) {
@@ -19052,7 +19087,7 @@ function existingRepoConfig(f) {
 }
 
 // src/repos-hooks-agent.ts
-import { spawn as spawn7, execFileSync as execFileSync8 } from "child_process";
+import { spawn as spawn7, execFileSync as execFileSync9 } from "child_process";
 import { realpathSync as realpathSync2 } from "fs";
 import { isAbsolute as isAbsolute2, relative } from "path";
 var AgentSuggestError = class extends Error {
@@ -19155,7 +19190,7 @@ function classifyFailure(o) {
 }
 function porcelain(dir) {
   try {
-    return execFileSync8("git", ["status", "--porcelain", "--untracked-files=all"], { cwd: dir, encoding: "utf8" });
+    return execFileSync9("git", ["status", "--porcelain", "--untracked-files=all"], { cwd: dir, encoding: "utf8" });
   } catch {
     return void 0;
   }
@@ -19224,7 +19259,7 @@ ${run3.err}` });
 }
 
 // src/sample-ticket.ts
-import { basename as basename11, dirname as dirname20, join as join38 } from "path";
+import { basename as basename11, dirname as dirname21, join as join38 } from "path";
 var SAMPLE_REPO = "crew-sample";
 var SAMPLE_REMOTE = `local/${SAMPLE_REPO}`;
 var SAMPLE_MARKER = "sample: true";
@@ -19247,7 +19282,7 @@ has something safe to work on: its test and build hooks always pass, it has no
 remote, and \`crew sample-ticket --remove\` deletes it.
 `;
 function sampleDir(existing, reposBase, workspace) {
-  if (existing.length > 0) return join38(dirname20(existing[0]), SAMPLE_REPO);
+  if (existing.length > 0) return join38(dirname21(existing[0]), SAMPLE_REPO);
   return join38(reposBase, workspace, SAMPLE_REPO);
 }
 var SAMPLE_TITLE = "Sample: add a documented `greet` function with a test";
@@ -19293,7 +19328,7 @@ function planSampleTicket(i) {
 
 // src/worktree-sweep.ts
 import { existsSync as existsSync37, readFileSync as readFileSync34, readdirSync as readdirSync14 } from "fs";
-import { basename as basename12, dirname as dirname21, join as join39, resolve as resolve4 } from "path";
+import { basename as basename12, dirname as dirname22, join as join39, resolve as resolve4 } from "path";
 function planWorktreeSweep(target, tickets, contract) {
   const terminal = new Set(contract.statuses.resolved.filter((s) => s !== contract.statuses.verified));
   const verified = contract.statuses.verified;
@@ -19357,7 +19392,7 @@ function worktreeTicketNumbers(target) {
   return [...nums];
 }
 function siblingWorktreeDirs(target) {
-  const parent = dirname21(target.dir.replace(/[/\\]+$/, ""));
+  const parent = dirname22(target.dir.replace(/[/\\]+$/, ""));
   const stem = `${basename12(target.dir.replace(/[/\\]+$/, ""))}-`;
   const registered = new Set(worktrees(target.dir).map((w) => resolve4(w.path)));
   let names;
@@ -20050,14 +20085,14 @@ ${tail2(preview.output)}`);
 }
 
 // src/periscope-idle.ts
-import { execFileSync as execFileSync9 } from "child_process";
+import { execFileSync as execFileSync10 } from "child_process";
 import { statSync as statSync11 } from "fs";
 import { join as join42 } from "path";
 var MAX_SCANNED_FILES = 2e4;
 function newestWorktreeMtime(root) {
   let listing;
   try {
-    listing = execFileSync9("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+    listing = execFileSync10("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
       cwd: root,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
@@ -20147,9 +20182,9 @@ async function runPeriscopeIdlePass(d) {
 import { dirname as dirOf2, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
-import { execFileSync as execFileSync10 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 import { existsSync as existsSync40, mkdirSync as mkdirSync26, readFileSync as readFileSync36, chmodSync as chmodSync3 } from "fs";
-import { dirname as dirname22, join as join43 } from "path";
+import { dirname as dirname23, join as join43 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
@@ -20159,9 +20194,9 @@ function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
   const publicKeyPath = `${privateKeyPath}.pub`;
   if (!existsSync40(privateKeyPath)) {
-    mkdirSync26(dirname22(privateKeyPath), { recursive: true });
+    mkdirSync26(dirname23(privateKeyPath), { recursive: true });
     try {
-      execFileSync10("ssh-keygen", [
+      execFileSync11("ssh-keygen", [
         "-t",
         "ed25519",
         "-N",
@@ -20187,7 +20222,7 @@ function ensureShipSshKeypair(stateDir) {
 }
 function sshKeygenAvailable() {
   try {
-    execFileSync10("ssh-keygen", ["-V"], { stdio: ["ignore", "ignore", "ignore"] });
+    execFileSync11("ssh-keygen", ["-V"], { stdio: ["ignore", "ignore", "ignore"] });
     return true;
   } catch (e) {
     return e.code !== "ENOENT";
@@ -21257,7 +21292,7 @@ import {
 } from "fs";
 import { createConnection } from "net";
 import { createServer } from "http";
-import { basename as basename13, dirname as dirname23, join as join46 } from "path";
+import { basename as basename13, dirname as dirname24, join as join46 } from "path";
 import { execFile as execFile3, spawn as spawn10 } from "child_process";
 
 // src/periscope-control.ts
@@ -21573,7 +21608,7 @@ function candidates(live, rotated) {
   const out = [live];
   if (!rotated) return out;
   try {
-    for (const n of readdirSync18(dirname23(live))) if (ROTATED_EVENTS_RE.test(n)) out.push(join46(dirname23(live), n));
+    for (const n of readdirSync18(dirname24(live))) if (ROTATED_EVENTS_RE.test(n)) out.push(join46(dirname24(live), n));
   } catch {
   }
   return out;
@@ -21733,7 +21768,7 @@ async function tailReply(path, q2, rotated, abort) {
   const deadline = Date.now() + Math.min(wait, MAX_WAIT_SECONDS) * 1e3;
   let r = readTail(path, { after, tail: tail3, rotated });
   while (after && !r.lines.length && !r.reset && Date.now() < deadline && !abort.aborted) {
-    await waitForChange(dirname23(path), deadline - Date.now(), abort);
+    await waitForChange(dirname24(path), deadline - Date.now(), abort);
     r = readTail(path, { after: r.cursor, rotated });
   }
   return reply2(200, r);
@@ -21923,7 +21958,7 @@ function crewJson(args, timeoutMs = 6e4) {
 
 // src/periscope-mcp.ts
 import { lstat, mkdir, readdir, readFile, readlink, realpath, rm, stat, writeFile } from "fs/promises";
-import { basename as basename14, dirname as dirname24, isAbsolute as isAbsolute3, join as join48, relative as relative2, resolve as resolve5, sep } from "path";
+import { basename as basename14, dirname as dirname25, isAbsolute as isAbsolute3, join as join48, relative as relative2, resolve as resolve5, sep } from "path";
 import { z } from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -22061,10 +22096,10 @@ async function realAncestor(p) {
     }
     if (isLink) {
       if (++hops > 40) throw new PathRefusal(`too many symbolic links resolving ${p}`);
-      cur = resolve5(dirname24(cur), await readlink(cur));
+      cur = resolve5(dirname25(cur), await readlink(cur));
       continue;
     }
-    const parent = dirname24(cur);
+    const parent = dirname25(cur);
     if (parent === cur) throw new PathRefusal(`cannot resolve ${p}`);
     tail3.push(basename14(cur));
     cur = parent;
@@ -22087,7 +22122,7 @@ async function resolveInWorktree(root, requested) {
   if (relative2(realRoot, final).split(sep).includes(".git")) throw new PathRefusal(".git is not reachable from a periscope");
   return final;
 }
-function globToRegExp(glob) {
+function globToRegExp2(glob) {
   let re = "";
   for (let i = 0; i < glob.length; i++) {
     const c = glob[i];
@@ -22161,7 +22196,7 @@ function createPeriscopeMcpServer(d, sc) {
     inputSchema: { pattern: z.string() },
     annotations: { readOnlyHint: true, openWorldHint: false }
   }, async ({ pattern }) => {
-    const re = globToRegExp(pattern);
+    const re = globToRegExp2(pattern);
     const listing = git(root, ["ls-files", "-z", "--cached", "--others", "--exclude-standard"]);
     const hits = listing.split("\0").filter((f) => f && re.test(f)).slice(0, MAX_SEARCH_RESULTS);
     return text(hits.length ? hits.join("\n") : "No matches found");
@@ -22175,7 +22210,7 @@ function createPeriscopeMcpServer(d, sc) {
     if (Buffer.byteLength(content) > MAX_WRITE_BYTES) return text(`content exceeds ${MAX_WRITE_BYTES} bytes`, true);
     const abs = await inTree(path);
     if (abs === await realpath(root)) return text("path must name a file", true);
-    await mkdir(dirname24(abs), { recursive: true });
+    await mkdir(dirname25(abs), { recursive: true });
     await inTree(path);
     await writeFile(abs, content);
     return text(`Wrote ${Buffer.byteLength(content)} bytes to ${await rel(abs)}`);
@@ -22215,7 +22250,7 @@ function createPeriscopeMcpServer(d, sc) {
     inputSchema: { path: z.string() },
     annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false }
   }, async ({ path }) => {
-    const parent = await inTree(dirname24(path) === "" ? "." : dirname24(path));
+    const parent = await inTree(dirname25(path) === "" ? "." : dirname25(path));
     const abs = join48(parent, basename14(path));
     if (basename14(path) === ".git" || abs === parent) return text("path must name a file", true);
     const st = await lstat(abs).catch(() => void 0);
@@ -22337,7 +22372,7 @@ function findPeriscope(sidecars, segment) {
 }
 
 // src/cli.ts
-var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname25(process.execPath) : resolve6(dirname25(fileURLToPath(import.meta.url)), "..");
+var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname26(process.execPath) : resolve6(dirname26(fileURLToPath(import.meta.url)), "..");
 var RELEASE_LOCK_TTL_MS = 20 * 60 * 1e3;
 var CYCLE_SECONDS2 = 120;
 var STALE_CYCLES = 3;
@@ -23325,7 +23360,14 @@ ${changed2.map((c) => `  - ${c}
     const out = /* @__PURE__ */ new Map();
     for (const c of routes) {
       const { settled } = await settleRepos(reposOf(c), (t) => t.name, (t) => resolveOneRepo(c, t));
-      for (const r of settled) if (r.config.sandbox && !out.has(r.name)) out.set(r.name, { name: r.name, decl: r.config.sandbox });
+      for (const r of settled) if (r.config.sandbox && !out.has(r.name)) {
+        let warm = {};
+        try {
+          warm = readWarmFiles(r.dir, `${r.config.branch.remote}/${r.config.branch.base}`, r.config.sandbox.warm ?? []);
+        } catch {
+        }
+        out.set(r.name, { name: r.name, decl: r.config.sandbox, warm });
+      }
     }
     return [...out.values()];
   }
@@ -24818,7 +24860,7 @@ ${cu.tail.trimEnd()}
           const found = cfg.routes.find((r) => r.route === routeArg);
           if (!found) throw new ReposError(`no route "${routeArg}" in the config (have: ${cfg.routes.map((r) => r.route).join(", ") || "none"})`);
           const named2 = value("route") ? void 0 : positional[3];
-          const dir = named2 ? repoDirOf(configText, dirname25(cfg.configFile), found.route, named2) : resolvePath(positional[value("route") ? 2 : 3] ?? ".");
+          const dir = named2 ? repoDirOf(configText, dirname26(cfg.configFile), found.route, named2) : resolvePath(positional[value("route") ? 2 : 3] ?? ".");
           const target = reposOf(found).find((t) => resolvePath(t.dir) === dir || t.name === named2);
           const o = target ? found.repoOverrides[target.name] : void 0;
           runReposCheck(dir, {
@@ -24841,7 +24883,7 @@ ${cu.tail.trimEnd()}
       if (sub === "hooks") {
         try {
           const a = parseHooksArgs(positional.slice(2), routeNamesOf(configText));
-          const dir = repoDirOf(configText, dirname25(cfg.configFile), a.route, a.name);
+          const dir = repoDirOf(configText, dirname26(cfg.configFile), a.route, a.name);
           if (!existsSync45(dir)) throw new ReposError(`${dir} does not exist on disk`);
           const files = { exists: (r) => existsSync45(resolvePath(dir, r)), list: (r) => {
             try {
@@ -25008,7 +25050,7 @@ ${cu.tail.trimEnd()}
       }
       const originOf = (dir) => gitOk(dir, ["remote", "get-url", "origin"]) ?? void 0;
       const text2 = configText;
-      const base = dirname25(cfg.configFile);
+      const base = dirname26(cfg.configFile);
       const isCheckout = (d) => existsSync45(`${d}/.git`);
       try {
         if (sub === "list") {
@@ -25684,7 +25726,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           process.stderr.write(`(dry run) would write resolved ids to ${resolvedPath}
 `);
         } else {
-          mkdirSync30(dirname25(resolvedPath), { recursive: true });
+          mkdirSync30(dirname26(resolvedPath), { recursive: true });
           if (hadPreviousFile) copyFileSync2(resolvedPath, `${resolvedPath}.bak`);
           const tmpPath = `${resolvedPath}.tmp${process.pid}`;
           writeFileSync33(tmpPath, `${JSON.stringify(resolved, null, 2)}
@@ -25733,7 +25775,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             process.stderr.write(`(dry run) would write the minted API key to ${apiKeyFile}
 `);
           } else {
-            mkdirSync30(dirname25(apiKeyFile), { recursive: true });
+            mkdirSync30(dirname26(apiKeyFile), { recursive: true });
             writeFileSync33(apiKeyFile, `${apiKeyVar}=${apiKey}
 `, { mode: 384 });
             process.stderr.write(`API key written to ${apiKeyFile}
@@ -26304,7 +26346,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       if (subS === "images") {
         const stateS = readSandboxState(cfg.ship.stateDir);
         const rows = declared.map((r) => {
-          const plan = planSandbox(r.name, r.decl);
+          const plan = planSandbox(r.name, r.decl, r.warm);
           return { repo: r.name, wants: plan.tag, tags: stateS[r.name]?.tags ?? [], ...sandboxImageStatus(stateS, plan) };
         });
         if (jsonS) {
@@ -26338,7 +26380,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       for (const t of targets) {
         await sandboxBuildTick([t], depsS, true);
         const after = readSandboxState(cfg.ship.stateDir);
-        const st = sandboxImageStatus(after, planSandbox(t.name, t.decl));
+        const st = sandboxImageStatus(after, planSandbox(t.name, t.decl, t.warm));
         if (st.status === "failed") failed = true;
         process.stdout.write(`${t.name}: ${st.status} \u2014 ${st.detail}
 `);
@@ -27057,7 +27099,7 @@ ${where.join("\n")}`);
       if (!route2.resolved) fail(`route ${route2.route} is not connected \u2014 run \`crew connect\` first`);
       const tracker = new Tracker(route2, cfg.ship);
       const configText = readFileSync40(cfg.configFile, "utf8");
-      const cfgBase = dirname25(cfg.configFile);
+      const cfgBase = dirname26(cfg.configFile);
       const configured2 = configuredRepos(configText, route2.route, cfgBase);
       const dir = configured2.find((r) => r.name === SAMPLE_REPO)?.dir ?? sampleDir(configured2.map((r) => r.dir), route2.reposBasePath, route2.route.split("/")[0]);
       const resolvedFile = resolvedPathFor(cfg.ship.stateDir, route2.route);
@@ -28076,7 +28118,7 @@ ${foreign.join("\n")}
         const declaredS = await sandboxReposOf(cfg.routes.filter((r) => r.enabled));
         const stateS = readSandboxState(cfg.ship.stateDir);
         for (const r of declaredS) {
-          const st = sandboxImageStatus(stateS, planSandbox(r.name, r.decl));
+          const st = sandboxImageStatus(stateS, planSandbox(r.name, r.decl, r.warm));
           process.stdout.write(`sandbox image:    ${r.name}: ${st.status.toUpperCase()} \u2014 ${st.detail}
 `);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.106.0",
+  "version": "0.107.0",
   "description": "A standing team of headless agents that picks work off a Tablation board, does it on a machine you control, and reports back.",
   "type": "module",
   "license": "MIT",