@joshuafolkken/kit 1.1229.0 → 1.1370.0

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

@@ -1,24 +1,17 @@
 import {
-  ENV_FILE_NAME
-} from "./chunk-RKUAD3I6.js";
+  ENV_FILE_NAME,
+  cost_transcript,
+  json_value,
+  process_identity,
+  process_owner_schema,
+  run_carry,
+  time_instant
+} from "./chunk-NZN2UFI6.js";
 import {
   PLATFORM_TEMP_ROOT,
   PROBE_TIMEOUT_MS,
   stamp_file
-} from "./chunk-ELCN5LCH.js";
-
-// scripts/lib/json-value.ts
-function parse_or_undefined(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return void 0;
-  }
-}
-function is_record(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var json_value = { parse_or_undefined, is_record };
+} from "./chunk-NEC4AT4Z.js";
 
 // scripts/cost-runtime/cost-blocks.ts
 import { z } from "zod";
@@ -151,6 +144,17 @@ var CSPELL_CACHE_FLAGS = content_cache_flags(CSPELL_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",
+    category: "AI tools",
+    reference: [
+      "[#<n>...] [--only] [--max <n>] [--idle <minutes>] [--agent claude|codex]",
+      "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",
@@ -181,7 +185,7 @@ var BACKLOG_COMMANDS = {
   },
   "backlog:stalled": {
     script: "scripts/backlog/backlog-stalled-cli.ts",
-    // A stall sends one Telegram warning (joshuafolkken/kit#3357). The `Stop` hook calls the detector
+    // 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",
@@ -276,7 +280,7 @@ var ISSUE_COMMANDS = {
   },
   "defect:rate": {
     script: "scripts/issue/defect-rate-cli.ts",
-    description: "Print the defect rate of merged work: defects filed per behavior change completed",
+    description: "Print the defect rate of merged work: defects filed per enhancement completed",
     category: "AI tools",
     reference: ["[--days <n>]", "automation", ["network"]]
   },
@@ -306,13 +310,19 @@ var ISSUE_COMMANDS = {
   },
   "issue:file": {
     script: "scripts/issue/issue-file-cli.ts",
-    description: "File an Issue with every filing step: lint, Origin, WIP cap, duplicate scout, labels, then epic:bundle",
+    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]",
+      "<title> --body-file <path> --depth <0|1|2> [--route <route>] [--label <name>] [--repo <owner/repo>] [--distinct <N,\u2026>] [--over-cap] [--no-auto-ok] [--requested] [--release]",
       "automation",
       ["network"]
     ]
+  },
+  "issue:release": {
+    script: "scripts/issue/issue-release-cli.ts",
+    description: "Link an Issue to the repository's open release Issue as its blocker, filing one when none is open",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["network"]]
   }
 };
 
