claude-code-session-manager 0.39.3 → 0.40.0

package/src/main/lib/queueStore.cjs

@@ -0,0 +1,299 @@
+/**
+ * queueStore.cjs — federated scheduler state (2026-07-31 domain-model
+ * decision: "retire the global-aware scheduler").
+ *
+ * The old system of record was one global
+ * `~/.claude/session-manager/scheduled-plans/queue.json`. It is retired.
+ * State now lives where it belongs in the TAB → EPIC → PRD hierarchy:
+ *
+ *   - Per-project job rows:   `<cwd>/session-manager-operations/scheduler/state/queue.json`
+ *     ({ jobs: [...] } — only that project's jobs)
+ *   - Per-project history:    `<cwd>/session-manager-operations/scheduler/state/history.jsonl`
+ *     (owned by queueHistory.cjs, path resolved here)
+ *   - Machine runtime state:  `~/.claude/session-manager/scheduler-machine.json`
+ *     (config, paused/rate-limit, scheduledFor, lastRunAt — these are
+ *     Session-Manager runtime concerns, like the sessionSlots pool, not any
+ *     one project's data. Run logs under scheduled-plans/runs/ stay
+ *     machine-local for the same reason: they're execution artifacts of this
+ *     machine's runner.)
+ *
+ * scheduler.cjs's 4k lines keep operating on ONE merged in-memory state
+ * object (jobs across all projects + machine fields); this module is the
+ * read-merge / write-split shim underneath readQueue/writeQueue. Jobs are
+ * split by `job.cwd` (fallback: the provided defaultCwd).
+ *
+ * Plain Node (no Electron deps) so watchdog scripts can require it; atomic
+ * writes are tmp+rename here rather than config.cjs's writeJson because
+ * config.cjs requires electron/chokidar and this must load outside the app.
+ */
+'use strict';
+
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+const { allProjectCwds, activeProjectCwds } = require('../../../scripts/lib/activeSessions.cjs');
+
+const MACHINE_STATE_PATH = path.join(os.homedir(), '.claude', 'session-manager', 'scheduler-machine.json');
+const LEGACY_QUEUE_PATH = path.join(os.homedir(), '.claude', 'session-manager', 'scheduled-plans', 'queue.json');
+const STATE_SUBPATH = ['session-manager-operations', 'scheduler', 'state'];
+
+function projectStateDir(cwd) {
+  if (!cwd || typeof cwd !== 'string') throw new Error('projectStateDir: cwd is required');
+  return path.join(cwd, ...STATE_SUBPATH);
+}
+
+function projectQueuePath(cwd) {
+  return path.join(projectStateDir(cwd), 'queue.json');
+}
+
+function projectHistoryPath(cwd) {
+  return path.join(projectStateDir(cwd), 'history.jsonl');
+}
+
+function writeJsonAtomicSync(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}`;
+  fs.writeFileSync(tmp, JSON.stringify(value, null, 2));
+  fs.renameSync(tmp, file);
+}
+
+async function writeJsonAtomic(file, value) {
+  await fsp.mkdir(path.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}`;
+  await fsp.writeFile(tmp, JSON.stringify(value, null, 2));
+  await fsp.rename(tmp, file);
+}
+
+// ---------- project-cwd enumeration (cached) ----------
+
+// allProjectCwds scans ~/.claude/projects; on the readQueue hot path (every
+// IPC status call) that's too much stat traffic, so cache the resolved cwd
+// list briefly. Correctness fallback: a brand-new project appears at worst
+// CACHE_MS late, and its first write goes through writeSplit which busts the
+// cache.
+const CACHE_MS = 30_000;
+let cwdCache = { at: 0, cwds: [] };
+
+function stateCwds(opts) {
+  const now = Date.now();
+  if (!opts && now - cwdCache.at < CACHE_MS) return cwdCache.cwds;
+  const seen = new Set();
+  const cwds = [];
+  const add = (cwd) => { if (cwd && !seen.has(cwd)) { seen.add(cwd); cwds.push(cwd); } };
+  // Projects that already have a state file are authoritative sources...
+  for (const cwd of allProjectCwds(opts)) {
+    try { if (fs.existsSync(projectQueuePath(cwd))) add(cwd); } catch { /* skip */ }
+  }
+  // ...and active projects are included even before their first write.
+  for (const cwd of activeProjectCwds(undefined, opts)) add(cwd);
+  if (!opts) cwdCache = { at: now, cwds };
+  return cwds;
+}
+
+function bustCwdCache() {
+  cwdCache = { at: 0, cwds: [] };
+}
+
+// ---------- merged read ----------
+
+function shapeMachine(raw) {
+  const data = raw ? JSON.parse(raw) : {};
+  return {
+    config: data.config || {},
+    scheduledFor: data.scheduledFor ?? null,
+    lastRunAt: data.lastRunAt ?? null,
+    paused: data.paused ?? null,
+  };
+}
+
+function shapeJobs(raw) {
+  const data = JSON.parse(raw);
+  return Array.isArray(data.jobs) ? data.jobs : [];
+}
+
+/**
+ * readMergedSync(opts?) → { config, jobs, scheduledFor, lastRunAt, paused,
+ * unreadable?, unreadablePath?, sourceCwds }.
+ *
+ * `unreadable` mirrors the old single-file semantics: ANY source file that
+ * exists but fails to parse halts scheduling (never treat a project's queue
+ * as empty because it read corrupt). `sourceCwds` records every project file
+ * consulted so writeSplit can persist "this project now has zero jobs".
+ */
+function readMergedSync(opts) {
+  const out = { config: {}, jobs: [], scheduledFor: null, lastRunAt: null, paused: null };
+  const sourceCwds = [];
+  try {
+    Object.assign(out, shapeMachine(fs.readFileSync(MACHINE_STATE_PATH, 'utf8')));
+  } catch (e) {
+    if (e?.code !== 'ENOENT') {
+      out.unreadable = `machine state unreadable: ${e?.message}`;
+      out.unreadablePath = MACHINE_STATE_PATH;
+    }
+  }
+  for (const cwd of stateCwds(opts)) {
+    const file = projectQueuePath(cwd);
+    try {
+      out.jobs.push(...shapeJobs(fs.readFileSync(file, 'utf8')));
+      sourceCwds.push(cwd);
+    } catch (e) {
+      if (e?.code === 'ENOENT') { sourceCwds.push(cwd); continue; }
+      out.unreadable = out.unreadable || `project queue unreadable (${file}): ${e?.message}`;
+      out.unreadablePath = out.unreadablePath || file;
+    }
+  }
+  defineSources(out, sourceCwds);
+  return out;
+}
+
+/** Async twin of readMergedSync for IPC hot paths. */
+async function readMerged(opts) {
+  const out = { config: {}, jobs: [], scheduledFor: null, lastRunAt: null, paused: null };
+  const sourceCwds = [];
+  try {
+    Object.assign(out, shapeMachine(await fsp.readFile(MACHINE_STATE_PATH, 'utf8')));
+  } catch (e) {
+    if (e?.code !== 'ENOENT') {
+      out.unreadable = `machine state unreadable: ${e?.message}`;
+      out.unreadablePath = MACHINE_STATE_PATH;
+    }
+  }
+  for (const cwd of stateCwds(opts)) {
+    const file = projectQueuePath(cwd);
+    try {
+      out.jobs.push(...shapeJobs(await fsp.readFile(file, 'utf8')));
+      sourceCwds.push(cwd);
+    } catch (e) {
+      if (e?.code === 'ENOENT') { sourceCwds.push(cwd); continue; }
+      out.unreadable = out.unreadable || `project queue unreadable (${file}): ${e?.message}`;
+      out.unreadablePath = out.unreadablePath || file;
+    }
+  }
+  defineSources(out, sourceCwds);
+  return out;
+}
+
+// Non-enumerable so broadcast/JSON payloads of the state never carry it.
+function defineSources(state, sourceCwds) {
+  Object.defineProperty(state, 'sourceCwds', {
+    value: sourceCwds, enumerable: false, configurable: true, writable: true,
+  });
+}
+
+// ---------- split write ----------
+
+/**
+ * writeSplit(state, defaultCwd) — persist a merged state back to its shards:
+ * machine fields → MACHINE_STATE_PATH; jobs grouped by job.cwd (fallback
+ * defaultCwd) → each project's state/queue.json. Every cwd the read consulted
+ * (state.sourceCwds) is written even when it now holds zero jobs, so
+ * deletions stick.
+ */
+async function writeSplit(state, defaultCwd) {
+  await writeJsonAtomic(MACHINE_STATE_PATH, {
+    config: state.config,
+    scheduledFor: state.scheduledFor ?? null,
+    lastRunAt: state.lastRunAt ?? null,
+    paused: state.paused ?? null,
+  });
+
+  const byCwd = new Map();
+  for (const cwd of state.sourceCwds ?? []) byCwd.set(cwd, []);
+  for (const job of state.jobs ?? []) {
+    const cwd = job.cwd || defaultCwd;
+    if (!cwd) continue; // nowhere to put it; job is dropped from persistence rather than crashing
+    if (!byCwd.has(cwd)) byCwd.set(cwd, []);
+    byCwd.get(cwd).push(job);
+  }
+  for (const [cwd, jobs] of byCwd) {
+    try {
+      await writeJsonAtomic(projectQueuePath(cwd), { jobs });
+    } catch (e) {
+      // A single unwritable project (deleted repo dir, permissions) must not
+      // lose every other project's write.
+      console.error(`[queueStore] failed to write ${projectQueuePath(cwd)}: ${e?.message}`);
+    }
+  }
+  bustCwdCache();
+}
+
+// ---------- legacy migration ----------
+
+/**
+ * migrateLegacyGlobalQueue(defaultCwd) — one-time boot split of the retired
+ * global queue.json into per-project shards. Shard rows win over legacy rows
+ * with the same slug (the shard is newer by construction). The legacy file is
+ * renamed to `queue.json.retired-<epoch>` so a rollback can recover it but no
+ * reader ever consults it again. Machine fields (config/paused/...) migrate
+ * only when no machine file exists yet. Idempotent: no legacy file → no-op.
+ */
+async function migrateLegacyGlobalQueue(defaultCwd) {
+  let raw;
+  try {
+    raw = await fsp.readFile(LEGACY_QUEUE_PATH, 'utf8');
+  } catch {
+    return { migrated: false };
+  }
+  let legacy;
+  try {
+    legacy = JSON.parse(raw);
+  } catch (e) {
+    console.error(`[queueStore] legacy queue.json unparseable — leaving in place: ${e?.message}`);
+    return { migrated: false, error: e?.message };
+  }
+
+  if (!fs.existsSync(MACHINE_STATE_PATH)) {
+    await writeJsonAtomic(MACHINE_STATE_PATH, {
+      config: legacy.config || {},
+      scheduledFor: legacy.scheduledFor ?? null,
+      lastRunAt: legacy.lastRunAt ?? null,
+      paused: legacy.paused ?? null,
+    });
+  }
+
+  const legacyJobs = Array.isArray(legacy.jobs) ? legacy.jobs : [];
+  const byCwd = new Map();
+  for (const job of legacyJobs) {
+    const cwd = job.cwd || defaultCwd;
+    if (!cwd) continue;
+    if (!byCwd.has(cwd)) byCwd.set(cwd, []);
+    byCwd.get(cwd).push(job);
+  }
+  let moved = 0;
+  for (const [cwd, jobs] of byCwd) {
+    const file = projectQueuePath(cwd);
+    let existing = [];
+    try { existing = shapeJobs(await fsp.readFile(file, 'utf8')); } catch { /* fresh shard */ }
+    const have = new Set(existing.map((j) => j.slug));
+    const merged = [...existing, ...jobs.filter((j) => !have.has(j.slug))];
+    try {
+      await writeJsonAtomic(file, { jobs: merged });
+      moved += merged.length - existing.length;
+    } catch (e) {
+      console.error(`[queueStore] legacy split: failed to write ${file}: ${e?.message}`);
+      return { migrated: false, error: e?.message };
+    }
+  }
+
+  await fsp.rename(LEGACY_QUEUE_PATH, `${LEGACY_QUEUE_PATH}.retired-${Date.now()}`);
+  bustCwdCache();
+  return { migrated: true, moved, projects: byCwd.size };
+}
+
+module.exports = {
+  MACHINE_STATE_PATH,
+  LEGACY_QUEUE_PATH,
+  STATE_SUBPATH,
+  projectStateDir,
+  projectQueuePath,
+  projectHistoryPath,
+  stateCwds,
+  bustCwdCache,
+  readMerged,
+  readMergedSync,
+  writeSplit,
+  migrateLegacyGlobalQueue,
+  writeJsonAtomic,
+  writeJsonAtomicSync,
+};

