@joshuafolkken/kit 1.1471.0 → 1.1514.0

package/dist/hooks/{chunk-AS74OU3D.js → chunk-TNUMY6NL.js}

@@ -2,11 +2,13 @@ import {
   ENV_FILE_NAME,
   cost_transcript,
   json_value,
+  lane_paths,
+  pr_raw_schema,
   process_identity,
   process_owner_schema,
   run_carry,
   time_instant
-} from "./chunk-E7OIKX5Z.js";
+} from "./chunk-APUO6U4J.js";
 import {
   PLATFORM_TEMP_ROOT,
   PROBE_TIMEOUT_MS,
@@ -100,1015 +102,438 @@ var COMMAND_PHASES = /* @__PURE__ */ new Map([
   ["josh followup", MERGE_PHASE]
 ]);
 
-// scripts/josh/josh-command-types.ts
-var OPTIONAL_ENV_FILE_FLAGS = [`--env-file-if-exists=${ENV_FILE_NAME}`];
-var GATE_COMMAND2 = "gate";
-var ESLINT_CACHE_FILE = ".eslintcache";
-var TS_BUILD_INFO_FILE = ".tsbuildinfo";
-var CSPELL_CACHE_FILE = ".cspellcache";
-var ESLINT_EDIT_CACHE_FILE = ".eslintcache.edit";
-var ESLINT_RELATED_CACHE_FILE = ".eslintcache.related";
-var ROOTED_JSON_PORTABILITY = "rooted-json";
-var ESLINT_CACHE_SPEC = {
-  cache_file: ESLINT_CACHE_FILE,
-  portability: ROOTED_JSON_PORTABILITY
-};
-var TS_CACHE_SPEC = {
-  cache_file: TS_BUILD_INFO_FILE,
-  portability: "raw"
-};
-var CSPELL_CACHE_SPEC = {
-  cache_file: CSPELL_CACHE_FILE,
-  portability: "raw"
-};
-var GATE_CACHE_SPECS = [
-  ESLINT_CACHE_SPEC,
-  TS_CACHE_SPEC,
-  CSPELL_CACHE_SPEC
-];
-var GATE_CACHE_FILES = GATE_CACHE_SPECS.map((spec) => spec.cache_file);
-var IGNORED_CACHE_FILES = [
-  ...GATE_CACHE_FILES,
-  ESLINT_EDIT_CACHE_FILE,
-  ESLINT_RELATED_CACHE_FILE
-];
-var CONTENT_CACHE_FLAGS = ["--cache", "--cache-strategy", "content"];
-var CACHE_LOCATION_FLAG = "--cache-location";
-function content_cache_flags(cache_file) {
-  return [...CONTENT_CACHE_FLAGS, CACHE_LOCATION_FLAG, cache_file];
-}
-var ESLINT_CACHE_FLAGS = content_cache_flags(ESLINT_CACHE_FILE);
-var ESLINT_EDIT_CACHE_FLAGS = content_cache_flags(ESLINT_EDIT_CACHE_FILE);
-var ESLINT_RELATED_CACHE_FLAGS = content_cache_flags(ESLINT_RELATED_CACHE_FILE);
-var CSPELL_CACHE_FLAGS = content_cache_flags(CSPELL_CACHE_FILE);
+// scripts/gate/core-budget.ts
+import { randomUUID } from "node:crypto";
+import { readdirSync as readdirSync2 } from "node:fs";
+import { availableParallelism as availableParallelism3 } from "node:os";
+import path3 from "node:path";
 
-// scripts/josh/josh-commands-backlog.ts
-var BACKLOG_COMMANDS = {
-  // Started from a terminal: the `backlogrun` keyword's launcher, and the board.
-  backlogrun: {
-    script: "scripts/backlog/backlogrun-cli.ts",
-    description: "Start a backlogrun in the background and show its board; with one already running, only show the board, or replace it when it is idle and the invocation differs; --stop stops it",
-    category: "AI tools",
-    reference: [
-      "[<n>...] [--only] [--max <n>] [--idle <minutes>] [--agent claude|codex] | --stop",
-      "developer",
-      ["files", "network", "processes"]
-    ]
-  },
-  "backlog:next": {
-    script: "scripts/backlog/backlog-next.ts",
-    description: "Order the whole opted-in backlog: auto-ok issues and the descendants of auto-ok epics, transitively through nested epics",
-    category: "AI tools",
-    reference: ["[--exclude <n>[,<n>...]] [--repo <owner/repo>]", "automation", ["network"]]
-  },
-  "backlog:offer": {
-    script: "scripts/backlog/backlog-offer-cli.ts",
-    description: "Collapse a backlogrun loop-head event into one call: read backlog:next, ask backlog:budget, return the verdict and any issues to start",
-    category: "AI tools",
-    reference: ["[options]", "automation", ["files", "network", "processes"]]
-  },
-  "backlog:drive": {
-    script: "scripts/backlog/backlog-drive-cli.ts",
-    description: "Drive backlogrun through offer, launch and merge; restore this run\u2019s lanes and report when complete",
-    category: "AI tools",
-    reference: ["--owner <pid> [options]", "automation", ["network"]]
-  },
-  "backlog:plan": {
-    script: "scripts/backlog/backlog-plan-cli.ts",
-    description: "Print the whole backlog as a plan: ready now, waiting on what, waiting on a person, out of scope",
-    category: "AI tools",
-    reference: [
-      "[issue...] [--only] [--waves] [--exclude <n>[,<n>...]]",
-      "automation",
-      ["network"]
-    ]
-  },
-  "backlog:stalled": {
-    script: "scripts/backlog/backlog-stalled-cli.ts",
-    // A stall sends one Telegram warning. The `Stop` hook calls the detector
-    // directly, so this flag costs only the manual command its in-process dispatch.
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Report whether ready backlog work is sitting undispatched with a free lane and no recent dispatch",
-    category: "AI tools",
-    reference: ["", "automation", ["network"]]
-  },
-  "backlog:budget": {
-    script: "scripts/backlog/backlog-budget-cli.ts",
-    description: "Say whether a backlogrun may start more work, keep watching, or finish",
-    category: "AI tools",
-    reference: ["[options]", "automation", ["none"]]
+// scripts/test/unit-worker-share.ts
+import { readdirSync } from "node:fs";
+import { availableParallelism } from "node:os";
+import path from "node:path";
+var RUN_PREFIX = "josh-unit-running-";
+var WORKER_FLAG = "--maxWorkers";
+var WORKER_FLAGS = [WORKER_FLAG, "--max-workers"];
+var MIN_WORKERS = 1;
+var SOLO_RUNS = 1;
+function marker_path(pid = process.pid) {
+  return stamp_file.stamp_path(RUN_PREFIX, String(pid));
+}
+function is_running(marker) {
+  return process_identity.is_same_process(marker.pid, marker.process_start) !== false;
+}
+function read_marker(source) {
+  const raw = stamp_file.read_stamp_text(source);
+  if (raw === void 0) return void 0;
+  const parsed = process_owner_schema.safeParse(json_value.parse_or_undefined(raw));
+  return parsed.success ? parsed.data : void 0;
+}
+function marker_files(directory = PLATFORM_TEMP_ROOT) {
+  try {
+    return readdirSync(directory).filter((name) => name.startsWith(RUN_PREFIX));
+  } catch {
+    return [];
   }
-};
-
-// scripts/josh/josh-commands-document.ts
-var DOCUMENT_COMMANDS = {
-  "doc:section": {
-    script: "scripts/document/document-section-cli.ts",
-    description: 'Print one section of a markdown document, for a `file.md` \u2192 "Heading" reference',
-    category: "AI tools",
-    reference: ["<file> <heading>", "automation", ["none"]],
-    is_bundled: true
-  },
-  "read:set": {
-    script: "scripts/document/read-set-cli.ts",
-    description: "Print what an entry point reads before it starts, and what that read costs",
-    category: "AI tools",
-    reference: ["[<entry>] [--json]", "automation", ["none"]]
-  },
-  "doc:read": {
-    script: "scripts/document/document-read-cli.ts",
-    description: "Read a whole document safely: print it, or point at the Read tool when over the Bash cap",
-    category: "AI tools",
-    reference: ["<file>", "automation", ["none"]]
-  },
-  "read:files": {
-    script: "scripts/document/read-files-cli.ts",
-    description: "Read several files in one call so edit targets fold into one turn",
-    category: "AI tools",
-    reference: ["<path> [<path> ...]", "automation", ["none"]]
-  },
-  "edit:files": {
-    script: "scripts/document/edit-files-cli.ts",
-    description: "Apply several content-addressed edits from a plan in one call",
-    category: "AI tools",
-    reference: ["<plan-path | ->", "automation", ["none"]]
+}
+function sweep_marker(source) {
+  try {
+    stamp_file.remove_stamp(source);
+  } catch {
   }
-};
-
-// scripts/josh/josh-commands-guard.ts
-var GUARD_COMMANDS = {
-  "investigation:guard": {
-    script: "scripts/delegation/investigation-guard.ts",
-    description: "Claude Code hook: refuse a read once the unedited-read threshold is reached again (reads the tool call on stdin)",
-    category: "AI tools",
-    reference: ["", "automation", ["none"]]
-  },
-  "duplicate-read:guard": {
-    script: "scripts/delegation/duplicate-read-guard.ts",
-    description: "Claude Code hook: refuse a second whole-file read of a path whose content has not changed since the run last read it (reads the tool call on stdin)",
-    category: "AI tools",
-    reference: ["", "automation", ["none"]]
-  },
-  "rule:guard": {
-    script: "scripts/rules/rule-guard.ts",
-    description: "Claude Code hook: deliver a trigger-delivered rule at the call that binds it (reads the tool call on stdin)",
-    category: "AI tools",
-    reference: ["", "automation", ["none"]]
+}
+function is_marker_live(source) {
+  const marker = read_marker(source);
+  if (marker === void 0) return false;
+  if (is_running(marker)) return true;
+  sweep_marker(source);
+  return false;
+}
+function live_run_count(directory = PLATFORM_TEMP_ROOT) {
+  return marker_files(directory).filter((name) => is_marker_live(path.join(directory, name))).length;
+}
+var NESTED_KEY = "JOSH_UNIT_RUN_MARKED";
+var NESTED_VALUE = "1";
+function is_nested_run() {
+  return process.env[NESTED_KEY] === NESTED_VALUE;
+}
+function resolve_unit_workers(available_cores, runs2) {
+  if (runs2 <= SOLO_RUNS) return void 0;
+  return Math.max(MIN_WORKERS, Math.floor(available_cores / runs2));
+}
+function cap_to_free(workers, free_cores, available_cores) {
+  if (free_cores === void 0 || free_cores >= (workers ?? available_cores)) return workers;
+  return Math.max(MIN_WORKERS, Math.floor(free_cores));
+}
+function current_share(available_cores = availableParallelism(), live_runs = live_run_count(), free_cores) {
+  const own_run2 = is_nested_run() ? 0 : SOLO_RUNS;
+  const share = resolve_unit_workers(available_cores, live_runs + own_run2);
+  return cap_to_free(share, free_cores, available_cores);
+}
+function is_worker_flag(argument) {
+  return WORKER_FLAGS.some((flag) => argument === flag || argument.startsWith(`${flag}=`));
+}
+function has_worker_flag(vitest_arguments) {
+  return vitest_arguments.some((argument) => is_worker_flag(argument));
+}
+function worker_arguments(vitest_arguments, share) {
+  if (share === void 0 || has_worker_flag(vitest_arguments)) return [];
+  return [`${WORKER_FLAG}=${String(share)}`];
+}
+function mark_run_started(target2) {
+  try {
+    stamp_file.write_stamp(target2, process_identity.own_fields());
+  } catch {
+  }
+}
+async function with_run_marker(run) {
+  if (is_nested_run()) return await run();
+  const target2 = marker_path();
+  mark_run_started(target2);
+  process.env[NESTED_KEY] = NESTED_VALUE;
+  try {
+    return await run();
+  } finally {
+    process.env[NESTED_KEY] = "";
+    stamp_file.remove_stamp(target2);
   }
+}
+var unit_worker_share = {
+  MIN_WORKERS,
+  NESTED_KEY,
+  NESTED_VALUE,
+  RUN_PREFIX,
+  SOLO_RUNS,
+  cap_to_free,
+  current_share,
+  has_worker_flag,
+  is_nested_run,
+  live_run_count,
+  marker_path,
+  read_marker,
+  resolve_unit_workers,
+  with_run_marker,
+  worker_arguments
 };
 
-// scripts/josh/josh-commands-issue.ts
-var ISSUES_WITH_REPO = "<issue...> [--repo <owner/repo>]";
-var ISSUE_COMMANDS = {
-  "issue:ack": {
-    script: "scripts/issue/issue-ack-cli.ts",
-    description: "Record that the run read a person's update to its issue, printing the update it acknowledges",
-    category: "AI tools",
-    reference: ["<issue>", "automation", ["network"]]
-  },
-  "issue:read": {
-    script: "scripts/issue/issue-read-cli.ts",
-    description: "Print each issue's title, body and every comment on it, in one call",
-    category: "AI tools",
-    reference: ["<issue...>", "automation", ["network"]]
-  },
-  "issue:state": {
-    script: "scripts/issue/issue-state-cli.ts",
-    description: "Print each issue's state and labels, in the spelling the documents compare against",
-    category: "AI tools",
-    reference: [ISSUES_WITH_REPO, "automation", ["network"]]
-  },
-  "issue:scout": {
-    script: "scripts/issue/issue-scout-cli.ts",
-    description: "Before filing: say whether an issue like this exists and which epic it belongs to",
-    category: "AI tools",
-    reference: ["<title> [--body <summary> | --body-file <path>]", "automation", ["network"]]
-  },
-  "defect:rate": {
-    script: "scripts/issue/defect-rate-cli.ts",
-    description: "Print the defect rate of merged work: defects filed per enhancement completed",
-    category: "AI tools",
-    reference: ["[--days <n>]", "automation", ["network"]]
-  },
-  "issue:fold": {
-    script: "scripts/issue/issue-fold-cli.ts",
-    description: "Before a second filing: say whether findings from this session fold into one issue",
-    category: "AI tools",
-    reference: ["<title>... [--not-separable] [--json]", "automation", ["none"]]
-  },
-  "issue:fold-existing": {
-    script: "scripts/issue/issue-fold-existing-cli.ts",
-    description: "Assess whether a complete draft can join an unstarted issue",
-    category: "AI tools",
-    reference: ["<assessment.json> [--json]", "automation", ["none"]]
-  },
-  "issue:cite": {
-    script: "scripts/issue/issue-cite-cli.ts",
-    description: "Print the paste-ready number-link citation line for each issue, in one call",
-    category: "AI tools",
-    reference: [ISSUES_WITH_REPO, "automation", ["network"]]
-  },
-  "issue:comment": {
-    script: "scripts/issue/issue-comment-cli.ts",
-    description: "Post one comment to an issue from a file, so no shell expands the body",
-    category: "AI tools",
-    reference: ["<issue> --body <text> | --body-file <path>", "automation", ["network"]]
-  },
-  "issue:file": {
-    script: "scripts/issue/issue-file-cli.ts",
-    description: "File an Issue with every filing step: lint, Origin, fold, 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] [--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 (or, with --wait, as waiting on it), filing one when none is open",
-    category: "AI tools",
-    reference: ["<issue> [--wait]", "automation", ["network"]]
+// scripts/gate/core-budget.ts
+import { z as z2 } 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/josh/josh-commands-lane.ts
-var LANE_SCRIPT = "scripts/lane/lane-cli.ts";
-var LANE_ARGUMENTS = { script: LANE_SCRIPT, tsx_arguments: OPTIONAL_ENV_FILE_FLAGS };
-var ISSUE_WITH_OPTIONS = "<issue> [options]";
-var MEASURE_ARGUMENTS = {
-  script: "scripts/lane/lane-measure-cli.ts",
-  tsx_arguments: OPTIONAL_ENV_FILE_FLAGS
+// scripts/gate/core-wait.ts
+import path2 from "node:path";
+var WAIT_REASONS = ["cores", "memory", "pressure"];
+var REASON_TEXT = {
+  cores: "not enough free cores",
+  memory: "not enough free memory",
+  pressure: "memory under pressure"
 };
-var LANE_COMMANDS = {
-  "lane:open": {
-    ...LANE_ARGUMENTS,
-    description: "Open a lane: a linked work tree with its own branch and its own port seed",
-    category: "AI tools",
-    reference: [ISSUE_WITH_OPTIONS, "automation", ["files", "git"]],
-    default_script_arguments: ["open"]
-  },
-  "lane:close": {
-    ...LANE_ARGUMENTS,
-    description: "Close a lane, leaving no work tree, branch or directory behind",
-    category: "AI tools",
-    reference: ["<issue>", "automation", ["files", "git"]],
-    default_script_arguments: ["close"]
-  },
-  "lane:list": {
-    ...LANE_ARGUMENTS,
-    description: "List the open lanes: which issue, which ports, and where each one is",
-    category: "AI tools",
-    reference: ["", "automation", ["none"]],
-    default_script_arguments: ["list"]
-  },
-  "lane:prune": {
-    ...LANE_ARGUMENTS,
-    description: "Close every lane an interruption left without its work tree and every spent lane, then sweep unregistered leftovers under the lanes root",
-    category: "AI tools",
-    reference: ["", "automation", ["files", "git"]],
-    default_script_arguments: ["prune"]
-  },
-  "lane:output": {
-    ...LANE_ARGUMENTS,
-    description: "Record, or read back, where the unit running a lane\u2019s child writes",
-    category: "AI tools",
-    reference: ["<issue> [path]", "automation", ["files"]],
-    default_script_arguments: ["output"]
-  },
-  "lane:dispatch": {
-    ...LANE_ARGUMENTS,
-    description: "Start a lane\u2019s child as a detached process that outlives this session",
-    category: "AI tools",
-    reference: ["<issue> <prompt>", "automation", ["processes"]],
-    default_script_arguments: ["dispatch"]
-  },
-  "lane:await": {
-    ...LANE_ARGUMENTS,
-    description: "Block until any of the named in-flight lane children completes; prints which one finished",
-    category: "AI tools",
-    reference: ["<issue> [<issue>...] [--owner <pid>]", "automation", ["files", "processes"]],
-    default_script_arguments: ["await"]
-  },
-  "lane:launch": {
-    script: "scripts/lane/lane-launch-cli.ts",
-    description: "Collapse a backlogrun lane-start event into one call: open the lane, pop and re-install on the first, dispatch the child",
-    category: "AI tools",
-    reference: ["<issue> [--stash <message>]", "automation", ["files", "git", "processes"]]
-  },
-  // `.env` is read for `JOSH_LANE_ROOT`, as every lane command reads it, so the lane is found.
-  "lane:restart": {
-    script: "scripts/lane/lane-restart-cli.ts",
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Stop a running lane child, stash its uncommitted work and re-dispatch its issue in a fresh session \u2014 not counted as an outage or a failure",
-    category: "AI tools",
-    reference: ["<issue>", "developer", ["files", "git", "processes", "network"]]
-  },
-  // A live run's lane limit: `.env` is read so the bare form reports the
-  // `JOSH_LANE_LIMIT` a person set there when no override stands.
-  "lane:limit": {
-    script: "scripts/lane/lane-limit-cli.ts",
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Change a live backlogrun\u2019s lane limit without stopping it, or print the limit, lanes in use and free lanes",
-    category: "AI tools",
-    reference: ["[<limit>] [--reset]", "developer", ["files"]]
-  },
-  // The lane-limit measurement: `.env` is read so `lane:stats` labels the row
-  // with the `JOSH_LANE_LIMIT` a person set there.
-  "lane:sample": {
-    ...MEASURE_ARGUMENTS,
-    description: "Record the machine load (load average, swap, free memory, working lanes) to the lane ledger \u2014 a backlogrun samples itself, this is for a reading outside one",
-    category: "AI tools",
-    reference: ["[--every <seconds>]", "maintainer", ["files"]],
-    default_script_arguments: ["sample"]
-  },
-  "lane:stats": {
-    ...MEASURE_ARGUMENTS,
-    description: "Print one table row of lane throughput, gate duration and machine load over a period, the per-stage durations of a lane under it, and the wait after each ship stop reason under those",
-    category: "AI tools",
-    reference: ["--period <days> [--limit <lane-limit>]", "maintainer", ["none"]],
-    default_script_arguments: ["stats"]
+function wait_reason(key, reservations, budget) {
+  const cores_only = { cores: budget.cores, memory_mb: Infinity };
+  if (!core_admission.is_admitted(key, reservations, cores_only)) return "cores";
+  return budget.memory_pressured === true ? "pressure" : "memory";
+}
+function wait_line(command, reason) {
+  return `\u23F3 ${command ?? "a step"} waits for the core budget \u2014 ${REASON_TEXT[reason]}`;
+}
+function lanes_root_of(checkout) {
+  if (lane_paths.lane_issue_of(checkout) === void 0) return lane_paths.lane_root(checkout);
+  return path2.dirname(path2.resolve(checkout));
+}
+function where_of(checkout) {
+  return { checkout, lane: lane_paths.lane_issue_of(checkout), lanes_root: lanes_root_of(checkout) };
+}
+function place_of(marker, home_root) {
+  const { checkout, lane, lanes_root } = marker;
+  if (checkout === void 0 || lanes_root === void 0 || lanes_root === home_root) {
+    return { lane, elsewhere: void 0 };
   }
+  const name = lane === void 0 ? path2.basename(checkout) : `${path2.basename(lanes_root)}/${lane}`;
+  return { lane: void 0, elsewhere: name };
+}
+function wait_of(marker, now, home_root) {
+  const { command, wait_reason: reason } = marker;
+  if (reason === void 0 || marker.admitted_at !== void 0) return [];
+  return [{ command, ...place_of(marker, home_root), waited_ms: now - marker.claimed_at, reason }];
+}
+function waits_of(entries, now, home) {
+  const home_root = lanes_root_of(home);
+  return entries.flatMap((entry) => wait_of(entry.reservation, now, home_root)).toSorted((left, right) => right.waited_ms - left.waited_ms);
+}
+var core_wait = {
+  REASON_TEXT,
+  WAIT_REASONS,
+  wait_line,
+  wait_reason,
+  waits_of,
+  where_of
 };
 
-// scripts/josh/josh-commands-run.ts
-var RUN_HOLD_SCRIPT = "scripts/run/hold/run-hold-cli.ts";
-var RUN_COMMANDS = {
-  "run:hold": {
-    script: RUN_HOLD_SCRIPT,
-    description: "Claim this working tree for a run, or say which run already holds it",
-    category: "AI tools",
-    reference: ["[<issue> [--fullrun | --halfrun-stop | --prrun-stop]]", "automation", ["files"]]
-  },
-  "run:release": {
-    script: RUN_HOLD_SCRIPT,
-    description: "Release this working tree's run record",
-    category: "AI tools",
-    reference: ["[issue|--force]", "automation", ["files"]],
-    default_script_arguments: ["--release"]
-  },
-  "run:tidy": {
-    script: "scripts/run/tidy/run-tidy-cli.ts",
-    description: "Close merged lanes and drop stashes whose issues are all merged",
-    category: "AI tools",
-    reference: ["", "automation", ["git", "network", "files"]]
-  },
-  "run:carry": {
-    script: "scripts/run/carry/run-carry-cli.ts",
-    // `--stopped` sends the stop confirmation, so the Telegram credentials come from `.env` as for
-    // `run:wake` below.
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Carry one invocation\u2019s budget across its own session cuts",
-    category: "AI tools",
-    reference: ["<operation> [arguments...]", "automation", ["files"]]
-  },
-  "run:add": {
-    script: "scripts/run/add/run-add-cli.ts",
-    description: "Add issues to a live backlogrun, ahead of the queue unless --no-priority",
-    category: "AI tools",
-    reference: ["<issue...> [--no-priority]", "automation", ["network", "files"]]
-  },
-  "run:wake": {
-    script: "scripts/run/wake/run-wake-cli.ts",
-    // `.env` rather than the ambient environment:
-    // the failure warning needs the Telegram credentials, the same
-    // reasons `notify` and `followup` carry these flags.
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Wake the next session of a cut backlogrun from outside the conversation",
-    category: "AI tools",
-    reference: ["[options]", "automation", ["processes", "notifications"]]
-  },
-  "run:cut": {
-    script: "scripts/run/cut/run-cut-cli.ts",
-    description: "Cut a lane child before the gate and resume a fresh process",
-    category: "AI tools",
-    reference: ["[--resume] <issue> [--impl] [--handoff <path>]", "automation", ["files"]]
-  },
-  "run:liveness": {
-    script: "scripts/run/run-liveness-cli.ts",
-    description: "Say whether a delegated unit is still working, or stopped without reporting",
-    category: "AI tools",
-    reference: ["<issue> --output <path> [options]", "automation", ["processes"]]
-  },
-  "run:ending": {
-    script: "scripts/run/run-ending-cli.ts",
-    description: "Classify how a dispatched lane child ended (merged, cut, abandoned, unreadable)",
-    category: "AI tools",
-    reference: ["<issue> --output <path> [--repo <owner/repo>]", "automation", ["network"]]
-  },
-  "run:progress": {
-    script: "scripts/run/progress/run-progress-cli.ts",
-    description: "Report an unattended run\u2019s progress once it has gone quiet for an interval",
-    category: "AI tools",
-    reference: [
-      "[--once | --wait] [--interval <minutes>] [--hours <hours>] [--repo <owner/repo>] [--output <path>] | --mark | --path",
-      "automation",
-      ["files"]
-    ]
-  },
-  "run:board": {
-    script: "scripts/run/board/run-board-cli.ts",
-    // `--every` pushes its frame as a Telegram, so the credentials come from `.env` as for `run:carry`.
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Draw a live board of the running backlogrun, redrawn every second",
-    category: "AI tools",
-    reference: ["[--once | --chat | --every <minutes>]", "automation", ["files", "network"]]
-  },
-  "run:prep": {
-    script: "scripts/run/run-prep-cli.ts",
-    description: "Bundle a run\u2019s pre-edit reads: body, comments, state, dependency scope",
-    category: "AI tools",
-    reference: ["<issue>", "automation", ["network"]]
-  },
-  // The entry sequence a lane opened on, folded into one call: claim the tree,
-  // read the budget, gather the issue reads and decide the pre-implementation step. `run:hold`,
-  // `cost --cut`, `run:prep` and `run:step` were four round trips re-billing a lane's full context each.
-  "run:entry": {
-    script: "scripts/run/entry/run-entry-cli.ts",
-    // A `busy` hold or an `over` budget sends the stop confirmation.
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Open a run in one call: claim the tree, read the budget, bundle the reads, decide the pre-implementation step",
-    category: "AI tools",
-    reference: ["<issue> [--to <command>]", "automation", ["git", "network", "files"]]
-  },
-  "run:status": {
-    script: "scripts/run/run-status-cli.ts",
-    description: "Bundle a run\u2019s read-only status: issue state, cost verdict, carry counters",
-    category: "AI tools",
-    reference: ["<issue> [--repo <owner/repo>]", "automation", ["network"]]
-  },
-  "run:next": {
-    script: "scripts/run/run-next-cli.ts",
-    description: "Print the next step a fullrun takes, computed from the run\u2019s state",
-    category: "AI tools",
-    reference: ["<issue>", "automation", ["network"]]
-  },
-  "run:step": {
-    script: "scripts/run/run-step-cli.ts",
-    description: "Print the run\u2019s next single action, computed from the event stream, carry record and issue state",
-    category: "AI tools",
-    reference: ["[<issue>]", "automation", ["network", "files"]]
+// scripts/gate/held-mark.ts
+var HELD_KEY = "JOSH_CORE_RESERVED";
+var HELD_VALUE = "1";
+var HELD_RESERVATION_KEY = "JOSH_CORE_RESERVATION";
+function is_held() {
+  return process.env[HELD_KEY] === HELD_VALUE;
+}
+function held_reservation() {
+  const key = process.env[HELD_RESERVATION_KEY] ?? "";
+  return key === "" ? void 0 : key;
+}
+function set_held_mark(value, reservation) {
+  process.env[HELD_KEY] = value;
+  process.env[HELD_RESERVATION_KEY] = reservation;
+}
+async function with_held_mark(run, reservation = "") {
+  const previous = process.env[HELD_KEY] ?? "";
+  const previous_reservation = process.env[HELD_RESERVATION_KEY] ?? "";
+  set_held_mark(HELD_VALUE, reservation);
+  try {
+    return await run();
+  } finally {
+    set_held_mark(previous, previous_reservation);
   }
+}
+var held_mark = {
+  HELD_KEY,
+  HELD_RESERVATION_KEY,
+  HELD_VALUE,
+  held_reservation,
+  is_held,
+  with_held_mark
 };
 
-// scripts/josh/josh-commands-split.ts
-var SPLIT_COMMANDS = {
-  "split:assess": {
-    script: "scripts/split/split-assess-cli.ts",
-    description: "Measure the branch change size (tests excluded) and answer the split assessment size question: split | single",
-    category: "AI tools",
-    reference: ["[--json]", "automation", ["none"]]
+// 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 VMSTAT_PATH = "/proc/vmstat";
+var LINUX_AVAILABLE = /^MemAvailable:\s+(?<kb>\d+) kB/mu;
+var LINUX_SWAP_IN = /^pswpin (?<pages>\d+)$/mu;
+var LINUX_SWAP_OUT = /^pswpout (?<pages>\d+)$/mu;
+var PAGE_SIZE_ARGUMENTS = ["PAGESIZE"];
+var LEVEL_NAME = "kern.memorystatus_level";
+var SWAP_IN_NAME = "vm.compressor.swapper.swapins_total";
+var SWAP_OUT_NAME = "vm.compressor.swapper.swapouts_total";
+var COMPRESSED_NAME = "vm.compressor_input_bytes";
+var PAGE_SIZE_NAME = "hw.pagesize";
+var PRESSURE_NAME = "kern.memorystatus_vm_pressure_level";
+var PRESSURE_WARNING = 2;
+var SWAP_PRESSURE_MB = 16;
+var COMPRESSION_PRESSURE_MB = 64;
+var SYSCTL_ARGUMENTS = [
+  LEVEL_NAME,
+  SWAP_IN_NAME,
+  SWAP_OUT_NAME,
+  COMPRESSED_NAME,
+  PAGE_SIZE_NAME,
+  PRESSURE_NAME
+];
+var SYSCTL_LINE = /^(?<name>[\w.]+): (?<value>\d+)$/gmu;
+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_share_between(before, after) {
+  const total = after.total - before.total;
+  if (total <= 0) return void 0;
+  return (after.busy - before.busy) / total;
+}
+function busy_cores_between(before, after, cores) {
+  const share = busy_share_between(before, after);
+  return share === void 0 ? void 0 : share * cores;
+}
+function sysctl_values(output) {
+  const values = [...output.matchAll(SYSCTL_LINE)].map(
+    (match) => [match.groups?.["name"] ?? "", Number(match.groups?.["value"])]
+  );
+  return new Map(values);
+}
+function swapped_pages(pages_in, pages_out) {
+  return pages_in === void 0 || pages_out === void 0 ? void 0 : pages_in + pages_out;
+}
+function mb_of(units, unit_bytes) {
+  if (units === void 0 || unit_bytes === void 0) return void 0;
+  return units * unit_bytes / BYTES_PER_MB;
+}
+function swapped_between(from, to) {
+  if (from === void 0 || to === void 0) return void 0;
+  return Math.max(0, to - from);
+}
+function parse_darwin_memory(output, total_bytes) {
+  const values = sysctl_values(output);
+  const level = values.get(LEVEL_NAME);
+  return {
+    available_mb: level === void 0 ? void 0 : level / PERCENT * (total_bytes / BYTES_PER_MB),
+    swapped_mb: mb_of(
+      swapped_pages(values.get(SWAP_IN_NAME), values.get(SWAP_OUT_NAME)),
+      values.get(PAGE_SIZE_NAME)
+    ),
+    pressure_level: values.get(PRESSURE_NAME),
+    compressed_mb: mb_of(values.get(COMPRESSED_NAME), 1)
+  };
+}
+function parse_linux_available(meminfo) {
+  const kb = LINUX_AVAILABLE.exec(meminfo)?.groups?.["kb"];
+  return kb === void 0 ? void 0 : Number(kb) / KB_PER_MB;
+}
+function pages_of(pattern, vmstat) {
+  const pages = pattern.exec(vmstat)?.groups?.["pages"];
+  return pages === void 0 ? void 0 : Number(pages);
+}
+function parse_linux_swapped(vmstat, page_bytes) {
+  const pages = swapped_pages(pages_of(LINUX_SWAP_IN, vmstat), pages_of(LINUX_SWAP_OUT, vmstat));
+  return mb_of(pages, page_bytes);
+}
+async function settled(read) {
+  try {
+    return await read();
+  } catch {
+    return void 0;
   }
+}
+async function read_darwin_memory() {
+  const { stdout } = await execa("sysctl", SYSCTL_ARGUMENTS, {
+    reject: false,
+    timeout: PROBE_TIMEOUT_MS
+  });
+  return parse_darwin_memory(stdout, totalmem());
+}
+async function read_page_size() {
+  const { stdout } = await execa("getconf", PAGE_SIZE_ARGUMENTS, { timeout: PROBE_TIMEOUT_MS });
+  return stdout;
+}
+async function read_linux_memory() {
+  const [meminfo, vmstat, page_size] = await Promise.all([
+    settled(async () => await readFile(MEMINFO_PATH, "utf8")),
+    settled(async () => await readFile(VMSTAT_PATH, "utf8")),
+    settled(read_page_size)
+  ]);
+  const page_bytes = page_size === void 0 ? void 0 : Number(page_size);
+  return {
+    available_mb: meminfo === void 0 ? void 0 : parse_linux_available(meminfo),
+    swapped_mb: vmstat === void 0 || page_bytes === void 0 ? void 0 : parse_linux_swapped(vmstat, page_bytes),
+    pressure_level: void 0
+  };
+}
+var UNREAD_MEMORY = {
+  available_mb: void 0,
+  swapped_mb: void 0,
+  pressure_level: void 0
 };
-
-// scripts/josh/josh-commands-ai.ts
-var ISSUE_WITH_OPTIONS2 = "<issue> [options]";
-var AI_COMMANDS = {
-  ...ISSUE_COMMANDS,
-  "pkg:scout": {
-    script: "scripts/package/package-scout-cli.ts",
-    description: "Rank package candidates by measured metrics so the Package-First tier decision is read, not judged",
-    category: "AI tools",
-    reference: ["<keywords> [--size <n>]", "automation", ["network"]]
-  },
-  "stash:pop": {
-    script: "scripts/git/stash/stash-pop-cli.ts",
-    description: "Pop the stash matching this message, not whichever a shared stack has on top",
-    category: "AI tools",
-    reference: ["<message>", "automation", ["git"]]
-  },
-  epic: {
-    script: "scripts/epic/epic.ts",
-    description: "Create an epic issue from its child issue numbers",
-    category: "AI tools",
-    reference: ["<title> <issue...> [--ordered]", "automation", ["network"]]
-  },
-  "epic:next": {
-    script: "scripts/epic/epic-next.ts",
-    description: "List an epic's runnable children, bundled per repository",
-    category: "AI tools",
-    reference: ["<epic>... [--repo <owner/repo>] [--lanes]", "automation", ["network"]]
-  },
-  "epic:bundle": {
-    script: "scripts/epic/epic-bundle-cli.ts",
-    description: "Say whether a newly filed issue belongs with ones already in the backlog",
-    category: "AI tools",
-    reference: ["<issue>", "automation", ["network"]]
-  },
-  "epic:audit": {
-    script: "scripts/epic/epic-audit-cli.ts",
-    description: "Audit an epic's children against each other for contradictions",
-    category: "AI tools",
-    reference: ["<epic>", "automation", ["network"]]
-  },
-  "epic:check": {
-    script: "scripts/epic/epic-check.ts",
-    description: "Check an epic issue against the tracking requirements",
-    category: "AI tools",
-    reference: ["<epic>", "automation", ["network"]]
-  },
-  "auto-ok:next": {
-    script: "scripts/auto-ok/auto-ok-cli.ts",
-    description: "Print the next opted-in issue an unattended run may pick up outside an epic",
-    category: "AI tools",
-    reference: ["[--exclude <n>[,<n>...]] [--label <name>]", "automation", ["network"]]
-  },
-  "auto-ok:judge": {
-    script: "scripts/auto-ok/auto-ok-judge-cli.ts",
-    description: "List the open issues backlogrun owes an auto-ok judgement, or record one (--apply / --decline)",
-    category: "AI tools",
-    reference: [
-      "[--apply <n> (--lane | --solo) | --decline <n> --reason <text>]",
-      "automation",
-      ["network"]
-    ]
-  },
-  ...BACKLOG_COMMANDS,
-  cost: {
-    script: "scripts/cost-runtime/cost-cli.ts",
-    description: "Say whether the next turn of a run crosses the context-cut threshold (--cut) or a given tokens-per-request figure (--over)",
-    category: "AI tools",
-    reference: ["(--cut | --over <tokens-per-request>) [--path <dir>]", "automation", ["none"]]
-  },
-  ...DOCUMENT_COMMANDS,
-  time: {
-    script: "scripts/time/time-cli.ts",
-    description: "Report where a run's wall clock went: model wait, tool execution, human wait",
-    category: "AI tools",
-    reference: ["[options]", "maintainer", ["none"]],
-    // Kit-only: it measures kit's own development runs and its report modules live under the
-    // undistributed `scripts/time/`, so it means nothing in a consumer project and is dropped from a
-    // consumer's help. The runtime analysis hooks and guards rely on stays
-    // distributed under `scripts/time-runtime/`.
-    is_kit_only: true
-  },
-  // The tool-calls-per-round-trip density the batching guard is measured on, aggregated across the
-  // recent lane sessions. Kit-only for the same reason `time` is: it reads
-  // kit's own lane transcripts and means nothing in a consumer project.
-  "time:density": {
-    script: "scripts/time/time-density-cli.ts",
-    description: "Report tool calls per round trip across the recent lane sessions",
-    category: "AI tools",
-    reference: ["[--lanes <n>] [--path <dir>]", "maintainer", ["none"]],
-    is_kit_only: true
-  },
-  retrospective: {
-    script: "scripts/retrospective/retrospective-cli.ts",
-    description: "Aggregate a finished run's cost, review findings, observation ledger and events into one digest",
-    category: "AI tools",
-    reference: ["", "maintainer", ["none"]],
-    // Kit-only: it reads kit's own development run — the transcript store, the review ledger and the
-    // run event stream — so it means nothing in a consumer project and is dropped from a consumer's
-    // help, through the same declaration `josh time` uses for the same reason.
-    is_kit_only: true
-  },
-  "review:brief": {
-    script: "scripts/review/review-brief-cli.ts",
-    description: "Print the whole /code-review invocation: level, what the gate already proved, target (--level-only for the level alone)",
-    category: "AI tools",
-    reference: ["[--round <1|2>] | --level-only [--staged] [--json]", "automation", ["files"]]
-  },
-  "review:attest": {
-    script: "scripts/review/review-attest-cli.ts",
-    description: "Record, or verify, which checkout a /code-review actually read",
-    category: "AI tools",
-    reference: ["<nonce> | --check", "automation", ["files"]]
-  },
-  "review:round2": {
-    script: "scripts/review/review-round2-cli.ts",
-    description: "Say whether the second /code-review round is due, or may be skipped entirely",
-    category: "AI tools",
-    reference: ["[--round-1-closed] [--json]", "automation", ["none"]]
-  },
-  delegate: {
-    script: "scripts/delegation/delegation-cli.ts",
-    description: "Say whether a run step may go to a cheaper execution tier",
-    category: "AI tools",
-    reference: ["<step> | --list", "automation", ["none"]]
-  },
-  fanout: {
-    script: "scripts/delegation/fanout-cli.ts",
-    description: "Say whether proposed implementation units are file-disjoint, so they may run in parallel",
-    category: "AI tools",
-    reference: ["<unit-files> <unit-files> [<unit-files> \u2026]", "automation", ["none"]]
-  },
-  ...RUN_COMMANDS,
-  "repo:party": {
-    script: "scripts/discovery/repo-party-cli.ts",
-    description: "Say whether a repository is first-party or third-party by owner equality (computed, not judged)",
-    category: "AI tools",
-    reference: ["[<owner/repo>]", "automation", ["none"]]
-  },
-  "run:merge": {
-    script: "scripts/run/merge/run-merge-cli.ts",
-    description: "Collapse a backlogrun merge event into one call: confirm the child, do the post-merge steps, offer the next child",
-    category: "AI tools",
-    reference: [ISSUE_WITH_OPTIONS2, "automation", ["git", "network"]]
-  },
-  "run:review": {
-    script: "scripts/run/review/run-review-cli.ts",
-    description: "Start the gate in the background and print the /code-review brief in one call so the two overlap (--join to join the gate and check its verdict)",
-    category: "AI tools",
-    reference: ["[--join]", "automation", ["processes", "files"]]
-  },
-  // The post-merge sequence a run closed on, folded into one call: commit the
-  // observation ledger, read the completion citations and decide the release scope. `observations:flush`,
-  // `issue:cite` and `release:scope` were three round trips re-billing the run's full context each.
-  "run:tail": {
-    script: "scripts/run/run-tail-cli.ts",
-    description: "Close a run in one call: return to the default branch, commit the observation ledger, read the citations, decide the release scope",
-    category: "AI tools",
-    reference: ["[<issue> ...]", "automation", ["git", "network"]]
-  },
-  // The commit-to-report region a run ships a change on, folded into one call:
-  // the gate, the commit/push/PR (`git -y`), the CI-wait merge (`followup`) and the report bookkeeping
-  // (`run:tail`) were four round trips re-billing the run's full context each. It stops at the first
-  // failed step and names it, so the run reads only the step to fix.
-  ship: {
-    script: "scripts/run/ship/run-ship-cli.ts",
-    description: "Ship a change in one call: gate, commit/push/PR, the CI-wait merge and the report bookkeeping, stopping at the first failed step",
-    category: "AI tools",
-    reference: [
-      '"<title> #<N>" [<follow-up-N> ...] [--cite <N>] [--review] [--detach] [--body-file <path>] [--notify-message <text> | --notify-message-file <path>] | --log <N>',
-      "automation",
-      ["git", "network"]
-    ]
-  },
-  "run:event": {
-    script: "scripts/run/event/run-event-cli.ts",
-    description: "Append to, read or watch the run\u2019s append-only event stream (--append <kind> <text> | --from|--follow <n> | --watch [<n>] | --last)",
-    category: "AI tools",
-    reference: [
-      "--append <kind> <text> | --from|--follow <n> | --watch [<n>] | --last",
-      "automation",
-      ["files"]
-    ]
-  },
-  "run:report": {
-    script: "scripts/run/run-report-cli.ts",
-    description: "Generate the session-facing report for this invocation from the run\u2019s event stream (merges, parks, cuts) with the release tail \u2014 the same text josh notify sends",
-    category: "AI tools",
-    reference: ["", "automation", ["files", "network"]]
-  },
-  ...LANE_COMMANDS,
-  ...GUARD_COMMANDS,
-  "run:watcher:guard": {
-    script: "scripts/run/run-watcher-guard-cli.ts",
-    description: "Guard: exits non-zero when lane children are in-flight but the watcher has not pinged recently",
-    category: "AI tools",
-    reference: ["", "automation", ["none"]]
-  },
-  "run:stranded": {
-    script: "scripts/run/run-stranded-cli.ts",
-    // `.env` rather than the ambient environment: the strand notification needs the Telegram
-    // credentials, the same reason `run:wake` carries these flags.
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Report whether the run is stranded \u2014 owner gone, no successor holding the budget, and no supervisor watching",
-    category: "AI tools",
-    reference: ["", "automation", ["processes", "notifications"]]
-  },
-  ...SPLIT_COMMANDS,
-  "oracle:list": {
-    script: "scripts/rules/oracle-list-cli.ts",
-    description: "Print the decision oracles \u2014 commands that answer a rule question mechanically",
-    category: "AI tools",
-    reference: ["", "automation", ["none"]]
-  },
-  eval: {
-    script: "scripts/eval/eval-run.ts",
-    description: "Run the agent rule-compliance scenarios (real Claude sessions)",
-    category: "AI tools",
-    reference: ["[scenario...]", "maintainer", ["processes", "network"]],
-    // Kit-only: it replays kit's own distributed rules against real Claude sessions, so it means
-    // nothing in a consumer project and is dropped from a consumer's help.
-    is_kit_only: true
-  }
-};
-
-// scripts/josh/josh-commands-clone.ts
-var CLONE_COMMANDS = {
-  "clone:scan": {
-    script: "scripts/clone/clone-scan-cli.ts",
-    description: "Count code duplication across files and first-party repositories, printing each clone as file:line pairs",
-    category: "AI tools",
-    reference: ["", "automation", ["files"]]
-  }
-};
-
-// scripts/gate/core-budget.ts
-import { randomUUID } from "node:crypto";
-import { readdirSync as readdirSync2 } from "node:fs";
-import { availableParallelism as availableParallelism3 } from "node:os";
-import path2 from "node:path";
-
-// scripts/test/unit-worker-share.ts
-import { readdirSync } from "node:fs";
-import { availableParallelism } from "node:os";
-import path from "node:path";
-var RUN_PREFIX = "josh-unit-running-";
-var WORKER_FLAG = "--maxWorkers";
-var WORKER_FLAGS = [WORKER_FLAG, "--max-workers"];
-var MIN_WORKERS = 1;
-var SOLO_RUNS = 1;
-function marker_path(pid = process.pid) {
-  return stamp_file.stamp_path(RUN_PREFIX, String(pid));
+async function read_memory() {
+  if (process.platform === "darwin") return await settled(read_darwin_memory) ?? UNREAD_MEMORY;
+  return process.platform === "linux" ? await read_linux_memory() : UNREAD_MEMORY;
 }
-function is_running(marker) {
-  return process_identity.is_same_process(marker.pid, marker.process_start) !== false;
+function is_unquoted() {
+  return cpus().length > 0 && cpus().length === availableParallelism2();
 }
-function read_marker(source) {
-  const raw = stamp_file.read_stamp_text(source);
-  if (raw === void 0) return void 0;
-  const parsed = process_owner_schema.safeParse(json_value.parse_or_undefined(raw));
-  return parsed.success ? parsed.data : void 0;
+async function default_sleep(ms) {
+  await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
 }
-function marker_files(directory = PLATFORM_TEMP_ROOT) {
-  try {
-    return readdirSync(directory).filter((name) => name.startsWith(RUN_PREFIX));
-  } catch {
-    return [];
-  }
+function moved_over(from, to, limit) {
+  return (swapped_between(from, to) ?? 0) > limit;
 }
-function sweep_marker(source) {
-  try {
-    stamp_file.remove_stamp(source);
-  } catch {
-  }
+function is_pressured(before, after) {
+  return (after.pressure_level ?? 0) >= PRESSURE_WARNING || moved_over(before.swapped_mb, after.swapped_mb, SWAP_PRESSURE_MB) || moved_over(before.compressed_mb, after.compressed_mb, COMPRESSION_PRESSURE_MB);
 }
-function is_marker_live(source) {
-  const marker = read_marker(source);
-  if (marker === void 0) return false;
-  if (is_running(marker)) return true;
-  sweep_marker(source);
-  return false;
-}
-function live_run_count(directory = PLATFORM_TEMP_ROOT) {
-  return marker_files(directory).filter((name) => is_marker_live(path.join(directory, name))).length;
-}
-var NESTED_KEY = "JOSH_UNIT_RUN_MARKED";
-var NESTED_VALUE = "1";
-function is_nested_run() {
-  return process.env[NESTED_KEY] === NESTED_VALUE;
-}
-function resolve_unit_workers(available_cores, runs2) {
-  if (runs2 <= SOLO_RUNS) return void 0;
-  return Math.max(MIN_WORKERS, Math.floor(available_cores / runs2));
-}
-function current_share(available_cores = availableParallelism(), live_runs = live_run_count()) {
-  const own_run2 = is_nested_run() ? 0 : SOLO_RUNS;
-  return resolve_unit_workers(available_cores, live_runs + own_run2);
-}
-function is_worker_flag(argument) {
-  return WORKER_FLAGS.some((flag) => argument === flag || argument.startsWith(`${flag}=`));
-}
-function worker_arguments(vitest_arguments, share) {
-  if (share === void 0 || vitest_arguments.some((argument) => is_worker_flag(argument))) {
-    return [];
-  }
-  return [`${WORKER_FLAG}=${String(share)}`];
-}
-function mark_run_started(target2) {
-  try {
-    stamp_file.write_stamp(target2, process_identity.own_fields());
-  } catch {
-  }
-}
-async function with_run_marker(run) {
-  if (is_nested_run()) return await run();
-  const target2 = marker_path();
-  mark_run_started(target2);
-  process.env[NESTED_KEY] = NESTED_VALUE;
-  try {
-    return await run();
-  } finally {
-    process.env[NESTED_KEY] = "";
-    stamp_file.remove_stamp(target2);
-  }
-}
-var unit_worker_share = {
-  MIN_WORKERS,
-  NESTED_KEY,
-  NESTED_VALUE,
-  RUN_PREFIX,
-  SOLO_RUNS,
-  current_share,
-  is_nested_run,
-  live_run_count,
-  marker_path,
-  read_marker,
-  resolve_unit_workers,
-  with_run_marker,
-  worker_arguments
-};
-
-// scripts/gate/core-budget.ts
-import { z as z2 } 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 VMSTAT_PATH = "/proc/vmstat";
-var LINUX_AVAILABLE = /^MemAvailable:\s+(?<kb>\d+) kB/mu;
-var LINUX_SWAP_IN = /^pswpin (?<pages>\d+)$/mu;
-var LINUX_SWAP_OUT = /^pswpout (?<pages>\d+)$/mu;
-var PAGE_SIZE_ARGUMENTS = ["PAGESIZE"];
-var LEVEL_NAME = "kern.memorystatus_level";
-var SWAP_IN_NAME = "vm.compressor.swapper.swapins_total";
-var SWAP_OUT_NAME = "vm.compressor.swapper.swapouts_total";
-var PAGE_SIZE_NAME = "hw.pagesize";
-var PRESSURE_NAME = "kern.memorystatus_vm_pressure_level";
-var SYSCTL_ARGUMENTS = [LEVEL_NAME, SWAP_IN_NAME, SWAP_OUT_NAME, PAGE_SIZE_NAME, PRESSURE_NAME];
-var SYSCTL_LINE = /^(?<name>[\w.]+): (?<value>\d+)$/gmu;
-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_share_between(before, after) {
-  const total = after.total - before.total;
-  if (total <= 0) return void 0;
-  return (after.busy - before.busy) / total;
-}
-function busy_cores_between(before, after, cores) {
-  const share = busy_share_between(before, after);
-  return share === void 0 ? void 0 : share * cores;
-}
-function sysctl_values(output) {
-  const values = [...output.matchAll(SYSCTL_LINE)].map(
-    (match) => [match.groups?.["name"] ?? "", Number(match.groups?.["value"])]
-  );
-  return new Map(values);
-}
-function swapped_pages(pages_in, pages_out) {
-  return pages_in === void 0 || pages_out === void 0 ? void 0 : pages_in + pages_out;
-}
-function swapped_mb(pages, page_bytes) {
-  if (pages === void 0 || page_bytes === void 0) return void 0;
-  return pages * page_bytes / BYTES_PER_MB;
-}
-function swapped_between(from, to) {
-  if (from === void 0 || to === void 0) return void 0;
-  return Math.max(0, to - from);
-}
-function parse_darwin_memory(output, total_bytes) {
-  const values = sysctl_values(output);
-  const level = values.get(LEVEL_NAME);
-  return {
-    available_mb: level === void 0 ? void 0 : level / PERCENT * (total_bytes / BYTES_PER_MB),
-    swapped_mb: swapped_mb(
-      swapped_pages(values.get(SWAP_IN_NAME), values.get(SWAP_OUT_NAME)),
-      values.get(PAGE_SIZE_NAME)
-    ),
-    pressure_level: values.get(PRESSURE_NAME)
-  };
-}
-function parse_linux_available(meminfo) {
-  const kb = LINUX_AVAILABLE.exec(meminfo)?.groups?.["kb"];
-  return kb === void 0 ? void 0 : Number(kb) / KB_PER_MB;
-}
-function pages_of(pattern, vmstat) {
-  const pages = pattern.exec(vmstat)?.groups?.["pages"];
-  return pages === void 0 ? void 0 : Number(pages);
-}
-function parse_linux_swapped(vmstat, page_bytes) {
-  const pages = swapped_pages(pages_of(LINUX_SWAP_IN, vmstat), pages_of(LINUX_SWAP_OUT, vmstat));
-  return swapped_mb(pages, page_bytes);
-}
-async function settled(read) {
-  try {
-    return await read();
-  } catch {
-    return void 0;
-  }
-}
-async function read_darwin_memory() {
-  const { stdout } = await execa("sysctl", SYSCTL_ARGUMENTS, {
-    reject: false,
-    timeout: PROBE_TIMEOUT_MS
-  });
-  return parse_darwin_memory(stdout, totalmem());
-}
-async function read_page_size() {
-  const { stdout } = await execa("getconf", PAGE_SIZE_ARGUMENTS, { timeout: PROBE_TIMEOUT_MS });
-  return stdout;
-}
-async function read_linux_memory() {
-  const [meminfo, vmstat, page_size] = await Promise.all([
-    settled(async () => await readFile(MEMINFO_PATH, "utf8")),
-    settled(async () => await readFile(VMSTAT_PATH, "utf8")),
-    settled(read_page_size)
-  ]);
-  const page_bytes = page_size === void 0 ? void 0 : Number(page_size);
-  return {
-    available_mb: meminfo === void 0 ? void 0 : parse_linux_available(meminfo),
-    swapped_mb: vmstat === void 0 || page_bytes === void 0 ? void 0 : parse_linux_swapped(vmstat, page_bytes),
-    pressure_level: void 0
-  };
-}
-var UNREAD_MEMORY = {
-  available_mb: void 0,
-  swapped_mb: void 0,
-  pressure_level: void 0
-};
-async function read_memory() {
-  if (process.platform === "darwin") return await settled(read_darwin_memory) ?? UNREAD_MEMORY;
-  return process.platform === "linux" ? await read_linux_memory() : UNREAD_MEMORY;
-}
-function is_unquoted() {
-  return cpus().length > 0 && cpus().length === availableParallelism2();
-}
-async function default_sleep(ms) {
-  await new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
+function pressured_available(before, after) {
+  if (after.available_mb === void 0) return void 0;
+  return is_pressured(before, after) ? 0 : after.available_mb;
 }
 async function read_machine(sleep = default_sleep) {
   const before = cpu_times();
-  const [memory] = await Promise.all([read_memory(), sleep(SAMPLE_WINDOW_MS)]);
+  const [memory_before] = await Promise.all([read_memory(), sleep(SAMPLE_WINDOW_MS)]);
+  const memory_after = await read_memory();
   const busy_cores = is_unquoted() ? busy_cores_between(before, cpu_times(), cpus().length) : void 0;
-  return { busy_cores, available_mb: memory.available_mb };
+  return {
+    busy_cores,
+    available_mb: pressured_available(memory_before, memory_after),
+    memory_pressured: is_pressured(memory_before, memory_after)
+  };
 }
 async function read_sample() {
   return { cpu: cpu_times(), memory: await read_memory(), total_mb: totalmem() / BYTES_PER_MB };
@@ -1120,210 +545,965 @@ function external_cores(busy_cores, ledger_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
+    memory_mb: reading.available_mb === void 0 ? Infinity : reading.available_mb + ledger.memory_mb,
+    memory_pressured: reading.memory_pressured
   };
 }
 var machine_capacity = {
   BASELINE_CORES,
   busy_cores_between,
   busy_share_between,
+  COMPRESSION_PRESSURE_MB,
   external_cores,
   machine_budget,
   parse_darwin_memory,
   parse_linux_available,
   parse_linux_swapped,
+  pressured_available,
   read_machine,
   read_memory,
   read_sample,
+  SWAP_PRESSURE_MB,
   swapped_between
 };
 
-// scripts/gate/core-budget.ts
-var RESERVED_PREFIX = "josh-core-reserved-";
-var RESERVED_SUFFIX = ".json";
-var POLL_INTERVAL_MS = 50;
-var WAIT_CAP_MS = 12e4;
-var MIN_BUDGET = 1;
-var CORE_WEIGHTS = {
-  lint: 2,
-  type_check: 1,
-  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: z2.number(),
-  claimed_at: z2.number(),
-  memory_mb: z2.number().optional(),
-  admitted_at: z2.number().optional()
-});
-function marker_name(key) {
-  return `${RESERVED_PREFIX}${key}${RESERVED_SUFFIX}`;
-}
-function is_running2(reservation) {
-  return process_identity.is_same_process(reservation.pid, reservation.process_start) !== false;
-}
-function read_reservation(source) {
-  const raw = stamp_file.read_stamp_text(source);
-  if (raw === void 0) return void 0;
-  return json_value.parse_with(raw, reservation_schema);
-}
-function sweep_marker2(source) {
-  try {
-    stamp_file.remove_stamp(source);
-  } catch {
-  }
-}
-function live_reservation(source) {
-  const reservation = read_reservation(source);
-  if (reservation === void 0) return void 0;
-  if (is_running2(reservation)) return reservation;
-  sweep_marker2(source);
-  return void 0;
-}
-function marker_files2(directory) {
-  try {
-    return readdirSync2(directory).filter(
-      (name) => name.startsWith(RESERVED_PREFIX) && name.endsWith(RESERVED_SUFFIX)
-    );
-  } catch {
-    return [];
-  }
-}
-function live_reservations(directory = PLATFORM_TEMP_ROOT) {
-  return marker_files2(directory).flatMap((name) => {
-    const reservation = live_reservation(path2.join(directory, name));
-    return reservation === void 0 ? [] : { key: name, reservation };
-  });
-}
-function normalize_budget(budget) {
-  return Number.isFinite(budget) ? Math.max(MIN_BUDGET, Math.floor(budget)) : MIN_BUDGET;
-}
-async function default_sleep2(ms) {
-  await new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-function write_reservation(target2, fields) {
-  stamp_file.replace_stamp(target2, { ...process_identity.own_fields(), ...fields });
-}
-function resolve_timing(options) {
-  return {
-    now: options.now ?? Date.now,
-    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) {
-  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 claimed_at = timing.now();
-  const name = marker_name(randomUUID());
-  const target2 = path2.join(directory, name);
-  const fields = { weight, claimed_at, memory_mb: options.memory_mb };
-  write_reservation(target2, fields);
-  const admission = await await_admission({
-    ...timing,
-    key: name,
-    target: target2,
-    directory,
-    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: target2, admission };
-}
-function release(handle) {
-  sweep_marker2(handle.target);
-}
-async function with_core_reservation(weight, run, options = {}) {
-  const handle = await reserve(weight, options);
-  try {
-    return await run(handle.admission);
-  } finally {
-    release(handle);
-  }
-}
-function is_held() {
-  return process.env[HELD_KEY] === HELD_VALUE;
-}
-function set_held_mark(value) {
-  process.env[HELD_KEY] = value;
-}
-async function with_held_mark(run) {
-  const previous = process.env[HELD_KEY] ?? "";
-  set_held_mark(HELD_VALUE);
-  try {
-    return await run();
-  } finally {
-    set_held_mark(previous);
+// scripts/gate/core-budget.ts
+var RESERVED_PREFIX = "josh-core-reserved-";
+var RESERVED_SUFFIX = ".json";
+var POLL_INTERVAL_MS = 50;
+var WAIT_CAP_MS = 12e4;
+var MIN_BUDGET = 1;
+var CORE_WEIGHTS = {
+  lint: 2,
+  type_check: 1,
+  spell_check: 1,
+  eslint_scan: 1,
+  format: 1,
+  retrospective: 1,
+  install: 1,
+  e2e: 2
+};
+var MEMORY_MB = {
+  lint: 2400,
+  type_check: 1300,
+  spell_check: 350,
+  eslint_scan: 2400,
+  unit_worker: 350,
+  format: 300,
+  retrospective: 900,
+  install: 100
+};
+var reservation_schema = process_owner_schema.extend({
+  weight: z2.number(),
+  claimed_at: z2.number(),
+  memory_mb: z2.number().optional(),
+  admitted_at: z2.number().optional(),
+  command: z2.string().optional(),
+  checkout: z2.string().optional(),
+  lane: z2.string().optional(),
+  lanes_root: z2.string().optional(),
+  wait_reason: z2.enum(core_wait.WAIT_REASONS).optional()
+});
+function marker_name(key) {
+  return `${RESERVED_PREFIX}${key}${RESERVED_SUFFIX}`;
+}
+function is_running2(reservation) {
+  return process_identity.is_same_process(reservation.pid, reservation.process_start) !== false;
+}
+function read_reservation(source) {
+  const raw = stamp_file.read_stamp_text(source);
+  if (raw === void 0) return void 0;
+  return json_value.parse_with(raw, reservation_schema);
+}
+function sweep_marker2(source) {
+  try {
+    stamp_file.remove_stamp(source);
+  } catch {
+  }
+}
+function live_reservation(source) {
+  const reservation = read_reservation(source);
+  if (reservation === void 0) return void 0;
+  if (is_running2(reservation)) return reservation;
+  sweep_marker2(source);
+  return void 0;
+}
+function marker_files2(directory) {
+  try {
+    return readdirSync2(directory).filter(
+      (name) => name.startsWith(RESERVED_PREFIX) && name.endsWith(RESERVED_SUFFIX)
+    );
+  } catch {
+    return [];
+  }
+}
+function live_reservations(directory = PLATFORM_TEMP_ROOT) {
+  return marker_files2(directory).flatMap((name) => {
+    const reservation = live_reservation(path3.join(directory, name));
+    return reservation === void 0 ? [] : { key: name, reservation };
+  });
+}
+function normalize_budget(budget) {
+  return Number.isFinite(budget) ? Math.max(MIN_BUDGET, Math.floor(budget)) : MIN_BUDGET;
+}
+async function default_sleep2(ms) {
+  await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function write_reservation(target2, fields) {
+  stamp_file.replace_stamp(target2, { ...process_identity.own_fields(), ...fields });
+}
+function report_wait(line) {
+  process.stderr.write(`${line}
+`);
+}
+function resolve_timing(options) {
+  return {
+    now: options.now ?? Date.now,
+    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
+  };
+}
+function mark_waiting(context, reason) {
+  const previous = context.fields.wait_reason;
+  if (previous === reason) return;
+  context.fields = { ...context.fields, wait_reason: reason };
+  write_reservation(context.target, context.fields);
+  if (previous === void 0) context.report(core_wait.wait_line(context.fields.command, reason));
+}
+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));
+  }
+  mark_waiting(context, core_wait.wait_reason(context.key, reservations, budget));
+  return void 0;
+}
+async function await_admission(context) {
+  let admission = await poll_admission(context);
+  while (admission === void 0) {
+    await context.sleep(context.poll_interval_ms);
+    admission = await poll_admission(context);
+  }
+  return admission;
+}
+function resolve_ports(options) {
+  return {
+    read_machine: options.read_machine ?? machine_capacity.read_machine,
+    report: options.report ?? report_wait
+  };
+}
+function claim_fields(weight, claimed_at, options) {
+  const { memory_mb, command } = options;
+  return { weight, claimed_at, memory_mb, command, ...core_wait.where_of(process.cwd()) };
+}
+async function reserve(weight, options = {}) {
+  const timing = resolve_timing(options);
+  const directory = options.directory ?? PLATFORM_TEMP_ROOT;
+  const claimed_at = timing.now();
+  const name = marker_name(randomUUID());
+  const target2 = path3.join(directory, name);
+  const fields = claim_fields(weight, claimed_at, options);
+  write_reservation(target2, fields);
+  const admission = await await_admission({
+    ...timing,
+    key: name,
+    target: target2,
+    directory,
+    budget: normalize_budget(options.budget ?? availableParallelism3()),
+    deadline: claimed_at + timing.wait_cap_ms,
+    fields,
+    ...resolve_ports(options)
+  });
+  return { target: target2, admission };
+}
+function budget_waits(directory = PLATFORM_TEMP_ROOT, now = Date.now(), home = process.cwd()) {
+  return core_wait.waits_of(live_reservations(directory), now, home);
+}
+function release(handle) {
+  sweep_marker2(handle.target);
+}
+async function with_core_reservation(weight, run, options = {}) {
+  const handle = await reserve(weight, options);
+  try {
+    return await run(handle.admission, path3.basename(handle.target));
+  } finally {
+    release(handle);
+  }
+}
+async function with_command_reservation(weight, run, options = {}) {
+  if (held_mark.is_held() || unit_worker_share.is_nested_run()) return await run();
+  return await with_core_reservation(
+    weight,
+    async (_admission, key) => await held_mark.with_held_mark(run, key),
+    options
+  );
+}
+var core_budget = {
+  CORE_WEIGHTS,
+  HELD_KEY: held_mark.HELD_KEY,
+  HELD_VALUE: held_mark.HELD_VALUE,
+  MEMORY_MB,
+  RESERVED_PREFIX,
+  admitted_keys: core_admission.admitted_keys,
+  admitted_load: core_admission.admitted_load,
+  budget_waits,
+  describe_overflow: core_admission.describe_overflow,
+  is_held: held_mark.is_held,
+  live_reservations,
+  release,
+  reserve,
+  with_command_reservation,
+  with_core_reservation,
+  with_held_mark: held_mark.with_held_mark
+};
+
+// scripts/josh/josh-command-types.ts
+var OPTIONAL_ENV_FILE_FLAGS = [`--env-file-if-exists=${ENV_FILE_NAME}`];
+var GATE_COMMAND2 = "gate";
+var ESLINT_CACHE_FILE = ".eslintcache";
+var TS_BUILD_INFO_FILE = ".tsbuildinfo";
+var CSPELL_CACHE_FILE = ".cspellcache";
+var ESLINT_EDIT_CACHE_FILE = ".eslintcache.edit";
+var ESLINT_RELATED_CACHE_FILE = ".eslintcache.related";
+var PRETTIER_CACHE_FILE = ".prettiercache";
+var PRETTIER_RELATED_CACHE_FILE = ".prettiercache.related";
+var CSPELL_COMMIT_CACHE_FILE = ".cspellcache.commit";
+var ESLINT_COMMIT_CACHE_FILE = ".eslintcache.commit";
+var ROOTED_JSON_PORTABILITY = "rooted-json";
+var ESLINT_CACHE_SPEC = {
+  cache_file: ESLINT_CACHE_FILE,
+  portability: ROOTED_JSON_PORTABILITY
+};
+var TS_CACHE_SPEC = {
+  cache_file: TS_BUILD_INFO_FILE,
+  portability: "raw"
+};
+var CSPELL_CACHE_SPEC = {
+  cache_file: CSPELL_CACHE_FILE,
+  portability: "raw"
+};
+var GATE_CACHE_SPECS = [
+  ESLINT_CACHE_SPEC,
+  TS_CACHE_SPEC,
+  CSPELL_CACHE_SPEC
+];
+var GATE_CACHE_FILES = GATE_CACHE_SPECS.map((spec) => spec.cache_file);
+var IGNORED_CACHE_FILES = [
+  ...GATE_CACHE_FILES,
+  ESLINT_EDIT_CACHE_FILE,
+  ESLINT_RELATED_CACHE_FILE,
+  PRETTIER_CACHE_FILE,
+  PRETTIER_RELATED_CACHE_FILE,
+  CSPELL_COMMIT_CACHE_FILE,
+  ESLINT_COMMIT_CACHE_FILE
+];
+var CONTENT_CACHE_FLAGS = ["--cache", "--cache-strategy", "content"];
+var CACHE_LOCATION_FLAG = "--cache-location";
+function content_cache_flags(cache_file) {
+  return [...CONTENT_CACHE_FLAGS, CACHE_LOCATION_FLAG, cache_file];
+}
+var ESLINT_CACHE_FLAGS = content_cache_flags(ESLINT_CACHE_FILE);
+var ESLINT_EDIT_CACHE_FLAGS = content_cache_flags(ESLINT_EDIT_CACHE_FILE);
+var ESLINT_RELATED_CACHE_FLAGS = content_cache_flags(ESLINT_RELATED_CACHE_FILE);
+var CSPELL_CACHE_FLAGS = content_cache_flags(CSPELL_CACHE_FILE);
+var PRETTIER_CACHE_FLAGS = content_cache_flags(PRETTIER_CACHE_FILE);
+var PRETTIER_RELATED_CACHE_FLAGS = content_cache_flags(PRETTIER_RELATED_CACHE_FILE);
+var CSPELL_COMMIT_CACHE_FLAGS = content_cache_flags(CSPELL_COMMIT_CACHE_FILE);
+var ESLINT_COMMIT_CACHE_FLAGS = content_cache_flags(ESLINT_COMMIT_CACHE_FILE);
+
+// scripts/josh/josh-commands-backlog.ts
+var BACKLOG_COMMANDS = {
+  // Started from a terminal: the `backlogrun` keyword's launcher, and the board.
+  backlogrun: {
+    script: "scripts/backlog/backlogrun-cli.ts",
+    description: "Start a backlogrun in the background and show its board; with one already running, only show the board, or replace it when it is idle and the invocation differs; --stop stops it",
+    category: "AI tools",
+    reference: [
+      "[<n>...] [--only] [--max <n>] [--idle <minutes>] [--agent claude|codex] | --stop",
+      "developer",
+      ["files", "network", "processes"]
+    ]
+  },
+  "backlog:next": {
+    script: "scripts/backlog/backlog-next.ts",
+    description: "Order the whole opted-in backlog: auto-ok issues and the descendants of auto-ok epics, transitively through nested epics",
+    category: "AI tools",
+    reference: ["[--exclude <n>[,<n>...]] [--repo <owner/repo>]", "automation", ["network"]]
+  },
+  "backlog:offer": {
+    script: "scripts/backlog/backlog-offer-cli.ts",
+    description: "Collapse a backlogrun loop-head event into one call: read backlog:next, ask backlog:budget, return the verdict and any issues to start",
+    category: "AI tools",
+    reference: ["[options]", "automation", ["files", "network", "processes"]]
+  },
+  "backlog:drive": {
+    script: "scripts/backlog/backlog-drive-cli.ts",
+    description: "Drive backlogrun through offer, launch and merge; restore this run\u2019s lanes and report when complete",
+    category: "AI tools",
+    reference: ["--owner <pid> [options]", "automation", ["network"]]
+  },
+  "backlog:plan": {
+    script: "scripts/backlog/backlog-plan-cli.ts",
+    description: "Print the whole backlog as a plan: ready now, waiting on what, waiting on a person, out of scope",
+    category: "AI tools",
+    reference: [
+      "[issue...] [--only] [--waves] [--exclude <n>[,<n>...]]",
+      "automation",
+      ["network"]
+    ]
+  },
+  "backlog:stalled": {
+    script: "scripts/backlog/backlog-stalled-cli.ts",
+    // A stall sends one Telegram warning. The `Stop` hook calls the detector
+    // directly, so this flag costs only the manual command its in-process dispatch.
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
+    description: "Report whether ready backlog work is sitting undispatched with a free lane and no recent dispatch",
+    category: "AI tools",
+    reference: ["", "automation", ["network"]]
+  },
+  "backlog:budget": {
+    script: "scripts/backlog/backlog-budget-cli.ts",
+    description: "Say whether a backlogrun may start more work, keep watching, or finish",
+    category: "AI tools",
+    reference: ["[options]", "automation", ["none"]]
+  }
+};
+
+// scripts/josh/josh-commands-document.ts
+var DOCUMENT_COMMANDS = {
+  "doc:section": {
+    script: "scripts/document/document-section-cli.ts",
+    description: 'Print one section of a markdown document, for a `file.md` \u2192 "Heading" reference',
+    category: "AI tools",
+    reference: ["<file> <heading>", "automation", ["none"]],
+    is_bundled: true
+  },
+  "read:set": {
+    script: "scripts/document/read-set-cli.ts",
+    description: "Print what an entry point reads before it starts, and what that read costs",
+    category: "AI tools",
+    reference: ["[<entry>] [--json]", "automation", ["none"]]
+  },
+  "doc:read": {
+    script: "scripts/document/document-read-cli.ts",
+    description: "Read a whole document safely: print it, or point at the Read tool when over the Bash cap",
+    category: "AI tools",
+    reference: ["<file>", "automation", ["none"]]
+  },
+  "read:files": {
+    script: "scripts/document/read-files-cli.ts",
+    description: "Read several files in one call so edit targets fold into one turn",
+    category: "AI tools",
+    reference: ["<path> [<path> ...]", "automation", ["none"]]
+  },
+  "edit:files": {
+    script: "scripts/document/edit-files-cli.ts",
+    description: "Apply several content-addressed edits from a plan in one call",
+    category: "AI tools",
+    reference: ["<plan-path | ->", "automation", ["none"]]
+  }
+};
+
+// scripts/josh/josh-commands-guard.ts
+var GUARD_COMMANDS = {
+  "investigation:guard": {
+    script: "scripts/delegation/investigation-guard.ts",
+    description: "Claude Code hook: refuse a read once the unedited-read threshold is reached again (reads the tool call on stdin)",
+    category: "AI tools",
+    reference: ["", "automation", ["none"]]
+  },
+  "duplicate-read:guard": {
+    script: "scripts/delegation/duplicate-read-guard.ts",
+    description: "Claude Code hook: refuse a second whole-file read of a path whose content has not changed since the run last read it (reads the tool call on stdin)",
+    category: "AI tools",
+    reference: ["", "automation", ["none"]]
+  },
+  "rule:guard": {
+    script: "scripts/rules/rule-guard.ts",
+    description: "Claude Code hook: deliver a trigger-delivered rule at the call that binds it (reads the tool call on stdin)",
+    category: "AI tools",
+    reference: ["", "automation", ["none"]]
+  }
+};
+
+// scripts/josh/josh-commands-issue.ts
+var ISSUES_WITH_REPO = "<issue...> [--repo <owner/repo>]";
+var ISSUE_COMMANDS = {
+  "issue:ack": {
+    script: "scripts/issue/issue-ack-cli.ts",
+    description: "Record that the run read a person's update to its issue, printing the update it acknowledges",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["network"]]
+  },
+  "issue:read": {
+    script: "scripts/issue/issue-read-cli.ts",
+    description: "Print each issue's title, body and every comment on it, in one call",
+    category: "AI tools",
+    reference: ["<issue...>", "automation", ["network"]]
+  },
+  "issue:state": {
+    script: "scripts/issue/issue-state-cli.ts",
+    description: "Print each issue's state and labels, in the spelling the documents compare against",
+    category: "AI tools",
+    reference: [ISSUES_WITH_REPO, "automation", ["network"]]
+  },
+  "issue:scout": {
+    script: "scripts/issue/issue-scout-cli.ts",
+    description: "Before filing: say whether an issue like this exists and which epic it belongs to",
+    category: "AI tools",
+    reference: ["<title> [--body <summary> | --body-file <path>]", "automation", ["network"]]
+  },
+  "defect:rate": {
+    script: "scripts/issue/defect-rate-cli.ts",
+    description: "Print the defect rate of merged work: defects filed per enhancement completed",
+    category: "AI tools",
+    reference: ["[--days <n>]", "automation", ["network"]]
+  },
+  "issue:fold": {
+    script: "scripts/issue/issue-fold-cli.ts",
+    description: "Before a second filing: say whether findings from this session fold into one issue",
+    category: "AI tools",
+    reference: ["<title>... [--not-separable] [--json]", "automation", ["none"]]
+  },
+  "issue:fold-existing": {
+    script: "scripts/issue/issue-fold-existing-cli.ts",
+    description: "Assess whether a complete draft can join an unstarted issue",
+    category: "AI tools",
+    reference: ["<assessment.json> [--json]", "automation", ["none"]]
+  },
+  "issue:cite": {
+    script: "scripts/issue/issue-cite-cli.ts",
+    description: "Print the paste-ready number-link citation line for each issue, in one call",
+    category: "AI tools",
+    reference: [ISSUES_WITH_REPO, "automation", ["network"]]
+  },
+  "issue:comment": {
+    script: "scripts/issue/issue-comment-cli.ts",
+    description: "Post one comment to an issue from a file, so no shell expands the body",
+    category: "AI tools",
+    reference: ["<issue> --body <text> | --body-file <path>", "automation", ["network"]]
+  },
+  "issue:file": {
+    script: "scripts/issue/issue-file-cli.ts",
+    description: "File an Issue with every filing step: lint, Origin, fold, 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] [--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 (or, with --wait, as waiting on it), filing one when none is open",
+    category: "AI tools",
+    reference: ["<issue> [--wait]", "automation", ["network"]]
+  }
+};
+
+// scripts/josh/josh-commands-lane.ts
+var LANE_SCRIPT = "scripts/lane/lane-cli.ts";
+var LANE_ARGUMENTS = { script: LANE_SCRIPT, tsx_arguments: OPTIONAL_ENV_FILE_FLAGS };
+var ISSUE_WITH_OPTIONS = "<issue> [options]";
+var MEASURE_ARGUMENTS = {
+  script: "scripts/lane/lane-measure-cli.ts",
+  tsx_arguments: OPTIONAL_ENV_FILE_FLAGS
+};
+var LANE_COMMANDS = {
+  "lane:open": {
+    ...LANE_ARGUMENTS,
+    description: "Open a lane: a linked work tree with its own branch and its own port seed",
+    category: "AI tools",
+    reference: [ISSUE_WITH_OPTIONS, "automation", ["files", "git"]],
+    default_script_arguments: ["open"]
+  },
+  "lane:close": {
+    ...LANE_ARGUMENTS,
+    description: "Close a lane, leaving no work tree, branch or directory behind",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["files", "git"]],
+    default_script_arguments: ["close"]
+  },
+  "lane:list": {
+    ...LANE_ARGUMENTS,
+    description: "List the open lanes: which issue, which ports, and where each one is",
+    category: "AI tools",
+    reference: ["", "automation", ["none"]],
+    default_script_arguments: ["list"]
+  },
+  "lane:prune": {
+    ...LANE_ARGUMENTS,
+    description: "Close every lane an interruption left without its work tree and every spent lane, then sweep unregistered leftovers under the lanes root",
+    category: "AI tools",
+    reference: ["", "automation", ["files", "git"]],
+    default_script_arguments: ["prune"]
+  },
+  "lane:output": {
+    ...LANE_ARGUMENTS,
+    description: "Record, or read back, where the unit running a lane\u2019s child writes",
+    category: "AI tools",
+    reference: ["<issue> [path]", "automation", ["files"]],
+    default_script_arguments: ["output"]
+  },
+  "lane:dispatch": {
+    ...LANE_ARGUMENTS,
+    description: "Start a lane\u2019s child as a detached process that outlives this session",
+    category: "AI tools",
+    reference: ["<issue> <prompt>", "automation", ["processes"]],
+    default_script_arguments: ["dispatch"]
+  },
+  "lane:await": {
+    ...LANE_ARGUMENTS,
+    description: "Block until any of the named in-flight lane children completes; prints which one finished",
+    category: "AI tools",
+    reference: ["<issue> [<issue>...] [--owner <pid>]", "automation", ["files", "processes"]],
+    default_script_arguments: ["await"]
+  },
+  "lane:launch": {
+    script: "scripts/lane/lane-launch-cli.ts",
+    description: "Collapse a backlogrun lane-start event into one call: open the lane, pop and re-install on the first, dispatch the child",
+    category: "AI tools",
+    reference: ["<issue> [--stash <message>]", "automation", ["files", "git", "processes"]]
+  },
+  // `.env` is read for `JOSH_LANE_ROOT`, as every lane command reads it, so the lane is found.
+  "lane:restart": {
+    script: "scripts/lane/lane-restart-cli.ts",
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
+    description: "Stop a running lane child, stash its uncommitted work and re-dispatch its issue in a fresh session \u2014 not counted as an outage or a failure",
+    category: "AI tools",
+    reference: ["<issue>", "developer", ["files", "git", "processes", "network"]]
+  },
+  // `.env` is read for `JOSH_LANE_ROOT`, as every lane command reads it, so the lane is found.
+  "lane:withdraw": {
+    script: "scripts/lane/lane-withdraw-cli.ts",
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
+    description: "Stop a running lane child, stash its uncommitted work, close its issue as not planned and close the lane \u2014 booked withdrawn, not as an outage or a failure",
+    category: "AI tools",
+    reference: ["<issue> --reason <text>", "developer", ["files", "git", "processes", "network"]]
+  },
+  // A live run's lane limit: `.env` is read so the bare form reports the
+  // `JOSH_LANE_LIMIT` a person set there when no override stands.
+  "lane:limit": {
+    script: "scripts/lane/lane-limit-cli.ts",
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
+    description: "Change a live backlogrun\u2019s lane limit without stopping it, or print the limit, lanes in use and free lanes",
+    category: "AI tools",
+    reference: ["[<limit>] [--reset]", "developer", ["files"]]
+  },
+  // The lane-limit measurement: `.env` is read so `lane:stats` labels the row
+  // with the `JOSH_LANE_LIMIT` a person set there.
+  "lane:sample": {
+    ...MEASURE_ARGUMENTS,
+    description: "Record the machine load (load average, swap, free memory, working lanes) to the lane ledger \u2014 a backlogrun samples itself, this is for a reading outside one",
+    category: "AI tools",
+    reference: ["[--every <seconds>]", "maintainer", ["files"]],
+    default_script_arguments: ["sample"]
+  },
+  "lane:stats": {
+    ...MEASURE_ARGUMENTS,
+    description: "Print one table row of lane throughput, gate duration and machine load over a period, the per-stage durations of a lane under it, the wait after each ship stop reason under those, and the duration and reuse count of each gate check last",
+    category: "AI tools",
+    reference: ["--period <days> [--limit <lane-limit>]", "maintainer", ["none"]],
+    default_script_arguments: ["stats"]
+  }
+};
+
+// scripts/josh/josh-commands-run.ts
+var RUN_HOLD_SCRIPT = "scripts/run/hold/run-hold-cli.ts";
+var RUN_COMMANDS = {
+  "run:hold": {
+    script: RUN_HOLD_SCRIPT,
+    description: "Claim this working tree for a run, or say which run already holds it",
+    category: "AI tools",
+    reference: ["[<issue> [--fullrun | --halfrun-stop | --prrun-stop]]", "automation", ["files"]]
+  },
+  "run:release": {
+    script: RUN_HOLD_SCRIPT,
+    description: "Release this working tree's run record",
+    category: "AI tools",
+    reference: ["[issue|--force]", "automation", ["files"]],
+    default_script_arguments: ["--release"]
+  },
+  "run:tidy": {
+    script: "scripts/run/tidy/run-tidy-cli.ts",
+    description: "Close merged lanes and drop stashes whose issues are all merged",
+    category: "AI tools",
+    reference: ["", "automation", ["git", "network", "files"]]
+  },
+  "run:carry": {
+    script: "scripts/run/carry/run-carry-cli.ts",
+    // `--stopped` sends the stop confirmation, so the Telegram credentials come from `.env` as for
+    // `run:wake` below.
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
+    description: "Carry one invocation\u2019s budget across its own session cuts",
+    category: "AI tools",
+    reference: ["<operation> [arguments...]", "automation", ["files"]]
+  },
+  "run:add": {
+    script: "scripts/run/add/run-add-cli.ts",
+    description: "Add issues to a live backlogrun, ahead of the queue unless --no-priority",
+    category: "AI tools",
+    reference: ["<issue...> [--no-priority]", "automation", ["network", "files"]]
+  },
+  "run:wake": {
+    script: "scripts/run/wake/run-wake-cli.ts",
+    // `.env` rather than the ambient environment:
+    // the failure warning needs the Telegram credentials, the same
+    // reasons `notify` and `followup` carry these flags.
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
+    description: "Wake the next session of a cut backlogrun from outside the conversation",
+    category: "AI tools",
+    reference: ["[options]", "automation", ["processes", "notifications"]]
+  },
+  "run:cut": {
+    script: "scripts/run/cut/run-cut-cli.ts",
+    description: "Cut a lane child before the gate and resume a fresh process",
+    category: "AI tools",
+    reference: ["[--resume] <issue> [--impl] [--handoff <path>]", "automation", ["files"]]
+  },
+  "run:liveness": {
+    script: "scripts/run/run-liveness-cli.ts",
+    description: "Say whether a delegated unit is still working, or stopped without reporting",
+    category: "AI tools",
+    reference: ["<issue> --output <path> [options]", "automation", ["processes"]]
+  },
+  "run:ending": {
+    script: "scripts/run/run-ending-cli.ts",
+    description: "Classify how a dispatched lane child ended (merged, cut, abandoned, unreadable)",
+    category: "AI tools",
+    reference: ["<issue> --output <path> [--repo <owner/repo>]", "automation", ["network"]]
+  },
+  "run:progress": {
+    script: "scripts/run/progress/run-progress-cli.ts",
+    description: "Report an unattended run\u2019s progress once it has gone quiet for an interval",
+    category: "AI tools",
+    reference: [
+      "[--once | --wait] [--interval <minutes>] [--hours <hours>] [--repo <owner/repo>] [--output <path>] | --mark | --path",
+      "automation",
+      ["files"]
+    ]
+  },
+  "run:board": {
+    script: "scripts/run/board/run-board-cli.ts",
+    // `--every` pushes its frame as a Telegram, so the credentials come from `.env` as for `run:carry`.
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
+    description: "Draw a live board of the running backlogrun, redrawn every second",
+    category: "AI tools",
+    reference: ["[--once | --chat | --every <minutes>]", "automation", ["files", "network"]]
+  },
+  "run:prep": {
+    script: "scripts/run/run-prep-cli.ts",
+    description: "Bundle a run\u2019s pre-edit reads: body, comments, state, dependency scope",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["network"]]
+  },
+  // The entry sequence a lane opened on, folded into one call: claim the tree,
+  // read the budget, gather the issue reads and decide the pre-implementation step. `run:hold`,
+  // `cost --cut`, `run:prep` and `run:step` were four round trips re-billing a lane's full context each.
+  "run:entry": {
+    script: "scripts/run/entry/run-entry-cli.ts",
+    // A `busy` hold or an `over` budget sends the stop confirmation.
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
+    description: "Open a run in one call: claim the tree, read the budget, bundle the reads, decide the pre-implementation step",
+    category: "AI tools",
+    reference: ["<issue> [--to <command>]", "automation", ["git", "network", "files"]]
+  },
+  "run:status": {
+    script: "scripts/run/run-status-cli.ts",
+    description: "Bundle a run\u2019s read-only status: issue state, cost verdict, carry counters",
+    category: "AI tools",
+    reference: ["<issue> [--repo <owner/repo>]", "automation", ["network"]]
+  },
+  "run:next": {
+    script: "scripts/run/run-next-cli.ts",
+    description: "Print the next step a fullrun takes, computed from the run\u2019s state",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["network"]]
+  },
+  "run:step": {
+    script: "scripts/run/run-step-cli.ts",
+    description: "Print the run\u2019s next single action, computed from the event stream, carry record and issue state",
+    category: "AI tools",
+    reference: ["[<issue>]", "automation", ["network", "files"]]
+  }
+};
+
+// scripts/josh/josh-commands-split.ts
+var SPLIT_COMMANDS = {
+  "split:assess": {
+    script: "scripts/split/split-assess-cli.ts",
+    description: "Measure the branch change size (tests excluded) and answer the split assessment size question: split | single",
+    category: "AI tools",
+    reference: ["[--json]", "automation", ["none"]]
+  }
+};
+
+// scripts/josh/josh-commands-ai.ts
+var ISSUE_WITH_OPTIONS2 = "<issue> [options]";
+var AI_COMMANDS = {
+  ...ISSUE_COMMANDS,
+  "pkg:scout": {
+    script: "scripts/package/package-scout-cli.ts",
+    description: "Rank package candidates by measured metrics so the Package-First tier decision is read, not judged",
+    category: "AI tools",
+    reference: ["<keywords> [--size <n>]", "automation", ["network"]]
+  },
+  "stash:pop": {
+    script: "scripts/git/stash/stash-pop-cli.ts",
+    description: "Pop the stash matching this message, not whichever a shared stack has on top",
+    category: "AI tools",
+    reference: ["<message>", "automation", ["git"]]
+  },
+  epic: {
+    script: "scripts/epic/epic.ts",
+    description: "Create an epic issue from its child issue numbers",
+    category: "AI tools",
+    reference: ["<title> <issue...> [--ordered]", "automation", ["network"]]
+  },
+  "epic:next": {
+    script: "scripts/epic/epic-next.ts",
+    description: "List an epic's runnable children, bundled per repository",
+    category: "AI tools",
+    reference: ["<epic>... [--repo <owner/repo>] [--lanes]", "automation", ["network"]]
+  },
+  "epic:bundle": {
+    script: "scripts/epic/epic-bundle-cli.ts",
+    description: "Say whether a newly filed issue belongs with ones already in the backlog",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["network"]]
+  },
+  "epic:audit": {
+    script: "scripts/epic/epic-audit-cli.ts",
+    description: "Audit an epic's children against each other for contradictions",
+    category: "AI tools",
+    reference: ["<epic>", "automation", ["network"]]
+  },
+  "epic:check": {
+    script: "scripts/epic/epic-check.ts",
+    description: "Check an epic issue against the tracking requirements",
+    category: "AI tools",
+    reference: ["<epic>", "automation", ["network"]]
+  },
+  "auto-ok:next": {
+    script: "scripts/auto-ok/auto-ok-cli.ts",
+    description: "Print the next opted-in issue an unattended run may pick up outside an epic",
+    category: "AI tools",
+    reference: ["[--exclude <n>[,<n>...]] [--label <name>]", "automation", ["network"]]
+  },
+  "auto-ok:judge": {
+    script: "scripts/auto-ok/auto-ok-judge-cli.ts",
+    description: "List the open issues backlogrun owes an auto-ok judgement, or record one (--apply / --decline)",
+    category: "AI tools",
+    reference: [
+      "[--apply <n> (--lane | --solo) | --decline <n> --reason <text>]",
+      "automation",
+      ["network"]
+    ]
+  },
+  ...BACKLOG_COMMANDS,
+  cost: {
+    script: "scripts/cost-runtime/cost-cli.ts",
+    description: "Say whether the next turn of a run crosses the context-cut threshold (--cut) or a given tokens-per-request figure (--over)",
+    category: "AI tools",
+    reference: ["(--cut | --over <tokens-per-request>) [--path <dir>]", "automation", ["none"]]
+  },
+  "cost:audit": {
+    script: "scripts/cost-audit/cost-audit-cli.ts",
+    description: "Report AI cost over a period by session kind, tool category and guard, with cost per merge and regressions against the period before",
+    category: "AI tools",
+    reference: ["[--period <days>]", "maintainer", ["none"]],
+    // Kit-only: it reads kit's own transcript store, like `josh retrospective`, which carries its
+    // summary line.
+    is_kit_only: true
+  },
+  ...DOCUMENT_COMMANDS,
+  time: {
+    script: "scripts/time/time-cli.ts",
+    description: "Report where a run's wall clock went: model wait, tool execution, human wait",
+    category: "AI tools",
+    reference: ["[options]", "maintainer", ["none"]],
+    // Kit-only: it measures kit's own development runs and its report modules live under the
+    // undistributed `scripts/time/`, so it means nothing in a consumer project and is dropped from a
+    // consumer's help. The runtime analysis hooks and guards rely on stays
+    // distributed under `scripts/time-runtime/`.
+    is_kit_only: true
+  },
+  // The tool-calls-per-round-trip density the batching guard is measured on, aggregated across the
+  // recent lane sessions. Kit-only for the same reason `time` is: it reads
+  // kit's own lane transcripts and means nothing in a consumer project.
+  "time:density": {
+    script: "scripts/time/time-density-cli.ts",
+    description: "Report tool calls per round trip across the recent lane sessions",
+    category: "AI tools",
+    reference: ["[--lanes <n>] [--path <dir>]", "maintainer", ["none"]],
+    is_kit_only: true
+  },
+  retrospective: {
+    script: "scripts/retrospective/retrospective-cli.ts",
+    description: "Aggregate a finished run's cost, review findings, observation ledger and events into one digest",
+    category: "AI tools",
+    reference: ["", "maintainer", ["none"]],
+    core_weight: core_budget.CORE_WEIGHTS.retrospective,
+    memory_mb: core_budget.MEMORY_MB.retrospective,
+    // Kit-only: it reads kit's own development run — the transcript store, the review ledger and the
+    // run event stream — so it means nothing in a consumer project and is dropped from a consumer's
+    // help, through the same declaration `josh time` uses for the same reason.
+    is_kit_only: true
+  },
+  "review:brief": {
+    script: "scripts/review/review-brief-cli.ts",
+    description: "Print the whole /code-review invocation: level, what the gate already proved, target (--level-only for the level alone)",
+    category: "AI tools",
+    reference: ["[--round <1|2>] | --level-only [--staged] [--json]", "automation", ["files"]]
+  },
+  "review:attest": {
+    script: "scripts/review/review-attest-cli.ts",
+    description: "Record, or verify, which checkout a /code-review actually read",
+    category: "AI tools",
+    reference: ["<nonce> | --check", "automation", ["files"]]
+  },
+  "review:round2": {
+    script: "scripts/review/review-round2-cli.ts",
+    description: "Say whether the second /code-review round is due, or may be skipped entirely",
+    category: "AI tools",
+    reference: ["[--round-1-closed] [--json]", "automation", ["none"]]
+  },
+  delegate: {
+    script: "scripts/delegation/delegation-cli.ts",
+    description: "Say whether a run step may go to a cheaper execution tier",
+    category: "AI tools",
+    reference: ["<step> | --list", "automation", ["none"]]
+  },
+  fanout: {
+    script: "scripts/delegation/fanout-cli.ts",
+    description: "Say whether proposed implementation units are file-disjoint, so they may run in parallel",
+    category: "AI tools",
+    reference: ["<unit-files> <unit-files> [<unit-files> \u2026]", "automation", ["none"]]
+  },
+  ...RUN_COMMANDS,
+  "repo:party": {
+    script: "scripts/discovery/repo-party-cli.ts",
+    description: "Say whether a repository is first-party or third-party by owner equality (computed, not judged)",
+    category: "AI tools",
+    reference: ["[<owner/repo>]", "automation", ["none"]]
+  },
+  "run:merge": {
+    script: "scripts/run/merge/run-merge-cli.ts",
+    description: "Collapse a backlogrun merge event into one call: confirm the child, do the post-merge steps, offer the next child",
+    category: "AI tools",
+    reference: [ISSUE_WITH_OPTIONS2, "automation", ["git", "network"]]
+  },
+  "run:review": {
+    script: "scripts/run/review/run-review-cli.ts",
+    description: "Start the gate in the background and print the /code-review brief in one call so the two overlap (--join to join the gate and check its verdict)",
+    category: "AI tools",
+    reference: ["[--join]", "automation", ["processes", "files"]]
+  },
+  // The post-merge sequence a run closed on, folded into one call: commit the
+  // observation ledger, read the completion citations and decide the release scope. `observations:flush`,
+  // `issue:cite` and `release:scope` were three round trips re-billing the run's full context each.
+  "run:tail": {
+    script: "scripts/run/run-tail-cli.ts",
+    description: "Close a run in one call: return to the default branch, commit the observation ledger, read the citations, decide the release scope",
+    category: "AI tools",
+    reference: ["[<issue> ...]", "automation", ["git", "network"]]
+  },
+  // The commit-to-report region a run ships a change on, folded into one call:
+  // the gate, the commit/push/PR (`git -y`), the CI-wait merge (`followup`) and the report bookkeeping
+  // (`run:tail`) were four round trips re-billing the run's full context each. It stops at the first
+  // failed step and names it, so the run reads only the step to fix.
+  ship: {
+    script: "scripts/run/ship/run-ship-cli.ts",
+    description: "Ship a change in one call: gate, commit/push/PR, the CI-wait merge and the report bookkeeping, stopping at the first failed step",
+    category: "AI tools",
+    reference: [
+      '"<title> #<N>" [<follow-up-N> ...] [--cite <N>] [--review] [--detach] [--body-file <path>] [--notify-message <text> | --notify-message-file <path>] | --log <N>',
+      "automation",
+      ["git", "network"]
+    ]
+  },
+  "run:event": {
+    script: "scripts/run/event/run-event-cli.ts",
+    description: "Append to, read or watch the run\u2019s append-only event stream (--append <kind> <text> | --from|--follow <n> | --watch [<n>] | --last)",
+    category: "AI tools",
+    reference: [
+      "--append <kind> <text> | --from|--follow <n> | --watch [<n>] | --last",
+      "automation",
+      ["files"]
+    ]
+  },
+  "run:report": {
+    script: "scripts/run/run-report-cli.ts",
+    description: "Generate the session-facing report for this invocation from the run\u2019s event stream (merges, parks, cuts) with the release tail \u2014 the same text josh notify sends",
+    category: "AI tools",
+    reference: ["", "automation", ["files", "network"]]
+  },
+  ...LANE_COMMANDS,
+  ...GUARD_COMMANDS,
+  "run:watcher:guard": {
+    script: "scripts/run/run-watcher-guard-cli.ts",
+    description: "Guard: exits non-zero when lane children are in-flight but the watcher has not pinged recently",
+    category: "AI tools",
+    reference: ["", "automation", ["none"]]
+  },
+  "run:stranded": {
+    script: "scripts/run/run-stranded-cli.ts",
+    // `.env` rather than the ambient environment: the strand notification needs the Telegram
+    // credentials, the same reason `run:wake` carries these flags.
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
+    description: "Report whether the run is stranded \u2014 owner gone, no successor holding the budget, and no supervisor watching",
+    category: "AI tools",
+    reference: ["", "automation", ["processes", "notifications"]]
+  },
+  ...SPLIT_COMMANDS,
+  "oracle:list": {
+    script: "scripts/rules/oracle-list-cli.ts",
+    description: "Print the decision oracles \u2014 commands that answer a rule question mechanically",
+    category: "AI tools",
+    reference: ["", "automation", ["none"]]
+  },
+  eval: {
+    script: "scripts/eval/eval-run.ts",
+    description: "Run the agent rule-compliance scenarios (real Claude sessions)",
+    category: "AI tools",
+    reference: ["[scenario...]", "maintainer", ["processes", "network"]],
+    // Kit-only: it replays kit's own distributed rules against real Claude sessions, so it means
+    // nothing in a consumer project and is dropped from a consumer's help.
+    is_kit_only: true
+  }
+};
+
+// scripts/josh/josh-commands-clone.ts
+var CLONE_COMMANDS = {
+  "clone:scan": {
+    script: "scripts/clone/clone-scan-cli.ts",
+    description: "Count code duplication across files and first-party repositories, printing each clone as file:line pairs",
+    category: "AI tools",
+    reference: ["", "automation", ["files"]]
   }
-}
-async function with_command_reservation(weight, run, options = {}) {
-  if (is_held() || unit_worker_share.is_nested_run()) return await run();
-  return await with_core_reservation(weight, async () => await with_held_mark(run), options);
-}
-var core_budget = {
-  CORE_WEIGHTS,
-  HELD_KEY,
-  HELD_VALUE,
-  MEMORY_MB,
-  RESERVED_PREFIX,
-  admitted_keys: core_admission.admitted_keys,
-  admitted_load: core_admission.admitted_load,
-  describe_overflow: core_admission.describe_overflow,
-  is_held,
-  live_reservations,
-  release,
-  reserve,
-  with_command_reservation,
-  with_core_reservation,
-  with_held_mark
 };
 
 // scripts/gate/gate-plan.ts
@@ -1389,6 +1569,7 @@ var TYPE_CHECK_LABEL = "check";
 var UNIT_LABEL = "test:unit";
 var BEHAVIOR_LABEL = "behavior";
 var METRICS_LABEL = "metrics";
+var EXPORTS_LABEL = "exports";
 var WARNING_CHECKER_LABELS = [LINT_LABEL, TYPE_CHECK_LABEL];
 var STATIC_CHECKS = [
   {
@@ -1414,7 +1595,7 @@ var STATIC_CHECKS = [
   // program and walks it for about 5s, and it is over well before lint and the type check. A
   // reservation would only take a place from the four-core CI runner's fan-out and a worker from the
   // unit suite for the whole gate.
-  { label: "exports", target: "exports:unused", reserved_cores: 0 },
+  { label: EXPORTS_LABEL, target: "exports:unused", reserved_cores: 0 },
   // **The metrics ratchet is kit's own**: it holds kit's repository-wide
   // totals to the merge-base's. It is one in-process eslint pass with only `max-lines` enabled, over
   // in a few seconds, so it reserves no core for the reason the unused-member check above does not.
@@ -1503,6 +1684,15 @@ function resolve_gate_plan(available_cores = availableParallelism4(), concurrent
     unit_worker_cap: unit_cap_for(checks, available_cores, concurrent_runs)
   };
 }
+function bound_by_free(plan, available_cores, free_cores) {
+  if (!has_unit_check(plan.checks)) return plan;
+  const unit_worker_cap = unit_worker_share.cap_to_free(
+    plan.unit_worker_cap,
+    free_cores,
+    available_cores
+  );
+  return { ...plan, unit_worker_cap };
+}
 function format_machine(available_cores, concurrent_runs) {
   const cores = `${String(available_cores)} cores`;
   if (concurrent_runs <= unit_worker_share.SOLO_RUNS) return cores;
@@ -1521,6 +1711,7 @@ function format_gate_plan(plan, available_cores = availableParallelism4(), concu
   return `${josh_verdict.GATE_OPENING_PREFIX}${width}, ${cap} (${machine})`;
 }
 var gate_plan = {
+  EXPORTS_LABEL,
   GATE_CHECKS,
   LINT_LABEL,
   MEASURED_CORES,
@@ -1530,6 +1721,7 @@ var gate_plan = {
   TYPE_CHECK_LABEL,
   UNIT_LABEL,
   WARNING_CHECKER_LABELS,
+  bound_by_free,
   check_memory,
   check_weight,
   direct_unit_memory,
@@ -1662,7 +1854,7 @@ var DEV_COMMANDS = {
   },
   "stop:guard": {
     script: "scripts/hooks/stop-guard.ts",
-    description: "Claude Code Stop hook: deliver the three stop-time rules \u2014 hold notify/release and issue citation (reads the Stop payload on stdin)",
+    description: "Claude Code Stop hook: send the hold notify, release the hold and print the issue citations itself; block on the rules that need the model (reads the Stop payload on stdin)",
     category: "Development",
     reference: ["", "automation", ["none"]]
     // **No `tsx_arguments`, deliberately**, the same as `pretool:guard` above: this runs at every
@@ -1796,6 +1988,12 @@ var HOOKS_COMMANDS = {
     category: "Git hooks",
     reference: ["[paths...]", "automation", ["none"]]
   },
+  "pre-commit-lint": {
+    script: "scripts/hooks/pre-commit-lint.ts",
+    description: "Git hook: run cspell, prettier or eslint over staged files from a content cache",
+    category: "Git hooks",
+    reference: ["<cspell|prettier|eslint> [paths...]", "automation", ["files"]]
+  },
   "pre-push-unit": {
     script: "scripts/hooks/pre-push-unit.ts",
     description: "Git hook: run unit tests, reusing a green gate recorded on the pushed tree",
@@ -2201,6 +2399,11 @@ var WORKFLOW_COMMANDS = {
   // A script rather than an `sh -c` chain, because the strategy has to be named rather than left to
   // the caller's git configuration: a bare `git pull` aborts with `Need to specify how to reconcile
   // divergent branches` on exactly the diverged branch the command exists for.
+  //
+  // **It declares no core weight, by measurement** (joshuafolkken/kit#3944): its own work is git, and
+  // the catalog it may regenerate took 0.6s of CPU. The heavy processes seen beside it are commit
+  // hooks — its regenerated catalog's commit runs them — which reserve themselves, and a weight here
+  // would set the held mark they inherit, folding the parallel hook tools into this one place.
   "main:merge": {
     script: "scripts/git/main-merge.ts",
     description: "Merge origin default branch into the current branch",
@@ -2267,6 +2470,7 @@ var ALIASES = {
   tm: "time",
   tmd: "time:density",
   rtr: "retrospective",
+  ca: "cost:audit",
   rvf: "review:findings",
   ruv: "rule:value",
   ev: "eval",
@@ -2276,6 +2480,7 @@ var ALIASES = {
   lst: "lane:stats",
   lli: "lane:limit",
   lrs: "lane:restart",
+  lwd: "lane:withdraw",
   blr: "backlogrun"
 };
 function canonical_command(name) {
@@ -2288,7 +2493,7 @@ var BASH_SEPARATOR = ": ";
 var WHITESPACE_PATTERN = /\s+/u;
 var SEGMENT_PATTERN = /&&|\|\||;|\|/u;
 var PIPE_PATTERN = /(?<!\|)\|(?!\|)/u;
-var CHAIN_PATTERN = /&&|\|\||;/u;
+var CHAIN_PATTERN = /&&|\|\||;|\n/u;
 var QUOTED_SPAN_PATTERN = /\\[\s\S]|'[^']*'|"(?:\\[\s\S]|[^"\\])*"/gu;
 var HEREDOC_MARKER = /(?<!<)<<-?\s*(['"]?)(\w+)\1/u;
 var HEREDOC_DELIMITER_GROUP = 2;
@@ -2386,13 +2591,24 @@ function drop_redirections(words) {
   }
   return kept;
 }
-function josh_arguments(command) {
-  const text = command_words(command_segment(command)).join(" ");
+function josh_arguments_of_segment(segment) {
+  const text = command_words(segment).join(" ");
   const match = JOSH_PATTERN.exec(text);
   if (match === null) return [];
   const words = text.slice(match[0].length).split(WHITESPACE_PATTERN).filter((word) => word !== "");
   return drop_redirections(words);
 }
+function josh_arguments(command) {
+  return josh_arguments_of_segment(command_segment(command));
+}
+function josh_signature_of_segment(segment) {
+  const name = josh_command_of_segment(segment);
+  if (name === "") return "";
+  return [name, ...josh_arguments_of_segment(segment)].join(" ");
+}
+function josh_signatures_of(command) {
+  return unquoted(command).split(SEGMENT_PATTERN).map((segment) => josh_signature_of_segment(segment)).filter((signature) => signature !== "");
+}
 var time_shell = {
   JOSH_PREFIX,
   bash_command,
@@ -2403,6 +2619,7 @@ var time_shell = {
   josh_arguments,
   josh_command_of,
   josh_commands_of,
+  josh_signatures_of,
   leading_word,
   unquoted
 };
@@ -2503,78 +2720,6 @@ var time_background = {
   unread_phases
 };
 
-// scripts/git/git-schemas.ts
-import { z as z3 } from "zod";
-var package_name_schema = z3.object({ name: z3.string().min(1) });
-var rollup_item_schema = z3.looseObject({
-  // eslint-disable-next-line @typescript-eslint/naming-convention -- GraphQL field name from GitHub API
-  __typename: z3.string().optional(),
-  state: z3.string().optional(),
-  status: z3.string().optional(),
-  conclusion: z3.string().optional(),
-  name: z3.string().optional(),
-  context: z3.string().optional(),
-  description: z3.string().nullish()
-});
-var pr_raw_schema = z3.object({
-  statusCheckRollup: z3.array(rollup_item_schema).optional(),
-  mergeStateStatus: z3.string().optional(),
-  reviewDecision: z3.string().optional()
-});
-var pull_comment_schema = z3.object({
-  body: z3.string().optional(),
-  html_url: z3.string().optional(),
-  user: z3.object({ login: z3.string().optional() }).optional()
-});
-var ai_review_pull_comment_schema = z3.object({
-  body: z3.string().optional(),
-  url: z3.string().optional(),
-  author: z3.object({ login: z3.string().optional() }).optional()
-});
-var pr_info_schema = z3.object({
-  mergeable: z3.union([z3.boolean(), z3.string()]).nullable().optional(),
-  mergeStateStatus: z3.string().nullable().optional(),
-  state: z3.string().optional()
-});
-var epic_issue_schema = z3.object({
-  number: z3.number(),
-  body: z3.string().optional()
-});
-var blocking_issue_schema = z3.object({
-  number: z3.number(),
-  state: z3.string().optional(),
-  repository_url: z3.string().optional()
-});
-var blocked_by_schema = z3.object({
-  nodes: z3.array(blocking_issue_schema).default([]),
-  totalCount: z3.number().optional()
-}).optional();
-var epic_child_schema = z3.object({
-  state: z3.string().optional(),
-  blockedBy: blocked_by_schema
-});
-var rest_comment_schema = z3.looseObject({
-  body: z3.string().nullish(),
-  html_url: z3.string().optional(),
-  user: z3.looseObject({ login: z3.string().optional() }).nullish()
-});
-var issue_label_schema = z3.object({ name: z3.string() });
-var epic_subject_schema = z3.object({
-  number: z3.number(),
-  state: z3.string().optional(),
-  labels: z3.array(issue_label_schema).optional(),
-  body: z3.string().optional()
-});
-var open_issue_schema = z3.object({
-  number: z3.number(),
-  title: z3.string(),
-  labels: z3.array(issue_label_schema).optional(),
-  createdAt: z3.string(),
-  blockedBy: blocked_by_schema,
-  // Present only on the pickup listing, which reads it for the paths each issue declares.
-  body: z3.string().optional()
-});
-
 // scripts/gh/git-pr-checks-parse.ts
 var CHECK_STATUS_PASS = "pass";
 var CHECK_STATUS_PENDING = "pending";
@@ -2753,7 +2898,7 @@ var PrConflictError = class extends Error {
 
 // scripts/lane/lane-ledger.ts
 import { closeSync, constants, openSync, writeSync } from "node:fs";
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 var LEDGER_PREFIX = "josh-lane-ledger-";
 var LEDGER_SUFFIX = ".jsonl";
 var LINE_SEPARATOR = "\n";
@@ -2767,63 +2912,83 @@ var KIND = {
   LOAD: "load",
   DISPATCH: "dispatch",
   STAGE: "stage",
-  STOP: "stop"
+  STOP: "stop",
+  OVERLAP: "overlap"
 };
-var merge_schema = z4.object({ kind: z4.literal(KIND.MERGE), at: z4.string(), issue: z4.number() });
-var gate_schema = z4.object({
-  kind: z4.literal(KIND.GATE),
-  at: z4.string(),
-  elapsed_ms: z4.number(),
-  is_passed: z4.boolean(),
+var merge_schema = z3.object({ kind: z3.literal(KIND.MERGE), at: z3.string(), issue: z3.number() });
+var check_schema = z3.object({
+  label: z3.string(),
+  elapsed_ms: z3.number(),
+  is_passed: z3.boolean(),
+  is_reused: z3.boolean().optional()
+});
+var gate_schema = z3.object({
+  kind: z3.literal(KIND.GATE),
+  at: z3.string(),
+  elapsed_ms: z3.number(),
+  is_passed: z3.boolean(),
   // The unit suite's own duration, present when this gate ran it — the one
   // record of a full vitest run `josh metrics` reads, so the suite is never timed twice.
-  unit_ms: z4.number().optional(),
+  unit_ms: z3.number().optional(),
   // The whole cores busy outside this gate, beyond the machine's baseline, at its start or its end —
   // whichever was higher. Absent when the machine could not be read.
-  external_cores: z4.number().optional()
+  external_cores: z3.number().optional(),
+  // Each check's own duration and verdict, so `josh lane:stats` can name the check a slow gate waited
+  // on. A reused check started no process: its row says so, and its zero is no timing.
+  checks: z3.array(check_schema).optional()
 });
-var process_kind_schema = z4.object({
-  kind: z4.string(),
-  cpu_percent: z4.number(),
-  rss_mb: z4.number(),
-  count: z4.number()
+var process_kind_schema = z3.object({
+  kind: z3.string(),
+  cpu_percent: z3.number(),
+  rss_mb: z3.number(),
+  count: z3.number()
 });
-var load_schema = z4.object({
-  kind: z4.literal(KIND.LOAD),
-  at: z4.string(),
-  load: z4.number(),
-  available_mb: z4.number().optional(),
-  swapped_mb: z4.number().optional(),
-  lanes: z4.number().optional(),
+var load_schema = z3.object({
+  kind: z3.literal(KIND.LOAD),
+  at: z3.string(),
+  load: z3.number(),
+  available_mb: z3.number().optional(),
+  swapped_mb: z3.number().optional(),
+  lanes: z3.number().optional(),
   // The heaviest process kinds at the instant of the sample (`lane-process-load.ts`), so the load the
   // core budget's ledger does not explain can be read back by what made it (joshuafolkken/kit#3874).
-  processes: z4.array(process_kind_schema).optional()
+  processes: z3.array(process_kind_schema).optional()
 });
-var dispatch_schema = z4.object({
-  kind: z4.literal(KIND.DISPATCH),
-  at: z4.string(),
-  issue: z4.number()
+var dispatch_schema = z3.object({
+  kind: z3.literal(KIND.DISPATCH),
+  at: z3.string(),
+  issue: z3.number()
 });
-var stage_schema = z4.object({
-  kind: z4.literal(KIND.STAGE),
-  at: z4.string(),
-  stage: z4.string(),
-  elapsed_ms: z4.number(),
-  issue: z4.number().optional()
+var stage_schema = z3.object({
+  kind: z3.literal(KIND.STAGE),
+  at: z3.string(),
+  stage: z3.string(),
+  elapsed_ms: z3.number(),
+  issue: z3.number().optional()
 });
-var stop_schema = z4.object({
-  kind: z4.literal(KIND.STOP),
-  at: z4.string(),
-  issue: z4.number(),
-  reason: z4.string()
+var stop_schema = z3.object({
+  kind: z3.literal(KIND.STOP),
+  at: z3.string(),
+  issue: z3.number(),
+  reason: z3.string()
 });
-var entry_schema = z4.discriminatedUnion("kind", [
+var overlap_schema = z3.object({
+  kind: z3.literal(KIND.OVERLAP),
+  at: z3.string(),
+  issue: z3.number(),
+  lanes: z3.array(z3.number()),
+  paths: z3.array(z3.string()),
+  waited_ms: z3.number(),
+  is_cleared: z3.boolean()
+});
+var entry_schema = z3.discriminatedUnion("kind", [
   merge_schema,
   gate_schema,
   load_schema,
   dispatch_schema,
   stage_schema,
-  stop_schema
+  stop_schema,
+  overlap_schema
 ]);
 function target_of(repository) {
   return stamp_file.stamp_path(LEDGER_PREFIX, repository, LEDGER_SUFFIX);
@@ -2837,19 +3002,19 @@ async function target() {
     return void 0;
   }
 }
-function append(path4, entry) {
-  const descriptor = openSync(path4, APPEND_FLAGS, LEDGER_FILE_MODE);
+function append(path5, entry) {
+  const descriptor = openSync(path5, APPEND_FLAGS, LEDGER_FILE_MODE);
   try {
-    if (stamp_file.is_own_regular_file(path4)) {
+    if (stamp_file.is_own_regular_file(path5)) {
       writeSync(descriptor, `${JSON.stringify(entry)}${LINE_SEPARATOR}`);
     }
   } finally {
     closeSync(descriptor);
   }
 }
-async function record(entry, path4) {
+async function record(entry, path5) {
   try {
-    const destination = path4 ?? await target();
+    const destination = path5 ?? await target();
     if (destination !== void 0) append(destination, entry);
   } catch {
   }
@@ -2857,20 +3022,23 @@ async function record(entry, path4) {
 function now_iso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
-async function record_gate(path4, gate) {
-  await record({ kind: KIND.GATE, at: now_iso(), ...gate }, path4);
+async function record_gate(path5, gate) {
+  await record({ kind: KIND.GATE, at: now_iso(), ...gate }, path5);
 }
 async function record_merge(issue) {
   await record({ kind: KIND.MERGE, at: now_iso(), issue });
 }
-async function record_dispatch(issue, path4) {
-  await record({ kind: KIND.DISPATCH, at: now_iso(), issue }, path4);
+async function record_dispatch(issue, path5) {
+  await record({ kind: KIND.DISPATCH, at: now_iso(), issue }, path5);
+}
+async function record_stage(stage, path5) {
+  await record({ kind: KIND.STAGE, at: now_iso(), ...stage }, path5);
 }
-async function record_stage(stage, path4) {
-  await record({ kind: KIND.STAGE, at: now_iso(), ...stage }, path4);
+async function record_stop(stop, path5) {
+  await record({ kind: KIND.STOP, at: now_iso(), ...stop }, path5);
 }
-async function record_stop(stop, path4) {
-  await record({ kind: KIND.STOP, at: now_iso(), ...stop }, path4);
+async function record_overlap(overlap, path5) {
+  await record({ kind: KIND.OVERLAP, at: now_iso(), ...overlap }, path5);
 }
 function parse_line2(line) {
   return entry_schema.safeParse(json_value.parse_or_undefined(line)).data;
@@ -2878,8 +3046,8 @@ function parse_line2(line) {
 function is_present(entry) {
   return entry !== void 0;
 }
-function read_entries(path4) {
-  const raw = stamp_file.read_stamp_text(path4);
+function read_entries(path5) {
+  const raw = stamp_file.read_stamp_text(path5);
   if (raw === void 0) return [];
   return raw.split(LINE_SEPARATOR).map((line) => parse_line2(line.trim())).filter(is_present);
 }
@@ -2892,6 +3060,7 @@ var lane_ledger = {
   record_dispatch,
   record_gate,
   record_merge,
+  record_overlap,
   record_stage,
   record_stop,
   target,
@@ -3058,9 +3227,9 @@ function read_stages(text) {
 var time_followup_stage = { NO_STAGES, read_stages };
 
 // scripts/time-runtime/time-reported-failure.ts
-import { z as z5 } from "zod";
-var TEXT_BLOCK_SCHEMA = z5.object({ text: z5.string().nullish() });
-var CONTENT_SCHEMA = z5.union([z5.string(), z5.array(z5.unknown())]);
+import { z as z4 } from "zod";
+var TEXT_BLOCK_SCHEMA = z4.object({ text: z4.string().nullish() });
+var CONTENT_SCHEMA = z4.union([z4.string(), z4.array(z4.unknown())]);
 var LINE_SEPARATOR3 = "\n";
 function block_text(block) {
   const parsed = TEXT_BLOCK_SCHEMA.safeParse(block);
@@ -3597,38 +3766,38 @@ function check_key(josh_command, command) {
 var time_single_check = { NO_CHECK, check_key };
 
 // scripts/time-runtime/time-transcript-line.ts
-import { z as z6 } from "zod";
-var BLOCK_SCHEMA2 = z6.object({
-  type: z6.string().nullish(),
-  name: z6.string().nullish(),
-  id: z6.string().nullish(),
-  tool_use_id: z6.string().nullish(),
-  input: z6.unknown().nullish(),
+import { z as z5 } from "zod";
+var BLOCK_SCHEMA2 = z5.object({
+  type: z5.string().nullish(),
+  name: z5.string().nullish(),
+  id: z5.string().nullish(),
+  tool_use_id: z5.string().nullish(),
+  input: z5.unknown().nullish(),
   // Whether the harness wrote this result back as a failure. Present on a
   // `tool_result` block and on nothing else, and absent even there for the tools that never report
   // one — which is why it is read as three answers rather than as a boolean with a default.
-  is_error: z6.boolean().nullish(),
+  is_error: z5.boolean().nullish(),
   // What the call printed. Read only to recover the outcome a pipeline threw away:
   // it is kept as flattened text rather than as blocks, because that is
   // the whole of what `time-reported-failure.ts` asks of it.
-  content: z6.unknown().nullish()
+  content: z5.unknown().nullish()
 });
-var CONTENT_SCHEMA2 = z6.union([z6.string(), z6.array(BLOCK_SCHEMA2)]);
-var MESSAGE_SCHEMA2 = z6.object({ id: z6.string().nullish(), content: CONTENT_SCHEMA2.nullish() });
-var LINE_SCHEMA = z6.object({
-  type: z6.string().nullish(),
-  timestamp: z6.string().nullish(),
+var CONTENT_SCHEMA2 = z5.union([z5.string(), z5.array(BLOCK_SCHEMA2)]);
+var MESSAGE_SCHEMA2 = z5.object({ id: z5.string().nullish(), content: CONTENT_SCHEMA2.nullish() });
+var LINE_SCHEMA = z5.object({
+  type: z5.string().nullish(),
+  timestamp: z5.string().nullish(),
   // The branch the line was written on, which is where the issue number lives — `josh git` names a
   // branch `<N>-<slug>`. Read here rather than re-parsed by a second reader so `josh time --issue`
   // and `josh cost --issue` answer from the same field.
-  gitBranch: z6.string().nullish(),
+  gitBranch: z5.string().nullish(),
   // The two fields outside `message` that the harness writes an end-of-task notice on.
   // **Both are read as `unknown` rather than as strings**: a schema
   // insisting on a string here would reject every line whose `content` is a list of blocks — which is
   // most of them — and a rejected line is dropped from the timeline entirely, so the shares would stop
   // reconstructing the elapsed time. The shape is checked at the read below instead.
-  content: z6.unknown().nullish(),
-  attachment: z6.unknown().nullish(),
+  content: z5.unknown().nullish(),
+  attachment: z5.unknown().nullish(),
   message: MESSAGE_SCHEMA2.nullish()
 });
 var UNKNOWN_BRANCH = "";
@@ -3739,6 +3908,7 @@ var NO_CALL = {
   label: "",
   josh_command: "",
   josh_commands: [],
+  josh_signatures: [],
   check_key: time_single_check.NO_CHECK,
   marker: time_markers.NO_MARKER,
   message_id: NO_MESSAGE_ID2,
@@ -3751,6 +3921,7 @@ var UNKNOWN_CALL = {
   label: UNKNOWN_TOOL,
   josh_command: "",
   josh_commands: [],
+  josh_signatures: [],
   check_key: time_single_check.NO_CHECK,
   marker: time_markers.NO_MARKER,
   message_id: NO_MESSAGE_ID2,
@@ -3764,6 +3935,7 @@ function non_bash_call(name, input, message_id) {
     label: name,
     josh_command: "",
     josh_commands: [],
+    josh_signatures: [],
     check_key: time_single_check.NO_CHECK,
     marker: time_markers.tool_marker(name, input),
     message_id,
@@ -3783,6 +3955,7 @@ function bash_call(input, message_id) {
     label: time_shell.bash_label(command),
     josh_command,
     josh_commands: time_shell.josh_commands_of(command),
+    josh_signatures: time_shell.josh_signatures_of(command),
     check_key: time_single_check.check_key(josh_command, command),
     marker: time_markers.bash_marker(command),
     message_id,
@@ -3905,6 +4078,7 @@ function to_spans(events, finished) {
     label: event.label,
     josh_command: event.josh_command,
     josh_commands: event.josh_commands,
+    josh_signatures: event.josh_signatures,
     check_key: event.check_key,
     marker: event.marker,
     is_bundleable: event.is_bundleable,
@@ -4425,7 +4599,7 @@ function describe_span(span) {
 }
 var FOLD_MINIMUM = 2;
 function read_targets(sequence) {
-  const paths = sequence.filter((span) => span.is_bundleable && !span.is_writing).map((span) => span.targets[0] ?? "").filter((path4) => path4 !== "" && time_bundle_call.has_extension(path4));
+  const paths = sequence.filter((span) => span.is_bundleable && !span.is_writing).map((span) => span.targets[0] ?? "").filter((path5) => path5 !== "" && time_bundle_call.has_extension(path5));
   return [...new Set(paths)];
 }
 function read_fold_directive(sequence) {
@@ -4434,7 +4608,7 @@ function read_fold_directive(sequence) {
   return ` Fold them into one call: \`pnpm josh read:files ${paths.join(" ")}\`.`;
 }
 function write_targets(sequence) {
-  const paths = sequence.filter((span) => span.label === EDIT_TOOL).map((span) => span.targets[0] ?? "").filter((path4) => path4 !== "" && time_bundle_call.has_extension(path4));
+  const paths = sequence.filter((span) => span.label === EDIT_TOOL).map((span) => span.targets[0] ?? "").filter((path5) => path5 !== "" && time_bundle_call.has_extension(path5));
   return [...new Set(paths)];
 }
 function write_fold_directive(sequence) {
@@ -4486,7 +4660,7 @@ var time_batch_guard = {
 };
 
 // scripts/time-runtime/time-hook-transcript.ts
-import path3 from "node:path";
+import path4 from "node:path";
 var { TRANSCRIPT_EXTENSION } = cost_transcript;
 var AGENT_PREFIX = "agent-";
 var AGENT_ID_PATTERN = /^[\w-]+$/u;
@@ -4494,10 +4668,10 @@ function is_agent_id(value) {
   return typeof value === "string" && AGENT_ID_PATTERN.test(value);
 }
 function fork_path(transcript_path, agent_id) {
-  const directory = path3.dirname(transcript_path);
-  const session_id = path3.basename(transcript_path, TRANSCRIPT_EXTENSION);
+  const directory = path4.dirname(transcript_path);
+  const session_id = path4.basename(transcript_path, TRANSCRIPT_EXTENSION);
   const file_name = `${AGENT_PREFIX}${agent_id}${TRANSCRIPT_EXTENSION}`;
-  return path3.join(cost_transcript.unit_directory(directory, session_id), file_name);
+  return path4.join(cost_transcript.unit_directory(directory, session_id), file_name);
 }
 function transcript_of(transcript_path, agent_id) {
   if (!is_agent_id(agent_id) || !transcript_path.endsWith(TRANSCRIPT_EXTENSION)) {
@@ -4512,7 +4686,7 @@ var time_hook_transcript = {
 
 // scripts/time-runtime/time-density-hook.ts
 import { closeSync as closeSync2, fstatSync, openSync as openSync2, readSync } from "node:fs";
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 
 // scripts/time-runtime/time-density.ts
 var MIN_ROUND_TRIPS = 10;
@@ -4568,15 +4742,15 @@ var TAIL_BYTES = 262144;
 var FILE_START = 0;
 var NOTICE_PREFIX = "josh-density-notice-";
 var NEVER_MS = 0;
-var payload_schema = z7.object({
-  transcript_path: z7.string().min(1).optional(),
+var payload_schema = z6.object({
+  transcript_path: z6.string().min(1).optional(),
   // **`nullish`, not `optional`.** A payload spelling the absent agent as `null` has to read as "no
   // fork"; rejected, it would fail `safeParse` for the whole payload and silence the line for every
   // edit of the main line — the opposite of this module's stated failure direction.
-  agent_id: z7.string().nullish()
+  agent_id: z6.string().nullish()
 });
-var notice_schema = z7.object({ notified_at_ms: z7.number() });
-var call_schema = z7.object({ tool_name: z7.string().min(1), tool_input: z7.unknown() });
+var notice_schema = z6.object({ notified_at_ms: z6.number() });
+var call_schema = z6.object({ tool_name: z6.string().min(1), tool_input: z6.unknown() });
 function parse_transcript_path(raw_payload) {
   const parsed = payload_schema.safeParse(JSON.parse(raw_payload));
   if (!parsed.success || parsed.data.transcript_path === void 0) return void 0;
@@ -4643,9 +4817,6 @@ export {
   ESLINT_EDIT_CACHE_FLAGS,
   time_shell,
   time_bundle_call,
-  blocking_issue_schema,
-  rest_comment_schema,
-  open_issue_schema,
   CHECK_STATUS_PENDING,
   CHECK_STATUS_FAIL,
   read_string,