@@ -348,7 +358,7 @@ var LANE_COMMANDS = {
   },
   "lane:prune": {
     ...LANE_ARGUMENTS,
-    description: "Close every lane an interruption left without its work tree",
+    description: "Close every lane an interruption left without its work tree, then sweep unregistered leftovers under the lanes root",
     category: "AI tools",
     reference: ["", "automation", ["files", "git"]],
     default_script_arguments: ["prune"]
@@ -380,18 +390,27 @@ var LANE_COMMANDS = {
     category: "AI tools",
     reference: ["<issue> [--stash <message>]", "automation", ["files", "git", "processes"]]
   },
-  // The lane-limit measurement (joshuafolkken/kit#3355): `.env` is read so `lane:stats` labels the row
+  // 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",
+    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",
+    description: "Print one table row of lane throughput, gate duration and machine load over a period, and the per-stage durations of a lane under it",
     category: "AI tools",
     reference: ["--period <days> [--limit <lane-limit>]", "maintainer", ["none"]],
     default_script_arguments: ["stats"]
@@ -423,12 +442,18 @@ var RUN_COMMANDS = {
   "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 (joshuafolkken/kit#3357).
+    // `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:
@@ -467,18 +492,26 @@ var RUN_COMMANDS = {
       ["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 (joshuafolkken/kit#2372): claim the tree,
+  // 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 (joshuafolkken/kit#3357).
+    // 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",
@@ -581,12 +614,12 @@ var AI_COMMANDS = {
     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 (joshuafolkken/kit#1997). The runtime analysis hooks and guards rely on stays
+    // 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 (joshuafolkken/kit#2405). Kit-only for the same reason `time` is: it reads
+  // 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",
@@ -602,7 +635,7 @@ var AI_COMMANDS = {
     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 (joshuafolkken/kit#2328), through the same declaration `josh time` uses for the same reason.
+    // help, through the same declaration `josh time` uses for the same reason.
     is_kit_only: true
   },
   "review:brief": {
@@ -654,7 +687,7 @@ var AI_COMMANDS = {
     category: "AI tools",
     reference: ["[--join]", "automation", ["processes", "files"]]
   },
-  // The post-merge sequence a run closed on, folded into one call (joshuafolkken/kit#2372): commit the
+  // 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": {
@@ -663,7 +696,7 @@ var AI_COMMANDS = {
     category: "AI tools",
     reference: ["[<issue> ...]", "automation", ["git", "network"]]
   },
-  // The commit-to-report region a run ships a change on, folded into one call (joshuafolkken/kit#2398):
+  // 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.
@@ -723,7 +756,7 @@ var AI_COMMANDS = {
     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 (joshuafolkken/kit#1988).
+    // nothing in a consumer project and is dropped from a consumer's help.
     is_kit_only: true
   }
 };
@@ -739,186 +772,15 @@ var CLONE_COMMANDS = {
 };
 
 // scripts/gate/core-budget.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { readdirSync as readdirSync2 } from "node:fs";
-import { availableParallelism as availableParallelism2 } from "node:os";
-import path3 from "node:path";
-
-// scripts/josh/process-identity.ts
-import { execFileSync, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { readFileSync, rmSync } from "node:fs";
-import { createServer } from "node:net";
-import path from "node:path";
-var PS_COMMAND = "/bin/ps";
-var FORMAT_FLAG = "-o";
-var START_TIME_FORMAT = "lstart=";
-var PID_FLAG = "-p";
-var PROBE_ENVIRONMENT = { TZ: "UTC", LC_ALL: "C" };
-var LIVENESS_SIGNAL = 0;
-var LOWEST_REAL_PID = 1;
-var PROC_START_FIELD_INDEX = 19;
-var BEACON_SCHEME = "socket:";
-var BEACON_SUFFIX = ".sock";
-var BEACON_PREFIX = `josh-process-identity-${String(process.getuid?.() ?? "")}-`;
-var BEACON_ID_LENGTH = 36;
-var BEACON_ID_PATTERN = /^[\da-f-]+$/u;
-var WINDOWS_PLATFORM = "win32";
-var SOCKET_PROBE_SOURCE = "const net=require('node:net');const socket=net.createConnection(process.argv[1]);socket.once('connect',()=>process.exit(0));socket.once('error',()=>process.exit(1));socket.setTimeout(1000,()=>process.exit(1));";
-var beacons = /* @__PURE__ */ new Map();
-var exit_cleanup = { is_registered: false };
-function is_live_pid(pid) {
-  if (pid < LOWEST_REAL_PID) return false;
-  try {
-    process.kill(pid, LIVENESS_SIGNAL);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function read_proc_start(pid) {
-  try {
-    const stat = readFileSync(`/proc/${String(pid)}/stat`, "utf8");
-    const fields = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/u);
-    const start = fields[PROC_START_FIELD_INDEX];
-    return start === void 0 ? void 0 : `proc:${start}`;
-  } catch {
-    return void 0;
-  }
-}
-function read_ps_start(pid) {
-  try {
-    const printed = execFileSync(
-      PS_COMMAND,
-      [FORMAT_FLAG, START_TIME_FORMAT, PID_FLAG, String(pid)],
-      {
-        encoding: "utf8",
-        timeout: PROBE_TIMEOUT_MS,
-        stdio: ["ignore", "pipe", "ignore"],
-        env: PROBE_ENVIRONMENT
-      }
-    ).trim();
-    return printed.length > 0 ? printed : void 0;
-  } catch {
-    return void 0;
-  }
-}
-var START_PROBES = { read_proc_start, read_ps_start };
-function safe_probe(probe, pid) {
-  try {
-    return probe(pid);
-  } catch {
-    return void 0;
-  }
-}
-function read_start(pid, probes = START_PROBES) {
-  return safe_probe(probes.read_proc_start, pid) ?? safe_probe(probes.read_ps_start, pid);
-}
-function close_beacon(token) {
-  const server = beacons.get(token);
-  if (server === void 0) return;
-  beacons.delete(token);
-  server.close();
-  rmSync(token.slice(BEACON_SCHEME.length), { force: true });
-}
-function close_beacons() {
-  for (const token of beacons.keys()) close_beacon(token);
-}
-function ensure_exit_cleanup() {
-  if (exit_cleanup.is_registered) return;
-  exit_cleanup.is_registered = true;
-  process.once("exit", close_beacons);
-}
-function ignore_beacon_error() {
-}
-function bind_beacon(target) {
-  return createServer().on("error", ignore_beacon_error).listen(target);
-}
-function try_bind_beacon(bind, target) {
-  try {
-    const server = bind(target);
-    return server.listening ? server : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function open_beacon(bind = bind_beacon) {
-  const target = path.join(PLATFORM_TEMP_ROOT, `${BEACON_PREFIX}${randomUUID()}${BEACON_SUFFIX}`);
-  const token = `${BEACON_SCHEME}${target}`;
-  const server = try_bind_beacon(bind, target);
-  if (server === void 0) return void 0;
-  server.unref();
-  beacons.set(token, server);
-  ensure_exit_cleanup();
-  return token;
-}
-function resolve_own_start(probes = START_PROBES, platform = process.platform) {
-  const start = read_start(process.pid, probes);
-  if (start !== void 0 || platform === WINDOWS_PLATFORM) return start;
-  return open_beacon();
-}
-function is_valid_beacon_name(name) {
-  if (!name.startsWith(BEACON_PREFIX) || !name.endsWith(BEACON_SUFFIX)) return false;
-  const id = name.slice(BEACON_PREFIX.length, -BEACON_SUFFIX.length);
-  return id.length === BEACON_ID_LENGTH && BEACON_ID_PATTERN.test(id);
-}
-function beacon_target(token) {
-  if (!token.startsWith(BEACON_SCHEME)) return void 0;
-  const target = token.slice(BEACON_SCHEME.length);
-  if (path.dirname(target) !== PLATFORM_TEMP_ROOT) return void 0;
-  return is_valid_beacon_name(path.basename(target)) ? target : void 0;
-}
-function is_live_beacon(target) {
-  return spawnSync(process.execPath, ["-e", SOCKET_PROBE_SOURCE, target], {
-    stdio: "ignore",
-    timeout: PROBE_TIMEOUT_MS
-  }).status === 0;
-}
-function has_matching_start(pid, recorded_start, read) {
-  const observed = read(pid);
-  return observed === void 0 ? void 0 : observed === recorded_start;
-}
-function matches_recorded_start(pid, recorded_start, read) {
-  const target = beacon_target(recorded_start);
-  return target === void 0 ? has_matching_start(pid, recorded_start, read) : is_live_beacon(target);
-}
-var own_probe = /* @__PURE__ */ new Map();
-function own_start() {
-  if (!own_probe.has(process.pid)) own_probe.set(process.pid, resolve_own_start());
-  return own_probe.get(process.pid);
-}
-function own_fields() {
-  const start = own_start();
-  return { pid: process.pid, ...start !== void 0 && { process_start: start } };
-}
-function is_same_process(pid, recorded_start, read = read_start) {
-  if (pid === void 0 || !is_live_pid(pid)) return false;
-  if (recorded_start === void 0) return void 0;
-  return matches_recorded_start(pid, recorded_start, read);
-}
-function is_own_process(pid, recorded_start) {
-  return pid === process.pid && recorded_start === own_start();
-}
-var process_identity = {
-  close_beacon,
-  is_live_pid,
-  is_own_process,
-  is_same_process,
-  open_beacon,
-  own_fields,
-  own_start,
-  read_start,
-  resolve_own_start
-};
-
-// scripts/josh/process-owner.ts
-import { z as z2 } from "zod";
-var process_owner_schema = z2.object({ pid: z2.number(), process_start: z2.string().optional() });
+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 path2 from "node:path";
+import path from "node:path";
 var RUN_PREFIX = "josh-unit-running-";
 var WORKER_FLAG = "--maxWorkers";
 var WORKER_FLAGS = [WORKER_FLAG, "--max-workers"];
@@ -957,7 +819,7 @@ function is_marker_live(source) {
   return false;
 }
 function live_run_count(directory = PLATFORM_TEMP_ROOT) {
-  return marker_files(directory).filter((name) => is_marker_live(path2.join(directory, name))).length;
+  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";
@@ -980,22 +842,22 @@ function worker_arguments(vitest_arguments, share) {
   if (vitest_arguments.some((argument) => is_worker_flag(argument))) return [];
   return [`${WORKER_FLAG}=${String(share)}`];
 }
-function mark_run_started(target) {
+function mark_run_started(target2) {
   try {
-    stamp_file.write_stamp(target, process_identity.own_fields());
+    stamp_file.write_stamp(target2, process_identity.own_fields());
   } catch {
   }
 }
 async function with_run_marker(run) {
   if (is_nested_run()) return await run();
-  const target = marker_path();
-  mark_run_started(target);
+  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(target);
+    stamp_file.remove_stamp(target2);
   }
 }
 var unit_worker_share = {
@@ -1015,7 +877,243 @@ var unit_worker_share = {
 };
 
 // scripts/gate/core-budget.ts
-import { z as z3 } from "zod";
+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);
+  });
+}
+async function read_machine(sleep = default_sleep) {
+  const before = cpu_times();
+  const [memory] = await Promise.all([read_memory(), sleep(SAMPLE_WINDOW_MS)]);
+  const busy_cores = is_unquoted() ? busy_cores_between(before, cpu_times(), cpus().length) : void 0;
+  return { busy_cores, available_mb: memory.available_mb };
+}
+async function read_sample() {
+  return { cpu: cpu_times(), memory: await read_memory(), total_mb: totalmem() / BYTES_PER_MB };
+}
+function external_cores(busy_cores, ledger_cores) {
+  if (busy_cores === void 0) return 0;
+  return Math.floor(Math.max(0, busy_cores - ledger_cores - BASELINE_CORES));
+}
+function machine_budget(cores, reading, ledger) {
+  return {
+    cores: cores - external_cores(reading.busy_cores, ledger.cores),
+    memory_mb: reading.available_mb === void 0 ? Infinity : reading.available_mb + ledger.memory_mb
+  };
+}
+var machine_capacity = {
+  BASELINE_CORES,
+  busy_cores_between,
+  busy_share_between,
+  external_cores,
+  machine_budget,
+  parse_darwin_memory,
+  parse_linux_available,
+  parse_linux_swapped,
+  read_machine,
+  read_memory,
+  read_sample,
+  swapped_between
+};
+
+// scripts/gate/core-budget.ts
 var RESERVED_PREFIX = "josh-core-reserved-";
 var RESERVED_SUFFIX = ".json";
 var POLL_INTERVAL_MS = 50;
@@ -1027,11 +1125,20 @@ var CORE_WEIGHTS = {
   spell_check: 1,
   eslint_scan: 1
 };
+var MEMORY_MB = {
+  lint: 2400,
+  type_check: 1300,
+  spell_check: 350,
+  eslint_scan: 2400,
+  unit_worker: 350
+};
 var HELD_KEY = "JOSH_CORE_RESERVED";
 var HELD_VALUE = "1";
 var reservation_schema = process_owner_schema.extend({
-  weight: z3.number(),
-  claimed_at: z3.number()
+  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}`;
@@ -1042,12 +1149,7 @@ function is_running2(reservation) {
 function read_reservation(source) {
   const raw = stamp_file.read_stamp_text(source);
   if (raw === void 0) return void 0;
-  try {
-    const parsed = reservation_schema.safeParse(JSON.parse(raw));
-    return parsed.success ? parsed.data : void 0;
-  } catch {
-    return void 0;
-  }
+  return json_value.parse_with(raw, reservation_schema);
 }
 function sweep_marker2(source) {
   try {
@@ -1064,78 +1166,92 @@ function live_reservation(source) {
 }
 function marker_files2(directory) {
   try {
-    return readdirSync2(directory).filter((name) => name.startsWith(RESERVED_PREFIX));
+    return readdirSync2(directory).filter(
+      (name) => name.startsWith(RESERVED_PREFIX) && name.endsWith(RESERVED_SUFFIX)
+    );
   } catch {
     return [];
   }
 }
 function live_reservations(directory = PLATFORM_TEMP_ROOT) {
   return marker_files2(directory).flatMap((name) => {
-    const reservation = live_reservation(path3.join(directory, name));
+    const reservation = live_reservation(path2.join(directory, name));
     return reservation === void 0 ? [] : { key: name, reservation };
   });
 }
-function compare_claim(left, right) {
-  const by_time = left.reservation.claimed_at - right.reservation.claimed_at;
-  return by_time === 0 ? left.key.localeCompare(right.key) : by_time;
-}
-function admitted_keys(reservations, budget) {
-  const admitted = /* @__PURE__ */ new Set();
-  let cumulative = 0;
-  for (const [index, entry] of reservations.toSorted(compare_claim).entries()) {
-    cumulative += entry.reservation.weight;
-    if (index !== 0 && cumulative > budget) break;
-    admitted.add(entry.key);
-  }
-  return admitted;
-}
-function is_admitted(key, reservations, budget) {
-  return admitted_keys(reservations, budget).has(key);
-}
-function admitted_load(reservations, budget) {
-  const admitted = admitted_keys(reservations, budget);
-  return reservations.filter((entry) => admitted.has(entry.key)).reduce((total, entry) => total + entry.reservation.weight, 0);
-}
 function normalize_budget(budget) {
   return Number.isFinite(budget) ? Math.max(MIN_BUDGET, Math.floor(budget)) : MIN_BUDGET;
 }
-async function default_sleep(ms) {
+async function default_sleep2(ms) {
   await new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
 }
-function write_reservation(target, weight, claimed_at) {
-  stamp_file.write_stamp(target, { ...process_identity.own_fields(), weight, claimed_at });
+function write_reservation(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_sleep,
-    poll_interval_ms: options.poll_interval_ms ?? POLL_INTERVAL_MS
+    sleep: options.sleep ?? default_sleep2,
+    poll_interval_ms: options.poll_interval_ms ?? POLL_INTERVAL_MS,
+    wait_cap_ms: options.wait_cap_ms ?? WAIT_CAP_MS
+  };
+}
+async function current_budget(context, reservations) {
+  if (reservations.length <= 1) return { cores: context.budget, memory_mb: Infinity };
+  const reading = await context.read_machine();
+  const ledger = core_admission.ledger_load(reservations, context.now());
+  const budget = machine_capacity.machine_budget(context.budget, reading, ledger);
+  return { ...budget, cores: normalize_budget(budget.cores) };
+}
+function admit(context, overflow) {
+  write_reservation(context.target, { ...context.fields, admitted_at: context.now() });
+  return { overflow };
+}
+function overflow_of(context, reservations, budget) {
+  return {
+    waited_ms: context.now() - context.fields.claimed_at,
+    ledger: core_admission.sum_load(reservations),
+    budget
   };
 }
+async function poll_admission(context) {
+  const reservations = live_reservations(context.directory);
+  const budget = await current_budget(context, reservations);
+  if (core_admission.is_admitted(context.key, reservations, budget)) return admit(context);
+  if (context.now() >= context.deadline) {
+    return admit(context, overflow_of(context, reservations, budget));
+  }
+  return void 0;
+}
 async function await_admission(context) {
-  while (!is_admitted(context.key, live_reservations(context.directory), context.budget)) {
-    if (context.now() >= context.deadline) return;
+  let admission = await poll_admission(context);
+  while (admission === void 0) {
     await context.sleep(context.poll_interval_ms);
+    admission = await poll_admission(context);
   }
+  return admission;
 }
 async function reserve(weight, options = {}) {
   const timing = resolve_timing(options);
   const directory = options.directory ?? PLATFORM_TEMP_ROOT;
-  const budget = normalize_budget(options.budget ?? availableParallelism2());
   const claimed_at = timing.now();
-  const name = marker_name(randomUUID2());
-  const target = path3.join(directory, name);
-  write_reservation(target, weight, claimed_at);
-  await await_admission({
+  const 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,
-    deadline: claimed_at + (options.wait_cap_ms ?? WAIT_CAP_MS)
+    budget: normalize_budget(options.budget ?? availableParallelism3()),
+    deadline: claimed_at + timing.wait_cap_ms,
+    fields,
+    read_machine: options.read_machine ?? machine_capacity.read_machine
   });
-  return { target };
+  return { target: target2, admission };
 }
 function release(handle) {
   sweep_marker2(handle.target);
@@ -1143,7 +1259,7 @@ function release(handle) {
 async function with_core_reservation(weight, run, options = {}) {
   const handle = await reserve(weight, options);
   try {
-    return await run();
+    return await run(handle.admission);
   } finally {
     release(handle);
   }
@@ -1171,9 +1287,11 @@ var core_budget = {
   CORE_WEIGHTS,
   HELD_KEY,
   HELD_VALUE,
+  MEMORY_MB,
   RESERVED_PREFIX,
-  admitted_keys,
-  admitted_load,
+  admitted_keys: core_admission.admitted_keys,
+  admitted_load: core_admission.admitted_load,
+  describe_overflow: core_admission.describe_overflow,
   is_held,
   live_reservations,
   release,
@@ -1184,7 +1302,7 @@ var core_budget = {
 };
 
 // scripts/gate/gate-plan.ts
-import { availableParallelism as availableParallelism3 } from "node:os";
+import { availableParallelism as availableParallelism4 } from "node:os";
 
 // scripts/lib/status-icons.ts
 var FAIL_ICON = "\u2717";
@@ -1232,28 +1350,53 @@ var LINT_LABEL = "lint";
 var TYPE_CHECK_LABEL = "check";
 var UNIT_LABEL = "test:unit";
 var BEHAVIOR_LABEL = "behavior";
+var METRICS_LABEL = "metrics";
 var WARNING_CHECKER_LABELS = [LINT_LABEL, TYPE_CHECK_LABEL];
 var STATIC_CHECKS = [
-  { label: LINT_LABEL, target: "lint", reserved_cores: core_budget.CORE_WEIGHTS.lint },
+  {
+    label: LINT_LABEL,
+    target: "lint",
+    reserved_cores: core_budget.CORE_WEIGHTS.lint,
+    memory_mb: core_budget.MEMORY_MB.lint
+  },
   {
     label: TYPE_CHECK_LABEL,
     target: "check",
-    reserved_cores: core_budget.CORE_WEIGHTS.type_check
+    reserved_cores: core_budget.CORE_WEIGHTS.type_check,
+    memory_mb: core_budget.MEMORY_MB.type_check
+  },
+  {
+    label: "cspell",
+    target: "cspell:dot",
+    reserved_cores: core_budget.CORE_WEIGHTS.spell_check,
+    memory_mb: core_budget.MEMORY_MB.spell_check
   },
-  { label: "cspell", target: "cspell:dot", reserved_cores: core_budget.CORE_WEIGHTS.spell_check },
   { label: BEHAVIOR_LABEL, target: BEHAVIOR_LABEL, reserved_cores: 0 },
-  // **The unused-member check reserves no core** (joshuafolkken/kit#2987): it builds one TypeScript
+  // **The unused-member check reserves no core**: it builds one TypeScript
   // 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", 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.
+  // It times no startup here: beside the unit suite that reads the load, not josh.
+  {
+    label: METRICS_LABEL,
+    target: METRICS_LABEL,
+    args: ["--no-startup"],
+    reserved_cores: 0,
+    memory_mb: core_budget.MEMORY_MB.eslint_scan,
+    is_kit_only: true
+  }
 ];
 var GATE_CHECKS = [
   ...STATIC_CHECKS,
   { label: UNIT_LABEL, target: UNIT_LABEL, reserved_cores: 0 }
 ];
-function select_gate_checks(is_unit_included) {
-  return is_unit_included ? GATE_CHECKS : STATIC_CHECKS;
+function select_gate_checks(is_unit_included, is_kit_repository = true) {
+  const checks = is_unit_included ? GATE_CHECKS : STATIC_CHECKS;
+  return is_kit_repository ? checks : checks.filter((check) => check.is_kit_only !== true);
 }
 function has_unit_check(checks) {
   return checks.some((check) => check.label === UNIT_LABEL);
@@ -1293,19 +1436,33 @@ function check_weight(check, plan, available_cores) {
   if (check.label !== UNIT_LABEL) return check.reserved_cores;
   return plan.unit_worker_cap ?? solo_unit_weight(available_cores);
 }
-function direct_unit_weight(available_cores = availableParallelism3(), live_runs = unit_worker_share.live_run_count()) {
+function unit_memory(workers) {
+  return workers * core_budget.MEMORY_MB.unit_worker;
+}
+function check_memory(check, plan, available_cores) {
+  if (check.label !== UNIT_LABEL) return check.memory_mb ?? 0;
+  return unit_memory(check_weight(check, plan, available_cores));
+}
+function direct_unit_weight(available_cores = availableParallelism4(), live_runs = unit_worker_share.live_run_count()) {
   const weight = unit_worker_share.current_share(available_cores, live_runs) ?? solo_unit_weight(available_cores);
   return Math.max(unit_worker_share.MIN_WORKERS, weight);
 }
+function direct_unit_memory() {
+  return unit_memory(direct_unit_weight());
+}
+function unit_cap_for(checks, available_cores, concurrent_runs) {
+  if (!has_unit_check(checks)) return void 0;
+  return resolve_unit_worker_cap(available_cores, concurrent_runs);
+}
 function plan_of(concurrency, unit_worker_cap, checks = GATE_CHECKS) {
   return { checks, concurrency, unit_worker_cap };
 }
-function resolve_gate_plan(available_cores = availableParallelism3(), concurrent_runs = unit_worker_share.SOLO_RUNS, is_unit_included = true) {
-  const checks = select_gate_checks(is_unit_included);
+function resolve_gate_plan(available_cores = availableParallelism4(), concurrent_runs = unit_worker_share.SOLO_RUNS, is_unit_included = true, is_kit_repository = true) {
+  const checks = select_gate_checks(is_unit_included, is_kit_repository);
   return {
     checks,
     concurrency: resolve_concurrency(available_cores, concurrent_runs, checks),
-    unit_worker_cap: is_unit_included ? resolve_unit_worker_cap(available_cores, concurrent_runs) : void 0
+    unit_worker_cap: unit_cap_for(checks, available_cores, concurrent_runs)
   };
 }
 function format_machine(available_cores, concurrent_runs) {
@@ -1318,7 +1475,7 @@ function format_unit_cap(plan) {
   if (plan.unit_worker_cap === void 0) return `${UNIT_LABEL} unrestricted`;
   return `${UNIT_LABEL} at ${String(plan.unit_worker_cap)} workers`;
 }
-function format_gate_plan(plan, available_cores = availableParallelism3(), concurrent_runs = unit_worker_share.SOLO_RUNS) {
+function format_gate_plan(plan, available_cores = availableParallelism4(), concurrent_runs = unit_worker_share.SOLO_RUNS) {
   const cap = format_unit_cap(plan);
   const count = `${String(plan.concurrency)} of ${String(plan.checks.length)}`;
   const width = `${count}${josh_verdict.GATE_OPENING_MARK}`;
@@ -1329,12 +1486,15 @@ var gate_plan = {
   GATE_CHECKS,
   LINT_LABEL,
   MEASURED_CORES,
+  METRICS_LABEL,
   RESERVED_CORES,
   STATIC_CHECKS,
   TYPE_CHECK_LABEL,
   UNIT_LABEL,
   WARNING_CHECKER_LABELS,
+  check_memory,
   check_weight,
+  direct_unit_memory,
   direct_unit_weight,
   format_gate_plan,
   format_machine,
@@ -1370,28 +1530,45 @@ var DEV_COMMANDS = {
     description: "Check code with prettier and eslint (skips a tool a basic project lacks)",
     category: "Development",
     reference: ["", "developer", ["processes"]],
-    core_weight: core_budget.CORE_WEIGHTS.lint
+    core_weight: core_budget.CORE_WEIGHTS.lint,
+    memory_mb: core_budget.MEMORY_MB.lint
   },
   "lint:related": {
     script: "scripts/lint/lint-related.ts",
     description: "Check only the changed files with prettier and eslint (whole tree on fallback)",
     category: "Development",
     reference: [FILE_ARGUMENTS, "developer", ["processes"]],
-    core_weight: core_budget.CORE_WEIGHTS.lint
+    core_weight: core_budget.CORE_WEIGHTS.lint,
+    memory_mb: core_budget.MEMORY_MB.lint
   },
   lines: {
     script: "scripts/lines/lines-command.ts",
     description: "Print a file's code lines against the max-lines limit and the headroom left",
     category: "Development",
     reference: [REQUIRED_FILE_ARGUMENTS, "developer", ["none"]],
-    core_weight: core_budget.CORE_WEIGHTS.eslint_scan
+    core_weight: core_budget.CORE_WEIGHTS.eslint_scan,
+    memory_mb: core_budget.MEMORY_MB.eslint_scan
+  },
+  metrics: {
+    script: "scripts/metrics/metrics-command.ts",
+    description: "Print repository-wide quality totals and durations, and fail when a total grew past the merge-base or a duration past its baseline",
+    category: "Development",
+    reference: [
+      '[--no-startup | --totals-only | --accept --reason "<why>"]',
+      "developer",
+      ["files"]
+    ],
+    core_weight: core_budget.CORE_WEIGHTS.eslint_scan,
+    memory_mb: core_budget.MEMORY_MB.eslint_scan,
+    is_kit_only: true
   },
   "refactor:scan": {
     script: "scripts/refactor/refactor-scan-cli.ts",
     description: "List refactoring candidates in the changed scope by category and answer clear/candidates",
     category: "Development",
     reference: ["", "automation", ["processes"]],
-    core_weight: core_budget.CORE_WEIGHTS.eslint_scan
+    core_weight: core_budget.CORE_WEIGHTS.eslint_scan,
+    memory_mb: core_budget.MEMORY_MB.eslint_scan
   },
   bytes: {
     script: "scripts/lines/bytes-command.ts",
@@ -1405,6 +1582,12 @@ var DEV_COMMANDS = {
     category: "AI tools",
     reference: ["[--refresh]", "developer", ["files"]]
   },
+  "rule:list": {
+    script: "scripts/rules/rule-list.ts",
+    description: "Print the trigger-delivered rules \u2014 each one's source, firing call and silent turn \u2014 from the guard rows",
+    category: "AI tools",
+    reference: ["", "automation", ["none"]]
+  },
   format: {
     script: "scripts/lint/format.ts",
     description: "Format code with prettier and eslint (skips a tool a basic project lacks)",
@@ -1425,8 +1608,8 @@ var DEV_COMMANDS = {
     // **No `tsx_arguments`, deliberately.** `JOSH_BATCH_GUARD` is a per-machine preference kept in
     // `.env`, which every other command reads through `OPTIONAL_ENV_FILE_FLAGS` — but declaring any
     // `tsx_arguments` disqualifies a command from in-process dispatch (`josh-in-process.ts`), and
-    // this one runs before every `Bash` call. That is the hot path joshuafolkken/kit#1342 took a
-    // second ~0.16 s tsx start off. The script calls `process.loadEnvFile` itself instead, which is
+    // this one runs before every `Bash` call, where a second ~0.16 s tsx start is not affordable.
+    // The script calls `process.loadEnvFile` itself instead, which is
     // node's own `--env-file` parser with node's own precedence.
   },
   "pretool:guard": {
@@ -1450,7 +1633,7 @@ var DEV_COMMANDS = {
   },
   "session:lang": {
     script: "scripts/josh/session-language-cli.ts",
-    description: "Claude Code hook: print the resolved JOSH_SESSION_LANG (defaults to ja) for the session context",
+    description: "Claude Code hook: print a non-default JOSH_SESSION_LANG for the session context, and the run:board reply rule while a backlogrun is live (otherwise nothing)",
     category: "Development",
     reference: ["", "automation", ["none"]]
     // **No `tsx_arguments`, deliberately**, the same as `batch:guard` above: this runs on every
@@ -1463,7 +1646,7 @@ var DEV_COMMANDS = {
     category: "Development",
     reference: ["<pretool|posttool>", "automation", ["none"]]
     // The live-source fallback `scripts/hooks/run-hook.sh` derives from the `codex-hook-adapter`
-    // bundle name (joshuafolkken/kit#3184). **No `tsx_arguments`**, the same as `pretool:guard`
+    // bundle name. **No `tsx_arguments`**, the same as `pretool:guard`
     // above: it runs before every guarded Codex call.
   },
   "cspell:dot": {
@@ -1471,7 +1654,8 @@ var DEV_COMMANDS = {
     description: "Run spell check including dotfiles",
     category: "Development",
     reference: ["", "developer", ["processes"]],
-    core_weight: core_budget.CORE_WEIGHTS.spell_check
+    core_weight: core_budget.CORE_WEIGHTS.spell_check,
+    memory_mb: core_budget.MEMORY_MB.spell_check
   },
   behavior: {
     script: "scripts/behavior/behavior-cli.ts",
@@ -1490,14 +1674,16 @@ var DEV_COMMANDS = {
     description: "Run unit tests with Vitest (skips when Vitest is absent; fails when it has no tests)",
     category: "Development",
     reference: [FILTER_ARGUMENTS, "developer", ["processes"]],
-    core_weight: gate_plan.direct_unit_weight
+    core_weight: gate_plan.direct_unit_weight,
+    memory_mb: gate_plan.direct_unit_memory
   },
   "test:related": {
     script: "scripts/test/test-related.ts",
     description: "Run only the unit tests related to the changed files (full suite on fallback)",
     category: "Development",
     reference: [FILE_ARGUMENTS, "developer", ["processes"]],
-    core_weight: gate_plan.direct_unit_weight
+    core_weight: gate_plan.direct_unit_weight,
+    memory_mb: gate_plan.direct_unit_memory
   },
   "test:declared": {
     script: "scripts/test/test-declared.ts",
@@ -1541,7 +1727,8 @@ var DEV_COMMANDS = {
     description: "Type-check with tsc (skips a basic project with no TypeScript to check)",
     category: "Development",
     reference: ["[arguments...]", "developer", ["processes"]],
-    core_weight: core_budget.CORE_WEIGHTS.type_check
+    core_weight: core_budget.CORE_WEIGHTS.type_check,
+    memory_mb: core_budget.MEMORY_MB.type_check
   },
   port: {
     script: "scripts/ports/port-command.ts",
@@ -1662,9 +1849,9 @@ var MAINTENANCE_COMMANDS = {
     shell: [
       "sh",
       "-c",
-      "export NODE_AUTH_TOKEN=$(gh auth token) && pnpm josh latest:guard && pnpm josh latest:corepack && pnpm josh latest:update && pnpm josh ranges && pnpm josh audit && pnpm josh latest:scope --record"
+      "export NODE_AUTH_TOKEN=$(gh auth token) && pnpm josh latest:guard && pnpm josh latest:update && pnpm josh ranges && pnpm josh audit && pnpm josh latest:corepack && pnpm josh latest:scope --record"
     ],
-    description: "Update pnpm, dependencies, and run security audit",
+    description: "Update dependencies, run security audit, then update pnpm",
     category: "Maintenance",
     reference: ["", "developer", ["files", "network", "processes"]],
     argument_targets: ["latest:corepack", "latest:update", "audit"]
@@ -1813,16 +2000,16 @@ var VERSIONING_COMMANDS = {
     category: "Versioning",
     reference: ["", "developer", ["network"]]
   },
-  // The one place that decides a version (joshuafolkken/kit#1169). A `script` entry for the same
+  // The one place that decides a version. A `script` entry for the same
   // reason `ranges` is one: script paths resolve against the kit package root, so it keeps working
   // from a consumer repository where the file lives under node_modules.
   release: {
     script: "scripts/release/release-cli.ts",
     description: "Release the merges main has taken since the version last changed",
     category: "Versioning",
-    reference: ["[version]", "maintainer", ["git", "network", "release"]]
+    reference: ["[--dry-run]", "maintainer", ["git", "network", "release"]]
   },
-  // The read-only half of the one above (joshuafolkken/kit#1582). `release --dry-run` cannot
+  // The read-only half of the one above. `release --dry-run` cannot
   // answer this question: it refuses off the default branch and on a dirty tree, which is every
   // position a run asks it from. A `script` entry for the same reason `release` is one.
   "release:scope": {
@@ -1831,8 +2018,8 @@ var VERSIONING_COMMANDS = {
     category: "Versioning",
     reference: ["[--json]", "automation", ["none"]]
   },
-  // Run by the release workflows, kit's and the one sync distributes, after a tag has published
-  // (joshuafolkken/kit#3007). Settings come from the environment, so the workflow decides them.
+  // Run by the release workflows, kit's and the one sync distributes, after a tag has published.
+  // Settings come from the environment, so the workflow decides them.
   "release:github": {
     script: "scripts/release/github-release-cli.ts",
     description: "Create the GitHub Release for a published tag, with generated notes",
@@ -1860,20 +2047,17 @@ var WORKFLOW_COMMANDS = {
     reference: ["<message>", "developer", ["network"]],
     default_script_arguments: ["-y", "--skip-commit", "--skip-push"]
   },
-  // **The optional form, on both** (joshuafolkken/kit#1564). These two were the last commands
-  // passing the mandatory `--env-file=.env`, which node resolves before the script's first line: on
-  // a machine with no `.env` they died as `.env: not found` with exit code 9, even where
-  // `TELEGRAM_BOT_TOKEN` and `TELEGRAM_CHAT_ID` existed as real environment variables — a cloud
-  // session, and `followup` with them the merge step of every `fullrun` there. `doctor` was moved to
-  // this form for the same reason in joshuafolkken/kit#869.
+  // **The optional form, on both**. The mandatory `--env-file=.env` is resolved by node before the
+  // script's first line: on a machine with no `.env` it dies as `.env: not found` with exit code 9,
+  // even where `TELEGRAM_BOT_TOKEN` and `TELEGRAM_CHAT_ID` exist as real environment variables — a
+  // cloud session, and `followup` with them the merge step of every `fullrun` there.
   //
   // Nothing is lost by relaxing it: both scripts already load `.env` through `josh_environment_file`
   // themselves, so the file is read either way and node's precedence — an existing environment
   // variable wins over the file — is node's own in both spellings.
   //
-  // **What the mandatory flag was accidentally providing was noise**, and that is replaced rather
-  // than dropped: `telegram_notify.send` now throws on missing credentials and on a failed send, so
-  // `josh notify` exits non-zero instead of warning and answering 0.
+  // **A missing credential still fails loudly**: `telegram_notify.send` throws on missing credentials
+  // and on a failed send, so `josh notify` exits non-zero instead of warning and answering 0.
   followup: {
     script: "scripts/followup/git-followup-workflow.ts",
     description: "Follow-up git workflow",
@@ -1889,11 +2073,23 @@ var WORKFLOW_COMMANDS = {
     script: "scripts/notify/telegram-test.ts",
     description: "Send Telegram notification",
     category: "Workflow",
-    reference: ["--task-type <type> --body <text>", "automation", ["notifications"]],
+    reference: [
+      "[--task-type <type>] [--body <text> | --body-file <path>] [--issue-url <url>] [--pr-url <url>] [--issue-title <text>] [--repo-name <name>]",
+      "automation",
+      ["notifications"]
+    ],
     tsx_arguments: OPTIONAL_ENV_FILE_FLAGS
   },
-  // The observation ledger's commit path for the lines no run's own commit carried
-  // (joshuafolkken/kit#1756, joshuafolkken/kit#2763): a lane's lines sit in the primary checkout, which
+  // One observation-ledger sighting: the key's count, the append and the second-sighting verdict,
+  // which a run used to type as a `cat | grep -c` and judge by hand.
+  "observation:record": {
+    script: "scripts/observations/observation-record-cli.ts",
+    description: "Record an observation sighting and answer whether it is now filed",
+    category: "Workflow",
+    reference: ["<key> <depth> <where> <what> [--checkout <path>]", "automation", ["files"]]
+  },
+  // The observation ledger's commit path for the lines no run's own commit carried:
+  // a lane's lines sit in the primary checkout, which
   // its commit cannot see, and the recurrence count the promotion rule reads is a count of main.
   "observations:flush": {
     script: "scripts/observations/observations-flush-cli.ts",
@@ -1901,8 +2097,8 @@ var WORKFLOW_COMMANDS = {
     category: "Workflow",
     reference: ["", "automation", ["git", "network"]]
   },
-  // The one write path for a `/code-review` round's findings (joshuafolkken/kit#2325), plus the
-  // `--check` gate `followup` runs before it merges (joshuafolkken/kit#2343). It appends a `- rf:`
+  // The one write path for a `/code-review` round's findings, plus the
+  // `--check` gate `followup` runs before it merges. It appends a `- rf:`
   // line per finding — or one zero-finding line for a clean round — to the observation ledger, so
   // `observations:flush` commits them and the recurrence count survives the run.
   "review:record": {
@@ -1910,12 +2106,12 @@ var WORKFLOW_COMMANDS = {
     description: "Record a review round\u2019s findings, or check a round was recorded",
     category: "Workflow",
     reference: [
-      "--issue <N> [<category>:<severity>:<file> ...] | --check --issue <N>",
+      "--issue <N> [--comment] [<category>:<severity>:<file> ...] | --check --issue <N>",
       "automation",
-      ["files"]
+      ["files", "network"]
     ]
   },
-  // The reader over what `review:record` wrote (joshuafolkken/kit#2325): each recurring category’s
+  // The reader over what `review:record` wrote: each recurring category’s
   // count, and the number of zero-finding rounds that distinguishes a quiet category from an unwatched one.
   "review:findings": {
     script: "scripts/review/review-findings-cli.ts",
@@ -1924,7 +2120,7 @@ var WORKFLOW_COMMANDS = {
     reference: ["", "developer", ["files"]]
   },
   // After a behavior-change Issue merges, re-run its declared baseline and print before/after; a value
-  // that did not move appends a refuted-premise line to the observation ledger (joshuafolkken/kit#2212).
+  // that did not move appends a refuted-premise line to the observation ledger.
   "measure:rerun": {
     script: "scripts/issue/measure-rerun-cli.ts",
     description: "Re-run a merged issue\u2019s baseline command and print the before/after pair",
@@ -1932,7 +2128,7 @@ var WORKFLOW_COMMANDS = {
     reference: ["<issue-number>", "automation", ["network", "processes", "files"]]
   },
   // A script rather than an `sh -c` chain, because it has a precondition to enforce: run inside a
-  // linked work tree it would hijack the default branch from every other one (joshuafolkken/kit#1535).
+  // linked work tree it would hijack the default branch from every other one.
   "main:sync": {
     script: "scripts/git/main-sync.ts",
     description: "Checkout default branch, pull latest, and prune merged remote-gone branches (refuses inside a lane)",
@@ -1940,9 +2136,8 @@ var WORKFLOW_COMMANDS = {
     reference: ["", "developer", ["git", "network"]]
   },
   // A script rather than an `sh -c` chain, because the strategy has to be named rather than left to
-  // the caller's git configuration: the `git pull` this replaced aborted with `Need to specify how
-  // to reconcile divergent branches` on exactly the diverged branch the command exists for
-  // (joshuafolkken/kit#1659).
+  // 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.
   "main:merge": {
     script: "scripts/git/main-merge.ts",
     description: "Merge origin default branch into the current branch",
@@ -1969,6 +2164,7 @@ var ALIASES = {
   lr: "lint:related",
   ln: "lines",
   by: "bytes",
+  mt: "metrics",
   f: "format",
   sd: "cspell:dot",
   bh: "behavior",
@@ -2011,7 +2207,9 @@ var ALIASES = {
   ruv: "rule:value",
   ev: "eval",
   lsm: "lane:sample",
-  lst: "lane:stats"
+  lst: "lane:stats",
+  lli: "lane:limit",
+  blr: "backlogrun"
 };
 function canonical_command(name) {
   if (!Object.hasOwn(ALIASES, name)) return name;
@@ -2234,74 +2432,74 @@ var time_background = {
 };
 
 // scripts/git/git-schemas.ts
-import { z as z4 } from "zod";
-var package_name_schema = z4.object({ name: z4.string().min(1) });
-var rollup_item_schema = z4.looseObject({
+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: z4.string().optional(),
-  state: z4.string().optional(),
-  status: z4.string().optional(),
-  conclusion: z4.string().optional(),
-  name: z4.string().optional(),
-  context: z4.string().optional()
+  __typename: z3.string().optional(),
+  state: z3.string().optional(),
+  status: z3.string().optional(),
+  conclusion: z3.string().optional(),
+  name: z3.string().optional(),
+  context: z3.string().optional()
 });
-var pr_raw_schema = z4.object({
-  statusCheckRollup: z4.array(rollup_item_schema).optional(),
-  mergeStateStatus: z4.string().optional(),
-  reviewDecision: z4.string().optional()
+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 = z4.object({
-  body: z4.string().optional(),
-  html_url: z4.string().optional(),
-  user: z4.object({ login: z4.string().optional() }).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 = z4.object({
-  body: z4.string().optional(),
-  url: z4.string().optional(),
-  author: z4.object({ login: z4.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 = z4.object({
-  mergeable: z4.union([z4.boolean(), z4.string()]).nullable().optional(),
-  mergeStateStatus: z4.string().nullable().optional(),
-  state: z4.string().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 = z4.object({
-  number: z4.number(),
-  body: z4.string().optional()
+var epic_issue_schema = z3.object({
+  number: z3.number(),
+  body: z3.string().optional()
 });
-var blocking_issue_schema = z4.object({
-  number: z4.number(),
-  state: z4.string().optional(),
-  repository_url: z4.string().optional()
+var blocking_issue_schema = z3.object({
+  number: z3.number(),
+  state: z3.string().optional(),
+  repository_url: z3.string().optional()
 });
-var blocked_by_schema = z4.object({
-  nodes: z4.array(blocking_issue_schema).default([]),
-  totalCount: z4.number().optional()
+var blocked_by_schema = z3.object({
+  nodes: z3.array(blocking_issue_schema).default([]),
+  totalCount: z3.number().optional()
 }).optional();
-var epic_child_schema = z4.object({
-  state: z4.string().optional(),
+var epic_child_schema = z3.object({
+  state: z3.string().optional(),
   blockedBy: blocked_by_schema
 });
-var rest_comment_schema = z4.looseObject({
-  body: z4.string().nullish(),
-  html_url: z4.string().optional(),
-  user: z4.looseObject({ login: z4.string().optional() }).nullish()
+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 = z4.object({ name: z4.string() });
-var epic_subject_schema = z4.object({
-  number: z4.number(),
-  state: z4.string().optional(),
-  labels: z4.array(issue_label_schema).optional(),
-  body: z4.string().optional()
+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 = z4.object({
-  number: z4.number(),
-  title: z4.string(),
-  labels: z4.array(issue_label_schema).optional(),
-  createdAt: z4.string(),
+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 restructures each issue declares.
-  body: z4.string().optional()
+  // 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
@@ -2477,9 +2675,135 @@ var PrConflictError = class extends Error {
   name = "PrConflictError";
 };
 
+// scripts/lane/lane-ledger.ts
+import { closeSync, constants, openSync, writeSync } from "node:fs";
+import { z as z4 } from "zod";
+var LEDGER_PREFIX = "josh-lane-ledger-";
+var LEDGER_SUFFIX = ".jsonl";
+var LINE_SEPARATOR = "\n";
+var CI_WAIT_STAGE = "ci-wait";
+var LEDGER_FILE_MODE = 384;
+var { O_APPEND, O_CREAT, O_NOFOLLOW, O_WRONLY } = constants;
+var APPEND_FLAGS = O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW;
+var KIND = {
+  MERGE: "merge",
+  GATE: "gate",
+  LOAD: "load",
+  DISPATCH: "dispatch",
+  STAGE: "stage"
+};
+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(),
+  // 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(),
+  // 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()
+});
+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 dispatch_schema = z4.object({
+  kind: z4.literal(KIND.DISPATCH),
+  at: z4.string(),
+  issue: z4.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 entry_schema = z4.discriminatedUnion("kind", [
+  merge_schema,
+  gate_schema,
+  load_schema,
+  dispatch_schema,
+  stage_schema
+]);
+function target_of(repository) {
+  return stamp_file.stamp_path(LEDGER_PREFIX, repository, LEDGER_SUFFIX);
+}
+async function target() {
+  if (process.env["VITEST"] !== void 0) return void 0;
+  try {
+    const repository = await run_carry.repository_directory();
+    return repository === void 0 ? void 0 : target_of(repository);
+  } catch {
+    return void 0;
+  }
+}
+function append(path4, entry) {
+  const descriptor = openSync(path4, APPEND_FLAGS, LEDGER_FILE_MODE);
+  try {
+    if (stamp_file.is_own_regular_file(path4)) {
+      writeSync(descriptor, `${JSON.stringify(entry)}${LINE_SEPARATOR}`);
+    }
+  } finally {
+    closeSync(descriptor);
+  }
+}
+async function record(entry, path4) {
+  try {
+    const destination = path4 ?? await target();
+    if (destination !== void 0) append(destination, entry);
+  } catch {
+  }
+}
+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_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_stage(stage, path4) {
+  await record({ kind: KIND.STAGE, at: now_iso(), ...stage }, path4);
+}
+function parse_line2(line) {
+  return entry_schema.safeParse(json_value.parse_or_undefined(line)).data;
+}
+function is_present(entry) {
+  return entry !== void 0;
+}
+function read_entries(path4) {
+  const raw = stamp_file.read_stamp_text(path4);
+  if (raw === void 0) return [];
+  return raw.split(LINE_SEPARATOR).map((line) => parse_line2(line.trim())).filter(is_present);
+}
+var lane_ledger = {
+  CI_WAIT_STAGE,
+  KIND,
+  append,
+  read_entries,
+  record,
+  record_dispatch,
+  record_gate,
+  record_merge,
+  record_stage,
+  target,
+  target_of
+};
+
 // scripts/time-runtime/time-format.ts
 var MS_PER_MINUTE = 6e4;
-var MS_PER_SECOND = 1e3;
+var MS_PER_SECOND2 = 1e3;
 var MINUTE_DECIMALS = 1;
 var SECOND_DECIMALS = 1;
 var PERCENT_SCALE = 100;
@@ -2499,7 +2823,7 @@ function format_minutes(duration_ms) {
   return `${(duration_ms / MS_PER_MINUTE).toFixed(MINUTE_DECIMALS)} min`;
 }
 function format_seconds(duration_ms) {
-  return `${(duration_ms / MS_PER_SECOND).toFixed(SECOND_DECIMALS)} s`;
+  return `${(duration_ms / MS_PER_SECOND2).toFixed(SECOND_DECIMALS)} s`;
 }
 function format_share(part, whole) {
   if (whole === 0) return "n/a";
@@ -2549,8 +2873,8 @@ var STAGE = {
   // blocker and on a red check, and those are the runs whose wait is longest — reporting nothing for
   // them would leave the measurement blind to exactly the invocations worth measuring.
   interrupted: "interrupted",
-  // The interrupted lap when the wait failed on a merge conflict (joshuafolkken/kit#3221), so the
-  // stage block names the cause a resumed session used to look up with `gh pr view`.
+  // The interrupted lap when the wait failed on a merge conflict, so the
+  // stage block names the cause a resumed session would otherwise look up with `gh pr view`.
   conflict: "conflict"
 };
 function stopped_lap(error) {
@@ -2580,6 +2904,14 @@ function format_stages(log) {
 function print_stages(log) {
   for (const line of format_stages(log)) console.info(line);
 }
+async function record_ci_wait(log) {
+  const wait = log.stages.find((stage) => stage.name === STAGE.checks_wait);
+  if (wait === void 0) return;
+  await lane_ledger.record_stage({
+    stage: lane_ledger.CI_WAIT_STAGE,
+    elapsed_ms: wait.duration_ms
+  });
+}
 var git_followup_stages = {
   STAGE,
   STAGE_LINE_PREFIX,
@@ -2589,14 +2921,15 @@ var git_followup_stages = {
   total_ms,
   format_stages,
   print_stages,
+  record_ci_wait,
   stopped_lap
 };
 
 // scripts/time-runtime/time-followup-stage.ts
-var LINE_SEPARATOR = "\n";
+var LINE_SEPARATOR2 = "\n";
 var SECONDS_SUFFIX = " s";
 var DIGIT_OR_POINT = /[\d.]/u;
-var MS_PER_SECOND2 = 1e3;
+var MS_PER_SECOND3 = 1e3;
 var NO_STAGES = [];
 function stage_body(line) {
   const trimmed = line.trimStart();
@@ -2619,11 +2952,11 @@ function to_stage(body) {
   const name = head.slice(0, start).trim();
   const digits = head.slice(start);
   if (name === "" || !is_duration(digits)) return void 0;
-  return { name, duration_ms: Number(digits) * MS_PER_SECOND2 };
+  return { name, duration_ms: Number(digits) * MS_PER_SECOND3 };
 }
 function read_stages(text) {
   if (!text.includes(git_followup_stages.STAGE_LINE_PREFIX)) return NO_STAGES;
-  return text.split(LINE_SEPARATOR).map((line) => stage_body(line)).filter((body) => body !== void 0).map((body) => to_stage(body)).filter((stage) => stage !== void 0);
+  return text.split(LINE_SEPARATOR2).map((line) => stage_body(line)).filter((body) => body !== void 0).map((body) => to_stage(body)).filter((stage) => stage !== void 0);
 }
 var time_followup_stage = { NO_STAGES, read_stages };
 
@@ -2631,7 +2964,7 @@ var time_followup_stage = { NO_STAGES, read_stages };
 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())]);
-var LINE_SEPARATOR2 = "\n";
+var LINE_SEPARATOR3 = "\n";
 function block_text(block) {
   const parsed = TEXT_BLOCK_SCHEMA.safeParse(block);
   return parsed.success ? parsed.data.text ?? "" : "";
@@ -2640,7 +2973,7 @@ function result_text2(content) {
   const parsed = CONTENT_SCHEMA.safeParse(content);
   if (!parsed.success) return "";
   if (typeof parsed.data === "string") return parsed.data;
-  return parsed.data.map((block) => block_text(block)).join(LINE_SEPARATOR2);
+  return parsed.data.map((block) => block_text(block)).join(LINE_SEPARATOR3);
 }
 function is_failure_line(line) {
   return line.trimStart().startsWith(status_icons.FAIL_ICON);
@@ -2692,7 +3025,7 @@ function did_scan_find(scan) {
   return scan.did_find || scan.has_failure_before_region || scan.has_failure_in_region;
 }
 function has_failure_line(content) {
-  const lines = result_text2(content).split(LINE_SEPARATOR2);
+  const lines = result_text2(content).split(LINE_SEPARATOR3);
   if (lines.some((line) => is_failed_verdict(line))) return true;
   return did_scan_find(scan_body(lines));
 }
@@ -2913,8 +3246,8 @@ function field_targets(input) {
 }
 function tool_targets(input) {
   const scalar_targets = TARGET_FIELDS.map((field) => field_text(input, field));
-  const targets = [...scalar_targets, ...field_targets(input)].map((target) => normalize(target));
-  return [...new Set(targets)].filter((target) => target !== "");
+  const targets = [...scalar_targets, ...field_targets(input)].map((target2) => normalize(target2));
+  return [...new Set(targets)].filter((target2) => target2 !== "");
 }
 function prompt_references_prior(input) {
   const prompt = field_text(input, "prompt").toLowerCase();
@@ -2959,27 +3292,27 @@ var time_bundle_call = {
   bash_facts,
   call_facts,
   tool_facts,
-  // Exported for `time-agent-bundles.ts` (joshuafolkken/kit#1854), which asks the launch question of a
+  // Exported for `time-agent-bundles.ts`, which asks the launch question of a
   // span's `label` — the tool name for a non-Bash call — so the set lives in one place.
   is_launch_tool,
-  // Exported for `time-writes.ts` (joshuafolkken/kit#1472), which asks what a call *wrote* rather
+  // Exported for `time-writes.ts`, which asks what a call *wrote* rather
   // than what it named. The extraction is the same one either way — a second copy of it would let a
   // path be recognized as a target when read and missed when written.
   targets_in,
   tool_targets,
-  // Exported for the batching guard's own word scan (joshuafolkken/kit#1390), so the two scanners
+  // Exported for the batching guard's own word scan, so the two scanners
   // cannot come to disagree about where one word of a shell line ends and the next begins.
-  // Exported for the read-fold notice (joshuafolkken/kit#2311), which offers `read:files <path>` only
+  // Exported for the read-fold notice, which offers `read:files <path>` only
   // over file-shaped targets — a bare directory like `scripts/` is a target here but not something
   // `read:files` can read, so the notice reuses this test rather than keep a second copy that could
   // drift from what counts as a file path.
   has_extension,
-  // Exported for `time-writes.ts` (joshuafolkken/kit#1509), which needs the same two answers to say
+  // Exported for `time-writes.ts`, which needs the same two answers to say
   // *which* files an in-place `sed` wrote. Two copies of this test disagreed in both directions at
   // once — one called a piped `grep -i` a write, the other missed a bundled `sed -ni`.
   write_segment,
   is_in_place_sed,
-  // Exported for the drift test in `time-bundle-call.test.ts` (joshuafolkken/kit#1875), which pins that
+  // Exported for the drift test in `time-bundle-call.test.ts`, which pins that
   // every name here is a real `josh` command and none of them writes.
   READ_JOSH_SUBCOMMANDS
 };
@@ -2991,9 +3324,9 @@ function issue_from_branch(branch) {
   const matched = ISSUE_BRANCH_PATTERN.exec(branch);
   return matched?.[1] === void 0 ? UNATTRIBUTED_KEY : Number(matched[1]);
 }
-function declared_issue(record) {
-  const declared = record.issue ?? UNATTRIBUTED_KEY;
-  return declared === UNATTRIBUTED_KEY ? issue_from_branch(record.branch) : declared;
+function declared_issue(record2) {
+  const declared = record2.issue ?? UNATTRIBUTED_KEY;
+  return declared === UNATTRIBUTED_KEY ? issue_from_branch(record2.branch) : declared;
 }
 function fill(declared, is_reverse) {
   const filled = Array.from({ length: declared.length }, () => UNATTRIBUTED_KEY);
@@ -3017,12 +3350,12 @@ function pick(own, carried, next, previous) {
 }
 function announcements(records) {
   return fill(
-    records.map((record) => record.issue ?? UNATTRIBUTED_KEY),
+    records.map((record2) => record2.issue ?? UNATTRIBUTED_KEY),
     false
   );
 }
 function attribute(records) {
-  const declared = records.map((record) => declared_issue(record));
+  const declared = records.map((record2) => declared_issue(record2));
   const carried = announcements(records);
   const next = fill(declared, true);
   const previous = fill(declared, false);
@@ -3033,9 +3366,9 @@ function attribute(records) {
 function group_by_issue(records) {
   const issues = attribute(records);
   const grouped = /* @__PURE__ */ new Map();
-  for (const [index, record] of records.entries()) {
+  for (const [index, record2] of records.entries()) {
     const bucket = grouped.get(issues[index] ?? UNATTRIBUTED_KEY) ?? [];
-    bucket.push(record);
+    bucket.push(record2);
     grouped.set(issues[index] ?? UNATTRIBUTED_KEY, bucket);
   }
   return [...grouped].toSorted(([left], [right]) => left - right).map(([issue, bucket]) => ({ issue, records: bucket }));
@@ -3164,28 +3497,18 @@ var time_single_check = { NO_CHECK, check_key };
 
 // scripts/time-runtime/time-transcript-line.ts
 import { z as z6 } from "zod";
-
-// scripts/time-runtime/time-instant.ts
-function parse_instant(raw) {
-  if (raw === null || raw === void 0) return void 0;
-  const parsed = Date.parse(raw);
-  return Number.isNaN(parsed) ? void 0 : parsed;
-}
-var time_instant = { parse_instant };
-
-// scripts/time-runtime/time-transcript-line.ts
 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(),
-  // Whether the harness wrote this result back as a failure (joshuafolkken/kit#1309). Present on a
+  // 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(),
-  // What the call printed. Read only to recover the outcome a pipeline threw away
-  // (joshuafolkken/kit#1361): it is kept as flattened text rather than as blocks, because that is
+  // 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()
 });
@@ -3196,10 +3519,10 @@ var LINE_SCHEMA = z6.object({
   timestamp: z6.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 (joshuafolkken/kit#1268).
+  // and `josh cost --issue` answer from the same field.
   gitBranch: z6.string().nullish(),
-  // The two fields outside `message` that the harness writes an end-of-task notice on
-  // (joshuafolkken/kit#1696). **Both are read as `unknown` rather than as strings**: a schema
+  // 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.
@@ -3213,6 +3536,7 @@ var NO_MESSAGE_ID = "";
 var ERROR_TEXT_LIMIT = 256;
 var REFUSAL_MARKER = "\u26D4";
 var HOOK_ERROR_LABEL = /^PreToolUse:\S+ hook error: /u;
+var STOP_FEEDBACK_LABEL = /^Stop hook feedback:\s*/u;
 var TOKEN_LINE = /^[a-z][a-z-]*$/u;
 var TOKEN_LINE_LIMIT = 8;
 function block_names(raw) {
@@ -3230,6 +3554,11 @@ function guard_from_refusal(text) {
   const colon = headline.indexOf(":");
   return (colon === -1 ? headline : headline.slice(0, colon)).trim();
 }
+function stop_guard_of(data) {
+  const content = data.message?.content;
+  if (typeof content !== "string" || !STOP_FEEDBACK_LABEL.test(content)) return "";
+  return guard_from_refusal(content.replace(STOP_FEEDBACK_LABEL, ""));
+}
 function token_lines_of(text) {
   return text.split("\n").map((line) => line.trim()).filter((line) => TOKEN_LINE.test(line)).slice(0, TOKEN_LINE_LIMIT);
 }
@@ -3268,19 +3597,24 @@ function to_line(data) {
     timestamp_ms,
     branch: data.gitBranch ?? UNKNOWN_BRANCH,
     finished_background: time_background.finished_id(notice_text(data)),
+    stop_guard: stop_guard_of(data),
     ...message_fields(data.message)
   };
 }
-function parse_line2(line) {
+function parse_line3(line) {
   const parsed = LINE_SCHEMA.safeParse(json_value.parse_or_undefined(line));
   return parsed.success ? to_line(parsed.data) : void 0;
 }
+function parse_text(text) {
+  return text.split("\n").flatMap((line) => parse_line3(line) ?? []);
+}
 var time_transcript_line = {
   ERROR_TEXT_LIMIT,
   NO_MESSAGE_ID,
   TOKEN_LINE_LIMIT,
   guard_from_refusal,
-  parse_line: parse_line2
+  parse_line: parse_line3,
+  parse_text
 };
 
 // scripts/time-runtime/time-writes.ts
@@ -3369,7 +3703,7 @@ var time_tool_call = {
 };
 
 // scripts/time-runtime/time-spans.ts
-var { NO_MESSAGE_ID: NO_MESSAGE_ID3, parse_line: parse_line3 } = time_transcript_line;
+var { NO_MESSAGE_ID: NO_MESSAGE_ID3, parse_line: parse_line4 } = time_transcript_line;
 var { NO_CALL: NO_CALL2, UNKNOWN_CALL: UNKNOWN_CALL2, UNKNOWN_TOOL: UNKNOWN_TOOL2, to_tool_call: to_tool_call2 } = time_tool_call;
 var ASSISTANT_TYPE = "assistant";
 var USER_TYPE = "user";
@@ -3489,12 +3823,12 @@ function to_spans(events, finished) {
   }));
 }
 function parse_timeline(text) {
-  const lines = text.split("\n").map((line) => parse_line3(line)).filter((line) => line !== void 0);
+  const lines = text.split("\n").map((line) => parse_line4(line)).filter((line) => line !== void 0);
   const events = to_events(lines, collect_calls(lines));
   return {
     started_ms: events[0]?.timestamp_ms ?? 0,
     ended_ms: events.at(-1)?.timestamp_ms ?? 0,
-    // **The positioning happens here rather than in a caller** (joshuafolkken/kit#1662): a launch and
+    // **The positioning happens here rather than in a caller**: a launch and
     // the call that reads its output are in one transcript, and by the time spans have been merged
     // across sessions and trimmed they are fragments rather than calls.
     spans: time_background.positioned(to_spans(events, time_background.finished_at(lines)))
@@ -3517,12 +3851,12 @@ var time_spans = {
   equal_durations,
   no_background,
   // Re-exported so the suites that measure how a command is read keep asking one namespace, and so
-  // `time-shell.ts` moving out of this file changed no call site (joshuafolkken/kit#1344).
+  // `time-shell.ts` moving out of this file changed no call site.
   bash_label: time_shell.bash_label,
   josh_command_of: time_shell.josh_command_of,
   josh_commands_of: time_shell.josh_commands_of,
   to_tool_call: to_tool_call2,
-  parse_line: parse_line3,
+  parse_line: parse_line4,
   parse_timeline
 };
 
@@ -3615,23 +3949,21 @@ var time_round_trips = {
   CALLS_PER_ROUND_TRIP_FLOOR,
   count_calls,
   count_round_trips,
-  // Exported since joshuafolkken/kit#1406, so a turn is defined in the one module that already
-  // defines a round trip rather than as a span filter in the report next door.
+  // Exported so a turn is defined in the one module that already defines a round trip rather than
+  // as a span filter in the report next door.
   count_turns,
   format_density,
-  // Exported since joshuafolkken/kit#1385, so the per-tool counts are read off the very groups this
-  // module counts rather than off a second grouping beside them.
+  // Exported so the per-tool counts are read off the very groups this module counts rather than off
+  // a second grouping beside them.
   group_round_trips,
-  // Exported since joshuafolkken/kit#1309, so the failure aggregation orders a run's spans through
+  // Exported so the failure aggregation orders a run's spans through
   // the one function that already knows why they need it — a second `toSorted` beside it would be
   // the clone `CLAUDE.md` prohibits, and the seam it guards (a delegated unit's spans appended
   // after the parent's) is not one a second copy would keep remembering.
   in_time_order,
   is_below_floor,
-  // The four below are exported since joshuafolkken/kit#1406, when the model-gap walk moved to
-  // `time-model-gaps.ts` and needed the same predicates and the same opener test this walk uses. A
-  // private copy there would be the clone `CLAUDE.md` prohibits, in the one place a drift would have
-  // the distribution and the count disagreeing about what a round trip is.
+  // Exported so callers price a round trip with the same divisor and guard rather than a private
+  // copy — the clone `CLAUDE.md` prohibits.
   per_round_trip
 };
 
@@ -3771,9 +4103,9 @@ function tally_for(tallies, label) {
   return created;
 }
 function count_trip(tallies, counted, label) {
-  const tally2 = tally_for(tallies, label);
-  tally2.recoverable_round_trips += ONE_CALL;
-  if (!counted.has(label)) tally2.sequence_count += ONE_CALL;
+  const tally = tally_for(tallies, label);
+  tally.recoverable_round_trips += ONE_CALL;
+  if (!counted.has(label)) tally.sequence_count += ONE_CALL;
   counted.add(label);
 }
 function tally_sequence(tallies, sequence) {
@@ -3791,7 +4123,7 @@ function by_weight(left, right) {
 function tool_rows(closed) {
   const tallies = /* @__PURE__ */ new Map();
   for (const sequence of closed) tally_sequence(tallies, sequence);
-  return [...tallies].map(([label, tally2]) => ({ label, ...tally2 })).toSorted(by_weight);
+  return [...tallies].map(([label, tally]) => ({ label, ...tally })).toSorted(by_weight);
 }
 function attributed_of(rows) {
   return rows.reduce((sum, row) => sum + row.recoverable_round_trips, NONE3);
@@ -3925,9 +4257,11 @@ var NONE4 = 0;
 var NOTICE_REFIRE_EVERY = ONE_TURN;
 var NAMED_CANDIDATE_COUNT = 3;
 var SEQUENCE_BEFORE_LIMIT = CONSECUTIVE_LIMIT - ONE_TURN;
-var REASON = `\u26D4 batching: the last ${String(SEQUENCE_BEFORE_LIMIT)} turns each issued a single tool call, so this one would make ${String(CONSECUTIVE_LIMIT)} in a row. Reissue it in one turn together with the calls meant to follow it that do not need its result. **The criterion is whether this call's input needs another call's result, not what kind of call it is** \u2014 edits are covered exactly as reads are, and it never authorizes weakening a verification gate or a review: fewer turns, never less work. The rule, and where its measured cost and rejected mechanisms are, is in \`prompts/collaboration-workflow/turn-batching.md\`. If this turn was already batching, or the call genuinely has nothing to go beside it, reissue it as it was: this fires once per run of single-call turns and cannot repeat on the call in hand.`;
-var NOTICE = `\u{1F4A1} batching: the last ${String(SEQUENCE_BEFORE_LIMIT)} turns each issued a single tool call, so this Write makes ${String(CONSECUTIVE_LIMIT)} in a row. This is a notice, not a refusal \u2014 the write proceeds. Where the writes meant to follow it do not need its result, issue them in one turn together. **The criterion is whether a call's input needs another call's result, not what kind of call it is** \u2014 it never authorizes weakening a verification gate or a review: fewer turns, never less work. The rule, and where its measured cost and rejected mechanisms are, is in \`prompts/collaboration-workflow/turn-batching.md\`. If this run was already batching, or the write genuinely has nothing to go beside it, carry on: this recurs every ${String(NOTICE_REFIRE_EVERY)} further single-call turn(s).`;
-var LANE_NOTICE = `\u{1F4A1} batching: the last ${String(SEQUENCE_BEFORE_LIMIT)} turns each issued a single tool call, so this one makes ${String(CONSECUTIVE_LIMIT)} in a row. This is a notice, not a refusal \u2014 the call proceeds, because a dispatched lane child ends its turn on a denial. Where the calls meant to follow it do not need its result, issue them in one turn together. **The criterion is whether a call's input needs another call's result, not what kind of call it is** \u2014 it never authorizes weakening a verification gate or a review: fewer turns, never less work. The rule, and where its measured cost and rejected mechanisms are, is in \`prompts/collaboration-workflow/turn-batching.md\`. If this run was already batching, or the call genuinely has nothing to go beside it, carry on: this recurs every ${String(NOTICE_REFIRE_EVERY)} further single-call turn(s).`;
+var RULE_POINTER = "`prompts/collaboration-workflow/turn-batching.md`";
+var STREAK = `${String(CONSECUTIVE_LIMIT)} single-call turns in a row`;
+var REASON = `\u26D4 batching: ${STREAK}. Reissue this with the calls that do not need its result \u2014 the test is whether a call's input needs another call's result, not what kind of call it is (edits are covered exactly as reads), and it never authorizes weakening a verification gate or a review. Already batching, or nothing to pair? Reissue it unchanged; this fires once per streak. ${RULE_POINTER}`;
+var NOTICE = `\u{1F4A1} batching: ${STREAK}; the Write proceeds. Issue the writes that do not need its result in one turn, never by weakening a gate or a review. ${RULE_POINTER}`;
+var LANE_NOTICE = `\u{1F4A1} batching: ${STREAK}; the call proceeds. Pair independent calls. ${RULE_POINTER}`;
 var WHOLE_FILE_WRITE_TOOL = "Write";
 var EDIT_TOOL = "Edit";
 function is_guarded_call(call) {
@@ -3984,13 +4318,13 @@ function should_notify(text, call, notified_at_ms) {
   return is_at_limit(spans, call, notified_at_ms, NOTICE_REFIRE_EVERY);
 }
 function describe_span(span) {
-  const target = span.targets[0] ?? "";
-  if (target === "" || span.label.includes(target)) return span.label;
-  return `${span.label} ${target}`;
+  const target2 = span.targets[0] ?? "";
+  if (target2 === "" || span.label.includes(target2)) return span.label;
+  return `${span.label} ${target2}`;
 }
 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((path7) => path7 !== "" && time_bundle_call.has_extension(path7));
+  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));
   return [...new Set(paths)];
 }
 function read_fold_directive(sequence) {
@@ -3999,7 +4333,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((path7) => path7 !== "" && time_bundle_call.has_extension(path7));
+  const paths = sequence.filter((span) => span.label === EDIT_TOOL).map((span) => span.targets[0] ?? "").filter((path4) => path4 !== "" && time_bundle_call.has_extension(path4));
   return [...new Set(paths)];
 }
 function write_fold_directive(sequence) {
@@ -4051,449 +4385,22 @@ var time_batch_guard = {
 };
 
 // scripts/time-runtime/time-hook-transcript.ts
-import path6 from "node:path";
-
-// scripts/cost-runtime/cost-transcript.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync3, statSync } from "node:fs";
-import { homedir } from "node:os";
-import path5 from "node:path";
-
-// scripts/lane/lane-paths.ts
-import path4 from "node:path";
-var LANE_ROOT_KEY = "JOSH_LANE_ROOT";
-var LANE_DIRECTORY_SUFFIX = "-lanes";
-var LANE_BRANCH_SUFFIX = "-lane";
-function default_lane_root(repository_root) {
-  const name = path4.basename(repository_root);
-  return path4.join(path4.dirname(repository_root), `.${name}${LANE_DIRECTORY_SUFFIX}`);
-}
-function lane_root(repository_root, environment = process.env) {
-  const configured = environment[LANE_ROOT_KEY]?.trim() ?? "";
-  return configured.length === 0 ? default_lane_root(repository_root) : path4.resolve(configured);
-}
-function lane_directory(root, issue) {
-  return path4.join(root, issue);
-}
-var LANE_ISSUE_PATTERN = /^\d+$/u;
-var DEFAULT_LANE_ROOT_PATTERN = new RegExp(String.raw`^\..+${LANE_DIRECTORY_SUFFIX}$`, "u");
-function is_lane_root(directory, environment) {
-  const configured = environment[LANE_ROOT_KEY]?.trim() ?? "";
-  if (configured.length > 0) return path4.resolve(configured) === directory;
-  return DEFAULT_LANE_ROOT_PATTERN.test(path4.basename(directory));
-}
-function lane_issue_of(directory, environment = process.env) {
-  const resolved = path4.resolve(directory);
-  const issue = path4.basename(resolved);
-  if (!LANE_ISSUE_PATTERN.test(issue)) return void 0;
-  return is_lane_root(path4.dirname(resolved), environment) ? issue : void 0;
-}
-function lane_branch(issue) {
-  return `${issue}${LANE_BRANCH_SUFFIX}`;
-}
-var lane_paths = {
-  LANE_BRANCH_SUFFIX,
-  LANE_ROOT_KEY,
-  default_lane_root,
-  lane_branch,
-  lane_directory,
-  lane_issue_of,
-  lane_root
-};
-
-// scripts/lib/read-file.ts
-import { readFileSync as readFileSync2 } from "node:fs";
-var ABSENT_CODE = "ENOENT";
-function is_absent(error) {
-  return error instanceof Error && "code" in error && error.code === ABSENT_CODE;
-}
-function read_optional(path7) {
-  try {
-    return readFileSync2(path7, "utf8");
-  } catch (error) {
-    if (is_absent(error)) return void 0;
-    throw error;
-  }
-}
-function read_file_or_empty(path7) {
-  return read_optional(path7) ?? "";
-}
-function read_if_readable(path7) {
-  try {
-    return readFileSync2(path7, "utf8");
-  } catch {
-    return void 0;
-  }
-}
-var file_reader = { read_optional, read_file_or_empty, read_if_readable };
-
-// scripts/cost-runtime/cost-usage.ts
-import { z as z7 } from "zod";
-var CACHE_CREATION_SCHEMA = z7.object({
-  ephemeral_1h_input_tokens: z7.number().nullish(),
-  ephemeral_5m_input_tokens: z7.number().nullish()
-});
-var USAGE_SCHEMA = z7.object({
-  input_tokens: z7.number(),
-  cache_creation_input_tokens: z7.number().nullish(),
-  cache_read_input_tokens: z7.number().nullish(),
-  output_tokens: z7.number(),
-  output_tokens_details: z7.object({ thinking_tokens: z7.number().nullish() }).nullish(),
-  cache_creation: CACHE_CREATION_SCHEMA.nullish()
-});
-var MESSAGE_SCHEMA3 = z7.object({
-  id: z7.string().nullish(),
-  model: z7.string().nullish(),
-  usage: USAGE_SCHEMA.nullish()
-});
-var LINE_SCHEMA2 = z7.object({
-  type: z7.string(),
-  requestId: z7.string().nullish(),
-  uuid: z7.string().nullish(),
-  gitBranch: z7.string().nullish(),
-  timestamp: z7.string().nullish(),
-  message: MESSAGE_SCHEMA3.nullish()
-});
-var SYNTHETIC_MODEL = "<synthetic>";
-var EMPTY_TOTALS = {
-  input_tokens: 0,
-  cache_write_5m_tokens: 0,
-  cache_write_1h_tokens: 0,
-  cache_read_tokens: 0,
-  output_tokens: 0,
-  thinking_tokens: 0,
-  thinking_measured: false
-};
-var UNKNOWN_MODEL = "unknown";
-var UNKNOWN_BRANCH2 = "";
-function split_cache_write(usage) {
-  const total = usage.cache_creation_input_tokens ?? 0;
-  const detail = usage.cache_creation;
-  if (!detail) return { write_5m: total, write_1h: 0 };
-  const write_1h = detail.ephemeral_1h_input_tokens ?? 0;
-  return { write_5m: detail.ephemeral_5m_input_tokens ?? total - write_1h, write_1h };
-}
-function thinking_usage(usage) {
-  const raw = usage.output_tokens_details?.thinking_tokens;
-  return { tokens: raw ?? 0, measured: raw !== null && raw !== void 0 };
-}
-function to_totals(usage) {
-  const { write_5m, write_1h } = split_cache_write(usage);
-  const thinking = thinking_usage(usage);
-  return {
-    input_tokens: usage.input_tokens,
-    cache_write_5m_tokens: write_5m,
-    cache_write_1h_tokens: write_1h,
-    cache_read_tokens: usage.cache_read_input_tokens ?? 0,
-    output_tokens: usage.output_tokens,
-    thinking_tokens: thinking.tokens,
-    thinking_measured: thinking.measured
-  };
-}
-function declared_id(data) {
-  return data.requestId ?? data.message?.id ?? data.uuid ?? void 0;
-}
-function request_id_of(data, usage) {
-  const fallback = `${data.timestamp ?? ""}-${String(usage.output_tokens)}`;
-  return declared_id(data) ?? fallback;
-}
-function to_record(data, usage) {
-  return {
-    request_id: request_id_of(data, usage),
-    model: data.message?.model ?? UNKNOWN_MODEL,
-    branch: data.gitBranch ?? UNKNOWN_BRANCH2,
-    at_ms: time_instant.parse_instant(data.timestamp),
-    totals: to_totals(usage)
-  };
-}
-var ASSISTANT_TYPE2 = "assistant";
-function is_priced_line(data) {
-  return data.type === ASSISTANT_TYPE2 && data.message?.model !== SYNTHETIC_MODEL;
-}
-function classify(data) {
-  if (!is_priced_line(data)) return { kind: "skipped" };
-  const usage = data.message?.usage;
-  return usage ? { kind: "record", record: to_record(data, usage) } : { kind: "no_usage" };
-}
-function parse_line4(line) {
-  if (line.trim() === "") return { kind: "skipped" };
-  const parsed = LINE_SCHEMA2.safeParse(json_value.parse_or_undefined(line));
-  return parsed.success ? classify(parsed.data) : { kind: "malformed" };
-}
-function later_instant(left, right) {
-  if (left === void 0) return right;
-  if (right === void 0) return left;
-  return Math.max(left, right);
-}
-function dedupe(records) {
-  const by_id = /* @__PURE__ */ new Map();
-  for (const record of records) {
-    const seen = by_id.get(record.request_id);
-    const at_ms = later_instant(seen?.at_ms, record.at_ms);
-    by_id.set(record.request_id, { ...seen ?? record, at_ms });
-  }
-  return [...by_id.values()];
-}
-function add_totals(left, right) {
-  return {
-    input_tokens: left.input_tokens + right.input_tokens,
-    cache_write_5m_tokens: left.cache_write_5m_tokens + right.cache_write_5m_tokens,
-    cache_write_1h_tokens: left.cache_write_1h_tokens + right.cache_write_1h_tokens,
-    cache_read_tokens: left.cache_read_tokens + right.cache_read_tokens,
-    output_tokens: left.output_tokens + right.output_tokens,
-    thinking_tokens: left.thinking_tokens + right.thinking_tokens,
-    thinking_measured: left.thinking_measured || right.thinking_measured
-  };
-}
-function sum_totals(records) {
-  let total = EMPTY_TOTALS;
-  for (const record of records) total = add_totals(total, record.totals);
-  return total;
-}
-function billed_input(totals) {
-  return totals.input_tokens + totals.cache_write_5m_tokens + totals.cache_write_1h_tokens + totals.cache_read_tokens;
-}
-var cost_usage = {
-  EMPTY_TOTALS,
-  UNKNOWN_MODEL,
-  SYNTHETIC_MODEL,
-  parse_line: parse_line4,
-  dedupe,
-  add_totals,
-  sum_totals,
-  billed_input
-};
-
-// scripts/cost-runtime/cost-transcript.ts
-var TRANSCRIPT_ROOT = path5.join(".claude", "projects");
-var TRANSCRIPT_EXTENSION = ".jsonl";
-var SLUG_PATTERN = /[^a-zA-Z0-9-]/gu;
-var UNIT_DIRECTORY = "subagents";
-var UNIT_ID_SEPARATOR = "/";
-function project_slug(cwd) {
-  return cwd.replaceAll(SLUG_PATTERN, "-");
-}
-function transcript_directory(cwd, home = homedir()) {
-  return path5.join(home, TRANSCRIPT_ROOT, project_slug(cwd));
-}
-var GIT_ENTRY = ".git";
-var GITDIR_PREFIX = "gitdir:";
-var WORKTREE_SEGMENT = `/${GIT_ENTRY}/worktrees/`;
-var NOT_FOUND = -1;
-function linked_worktree_gitdir(cwd) {
-  try {
-    const contents = readFileSync3(path5.join(cwd, GIT_ENTRY), "utf8").trim();
-    return contents.startsWith(GITDIR_PREFIX) ? contents.slice(GITDIR_PREFIX.length).trim() : "";
-  } catch {
-    return "";
-  }
-}
-function session_cwd(cwd) {
-  const gitdir = linked_worktree_gitdir(cwd);
-  const absolute = gitdir === "" ? "" : path5.resolve(cwd, gitdir);
-  const segment = absolute.indexOf(WORKTREE_SEGMENT);
-  return segment === NOT_FOUND ? cwd : absolute.slice(0, segment);
-}
-function read_directory(directory) {
-  try {
-    return readdirSync3(directory);
-  } catch {
-    return [];
-  }
-}
-var LANE_ISSUE_SLUG = /^\d+$/u;
-function lane_transcript_directories(main_cwd, home) {
-  const projects = path5.join(home, TRANSCRIPT_ROOT);
-  const prefix = `${project_slug(lane_paths.lane_root(main_cwd))}-`;
-  return read_directory(projects).filter((name) => name.startsWith(prefix) && LANE_ISSUE_SLUG.test(name.slice(prefix.length))).map((name) => path5.join(projects, name));
-}
-function transcript_directories(cwd, home = homedir()) {
-  const own = transcript_directory(cwd, home);
-  const lanes = session_cwd(cwd) === cwd ? lane_transcript_directories(cwd, home) : [];
-  return [.../* @__PURE__ */ new Set([own, ...lanes])];
-}
-var OWN_DEPTH = 0;
-function home_directory() {
-  return homedir();
-}
-function to_session_file(full_path, session_id, depth) {
-  try {
-    return {
-      session_id,
-      path: full_path,
-      modified_ms: statSync(full_path).mtimeMs,
-      is_delegated: depth > OWN_DEPTH,
-      depth
-    };
-  } catch {
-    return void 0;
-  }
-}
-function is_transcript(name) {
-  return name.endsWith(TRANSCRIPT_EXTENSION);
-}
-function without_extension(name) {
-  return name.slice(0, -TRANSCRIPT_EXTENSION.length);
-}
-function own_files(directory, names) {
-  return names.filter((name) => is_transcript(name)).map((name) => to_session_file(path5.join(directory, name), without_extension(name), OWN_DEPTH)).filter((file) => file !== void 0);
-}
-function unit_directory(directory, session_id) {
-  return path5.join(directory, session_id, UNIT_DIRECTORY);
-}
-var UNIT_DEPTH = 1;
-function level_units(subagents_directory, prefix, depth) {
-  return read_directory(subagents_directory).filter((name) => is_transcript(name)).map(
-    (name) => to_session_file(
-      path5.join(subagents_directory, name),
-      `${prefix}${UNIT_ID_SEPARATOR}${without_extension(name)}`,
-      depth
-    )
-  ).filter((file) => file !== void 0);
-}
-function collect_units(subagents_directory, prefix, depth) {
-  const nested = read_directory(subagents_directory).filter((name) => !is_transcript(name)).flatMap(
-    (name) => collect_units(
-      unit_directory(subagents_directory, name),
-      `${prefix}${UNIT_ID_SEPARATOR}${name}`,
-      depth + 1
-    )
-  );
-  return [...level_units(subagents_directory, prefix, depth), ...nested];
-}
-function unit_files(directory, session_name) {
-  return collect_units(unit_directory(directory, session_name), session_name, UNIT_DEPTH);
-}
-function list_sessions(directory) {
-  const names = read_directory(directory);
-  const units = names.filter((name) => !is_transcript(name)).flatMap((name) => unit_files(directory, name));
-  return [...own_files(directory, names), ...units].toSorted(
-    (left, right) => right.modified_ms - left.modified_ms
-  );
-}
-function list_sessions_across(directories) {
-  const seen = /* @__PURE__ */ new Set();
-  const merged = directories.flatMap((directory) => list_sessions(directory));
-  const newest_first = merged.toSorted((left, right) => right.modified_ms - left.modified_ms);
-  const kept = [];
-  for (const file of newest_first) {
-    if (seen.has(file.session_id)) continue;
-    seen.add(file.session_id);
-    kept.push(file);
-  }
-  return kept;
-}
-function owning_session_id(file) {
-  const [owner] = file.session_id.split(UNIT_ID_SEPARATOR);
-  return owner ?? file.session_id;
-}
-function parent_session_id(file) {
-  const separator = file.session_id.lastIndexOf(UNIT_ID_SEPARATOR);
-  return separator === NOT_FOUND ? file.session_id : file.session_id.slice(0, separator);
-}
-function latest_own_index(files) {
-  const index = files.findIndex((file) => !file.is_delegated);
-  return index === -1 ? 0 : index;
-}
-function empty_session() {
-  return {
-    records: [],
-    no_usage_lines: 0,
-    malformed_lines: 0,
-    is_readable: false,
-    baseline_tokens: 0
-  };
-}
-function tally(content) {
-  const outcomes = content.split("\n").map((line) => cost_usage.parse_line(line));
-  const records = outcomes.flatMap(
-    (outcome) => outcome.kind === "record" ? [outcome.record] : []
-  );
-  const unique = cost_usage.dedupe(records);
-  const [first] = unique;
-  return {
-    records: unique,
-    no_usage_lines: outcomes.filter((outcome) => outcome.kind === "no_usage").length,
-    malformed_lines: outcomes.filter((outcome) => outcome.kind === "malformed").length,
-    is_readable: true,
-    baseline_tokens: first === void 0 ? 0 : cost_usage.billed_input(first.totals)
-  };
-}
-function read_session(file) {
-  const content = file_reader.read_if_readable(file.path);
-  if (content === void 0) return { session_id: file.session_id, ...empty_session() };
-  return { session_id: file.session_id, ...tally(content) };
-}
-function read_raw(file) {
-  return file_reader.read_if_readable(file.path) ?? "";
-}
-function read_optional2(file) {
-  return file_reader.read_if_readable(file.path);
-}
-function directory_exists(directory) {
-  try {
-    return statSync(directory).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function searched_directories(directories) {
-  return directories.map((directory) => ({
-    path: directory,
-    exists: directory_exists(directory)
-  }));
-}
-function describe_searched(directory) {
-  return `  ${directory.path} \u2014 ${directory.exists ? "no transcripts here" : "no such directory"}`;
-}
-function missing_message(searched, session_id) {
-  const lead = session_id === void 0 ? "No transcripts found. Searched:" : `No transcript named ${session_id}. Searched:`;
-  const listed = searched.map((directory) => describe_searched(directory));
-  if (session_id !== void 0) return [lead, ...listed];
-  return [
-    lead,
-    ...listed,
-    "Claude Code writes them per project; run this from the project it ran in."
-  ];
-}
-var cost_transcript = {
-  TRANSCRIPT_EXTENSION,
-  TRANSCRIPT_ROOT,
-  UNIT_DIRECTORY,
-  project_slug,
-  transcript_directory,
-  transcript_directories,
-  session_cwd,
-  unit_directory,
-  list_sessions,
-  list_sessions_across,
-  searched_directories,
-  owning_session_id,
-  parent_session_id,
-  latest_own_index,
-  tally,
-  read_session,
-  read_raw,
-  read_optional: read_optional2,
-  missing_message,
-  home_directory
-};
-
-// scripts/time-runtime/time-hook-transcript.ts
-var { TRANSCRIPT_EXTENSION: TRANSCRIPT_EXTENSION2 } = cost_transcript;
+import path3 from "node:path";
+var { TRANSCRIPT_EXTENSION } = cost_transcript;
 var AGENT_PREFIX = "agent-";
 var AGENT_ID_PATTERN = /^[\w-]+$/u;
 function is_agent_id(value) {
   return typeof value === "string" && AGENT_ID_PATTERN.test(value);
 }
 function fork_path(transcript_path, agent_id) {
-  const directory = path6.dirname(transcript_path);
-  const session_id = path6.basename(transcript_path, TRANSCRIPT_EXTENSION2);
-  const file_name = `${AGENT_PREFIX}${agent_id}${TRANSCRIPT_EXTENSION2}`;
-  return path6.join(cost_transcript.unit_directory(directory, session_id), file_name);
+  const directory = path3.dirname(transcript_path);
+  const session_id = path3.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);
 }
 function transcript_of(transcript_path, agent_id) {
   if (!is_agent_id(agent_id)) return transcript_path;
-  if (!transcript_path.endsWith(TRANSCRIPT_EXTENSION2)) return transcript_path;
+  if (!transcript_path.endsWith(TRANSCRIPT_EXTENSION)) return transcript_path;
   return fork_path(transcript_path, agent_id);
 }
 var time_hook_transcript = {
@@ -4502,8 +4409,8 @@ var time_hook_transcript = {
 };
 
 // scripts/time-runtime/time-density-hook.ts
-import { closeSync, fstatSync, openSync, readSync } from "node:fs";
-import { z as z8 } from "zod";
+import { closeSync as closeSync2, fstatSync, openSync as openSync2, readSync } from "node:fs";
+import { z as z7 } from "zod";
 
 // scripts/time-runtime/time-density.ts
 var MIN_ROUND_TRIPS = 10;
@@ -4559,15 +4466,15 @@ var TAIL_BYTES = 262144;
 var FILE_START = 0;
 var NOTICE_PREFIX = "josh-density-notice-";
 var NEVER_MS = 0;
-var payload_schema = z8.object({
-  transcript_path: z8.string().min(1).optional(),
+var payload_schema = z7.object({
+  transcript_path: z7.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: z8.string().nullish()
+  agent_id: z7.string().nullish()
 });
-var notice_schema = z8.object({ notified_at_ms: z8.number() });
-var call_schema = z8.object({ tool_name: z8.string().min(1), tool_input: z8.unknown() });
+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() });
 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;
@@ -4579,7 +4486,7 @@ function parse_call(raw_payload) {
   return { name: parsed.data.tool_name, input: parsed.data.tool_input };
 }
 function read_tail(file_path, max_bytes = TAIL_BYTES) {
-  const descriptor = openSync(file_path, "r");
+  const descriptor = openSync2(file_path, "r");
   try {
     const { size } = fstatSync(descriptor);
     const length = Math.min(size, max_bytes);
@@ -4587,7 +4494,7 @@ function read_tail(file_path, max_bytes = TAIL_BYTES) {
     const read = readSync(descriptor, buffer, FILE_START, length, size - length);
     return buffer.subarray(FILE_START, read).toString("utf8");
   } finally {
-    closeSync(descriptor);
+    closeSync2(descriptor);
   }
 }
 function notice_path(transcript_path) {
@@ -4596,15 +4503,11 @@ function notice_path(transcript_path) {
 function last_notice_ms(source) {
   const raw = stamp_file.read_stamp_text(source);
   if (raw === void 0) return NEVER_MS;
-  try {
-    return notice_schema.parse(JSON.parse(raw)).notified_at_ms;
-  } catch {
-    return NEVER_MS;
-  }
+  return json_value.parse_with(raw, notice_schema)?.notified_at_ms ?? NEVER_MS;
 }
-function arm_throttle(target, now_ms) {
+function arm_throttle(target2, now_ms) {
   try {
-    stamp_file.write_stamp(target, { notified_at_ms: now_ms });
+    stamp_file.write_stamp(target2, { notified_at_ms: now_ms });
   } catch {
   }
 }
@@ -4613,11 +4516,11 @@ function notice_for(raw_payload, now_ms) {
   if (transcript_path === void 0) return void 0;
   const tail = read_tail(transcript_path);
   const reading = time_density.read_window(tail);
-  const target = notice_path(transcript_path);
-  if (!time_density.is_due(reading, now_ms - last_notice_ms(target))) return void 0;
+  const target2 = notice_path(transcript_path);
+  if (!time_density.is_due(reading, now_ms - last_notice_ms(target2))) return void 0;
   const candidates = time_batch_guard.pairing_candidates(tail, parse_call(raw_payload));
   if (candidates === "") return void 0;
-  arm_throttle(target, now_ms);
+  arm_throttle(target2, now_ms);
   return time_density.format_notice(reading, candidates);
 }
 function density_notice(raw_payload, now_ms = Date.now()) {
@@ -4634,11 +4537,8 @@ var time_density_hook = {
 };
 
 export {
-  json_value,
   cost_blocks,
   ESLINT_EDIT_CACHE_FLAGS,
-  process_identity,
-  process_owner_schema,
   time_shell,
   time_bundle_call,
   blocking_issue_schema,
@@ -4660,10 +4560,6 @@ export {
   time_transcript_line,
   time_spans,
   time_batch_guard,
-  lane_paths,
-  file_reader,
-  cost_usage,
-  cost_transcript,
   time_hook_transcript,
   time_density_hook
 };