package/src/main/lib/schedulerBatch.cjs

@@ -38,12 +38,44 @@ const DEFAULT_PROJECT_CWD = path.join(os.homedir(), 'Projects', 'session-manager
  *   human-readable reason text that would otherwise only reach console.log.
  */
 function pickForProject(projectJobs, runningSlugsInProject, slots) {
-  const pending = projectJobs.filter(
+  const projectCwd = (projectJobs.find((j) => j.cwd) || {}).cwd || DEFAULT_PROJECT_CWD;
+
+  // Explicit dependsOn eligibility (PRD 832). A dep slug is BLOCKING while a
+  // queue row for it exists in a non-completed state; a slug with no row is
+  // treated as already done (completed rows are retired to history shards,
+  // so absence is the normal end-state of a finished dep). A FAILED dep
+  // holds the dependent with an explicit reason, mirroring the failure gate.
+  // Legacy jobs without dependsOn keep the shared-NN group semantics below
+  // unchanged (lowest-number-first waves), so an in-flight mixed queue keeps
+  // its order without migration.
+  const rowBySlug = new Map(projectJobs.map((j) => [j.slug, j]));
+  const blockingDep = (j) => (j.dependsOn ?? []).find((slug) => {
+    const dep = rowBySlug.get(slug);
+    return dep && dep.status !== 'completed';
+  });
+
+  const allPending = projectJobs.filter(
     (j) => j.status === 'pending' && !runningSlugsInProject.has(j.slug),
   );
-  if (pending.length === 0) return { batch: [], reason: null };
-
-  const projectCwd = (projectJobs.find((j) => j.cwd) || {}).cwd || DEFAULT_PROJECT_CWD;
+  if (allPending.length === 0) return { batch: [], reason: null };
+
+  const pending = [];
+  const heldByFailedDep = [];
+  for (const j of allPending) {
+    const dep = blockingDep(j);
+    if (!dep) { pending.push(j); continue; }
+    if (rowBySlug.get(dep)?.status === 'failed') heldByFailedDep.push({ job: j, dep });
+    // running/pending/needs_review dep — simply not eligible this tick.
+  }
+  if (pending.length === 0) {
+    if (heldByFailedDep.length > 0) {
+      const detail = heldByFailedDep.map(({ job, dep }) => `${job.slug} <- ${dep}`).join(', ');
+      const reason = `[scheduler] depends-gate [${projectCwd}]: holding ${heldByFailedDep.length} job(s) behind failed dependencies [${detail}]. Reset or archive the dep to unblock.`;
+      console.log(reason);
+      return { batch: [], reason };
+    }
+    return { batch: [], reason: null };
+  }
 
   // Lowest pending group (computed up-front for the failure-gate check).
   const lowestPendingGroup = pending.reduce(

package/src/main/lib/sessionSlots.cjs

@@ -0,0 +1,85 @@
+/**
+ * sessionSlots.cjs — the Session-Manager-owned machine-wide `claude -p`
+ * concurrency pool (2026-07-31 domain-model decision).
+ *
+ * Caps and limits belong to Session-Manager, not to any one consumer: the
+ * scheduler and chatRunner previously each enforced a private cap (3 and 2),
+ * which combined could exceed the machine's real budget — the exact shape of
+ * the 2026-06-10 five-parallel-`claude -p` OOM. Now every subsystem that
+ * wants to launch a `claude -p` process REQUESTS a slot here first and
+ * releases it when the process settles. There is one pool, sized to the
+ * machine (default 3 — CLAUDE.md "Avoid" cap; SM_SESSION_SLOTS overrides,
+ * clamped to [1, 3]).
+ *
+ * Consumers keep their own scheduling policy (FIFO lanes, batch picking,
+ * memory gates); this module only answers "may one more process start right
+ * now?". Plain Node, no Electron deps, process-local state — all consumers
+ * live in the one Electron main process, which is exactly why it can be the
+ * arbiter.
+ */
+'use strict';
+
+const crypto = require('node:crypto');
+
+function totalSlots() {
+  const parsed = parseInt(process.env.SM_SESSION_SLOTS || '3', 10);
+  return Math.min(3, Math.max(1, Number.isFinite(parsed) ? parsed : 3));
+}
+
+// token → { owner, at }
+const holders = new Map();
+
+function inUse() {
+  return holders.size;
+}
+
+function available() {
+  return Math.max(0, totalSlots() - holders.size);
+}
+
+/**
+ * acquire(owner) → token string, or null when the pool is exhausted.
+ * `owner` is a diagnostic label ("scheduler:<slug>", "chat:<tabId>") shown in
+ * snapshot() so a stuck holder is attributable.
+ */
+function acquire(owner) {
+  if (holders.size >= totalSlots()) return null;
+  const token = crypto.randomUUID();
+  holders.set(token, { owner: String(owner || 'unknown'), at: new Date().toISOString() });
+  return token;
+}
+
+// Release listeners: each consumer registers its own "a slot freed — try to
+// start work" pump so a scheduler release wakes the chat lane and vice versa.
+const listeners = new Set();
+function subscribe(fn) {
+  listeners.add(fn);
+  return () => listeners.delete(fn);
+}
+
+/** release(token) — idempotent; releasing an unknown/already-released token is a no-op. */
+function release(token) {
+  const had = holders.delete(token);
+  if (had) {
+    for (const fn of listeners) {
+      try { fn(); } catch { /* a consumer's pump error is its own problem */ }
+    }
+  }
+  return had;
+}
+
+/** Diagnostic view for status surfaces and tests. */
+function snapshot() {
+  return {
+    total: totalSlots(),
+    inUse: holders.size,
+    holders: [...holders.values()],
+  };
+}
+
+/** Test hook: drop all held slots. */
+function __resetForTests() {
+  holders.clear();
+}
+
+module.exports = { totalSlots, inUse, available, acquire, release, subscribe, snapshot, __resetForTests };

package/src/main/pty.cjs

@@ -231,6 +231,14 @@ class PtyManager {
   killAll() {
     for (const tabId of [...this.sessions.keys()]) this.kill(tabId);
   }
+
+  /** Subset of `ids` that currently have a live PTY in the sessions map.
+   *  Lets the Epics workspace reconcile Terminal-mode attachment after a
+   *  renderer reload (the PTY survives; the renderer's in-memory attachment
+   *  record does not — PRD 833 C1). */
+  aliveOf(ids) {
+    return ids.filter((id) => this.sessions.has(id));
+  }
 }
 
 const manager = new PtyManager();
@@ -244,6 +252,7 @@ function registerPtyHandlers() {
     if (typeof tabId !== 'string') return;
     manager.kill(tabId);
   });
+  ipcMain.handle('pty:alive', v(s.ptyAlive, ({ tabIds }) => manager.aliveOf(tabIds)));
 }
 
 module.exports = { manager, registerPtyHandlers };

package/src/main/queueOps.cjs

@@ -307,6 +307,16 @@ async function archiveOne(slug, archiveDir) {
   }
 }
 
+/**
+ * Injected by index.cjs at registration time (see registerQueueOpsHandlers)
+ * so a manual archive can retire any still-runnable queue job for the same
+ * slug without queueOps.cjs importing scheduler.cjs (circular — scheduler.cjs
+ * already requires queueOps.cjs). No-op until set; the auto-archive path
+ * never needs it (selectAutoArchivable only ever selects already-completed
+ * jobs).
+ */
+let retireCompletedSlugsFn = async () => {};
+
 async function archiveMany(slugs) {
   if (!Array.isArray(slugs) || slugs.length === 0) {
     return { ok: true, archived: 0, archivedTo: null, results: [] };
@@ -324,6 +334,12 @@ async function archiveMany(slugs) {
     results.push(await archiveOne(slug, archiveDir));
   }
   const archived = results.filter((r) => r.ok).length;
+  const archivedSlugs = results.filter((r) => r.ok).map((r) => r.slug);
+  if (archivedSlugs.length > 0) {
+    await retireCompletedSlugsFn(archivedSlugs).catch((e) => {
+      logs.writeLine({ level: 'warn', scope: 'queueOps', message: 'archiveMany: retireCompletedSlugs failed', meta: { error: e?.message } });
+    });
+  }
   return { ok: true, archived, archivedTo: archiveDir, results };
 }
 
@@ -547,7 +563,10 @@ async function retagMany(items) {
 
 // ────────────────────────────────────────────── IPC registration
 
-function registerQueueOpsHandlers() {
+function registerQueueOpsHandlers({ retireCompletedSlugs } = {}) {
+  if (typeof retireCompletedSlugs === 'function') {
+    retireCompletedSlugsFn = retireCompletedSlugs;
+  }
   ipcMain.handle('schedule:lint-queue', async () => {
     return lintAll();
   });

package/src/main/scheduler/prdParser.cjs

@@ -18,6 +18,7 @@ const fsp = require('node:fs/promises');
 const os = require('node:os');
 const path = require('node:path');
 const { splitFrontmatter } = require('../lib/prdFrontmatter.cjs');
+const { deriveEpicIdFromPrdPath } = require('../lib/prdLocations.cjs');
 
 /**
  * Expand a PRD `cwd` value to an absolute path.
@@ -66,17 +67,37 @@ async function parsePrdRaw(filePath) {
     parallelGroup: (fm.parallelGroup ? Number(fm.parallelGroup) || null : null) ?? groupFromName ?? 99,
     // Optional traceability back to the PromptTicket.id (PRD 748) that was
     // classified 'develop' and spawned this PRD (PRD 749). Additive — absent
-    // on every PRD authored before this field existed.
-    sourcePromptId: fm.sourcePromptId || null,
+    // on every PRD authored before this field existed. When frontmatter
+    // omits it, fall back to the owning Epic dir name (PRD 830) — a PRD's
+    // file location already IS its Epic membership, so hand-authored PRDs
+    // dropped straight into an Epic's prds/ dir still get real linkage
+    // instead of null.
+    sourcePromptId: fm.sourcePromptId || deriveEpicIdFromPrdPath(filePath) || null,
     // Optional traceability back to the chat tab that queued this PRD (PRD
     // 761) — read back at job completion to route a status prompt via
     // enqueueExternalPrompt (PRD 753). Additive — absent on every PRD
     // authored before this field existed.
     sourceTabId: fm.sourceTabId || null,
+    // Explicit cross-PRD ordering (PRD 832): `dependsOn: [<slug>, <slug>]`
+    // or a comma-separated string. Replaces the retired shared-NN-means-
+    // parallel convention — a job is eligible only once every listed slug's
+    // queue row is completed (a slug with no row is treated as already
+    // done/archived, matching retireCompletedSlugs semantics).
+    dependsOn: parseDependsOn(fm.dependsOn),
     body: body.trim(),
   };
 }
 
+/** `[a, b]` / `a, b` / `a` → ['a','b']; anything else → []. */
+function parseDependsOn(raw) {
+  if (!raw || typeof raw !== 'string') return [];
+  const inner = raw.trim().replace(/^\[/, '').replace(/\]$/, '');
+  return inner
+    .split(',')
+    .map((s) => s.trim().replace(/^['"]|['"]$/g, ''))
+    .filter((s) => /^[A-Za-z0-9][\w.-]*$/.test(s));
+}
+
 /**
  * List `.md` PRD files under the given dir. Caches the result keyed by the
  * directory mtime so repeated reconcile() calls don't re-stat every entry.
@@ -257,11 +278,14 @@ async function maxParallelGroupInUse(prdsDir) {
  * number) and never wedges future callers, since each attempt only needs
  * the marker for its OWN candidate to not already exist.
  */
-async function allocateParallelGroup(prdsDir) {
+async function allocateParallelGroup(prdsDir, { extraFloor = 0 } = {}) {
   await fsp.mkdir(prdsDir, { recursive: true });
   const scanMax = await maxParallelGroupInUse(prdsDir);
   const highWater = await readHighWaterMark(prdsDir);
-  const floor = Math.max(scanMax, highWater);
+  // extraFloor (PRD 832): the caller's max across OTHER dirs sharing the
+  // project's number space (epic prds/ dirs, prds-archived) — numbers are
+  // unique per project, never merely per directory.
+  const floor = Math.max(scanMax, highWater, extraFloor);
   let candidate = floor + 1;
   for (let attempt = 0; attempt < MAX_RESERVE_ATTEMPTS; attempt += 1) {
     const markerPath = path.join(prdsDir, `.reserved-${candidate}`);