@brainervirus/workit-cli 8.38.4 → 8.39.0

package/dist/index.js

@@ -9317,7 +9317,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@brainervirus/workit-cli",
-    version: "8.38.4",
+    version: "8.39.0",
     private: false,
     description: "Workit CLI — setup wizard, doctor, and task control for agentic coding workflows",
     keywords: [
@@ -9355,13 +9355,13 @@ var init_package = __esm(() => {
     },
     dependencies: {
       "@babel/parser": "7.29.9",
-      "@brainervirus/workit-cursor": "^8.38.4",
+      "@brainervirus/workit-cursor": "^8.39.0",
       "@inkjs/ui": "2.0.0",
       ink: "7.1.1",
       react: "19.2.8"
     },
     devDependencies: {
-      "@brainervirus/workit-core": "^8.38.4"
+      "@brainervirus/workit-core": "^8.39.0"
     },
     engines: {
       node: ">=24"
@@ -77869,6 +77869,7 @@ function resolveResourceSettings(sources, host = hostShape()) {
   const settings = {
     slots: DEFAULT_SLOTS,
     heavy: [...DEFAULT_HEAVY_CHECKS],
+    light: [...DEFAULT_LIGHT_CHECKS],
     memoryMax: "",
     cpuQuota: "",
     waitMs: DEFAULT_WAIT_S * 1000,
@@ -77910,8 +77911,21 @@ function resolveResourceSettings(sources, host = hostShape()) {
       const heavy = isRecord9(value.heavy) ? Object.keys(value.heavy) : value.heavy;
       if (!Array.isArray(heavy) || !heavy.every((item) => typeof item === "string"))
         warn("heavy", "must be a list of check names");
-      else
+      else {
         settings.heavy = repo ? [...new Set([...settings.heavy, ...heavy])] : heavy;
+        settings.light = settings.light.filter((name) => !heavy.includes(name));
+      }
+    }
+    if (value.light !== undefined) {
+      const light = value.light;
+      if (repo)
+        machineOnly("light");
+      else if (!Array.isArray(light) || !light.every((item) => typeof item === "string"))
+        warn("light", "must be a list of check names");
+      else {
+        settings.light = light;
+        settings.heavy = settings.heavy.filter((name) => !light.includes(name));
+      }
     }
     if (value.memoryMax !== undefined) {
       const next = memoryValue(value.memoryMax, host);
@@ -77932,10 +77946,11 @@ function resolveResourceSettings(sources, host = hostShape()) {
         cpu = next;
     }
     if (value.wait !== undefined) {
-      if (typeof value.wait === "number" && value.wait >= 0)
-        settings.waitMs = value.wait * 1000;
+      const wait = typeof value.wait === "number" ? value.wait >= 0 ? value.wait * 1000 : null : typeof value.wait === "string" ? parseWait(value.wait) : null;
+      if (wait !== null)
+        settings.waitMs = wait;
       else
-        warn("wait", "must be a number of seconds");
+        warn("wait", 'must be a number of seconds or a duration ("30m")');
     }
   }
   settings.memoryMax = String(memory);
@@ -78053,7 +78068,65 @@ function removeOwn(file, id) {
   if (parseLease(readText5(file))?.id === id)
     fs24.rmSync(file, { force: true });
 }
+function leaseQueue(dir, probe = {}) {
+  let names;
+  try {
+    names = fs24.readdirSync(queueDir(dir));
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const name of names.filter((item) => item.endsWith(".json")).toSorted()) {
+    const file = path52.join(queueDir(dir), name);
+    const record = parseLease(readText5(file));
+    if (!record)
+      continue;
+    entries.push({
+      file,
+      holder: holderOf(record),
+      id: record.id,
+      stale: staleReason(record, probe)
+    });
+  }
+  return entries;
+}
+function waitersAhead(options, own) {
+  let ahead = 0;
+  for (const entry of leaseQueue(options.dir, options.probe)) {
+    if (path52.basename(entry.file) >= own)
+      break;
+    if (!TICKET.test(path52.basename(entry.file)))
+      continue;
+    if (entry.stale && reclaim(entry.file, (current) => !current || staleReason(current, options.probe) !== null))
+      continue;
+    ahead += 1;
+  }
+  return ahead;
+}
+function liveHolders(options) {
+  return leaseSlots(options.dir, options.slots, options.probe).filter((slot) => slot.holder && !slot.stale).map((slot) => slot.holder);
+}
+function writeTicket(file, record) {
+  fs24.mkdirSync(path52.dirname(file), { recursive: true, mode: 448 });
+  fs24.writeFileSync(file, `${JSON.stringify(record)}
+`, { mode: 384 });
+}
+function parseWait(text) {
+  const match = /^(\d+(?:\.\d+)?)([smh]?)$/u.exec(text.trim());
+  if (!match)
+    return null;
+  const unit = { "": 1000, s: 1000, m: 60000, h: 3600000 }[match[2]] ?? 1000;
+  return Math.round(Number(match[1]) * unit);
+}
+function formatWait(ms) {
+  const seconds = Math.max(0, Math.round(ms / 1000));
+  if (seconds < 60)
+    return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  return seconds % 60 ? `${minutes}m ${seconds % 60}s` : `${minutes}m`;
+}
 async function acquireLease(options) {
+  const clock = options.clock ?? realClock;
   const pid = options.pid ?? process.pid;
   const boot = bootId();
   const record = {
@@ -78067,7 +78140,7 @@ async function acquireLease(options) {
     check: options.check,
     cwd: options.cwd,
     session: options.session,
-    startedAt: new Date().toISOString(),
+    startedAt: new Date(clock.now()).toISOString(),
     scope: null
   };
   try {
@@ -78075,48 +78148,104 @@ async function acquireLease(options) {
   } catch (error) {
     return { ok: false, reason: "unavailable", error: error.message };
   }
-  const started = Date.now();
+  const started = clock.now();
   const reclaimed = [];
   let waitedOn = [];
-  for (;; ) {
-    let outcome;
-    try {
-      outcome = tryOnce(options, record, reclaimed);
-    } catch (error) {
-      return { ok: false, reason: "unavailable", error: error.message };
-    }
-    if ("slot" in outcome) {
-      const { file, slot } = outcome;
-      let released = false;
-      const release = () => {
-        if (released)
-          return;
-        released = true;
-        process.off("exit", release);
-        removeOwn(file, record.id);
-      };
-      process.on("exit", release);
-      return {
-        ok: true,
-        lease: {
-          record,
-          slot,
-          file,
-          waitedOn,
-          waitedMs: waitedOn.length ? Date.now() - started : 0,
-          reclaimed,
-          release
+  const name = ticketName(started, record.id);
+  const ticket = path52.join(queueDir(options.dir), name);
+  const ticketRecord = {
+    ...record,
+    maxAgeMs: options.waitMs + 60000
+  };
+  let queued = false;
+  const onSignal = (signal) => {
+    leave();
+    process.exit(signal === "SIGINT" ? 130 : 143);
+  };
+  const leave = () => {
+    process.off("exit", leave);
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+    if (queued)
+      removeOwn(ticket, record.id);
+    queued = false;
+  };
+  let nextStatus = 0;
+  try {
+    for (;; ) {
+      const waited = clock.now() - started;
+      const ahead = queued ? waitersAhead(options, name) : waitersAhead(options, "~");
+      const free = options.slots - liveHolders(options).length;
+      if (ahead < free) {
+        const outcome = tryOnce(options, record, reclaimed);
+        if ("slot" in outcome) {
+          const waitedMs = queued ? waited : 0;
+          leave();
+          const { file, slot } = outcome;
+          let released = false;
+          const release = () => {
+            if (released)
+              return;
+            released = true;
+            process.off("exit", release);
+            removeOwn(file, record.id);
+          };
+          process.on("exit", release);
+          return {
+            ok: true,
+            lease: {
+              record,
+              slot,
+              file,
+              waitedOn,
+              waitedMs,
+              reclaimed,
+              release
+            }
+          };
         }
-      };
-    }
-    const waited = Date.now() - started;
-    if (!waitedOn.length) {
-      waitedOn = outcome.holders;
-      options.onWait?.(outcome.holders);
+      }
+      const holders = liveHolders(options);
+      if (!waitedOn.length) {
+        waitedOn = holders;
+        options.onWait?.(holders);
+      }
+      if (waited >= options.waitMs)
+        return {
+          ok: false,
+          reason: "timeout",
+          holders,
+          waitedMs: waited,
+          position: ahead + 1
+        };
+      if (!queued) {
+        writeTicket(ticket, ticketRecord);
+        queued = true;
+        process.on("exit", leave);
+        process.on("SIGINT", onSignal);
+        process.on("SIGTERM", onSignal);
+      } else if (!fs24.existsSync(ticket)) {
+        writeTicket(ticket, ticketRecord);
+      }
+      if (waited >= nextStatus) {
+        options.onStatus?.({
+          position: ahead + 1,
+          ahead,
+          holders,
+          waitedMs: waited
+        });
+        nextStatus = waited + (options.statusEveryMs ?? 30000);
+      }
+      await clock.sleep(Math.min(options.pollMs ?? 2000, Math.max(1, options.waitMs - waited)));
     }
-    if (waited >= options.waitMs)
-      return { ok: false, reason: "timeout", holders: outcome.holders, waitedMs: waited };
-    await sleep(Math.min(options.pollMs ?? 2000, Math.max(1, options.waitMs - waited)));
+  } catch (error) {
+    return {
+      ok: false,
+      reason: "unavailable",
+      error: error.message
+    };
+  } finally {
+    leave();
   }
 }
 function updateLease(lease, patch) {
@@ -78229,7 +78358,7 @@ function leaseSlots(dir, slots, probe = {}) {
   }
   return states;
 }
-var DEFAULT_HEAVY_CHECKS, DEFAULT_SLOTS = 1, DEFAULT_WAIT_S = 600, DEFAULT_MEMORY_SHARE = 0.4, DEFAULT_CPU_SHARE = 0.7, MAX_SLOTS = 64, UNREADABLE_TTL_MS = 30000, GUARD_TTL_MS = 30000, hostShape = () => ({
+var DEFAULT_HEAVY_CHECKS, DEFAULT_LIGHT_CHECKS, DEFAULT_SLOTS = 1, DEFAULT_WAIT_S = 1800, DEFAULT_MEMORY_SHARE = 0.4, DEFAULT_CPU_SHARE = 0.7, MAX_SLOTS = 64, UNREADABLE_TTL_MS = 30000, GUARD_TTL_MS = 30000, hostShape = () => ({
   totalMemBytes: os20.totalmem(),
   cpus: Math.max(1, os20.availableParallelism?.() ?? os20.cpus().length)
 }), isRecord9 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), SIZE, PERCENT, UNITS, leaseDir = (env) => path52.join(stateDir2(env), "leases"), readText5 = (file) => {
@@ -78263,16 +78392,22 @@ var DEFAULT_HEAVY_CHECKS, DEFAULT_SLOTS = 1, DEFAULT_WAIT_S = 600, DEFAULT_MEMOR
   cwd: lease.cwd,
   session: lease.session,
   startedAt: lease.startedAt
-}), sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), SCOPE_START_FAILURE, NOTICE_TTL_MS;
+}), realClock, queueDir = (dir) => path52.join(dir, "queue"), TICKET, ticketName = (now, id) => `${String(now).padStart(15, "0")}-${String(process.hrtime.bigint() % 10n ** 16n).padStart(16, "0")}-${id}.json`, SCOPE_START_FAILURE, NOTICE_TTL_MS;
 var init_resources = __esm(() => {
   init_checks3();
   init_heavy();
   init_heavy_scope();
-  DEFAULT_HEAVY_CHECKS = ["test", "build", "typecheck"];
+  DEFAULT_HEAVY_CHECKS = ["test", "build"];
+  DEFAULT_LIGHT_CHECKS = ["lint", "typecheck", "format"];
   SIZE = /^(\d+(?:\.\d+)?)([KMGT]?)$/iu;
   PERCENT = /^(\d+(?:\.\d+)?)%$/u;
   UNITS = { "": 1, K: 1024, M: 1024 ** 2, G: 1024 ** 3, T: 1024 ** 4 };
   SCOPE_UNIT = /^[\w.@-]+\.scope$/u;
+  realClock = {
+    now: () => Date.now(),
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+  };
+  TICKET = /^\d{15}-\d{16}-[\w-]+\.json$/u;
   SCOPE_START_FAILURE = /^Failed to (?:connect to bus|create bus connection|start transient scope unit|parse \S+?=)/u;
   NOTICE_TTL_MS = 7 * 86400000;
 });
@@ -78283,7 +78418,6 @@ __export(exports_check, {
   OUTPUT_LINES: () => OUTPUT_LINES,
   boundedOutput: () => boundedOutput,
   countWarnings: () => countWarnings,
-  hostToolWaitCapMs: () => hostToolWaitCapMs,
   run: () => run12,
   workspaceResources: () => workspaceResources
 });
@@ -78306,6 +78440,7 @@ function parse6(argv) {
     positionals: [],
     command: split >= 0 ? argv.slice(split + 1) : null
   };
+  let noWait = false;
   for (let index = 0;index < head.length; index += 1) {
     const arg = head[index];
     const [flag, inline] = arg.startsWith("--") && arg.includes("=") ? arg.split(/=(.*)/su) : [arg];
@@ -78329,6 +78464,13 @@ function parse6(argv) {
         options.noLease = true;
       continue;
     }
+    if (flag === "--no-wait") {
+      if (options.waitMs !== null && !noWait)
+        return new Error("--no-wait goes without --wait");
+      noWait = true;
+      options.waitMs = 0;
+      continue;
+    }
     if (flag === "--name" || flag === "--task" || flag === "--base" || flag === "--timeout" || flag === "--wait" || flag === "--reason") {
       const got = value();
       if (got instanceof Error)
@@ -78338,10 +78480,12 @@ function parse6(argv) {
       else if (flag === "--reason")
         options.reason = got.trim() || null;
       else if (flag === "--wait") {
-        const seconds = Number(got);
-        if (!Number.isFinite(seconds) || seconds < 0)
-          return new Error("--wait must be a number of seconds");
-        options.waitMs = Math.round(seconds * 1000);
+        if (noWait)
+          return new Error("--no-wait goes without --wait");
+        const waitMs = parseWait(got);
+        if (waitMs === null)
+          return new Error('--wait must be seconds or a duration ("90", "90s", "30m", "1h")');
+        options.waitMs = waitMs;
       } else if (flag === "--task")
         options.task = got;
       else if (flag === "--base")
@@ -78471,22 +78615,30 @@ function countWarnings(log) {
   return redactLog(log).replace(ANSI_COLOR, "").split(`
 `).filter((line) => WARNING_LINE.test(line) && !NO_WARNINGS.test(line)).length;
 }
-function boundedOutput(log, lines) {
+function boundedOutput(log, lines, stderr = "") {
   const all = tailLines(log, Number.MAX_SAFE_INTEGER);
   if (all.length === 0)
     return "";
-  const shown = all.slice(-lines);
+  let shown = all.slice(-lines);
+  const errors = tailLines(redactLog(stderr), STDERR_TAIL_LINES);
+  let missing = [];
+  if (errors.length) {
+    const tail = new Set(shown);
+    if (errors.some((line) => !tail.has(line))) {
+      shown = all.slice(-Math.max(1, lines - errors.length - 2));
+      const kept = new Set(shown);
+      missing = errors.filter((line) => !kept.has(line));
+    }
+  }
   const omitted = all.length - shown.length;
+  const footer = missing.length ? `… the last stderr lines, which the merged log holds earlier:
+${missing.join(`
+`)}
+` : "";
   return `${omitted ? `… ${omitted} earlier line${omitted === 1 ? "" : "s"} omitted (the full log is named below; --full streams it)
 ` : ""}${shown.join(`
 `)}
-`;
-}
-function hostToolWaitCapMs(env) {
-  if (!env.CLAUDECODE && !env.OPENCODE && !env.OPENCODE_SESSION_ID)
-    return null;
-  const override = Number(env.WORKIT_HOST_WAIT_CAP_MS);
-  return Number.isFinite(override) && override >= 0 && env.WORKIT_HOST_WAIT_CAP_MS ? override : HOST_TOOL_WAIT_CAP_MS;
+${footer}`;
 }
 async function workspaceResources(io) {
   const env = io.env;
@@ -78520,14 +78672,26 @@ async function prepareHeavy(io, settings, label, runCwd, timeoutMs) {
     waitMs: settings.waitMs,
     pollMs: 1000,
     maxAgeMs: (timeoutMs || MAX_UNVERIFIED_RUN_MS) + 60000,
-    onWait: (holders) => io.stderr(`workit: waiting for the heavy-check lease (${settings.slots} slot${settings.slots === 1 ? "" : "s"}): held by ${holders.map((holder) => describeHolder(holder)).join("; ")}
-`)
+    onStatus: (status) => {
+      const slots = `${settings.slots} slot${settings.slots === 1 ? "" : "s"}`;
+      const holders = status.holders.map((holder) => describeHolder(holder)).join("; ");
+      io.stderr(status.waitedMs === 0 ? `workit: waiting for the heavy-check lease (${slots}): held by ${holders || "nobody; waiters ahead"}; queued at position ${status.position}, waiting up to ${formatWait(settings.waitMs)} (--wait <dur> sets it)
+` : `workit: still queued for the heavy-check lease: position ${status.position}, ${formatWait(status.waitedMs)} of ${formatWait(settings.waitMs)} waited; held by ${holders || "nobody; waiters ahead"}
+`);
+    }
   });
   if (!acquired.ok && acquired.reason === "timeout") {
     const holders = acquired.holders.map((holder) => describeHolder(holder)).join("; ");
-    emit(io, fail2("busy", `the heavy-check lease stayed busy for ${Math.round(acquired.waitedMs / 1000)} s`, {
-      data: { lease: { waitedMs: acquired.waitedMs, holders: acquired.holders } },
-      unblock: `wait for ${holders || "the holders"} to finish, then run it again`
+    const waited = formatWait(acquired.waitedMs);
+    emit(io, fail2("busy", settings.waitMs === 0 ? `the heavy-check lease is busy (--no-wait): held by ${holders || "nobody; waiters ahead"}` : `the heavy-check lease stayed busy for ${waited} (position ${acquired.position} in the queue)`, {
+      data: {
+        lease: {
+          waitedMs: acquired.waitedMs,
+          holders: acquired.holders,
+          position: acquired.position
+        }
+      },
+      unblock: `wait for ${holders || "the waiters ahead"} to finish (each holder's age is shown; a full test suite takes minutes), then run it again, or queue longer with --wait 30m`
     }));
     return 4;
   }
@@ -78627,11 +78791,8 @@ async function run12(argv, io) {
       { label: "workspaces.json", trust: "machine", value: workspace.value },
       { label: CHECKS_FILE, trust: "repo", value: config.resources }
     ]);
-    const cap = hostToolWaitCapMs(io.env);
     if (options.waitMs !== null)
       settings.waitMs = options.waitMs;
-    else if (cap !== null)
-      settings.waitMs = Math.min(settings.waitMs, cap);
     for (const warning of [workspace.warning, ...warnings])
       if (warning)
         io.stderr(`workit: resources: ${warning}
@@ -78648,6 +78809,7 @@ async function run12(argv, io) {
 `);
   const lease = heavy?.lease ?? null;
   let result;
+  let stderrTail = "";
   try {
     const scoped = await runScoped((wrapper, sinks) => runCheckCommand(command, {
       cwd: runCwd,
@@ -78657,7 +78819,12 @@ async function run12(argv, io) {
       ...sinks,
       ...wrapper ? { wrapper } : {},
       ...lease ? { onSpawn: (pid) => updateLease(lease, { pgid: pid }) } : {}
-    }), heavy?.wrapper ?? null, options.full ? { onStdout: io.json ? io.stderr : io.stdout, onStderr: io.stderr } : { onStdout: () => {}, onStderr: () => {} });
+    }), heavy?.wrapper ?? null, options.full ? { onStdout: io.json ? io.stderr : io.stdout, onStderr: io.stderr } : {
+      onStdout: () => {},
+      onStderr: (text) => {
+        stderrTail = (stderrTail + text).slice(-STDERR_KEEP_CHARS);
+      }
+    });
     result = scoped.result;
     if (heavy && scoped.fallback) {
       io.stderr(`workit: the memory/CPU scope could not start (${scoped.fallback}); ran without it
@@ -78769,7 +78936,7 @@ async function run12(argv, io) {
 `);
   else {
     if (!options.full)
-      io.stdout(boundedOutput(result.log, OUTPUT_LINES));
+      io.stdout(boundedOutput(result.log, OUTPUT_LINES, stderrTail));
     io.stderr(`${summary}
 `);
     if (recordError && passed)
@@ -78786,7 +78953,7 @@ async function run12(argv, io) {
     return recordError.code === "busy" ? 4 : recordError.code === "invalid_input" ? 2 : 5;
   return 0;
 }
-var USAGE6 = 'workit check <name> [--full] [--no-lease --reason "<why>"] | workit check [--name <n>] [--shell] [--heavy] [--full] [--wait <s>] [--timeout <s>] [--task <id>] [--json] -- <cmd…>', OUTPUT_LINES = 60, MAX_UNVERIFIED_RUN_MS, RECORD_TAIL_LINES = 20, RECORD_TAIL_CHARS = 200, posix = (value) => value.split(path53.sep).join("/") || ".", ENGINE_CODES2, FINGERPRINT_VARS, ANSI_COLOR, WARNING_LINE, NO_WARNINGS, HOST_TOOL_WAIT_CAP_MS = 1e5;
+var USAGE6 = 'workit check <name> [--full] [--wait <dur> | --no-wait] [--no-lease --reason "<why>"] | workit check [--name <n>] [--shell] [--heavy] [--full] [--wait <dur> | --no-wait] [--timeout <s>] [--task <id>] [--json] -- <cmd…>', OUTPUT_LINES = 60, MAX_UNVERIFIED_RUN_MS, RECORD_TAIL_LINES = 20, RECORD_TAIL_CHARS = 200, posix = (value) => value.split(path53.sep).join("/") || ".", ENGINE_CODES2, FINGERPRINT_VARS, ANSI_COLOR, WARNING_LINE, NO_WARNINGS, STDERR_TAIL_LINES = 10, STDERR_KEEP_CHARS = 65536;
 var init_check = __esm(() => {
   init_check_config();
   init_checks3();
@@ -78824,25 +78991,35 @@ async function settingsFor(io) {
     { label: CHECKS_FILE, trust: "repo", value: config.resources }
   ]).settings;
 }
-function slotLines(slots) {
+function slotLines(slots, queue = []) {
   const busy = held(slots).length;
+  const waiting = queue.filter((entry) => !entry.stale);
   return [
     `heavy-check lease: ${busy} of ${slots.length} slot${slots.length === 1 ? "" : "s"} held`,
-    ...slots.map((slot) => slot.holder ? `  slot ${slot.slot}: ${describeHolder(slot.holder)}${slot.stale ? ` (stale: ${slot.stale}; the next heavy check reclaims it)` : ""}` : `  slot ${slot.slot}: free`)
+    ...slots.map((slot) => slot.holder ? `  slot ${slot.slot}: ${describeHolder(slot.holder)}${slot.stale ? ` (stale: ${slot.stale}; the next heavy check reclaims it)` : ""}` : `  slot ${slot.slot}: free`),
+    `queue: ${waiting.length ? `${waiting.length} waiting, first come, first served` : "empty"}`,
+    ...waiting.map((entry, index) => `  ${index + 1}. ${describeHolder(entry.holder)}`)
   ];
 }
 async function status(io) {
   const settings = await settingsFor(io);
   const slots = leaseSlots(leaseDir(io.env), settings.slots);
-  return emit(io, ok2({ dir: leaseDir(io.env), slots, waitMs: settings.waitMs }), (data) => slotLines(data.slots));
+  const queue = leaseQueue(leaseDir(io.env));
+  const waiting = queue.filter((entry) => !entry.stale).map((entry) => entry.holder);
+  return emit(io, ok2({
+    dir: leaseDir(io.env),
+    slots,
+    queue: waiting,
+    waitMs: settings.waitMs,
+    light: settings.light
+  }), () => slotLines(slots, queue));
 }
 function timeoutOf(args) {
   const at = args.findIndex((arg) => arg === "--timeout" || arg.startsWith("--timeout="));
   if (at < 0)
     return null;
   const raw = args[at].includes("=") ? args[at].split("=")[1] : args[at + 1];
-  const seconds = Number(raw);
-  return Number.isFinite(seconds) && seconds >= 0 ? Math.round(seconds * 1000) : new Error("--timeout must be a number of seconds");
+  return parseWait(raw ?? "") ?? new Error('--timeout must be seconds or a duration ("90", "90s", "30m", "1h")');
 }
 async function wait(args, io) {
   const timeout = timeoutOf(args);
@@ -78859,10 +79036,10 @@ async function wait(args, io) {
     const waitedMs = Date.now() - started;
     if (busy.length < slots.length)
       return emit(io, ok2({ free: true, waitedMs, slots }), () => [
-        `workit: the heavy-check lease has a free slot${waitedMs ? ` after ${Math.round(waitedMs / 1000)} s` : ""}`
+        `workit: the heavy-check lease has a free slot${waitedMs ? ` after ${formatWait(waitedMs)}` : ""}`
       ]);
     if (waitedMs >= limit)
-      return emit(io, fail2("busy", `the heavy-check lease stayed busy for ${Math.round(waitedMs / 1000)} s`, {
+      return emit(io, fail2("busy", `the heavy-check lease stayed busy for ${formatWait(waitedMs)}`, {
         data: { free: false, waitedMs, slots },
         unblock: "workit lock status"
       }));
@@ -78871,16 +79048,16 @@ async function wait(args, io) {
       io.stderr(`workit: waiting for the heavy-check lease: held by ${busy.flatMap((slot) => slot.holder ? [describeHolder(slot.holder)] : []).join("; ")}
 `);
     }
-    await sleep2(Math.min(1000, Math.max(1, limit - waitedMs)));
+    await sleep(Math.min(1000, Math.max(1, limit - waitedMs)));
   }
 }
 async function runHeavy(args, io) {
   const split = args.indexOf("--");
   const head = split < 0 ? args : args.slice(0, split);
-  const unknown = head.find((arg, index) => arg !== "--shell" && arg !== "--json" && !arg.startsWith("--timeout") && !arg.startsWith("--wait") && !((head[index - 1] === "--timeout" || head[index - 1] === "--wait") && !arg.startsWith("-")));
+  const unknown = head.find((arg, index) => arg !== "--shell" && arg !== "--json" && arg !== "--no-wait" && !arg.startsWith("--timeout") && !arg.startsWith("--wait") && !((head[index - 1] === "--timeout" || head[index - 1] === "--wait") && !arg.startsWith("-")));
   if (split < 0 || unknown)
     return emit(io, fail2("invalid_input", unknown ? `unexpected ${unknown}` : "no command after --", {
-      unblock: "workit lock run [--shell] [--wait <s>] [--timeout <s>] -- <cmd…>"
+      unblock: "workit lock run [--shell] [--wait <dur> | --no-wait] [--timeout <s>] -- <cmd…>"
     }));
   const check = await Promise.resolve().then(() => (init_check(), {}));
   return run12([`--heavy`, ...head, ...args.slice(split)], io);
@@ -78966,7 +79143,7 @@ async function run13(argv, io) {
     return heavy(rest, io);
   return emit(io, fail2("invalid_input", `unknown lock subcommand ${sub ?? "(none)"}`, { unblock: USAGE7 }));
 }
-var USAGE7 = "workit lock status | wait [--timeout <s>] | run [--shell] [--wait <s>] [--timeout <s>] -- <cmd…> | heavy list|add|remove|test", held = (slots) => slots.filter((slot) => slot.holder && !slot.stale), sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), commandText = (args) => {
+var USAGE7 = "workit lock status | wait [--timeout <dur>] | run [--shell] [--wait <dur> | --no-wait] [--timeout <s>] -- <cmd…> | heavy list|add|remove|test", held = (slots) => slots.filter((slot) => slot.holder && !slot.stale), sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), commandText = (args) => {
   const split = args.indexOf("--");
   return (split < 0 ? args : args.slice(split + 1)).join(" ").trim();
 };
@@ -82301,6 +82478,74 @@ function syncStack(cwd, ctx, stack, options, actor) {
   }
   return { ok: true, data: outcome };
 }
+function pruneMergedBranches(cwd, ctx, stack, options) {
+  const outcome = { deleted: [], kept: [] };
+  const remote = remoteFor(cwd, ctx?.resolved ?? null, stack.trunk);
+  const trunkSha = trunkTip(cwd, remote, stack.trunk);
+  const keep = (branch, reason) => outcome.kept.push({ branch, reason });
+  for (const entry of stack.branches) {
+    if (!entry.merged || !safeRef3(entry.branch) || entry.branch === stack.trunk)
+      continue;
+    const tip = branchTip(cwd, entry.branch);
+    if (!tip)
+      continue;
+    if (isProtectedTarget(cwd, entry.branch)) {
+      keep(entry.branch, "a protected branch under the workspace branch policy; never deleted");
+      continue;
+    }
+    if (entry.lastHead === null || tip !== entry.lastHead) {
+      keep(entry.branch, `its tip ${tip.slice(0, 12)} is not recorded by the stack (last ${entry.lastHead?.slice(0, 12) ?? "none"}); commits made after it merged stay`);
+      continue;
+    }
+    const owner = worktreeOf(cwd, entry.branch);
+    if (owner) {
+      keep(entry.branch, `checked out in ${owner}; switch it away, then git branch -D ${entry.branch}`);
+      continue;
+    }
+    const safe = safeToDelete(cwd, ctx, remote, trunkSha, entry, tip);
+    if (safe === null) {
+      keep(entry.branch, `${tip.slice(0, 12)} is not on ${stack.trunk}, not the head its PR merged at and not on ${remote}/${entry.branch}: deleting it could lose commits (push them, or delete it yourself)`);
+      continue;
+    }
+    if (!options.dryRun) {
+      const removed = gitRun3(cwd, ["branch", "-D", "--", entry.branch]);
+      if (!removed.ok) {
+        keep(entry.branch, `git branch -D failed: ${removed.stderr.trim().split(`
+`)[0] ?? ""}`);
+        continue;
+      }
+      appendObserved(cwd, {
+        type: "stack.branch.deleted",
+        actor: options.actor,
+        stack: stack.name,
+        branch: entry.branch,
+        head: tip,
+        pr: entry.pr,
+        because: safe
+      });
+    }
+    outcome.deleted.push({ branch: entry.branch, sha: tip });
+  }
+  return outcome;
+}
+function safeToDelete(cwd, ctx, remote, trunkSha, entry, tip) {
+  if (trunkSha && isAncestor2(cwd, tip, trunkSha))
+    return "on_trunk";
+  if (ctx && entry.pr) {
+    const read = statusDoc(ctx, entry.pr);
+    if (read.ok && read.data.state === "merged" && read.data.head.sha === tip)
+      return "merged_head";
+  }
+  const own = pushRemoteName(cwd, entry.branch) ?? remote;
+  const remoteTip = remoteRefTip(cwd, own, `refs/heads/${entry.branch}`);
+  if (remoteTip.ok && remoteTip.sha) {
+    if (!hasCommit(cwd, remoteTip.sha))
+      fetchRefs(cwd, own, [remoteTip.sha]);
+    if (hasCommit(cwd, remoteTip.sha) && isAncestor2(cwd, tip, remoteTip.sha))
+      return "on_remote";
+  }
+  return null;
+}
 async function awaitChecks(ctx, pr, head, options) {
   let waited = 0;
   for (let poll = 0;; poll += 1) {
@@ -82541,6 +82786,7 @@ ${run.stdout}`.split(`
 }, commitCount = (cwd, base, head) => Number(gitRun3(cwd, ["rev-list", "--count", "--no-merges", `${base}..${head}`]).stdout.trim()) || 0, shortStat = (cwd, base, head) => gitRun3(cwd, ["diff", "--shortstat", `${base}...${head}`]).stdout.trim();
 var init_stack = __esm(() => {
   init_autonomy();
+  init_branch();
   init_store_lock();
   init_pr_ops();
   init_report2();
@@ -84991,8 +85237,213 @@ var init_pr_edit = __esm(() => {
   init_report2();
 });
 
-// packages/workit-core/src/core/live-session.ts
+// packages/workit-core/src/fanout-landed.ts
 import { spawnSync as spawnSync26 } from "node:child_process";
+function forgeBreaker(resolved) {
+  if (!resolved)
+    return { forge: null, down: () => null };
+  let tripped = null;
+  const guard = (call) => (...args) => {
+    if (tripped)
+      return { ok: false, code: "unavailable", error: tripped };
+    const result = call(...args);
+    if (!result.ok && result.code === "unavailable")
+      tripped = result.error;
+    return result;
+  };
+  const inner = resolved.forge;
+  const forge = Object.create(inner);
+  forge.findPr = guard(inner.findPr.bind(inner));
+  forge.prStatus = guard(inner.prStatus.bind(inner));
+  return { forge: { ...resolved, forge }, down: () => tripped };
+}
+function branchCreatedAt(cwd, branch) {
+  if (!branch || branch.startsWith("-"))
+    return null;
+  const log = gitRun4(cwd, ["log", "-g", "--format=%H", `refs/heads/${branch}`, "--"]);
+  if (!log.ok)
+    return null;
+  return log.stdout.trim().split(`
+`).findLast(Boolean) ?? null;
+}
+function hasOwnCommits2(cwd, branch, start, head) {
+  if (!branch || branch.startsWith("-"))
+    return false;
+  const log = gitRun4(cwd, ["log", "-g", "--format=%H%x00%gs", `refs/heads/${branch}`, "--"]);
+  if (!log.ok)
+    return false;
+  for (const line of log.stdout.split(`
+`)) {
+    const [sha, subject = ""] = line.split("\x00");
+    if (!sha)
+      continue;
+    const made = /^(?:commit(?: \((?:initial|amend)\))?|cherry-pick|rebase(?: -i)? \(pick\)):/u.test(subject);
+    const onto = /^rebase(?: -i)? \(finish\): \S+ onto ([0-9a-f]+)/u.exec(subject)?.[1];
+    if (!made && !(onto && !sha.startsWith(onto) && !onto.startsWith(sha)))
+      continue;
+    if (sha !== head && !isAncestor3(cwd, sha, head))
+      continue;
+    if (start && (sha === start || isAncestor3(cwd, sha, start)))
+      continue;
+    return true;
+  }
+  return false;
+}
+function reverted(cwd, trunk, landedHead, start) {
+  const fork = mergeBase(cwd, landedHead, trunk);
+  if (fork && fork !== landedHead)
+    return unchangedSince(cwd, fork, landedHead, trunk);
+  const before = start && start !== landedHead && isAncestor3(cwd, start, landedHead) ? start : gitRun4(cwd, ["rev-parse", "--verify", "-q", `${landedHead}^1`]).stdout.trim();
+  return before ? unchangedSince(cwd, before, landedHead, trunk) : false;
+}
+function unchangedSince(cwd, before, after, trunk) {
+  const paths = gitRun4(cwd, ["diff", "--name-only", "--no-renames", "-z", before, after]);
+  const files = paths.ok ? paths.stdout.split("\x00").filter(Boolean) : [];
+  if (files.length === 0)
+    return false;
+  return gitRun4(cwd, ["diff", "--quiet", before, trunk, "--", ...files]).ok;
+}
+function trunkPatchIds(ctx, fork) {
+  const cache = ctx.cache ??= new Map;
+  const known = cache.get(fork);
+  if (known)
+    return known;
+  const ids = new Set;
+  const log = gitRun4(ctx.cwd, [
+    "log",
+    "--no-merges",
+    `--max-count=${TRUNK_SCAN}`,
+    "-p",
+    "--format=commit %H",
+    "-U3",
+    "--diff-algorithm=myers",
+    "--indent-heuristic",
+    "--no-color",
+    "--no-ext-diff",
+    "--no-textconv",
+    "--no-renames",
+    "--full-index",
+    "--src-prefix=a/",
+    "--dst-prefix=b/",
+    `${fork}..${ctx.trunk}`,
+    "--"
+  ]);
+  if (log.ok && log.stdout.trim()) {
+    const run = spawnSync26("git", ["patch-id", "--stable"], {
+      cwd: ctx.cwd,
+      input: log.stdout,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUTS.local,
+      windowsHide: true,
+      maxBuffer: 64 * 1024 * 1024
+    });
+    for (const line of (run.stdout ?? "").split(`
+`)) {
+      const id = line.trim().split(/\s+/u)[0];
+      if (id)
+        ids.add(id);
+    }
+  }
+  cache.set(fork, ids);
+  return ids;
+}
+function inSliceRun(row, slice) {
+  if (row.type === "fanout.worktree.created" && typeof row.sliceHash === "string" && slice.hash)
+    return row.sliceHash === slice.hash;
+  const since = Date.parse(slice.hashSince);
+  return Number.isNaN(since) || Date.parse(String(row.at)) >= since;
+}
+function linked(rows, input, slice, head) {
+  const since = input.since ? Date.parse(input.since) : Number.NaN;
+  const recent = (row) => Number.isNaN(since) || Date.parse(String(row.at)) >= since;
+  return rows.some((row) => {
+    if (row.type === "fanout.worktree.created" && row.fanout === input.fanout && row.slice === slice.id)
+      return typeof row.sliceHash === "string" && input.sliceHash ? row.sliceHash === input.sliceHash : recent(row);
+    return recent(row) && head !== null && row.branch === slice.branch && row.head === head;
+  });
+}
+function detectLanding(ctx, slice, input) {
+  const out = {
+    landed: false,
+    how: null,
+    pr: null,
+    landedHead: null,
+    forgeError: null,
+    note: null
+  };
+  const landed = (how, landedHead) => {
+    if (!hasCommit(ctx.cwd, landedHead) || !reverted(ctx.cwd, ctx.trunk, landedHead, input.createdFrom))
+      return { ...out, landed: true, how, landedHead };
+    return {
+      ...out,
+      note: `landed (${how}${out.pr ? ` #${out.pr.number}` : ""}), then reverted on the trunk: its paths read as before it`
+    };
+  };
+  const { head } = input;
+  if (ctx.forge) {
+    const found = ctx.forge.forge.findPr(slice.branch, {
+      owner: ctx.forge.headRepo.split("/")[0] ?? null,
+      projectId: ctx.forge.headProjectId,
+      sha: head
+    });
+    if (!found.ok)
+      out.forgeError = found.error;
+    else if (found.data) {
+      out.pr = found.data;
+      if (found.data.state === "merged") {
+        const merged = found.data.headSha;
+        const label = `#${found.data.number}`;
+        if (!head) {
+          if (!linked(input.rows, input, slice, merged)) {
+            out.pr = null;
+            out.note = `${slice.branch} is gone; merged ${label} is not linked to this slice in the ledger (an older branch of the same name?)`;
+            return out;
+          }
+          return merged ? landed("pr_merged", merged) : { ...out, landed: true, how: "pr_merged" };
+        }
+        if (!merged || head === merged || isAncestor3(ctx.cwd, head, merged))
+          return landed("pr_merged", merged ?? head);
+        out.note = isAncestor3(ctx.cwd, merged, head) ? `${label} merged at ${merged.slice(0, 12)}; ${slice.branch} is ahead of it with newer commits` : `${label} merged at ${merged.slice(0, 12)}; ${slice.branch} has diverged from it (rewritten after the merge)`;
+        return out;
+      }
+    }
+  }
+  if (!head)
+    return out;
+  const fork = mergeBase(ctx.cwd, head, ctx.trunk);
+  if (fork === head) {
+    return hasOwnCommits2(ctx.cwd, slice.branch, input.createdFrom, head) ? landed("on_trunk", head) : out;
+  }
+  if (!fork)
+    return out;
+  const trunkIds = trunkPatchIds(ctx, fork);
+  if (trunkIds.size === 0)
+    return out;
+  const froms = [fork];
+  if (input.parentHead && input.parentHead !== head && isAncestor3(ctx.cwd, input.parentHead, head))
+    froms.push(input.parentHead);
+  for (const from of froms) {
+    const id = patchId(ctx.cwd, from, head);
+    if (id && trunkIds.has(id))
+      return landed("squash_patch", head);
+  }
+  return out;
+}
+function sliceStart(cwd, rows, fanout, slice) {
+  const reflog = branchCreatedAt(cwd, slice.branch);
+  if (reflog)
+    return reflog;
+  const row = rows.findLast((candidate) => candidate.type === "fanout.worktree.created" && candidate.fanout === fanout && candidate.slice === slice.id && typeof candidate.baseSha === "string" && inSliceRun(candidate, slice));
+  return row?.baseSha ?? null;
+}
+var isAncestor3 = (cwd, a, b) => gitRun4(cwd, ["merge-base", "--is-ancestor", a, b]).ok, TRUNK_SCAN = 500;
+var init_fanout_landed = __esm(() => {
+  init_rev();
+  init_fanout();
+});
+
+// packages/workit-core/src/core/live-session.ts
+import { spawnSync as spawnSync27 } from "node:child_process";
 var LIVE_SESSION_TTL_MS, liveProbe, PIDS;
 var init_live_session = __esm(() => {
   init_paths();
@@ -85001,7 +85452,7 @@ var init_live_session = __esm(() => {
   LIVE_SESSION_TTL_MS = 15 * 60000;
   liveProbe = {
     platform: process.platform,
-    run: (args) => spawnSync26("ps", args, { encoding: "utf8", timeout: 2000 }).stdout ?? "",
+    run: (args) => spawnSync27("ps", args, { encoding: "utf8", timeout: 2000 }).stdout ?? "",
     start: (pid) => processStartOf(pid)
   };
   PIDS = new Map;
@@ -85294,8 +85745,65 @@ function worktreeDependencies(main, worktree) {
       ]
     };
   }
+  const stale = staleBunInstall(main);
+  if (stale && !fs32.existsSync(path64.join(worktree, "node_modules"))) {
+    const command = `bun install --frozen-lockfile --cwd ${worktree}`;
+    return {
+      linked: null,
+      install: command,
+      notes: [
+        `the main checkout's node_modules (${main}) do not match its bun.lock (${stale}), so they were not linked; install dependencies first: ${command}`
+      ]
+    };
+  }
   return { ...linkWorktreeDependencies(main, worktree), install: null };
 }
+function staleBunInstall(main) {
+  if (!fs32.existsSync(path64.join(main, "node_modules")))
+    return null;
+  const text = readBytes(path64.join(main, "bun.lock"))?.toString("utf8");
+  if (!text)
+    return null;
+  let packages;
+  try {
+    const parsed = JSON.parse(text.replace(/,(\s*[}\]])/gu, "$1"));
+    if (!parsed.packages || typeof parsed.packages !== "object")
+      return null;
+    packages = parsed.packages;
+  } catch {
+    return null;
+  }
+  const problems = [];
+  let scanned = 0;
+  for (const [key, entry] of Object.entries(packages)) {
+    if (scanned++ >= STALE_SCAN || problems.length >= 3)
+      break;
+    const spec = Array.isArray(entry) && typeof entry[0] === "string" ? entry[0] : null;
+    if (!spec)
+      continue;
+    const at = spec.lastIndexOf("@");
+    if (at <= 0)
+      continue;
+    const name = spec.slice(0, at);
+    const version = spec.slice(at + 1);
+    if (name !== key || version.includes(":"))
+      continue;
+    const manifest = readBytes(path64.join(main, "node_modules", key, "package.json"));
+    if (!manifest) {
+      problems.push(`${key} missing`);
+      continue;
+    }
+    let installed;
+    try {
+      installed = JSON.parse(manifest.toString("utf8")).version;
+    } catch {
+      installed = null;
+    }
+    if (installed !== version)
+      problems.push(`${key} ${String(installed ?? "?")} installed, bun.lock has ${version}`);
+  }
+  return problems.length ? problems.join("; ") : null;
+}
 function ensureScratch(worktree) {
   const scratch = path64.join(worktree, SCRATCH_DIR);
   fs32.mkdirSync(scratch, { recursive: true });
@@ -85372,14 +85880,19 @@ function createSliceWorktree(cwd, plan, input) {
       notes.push(`resumed ${slice.branch} from ${remote}/${slice.branch}`);
     } else {
       mode = "new";
-      const parent = plan.slices.find((other) => other.branch === slice.base);
-      const from = slice.base === plan.trunk ? trunkRef(cwd, plan.trunk) : parent ? branchRef(cwd, parent.branch) : branchRef(cwd, slice.base);
+      const landedOn = dependenciesLanded(cwd, plan, slice, input.forge);
+      if (landedOn) {
+        base.base = plan.trunk;
+        notes.push(landedOn);
+      }
+      const parent = landedOn ? undefined : plan.slices.find((other) => other.branch === slice.base);
+      const from = base.base === plan.trunk ? trunkRef(cwd, plan.trunk) : parent ? branchRef(cwd, parent.branch) : branchRef(cwd, slice.base);
       if (!from)
         return fanoutFail("not_found", `base ${slice.base} of slice ${slice.id} does not resolve here`, parent ? `start slice ${parent.id} first (its branch ${parent.branch} is the base)` : `git fetch origin ${slice.base}`);
       const added = gitRun4(cwd, ["worktree", "add", "--detach", target, from], SLOW);
       if (!added.ok)
         return worktreeFailed(added.stderr);
-      const branched = gitBranch(target, { name: slice.branch, base: slice.base });
+      const branched = gitBranch(target, { name: slice.branch, base: base.base });
       if (!branched.ok) {
         gitRun4(cwd, ["worktree", "remove", target], SLOW);
         return fanoutFail(branched.code, `workit git branch ${slice.branch} refused: ${branched.error}`, branched.unblock ?? `fix the branch name in the plan, then workit fanout worktree create ${slice.id}`);
@@ -85409,6 +85922,7 @@ function createSliceWorktree(cwd, plan, input) {
     sliceHash: slice.hash,
     ...admin ? { adminId: admin.id, adminIno: admin.ino, adminToken: admin.token } : {},
     ...baseSha ? { baseSha } : {},
+    ...base.base === slice.base ? {} : { startBase: base.base },
     ...deps.install ? { install: deps.install } : {}
   });
   return {
@@ -85425,6 +85939,35 @@ function createSliceWorktree(cwd, plan, input) {
     }
   };
 }
+function dependenciesLanded(cwd, plan, slice, forge) {
+  if (slice.base === plan.trunk || slice.dependsOn.length === 0)
+    return null;
+  const deps = slice.dependsOn.map((id) => plan.slices.find((other) => other.id === id));
+  if (deps.some((dep) => !dep))
+    return null;
+  const trunk = trunkRef(cwd, plan.trunk);
+  if (!trunk)
+    return null;
+  const ledger = readLedger(cwd);
+  const rows = ledger.ok ? ledger.value.rows : [];
+  const ctx = { cwd, trunk, forge: forgeBreaker(forge?.() ?? null).forge };
+  const landed = [];
+  for (const dep of deps) {
+    const landing = detectLanding(ctx, dep, {
+      head: branchRef(cwd, dep.branch),
+      createdFrom: sliceStart(cwd, rows, plan.name, dep),
+      parentHead: null,
+      fanout: plan.name,
+      since: dep.hashSince || plan.createdAt || null,
+      sliceHash: dep.hash || null,
+      rows
+    });
+    if (!landing.landed)
+      return null;
+    landed.push(`${dep.branch} landed (${landing.how ?? "pr_merged"}${landing.pr ? ` #${landing.pr.number}` : ""})`);
+  }
+  return `${landed.join(", ")}: started from ${plan.trunk}, not from ${slice.base}'s pre-merge tip`;
+}
 function releaseSliceWorktree(cwd, plan, input) {
   const found = findSlice(plan, input.slice);
   if (!found.ok)
@@ -85567,12 +86110,13 @@ var SLOW, SCRATCH_DIR = ".workit-scratch", EXCLUDE_LINE, DIRTY_ROW_BYTES = 2000,
   } catch {
     return null;
   }
-}, worktreeFailed = (stderr) => fanoutFail("failed", `git worktree add failed: ${stderr.trim().split(`
+}, STALE_SCAN = 5000, worktreeFailed = (stderr) => fanoutFail("failed", `git worktree add failed: ${stderr.trim().split(`
 `)[0] || "unknown error"}`);
 var init_fanout_worktree = __esm(() => {
   init_ops();
   init_rev();
   init_ledger();
+  init_fanout_landed();
   init_worktree_confine();
   init_worktree_deps();
   init_fanout();
@@ -87205,7 +87749,7 @@ var init_git2 = __esm(() => {
 });
 
 // packages/workit-core/src/forge/verify.ts
-import { spawnSync as spawnSync27 } from "node:child_process";
+import { spawnSync as spawnSync28 } from "node:child_process";
 function finish(cwd, report, actor) {
   const delivered = report.observations.length > 0 && report.observations.every((entry) => entry.ok);
   const out = { ...report, delivered };
@@ -87418,7 +87962,7 @@ var NPM_NAME, SEMVER2, SAFE_ARG, systemNpm = (args) => {
   };
   const found = process.platform === "win32" ? findExecutable("npm.cmd", process.env) : null;
   const npmCmd = found && !/["%!^]/u.test(found) ? `"${found}"` : "npm.cmd";
-  const result = process.platform === "win32" ? spawnSync27(`${npmCmd} ${args.join(" ")}`, { ...options, shell: true }) : spawnSync27("npm", [...args], options);
+  const result = process.platform === "win32" ? spawnSync28(`${npmCmd} ${args.join(" ")}`, { ...options, shell: true }) : spawnSync28("npm", [...args], options);
   return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
 }, short3 = (sha) => sha ? sha.slice(0, 12) : "(absent)", npmView = (stdout) => {
   try {
@@ -87643,7 +88187,7 @@ function planReleaseFinish(cwd, input) {
       return failure3("not_found", `${name} exists neither locally nor on ${remote ?? "a remote"}`);
     if (!tracked || name === openRelease)
       continue;
-    if (!isAncestor3(cwd, tracked, local))
+    if (!isAncestor4(cwd, tracked, local))
       return failure3("blocked", `branch_behind: local ${name} is behind or diverged from ${remote}/${name}; git-flow finishes only onto up-to-date branches`, `git switch ${name} && git merge --ff-only ${remote}/${name}  # then: workit release finish ${version}`);
     const productionTracked = remote ? resolveRef(cwd, `refs/remotes/${remote}/${line.production}`) : null;
     const foreign = git5(cwd, [
@@ -87653,16 +88197,16 @@ function planReleaseFinish(cwd, input) {
       `^${releaseTip}`,
       ...productionTracked ? [`^${productionTracked}`] : []
     ]).stdout.split(`
-`).filter(Boolean).filter((sha) => !(git5(cwd, ["rev-parse", "-q", "--verify", `${sha}^2`]).ok && isAncestor3(cwd, releaseTip, sha)));
+`).filter(Boolean).filter((sha) => !(git5(cwd, ["rev-parse", "-q", "--verify", `${sha}^2`]).ok && isAncestor4(cwd, releaseTip, sha)));
     if (foreign.length)
       return failure3("blocked", `branch_ahead: local ${name} has ${foreign.length} commit(s) ${remote}/${name} lacks that are not part of ${branch}; the finish push would publish them`, `land them through review first, or: git switch ${name} && git reset --keep ${remote}/${name}  # then: workit release finish ${version}`);
   }
-  if (branchTip && remoteBranch && !isAncestor3(cwd, remoteBranch, branchTip))
+  if (branchTip && remoteBranch && !isAncestor4(cwd, remoteBranch, branchTip))
     return failure3("blocked", `release_behind: ${remote}/${branch} has commits local ${branch} lacks`, `git switch ${branch} && git merge --ff-only ${remote}/${branch}`);
   const production = resolveRef(cwd, `refs/heads/${line.production}`);
-  const merged = isAncestor3(cwd, releaseTip, production);
+  const merged = isAncestor4(cwd, releaseTip, production);
   const localTag = resolveRef(cwd, `refs/tags/${tag}`);
-  if (localTag && !(isAncestor3(cwd, localTag, production) && isAncestor3(cwd, releaseTip, localTag)))
+  if (localTag && !(isAncestor4(cwd, localTag, production) && isAncestor4(cwd, releaseTip, localTag)))
     return failure3("blocked", `tag_exists: ${tag} (${localTag.slice(0, 12)}) is not this release's merge on ${line.production}`, "a release tag never moves; finish under the next version");
   if (remote) {
     const remoteTag = remoteRefTip(cwd, remote, `refs/tags/${tag}`);
@@ -87676,7 +88220,7 @@ function planReleaseFinish(cwd, input) {
     tagged: localTag !== null,
     mergedBack: Object.fromEntries(mergeBack.map((name) => [
       name,
-      localTag !== null && isAncestor3(cwd, localTag, resolveRef(cwd, `refs/heads/${name}`))
+      localTag !== null && isAncestor4(cwd, localTag, resolveRef(cwd, `refs/heads/${name}`))
     ])),
     branchDeleted: branchTip === null
   };
@@ -87838,7 +88382,7 @@ var VERSION, PLACEHOLDER4, validVersion = (version) => VERSION.test(version) &&
   return ledger.value.rows.filter((row) => row.type.startsWith("release."));
 }, record2 = (cwd, actor, row) => {
   appendObserved(cwd, { ...row, actor });
-}, KINDS, isAncestor3 = (cwd, ancestor, descendant) => git5(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]).ok, switchTo = (cwd, branch) => {
+}, KINDS, isAncestor4 = (cwd, ancestor, descendant) => git5(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]).ok, switchTo = (cwd, branch) => {
   if (currentBranch(cwd) === branch)
     return success2(undefined);
   const switched = git5(cwd, ["switch", "-q", branch]);
@@ -88304,24 +88848,25 @@ async function status3(argv, io) {
     ...data.next ? [`next: ${data.next}`] : []
   ]);
 }
-async function sync(argv, io) {
+async function sync(argv, io, restack = false) {
+  const usageText = restack ? RESTACK_USAGE : SYNC_USAGE;
   const flags = parseFlags(argv, {
     name: "value",
-    local: "boolean",
+    ...restack ? {} : { local: "boolean" },
     "dry-run": "boolean",
     force: "list"
   });
   if (typeof flags === "string")
-    return usage4(io, flags, SYNC_USAGE);
+    return usage4(io, flags, usageText);
   if (flags.positionals.length)
-    return usage4(io, `unexpected argument ${flags.positionals[0]}`, SYNC_USAGE);
+    return usage4(io, `unexpected argument ${flags.positionals[0]}`, usageText);
   const selected = selectStack(io.cwd, flags.values.name ?? null);
   if (!selected.ok)
     return stackFailed(io, selected);
   const force = new Set(flags.lists.force ?? []);
   const unknown = [...force].filter((branch) => !selected.data.branches.some((entry) => entry.branch === branch));
   if (unknown.length)
-    return usage4(io, `--force ${unknown[0]}: not a branch of stack ${selected.data.name}`, SYNC_USAGE);
+    return usage4(io, `--force ${unknown[0]}: not a branch of stack ${selected.data.name}`, usageText);
   const local = flags.booleans.has("local");
   let ctx = null;
   if (!local) {
@@ -88340,14 +88885,23 @@ async function sync(argv, io) {
     const fresh = readStack(io.cwd, name);
     if (!fresh.ok)
       return fresh;
-    return syncStack(io.cwd, ctx, fresh.data ?? selected.data, {
-      publish: !local,
-      dryRun: flags.booleans.has("dry-run"),
-      force
-    }, actorFromEnv(io.env));
+    const stack = fresh.data ?? selected.data;
+    const dryRun = flags.booleans.has("dry-run");
+    const synced = syncStack(io.cwd, ctx, stack, { publish: !local, dryRun, force }, actorFromEnv(io.env));
+    if (!synced.ok || !restack)
+      return synced;
+    return {
+      ok: true,
+      data: {
+        ...synced.data,
+        pruned: pruneMergedBranches(io.cwd, ctx, stack, { dryRun, actor: actorFromEnv(io.env) })
+      }
+    };
   });
   if (!result.ok)
     return stackFailed(io, result);
+  if (restack)
+    return emit(io, ok2(result.data), renderRestack);
   return emit(io, ok2(result.data), renderSync);
 }
 async function land(argv, io) {
@@ -88434,11 +88988,13 @@ async function run20(argv, io) {
     return status3(rest, io);
   if (sub === "sync")
     return sync(rest, io);
+  if (sub === "restack")
+    return sync(rest, io, true);
   if (sub === "land")
     return land(rest, io);
   return usage4(io, sub && !sub.startsWith("-") ? `unknown stack subcommand "${sub}"` : "missing stack subcommand", USAGE13);
 }
-var PLAN_USAGE = "workit stack plan [--name <n>] [--trunk <b> | --track <t>] [<bottom> … <top>] [--json]", STATUS_USAGE2 = "workit stack status [--name <n>] [--json]", SYNC_USAGE = "workit stack sync [--name <n>] [--local] [--dry-run] [--force <branch>]… [--json]", LAND_USAGE = "workit stack land [--name <n>] [--dry-run] [--max <n>] [--method squash|merge|rebase] [--unverified --reason <why>] [--base-red-ok --reason <why>] [--timeout 20m] [--interval 30s] [--json]", USAGE13 = "workit stack plan|status|sync|land ... (workit help stack)", short5 = (sha) => sha ? sha.slice(0, 12) : "?", stackFailed = (io, result) => emit(io, fail2(result.code, result.error, {
+var PLAN_USAGE = "workit stack plan [--name <n>] [--trunk <b> | --track <t>] [<bottom> … <top>] [--json]", STATUS_USAGE2 = "workit stack status [--name <n>] [--json]", SYNC_USAGE = "workit stack sync [--name <n>] [--local] [--dry-run] [--force <branch>]… [--json]", RESTACK_USAGE = "workit stack restack [--name <n>] [--dry-run] [--force <branch>]… [--json]", LAND_USAGE = "workit stack land [--name <n>] [--dry-run] [--max <n>] [--method squash|merge|rebase] [--unverified --reason <why>] [--base-red-ok --reason <why>] [--timeout 20m] [--interval 30s] [--json]", USAGE13 = "workit stack plan|status|sync|restack|land ... (workit help stack)", short5 = (sha) => sha ? sha.slice(0, 12) : "?", stackFailed = (io, result) => emit(io, fail2(result.code, result.error, {
   unblock: result.unblock,
   data: result.data ?? {}
 })), label3 = (forge, pr) => pr === null ? "no PR" : `${forge === "gitlab" ? "MR !" : "PR #"}${pr}`, renderSync = (data) => [
@@ -88449,6 +89005,10 @@ var PLAN_USAGE = "workit stack plan [--name <n>] [--trunk <b> | --track <t>] [<b
     step.push ? step.push.pushed ? `pushed${step.push.forced ? " (lease)" : ""}` : "remote current" : "",
     step.retarget ? `retargeted ${step.retarget.from} -> ${step.retarget.to}` : ""
   ].filter(Boolean).join(" "))
+], renderRestack = (data) => [
+  ...renderSync(data),
+  ...data.pruned.deleted.map((item) => `${data.dryRun ? "would delete" : "deleted"} merged branch ${item.branch} at ${item.sha} (local; restore: git branch ${item.branch} ${item.sha})`),
+  ...data.pruned.kept.map((item) => `kept merged branch ${item.branch}: ${item.reason}`)
 ], METHODS3;
 var init_stack2 = __esm(() => {
   init_ledger();
@@ -88488,6 +89048,7 @@ function renderBrief(cwd, plan, input) {
   const planned = `${slicePath(cwd, slice)}${input.attempt === null ? "" : `+try${input.attempt}`}`;
   const made = ledger.value.rows.findLast((row) => row.type === "fanout.worktree.created" && row.fanout === plan.name && row.slice === slice.id && typeof row.path === "string" && samePath(row.path, planned));
   const fresh = Boolean(head) && made?.baseSha === head;
+  const sliceBase = typeof made?.startBase === "string" ? made.startBase : slice.base;
   const mode = input.mode ?? (head && !fresh ? "resume" : "new");
   if (mode === "resume" && !head)
     return fanoutFail("not_found", `MODE resume needs the branch ${branch}, which does not exist here`, `workit fanout brief ${slice.id} --mode new`);
@@ -88516,13 +89077,13 @@ function renderBrief(cwd, plan, input) {
     `GOAL: ${slice.goal}`,
     `SCOPE: ${slice.scope.join(", ")}`,
     ...slice.owns.length ? [`  owns: ${slice.owns.join(", ")}`] : [],
-    `  branch: ${branch}   base: ${slice.base}`,
+    `  branch: ${branch}   base: ${sliceBase}`,
     `CONTEXT: ${slice.context ?? "none given: read the files in SCOPE and the neighbours they import"}`,
     ...slice.issues.length ? [
       `ISSUE: ${slice.issues.join(", ")}  (\`workit pr create\` on ${branch} links ${slice.issues.length === 1 ? "it" : "them"} by itself; no --issue needed)`
     ] : [],
     ...mode === "resume" && head ? [
-      `  resume: continue ${branch} from ${head.slice(0, 12)}; read \`git log ${slice.base}..${branch}\` and \`workit ledger list --branch ${branch}\` (the last report, verdicts, rulings)`
+      `  resume: continue ${branch} from ${head.slice(0, 12)}; read \`git log ${sliceBase}..${branch}\` and \`workit ledger list --branch ${branch}\` (the last report, verdicts, rulings)`
     ] : [],
     "ACCEPTANCE:",
     ...slice.acceptance.map((line) => `  - ${line}`),
@@ -88545,7 +89106,7 @@ function renderBrief(cwd, plan, input) {
     exists ? `WORKTREE: ${planned}  (made by \`workit fanout worktree create ${slice.id}\`; yours alone)` : `WORKTREE: ${planned}  (not made yet: the lead runs \`workit fanout worktree create ${slice.id}\` before spawning, then renders this brief again)`,
     ...exists && typeof made?.install === "string" && !fs35.existsSync(path68.join(planned, "node_modules")) ? [`INSTALL: \`${made.install}\` first: the main checkout's node_modules was not linked here`] : [],
     ...identityLines(identity, minted),
-    ...rules(mode, branch, slice.base, exists ? planned : null)
+    ...rules(mode, branch, sliceBase, exists ? planned : null)
   ];
   return {
     ok: true,
@@ -88555,7 +89116,7 @@ function renderBrief(cwd, plan, input) {
       mode,
       attempt: input.attempt,
       branch,
-      base: slice.base,
+      base: sliceBase,
       tier: slice.tier,
       issues: slice.issues,
       model: model?.model ?? null,
@@ -88620,211 +89181,6 @@ var init_fanout_brief = __esm(() => {
   ];
 });
 
-// packages/workit-core/src/fanout-landed.ts
-import { spawnSync as spawnSync28 } from "node:child_process";
-function forgeBreaker(resolved) {
-  if (!resolved)
-    return { forge: null, down: () => null };
-  let tripped = null;
-  const guard = (call) => (...args) => {
-    if (tripped)
-      return { ok: false, code: "unavailable", error: tripped };
-    const result = call(...args);
-    if (!result.ok && result.code === "unavailable")
-      tripped = result.error;
-    return result;
-  };
-  const inner = resolved.forge;
-  const forge = Object.create(inner);
-  forge.findPr = guard(inner.findPr.bind(inner));
-  forge.prStatus = guard(inner.prStatus.bind(inner));
-  return { forge: { ...resolved, forge }, down: () => tripped };
-}
-function branchCreatedAt(cwd, branch) {
-  if (!branch || branch.startsWith("-"))
-    return null;
-  const log = gitRun4(cwd, ["log", "-g", "--format=%H", `refs/heads/${branch}`, "--"]);
-  if (!log.ok)
-    return null;
-  return log.stdout.trim().split(`
-`).findLast(Boolean) ?? null;
-}
-function hasOwnCommits2(cwd, branch, start, head) {
-  if (!branch || branch.startsWith("-"))
-    return false;
-  const log = gitRun4(cwd, ["log", "-g", "--format=%H%x00%gs", `refs/heads/${branch}`, "--"]);
-  if (!log.ok)
-    return false;
-  for (const line of log.stdout.split(`
-`)) {
-    const [sha, subject = ""] = line.split("\x00");
-    if (!sha)
-      continue;
-    const made = /^(?:commit(?: \((?:initial|amend)\))?|cherry-pick|rebase(?: -i)? \(pick\)):/u.test(subject);
-    const onto = /^rebase(?: -i)? \(finish\): \S+ onto ([0-9a-f]+)/u.exec(subject)?.[1];
-    if (!made && !(onto && !sha.startsWith(onto) && !onto.startsWith(sha)))
-      continue;
-    if (sha !== head && !isAncestor4(cwd, sha, head))
-      continue;
-    if (start && (sha === start || isAncestor4(cwd, sha, start)))
-      continue;
-    return true;
-  }
-  return false;
-}
-function reverted(cwd, trunk, landedHead, start) {
-  const fork = mergeBase(cwd, landedHead, trunk);
-  if (fork && fork !== landedHead)
-    return unchangedSince(cwd, fork, landedHead, trunk);
-  const before = start && start !== landedHead && isAncestor4(cwd, start, landedHead) ? start : gitRun4(cwd, ["rev-parse", "--verify", "-q", `${landedHead}^1`]).stdout.trim();
-  return before ? unchangedSince(cwd, before, landedHead, trunk) : false;
-}
-function unchangedSince(cwd, before, after, trunk) {
-  const paths = gitRun4(cwd, ["diff", "--name-only", "--no-renames", "-z", before, after]);
-  const files = paths.ok ? paths.stdout.split("\x00").filter(Boolean) : [];
-  if (files.length === 0)
-    return false;
-  return gitRun4(cwd, ["diff", "--quiet", before, trunk, "--", ...files]).ok;
-}
-function trunkPatchIds(ctx, fork) {
-  const cache = ctx.cache ??= new Map;
-  const known = cache.get(fork);
-  if (known)
-    return known;
-  const ids = new Set;
-  const log = gitRun4(ctx.cwd, [
-    "log",
-    "--no-merges",
-    `--max-count=${TRUNK_SCAN}`,
-    "-p",
-    "--format=commit %H",
-    "-U3",
-    "--diff-algorithm=myers",
-    "--indent-heuristic",
-    "--no-color",
-    "--no-ext-diff",
-    "--no-textconv",
-    "--no-renames",
-    "--full-index",
-    "--src-prefix=a/",
-    "--dst-prefix=b/",
-    `${fork}..${ctx.trunk}`,
-    "--"
-  ]);
-  if (log.ok && log.stdout.trim()) {
-    const run = spawnSync28("git", ["patch-id", "--stable"], {
-      cwd: ctx.cwd,
-      input: log.stdout,
-      encoding: "utf8",
-      timeout: GIT_TIMEOUTS.local,
-      windowsHide: true,
-      maxBuffer: 64 * 1024 * 1024
-    });
-    for (const line of (run.stdout ?? "").split(`
-`)) {
-      const id = line.trim().split(/\s+/u)[0];
-      if (id)
-        ids.add(id);
-    }
-  }
-  cache.set(fork, ids);
-  return ids;
-}
-function inSliceRun(row, slice) {
-  if (row.type === "fanout.worktree.created" && typeof row.sliceHash === "string" && slice.hash)
-    return row.sliceHash === slice.hash;
-  const since = Date.parse(slice.hashSince);
-  return Number.isNaN(since) || Date.parse(String(row.at)) >= since;
-}
-function linked(rows, input, slice, head) {
-  const since = input.since ? Date.parse(input.since) : Number.NaN;
-  const recent = (row) => Number.isNaN(since) || Date.parse(String(row.at)) >= since;
-  return rows.some((row) => {
-    if (row.type === "fanout.worktree.created" && row.fanout === input.fanout && row.slice === slice.id)
-      return typeof row.sliceHash === "string" && input.sliceHash ? row.sliceHash === input.sliceHash : recent(row);
-    return recent(row) && head !== null && row.branch === slice.branch && row.head === head;
-  });
-}
-function detectLanding(ctx, slice, input) {
-  const out = {
-    landed: false,
-    how: null,
-    pr: null,
-    landedHead: null,
-    forgeError: null,
-    note: null
-  };
-  const landed = (how, landedHead) => {
-    if (!hasCommit(ctx.cwd, landedHead) || !reverted(ctx.cwd, ctx.trunk, landedHead, input.createdFrom))
-      return { ...out, landed: true, how, landedHead };
-    return {
-      ...out,
-      note: `landed (${how}${out.pr ? ` #${out.pr.number}` : ""}), then reverted on the trunk: its paths read as before it`
-    };
-  };
-  const { head } = input;
-  if (ctx.forge) {
-    const found = ctx.forge.forge.findPr(slice.branch, {
-      owner: ctx.forge.headRepo.split("/")[0] ?? null,
-      projectId: ctx.forge.headProjectId,
-      sha: head
-    });
-    if (!found.ok)
-      out.forgeError = found.error;
-    else if (found.data) {
-      out.pr = found.data;
-      if (found.data.state === "merged") {
-        const merged = found.data.headSha;
-        const label = `#${found.data.number}`;
-        if (!head) {
-          if (!linked(input.rows, input, slice, merged)) {
-            out.pr = null;
-            out.note = `${slice.branch} is gone; merged ${label} is not linked to this slice in the ledger (an older branch of the same name?)`;
-            return out;
-          }
-          return merged ? landed("pr_merged", merged) : { ...out, landed: true, how: "pr_merged" };
-        }
-        if (!merged || head === merged || isAncestor4(ctx.cwd, head, merged))
-          return landed("pr_merged", merged ?? head);
-        out.note = isAncestor4(ctx.cwd, merged, head) ? `${label} merged at ${merged.slice(0, 12)}; ${slice.branch} is ahead of it with newer commits` : `${label} merged at ${merged.slice(0, 12)}; ${slice.branch} has diverged from it (rewritten after the merge)`;
-        return out;
-      }
-    }
-  }
-  if (!head)
-    return out;
-  const fork = mergeBase(ctx.cwd, head, ctx.trunk);
-  if (fork === head) {
-    return hasOwnCommits2(ctx.cwd, slice.branch, input.createdFrom, head) ? landed("on_trunk", head) : out;
-  }
-  if (!fork)
-    return out;
-  const trunkIds = trunkPatchIds(ctx, fork);
-  if (trunkIds.size === 0)
-    return out;
-  const froms = [fork];
-  if (input.parentHead && input.parentHead !== head && isAncestor4(ctx.cwd, input.parentHead, head))
-    froms.push(input.parentHead);
-  for (const from of froms) {
-    const id = patchId(ctx.cwd, from, head);
-    if (id && trunkIds.has(id))
-      return landed("squash_patch", head);
-  }
-  return out;
-}
-function sliceStart(cwd, rows, fanout, slice) {
-  const reflog = branchCreatedAt(cwd, slice.branch);
-  if (reflog)
-    return reflog;
-  const row = rows.findLast((candidate) => candidate.type === "fanout.worktree.created" && candidate.fanout === fanout && candidate.slice === slice.id && typeof candidate.baseSha === "string" && inSliceRun(candidate, slice));
-  return row?.baseSha ?? null;
-}
-var isAncestor4 = (cwd, a, b) => gitRun4(cwd, ["merge-base", "--is-ancestor", a, b]).ok, TRUNK_SCAN = 500;
-var init_fanout_landed = __esm(() => {
-  init_rev();
-  init_fanout();
-});
-
 // packages/workit-core/src/fanout-check.ts
 function mergeConflicts(cwd, a, b) {
   const run = gitRun4(cwd, [
@@ -89007,7 +89363,9 @@ function inspect(cwd, plan, slice, ctx, changedBy) {
     return check;
   }
   const parent = plan.slices.find((other) => other.branch === slice.base);
-  const baseRef = slice.base === plan.trunk ? trunk : parent ? tips.get(parent.id) ?? ctx.landings.get(parent.id)?.landedHead ?? null : branchRef(cwd, slice.base);
+  const parentLanded = parent ? ctx.landings.get(parent.id)?.landed === true : false;
+  const parentRef = parent ? tips.get(parent.id) ?? ctx.landings.get(parent.id)?.landedHead ?? null : null;
+  const baseRef = slice.base === plan.trunk ? trunk : parent ? parentLanded && !(parentRef && isAncestor5(cwd, parentRef, head)) ? trunk : parentRef : branchRef(cwd, slice.base);
   if (!SAFE(baseRef)) {
     check.reasons.push(`base ${slice.base} not found`);
     return check;
@@ -89475,7 +89833,8 @@ function worktree(argv, io) {
   if (action === "create") {
     const result = createSliceWorktree(io.cwd, selected.data, {
       slice: flags.positionals[0],
-      actor
+      actor,
+      forge: () => forgeFor(io, false).forge
     });
     if (!result.ok)
       return failed(io, result);
@@ -107041,9 +107400,10 @@ function withSubcommands(entry, options = {}) {
   };
 }
 var LEASE_NOTES = [
-  "The heavy-check lease: heavy work (tests, builds, lint, typecheck, installs, image builds) shares one machine-wide lease, so parallel agents and worktrees never exhaust this machine's memory and CPU. `slots` (default 1) heavy checks run at once; on Linux each also runs in a systemd scope with MemoryMax and CPUQuota.",
-  "Waiting: a heavy check that finds every slot held prints one `waiting for the heavy-check lease` line naming the holder (check, pid, session, age, directory), polls once a second, and exits 4 (busy) after `--wait <s>`, else `resources.wait` seconds (default 600, capped at 100 inside a Claude Code or OpenCode shell). `workit lock status` shows the holders; `workit lock wait` waits for a free slot.",
-  "--heavy: an ad-hoc `workit check -- <cmd>` takes the lease only with --heavy; the named checks test, build and typecheck always do. The shell hook runs a raw heavy command (`npx jest`, `npm run test:ci`, `cargo test`, `docker build`) as `workit check --heavy -- <cmd>` on Claude Code, OpenCode and Pi, and denies it with that exact command on Codex and Cursor.",
+  "The heavy-check lease: heavy work (tests, builds, installs, image builds) shares one machine-wide lease, so parallel agents and worktrees never exhaust this machine's memory and CPU. `slots` (default 1) heavy checks run at once; on Linux each also runs in a systemd scope with MemoryMax and CPUQuota.",
+  "Queueing: a heavy check that finds every slot held joins a first-come, first-served queue and prints `waiting for the heavy-check lease` naming the holder (check, pid, session, age, directory) and its position, then a status line every 30 s. It waits `--wait <dur>` (90, 90s, 30m, 1h), else `resources.wait` (default 30 min), and exits 4 (busy) only past that wait or at once with --no-wait. A waiter that is killed gives up its place. A wait longer than your shell tool's timeout belongs in a background call. `workit lock status` shows the holders and the queue.",
+  "Light checks: the named checks lint, typecheck and format (`resources.light`, set in workspaces.json) never take the lease, so they run at once beside a long suite.",
+  "--heavy: an ad-hoc `workit check -- <cmd>` takes the lease only with --heavy; the named checks test and build always do. The shell hook runs a raw heavy command (`npx jest`, `npm run test:ci`, `cargo test`, `docker build`) as `workit check --heavy -- <cmd>` on Claude Code, OpenCode and Pi, and denies it with that exact command on Codex and Cursor.",
   '--no-lease skips the lease and needs --reason "<why>". Never hand-roll a flock: the lease already queues every agent on the machine.',
   "Output: a check prints the last 60 lines of its output and one summary line with `log: <path>` to the full log; --full streams all of it."
 ];
@@ -107160,7 +107520,7 @@ var VERBS = [
   {
     name: "check",
     group: "delivery",
-    usage: 'workit check <name> [--full] [--task <id>] [--base <ref>] [--no-lease --reason "<why>"] | workit check [--name <n>] [--shell] [--full] [--timeout <s>] [--task <id>] [--base <ref>] [--heavy [--wait <s>]] [--no-lease --reason "<why>"] -- <cmd…>',
+    usage: 'workit check <name> [--full] [--task <id>] [--base <ref>] [--wait <dur> | --no-wait] [--no-lease --reason "<why>"] | workit check [--name <n>] [--shell] [--full] [--timeout <s>] [--task <id>] [--base <ref>] [--heavy [--wait <dur> | --no-wait]] [--no-lease --reason "<why>"] -- <cmd…>',
     flagHints: {
       list: "workit check <name> runs a configured check; a name that is not configured prints the valid ones (workit check test|lint|typecheck|check)"
     },
@@ -107168,6 +107528,7 @@ var VERBS = [
     examples: [
       "workit check test",
       "workit check --heavy -- npx jest",
+      "workit check test --wait 45m",
       "workit check --name unit -- bun test test/unit",
       'workit check test --no-lease --reason "machine is idle, debugging a hang"'
     ],
@@ -107182,16 +107543,16 @@ var VERBS = [
       {
         name: "status",
         usage: "workit lock status",
-        summary: "Show each lease slot: free, held (check, pid, session, age, directory) or stale"
+        summary: "Show each lease slot (free, held by check, pid, session, age, directory, or stale) and the queue of waiting checks in arrival order"
       },
       {
         name: "wait",
-        usage: "workit lock wait [--timeout <s>]",
+        usage: "workit lock wait [--timeout <dur>]",
         summary: "Wait until a lease slot is free, without taking it (exit 0 free, 4 still busy at the timeout)"
       },
       {
         name: "run",
-        usage: "workit lock run [--shell] [--wait <s>] [--timeout <s>] -- <cmd…>",
+        usage: "workit lock run [--shell] [--wait <dur> | --no-wait] [--timeout <s>] -- <cmd…>",
         summary: "Run a command under the lease: the same as workit check --heavy -- <cmd…>"
       },
       {
@@ -107408,6 +107769,11 @@ var VERBS = [
         usage: "workit stack sync [--name <n>] [--local] [--dry-run] [--force <branch>]…",
         summary: "Restack onto the moved bases, lease-push and retarget the PRs"
       },
+      {
+        name: "restack",
+        usage: "workit stack restack [--name <n>] [--dry-run] [--force <branch>]…",
+        summary: "After a parent merged (squash too): sync, then delete the merged stack branches locally"
+      },
       {
         name: "land",
         usage: "workit stack land [--name <n>] [--dry-run] [--max <n>] [--method squash|merge|rebase] [--unverified --reason <why>] [--base-red-ok --reason <why>] [--timeout 20m] [--interval 30s]",