@brainervirus/workit-claude-code 8.38.3 → 8.38.5

package/dist/workit.js

@@ -9317,7 +9317,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@brainervirus/workit-cli",
-    version: "8.38.3",
+    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.3",
+      "@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.3"
+      "@brainervirus/workit-core": "^8.38.5"
     },
     engines: {
       node: ">=24"
@@ -16832,6 +16832,79 @@ var init_workers = __esm(() => {
   UNCERTAIN_WORKER_STATES = ["dispatching", "running", "cancelling", "unknown"];
 });
 
+// packages/workit-core/src/core/task-delivery.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
+function closeDeliveredTasks(store, now, options = {}) {
+  let closedCount = 0;
+  const index = store.listStoreIndex();
+  if (!index.ok)
+    return 0;
+  const open = index.data.filter((entry) => entry.status !== "closed" && entry.branch !== null);
+  if (open.length === 0)
+    return 0;
+  const file = options.cached ? ledgerPath(store.root) : null;
+  const signature = file?.ok ? `${fileSignature(file.value) ?? "-"}|${open.map((entry) => entry.id).join(",")}` : null;
+  const marker = file?.ok ? `${file.value}.delivery-sweep` : null;
+  if (signature && marker) {
+    try {
+      if (readFileSync6(marker, "utf8") === signature)
+        return 0;
+    } catch {}
+  }
+  const ledger = readLedger(store.root);
+  if (!ledger.ok)
+    return 0;
+  const rows = ledger.value.rows;
+  const after = (row, since) => Date.parse(row.at) >= Date.parse(since);
+  for (const entry of open) {
+    const merged = rows.findLast((row) => row.type === "pr.merged" && row.branch === entry.branch && typeof row.pr === "number" && after(row, entry.createdAt));
+    if (!merged)
+      continue;
+    const pr = merged.pr;
+    const verified = rows.findLast((row) => row.type === "delivery.verified" && row.expect === "merged" && row.branch === entry.branch && (row.pr === undefined || row.pr === pr));
+    if (!verified) {
+      const next = `PR #${pr} is merged but delivery is not verified: run \`workit verify-delivery merged\``;
+      if (entry.progress.nextAction !== next) {
+        store.mutateTask(entry.id, entry.revision, (task, context) => success(context.revision, null, {
+          ...task,
+          progress: { ...task.progress, nextAction: next }
+        }));
+      }
+      continue;
+    }
+    const task = store.readTask(entry.id);
+    if (!task.ok || task.data.status === "closed")
+      continue;
+    if (task.data.workers.some((worker) => workerBlocksTransition("close", worker.data.state)))
+      continue;
+    const closed = store.mutateTask(entry.id, task.data.revision, (value, context) => success(context.revision, null, {
+      ...value,
+      status: "closed",
+      closure: {
+        outcome: "verified",
+        at: context.now,
+        summary: `delivered: PR #${pr} merged (pr.merged ${String(merged.id)}) and delivery verified (delivery.verified ${String(verified.id)})`,
+        decisionIds: [],
+        evidenceIds: []
+      }
+    }), now);
+    if (closed.ok)
+      closedCount++;
+  }
+  if (signature && marker && closedCount === 0 && !racySignature(signature.split("|")[0] ?? "")) {
+    try {
+      writeFileSync4(marker, signature);
+    } catch {}
+  }
+  return closedCount;
+}
+var init_task_delivery = __esm(() => {
+  init_ledger();
+  init_task_store();
+  init_task_contract();
+  init_workers();
+});
+
 // packages/workit-core/src/core/task-evaluation.ts
 import { createHash as createHash11 } from "node:crypto";
 import * as fs14 from "node:fs";
@@ -18804,10 +18877,10 @@ var init_route_intent = __esm(() => {
 
 // packages/workit-core/src/core/runtime-identity.ts
 import { createHash as createHash12 } from "node:crypto";
-import { readFileSync as readFileSync7 } from "node:fs";
+import { readFileSync as readFileSync8 } from "node:fs";
 var sha256Hex = (bytes) => createHash12("sha256").update(bytes).digest("hex"), bundleHashOfFile = (file) => {
   try {
-    return sha256Hex(readFileSync7(file));
+    return sha256Hex(readFileSync8(file));
   } catch {
     return null;
   }
@@ -21199,7 +21272,7 @@ var init_core3 = __esm(() => {
 });
 
 // packages/workit-cli/src/task.ts
-import { readFileSync as readFileSync8 } from "node:fs";
+import { readFileSync as readFileSync9 } from "node:fs";
 import path27 from "node:path";
 async function readInput(input) {
   if (typeof input === "string")
@@ -21216,7 +21289,7 @@ async function payloadValue(raw, deps) {
     return { ok: true, value: {} };
   let source;
   try {
-    source = raw === "-" ? await readInput(deps.stdin ?? process.stdin) : raw.startsWith("@") ? decodeUtf8(readFileSync8(raw.slice(1))) : raw;
+    source = raw === "-" ? await readInput(deps.stdin ?? process.stdin) : raw.startsWith("@") ? decodeUtf8(readFileSync9(raw.slice(1))) : raw;
   } catch (error) {
     return {
       ok: false,
@@ -21504,7 +21577,12 @@ async function runTaskCommand(argv, deps = {}) {
     return parsed.usage ? 2 : 1;
   }
   const root = workspaceRootFor(deps);
-  const core = new WorkitCore(new TaskStore(root), contextFor(root, parsed.parsed.actor !== undefined ? { ...deps, actor: parsed.parsed.actor } : deps));
+  const store = new TaskStore(root);
+  try {
+    const now = new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+    closeDeliveredTasks(store, now, { cached: parsed.parsed.action !== "list" });
+  } catch {}
+  const core = new WorkitCore(store, contextFor(root, parsed.parsed.actor !== undefined ? { ...deps, actor: parsed.parsed.actor } : deps));
   let result;
   if (parsed.parsed.handoff) {
     const exported = dispatch(core, "state", parsed.parsed.request);
@@ -21600,6 +21678,7 @@ var init_task = __esm(() => {
   init_current_judgment();
   init_judgment();
   init_lane();
+  init_task_delivery();
   init_task_store();
   init_core3();
   init_task_contract();
@@ -65285,13 +65364,13 @@ var init_changelog = __esm(() => {
 
 // packages/workit-core/src/core/hygiene.ts
 import { spawnSync as spawnSync12 } from "node:child_process";
-import { existsSync as existsSync10, readFileSync as readFileSync10, readdirSync as readdirSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync11, readdirSync as readdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
 import path29 from "node:path";
 var repoRoot2, templatesDir = () => path29.join(repoRoot2, "templates", "hygiene"), packageJson = (root) => {
   if (!existsSync10(path29.join(root, "package.json")))
     return null;
   try {
-    return JSON.parse(readFileSync10(path29.join(root, "package.json"), "utf8"));
+    return JSON.parse(readFileSync11(path29.join(root, "package.json"), "utf8"));
   } catch {
     return null;
   }
@@ -65344,7 +65423,7 @@ var repoRoot2, templatesDir = () => path29.join(repoRoot2, "templates", "hygiene
     const tpl = path29.join(templatesDir(), file);
     if (!existsSync10(tpl))
       continue;
-    const content = readFileSync10(tpl, "utf8").replace(/<PROJECT>/g, path29.basename(root)).replace(/<YEAR>/g, String(new Date().getFullYear())).replace(/<HOLDER>\s*/g, licenseHolder(root));
+    const content = readFileSync11(tpl, "utf8").replace(/<PROJECT>/g, path29.basename(root)).replace(/<YEAR>/g, String(new Date().getFullYear())).replace(/<HOLDER>\s*/g, licenseHolder(root));
     planned.push({ path: path29.join(root, file), content });
   }
   return planned;
@@ -65356,13 +65435,13 @@ var init_hygiene = __esm(() => {
 });
 
 // packages/workit-cli/src/admin/setup-state.ts
-import { existsSync as existsSync11, readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync12 } from "node:fs";
 import path30 from "node:path";
 var classifySetupFile = (dir, name) => {
   const file = path30.join(dir, name);
   let raw;
   try {
-    raw = readFileSync11(file, "utf8");
+    raw = readFileSync12(file, "utf8");
   } catch {
     if (existsSync11(file)) {
       return { file, status: "malformed", error: `${file} is not readable` };
@@ -65803,7 +65882,7 @@ import {
   accessSync,
   constants as constants2,
   existsSync as existsSync12,
-  readFileSync as readFileSync12,
+  readFileSync as readFileSync13,
   readdirSync as readdirSync6,
   realpathSync as realpathSync6,
   statSync as statSync2
@@ -66093,7 +66172,7 @@ function runHostCommand(step, context = {}) {
 }
 var resolveWindowsShimScript = (shim) => {
   try {
-    const contents = readFileSync12(shim, "utf8");
+    const contents = readFileSync13(shim, "utf8");
     return resolveWindowsShimEntry(contents, shim);
   } catch {
     return null;
@@ -66114,7 +66193,7 @@ var resolveWindowsShimScript = (shim) => {
 }, isPiWorkitInstalled = (home, env = process.env) => {
   const settings = path33.join(env.PI_CODING_AGENT_DIR ?? path33.join(home, ".pi", "agent"), "settings.json");
   try {
-    const document2 = JSON.parse(readFileSync12(settings, "utf8"));
+    const document2 = JSON.parse(readFileSync13(settings, "utf8"));
     return (document2.packages ?? []).some((entry) => {
       const source = entry && typeof entry === "object" && !Array.isArray(entry) ? entry.source : entry;
       const value = String(source).replaceAll("\\", "/").replace(/\/+$/, "");
@@ -66125,7 +66204,7 @@ var resolveWindowsShimScript = (shim) => {
   }
 }, OPENCODE_PLUGIN_SCOPE = "@brainervirus", OPENCODE_PLUGIN_NAME = "workit-opencode", packageVersionAt = (root, name) => {
   try {
-    const pkg = JSON.parse(readFileSync12(path33.join(root, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync13(path33.join(root, "package.json"), "utf8"));
     return pkg.name === name && typeof pkg.version === "string" ? pkg.version : null;
   } catch {
     return null;
@@ -66163,7 +66242,7 @@ var resolveWindowsShimScript = (shim) => {
     path33.join(root, "package.json")
   ]) {
     try {
-      const manifest = JSON.parse(readFileSync12(file, "utf8"));
+      const manifest = JSON.parse(readFileSync13(file, "utf8"));
       const repository = typeof manifest.repository === "string" ? manifest.repository : manifest.repository?.url;
       if ((manifest.name === "workit" || manifest.name === "@brainervirus/workit-codex") && repository?.replace(/\.git$/, "").toLowerCase() === "https://github.com/brainervirus/workit")
         return true;
@@ -66204,7 +66283,7 @@ var resolveWindowsShimScript = (shim) => {
   return relative === "" || !relative.startsWith("..") && !path33.isAbsolute(relative);
 }, isCanonicalClaudePlugin = (root) => {
   try {
-    const manifest = JSON.parse(readFileSync12(path33.join(root, ".claude-plugin", "plugin.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync13(path33.join(root, ".claude-plugin", "plugin.json"), "utf8"));
     const repository = typeof manifest.repository === "string" ? manifest.repository : manifest.repository?.url;
     return manifest.name === "workit" && repository?.replace(/\.git$/, "").toLowerCase() === "https://github.com/brainervirus/workit";
   } catch {
@@ -66214,7 +66293,7 @@ var resolveWindowsShimScript = (shim) => {
   const file = path33.join(claudeConfigDir(home, env), "plugins", "installed_plugins.json");
   let registry;
   try {
-    registry = JSON.parse(readFileSync12(file, "utf8"));
+    registry = JSON.parse(readFileSync13(file, "utf8"));
   } catch {
     return [];
   }
@@ -66263,7 +66342,7 @@ var init_host_install = __esm(() => {
 });
 
 // packages/workit-core/src/core/skill-manifests.ts
-import { cpSync as cpSync3, existsSync as existsSync13, readFileSync as readFileSync13, readdirSync as readdirSync7, statSync as statSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { cpSync as cpSync3, existsSync as existsSync13, readFileSync as readFileSync14, readdirSync as readdirSync7, statSync as statSync3, writeFileSync as writeFileSync6 } from "node:fs";
 import path34 from "node:path";
 var WORKIT_METHOD_SKILLS, skillManifestNames = (root) => existsSync13(root) ? readdirSync7(root).filter((name) => existsSync13(path34.join(root, name, "SKILL.md"))).toSorted() : [], validateSkillManifests = (root, expected, label) => {
   const actual = skillManifestNames(root);
@@ -66281,7 +66360,7 @@ var WORKIT_METHOD_SKILLS, skillManifestNames = (root) => existsSync13(root) ? re
       const file = path34.join(dir, entry.name);
       if (entry.isDirectory())
         pending.push(file);
-      else if ((statSync3(file).mode & 73) !== 0 || readFileSync13(file).subarray(0, 2).toString("latin1") === "#!") {
+      else if ((statSync3(file).mode & 73) !== 0 || readFileSync14(file).subarray(0, 2).toString("latin1") === "#!") {
         return `Cursor vendor contains active file: ${file}`;
       }
     }
@@ -66314,11 +66393,11 @@ import {
   existsSync as existsSync14,
   lstatSync as lstatSync4,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   renameSync as renameSync3,
   rmSync as rmSync2,
   statSync as statSync4,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "node:fs";
 import path35 from "node:path";
 function inspectSessionHook(cwd, env = process.env) {
@@ -66517,7 +66596,7 @@ exit 0
   return rel === "" || !rel.startsWith("..") && !path35.isAbsolute(rel);
 }, readText3 = (file) => {
   try {
-    return readFileSync14(file, "utf8");
+    return readFileSync15(file, "utf8");
   } catch {
     return null;
   }
@@ -66621,7 +66700,7 @@ exit 0
   mkdirSync5(path35.dirname(file), { recursive: true });
   const staged = `${file}.workit-new`;
   try {
-    writeFileSync6(staged, content, { mode: 493 });
+    writeFileSync7(staged, content, { mode: 493 });
     chmodSync(staged, 493);
     renameSync3(staged, file);
   } finally {
@@ -66684,7 +66763,7 @@ var init_heavy_words = __esm(() => {
 });
 
 // packages/workit-core/src/hooks/hook-runs.ts
-import { mkdirSync as mkdirSync6, readdirSync as readdirSync8, readFileSync as readFileSync15, writeFileSync as writeFileSync7 } from "node:fs";
+import { mkdirSync as mkdirSync6, readdirSync as readdirSync8, readFileSync as readFileSync16, writeFileSync as writeFileSync8 } from "node:fs";
 import path37 from "node:path";
 var HOOK_RUNS_DIR = "hook-runs", readHookRuns = (dir) => {
   const runs = [];
@@ -66696,7 +66775,7 @@ var HOOK_RUNS_DIR = "hook-runs", readHookRuns = (dir) => {
   }
   for (const name of names) {
     try {
-      const row = JSON.parse(readFileSync15(path37.join(dir, HOOK_RUNS_DIR, name), "utf8"));
+      const row = JSON.parse(readFileSync16(path37.join(dir, HOOK_RUNS_DIR, name), "utf8"));
       if (typeof row.host === "string" && typeof row.event === "string" && typeof row.at === "string" && typeof row.count === "number")
         runs.push({
           host: row.host,
@@ -66742,7 +66821,7 @@ import {
   existsSync as existsSync15,
   readdirSync as readdirSync9,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync17,
   realpathSync as realpathSync7,
   rmSync as rmSync3,
   statSync as statSync5
@@ -67170,7 +67249,7 @@ ${[...rules, ...lease, grant].join(`
 }, AGENT_SESSION_VARS, agentSessionVar = (env) => AGENT_SESSION_VARS.find((name) => (env[name] ?? "") !== "") ?? null, RECORD_FILE = "host-permissions.json", readOwnership = (options = {}) => {
   const { stateDir } = resolvePaths(options);
   try {
-    const value = JSON.parse(readFileSync16(path38.join(stateDir, RECORD_FILE), "utf8"));
+    const value = JSON.parse(readFileSync17(path38.join(stateDir, RECORD_FILE), "utf8"));
     if (isRecord5(value) && isRecord5(value.hosts))
       return { version: 1, hosts: value.hosts };
   } catch {}
@@ -67199,7 +67278,7 @@ ${[...rules, ...lease, grant].join(`
   writeOwnership(record, paths.stateDir);
 }, readText4 = (file) => {
   try {
-    return readFileSync16(file, "utf8");
+    return readFileSync17(file, "utf8");
   } catch {
     return null;
   }
@@ -67361,13 +67440,13 @@ import {
   mkdirSync as mkdirSync8,
   mkdtempSync,
   readdirSync as readdirSync10,
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync18,
   readlinkSync as readlinkSync2,
   renameSync as renameSync4,
   rmSync as rmSync4,
   statSync as statSync6,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync9
 } from "node:fs";
 import os12 from "node:os";
 import path39 from "node:path";
@@ -67431,14 +67510,14 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   };
 }, readJson = (p) => {
   try {
-    const parsed = JSON.parse(readFileSync17(p, "utf8"));
+    const parsed = JSON.parse(readFileSync18(p, "utf8"));
     return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
   }
 }, parsesAsConfigObject = (p) => {
   try {
-    return isConfigObject(JSON.parse(readFileSync17(p, "utf8")));
+    return isConfigObject(JSON.parse(readFileSync18(p, "utf8")));
   } catch {
     return false;
   }
@@ -67661,7 +67740,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   const tables = new Map;
   let text;
   try {
-    text = readFileSync17(file, "utf8");
+    text = readFileSync18(file, "utf8");
   } catch {
     return tables;
   }
@@ -67832,7 +67911,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     let stale = false;
     for (const file of files) {
       const dest = path39.join(agentsDir, file);
-      const want = stampCodexAgent(readFileSync17(path39.join(source, file), "utf8"), version);
+      const want = stampCodexAgent(readFileSync18(path39.join(source, file), "utf8"), version);
       let link = false;
       try {
         link = lstatSync5(dest).isSymbolicLink();
@@ -67846,7 +67925,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
       }
       let have = null;
       try {
-        have = readFileSync17(dest, "utf8");
+        have = readFileSync18(dest, "utf8");
       } catch {
         have = null;
       }
@@ -68095,7 +68174,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
 }, validNodeEntry = (entry, runtime, env) => {
   try {
     const stat = statSync6(entry);
-    if (!stat.isFile() || stat.size === 0 || !readFileSync17(entry, "utf8").startsWith(`#!/usr/bin/env node
+    if (!stat.isFile() || stat.size === 0 || !readFileSync18(entry, "utf8").startsWith(`#!/usr/bin/env node
 `)) {
       return false;
     }
@@ -68951,7 +69030,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   return { ...installSessionHook(res.cwd, res.env), workspace: workspace.name };
 }, isPlaceholder = (p) => {
   try {
-    return readFileSync17(p, "utf8").trim() === TOKEN_PLACEHOLDER2;
+    return readFileSync18(p, "utf8").trim() === TOKEN_PLACEHOLDER2;
   } catch {
     return false;
   }
@@ -69165,7 +69244,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   const probe = path39.join(logsDir, "doctor-probe.tmp");
   try {
     mkdirSync8(logsDir, { recursive: true, mode: 448 });
-    writeFileSync8(probe, `{"probe":true}
+    writeFileSync9(probe, `{"probe":true}
 `, { mode: 384 });
     return {
       id: "log_writable",
@@ -69244,7 +69323,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   const counts = { skip: 0, late: 0 };
   let text = "";
   try {
-    text = readFileSync17(path39.join(stateDir, HOOK_SKIPS_FILE), "utf8");
+    text = readFileSync18(path39.join(stateDir, HOOK_SKIPS_FILE), "utf8");
   } catch {
     return counts;
   }
@@ -69435,7 +69514,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     return null;
   return files.some((file) => {
     try {
-      return readFileSync17(path39.join(root, "dist", file), "utf8").includes(HOOK_ISSUED_MARKER);
+      return readFileSync18(path39.join(root, "dist", file), "utf8").includes(HOOK_ISSUED_MARKER);
     } catch {
       return false;
     }
@@ -69779,13 +69858,13 @@ import {
   lstatSync as lstatSync6,
   mkdirSync as mkdirSync9,
   mkdtempSync as mkdtempSync2,
-  readFileSync as readFileSync18,
+  readFileSync as readFileSync19,
   readdirSync as readdirSync11,
   realpathSync as realpathSync8,
   renameSync as renameSync5,
   rmSync as rmSync5,
   statSync as statSync7,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync10
 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import os13 from "node:os";
@@ -69953,7 +70032,7 @@ function buildSetupPreview(values, opts = {}) {
     if (target?.ok) {
       const root = target.root;
       const gitignorePath = path40.join(root, ".gitignore");
-      const existing = existsSync17(gitignorePath) ? readFileSync18(gitignorePath, "utf8") : "";
+      const existing = existsSync17(gitignorePath) ? readFileSync19(gitignorePath, "utf8") : "";
       const existingLines = new Set(existing.split(`
 `).map((l) => l.trim()).filter(Boolean));
       const entries = GITIGNORE_ENTRIES.filter((e) => e.trim() !== "" && !existingLines.has(e.trim()));
@@ -70017,7 +70096,7 @@ function applyMutation(m) {
         return { platform: "core", file: m.path, status: "Skipped", detail: "already configured" };
       }
       mkdirSync9(dir, { recursive: true });
-      writeFileSync9(m.path, JSON.stringify(merged, null, 2) + `
+      writeFileSync10(m.path, JSON.stringify(merged, null, 2) + `
 `, "utf8");
       return existing.kind === "record" ? { platform: "core", file: m.path, status: "Configured" } : { platform: "core", file: m.path, status: "Installed" };
     }
@@ -70061,7 +70140,7 @@ function applyMutation(m) {
       mkdirSync9(dir, { recursive: true });
       const tmp = `${m.path}.${process.pid}.tmp`;
       try {
-        writeFileSync9(tmp, next, "utf8");
+        writeFileSync10(tmp, next, "utf8");
         if (workspacesRevision(readFileSafe(m.path)) !== m.expectedRevision) {
           rmSync5(tmp, { force: true });
           return {
@@ -70100,7 +70179,7 @@ function applyMutation(m) {
       const separator = existing && !existing.endsWith(`
 `) ? `
 ` : "";
-      writeFileSync9(m.path, existing + separator + (existing ? `
+      writeFileSync10(m.path, existing + separator + (existing ? `
 ` : "") + add.join(`
 `) + `
 `, "utf8");
@@ -70140,7 +70219,7 @@ function applyMutation(m) {
         };
       }
       mkdirSync9(path40.dirname(m.path), { recursive: true });
-      writeFileSync9(m.path, JSON.stringify(merged, null, 2) + `
+      writeFileSync10(m.path, JSON.stringify(merged, null, 2) + `
 `, "utf8");
       return existing.kind === "record" ? { platform: "core", file: m.path, status: "Configured" } : { platform: "core", file: m.path, status: "Installed" };
     }
@@ -70212,7 +70291,7 @@ function applyOpenCode(root, res) {
       detail: "already registered"
     };
   }
-  writeFileSync9(res.opencodeConfig, JSON.stringify(merged.config, null, 2) + `
+  writeFileSync10(res.opencodeConfig, JSON.stringify(merged.config, null, 2) + `
 `, "utf8");
   return existing.kind === "record" ? {
     platform: "opencode",
@@ -70247,12 +70326,12 @@ function copyPluginDir(src, dest) {
     });
     const stagedHooks = path40.join(stage, CURSOR_HOOKS_FILE);
     if (existsSync17(stagedHooks))
-      writeFileSync9(stagedHooks, localizedCursorHooks(readFileSync18(stagedHooks), dest));
+      writeFileSync10(stagedHooks, localizedCursorHooks(readFileSync19(stagedHooks), dest));
     for (const [name, content] of rules) {
       mkdirSync9(path40.join(stage, "rules"), { recursive: true });
-      writeFileSync9(path40.join(stage, "rules", name), content);
+      writeFileSync10(path40.join(stage, "rules", name), content);
     }
-    writeFileSync9(path40.join(stage, ".workit-root"), realSrc + `
+    writeFileSync10(path40.join(stage, ".workit-root"), realSrc + `
 `, "utf8");
     if (!samePluginContent(realSrc, stage, dest))
       throw new Error("staged adapter content is incomplete");
@@ -70294,7 +70373,7 @@ function applyCursorSettings(root, res) {
       detail: "already registered"
     };
   }
-  writeFileSync9(res.cursorSettings, JSON.stringify(settings.config, null, 2) + `
+  writeFileSync10(res.cursorSettings, JSON.stringify(settings.config, null, 2) + `
 `, "utf8");
   return {
     platform: "cursor",
@@ -70333,7 +70412,7 @@ function applyCursorMcp(root, res) {
       detail: "already registered"
     };
   }
-  writeFileSync9(res.cursorMcp, JSON.stringify(mcp.config, null, 2) + `
+  writeFileSync10(res.cursorMcp, JSON.stringify(mcp.config, null, 2) + `
 `, "utf8");
   return {
     platform: "cursor",
@@ -70602,7 +70681,7 @@ var TOKEN_PLACEHOLDER3 = "YOUR_TOKEN_HERE", YT_OVERRIDES, VCS_OVERRIDES, SETUP_O
   return configured ?? fallback;
 }, readConfigRecord = (file) => {
   try {
-    const value = JSON.parse(readFileSync18(file, "utf8"));
+    const value = JSON.parse(readFileSync19(file, "utf8"));
     return isRecord6(value) ? value : null;
   } catch {
     return null;
@@ -70623,7 +70702,7 @@ var TOKEN_PLACEHOLDER3 = "YOUR_TOKEN_HERE", YT_OVERRIDES, VCS_OVERRIDES, SETUP_O
 }, isRecord6 = (v) => v !== null && typeof v === "object" && !Array.isArray(v), readExisting = (p) => {
   let raw;
   try {
-    raw = readFileSync18(p, "utf8");
+    raw = readFileSync19(p, "utf8");
   } catch {
     if (existsSync17(p))
       return { kind: "malformed", error: `${p} is not readable` };
@@ -70640,7 +70719,7 @@ var TOKEN_PLACEHOLDER3 = "YOUR_TOKEN_HERE", YT_OVERRIDES, VCS_OVERRIDES, SETUP_O
   return { kind: "malformed", error: `${p} is not a JSON object` };
 }, readFileSafe = (p) => {
   try {
-    return readFileSync18(p, "utf8");
+    return readFileSync19(p, "utf8");
   } catch {
     return null;
   }
@@ -70655,7 +70734,7 @@ var TOKEN_PLACEHOLDER3 = "YOUR_TOKEN_HERE", YT_OVERRIDES, VCS_OVERRIDES, SETUP_O
   }
 }, isAdapter = (root, platform) => {
   try {
-    const pkg = JSON.parse(readFileSync18(path40.join(root, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync19(path40.join(root, "package.json"), "utf8"));
     return pkg.name === `@brainervirus/workit-${platform}`;
   } catch {
     return false;
@@ -70704,8 +70783,8 @@ var TOKEN_PLACEHOLDER3 = "YOUR_TOKEN_HERE", YT_OVERRIDES, VCS_OVERRIDES, SETUP_O
         if (!statSync7(installed).isDirectory() || !samePluginContent(source, installed, pluginDir, rel))
           return false;
       } else {
-        const expected = rel === CURSOR_HOOKS_FILE ? localizedCursorHooks(readFileSync18(source), pluginDir) : readFileSync18(source);
-        if (!expected.equals(readFileSync18(installed)))
+        const expected = rel === CURSOR_HOOKS_FILE ? localizedCursorHooks(readFileSync19(source), pluginDir) : readFileSync19(source);
+        if (!expected.equals(readFileSync19(installed)))
           return false;
       }
     }
@@ -70733,7 +70812,7 @@ var TOKEN_PLACEHOLDER3 = "YOUR_TOKEN_HERE", YT_OVERRIDES, VCS_OVERRIDES, SETUP_O
         continue;
       if (existsSync17(path40.join(sourceRules, entry.name)))
         continue;
-      preserved.set(entry.name, readFileSync18(path40.join(installedRules, entry.name)));
+      preserved.set(entry.name, readFileSync19(path40.join(installedRules, entry.name)));
     }
   } catch {}
   return preserved;
@@ -70788,7 +70867,7 @@ var init_setup = __esm(() => {
 });
 
 // packages/workit-core/src/core/workspace-branch-policy.ts
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync19, renameSync as renameSync6, rmSync as rmSync6, writeFileSync as writeFileSync10 } from "node:fs";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync20, renameSync as renameSync6, rmSync as rmSync6, writeFileSync as writeFileSync11 } from "node:fs";
 import path41 from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual3 } from "node:util";
 function applyWorkspaceBranchPolicy(opts) {
@@ -70857,7 +70936,7 @@ function applyWorkspaceBranchPolicy(opts) {
   mkdirSync10(path41.dirname(wsPath), { recursive: true });
   const tmp = `${wsPath}.${process.pid}.tmp`;
   try {
-    writeFileSync10(tmp, JSON.stringify({ ...document2, workspaces: next }, null, 2) + `
+    writeFileSync11(tmp, JSON.stringify({ ...document2, workspaces: next }, null, 2) + `
 `, "utf8");
     if (workspacesRevision(readFileSafe2(wsPath)) !== revision) {
       rmSync6(tmp, { force: true });
@@ -70886,7 +70965,7 @@ function applyWorkspaceBranchPolicy(opts) {
 }
 var readFileSafe2 = (p) => {
   try {
-    return readFileSync19(p, "utf8");
+    return readFileSync20(p, "utf8");
   } catch {
     return null;
   }
@@ -71726,7 +71805,7 @@ var init_wizard_state = __esm(() => {
 });
 
 // packages/workit-cli/src/admin/uninstall.ts
-import { existsSync as existsSync19, readFileSync as readFileSync20, realpathSync as realpathSync9, rmSync as rmSync7, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync21, realpathSync as realpathSync9, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "node:fs";
 import os14 from "node:os";
 import path43 from "node:path";
 function cleanCursorSettings(settings, pluginDir) {
@@ -71988,7 +72067,7 @@ var resolveUninstallPaths = (options = {}) => {
 }, isRecord7 = (v) => v !== null && typeof v === "object" && !Array.isArray(v), readJsonRecord = (file) => {
   let raw;
   try {
-    raw = readFileSync20(file, "utf8");
+    raw = readFileSync21(file, "utf8");
   } catch {
     if (existsSync19(file))
       return { kind: "malformed", error: `${file} is not readable` };
@@ -72053,7 +72132,7 @@ var resolveUninstallPaths = (options = {}) => {
 `;
   let current;
   try {
-    current = readFileSync20(target, "utf8");
+    current = readFileSync21(target, "utf8");
   } catch (error) {
     return {
       status: "failed",
@@ -72064,7 +72143,7 @@ var resolveUninstallPaths = (options = {}) => {
     return { status: "skipped", detail: "already clean" };
   }
   try {
-    writeFileSync11(target, serialized, "utf8");
+    writeFileSync12(target, serialized, "utf8");
   } catch (error) {
     return {
       status: "failed",
@@ -74839,7 +74918,7 @@ var init_setup2 = __esm(() => {
 });
 
 // packages/workit-cli/src/upgrade/shared.ts
-import { existsSync as existsSync20, readFileSync as readFileSync21 } from "node:fs";
+import { existsSync as existsSync20, readFileSync as readFileSync22 } from "node:fs";
 import path44 from "node:path";
 import os16 from "node:os";
 import { createHash as createHash15 } from "node:crypto";
@@ -74876,7 +74955,7 @@ var LAUNCH_HOSTS, HOSTS2, LIVE_HOSTS, OPENCODE_PACKAGE = "@brainervirus/workit-o
     return null;
   let data;
   try {
-    data = JSON.parse(readFileSync21(file, "utf8"));
+    data = JSON.parse(readFileSync22(file, "utf8"));
   } catch {
     throw new Error(`${file} is not valid JSON; use the native host to inspect JSONC settings`);
   }
@@ -74889,7 +74968,7 @@ var LAUNCH_HOSTS, HOSTS2, LIVE_HOSTS, OPENCODE_PACKAGE = "@brainervirus/workit-o
   } catch {
     return null;
   }
-}, digest2 = (file) => existsSync20(file) ? createHash15("sha256").update(readFileSync21(file)).digest("hex") : "missing", runner = (deps) => deps.run ?? ((command, args) => {
+}, digest2 = (file) => existsSync20(file) ? createHash15("sha256").update(readFileSync22(file)).digest("hex") : "missing", runner = (deps) => deps.run ?? ((command, args) => {
   const { home, env } = upgradePaths(deps);
   let step;
   try {
@@ -75350,7 +75429,7 @@ var init_apply = __esm(() => {
 });
 
 // packages/workit-cli/src/upgrade/plan.ts
-import { existsSync as existsSync22, mkdtempSync as mkdtempSync3, rmSync as rmSync8, lstatSync as lstatSync7, readFileSync as readFileSync22 } from "node:fs";
+import { existsSync as existsSync22, mkdtempSync as mkdtempSync3, rmSync as rmSync8, lstatSync as lstatSync7, readFileSync as readFileSync23 } from "node:fs";
 import path47 from "node:path";
 import os17 from "node:os";
 function previewUpgrade(hosts = HOSTS2, deps = {}) {
@@ -75504,7 +75583,7 @@ function previewUpgrade(hosts = HOSTS2, deps = {}) {
 var codexRegistered = (configFile) => {
   let text;
   try {
-    text = readFileSync22(configFile, "utf8");
+    text = readFileSync23(configFile, "utf8");
   } catch {
     return false;
   }
@@ -77790,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,
@@ -77831,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);
@@ -77853,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);
@@ -77974,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 = {
@@ -77988,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 {
@@ -77996,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) {
@@ -78150,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) => {
@@ -78184,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;
 });
@@ -78204,7 +78418,6 @@ __export(exports_check, {
   OUTPUT_LINES: () => OUTPUT_LINES,
   boundedOutput: () => boundedOutput,
   countWarnings: () => countWarnings,
-  hostToolWaitCapMs: () => hostToolWaitCapMs,
   run: () => run12,
   workspaceResources: () => workspaceResources
 });
@@ -78227,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];
@@ -78250,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)
@@ -78259,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")
@@ -78392,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;
@@ -78441,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;
   }
@@ -78548,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}
@@ -78569,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,
@@ -78578,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
@@ -78690,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)
@@ -78707,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();
@@ -78745,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);
@@ -78780,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"
       }));
@@ -78792,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);
@@ -78887,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();
 };
@@ -78904,7 +79160,7 @@ var exports_models = {};
 __export(exports_models, {
   run: () => run14
 });
-import { existsSync as existsSync24, readdirSync as readdirSync13, readFileSync as readFileSync23, statSync as statSync9 } from "node:fs";
+import { existsSync as existsSync24, readdirSync as readdirSync13, readFileSync as readFileSync24, statSync as statSync9 } from "node:fs";
 import os22 from "node:os";
 import path55 from "node:path";
 async function run14(argv, io) {
@@ -78967,7 +79223,7 @@ var USAGE8 = "workit models show [--role <role>] [--tier <tier>] [--host <host>]
   const found = new Set;
   let text = "";
   try {
-    text = readFileSync23(file, "utf8");
+    text = readFileSync24(file, "utf8");
   } catch {
     return found;
   }
@@ -78998,7 +79254,7 @@ var USAGE8 = "workit models show [--role <role>] [--tier <tier>] [--host <host>]
         try {
           if (statSync9(meta).mtimeMs < since)
             continue;
-          const agentType = JSON.parse(readFileSync23(meta, "utf8")).agentType;
+          const agentType = JSON.parse(readFileSync24(meta, "utf8")).agentType;
           const transcript = meta.replace(/\.meta\.json$/, ".jsonl");
           if (typeof agentType !== "string" || !existsSync24(transcript))
             continue;
@@ -79139,7 +79395,7 @@ var success2 = (data) => ({ ok: true, data }), failure3 = (code, error, unblock)
 
 // packages/workit-core/src/git/ops.ts
 import { spawnSync as spawnSync20 } from "node:child_process";
-import { existsSync as existsSync25, readFileSync as readFileSync24 } from "node:fs";
+import { existsSync as existsSync25, readFileSync as readFileSync25 } from "node:fs";
 import path56 from "node:path";
 function operationInProgress(cwd) {
   const markers = [
@@ -79164,7 +79420,7 @@ function operationInProgress(cwd) {
     if (index === 0 && existsSync25(path56.join(marker, "amend")) && !conflicted()) {
       let headName = "";
       try {
-        headName = readFileSync24(path56.join(marker, "head-name"), "utf8").trim();
+        headName = readFileSync25(path56.join(marker, "head-name"), "utf8").trim();
       } catch {}
       const branch = headName.startsWith("refs/heads/") ? headName.slice("refs/heads/".length) : null;
       return { operation, commitAllowed: branch !== null, branch };
@@ -85860,7 +86116,7 @@ var init_duration = __esm(() => {
 });
 
 // packages/workit-cli/src/verbs/forge-common.ts
-import { readFileSync as readFileSync25 } from "node:fs";
+import { readFileSync as readFileSync26 } from "node:fs";
 function parseFlags(argv, spec) {
   const parsed = { values: {}, booleans: new Set, lists: {}, positionals: [] };
   for (let index = 0;index < argv.length; index += 1) {
@@ -86015,7 +86271,7 @@ var init_forge_common = __esm(() => {
   forgeDeps = {
     runner: undefined,
     npm: undefined,
-    readStdin: () => readFileSync25(0, "utf8"),
+    readStdin: () => readFileSync26(0, "utf8"),
     sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     now: () => Date.now()
   };
@@ -86026,12 +86282,12 @@ var exports_pr = {};
 __export(exports_pr, {
   run: () => run15
 });
-import { readFileSync as readFileSync26 } from "node:fs";
+import { readFileSync as readFileSync27 } from "node:fs";
 import path66 from "node:path";
 function readBodyFile(io, file) {
   try {
     return {
-      body: file === "-" ? forgeDeps.readStdin() : readFileSync26(path66.resolve(io.cwd, file), "utf8")
+      body: file === "-" ? forgeDeps.readStdin() : readFileSync27(path66.resolve(io.cwd, file), "utf8")
     };
   } catch {
     return `cannot read --body-file ${file}`;
@@ -86835,7 +87091,7 @@ var exports_git = {};
 __export(exports_git, {
   run: () => run17
 });
-import { readFileSync as readFileSync27 } from "node:fs";
+import { readFileSync as readFileSync28 } from "node:fs";
 import path67 from "node:path";
 function kindHint(cwd, kind) {
   let kinds = [...BRANCH_KINDS];
@@ -86940,7 +87196,7 @@ function commitMessage(parsed, io) {
 
 `);
   try {
-    return file === "-" ? readFileSync27(0, "utf8") : readFileSync27(path67.resolve(io.cwd, file), "utf8");
+    return file === "-" ? readFileSync28(0, "utf8") : readFileSync28(path67.resolve(io.cwd, file), "utf8");
   } catch (error) {
     return {
       error: `cannot read -F ${file}: ${error instanceof Error ? error.message : String(error)}`
@@ -88101,6 +88357,11 @@ async function run19(argv, io) {
   if (!result.ok)
     return forgeFail(io, result);
   const report = result.data;
+  if (report.delivered && expect === "merged") {
+    try {
+      closeDeliveredTasks(new TaskStore(io.cwd), new Date().toISOString().replace(/\.\d{3}Z$/, "Z"));
+    } catch {}
+  }
   if (report.delivered)
     return emit(io, ok2(report), render2);
   const failed = report.observations.filter((entry) => !entry.ok);
@@ -88119,6 +88380,8 @@ var USAGE12 = "workit verify-delivery [push|pr|merge|release] [--expect pushed|p
 ];
 var init_verify_delivery = __esm(() => {
   init_verify();
+  init_task_store();
+  init_task_delivery();
   init_ledger();
   init_output();
   init_forge_common();
@@ -105693,7 +105956,7 @@ var init_rules = __esm(() => {
 
 // packages/workit-cli/src/test-audit/audit.ts
 import { spawnSync as spawnSync29 } from "node:child_process";
-import { existsSync as existsSync26, readdirSync as readdirSync14, readFileSync as readFileSync28, statSync as statSync10 } from "node:fs";
+import { existsSync as existsSync26, readdirSync as readdirSync14, readFileSync as readFileSync29, statSync as statSync10 } from "node:fs";
 import path71 from "node:path";
 function git7(cwd, args) {
   const run = spawnSync29("git", ["-c", "core.quotepath=off", ...args], {
@@ -105773,7 +106036,7 @@ function auditFiles(files, display) {
     const shown = display(file);
     let parsed;
     try {
-      parsed = parseSource(readFileSync28(file, "utf8"), file);
+      parsed = parseSource(readFileSync29(file, "utf8"), file);
     } catch (error) {
       parseErrors.push({
         file: shown,
@@ -105841,14 +106104,14 @@ import {
   mkdirSync as mkdirSync12,
   mkdtempSync as mkdtempSync4,
   readdirSync as readdirSync15,
-  readFileSync as readFileSync29,
+  readFileSync as readFileSync30,
   readlinkSync as readlinkSync3,
   realpathSync as realpathSync10,
   renameSync as renameSync7,
   rmSync as rmSync9,
   statSync as statSync11,
   symlinkSync,
-  writeFileSync as writeFileSync12,
+  writeFileSync as writeFileSync13,
   copyFileSync as copyFileSync8
 } from "node:fs";
 import os23 from "node:os";
@@ -105950,7 +106213,7 @@ function removeStaleCopies(tmp = os23.tmpdir()) {
       const stat = lstatSync8(dir);
       if (!stat.isDirectory() || uid !== undefined && stat.uid !== uid)
         continue;
-      const pid = Number(readFileSync29(path72.join(dir, PID_FILE), "utf8"));
+      const pid = Number(readFileSync30(path72.join(dir, PID_FILE), "utf8"));
       if (Number.isInteger(pid) && pid > 0 && alive(pid))
         continue;
     } catch (error) {
@@ -106020,13 +106283,13 @@ function writeInside(copy, file, content) {
     return false;
   }
   const temp = `${target}.workit-mutant-${process.pid}`;
-  writeFileSync12(temp, content);
+  writeFileSync13(temp, content);
   renameSync7(temp, target);
   return true;
 }
 function copyWorkingTree(repo) {
   const dir = mkdtempSync4(path72.join(os23.tmpdir(), TEMP_PREFIX));
-  writeFileSync12(path72.join(dir, PID_FILE), String(process.pid));
+  writeFileSync13(path72.join(dir, PID_FILE), String(process.pid));
   const tree = path72.join(dir, "tree");
   const head = git7(repo, ["rev-parse", "--verify", "--quiet", "HEAD"]).stdout.trim();
   if (head && git7(dir, ["clone", "-q", "--shared", "--no-checkout", repo, tree]).ok) {
@@ -106105,7 +106368,7 @@ async function runMutation(options) {
   const tracked = git7(repo, ["ls-files", "-co", "--exclude-standard", "-z"]).stdout.split("\x00").filter(Boolean);
   const testFiles = tracked.filter((file) => TEST_FILE.test(file)).map((file) => {
     try {
-      return { file, text: readFileSync29(path72.join(repo, file), "utf8") };
+      return { file, text: readFileSync30(path72.join(repo, file), "utf8") };
     } catch {
       return { file, text: "" };
     }
@@ -106118,7 +106381,7 @@ async function runMutation(options) {
     if (NOT_SOURCE.test(relative) || !existsSync27(absolute))
       continue;
     try {
-      candidates.push(...mutantsFor(readFileSync29(absolute, "utf8"), relative, lines));
+      candidates.push(...mutantsFor(readFileSync30(absolute, "utf8"), relative, lines));
     } catch {}
   }
   const mutants = candidates.map((mutant, index) => ({ ...mutant, id: index + 1 }));
@@ -106199,7 +106462,7 @@ async function runMutation(options) {
         record({ ...mutant, status: "skipped", durationMs: 0, tests, reason: "budget" });
         continue;
       }
-      const original = readFileSync29(path72.join(copy, mutant.file), "utf8");
+      const original = readFileSync30(path72.join(copy, mutant.file), "utf8");
       const mutated = original.slice(0, mutant.start) + mutant.replacement + original.slice(mutant.end);
       current = { file: mutant.file, original };
       if (!writeInside(copy, mutant.file, mutated)) {
@@ -106550,7 +106813,7 @@ var exports_youtrack = {};
 __export(exports_youtrack, {
   run: () => run25
 });
-import { readFileSync as readFileSync30 } from "node:fs";
+import { readFileSync as readFileSync31 } from "node:fs";
 import path74 from "node:path";
 async function run25(argv, io) {
   const [sub, ...rest] = argv;
@@ -106597,7 +106860,7 @@ async function run25(argv, io) {
     let markdown = flags.values.markdown ?? "";
     if (flags.values.file)
       try {
-        markdown = readFileSync30(path74.resolve(io.cwd, flags.values.file), "utf8");
+        markdown = readFileSync31(path74.resolve(io.cwd, flags.values.file), "utf8");
       } catch (error) {
         return usage4(io, `cannot read ${flags.values.file}: ${String(error)}`, USAGE18);
       }
@@ -106665,7 +106928,7 @@ var exports_changelog = {};
 __export(exports_changelog, {
   run: () => run26
 });
-import { readFileSync as readFileSync31 } from "node:fs";
+import { readFileSync as readFileSync32 } from "node:fs";
 import path75 from "node:path";
 async function run26(argv, io) {
   const [sub, ...rest] = argv;
@@ -106712,7 +106975,7 @@ async function run26(argv, io) {
   ]);
 }
 var USAGE19 = "workit changelog apply (--entries <JSON|@file|-> | --normalize-only) [--path CHANGELOG.md] [--preview]", readEntries = (raw, cwd) => {
-  const text = raw === "-" ? readFileSync31(0, "utf8") : raw.startsWith("@") ? readFileSync31(path75.resolve(cwd, raw.slice(1)), "utf8") : raw;
+  const text = raw === "-" ? readFileSync32(0, "utf8") : raw.startsWith("@") ? readFileSync32(path75.resolve(cwd, raw.slice(1)), "utf8") : raw;
   return JSON.parse(text);
 };
 var init_changelog2 = __esm(() => {
@@ -106955,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."
 ];
@@ -107074,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)"
     },
@@ -107082,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"'
     ],
@@ -107096,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…>"
       },
       {