@joshuafolkken/kit 1.1229.0 → 1.1240.0

package/dist/hooks/{chunk-55HHG5PX.js → chunk-WK2XSHSI.js}

@@ -309,10 +309,16 @@ var ISSUE_COMMANDS = {
     description: "File an Issue with every filing step: lint, Origin, WIP cap, duplicate scout, labels, then epic:bundle",
     category: "AI tools",
     reference: [
-      "<title> --body-file <path> --depth <0|1|2> [--route <route>] [--label <name>] [--repo <owner/repo>] [--distinct <N,\u2026>] [--over-cap] [--no-auto-ok]",
+      "<title> --body-file <path> --depth <0|1|2> [--route <route>] [--label <name>] [--repo <owner/repo>] [--distinct <N,\u2026>] [--over-cap] [--no-auto-ok] [--release]",
       "automation",
       ["network"]
     ]
+  },
+  "issue:release": {
+    script: "scripts/issue/issue-release-cli.ts",
+    description: "Link an Issue to the repository's open release Issue as its blocker, filing one when none is open",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["network"]]
   }
 };
 
@@ -348,7 +354,7 @@ var LANE_COMMANDS = {
   },
   "lane:prune": {
     ...LANE_ARGUMENTS,
-    description: "Close every lane an interruption left without its work tree",
+    description: "Close every lane an interruption left without its work tree, then sweep unregistered leftovers under the lanes root",
     category: "AI tools",
     reference: ["", "automation", ["files", "git"]],
     default_script_arguments: ["prune"]
@@ -741,7 +747,7 @@ var CLONE_COMMANDS = {
 // scripts/gate/core-budget.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { readdirSync as readdirSync2 } from "node:fs";
-import { availableParallelism as availableParallelism2 } from "node:os";
+import { availableParallelism as availableParallelism3 } from "node:os";
 import path3 from "node:path";
 
 // scripts/josh/process-identity.ts
@@ -1016,6 +1022,159 @@ var unit_worker_share = {
 
 // scripts/gate/core-budget.ts
 import { z as z3 } from "zod";
+
+// scripts/gate/core-admission.ts
+var MS_PER_SECOND = 1e3;
+var RAMP_UP_MS = 3e4;
+function compare_claim(left, right) {
+  const by_time = left.reservation.claimed_at - right.reservation.claimed_at;
+  return by_time === 0 ? left.key.localeCompare(right.key) : by_time;
+}
+function add_load(totals, reservation) {
+  totals.cores += reservation.weight;
+  totals.memory_mb += reservation.memory_mb ?? 0;
+}
+function exceeds(totals, budget) {
+  return totals.cores > budget.cores || totals.memory_mb > budget.memory_mb;
+}
+function admitted_keys(reservations, budget, memory_budget = Infinity) {
+  const limit = { cores: budget, memory_mb: memory_budget };
+  const totals = { cores: 0, memory_mb: 0 };
+  const admitted = /* @__PURE__ */ new Set();
+  for (const [index, entry] of reservations.toSorted(compare_claim).entries()) {
+    add_load(totals, entry.reservation);
+    if (index !== 0 && exceeds(totals, limit)) break;
+    admitted.add(entry.key);
+  }
+  return admitted;
+}
+function is_admitted(key, reservations, budget) {
+  return admitted_keys(reservations, budget.cores, budget.memory_mb).has(key);
+}
+function sum_load(reservations) {
+  const load = { cores: 0, memory_mb: 0 };
+  for (const entry of reservations) add_load(load, entry.reservation);
+  return load;
+}
+function is_ramped(reservation, now) {
+  const { admitted_at } = reservation;
+  return admitted_at !== void 0 && now - admitted_at >= RAMP_UP_MS;
+}
+function ledger_load(reservations, now) {
+  const admitted = reservations.filter((entry) => entry.reservation.admitted_at !== void 0);
+  const ramped = admitted.filter((entry) => is_ramped(entry.reservation, now));
+  return { cores: sum_load(admitted).cores, memory_mb: sum_load(ramped).memory_mb };
+}
+function total_weight(reservations) {
+  return sum_load(reservations).cores;
+}
+function admitted_load(reservations, budget) {
+  const admitted = admitted_keys(reservations, budget);
+  return total_weight(reservations.filter((entry) => admitted.has(entry.key)));
+}
+function describe_memory(ledger, budget) {
+  if (!Number.isFinite(budget.memory_mb)) return "";
+  return ` and ${String(Math.round(ledger.memory_mb))} MB of memory against ${String(Math.round(budget.memory_mb))} MB`;
+}
+function describe_overflow(admission) {
+  const { overflow } = admission;
+  if (overflow === void 0) return void 0;
+  const { ledger, budget } = overflow;
+  const waited = String(Math.round(overflow.waited_ms / MS_PER_SECOND));
+  const cores = `the ledger held ${String(ledger.cores)} cores against a budget of ${String(budget.cores)}`;
+  return `started past the core budget after ${waited}s \u2014 ${cores}${describe_memory(ledger, budget)}`;
+}
+var core_admission = {
+  RAMP_UP_MS,
+  admitted_keys,
+  admitted_load,
+  describe_overflow,
+  is_admitted,
+  ledger_load,
+  sum_load
+};
+
+// scripts/gate/machine-capacity.ts
+import { readFile } from "node:fs/promises";
+import { availableParallelism as availableParallelism2, cpus, totalmem } from "node:os";
+import { execa } from "execa";
+var SAMPLE_WINDOW_MS = 250;
+var BASELINE_CORES = 2;
+var BYTES_PER_MB = 1048576;
+var KB_PER_MB = 1024;
+var PERCENT = 100;
+var MEMINFO_PATH = "/proc/meminfo";
+var LINUX_AVAILABLE = /^MemAvailable:\s+(?<kb>\d+) kB/mu;
+var PRESSURE_ARGUMENTS = ["-n", "kern.memorystatus_level"];
+var PRESSURE_LEVEL = /^\s*(?<level>\d+)\s*$/u;
+function cpu_times() {
+  let busy = 0;
+  let idle = 0;
+  for (const { times } of cpus()) {
+    busy += times.user + times.nice + times.sys + times.irq;
+    idle += times.idle;
+  }
+  return { busy, total: busy + idle };
+}
+function busy_cores_between(before, after, cores) {
+  const total = after.total - before.total;
+  if (total <= 0) return void 0;
+  return (after.busy - before.busy) / total * cores;
+}
+function parse_darwin_pressure(output, total_bytes) {
+  const level = PRESSURE_LEVEL.exec(output)?.groups?.["level"];
+  if (level === void 0) return void 0;
+  return Number(level) / PERCENT * (total_bytes / BYTES_PER_MB);
+}
+function parse_linux_available(meminfo) {
+  const kb = LINUX_AVAILABLE.exec(meminfo)?.groups?.["kb"];
+  return kb === void 0 ? void 0 : Number(kb) / KB_PER_MB;
+}
+async function read_available_mb(platform = process.platform) {
+  try {
+    if (platform === "darwin") {
+      const { stdout } = await execa("sysctl", PRESSURE_ARGUMENTS);
+      return parse_darwin_pressure(stdout, totalmem());
+    }
+    return platform === "linux" ? parse_linux_available(await readFile(MEMINFO_PATH, "utf8")) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function is_unquoted() {
+  return cpus().length > 0 && cpus().length === availableParallelism2();
+}
+async function default_sleep(ms) {
+  await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+async function read_machine(sleep = default_sleep) {
+  const before = cpu_times();
+  const [available_mb] = await Promise.all([read_available_mb(), sleep(SAMPLE_WINDOW_MS)]);
+  const busy_cores = is_unquoted() ? busy_cores_between(before, cpu_times(), cpus().length) : void 0;
+  return { busy_cores, available_mb };
+}
+function external_cores(busy_cores, ledger_cores) {
+  if (busy_cores === void 0) return 0;
+  return Math.floor(Math.max(0, busy_cores - ledger_cores - BASELINE_CORES));
+}
+function machine_budget(cores, reading, ledger) {
+  return {
+    cores: cores - external_cores(reading.busy_cores, ledger.cores),
+    memory_mb: reading.available_mb === void 0 ? Infinity : reading.available_mb + ledger.memory_mb
+  };
+}
+var machine_capacity = {
+  BASELINE_CORES,
+  busy_cores_between,
+  machine_budget,
+  parse_darwin_pressure,
+  parse_linux_available,
+  read_machine
+};
+
+// scripts/gate/core-budget.ts
 var RESERVED_PREFIX = "josh-core-reserved-";
 var RESERVED_SUFFIX = ".json";
 var POLL_INTERVAL_MS = 50;
@@ -1027,11 +1186,20 @@ var CORE_WEIGHTS = {
   spell_check: 1,
   eslint_scan: 1
 };
+var MEMORY_MB = {
+  lint: 2400,
+  type_check: 1300,
+  spell_check: 350,
+  eslint_scan: 2400,
+  unit_worker: 350
+};
 var HELD_KEY = "JOSH_CORE_RESERVED";
 var HELD_VALUE = "1";
 var reservation_schema = process_owner_schema.extend({
   weight: z3.number(),
-  claimed_at: z3.number()
+  claimed_at: z3.number(),
+  memory_mb: z3.number().optional(),
+  admitted_at: z3.number().optional()
 });
 function marker_name(key) {
   return `${RESERVED_PREFIX}${key}${RESERVED_SUFFIX}`;
@@ -1064,7 +1232,9 @@ function live_reservation(source) {
 }
 function marker_files2(directory) {
   try {
-    return readdirSync2(directory).filter((name) => name.startsWith(RESERVED_PREFIX));
+    return readdirSync2(directory).filter(
+      (name) => name.startsWith(RESERVED_PREFIX) && name.endsWith(RESERVED_SUFFIX)
+    );
   } catch {
     return [];
   }
@@ -1075,67 +1245,79 @@ function live_reservations(directory = PLATFORM_TEMP_ROOT) {
     return reservation === void 0 ? [] : { key: name, reservation };
   });
 }
-function compare_claim(left, right) {
-  const by_time = left.reservation.claimed_at - right.reservation.claimed_at;
-  return by_time === 0 ? left.key.localeCompare(right.key) : by_time;
-}
-function admitted_keys(reservations, budget) {
-  const admitted = /* @__PURE__ */ new Set();
-  let cumulative = 0;
-  for (const [index, entry] of reservations.toSorted(compare_claim).entries()) {
-    cumulative += entry.reservation.weight;
-    if (index !== 0 && cumulative > budget) break;
-    admitted.add(entry.key);
-  }
-  return admitted;
-}
-function is_admitted(key, reservations, budget) {
-  return admitted_keys(reservations, budget).has(key);
-}
-function admitted_load(reservations, budget) {
-  const admitted = admitted_keys(reservations, budget);
-  return reservations.filter((entry) => admitted.has(entry.key)).reduce((total, entry) => total + entry.reservation.weight, 0);
-}
 function normalize_budget(budget) {
   return Number.isFinite(budget) ? Math.max(MIN_BUDGET, Math.floor(budget)) : MIN_BUDGET;
 }
-async function default_sleep(ms) {
+async function default_sleep2(ms) {
   await new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
 }
-function write_reservation(target, weight, claimed_at) {
-  stamp_file.write_stamp(target, { ...process_identity.own_fields(), weight, claimed_at });
+function write_reservation(target, fields) {
+  stamp_file.replace_stamp(target, { ...process_identity.own_fields(), ...fields });
 }
 function resolve_timing(options) {
   return {
     now: options.now ?? Date.now,
-    sleep: options.sleep ?? default_sleep,
-    poll_interval_ms: options.poll_interval_ms ?? POLL_INTERVAL_MS
+    sleep: options.sleep ?? default_sleep2,
+    poll_interval_ms: options.poll_interval_ms ?? POLL_INTERVAL_MS,
+    wait_cap_ms: options.wait_cap_ms ?? WAIT_CAP_MS
   };
 }
+async function current_budget(context, reservations) {
+  if (reservations.length <= 1) return { cores: context.budget, memory_mb: Infinity };
+  const reading = await context.read_machine();
+  const ledger = core_admission.ledger_load(reservations, context.now());
+  const budget = machine_capacity.machine_budget(context.budget, reading, ledger);
+  return { ...budget, cores: normalize_budget(budget.cores) };
+}
+function admit(context, overflow) {
+  write_reservation(context.target, { ...context.fields, admitted_at: context.now() });
+  return { overflow };
+}
+function overflow_of(context, reservations, budget) {
+  return {
+    waited_ms: context.now() - context.fields.claimed_at,
+    ledger: core_admission.sum_load(reservations),
+    budget
+  };
+}
+async function poll_admission(context) {
+  const reservations = live_reservations(context.directory);
+  const budget = await current_budget(context, reservations);
+  if (core_admission.is_admitted(context.key, reservations, budget)) return admit(context);
+  if (context.now() >= context.deadline) {
+    return admit(context, overflow_of(context, reservations, budget));
+  }
+  return void 0;
+}
 async function await_admission(context) {
-  while (!is_admitted(context.key, live_reservations(context.directory), context.budget)) {
-    if (context.now() >= context.deadline) return;
+  let admission = await poll_admission(context);
+  while (admission === void 0) {
     await context.sleep(context.poll_interval_ms);
+    admission = await poll_admission(context);
   }
+  return admission;
 }
 async function reserve(weight, options = {}) {
   const timing = resolve_timing(options);
   const directory = options.directory ?? PLATFORM_TEMP_ROOT;
-  const budget = normalize_budget(options.budget ?? availableParallelism2());
   const claimed_at = timing.now();
   const name = marker_name(randomUUID2());
   const target = path3.join(directory, name);
-  write_reservation(target, weight, claimed_at);
-  await await_admission({
+  const fields = { weight, claimed_at, memory_mb: options.memory_mb };
+  write_reservation(target, fields);
+  const admission = await await_admission({
     ...timing,
     key: name,
+    target,
     directory,
-    budget,
-    deadline: claimed_at + (options.wait_cap_ms ?? WAIT_CAP_MS)
+    budget: normalize_budget(options.budget ?? availableParallelism3()),
+    deadline: claimed_at + timing.wait_cap_ms,
+    fields,
+    read_machine: options.read_machine ?? machine_capacity.read_machine
   });
-  return { target };
+  return { target, admission };
 }
 function release(handle) {
   sweep_marker2(handle.target);
@@ -1143,7 +1325,7 @@ function release(handle) {
 async function with_core_reservation(weight, run, options = {}) {
   const handle = await reserve(weight, options);
   try {
-    return await run();
+    return await run(handle.admission);
   } finally {
     release(handle);
   }
@@ -1171,9 +1353,11 @@ var core_budget = {
   CORE_WEIGHTS,
   HELD_KEY,
   HELD_VALUE,
+  MEMORY_MB,
   RESERVED_PREFIX,
-  admitted_keys,
-  admitted_load,
+  admitted_keys: core_admission.admitted_keys,
+  admitted_load: core_admission.admitted_load,
+  describe_overflow: core_admission.describe_overflow,
   is_held,
   live_reservations,
   release,
@@ -1184,7 +1368,7 @@ var core_budget = {
 };
 
 // scripts/gate/gate-plan.ts
-import { availableParallelism as availableParallelism3 } from "node:os";
+import { availableParallelism as availableParallelism4 } from "node:os";
 
 // scripts/lib/status-icons.ts
 var FAIL_ICON = "\u2717";
@@ -1234,13 +1418,24 @@ var UNIT_LABEL = "test:unit";
 var BEHAVIOR_LABEL = "behavior";
 var WARNING_CHECKER_LABELS = [LINT_LABEL, TYPE_CHECK_LABEL];
 var STATIC_CHECKS = [
-  { label: LINT_LABEL, target: "lint", reserved_cores: core_budget.CORE_WEIGHTS.lint },
+  {
+    label: LINT_LABEL,
+    target: "lint",
+    reserved_cores: core_budget.CORE_WEIGHTS.lint,
+    memory_mb: core_budget.MEMORY_MB.lint
+  },
   {
     label: TYPE_CHECK_LABEL,
     target: "check",
-    reserved_cores: core_budget.CORE_WEIGHTS.type_check
+    reserved_cores: core_budget.CORE_WEIGHTS.type_check,
+    memory_mb: core_budget.MEMORY_MB.type_check
+  },
+  {
+    label: "cspell",
+    target: "cspell:dot",
+    reserved_cores: core_budget.CORE_WEIGHTS.spell_check,
+    memory_mb: core_budget.MEMORY_MB.spell_check
   },
-  { label: "cspell", target: "cspell:dot", reserved_cores: core_budget.CORE_WEIGHTS.spell_check },
   { label: BEHAVIOR_LABEL, target: BEHAVIOR_LABEL, reserved_cores: 0 },
   // **The unused-member check reserves no core** (joshuafolkken/kit#2987): it builds one TypeScript
   // program and walks it for about 5s, and it is over well before lint and the type check. A
@@ -1293,14 +1488,24 @@ function check_weight(check, plan, available_cores) {
   if (check.label !== UNIT_LABEL) return check.reserved_cores;
   return plan.unit_worker_cap ?? solo_unit_weight(available_cores);
 }
-function direct_unit_weight(available_cores = availableParallelism3(), live_runs = unit_worker_share.live_run_count()) {
+function unit_memory(workers) {
+  return workers * core_budget.MEMORY_MB.unit_worker;
+}
+function check_memory(check, plan, available_cores) {
+  if (check.label !== UNIT_LABEL) return check.memory_mb ?? 0;
+  return unit_memory(check_weight(check, plan, available_cores));
+}
+function direct_unit_weight(available_cores = availableParallelism4(), live_runs = unit_worker_share.live_run_count()) {
   const weight = unit_worker_share.current_share(available_cores, live_runs) ?? solo_unit_weight(available_cores);
   return Math.max(unit_worker_share.MIN_WORKERS, weight);
 }
+function direct_unit_memory() {
+  return unit_memory(direct_unit_weight());
+}
 function plan_of(concurrency, unit_worker_cap, checks = GATE_CHECKS) {
   return { checks, concurrency, unit_worker_cap };
 }
-function resolve_gate_plan(available_cores = availableParallelism3(), concurrent_runs = unit_worker_share.SOLO_RUNS, is_unit_included = true) {
+function resolve_gate_plan(available_cores = availableParallelism4(), concurrent_runs = unit_worker_share.SOLO_RUNS, is_unit_included = true) {
   const checks = select_gate_checks(is_unit_included);
   return {
     checks,
@@ -1318,7 +1523,7 @@ function format_unit_cap(plan) {
   if (plan.unit_worker_cap === void 0) return `${UNIT_LABEL} unrestricted`;
   return `${UNIT_LABEL} at ${String(plan.unit_worker_cap)} workers`;
 }
-function format_gate_plan(plan, available_cores = availableParallelism3(), concurrent_runs = unit_worker_share.SOLO_RUNS) {
+function format_gate_plan(plan, available_cores = availableParallelism4(), concurrent_runs = unit_worker_share.SOLO_RUNS) {
   const cap = format_unit_cap(plan);
   const count = `${String(plan.concurrency)} of ${String(plan.checks.length)}`;
   const width = `${count}${josh_verdict.GATE_OPENING_MARK}`;
@@ -1334,7 +1539,9 @@ var gate_plan = {
   TYPE_CHECK_LABEL,
   UNIT_LABEL,
   WARNING_CHECKER_LABELS,
+  check_memory,
   check_weight,
+  direct_unit_memory,
   direct_unit_weight,
   format_gate_plan,
   format_machine,
@@ -1370,28 +1577,32 @@ var DEV_COMMANDS = {
     description: "Check code with prettier and eslint (skips a tool a basic project lacks)",
     category: "Development",
     reference: ["", "developer", ["processes"]],
-    core_weight: core_budget.CORE_WEIGHTS.lint
+    core_weight: core_budget.CORE_WEIGHTS.lint,
+    memory_mb: core_budget.MEMORY_MB.lint
   },
   "lint:related": {
     script: "scripts/lint/lint-related.ts",
     description: "Check only the changed files with prettier and eslint (whole tree on fallback)",
     category: "Development",
     reference: [FILE_ARGUMENTS, "developer", ["processes"]],
-    core_weight: core_budget.CORE_WEIGHTS.lint
+    core_weight: core_budget.CORE_WEIGHTS.lint,
+    memory_mb: core_budget.MEMORY_MB.lint
   },
   lines: {
     script: "scripts/lines/lines-command.ts",
     description: "Print a file's code lines against the max-lines limit and the headroom left",
     category: "Development",
     reference: [REQUIRED_FILE_ARGUMENTS, "developer", ["none"]],
-    core_weight: core_budget.CORE_WEIGHTS.eslint_scan
+    core_weight: core_budget.CORE_WEIGHTS.eslint_scan,
+    memory_mb: core_budget.MEMORY_MB.eslint_scan
   },
   "refactor:scan": {
     script: "scripts/refactor/refactor-scan-cli.ts",
     description: "List refactoring candidates in the changed scope by category and answer clear/candidates",
     category: "Development",
     reference: ["", "automation", ["processes"]],
-    core_weight: core_budget.CORE_WEIGHTS.eslint_scan
+    core_weight: core_budget.CORE_WEIGHTS.eslint_scan,
+    memory_mb: core_budget.MEMORY_MB.eslint_scan
   },
   bytes: {
     script: "scripts/lines/bytes-command.ts",
@@ -1471,7 +1682,8 @@ var DEV_COMMANDS = {
     description: "Run spell check including dotfiles",
     category: "Development",
     reference: ["", "developer", ["processes"]],
-    core_weight: core_budget.CORE_WEIGHTS.spell_check
+    core_weight: core_budget.CORE_WEIGHTS.spell_check,
+    memory_mb: core_budget.MEMORY_MB.spell_check
   },
   behavior: {
     script: "scripts/behavior/behavior-cli.ts",
@@ -1490,14 +1702,16 @@ var DEV_COMMANDS = {
     description: "Run unit tests with Vitest (skips when Vitest is absent; fails when it has no tests)",
     category: "Development",
     reference: [FILTER_ARGUMENTS, "developer", ["processes"]],
-    core_weight: gate_plan.direct_unit_weight
+    core_weight: gate_plan.direct_unit_weight,
+    memory_mb: gate_plan.direct_unit_memory
   },
   "test:related": {
     script: "scripts/test/test-related.ts",
     description: "Run only the unit tests related to the changed files (full suite on fallback)",
     category: "Development",
     reference: [FILE_ARGUMENTS, "developer", ["processes"]],
-    core_weight: gate_plan.direct_unit_weight
+    core_weight: gate_plan.direct_unit_weight,
+    memory_mb: gate_plan.direct_unit_memory
   },
   "test:declared": {
     script: "scripts/test/test-declared.ts",
@@ -1541,7 +1755,8 @@ var DEV_COMMANDS = {
     description: "Type-check with tsc (skips a basic project with no TypeScript to check)",
     category: "Development",
     reference: ["[arguments...]", "developer", ["processes"]],
-    core_weight: core_budget.CORE_WEIGHTS.type_check
+    core_weight: core_budget.CORE_WEIGHTS.type_check,
+    memory_mb: core_budget.MEMORY_MB.type_check
   },
   port: {
     script: "scripts/ports/port-command.ts",
@@ -1662,9 +1877,9 @@ var MAINTENANCE_COMMANDS = {
     shell: [
       "sh",
       "-c",
-      "export NODE_AUTH_TOKEN=$(gh auth token) && pnpm josh latest:guard && pnpm josh latest:corepack && pnpm josh latest:update && pnpm josh ranges && pnpm josh audit && pnpm josh latest:scope --record"
+      "export NODE_AUTH_TOKEN=$(gh auth token) && pnpm josh latest:guard && pnpm josh latest:update && pnpm josh ranges && pnpm josh audit && pnpm josh latest:corepack && pnpm josh latest:scope --record"
     ],
-    description: "Update pnpm, dependencies, and run security audit",
+    description: "Update dependencies, run security audit, then update pnpm",
     category: "Maintenance",
     reference: ["", "developer", ["files", "network", "processes"]],
     argument_targets: ["latest:corepack", "latest:update", "audit"]
@@ -2479,7 +2694,7 @@ var PrConflictError = class extends Error {
 
 // scripts/time-runtime/time-format.ts
 var MS_PER_MINUTE = 6e4;
-var MS_PER_SECOND = 1e3;
+var MS_PER_SECOND2 = 1e3;
 var MINUTE_DECIMALS = 1;
 var SECOND_DECIMALS = 1;
 var PERCENT_SCALE = 100;
@@ -2499,7 +2714,7 @@ function format_minutes(duration_ms) {
   return `${(duration_ms / MS_PER_MINUTE).toFixed(MINUTE_DECIMALS)} min`;
 }
 function format_seconds(duration_ms) {
-  return `${(duration_ms / MS_PER_SECOND).toFixed(SECOND_DECIMALS)} s`;
+  return `${(duration_ms / MS_PER_SECOND2).toFixed(SECOND_DECIMALS)} s`;
 }
 function format_share(part, whole) {
   if (whole === 0) return "n/a";
@@ -2596,7 +2811,7 @@ var git_followup_stages = {
 var LINE_SEPARATOR = "\n";
 var SECONDS_SUFFIX = " s";
 var DIGIT_OR_POINT = /[\d.]/u;
-var MS_PER_SECOND2 = 1e3;
+var MS_PER_SECOND3 = 1e3;
 var NO_STAGES = [];
 function stage_body(line) {
   const trimmed = line.trimStart();
@@ -2619,7 +2834,7 @@ function to_stage(body) {
   const name = head.slice(0, start).trim();
   const digits = head.slice(start);
   if (name === "" || !is_duration(digits)) return void 0;
-  return { name, duration_ms: Number(digits) * MS_PER_SECOND2 };
+  return { name, duration_ms: Number(digits) * MS_PER_SECOND3 };
 }
 function read_stages(text) {
   if (!text.includes(git_followup_stages.STAGE_LINE_PREFIX)) return NO_STAGES;
@@ -4090,10 +4305,16 @@ function lane_issue_of(directory, environment = process.env) {
 function lane_branch(issue) {
   return `${issue}${LANE_BRANCH_SUFFIX}`;
 }
+var SEAT_LOCK_DIR = ".seat-locks";
+function is_lane_entry(name) {
+  return LANE_ISSUE_PATTERN.test(name) || DEFAULT_LANE_ROOT_PATTERN.test(name);
+}
 var lane_paths = {
   LANE_BRANCH_SUFFIX,
   LANE_ROOT_KEY,
+  SEAT_LOCK_DIR,
   default_lane_root,
+  is_lane_entry,
   lane_branch,
   lane_directory,
   lane_issue_of,

package/dist/hooks/{chunk-5VMKCCC4.js → chunk-XZYKEM6J.js}

@@ -1,6 +1,6 @@
 import {
   hook_decision
-} from "./chunk-6HJJXRBX.js";
+} from "./chunk-ZQGD4GBY.js";
 import {
   cost_blocks,
   cost_transcript,
@@ -8,7 +8,7 @@ import {
   time_bundle_call,
   time_shell,
   time_spans
-} from "./chunk-55HHG5PX.js";
+} from "./chunk-WK2XSHSI.js";
 
 // scripts/delegation/investigation-reads.ts
 import path2 from "node:path";

package/dist/hooks/{chunk-6HJJXRBX.js → chunk-ZQGD4GBY.js}

@@ -2,7 +2,7 @@ import {
   lane_paths,
   time_density_hook,
   time_hook_transcript
-} from "./chunk-55HHG5PX.js";
+} from "./chunk-WK2XSHSI.js";
 import {
   josh_environment_file
 } from "./chunk-WPALEIRX.js";

package/dist/hooks/codex-hook-adapter.js

@@ -1,28 +1,28 @@
 #!/usr/bin/env tsx
 import {
   pretool_guard
-} from "./chunk-JUDKDCDP.js";
-import "./chunk-TQNPDZNH.js";
+} from "./chunk-4TZVB44A.js";
+import "./chunk-QVSWU24O.js";
 import {
   bounded_pool
-} from "./chunk-NV2JRZZO.js";
+} from "./chunk-KHX4U3BG.js";
 import {
   build_envelope,
   compose_context,
   format_edited_payload
-} from "./chunk-FIVDHQGT.js";
+} from "./chunk-KHGB5S3Y.js";
 import "./chunk-JBBMAPC4.js";
 import "./chunk-CDY4NFQG.js";
-import "./chunk-RNWHN5BP.js";
-import "./chunk-F56MFS4B.js";
-import "./chunk-5VMKCCC4.js";
-import "./chunk-VC3PZPZO.js";
+import "./chunk-F3ELQ2AF.js";
+import "./chunk-KRBERBBI.js";
+import "./chunk-XZYKEM6J.js";
+import "./chunk-GPTFMK5E.js";
 import {
   hook_decision
-} from "./chunk-6HJJXRBX.js";
+} from "./chunk-ZQGD4GBY.js";
 import {
   time_density_hook
-} from "./chunk-55HHG5PX.js";
+} from "./chunk-WK2XSHSI.js";
 import "./chunk-WPALEIRX.js";
 import "./chunk-RKUAD3I6.js";
 import "./chunk-ELCN5LCH.js";

package/dist/hooks/duplicate-read-guard.js

@@ -9,11 +9,11 @@ import {
   is_enabled,
   notice_refusal_path,
   refusal_path
-} from "./chunk-TQNPDZNH.js";
-import "./chunk-5VMKCCC4.js";
-import "./chunk-VC3PZPZO.js";
-import "./chunk-6HJJXRBX.js";
-import "./chunk-55HHG5PX.js";
+} from "./chunk-QVSWU24O.js";
+import "./chunk-XZYKEM6J.js";
+import "./chunk-GPTFMK5E.js";
+import "./chunk-ZQGD4GBY.js";
+import "./chunk-WK2XSHSI.js";
 import "./chunk-WPALEIRX.js";
 import "./chunk-RKUAD3I6.js";
 import "./chunk-ELCN5LCH.js";

package/dist/hooks/format-edited.js

@@ -2,9 +2,9 @@
 import {
   report_no_payload,
   run_hook
-} from "./chunk-FIVDHQGT.js";
+} from "./chunk-KHGB5S3Y.js";
 import "./chunk-JBBMAPC4.js";
-import "./chunk-55HHG5PX.js";
+import "./chunk-WK2XSHSI.js";
 import "./chunk-RKUAD3I6.js";
 import "./chunk-ELCN5LCH.js";