@brainervirus/workit-cli 8.38.4 → 8.38.5

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.38.5",
     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.38.5",
       "@inkjs/ui": "2.0.0",
       ink: "7.1.1",
       react: "19.2.8"
     },
     devDependencies: {
-      "@brainervirus/workit-core": "^8.38.4"
+      "@brainervirus/workit-core": "^8.38.5"
     },
     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();
 };
@@ -107041,9 +107218,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 +107338,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 +107346,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 +107361,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…>"
       },
       {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-cli",
-  "version": "8.38.4",
+  "version": "8.38.5",
   "private": false,
   "description": "Workit CLI — setup wizard, doctor, and task control for agentic coding workflows",
   "keywords": [
@@ -38,13 +38,13 @@
   },
   "dependencies": {
     "@babel/parser": "7.29.9",
-    "@brainervirus/workit-cursor": "^8.38.4",
+    "@brainervirus/workit-cursor": "^8.38.5",
     "@inkjs/ui": "2.0.0",
     "ink": "7.1.1",
     "react": "19.2.8"
   },
   "devDependencies": {
-    "@brainervirus/workit-core": "^8.38.4"
+    "@brainervirus/workit-core": "^8.38.5"
   },
   "engines": {
     "node": ">=24"