@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/dist/hooks/chunk-TNUMY6NL.js

@@ -1,4838 +0,0 @@
-import {
-  ENV_FILE_NAME,
-  cost_transcript,
-  json_value,
-  lane_paths,
-  pr_raw_schema,
-  process_identity,
-  process_owner_schema,
-  run_carry,
-  time_instant
-} from "./chunk-APUO6U4J.js";
-import {
-  PLATFORM_TEMP_ROOT,
-  PROBE_TIMEOUT_MS,
-  stamp_file
-} from "./chunk-DGT54IH5.js";
-
-// scripts/cost-runtime/cost-blocks.ts
-import { z } from "zod";
-var CONTENT_ITEM_SCHEMA = z.object({ text: z.string().nullish() });
-var RESULT_CONTENT_SCHEMA = z.union([z.string(), z.array(CONTENT_ITEM_SCHEMA)]);
-var BLOCK_SCHEMA = z.object({
-  type: z.string().nullish(),
-  text: z.string().nullish(),
-  name: z.string().nullish(),
-  input: z.unknown().nullish(),
-  content: RESULT_CONTENT_SCHEMA.nullish()
-});
-var LINE_CONTENT_SCHEMA = z.union([z.string(), z.array(BLOCK_SCHEMA)]);
-var MESSAGE_SCHEMA = z.object({ content: LINE_CONTENT_SCHEMA.nullish() });
-var CONTENT_LINE_SCHEMA = z.object({ type: z.string(), message: MESSAGE_SCHEMA.nullish() });
-var TEXT_TYPE = "text";
-var TOOL_USE_TYPE = "tool_use";
-var TOOL_RESULT_TYPE = "tool_result";
-var BASH_TOOL = "Bash";
-var COMMAND_KEY = "command";
-function json_of(value) {
-  return value === void 0 || value === null ? "" : JSON.stringify(value);
-}
-function split_bash_input(input) {
-  if (!json_value.is_record(input)) return { command: "", rest: json_of(input) };
-  const command = input[COMMAND_KEY];
-  const rest = Object.entries(input).filter(([key]) => key !== COMMAND_KEY);
-  return {
-    command: typeof command === "string" ? command : "",
-    rest: json_of(Object.fromEntries(rest))
-  };
-}
-function to_tool_use(block) {
-  const tool_name = block.name ?? "";
-  const is_bash = tool_name === BASH_TOOL;
-  const { command, rest } = is_bash ? split_bash_input(block.input) : { command: "", rest: json_of(block.input) };
-  return { type: TOOL_USE_TYPE, tool_name, command, text: rest };
-}
-function result_text(content) {
-  if (typeof content === "string") return content;
-  return content.map((item) => item.text ?? "").join("");
-}
-function to_plain_block(block) {
-  const base = { type: block.type ?? "", tool_name: "", command: "" };
-  const text = block.type === TOOL_RESULT_TYPE ? result_text(block.content ?? "") : block.text ?? "";
-  return { ...base, text };
-}
-function to_block(block) {
-  return block.type === TOOL_USE_TYPE ? to_tool_use(block) : to_plain_block(block);
-}
-function to_blocks(content) {
-  if (typeof content === "string") {
-    return [{ type: TEXT_TYPE, tool_name: "", command: "", text: content }];
-  }
-  return content.map((block) => to_block(block));
-}
-function content_of(line) {
-  const parsed = CONTENT_LINE_SCHEMA.safeParse(json_value.parse_or_undefined(line));
-  return parsed.success ? parsed.data.message?.content ?? void 0 : void 0;
-}
-function parse_line(line) {
-  const content = content_of(line);
-  return content === void 0 ? [] : to_blocks(content);
-}
-function parse_content(text) {
-  return text.split("\n").flatMap((line) => parse_line(line));
-}
-var cost_blocks = {
-  BASH_TOOL,
-  TEXT_TYPE,
-  TOOL_USE_TYPE,
-  TOOL_RESULT_TYPE,
-  parse_line,
-  parse_content
-};
-
-// scripts/time-runtime/time-phase-names.ts
-var GATE_PHASE = "gate";
-var PR_PHASE = "pr";
-var MERGE_PHASE = "merge";
-var GATE_COMMAND = "josh gate";
-var COMMAND_PHASES = /* @__PURE__ */ new Map([
-  [GATE_COMMAND, GATE_PHASE],
-  ["josh git", PR_PHASE],
-  ["josh pr", PR_PHASE],
-  ["josh followup", MERGE_PHASE]
-]);
-
-// scripts/gate/core-budget.ts
-import { randomUUID } from "node:crypto";
-import { readdirSync as readdirSync2 } from "node:fs";
-import { availableParallelism as availableParallelism3 } from "node:os";
-import path3 from "node:path";
-
-// scripts/test/unit-worker-share.ts
-import { readdirSync } from "node:fs";
-import { availableParallelism } from "node:os";
-import path from "node:path";
-var RUN_PREFIX = "josh-unit-running-";
-var WORKER_FLAG = "--maxWorkers";
-var WORKER_FLAGS = [WORKER_FLAG, "--max-workers"];
-var MIN_WORKERS = 1;
-var SOLO_RUNS = 1;
-function marker_path(pid = process.pid) {
-  return stamp_file.stamp_path(RUN_PREFIX, String(pid));
-}
-function is_running(marker) {
-  return process_identity.is_same_process(marker.pid, marker.process_start) !== false;
-}
-function read_marker(source) {
-  const raw = stamp_file.read_stamp_text(source);
-  if (raw === void 0) return void 0;
-  const parsed = process_owner_schema.safeParse(json_value.parse_or_undefined(raw));
-  return parsed.success ? parsed.data : void 0;
-}
-function marker_files(directory = PLATFORM_TEMP_ROOT) {
-  try {
-    return readdirSync(directory).filter((name) => name.startsWith(RUN_PREFIX));
-  } catch {
-    return [];
-  }
-}
-function sweep_marker(source) {
-  try {
-    stamp_file.remove_stamp(source);
-  } catch {
-  }
-}
-function is_marker_live(source) {
-  const marker = read_marker(source);
-  if (marker === void 0) return false;
-  if (is_running(marker)) return true;
-  sweep_marker(source);
-  return false;
-}
-function live_run_count(directory = PLATFORM_TEMP_ROOT) {
-  return marker_files(directory).filter((name) => is_marker_live(path.join(directory, name))).length;
-}
-var NESTED_KEY = "JOSH_UNIT_RUN_MARKED";
-var NESTED_VALUE = "1";
-function is_nested_run() {
-  return process.env[NESTED_KEY] === NESTED_VALUE;
-}
-function resolve_unit_workers(available_cores, runs2) {
-  if (runs2 <= SOLO_RUNS) return void 0;
-  return Math.max(MIN_WORKERS, Math.floor(available_cores / runs2));
-}
-function cap_to_free(workers, free_cores, available_cores) {
-  if (free_cores === void 0 || free_cores >= (workers ?? available_cores)) return workers;
-  return Math.max(MIN_WORKERS, Math.floor(free_cores));
-}
-function current_share(available_cores = availableParallelism(), live_runs = live_run_count(), free_cores) {
-  const own_run2 = is_nested_run() ? 0 : SOLO_RUNS;
-  const share = resolve_unit_workers(available_cores, live_runs + own_run2);
-  return cap_to_free(share, free_cores, available_cores);
-}
-function is_worker_flag(argument) {
-  return WORKER_FLAGS.some((flag) => argument === flag || argument.startsWith(`${flag}=`));
-}
-function has_worker_flag(vitest_arguments) {
-  return vitest_arguments.some((argument) => is_worker_flag(argument));
-}
-function worker_arguments(vitest_arguments, share) {
-  if (share === void 0 || has_worker_flag(vitest_arguments)) return [];
-  return [`${WORKER_FLAG}=${String(share)}`];
-}
-function mark_run_started(target2) {
-  try {
-    stamp_file.write_stamp(target2, process_identity.own_fields());
-  } catch {
-  }
-}
-async function with_run_marker(run) {
-  if (is_nested_run()) return await run();
-  const target2 = marker_path();
-  mark_run_started(target2);
-  process.env[NESTED_KEY] = NESTED_VALUE;
-  try {
-    return await run();
-  } finally {
-    process.env[NESTED_KEY] = "";
-    stamp_file.remove_stamp(target2);
-  }
-}
-var unit_worker_share = {
-  MIN_WORKERS,
-  NESTED_KEY,
-  NESTED_VALUE,
-  RUN_PREFIX,
-  SOLO_RUNS,
-  cap_to_free,
-  current_share,
-  has_worker_flag,
-  is_nested_run,
-  live_run_count,
-  marker_path,
-  read_marker,
-  resolve_unit_workers,
-  with_run_marker,
-  worker_arguments
-};
-
-// scripts/gate/core-budget.ts
-import { z as z2 } from "zod";
-
-// scripts/gate/core-admission.ts
-var MS_PER_SECOND = 1e3;
-var RAMP_UP_MS = 3e4;
-function compare_claim(left, right) {
-  const by_time = left.reservation.claimed_at - right.reservation.claimed_at;
-  return by_time === 0 ? left.key.localeCompare(right.key) : by_time;
-}
-function add_load(totals, reservation) {
-  totals.cores += reservation.weight;
-  totals.memory_mb += reservation.memory_mb ?? 0;
-}
-function exceeds(totals, budget) {
-  return totals.cores > budget.cores || totals.memory_mb > budget.memory_mb;
-}
-function admitted_keys(reservations, budget, memory_budget = Infinity) {
-  const limit = { cores: budget, memory_mb: memory_budget };
-  const totals = { cores: 0, memory_mb: 0 };
-  const admitted = /* @__PURE__ */ new Set();
-  for (const [index, entry] of reservations.toSorted(compare_claim).entries()) {
-    add_load(totals, entry.reservation);
-    if (index !== 0 && exceeds(totals, limit)) break;
-    admitted.add(entry.key);
-  }
-  return admitted;
-}
-function is_admitted(key, reservations, budget) {
-  return admitted_keys(reservations, budget.cores, budget.memory_mb).has(key);
-}
-function sum_load(reservations) {
-  const load = { cores: 0, memory_mb: 0 };
-  for (const entry of reservations) add_load(load, entry.reservation);
-  return load;
-}
-function is_ramped(reservation, now) {
-  const { admitted_at } = reservation;
-  return admitted_at !== void 0 && now - admitted_at >= RAMP_UP_MS;
-}
-function ledger_load(reservations, now) {
-  const admitted = reservations.filter((entry) => entry.reservation.admitted_at !== void 0);
-  const ramped = admitted.filter((entry) => is_ramped(entry.reservation, now));
-  return { cores: sum_load(admitted).cores, memory_mb: sum_load(ramped).memory_mb };
-}
-function total_weight(reservations) {
-  return sum_load(reservations).cores;
-}
-function admitted_load(reservations, budget) {
-  const admitted = admitted_keys(reservations, budget);
-  return total_weight(reservations.filter((entry) => admitted.has(entry.key)));
-}
-function describe_memory(ledger, budget) {
-  if (!Number.isFinite(budget.memory_mb)) return "";
-  return ` and ${String(Math.round(ledger.memory_mb))} MB of memory against ${String(Math.round(budget.memory_mb))} MB`;
-}
-function describe_overflow(admission) {
-  const { overflow } = admission;
-  if (overflow === void 0) return void 0;
-  const { ledger, budget } = overflow;
-  const waited = String(Math.round(overflow.waited_ms / MS_PER_SECOND));
-  const cores = `the ledger held ${String(ledger.cores)} cores against a budget of ${String(budget.cores)}`;
-  return `started past the core budget after ${waited}s \u2014 ${cores}${describe_memory(ledger, budget)}`;
-}
-var core_admission = {
-  RAMP_UP_MS,
-  admitted_keys,
-  admitted_load,
-  describe_overflow,
-  is_admitted,
-  ledger_load,
-  sum_load
-};
-
-// scripts/gate/core-wait.ts
-import path2 from "node:path";
-var WAIT_REASONS = ["cores", "memory", "pressure"];
-var REASON_TEXT = {
-  cores: "not enough free cores",
-  memory: "not enough free memory",
-  pressure: "memory under pressure"
-};
-function wait_reason(key, reservations, budget) {
-  const cores_only = { cores: budget.cores, memory_mb: Infinity };
-  if (!core_admission.is_admitted(key, reservations, cores_only)) return "cores";
-  return budget.memory_pressured === true ? "pressure" : "memory";
-}
-function wait_line(command, reason) {
-  return `\u23F3 ${command ?? "a step"} waits for the core budget \u2014 ${REASON_TEXT[reason]}`;
-}
-function lanes_root_of(checkout) {
-  if (lane_paths.lane_issue_of(checkout) === void 0) return lane_paths.lane_root(checkout);
-  return path2.dirname(path2.resolve(checkout));
-}
-function where_of(checkout) {
-  return { checkout, lane: lane_paths.lane_issue_of(checkout), lanes_root: lanes_root_of(checkout) };
-}
-function place_of(marker, home_root) {
-  const { checkout, lane, lanes_root } = marker;
-  if (checkout === void 0 || lanes_root === void 0 || lanes_root === home_root) {
-    return { lane, elsewhere: void 0 };
-  }
-  const name = lane === void 0 ? path2.basename(checkout) : `${path2.basename(lanes_root)}/${lane}`;
-  return { lane: void 0, elsewhere: name };
-}
-function wait_of(marker, now, home_root) {
-  const { command, wait_reason: reason } = marker;
-  if (reason === void 0 || marker.admitted_at !== void 0) return [];
-  return [{ command, ...place_of(marker, home_root), waited_ms: now - marker.claimed_at, reason }];
-}
-function waits_of(entries, now, home) {
-  const home_root = lanes_root_of(home);
-  return entries.flatMap((entry) => wait_of(entry.reservation, now, home_root)).toSorted((left, right) => right.waited_ms - left.waited_ms);
-}
-var core_wait = {
-  REASON_TEXT,
-  WAIT_REASONS,
-  wait_line,
-  wait_reason,
-  waits_of,
-  where_of
-};
-
-// scripts/gate/held-mark.ts
-var HELD_KEY = "JOSH_CORE_RESERVED";
-var HELD_VALUE = "1";
-var HELD_RESERVATION_KEY = "JOSH_CORE_RESERVATION";
-function is_held() {
-  return process.env[HELD_KEY] === HELD_VALUE;
-}
-function held_reservation() {
-  const key = process.env[HELD_RESERVATION_KEY] ?? "";
-  return key === "" ? void 0 : key;
-}
-function set_held_mark(value, reservation) {
-  process.env[HELD_KEY] = value;
-  process.env[HELD_RESERVATION_KEY] = reservation;
-}
-async function with_held_mark(run, reservation = "") {
-  const previous = process.env[HELD_KEY] ?? "";
-  const previous_reservation = process.env[HELD_RESERVATION_KEY] ?? "";
-  set_held_mark(HELD_VALUE, reservation);
-  try {
-    return await run();
-  } finally {
-    set_held_mark(previous, previous_reservation);
-  }
-}
-var held_mark = {
-  HELD_KEY,
-  HELD_RESERVATION_KEY,
-  HELD_VALUE,
-  held_reservation,
-  is_held,
-  with_held_mark
-};
-
-// scripts/gate/machine-capacity.ts
-import { readFile } from "node:fs/promises";
-import { availableParallelism as availableParallelism2, cpus, totalmem } from "node:os";
-import { execa } from "execa";
-var SAMPLE_WINDOW_MS = 250;
-var BASELINE_CORES = 2;
-var BYTES_PER_MB = 1048576;
-var KB_PER_MB = 1024;
-var PERCENT = 100;
-var MEMINFO_PATH = "/proc/meminfo";
-var VMSTAT_PATH = "/proc/vmstat";
-var LINUX_AVAILABLE = /^MemAvailable:\s+(?<kb>\d+) kB/mu;
-var LINUX_SWAP_IN = /^pswpin (?<pages>\d+)$/mu;
-var LINUX_SWAP_OUT = /^pswpout (?<pages>\d+)$/mu;
-var PAGE_SIZE_ARGUMENTS = ["PAGESIZE"];
-var LEVEL_NAME = "kern.memorystatus_level";
-var SWAP_IN_NAME = "vm.compressor.swapper.swapins_total";
-var SWAP_OUT_NAME = "vm.compressor.swapper.swapouts_total";
-var COMPRESSED_NAME = "vm.compressor_input_bytes";
-var PAGE_SIZE_NAME = "hw.pagesize";
-var PRESSURE_NAME = "kern.memorystatus_vm_pressure_level";
-var PRESSURE_WARNING = 2;
-var SWAP_PRESSURE_MB = 16;
-var COMPRESSION_PRESSURE_MB = 64;
-var SYSCTL_ARGUMENTS = [
-  LEVEL_NAME,
-  SWAP_IN_NAME,
-  SWAP_OUT_NAME,
-  COMPRESSED_NAME,
-  PAGE_SIZE_NAME,
-  PRESSURE_NAME
-];
-var SYSCTL_LINE = /^(?<name>[\w.]+): (?<value>\d+)$/gmu;
-function cpu_times() {
-  let busy = 0;
-  let idle = 0;
-  for (const { times } of cpus()) {
-    busy += times.user + times.nice + times.sys + times.irq;
-    idle += times.idle;
-  }
-  return { busy, total: busy + idle };
-}
-function busy_share_between(before, after) {
-  const total = after.total - before.total;
-  if (total <= 0) return void 0;
-  return (after.busy - before.busy) / total;
-}
-function busy_cores_between(before, after, cores) {
-  const share = busy_share_between(before, after);
-  return share === void 0 ? void 0 : share * cores;
-}
-function sysctl_values(output) {
-  const values = [...output.matchAll(SYSCTL_LINE)].map(
-    (match) => [match.groups?.["name"] ?? "", Number(match.groups?.["value"])]
-  );
-  return new Map(values);
-}
-function swapped_pages(pages_in, pages_out) {
-  return pages_in === void 0 || pages_out === void 0 ? void 0 : pages_in + pages_out;
-}
-function mb_of(units, unit_bytes) {
-  if (units === void 0 || unit_bytes === void 0) return void 0;
-  return units * unit_bytes / BYTES_PER_MB;
-}
-function swapped_between(from, to) {
-  if (from === void 0 || to === void 0) return void 0;
-  return Math.max(0, to - from);
-}
-function parse_darwin_memory(output, total_bytes) {
-  const values = sysctl_values(output);
-  const level = values.get(LEVEL_NAME);
-  return {
-    available_mb: level === void 0 ? void 0 : level / PERCENT * (total_bytes / BYTES_PER_MB),
-    swapped_mb: mb_of(
-      swapped_pages(values.get(SWAP_IN_NAME), values.get(SWAP_OUT_NAME)),
-      values.get(PAGE_SIZE_NAME)
-    ),
-    pressure_level: values.get(PRESSURE_NAME),
-    compressed_mb: mb_of(values.get(COMPRESSED_NAME), 1)
-  };
-}
-function parse_linux_available(meminfo) {
-  const kb = LINUX_AVAILABLE.exec(meminfo)?.groups?.["kb"];
-  return kb === void 0 ? void 0 : Number(kb) / KB_PER_MB;
-}
-function pages_of(pattern, vmstat) {
-  const pages = pattern.exec(vmstat)?.groups?.["pages"];
-  return pages === void 0 ? void 0 : Number(pages);
-}
-function parse_linux_swapped(vmstat, page_bytes) {
-  const pages = swapped_pages(pages_of(LINUX_SWAP_IN, vmstat), pages_of(LINUX_SWAP_OUT, vmstat));
-  return mb_of(pages, page_bytes);
-}
-async function settled(read) {
-  try {
-    return await read();
-  } catch {
-    return void 0;
-  }
-}
-async function read_darwin_memory() {
-  const { stdout } = await execa("sysctl", SYSCTL_ARGUMENTS, {
-    reject: false,
-    timeout: PROBE_TIMEOUT_MS
-  });
-  return parse_darwin_memory(stdout, totalmem());
-}
-async function read_page_size() {
-  const { stdout } = await execa("getconf", PAGE_SIZE_ARGUMENTS, { timeout: PROBE_TIMEOUT_MS });
-  return stdout;
-}
-async function read_linux_memory() {
-  const [meminfo, vmstat, page_size] = await Promise.all([
-    settled(async () => await readFile(MEMINFO_PATH, "utf8")),
-    settled(async () => await readFile(VMSTAT_PATH, "utf8")),
-    settled(read_page_size)
-  ]);
-  const page_bytes = page_size === void 0 ? void 0 : Number(page_size);
-  return {
-    available_mb: meminfo === void 0 ? void 0 : parse_linux_available(meminfo),
-    swapped_mb: vmstat === void 0 || page_bytes === void 0 ? void 0 : parse_linux_swapped(vmstat, page_bytes),
-    pressure_level: void 0
-  };
-}
-var UNREAD_MEMORY = {
-  available_mb: void 0,
-  swapped_mb: void 0,
-  pressure_level: void 0
-};
-async function read_memory() {
-  if (process.platform === "darwin") return await settled(read_darwin_memory) ?? UNREAD_MEMORY;
-  return process.platform === "linux" ? await read_linux_memory() : UNREAD_MEMORY;
-}
-function is_unquoted() {
-  return cpus().length > 0 && cpus().length === availableParallelism2();
-}
-async function default_sleep(ms) {
-  await new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-function moved_over(from, to, limit) {
-  return (swapped_between(from, to) ?? 0) > limit;
-}
-function is_pressured(before, after) {
-  return (after.pressure_level ?? 0) >= PRESSURE_WARNING || moved_over(before.swapped_mb, after.swapped_mb, SWAP_PRESSURE_MB) || moved_over(before.compressed_mb, after.compressed_mb, COMPRESSION_PRESSURE_MB);
-}
-function pressured_available(before, after) {
-  if (after.available_mb === void 0) return void 0;
-  return is_pressured(before, after) ? 0 : after.available_mb;
-}
-async function read_machine(sleep = default_sleep) {
-  const before = cpu_times();
-  const [memory_before] = await Promise.all([read_memory(), sleep(SAMPLE_WINDOW_MS)]);
-  const memory_after = await read_memory();
-  const busy_cores = is_unquoted() ? busy_cores_between(before, cpu_times(), cpus().length) : void 0;
-  return {
-    busy_cores,
-    available_mb: pressured_available(memory_before, memory_after),
-    memory_pressured: is_pressured(memory_before, memory_after)
-  };
-}
-async function read_sample() {
-  return { cpu: cpu_times(), memory: await read_memory(), total_mb: totalmem() / BYTES_PER_MB };
-}
-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,
-    memory_pressured: reading.memory_pressured
-  };
-}
-var machine_capacity = {
-  BASELINE_CORES,
-  busy_cores_between,
-  busy_share_between,
-  COMPRESSION_PRESSURE_MB,
-  external_cores,
-  machine_budget,
-  parse_darwin_memory,
-  parse_linux_available,
-  parse_linux_swapped,
-  pressured_available,
-  read_machine,
-  read_memory,
-  read_sample,
-  SWAP_PRESSURE_MB,
-  swapped_between
-};
-
-// scripts/gate/core-budget.ts
-var RESERVED_PREFIX = "josh-core-reserved-";
-var RESERVED_SUFFIX = ".json";
-var POLL_INTERVAL_MS = 50;
-var WAIT_CAP_MS = 12e4;
-var MIN_BUDGET = 1;
-var CORE_WEIGHTS = {
-  lint: 2,
-  type_check: 1,
-  spell_check: 1,
-  eslint_scan: 1,
-  format: 1,
-  retrospective: 1,
-  install: 1,
-  e2e: 2
-};
-var MEMORY_MB = {
-  lint: 2400,
-  type_check: 1300,
-  spell_check: 350,
-  eslint_scan: 2400,
-  unit_worker: 350,
-  format: 300,
-  retrospective: 900,
-  install: 100
-};
-var reservation_schema = process_owner_schema.extend({
-  weight: z2.number(),
-  claimed_at: z2.number(),
-  memory_mb: z2.number().optional(),
-  admitted_at: z2.number().optional(),
-  command: z2.string().optional(),
-  checkout: z2.string().optional(),
-  lane: z2.string().optional(),
-  lanes_root: z2.string().optional(),
-  wait_reason: z2.enum(core_wait.WAIT_REASONS).optional()
-});
-function marker_name(key) {
-  return `${RESERVED_PREFIX}${key}${RESERVED_SUFFIX}`;
-}
-function is_running2(reservation) {
-  return process_identity.is_same_process(reservation.pid, reservation.process_start) !== false;
-}
-function read_reservation(source) {
-  const raw = stamp_file.read_stamp_text(source);
-  if (raw === void 0) return void 0;
-  return json_value.parse_with(raw, reservation_schema);
-}
-function sweep_marker2(source) {
-  try {
-    stamp_file.remove_stamp(source);
-  } catch {
-  }
-}
-function live_reservation(source) {
-  const reservation = read_reservation(source);
-  if (reservation === void 0) return void 0;
-  if (is_running2(reservation)) return reservation;
-  sweep_marker2(source);
-  return void 0;
-}
-function marker_files2(directory) {
-  try {
-    return readdirSync2(directory).filter(
-      (name) => name.startsWith(RESERVED_PREFIX) && name.endsWith(RESERVED_SUFFIX)
-    );
-  } catch {
-    return [];
-  }
-}
-function live_reservations(directory = PLATFORM_TEMP_ROOT) {
-  return marker_files2(directory).flatMap((name) => {
-    const reservation = live_reservation(path3.join(directory, name));
-    return reservation === void 0 ? [] : { key: name, reservation };
-  });
-}
-function normalize_budget(budget) {
-  return Number.isFinite(budget) ? Math.max(MIN_BUDGET, Math.floor(budget)) : MIN_BUDGET;
-}
-async function default_sleep2(ms) {
-  await new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-function write_reservation(target2, fields) {
-  stamp_file.replace_stamp(target2, { ...process_identity.own_fields(), ...fields });
-}
-function report_wait(line) {
-  process.stderr.write(`${line}
-`);
-}
-function resolve_timing(options) {
-  return {
-    now: options.now ?? Date.now,
-    sleep: options.sleep ?? default_sleep2,
-    poll_interval_ms: options.poll_interval_ms ?? POLL_INTERVAL_MS,
-    wait_cap_ms: options.wait_cap_ms ?? WAIT_CAP_MS
-  };
-}
-async function current_budget(context, reservations) {
-  if (reservations.length <= 1) return { cores: context.budget, memory_mb: Infinity };
-  const reading = await context.read_machine();
-  const ledger = core_admission.ledger_load(reservations, context.now());
-  const budget = machine_capacity.machine_budget(context.budget, reading, ledger);
-  return { ...budget, cores: normalize_budget(budget.cores) };
-}
-function admit(context, overflow) {
-  write_reservation(context.target, { ...context.fields, admitted_at: context.now() });
-  return { overflow };
-}
-function overflow_of(context, reservations, budget) {
-  return {
-    waited_ms: context.now() - context.fields.claimed_at,
-    ledger: core_admission.sum_load(reservations),
-    budget
-  };
-}
-function mark_waiting(context, reason) {
-  const previous = context.fields.wait_reason;
-  if (previous === reason) return;
-  context.fields = { ...context.fields, wait_reason: reason };
-  write_reservation(context.target, context.fields);
-  if (previous === void 0) context.report(core_wait.wait_line(context.fields.command, reason));
-}
-async function poll_admission(context) {
-  const reservations = live_reservations(context.directory);
-  const budget = await current_budget(context, reservations);
-  if (core_admission.is_admitted(context.key, reservations, budget)) return admit(context);
-  if (context.now() >= context.deadline) {
-    return admit(context, overflow_of(context, reservations, budget));
-  }
-  mark_waiting(context, core_wait.wait_reason(context.key, reservations, budget));
-  return void 0;
-}
-async function await_admission(context) {
-  let admission = await poll_admission(context);
-  while (admission === void 0) {
-    await context.sleep(context.poll_interval_ms);
-    admission = await poll_admission(context);
-  }
-  return admission;
-}
-function resolve_ports(options) {
-  return {
-    read_machine: options.read_machine ?? machine_capacity.read_machine,
-    report: options.report ?? report_wait
-  };
-}
-function claim_fields(weight, claimed_at, options) {
-  const { memory_mb, command } = options;
-  return { weight, claimed_at, memory_mb, command, ...core_wait.where_of(process.cwd()) };
-}
-async function reserve(weight, options = {}) {
-  const timing = resolve_timing(options);
-  const directory = options.directory ?? PLATFORM_TEMP_ROOT;
-  const claimed_at = timing.now();
-  const name = marker_name(randomUUID());
-  const target2 = path3.join(directory, name);
-  const fields = claim_fields(weight, claimed_at, options);
-  write_reservation(target2, fields);
-  const admission = await await_admission({
-    ...timing,
-    key: name,
-    target: target2,
-    directory,
-    budget: normalize_budget(options.budget ?? availableParallelism3()),
-    deadline: claimed_at + timing.wait_cap_ms,
-    fields,
-    ...resolve_ports(options)
-  });
-  return { target: target2, admission };
-}
-function budget_waits(directory = PLATFORM_TEMP_ROOT, now = Date.now(), home = process.cwd()) {
-  return core_wait.waits_of(live_reservations(directory), now, home);
-}
-function release(handle) {
-  sweep_marker2(handle.target);
-}
-async function with_core_reservation(weight, run, options = {}) {
-  const handle = await reserve(weight, options);
-  try {
-    return await run(handle.admission, path3.basename(handle.target));
-  } finally {
-    release(handle);
-  }
-}
-async function with_command_reservation(weight, run, options = {}) {
-  if (held_mark.is_held() || unit_worker_share.is_nested_run()) return await run();
-  return await with_core_reservation(
-    weight,
-    async (_admission, key) => await held_mark.with_held_mark(run, key),
-    options
-  );
-}
-var core_budget = {
-  CORE_WEIGHTS,
-  HELD_KEY: held_mark.HELD_KEY,
-  HELD_VALUE: held_mark.HELD_VALUE,
-  MEMORY_MB,
-  RESERVED_PREFIX,
-  admitted_keys: core_admission.admitted_keys,
-  admitted_load: core_admission.admitted_load,
-  budget_waits,
-  describe_overflow: core_admission.describe_overflow,
-  is_held: held_mark.is_held,
-  live_reservations,
-  release,
-  reserve,
-  with_command_reservation,
-  with_core_reservation,
-  with_held_mark: held_mark.with_held_mark
-};
-
-// scripts/josh/josh-command-types.ts
-var OPTIONAL_ENV_FILE_FLAGS = [`--env-file-if-exists=${ENV_FILE_NAME}`];
-var GATE_COMMAND2 = "gate";
-var ESLINT_CACHE_FILE = ".eslintcache";
-var TS_BUILD_INFO_FILE = ".tsbuildinfo";
-var CSPELL_CACHE_FILE = ".cspellcache";
-var ESLINT_EDIT_CACHE_FILE = ".eslintcache.edit";
-var ESLINT_RELATED_CACHE_FILE = ".eslintcache.related";
-var PRETTIER_CACHE_FILE = ".prettiercache";
-var PRETTIER_RELATED_CACHE_FILE = ".prettiercache.related";
-var CSPELL_COMMIT_CACHE_FILE = ".cspellcache.commit";
-var ESLINT_COMMIT_CACHE_FILE = ".eslintcache.commit";
-var ROOTED_JSON_PORTABILITY = "rooted-json";
-var ESLINT_CACHE_SPEC = {
-  cache_file: ESLINT_CACHE_FILE,
-  portability: ROOTED_JSON_PORTABILITY
-};
-var TS_CACHE_SPEC = {
-  cache_file: TS_BUILD_INFO_FILE,
-  portability: "raw"
-};
-var CSPELL_CACHE_SPEC = {
-  cache_file: CSPELL_CACHE_FILE,
-  portability: "raw"
-};
-var GATE_CACHE_SPECS = [
-  ESLINT_CACHE_SPEC,
-  TS_CACHE_SPEC,
-  CSPELL_CACHE_SPEC
-];
-var GATE_CACHE_FILES = GATE_CACHE_SPECS.map((spec) => spec.cache_file);
-var IGNORED_CACHE_FILES = [
-  ...GATE_CACHE_FILES,
-  ESLINT_EDIT_CACHE_FILE,
-  ESLINT_RELATED_CACHE_FILE,
-  PRETTIER_CACHE_FILE,
-  PRETTIER_RELATED_CACHE_FILE,
-  CSPELL_COMMIT_CACHE_FILE,
-  ESLINT_COMMIT_CACHE_FILE
-];
-var CONTENT_CACHE_FLAGS = ["--cache", "--cache-strategy", "content"];
-var CACHE_LOCATION_FLAG = "--cache-location";
-function content_cache_flags(cache_file) {
-  return [...CONTENT_CACHE_FLAGS, CACHE_LOCATION_FLAG, cache_file];
-}
-var ESLINT_CACHE_FLAGS = content_cache_flags(ESLINT_CACHE_FILE);
-var ESLINT_EDIT_CACHE_FLAGS = content_cache_flags(ESLINT_EDIT_CACHE_FILE);
-var ESLINT_RELATED_CACHE_FLAGS = content_cache_flags(ESLINT_RELATED_CACHE_FILE);
-var CSPELL_CACHE_FLAGS = content_cache_flags(CSPELL_CACHE_FILE);
-var PRETTIER_CACHE_FLAGS = content_cache_flags(PRETTIER_CACHE_FILE);
-var PRETTIER_RELATED_CACHE_FLAGS = content_cache_flags(PRETTIER_RELATED_CACHE_FILE);
-var CSPELL_COMMIT_CACHE_FLAGS = content_cache_flags(CSPELL_COMMIT_CACHE_FILE);
-var ESLINT_COMMIT_CACHE_FLAGS = content_cache_flags(ESLINT_COMMIT_CACHE_FILE);
-
-// scripts/josh/josh-commands-backlog.ts
-var BACKLOG_COMMANDS = {
-  // Started from a terminal: the `backlogrun` keyword's launcher, and the board.
-  backlogrun: {
-    script: "scripts/backlog/backlogrun-cli.ts",
-    description: "Start a backlogrun in the background and show its board; with one already running, only show the board, or replace it when it is idle and the invocation differs; --stop stops it",
-    category: "AI tools",
-    reference: [
-      "[<n>...] [--only] [--max <n>] [--idle <minutes>] [--agent claude|codex] | --stop",
-      "developer",
-      ["files", "network", "processes"]
-    ]
-  },
-  "backlog:next": {
-    script: "scripts/backlog/backlog-next.ts",
-    description: "Order the whole opted-in backlog: auto-ok issues and the descendants of auto-ok epics, transitively through nested epics",
-    category: "AI tools",
-    reference: ["[--exclude <n>[,<n>...]] [--repo <owner/repo>]", "automation", ["network"]]
-  },
-  "backlog:offer": {
-    script: "scripts/backlog/backlog-offer-cli.ts",
-    description: "Collapse a backlogrun loop-head event into one call: read backlog:next, ask backlog:budget, return the verdict and any issues to start",
-    category: "AI tools",
-    reference: ["[options]", "automation", ["files", "network", "processes"]]
-  },
-  "backlog:drive": {
-    script: "scripts/backlog/backlog-drive-cli.ts",
-    description: "Drive backlogrun through offer, launch and merge; restore this run\u2019s lanes and report when complete",
-    category: "AI tools",
-    reference: ["--owner <pid> [options]", "automation", ["network"]]
-  },
-  "backlog:plan": {
-    script: "scripts/backlog/backlog-plan-cli.ts",
-    description: "Print the whole backlog as a plan: ready now, waiting on what, waiting on a person, out of scope",
-    category: "AI tools",
-    reference: [
-      "[issue...] [--only] [--waves] [--exclude <n>[,<n>...]]",
-      "automation",
-      ["network"]
-    ]
-  },
-  "backlog:stalled": {
-    script: "scripts/backlog/backlog-stalled-cli.ts",
-    // A stall sends one Telegram warning. The `Stop` hook calls the detector
-    // directly, so this flag costs only the manual command its in-process dispatch.
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Report whether ready backlog work is sitting undispatched with a free lane and no recent dispatch",
-    category: "AI tools",
-    reference: ["", "automation", ["network"]]
-  },
-  "backlog:budget": {
-    script: "scripts/backlog/backlog-budget-cli.ts",
-    description: "Say whether a backlogrun may start more work, keep watching, or finish",
-    category: "AI tools",
-    reference: ["[options]", "automation", ["none"]]
-  }
-};
-
-// scripts/josh/josh-commands-document.ts
-var DOCUMENT_COMMANDS = {
-  "doc:section": {
-    script: "scripts/document/document-section-cli.ts",
-    description: 'Print one section of a markdown document, for a `file.md` \u2192 "Heading" reference',
-    category: "AI tools",
-    reference: ["<file> <heading>", "automation", ["none"]],
-    is_bundled: true
-  },
-  "read:set": {
-    script: "scripts/document/read-set-cli.ts",
-    description: "Print what an entry point reads before it starts, and what that read costs",
-    category: "AI tools",
-    reference: ["[<entry>] [--json]", "automation", ["none"]]
-  },
-  "doc:read": {
-    script: "scripts/document/document-read-cli.ts",
-    description: "Read a whole document safely: print it, or point at the Read tool when over the Bash cap",
-    category: "AI tools",
-    reference: ["<file>", "automation", ["none"]]
-  },
-  "read:files": {
-    script: "scripts/document/read-files-cli.ts",
-    description: "Read several files in one call so edit targets fold into one turn",
-    category: "AI tools",
-    reference: ["<path> [<path> ...]", "automation", ["none"]]
-  },
-  "edit:files": {
-    script: "scripts/document/edit-files-cli.ts",
-    description: "Apply several content-addressed edits from a plan in one call",
-    category: "AI tools",
-    reference: ["<plan-path | ->", "automation", ["none"]]
-  }
-};
-
-// scripts/josh/josh-commands-guard.ts
-var GUARD_COMMANDS = {
-  "investigation:guard": {
-    script: "scripts/delegation/investigation-guard.ts",
-    description: "Claude Code hook: refuse a read once the unedited-read threshold is reached again (reads the tool call on stdin)",
-    category: "AI tools",
-    reference: ["", "automation", ["none"]]
-  },
-  "duplicate-read:guard": {
-    script: "scripts/delegation/duplicate-read-guard.ts",
-    description: "Claude Code hook: refuse a second whole-file read of a path whose content has not changed since the run last read it (reads the tool call on stdin)",
-    category: "AI tools",
-    reference: ["", "automation", ["none"]]
-  },
-  "rule:guard": {
-    script: "scripts/rules/rule-guard.ts",
-    description: "Claude Code hook: deliver a trigger-delivered rule at the call that binds it (reads the tool call on stdin)",
-    category: "AI tools",
-    reference: ["", "automation", ["none"]]
-  }
-};
-
-// scripts/josh/josh-commands-issue.ts
-var ISSUES_WITH_REPO = "<issue...> [--repo <owner/repo>]";
-var ISSUE_COMMANDS = {
-  "issue:ack": {
-    script: "scripts/issue/issue-ack-cli.ts",
-    description: "Record that the run read a person's update to its issue, printing the update it acknowledges",
-    category: "AI tools",
-    reference: ["<issue>", "automation", ["network"]]
-  },
-  "issue:read": {
-    script: "scripts/issue/issue-read-cli.ts",
-    description: "Print each issue's title, body and every comment on it, in one call",
-    category: "AI tools",
-    reference: ["<issue...>", "automation", ["network"]]
-  },
-  "issue:state": {
-    script: "scripts/issue/issue-state-cli.ts",
-    description: "Print each issue's state and labels, in the spelling the documents compare against",
-    category: "AI tools",
-    reference: [ISSUES_WITH_REPO, "automation", ["network"]]
-  },
-  "issue:scout": {
-    script: "scripts/issue/issue-scout-cli.ts",
-    description: "Before filing: say whether an issue like this exists and which epic it belongs to",
-    category: "AI tools",
-    reference: ["<title> [--body <summary> | --body-file <path>]", "automation", ["network"]]
-  },
-  "defect:rate": {
-    script: "scripts/issue/defect-rate-cli.ts",
-    description: "Print the defect rate of merged work: defects filed per enhancement completed",
-    category: "AI tools",
-    reference: ["[--days <n>]", "automation", ["network"]]
-  },
-  "issue:fold": {
-    script: "scripts/issue/issue-fold-cli.ts",
-    description: "Before a second filing: say whether findings from this session fold into one issue",
-    category: "AI tools",
-    reference: ["<title>... [--not-separable] [--json]", "automation", ["none"]]
-  },
-  "issue:fold-existing": {
-    script: "scripts/issue/issue-fold-existing-cli.ts",
-    description: "Assess whether a complete draft can join an unstarted issue",
-    category: "AI tools",
-    reference: ["<assessment.json> [--json]", "automation", ["none"]]
-  },
-  "issue:cite": {
-    script: "scripts/issue/issue-cite-cli.ts",
-    description: "Print the paste-ready number-link citation line for each issue, in one call",
-    category: "AI tools",
-    reference: [ISSUES_WITH_REPO, "automation", ["network"]]
-  },
-  "issue:comment": {
-    script: "scripts/issue/issue-comment-cli.ts",
-    description: "Post one comment to an issue from a file, so no shell expands the body",
-    category: "AI tools",
-    reference: ["<issue> --body <text> | --body-file <path>", "automation", ["network"]]
-  },
-  "issue:file": {
-    script: "scripts/issue/issue-file-cli.ts",
-    description: "File an Issue with every filing step: lint, Origin, fold, WIP cap, duplicate scout, labels, then epic:bundle",
-    category: "AI tools",
-    reference: [
-      "<title> --body-file <path> --depth <0|1|2> [--route <route>] [--label <name>] [--repo <owner/repo>] [--distinct <N,\u2026>] [--over-cap] [--no-auto-ok] [--release]",
-      "automation",
-      ["network"]
-    ]
-  },
-  "issue:release": {
-    script: "scripts/issue/issue-release-cli.ts",
-    description: "Link an Issue to the repository's open release Issue as its blocker (or, with --wait, as waiting on it), filing one when none is open",
-    category: "AI tools",
-    reference: ["<issue> [--wait]", "automation", ["network"]]
-  }
-};
-
-// scripts/josh/josh-commands-lane.ts
-var LANE_SCRIPT = "scripts/lane/lane-cli.ts";
-var LANE_ARGUMENTS = { script: LANE_SCRIPT, tsx_arguments: OPTIONAL_ENV_FILE_FLAGS };
-var ISSUE_WITH_OPTIONS = "<issue> [options]";
-var MEASURE_ARGUMENTS = {
-  script: "scripts/lane/lane-measure-cli.ts",
-  tsx_arguments: OPTIONAL_ENV_FILE_FLAGS
-};
-var LANE_COMMANDS = {
-  "lane:open": {
-    ...LANE_ARGUMENTS,
-    description: "Open a lane: a linked work tree with its own branch and its own port seed",
-    category: "AI tools",
-    reference: [ISSUE_WITH_OPTIONS, "automation", ["files", "git"]],
-    default_script_arguments: ["open"]
-  },
-  "lane:close": {
-    ...LANE_ARGUMENTS,
-    description: "Close a lane, leaving no work tree, branch or directory behind",
-    category: "AI tools",
-    reference: ["<issue>", "automation", ["files", "git"]],
-    default_script_arguments: ["close"]
-  },
-  "lane:list": {
-    ...LANE_ARGUMENTS,
-    description: "List the open lanes: which issue, which ports, and where each one is",
-    category: "AI tools",
-    reference: ["", "automation", ["none"]],
-    default_script_arguments: ["list"]
-  },
-  "lane:prune": {
-    ...LANE_ARGUMENTS,
-    description: "Close every lane an interruption left without its work tree and every spent lane, then sweep unregistered leftovers under the lanes root",
-    category: "AI tools",
-    reference: ["", "automation", ["files", "git"]],
-    default_script_arguments: ["prune"]
-  },
-  "lane:output": {
-    ...LANE_ARGUMENTS,
-    description: "Record, or read back, where the unit running a lane\u2019s child writes",
-    category: "AI tools",
-    reference: ["<issue> [path]", "automation", ["files"]],
-    default_script_arguments: ["output"]
-  },
-  "lane:dispatch": {
-    ...LANE_ARGUMENTS,
-    description: "Start a lane\u2019s child as a detached process that outlives this session",
-    category: "AI tools",
-    reference: ["<issue> <prompt>", "automation", ["processes"]],
-    default_script_arguments: ["dispatch"]
-  },
-  "lane:await": {
-    ...LANE_ARGUMENTS,
-    description: "Block until any of the named in-flight lane children completes; prints which one finished",
-    category: "AI tools",
-    reference: ["<issue> [<issue>...] [--owner <pid>]", "automation", ["files", "processes"]],
-    default_script_arguments: ["await"]
-  },
-  "lane:launch": {
-    script: "scripts/lane/lane-launch-cli.ts",
-    description: "Collapse a backlogrun lane-start event into one call: open the lane, pop and re-install on the first, dispatch the child",
-    category: "AI tools",
-    reference: ["<issue> [--stash <message>]", "automation", ["files", "git", "processes"]]
-  },
-  // `.env` is read for `JOSH_LANE_ROOT`, as every lane command reads it, so the lane is found.
-  "lane:restart": {
-    script: "scripts/lane/lane-restart-cli.ts",
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Stop a running lane child, stash its uncommitted work and re-dispatch its issue in a fresh session \u2014 not counted as an outage or a failure",
-    category: "AI tools",
-    reference: ["<issue>", "developer", ["files", "git", "processes", "network"]]
-  },
-  // `.env` is read for `JOSH_LANE_ROOT`, as every lane command reads it, so the lane is found.
-  "lane:withdraw": {
-    script: "scripts/lane/lane-withdraw-cli.ts",
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Stop a running lane child, stash its uncommitted work, close its issue as not planned and close the lane \u2014 booked withdrawn, not as an outage or a failure",
-    category: "AI tools",
-    reference: ["<issue> --reason <text>", "developer", ["files", "git", "processes", "network"]]
-  },
-  // A live run's lane limit: `.env` is read so the bare form reports the
-  // `JOSH_LANE_LIMIT` a person set there when no override stands.
-  "lane:limit": {
-    script: "scripts/lane/lane-limit-cli.ts",
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Change a live backlogrun\u2019s lane limit without stopping it, or print the limit, lanes in use and free lanes",
-    category: "AI tools",
-    reference: ["[<limit>] [--reset]", "developer", ["files"]]
-  },
-  // The lane-limit measurement: `.env` is read so `lane:stats` labels the row
-  // with the `JOSH_LANE_LIMIT` a person set there.
-  "lane:sample": {
-    ...MEASURE_ARGUMENTS,
-    description: "Record the machine load (load average, swap, free memory, working lanes) to the lane ledger \u2014 a backlogrun samples itself, this is for a reading outside one",
-    category: "AI tools",
-    reference: ["[--every <seconds>]", "maintainer", ["files"]],
-    default_script_arguments: ["sample"]
-  },
-  "lane:stats": {
-    ...MEASURE_ARGUMENTS,
-    description: "Print one table row of lane throughput, gate duration and machine load over a period, the per-stage durations of a lane under it, the wait after each ship stop reason under those, and the duration and reuse count of each gate check last",
-    category: "AI tools",
-    reference: ["--period <days> [--limit <lane-limit>]", "maintainer", ["none"]],
-    default_script_arguments: ["stats"]
-  }
-};
-
-// scripts/josh/josh-commands-run.ts
-var RUN_HOLD_SCRIPT = "scripts/run/hold/run-hold-cli.ts";
-var RUN_COMMANDS = {
-  "run:hold": {
-    script: RUN_HOLD_SCRIPT,
-    description: "Claim this working tree for a run, or say which run already holds it",
-    category: "AI tools",
-    reference: ["[<issue> [--fullrun | --halfrun-stop | --prrun-stop]]", "automation", ["files"]]
-  },
-  "run:release": {
-    script: RUN_HOLD_SCRIPT,
-    description: "Release this working tree's run record",
-    category: "AI tools",
-    reference: ["[issue|--force]", "automation", ["files"]],
-    default_script_arguments: ["--release"]
-  },
-  "run:tidy": {
-    script: "scripts/run/tidy/run-tidy-cli.ts",
-    description: "Close merged lanes and drop stashes whose issues are all merged",
-    category: "AI tools",
-    reference: ["", "automation", ["git", "network", "files"]]
-  },
-  "run:carry": {
-    script: "scripts/run/carry/run-carry-cli.ts",
-    // `--stopped` sends the stop confirmation, so the Telegram credentials come from `.env` as for
-    // `run:wake` below.
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Carry one invocation\u2019s budget across its own session cuts",
-    category: "AI tools",
-    reference: ["<operation> [arguments...]", "automation", ["files"]]
-  },
-  "run:add": {
-    script: "scripts/run/add/run-add-cli.ts",
-    description: "Add issues to a live backlogrun, ahead of the queue unless --no-priority",
-    category: "AI tools",
-    reference: ["<issue...> [--no-priority]", "automation", ["network", "files"]]
-  },
-  "run:wake": {
-    script: "scripts/run/wake/run-wake-cli.ts",
-    // `.env` rather than the ambient environment:
-    // the failure warning needs the Telegram credentials, the same
-    // reasons `notify` and `followup` carry these flags.
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Wake the next session of a cut backlogrun from outside the conversation",
-    category: "AI tools",
-    reference: ["[options]", "automation", ["processes", "notifications"]]
-  },
-  "run:cut": {
-    script: "scripts/run/cut/run-cut-cli.ts",
-    description: "Cut a lane child before the gate and resume a fresh process",
-    category: "AI tools",
-    reference: ["[--resume] <issue> [--impl] [--handoff <path>]", "automation", ["files"]]
-  },
-  "run:liveness": {
-    script: "scripts/run/run-liveness-cli.ts",
-    description: "Say whether a delegated unit is still working, or stopped without reporting",
-    category: "AI tools",
-    reference: ["<issue> --output <path> [options]", "automation", ["processes"]]
-  },
-  "run:ending": {
-    script: "scripts/run/run-ending-cli.ts",
-    description: "Classify how a dispatched lane child ended (merged, cut, abandoned, unreadable)",
-    category: "AI tools",
-    reference: ["<issue> --output <path> [--repo <owner/repo>]", "automation", ["network"]]
-  },
-  "run:progress": {
-    script: "scripts/run/progress/run-progress-cli.ts",
-    description: "Report an unattended run\u2019s progress once it has gone quiet for an interval",
-    category: "AI tools",
-    reference: [
-      "[--once | --wait] [--interval <minutes>] [--hours <hours>] [--repo <owner/repo>] [--output <path>] | --mark | --path",
-      "automation",
-      ["files"]
-    ]
-  },
-  "run:board": {
-    script: "scripts/run/board/run-board-cli.ts",
-    // `--every` pushes its frame as a Telegram, so the credentials come from `.env` as for `run:carry`.
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Draw a live board of the running backlogrun, redrawn every second",
-    category: "AI tools",
-    reference: ["[--once | --chat | --every <minutes>]", "automation", ["files", "network"]]
-  },
-  "run:prep": {
-    script: "scripts/run/run-prep-cli.ts",
-    description: "Bundle a run\u2019s pre-edit reads: body, comments, state, dependency scope",
-    category: "AI tools",
-    reference: ["<issue>", "automation", ["network"]]
-  },
-  // The entry sequence a lane opened on, folded into one call: claim the tree,
-  // read the budget, gather the issue reads and decide the pre-implementation step. `run:hold`,
-  // `cost --cut`, `run:prep` and `run:step` were four round trips re-billing a lane's full context each.
-  "run:entry": {
-    script: "scripts/run/entry/run-entry-cli.ts",
-    // A `busy` hold or an `over` budget sends the stop confirmation.
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Open a run in one call: claim the tree, read the budget, bundle the reads, decide the pre-implementation step",
-    category: "AI tools",
-    reference: ["<issue> [--to <command>]", "automation", ["git", "network", "files"]]
-  },
-  "run:status": {
-    script: "scripts/run/run-status-cli.ts",
-    description: "Bundle a run\u2019s read-only status: issue state, cost verdict, carry counters",
-    category: "AI tools",
-    reference: ["<issue> [--repo <owner/repo>]", "automation", ["network"]]
-  },
-  "run:next": {
-    script: "scripts/run/run-next-cli.ts",
-    description: "Print the next step a fullrun takes, computed from the run\u2019s state",
-    category: "AI tools",
-    reference: ["<issue>", "automation", ["network"]]
-  },
-  "run:step": {
-    script: "scripts/run/run-step-cli.ts",
-    description: "Print the run\u2019s next single action, computed from the event stream, carry record and issue state",
-    category: "AI tools",
-    reference: ["[<issue>]", "automation", ["network", "files"]]
-  }
-};
-
-// scripts/josh/josh-commands-split.ts
-var SPLIT_COMMANDS = {
-  "split:assess": {
-    script: "scripts/split/split-assess-cli.ts",
-    description: "Measure the branch change size (tests excluded) and answer the split assessment size question: split | single",
-    category: "AI tools",
-    reference: ["[--json]", "automation", ["none"]]
-  }
-};
-
-// scripts/josh/josh-commands-ai.ts
-var ISSUE_WITH_OPTIONS2 = "<issue> [options]";
-var AI_COMMANDS = {
-  ...ISSUE_COMMANDS,
-  "pkg:scout": {
-    script: "scripts/package/package-scout-cli.ts",
-    description: "Rank package candidates by measured metrics so the Package-First tier decision is read, not judged",
-    category: "AI tools",
-    reference: ["<keywords> [--size <n>]", "automation", ["network"]]
-  },
-  "stash:pop": {
-    script: "scripts/git/stash/stash-pop-cli.ts",
-    description: "Pop the stash matching this message, not whichever a shared stack has on top",
-    category: "AI tools",
-    reference: ["<message>", "automation", ["git"]]
-  },
-  epic: {
-    script: "scripts/epic/epic.ts",
-    description: "Create an epic issue from its child issue numbers",
-    category: "AI tools",
-    reference: ["<title> <issue...> [--ordered]", "automation", ["network"]]
-  },
-  "epic:next": {
-    script: "scripts/epic/epic-next.ts",
-    description: "List an epic's runnable children, bundled per repository",
-    category: "AI tools",
-    reference: ["<epic>... [--repo <owner/repo>] [--lanes]", "automation", ["network"]]
-  },
-  "epic:bundle": {
-    script: "scripts/epic/epic-bundle-cli.ts",
-    description: "Say whether a newly filed issue belongs with ones already in the backlog",
-    category: "AI tools",
-    reference: ["<issue>", "automation", ["network"]]
-  },
-  "epic:audit": {
-    script: "scripts/epic/epic-audit-cli.ts",
-    description: "Audit an epic's children against each other for contradictions",
-    category: "AI tools",
-    reference: ["<epic>", "automation", ["network"]]
-  },
-  "epic:check": {
-    script: "scripts/epic/epic-check.ts",
-    description: "Check an epic issue against the tracking requirements",
-    category: "AI tools",
-    reference: ["<epic>", "automation", ["network"]]
-  },
-  "auto-ok:next": {
-    script: "scripts/auto-ok/auto-ok-cli.ts",
-    description: "Print the next opted-in issue an unattended run may pick up outside an epic",
-    category: "AI tools",
-    reference: ["[--exclude <n>[,<n>...]] [--label <name>]", "automation", ["network"]]
-  },
-  "auto-ok:judge": {
-    script: "scripts/auto-ok/auto-ok-judge-cli.ts",
-    description: "List the open issues backlogrun owes an auto-ok judgement, or record one (--apply / --decline)",
-    category: "AI tools",
-    reference: [
-      "[--apply <n> (--lane | --solo) | --decline <n> --reason <text>]",
-      "automation",
-      ["network"]
-    ]
-  },
-  ...BACKLOG_COMMANDS,
-  cost: {
-    script: "scripts/cost-runtime/cost-cli.ts",
-    description: "Say whether the next turn of a run crosses the context-cut threshold (--cut) or a given tokens-per-request figure (--over)",
-    category: "AI tools",
-    reference: ["(--cut | --over <tokens-per-request>) [--path <dir>]", "automation", ["none"]]
-  },
-  "cost:audit": {
-    script: "scripts/cost-audit/cost-audit-cli.ts",
-    description: "Report AI cost over a period by session kind, tool category and guard, with cost per merge and regressions against the period before",
-    category: "AI tools",
-    reference: ["[--period <days>]", "maintainer", ["none"]],
-    // Kit-only: it reads kit's own transcript store, like `josh retrospective`, which carries its
-    // summary line.
-    is_kit_only: true
-  },
-  ...DOCUMENT_COMMANDS,
-  time: {
-    script: "scripts/time/time-cli.ts",
-    description: "Report where a run's wall clock went: model wait, tool execution, human wait",
-    category: "AI tools",
-    reference: ["[options]", "maintainer", ["none"]],
-    // Kit-only: it measures kit's own development runs and its report modules live under the
-    // undistributed `scripts/time/`, so it means nothing in a consumer project and is dropped from a
-    // consumer's help. The runtime analysis hooks and guards rely on stays
-    // distributed under `scripts/time-runtime/`.
-    is_kit_only: true
-  },
-  // The tool-calls-per-round-trip density the batching guard is measured on, aggregated across the
-  // recent lane sessions. Kit-only for the same reason `time` is: it reads
-  // kit's own lane transcripts and means nothing in a consumer project.
-  "time:density": {
-    script: "scripts/time/time-density-cli.ts",
-    description: "Report tool calls per round trip across the recent lane sessions",
-    category: "AI tools",
-    reference: ["[--lanes <n>] [--path <dir>]", "maintainer", ["none"]],
-    is_kit_only: true
-  },
-  retrospective: {
-    script: "scripts/retrospective/retrospective-cli.ts",
-    description: "Aggregate a finished run's cost, review findings, observation ledger and events into one digest",
-    category: "AI tools",
-    reference: ["", "maintainer", ["none"]],
-    core_weight: core_budget.CORE_WEIGHTS.retrospective,
-    memory_mb: core_budget.MEMORY_MB.retrospective,
-    // Kit-only: it reads kit's own development run — the transcript store, the review ledger and the
-    // run event stream — so it means nothing in a consumer project and is dropped from a consumer's
-    // help, through the same declaration `josh time` uses for the same reason.
-    is_kit_only: true
-  },
-  "review:brief": {
-    script: "scripts/review/review-brief-cli.ts",
-    description: "Print the whole /code-review invocation: level, what the gate already proved, target (--level-only for the level alone)",
-    category: "AI tools",
-    reference: ["[--round <1|2>] | --level-only [--staged] [--json]", "automation", ["files"]]
-  },
-  "review:attest": {
-    script: "scripts/review/review-attest-cli.ts",
-    description: "Record, or verify, which checkout a /code-review actually read",
-    category: "AI tools",
-    reference: ["<nonce> | --check", "automation", ["files"]]
-  },
-  "review:round2": {
-    script: "scripts/review/review-round2-cli.ts",
-    description: "Say whether the second /code-review round is due, or may be skipped entirely",
-    category: "AI tools",
-    reference: ["[--round-1-closed] [--json]", "automation", ["none"]]
-  },
-  delegate: {
-    script: "scripts/delegation/delegation-cli.ts",
-    description: "Say whether a run step may go to a cheaper execution tier",
-    category: "AI tools",
-    reference: ["<step> | --list", "automation", ["none"]]
-  },
-  fanout: {
-    script: "scripts/delegation/fanout-cli.ts",
-    description: "Say whether proposed implementation units are file-disjoint, so they may run in parallel",
-    category: "AI tools",
-    reference: ["<unit-files> <unit-files> [<unit-files> \u2026]", "automation", ["none"]]
-  },
-  ...RUN_COMMANDS,
-  "repo:party": {
-    script: "scripts/discovery/repo-party-cli.ts",
-    description: "Say whether a repository is first-party or third-party by owner equality (computed, not judged)",
-    category: "AI tools",
-    reference: ["[<owner/repo>]", "automation", ["none"]]
-  },
-  "run:merge": {
-    script: "scripts/run/merge/run-merge-cli.ts",
-    description: "Collapse a backlogrun merge event into one call: confirm the child, do the post-merge steps, offer the next child",
-    category: "AI tools",
-    reference: [ISSUE_WITH_OPTIONS2, "automation", ["git", "network"]]
-  },
-  "run:review": {
-    script: "scripts/run/review/run-review-cli.ts",
-    description: "Start the gate in the background and print the /code-review brief in one call so the two overlap (--join to join the gate and check its verdict)",
-    category: "AI tools",
-    reference: ["[--join]", "automation", ["processes", "files"]]
-  },
-  // The post-merge sequence a run closed on, folded into one call: commit the
-  // observation ledger, read the completion citations and decide the release scope. `observations:flush`,
-  // `issue:cite` and `release:scope` were three round trips re-billing the run's full context each.
-  "run:tail": {
-    script: "scripts/run/run-tail-cli.ts",
-    description: "Close a run in one call: return to the default branch, commit the observation ledger, read the citations, decide the release scope",
-    category: "AI tools",
-    reference: ["[<issue> ...]", "automation", ["git", "network"]]
-  },
-  // The commit-to-report region a run ships a change on, folded into one call:
-  // the gate, the commit/push/PR (`git -y`), the CI-wait merge (`followup`) and the report bookkeeping
-  // (`run:tail`) were four round trips re-billing the run's full context each. It stops at the first
-  // failed step and names it, so the run reads only the step to fix.
-  ship: {
-    script: "scripts/run/ship/run-ship-cli.ts",
-    description: "Ship a change in one call: gate, commit/push/PR, the CI-wait merge and the report bookkeeping, stopping at the first failed step",
-    category: "AI tools",
-    reference: [
-      '"<title> #<N>" [<follow-up-N> ...] [--cite <N>] [--review] [--detach] [--body-file <path>] [--notify-message <text> | --notify-message-file <path>] | --log <N>',
-      "automation",
-      ["git", "network"]
-    ]
-  },
-  "run:event": {
-    script: "scripts/run/event/run-event-cli.ts",
-    description: "Append to, read or watch the run\u2019s append-only event stream (--append <kind> <text> | --from|--follow <n> | --watch [<n>] | --last)",
-    category: "AI tools",
-    reference: [
-      "--append <kind> <text> | --from|--follow <n> | --watch [<n>] | --last",
-      "automation",
-      ["files"]
-    ]
-  },
-  "run:report": {
-    script: "scripts/run/run-report-cli.ts",
-    description: "Generate the session-facing report for this invocation from the run\u2019s event stream (merges, parks, cuts) with the release tail \u2014 the same text josh notify sends",
-    category: "AI tools",
-    reference: ["", "automation", ["files", "network"]]
-  },
-  ...LANE_COMMANDS,
-  ...GUARD_COMMANDS,
-  "run:watcher:guard": {
-    script: "scripts/run/run-watcher-guard-cli.ts",
-    description: "Guard: exits non-zero when lane children are in-flight but the watcher has not pinged recently",
-    category: "AI tools",
-    reference: ["", "automation", ["none"]]
-  },
-  "run:stranded": {
-    script: "scripts/run/run-stranded-cli.ts",
-    // `.env` rather than the ambient environment: the strand notification needs the Telegram
-    // credentials, the same reason `run:wake` carries these flags.
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Report whether the run is stranded \u2014 owner gone, no successor holding the budget, and no supervisor watching",
-    category: "AI tools",
-    reference: ["", "automation", ["processes", "notifications"]]
-  },
-  ...SPLIT_COMMANDS,
-  "oracle:list": {
-    script: "scripts/rules/oracle-list-cli.ts",
-    description: "Print the decision oracles \u2014 commands that answer a rule question mechanically",
-    category: "AI tools",
-    reference: ["", "automation", ["none"]]
-  },
-  eval: {
-    script: "scripts/eval/eval-run.ts",
-    description: "Run the agent rule-compliance scenarios (real Claude sessions)",
-    category: "AI tools",
-    reference: ["[scenario...]", "maintainer", ["processes", "network"]],
-    // Kit-only: it replays kit's own distributed rules against real Claude sessions, so it means
-    // nothing in a consumer project and is dropped from a consumer's help.
-    is_kit_only: true
-  }
-};
-
-// scripts/josh/josh-commands-clone.ts
-var CLONE_COMMANDS = {
-  "clone:scan": {
-    script: "scripts/clone/clone-scan-cli.ts",
-    description: "Count code duplication across files and first-party repositories, printing each clone as file:line pairs",
-    category: "AI tools",
-    reference: ["", "automation", ["files"]]
-  }
-};
-
-// scripts/gate/gate-plan.ts
-import { availableParallelism as availableParallelism4 } from "node:os";
-
-// scripts/lib/status-icons.ts
-var FAIL_ICON = "\u2717";
-var PASS_ICON = "\u2714";
-var WARN_ICON = "\u26A0";
-var status_icons = { FAIL_ICON, PASS_ICON, WARN_ICON };
-
-// scripts/josh/josh-verdict.ts
-var { FAIL_ICON: FAIL_ICON2, PASS_ICON: PASS_ICON2, WARN_ICON: WARN_ICON2 } = status_icons;
-var GATE_SUBJECT = "verification gate";
-var GATE_PASSED_PREFIX = `${PASS_ICON2} ${GATE_SUBJECT} passed`;
-var GATE_FAILED_PREFIX = `${FAIL_ICON2} ${GATE_SUBJECT} failed`;
-var GATE_UNVERIFIED_PREFIX = `${WARN_ICON2} ${GATE_SUBJECT} not verified`;
-var PASSED_VERDICT = "passed";
-var FAILED_VERDICT = "failed";
-var UNVERIFIED_VERDICT = "unverified";
-function format_counts(counts) {
-  if (counts.skipped === 0) return `${String(counts.ran)} checks`;
-  return `${String(counts.ran)} ran, ${String(counts.skipped)} skipped`;
-}
-function format_gate_passed(counts, total) {
-  return `${GATE_PASSED_PREFIX} (${format_counts(counts)}) in ${total}.`;
-}
-function format_gate_unverified(skipped, total) {
-  return `${GATE_UNVERIFIED_PREFIX} (0 ran, ${String(skipped)} skipped) in ${total}.`;
-}
-function format_gate_failed(failed_labels, total) {
-  return `${GATE_FAILED_PREFIX}: ${failed_labels} (${total})`;
-}
-var GATE_OPENING_PREFIX = "plan: ";
-var GATE_OPENING_MARK = " checks at once";
-function is_gate_opening(line) {
-  const trimmed = line.trimStart();
-  return trimmed.startsWith(GATE_OPENING_PREFIX) && trimmed.includes(GATE_OPENING_MARK);
-}
-function read_verdict(line) {
-  const trimmed = line.trimStart();
-  if (trimmed.startsWith(GATE_FAILED_PREFIX)) return FAILED_VERDICT;
-  if (trimmed.startsWith(GATE_PASSED_PREFIX)) return PASSED_VERDICT;
-  if (trimmed.startsWith(GATE_UNVERIFIED_PREFIX)) return UNVERIFIED_VERDICT;
-  return void 0;
-}
-var josh_verdict = {
-  PASSED_VERDICT,
-  FAILED_VERDICT,
-  UNVERIFIED_VERDICT,
-  format_gate_passed,
-  format_gate_failed,
-  format_gate_unverified,
-  GATE_OPENING_MARK,
-  GATE_OPENING_PREFIX,
-  is_gate_opening,
-  read_verdict
-};
-
-// scripts/gate/gate-plan.ts
-var LINT_LABEL = "lint";
-var TYPE_CHECK_LABEL = "check";
-var UNIT_LABEL = "test:unit";
-var BEHAVIOR_LABEL = "behavior";
-var METRICS_LABEL = "metrics";
-var EXPORTS_LABEL = "exports";
-var WARNING_CHECKER_LABELS = [LINT_LABEL, TYPE_CHECK_LABEL];
-var STATIC_CHECKS = [
-  {
-    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,
-    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: BEHAVIOR_LABEL, target: BEHAVIOR_LABEL, reserved_cores: 0 },
-  // **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_LABEL, target: "exports:unused", reserved_cores: 0 },
-  // **The metrics ratchet is kit's own**: it holds kit's repository-wide
-  // totals to the merge-base's. It is one in-process eslint pass with only `max-lines` enabled, over
-  // in a few seconds, so it reserves no core for the reason the unused-member check above does not.
-  // 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, 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);
-}
-var RESERVED_CORES = STATIC_CHECKS.reduce(
-  (total, check) => total + check.reserved_cores,
-  0
-);
-var MEASURED_CORES = 11;
-var MIN_CONCURRENCY = 1;
-var MIN_SHARED_CORES = 1;
-function shared_cores(available_cores, concurrent_runs) {
-  const runs2 = Number.isFinite(concurrent_runs) ? Math.max(unit_worker_share.SOLO_RUNS, concurrent_runs) : unit_worker_share.SOLO_RUNS;
-  return Math.max(MIN_SHARED_CORES, Math.floor(available_cores / runs2));
-}
-function resolve_concurrency(available_cores, concurrent_runs = unit_worker_share.SOLO_RUNS, checks = GATE_CHECKS) {
-  const share = shared_cores(available_cores, concurrent_runs);
-  let admitted = 0;
-  let reserved = 0;
-  for (const check of checks) {
-    reserved += check.reserved_cores;
-    if (reserved > share) break;
-    admitted += 1;
-  }
-  return Math.max(MIN_CONCURRENCY, admitted);
-}
-function resolve_unit_worker_cap(available_cores, concurrent_runs = unit_worker_share.SOLO_RUNS) {
-  const share = unit_worker_share.resolve_unit_workers(available_cores, concurrent_runs);
-  if (share !== void 0) return share;
-  if (available_cores < MEASURED_CORES) return void 0;
-  return available_cores - RESERVED_CORES;
-}
-function solo_unit_weight(available_cores) {
-  return Math.max(0, available_cores - RESERVED_CORES);
-}
-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 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 = 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: unit_cap_for(checks, available_cores, concurrent_runs)
-  };
-}
-function bound_by_free(plan, available_cores, free_cores) {
-  if (!has_unit_check(plan.checks)) return plan;
-  const unit_worker_cap = unit_worker_share.cap_to_free(
-    plan.unit_worker_cap,
-    free_cores,
-    available_cores
-  );
-  return { ...plan, unit_worker_cap };
-}
-function format_machine(available_cores, concurrent_runs) {
-  const cores = `${String(available_cores)} cores`;
-  if (concurrent_runs <= unit_worker_share.SOLO_RUNS) return cores;
-  return `${cores}, ${String(concurrent_runs)} unit runs`;
-}
-function format_unit_cap(plan) {
-  if (!has_unit_check(plan.checks)) return `${UNIT_LABEL} elsewhere`;
-  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 = 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}`;
-  const machine = format_machine(available_cores, concurrent_runs);
-  return `${josh_verdict.GATE_OPENING_PREFIX}${width}, ${cap} (${machine})`;
-}
-var gate_plan = {
-  EXPORTS_LABEL,
-  GATE_CHECKS,
-  LINT_LABEL,
-  MEASURED_CORES,
-  METRICS_LABEL,
-  RESERVED_CORES,
-  STATIC_CHECKS,
-  TYPE_CHECK_LABEL,
-  UNIT_LABEL,
-  WARNING_CHECKER_LABELS,
-  bound_by_free,
-  check_memory,
-  check_weight,
-  direct_unit_memory,
-  direct_unit_weight,
-  format_gate_plan,
-  format_machine,
-  has_unit_check,
-  plan_of,
-  resolve_concurrency,
-  resolve_gate_plan,
-  resolve_unit_worker_cap,
-  select_gate_checks
-};
-
-// scripts/josh/josh-commands-development.ts
-var FILE_ARGUMENTS = "[files...]";
-var REQUIRED_FILE_ARGUMENTS = "<files...>";
-var FILTER_ARGUMENTS = "[filters...]";
-var MATCH_ARGUMENTS = "[--match]";
-var PATH_ARGUMENTS = "<path...>";
-var DEV_COMMANDS = {
-  "pr:classification": {
-    script: "scripts/ci/pr-classification.ts",
-    description: "Require one release classification on a pull request",
-    category: "Development",
-    reference: ["", "automation", ["none"]]
-  },
-  [GATE_COMMAND2]: {
-    script: "scripts/gate/verification-gate.ts",
-    description: "Run lint, type check, spell check and unit tests concurrently",
-    category: "Development",
-    reference: ["[--verbose|--force|--no-unit]", "developer", ["files", "processes"]]
-  },
-  lint: {
-    script: "scripts/lint/lint-parallel.ts",
-    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,
-    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,
-    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,
-    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,
-    memory_mb: core_budget.MEMORY_MB.eslint_scan
-  },
-  bytes: {
-    script: "scripts/lines/bytes-command.ts",
-    description: "Print an agent-read document's byte size against its ceiling and the headroom left",
-    category: "Development",
-    reference: [REQUIRED_FILE_ARGUMENTS, "developer", ["none"]]
-  },
-  "rule:value": {
-    script: "scripts/rules/rule-value-cli.ts",
-    description: "Print each delivered rule's unaided compliance \u2014 runs reached, kept rate, refusals",
-    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)",
-    category: "Development",
-    reference: ["", "developer", ["files", "processes"]]
-  },
-  "format:edited": {
-    script: "scripts/hooks/format-edited-cli.ts",
-    description: "Claude Code hook: format the file just edited (reads the tool call on stdin)",
-    category: "Development",
-    reference: ["", "automation", ["files", "processes"]]
-  },
-  "batch:guard": {
-    script: "scripts/hooks/batch-guard.ts",
-    description: "Claude Code hook: refuse a third consecutive single-call turn (reads the tool call on stdin)",
-    category: "Development",
-    reference: ["", "automation", ["none"]]
-    // **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, 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": {
-    script: "scripts/hooks/pretool-guard-cli.ts",
-    description: "Claude Code hook: the batch, investigation and rule guards in one process (reads the tool call on stdin)",
-    category: "Development",
-    reference: ["", "automation", ["none"]]
-    // **No `tsx_arguments`, deliberately**, the same as `batch:guard` above: this is the one
-    // PreToolUse hook consumers run before every guarded call, so it must stay eligible for
-    // in-process dispatch rather than pay a second tsx start. Each guard it composes loads `.env`
-    // through the shared loader.
-  },
-  "stop:guard": {
-    script: "scripts/hooks/stop-guard.ts",
-    description: "Claude Code Stop hook: send the hold notify, release the hold and print the issue citations itself; block on the rules that need the model (reads the Stop payload on stdin)",
-    category: "Development",
-    reference: ["", "automation", ["none"]]
-    // **No `tsx_arguments`, deliberately**, the same as `pretool:guard` above: this runs at every
-    // turn end, so it must stay eligible for in-process dispatch rather than pay a second tsx start.
-    // It loads `.env` through the shared `hook-decision.ts` loader.
-  },
-  "session:lang": {
-    script: "scripts/josh/session-language-cli.ts",
-    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
-    // `UserPromptSubmit`, so it must stay eligible for in-process dispatch rather than pay a second
-    // tsx start each turn. It calls `process.loadEnvFile` itself through the shared loader.
-  },
-  "codex:hook-adapter": {
-    script: "scripts/hooks/codex-hook-adapter.ts",
-    description: "Codex hook: run the pretool or posttool guard on a Codex payload (reads the tool call on stdin)",
-    category: "Development",
-    reference: ["<pretool|posttool>", "automation", ["none"]]
-    // The live-source fallback `scripts/hooks/run-hook.sh` derives from the `codex-hook-adapter`
-    // bundle name. **No `tsx_arguments`**, the same as `pretool:guard`
-    // above: it runs before every guarded Codex call.
-  },
-  "cspell:dot": {
-    script: "scripts/lint/cspell-cached.ts",
-    description: "Run spell check including dotfiles",
-    category: "Development",
-    reference: ["", "developer", ["processes"]],
-    core_weight: core_budget.CORE_WEIGHTS.spell_check,
-    memory_mb: core_budget.MEMORY_MB.spell_check
-  },
-  behavior: {
-    script: "scripts/behavior/behavior-cli.ts",
-    description: "Check the current run's recorded transcript against the behavior assertions (no model call)",
-    category: "Development",
-    reference: ["", "developer", ["files"]]
-  },
-  "exports:unused": {
-    script: "scripts/exports/unused-members-cli.ts",
-    description: "Report exported namespace members nothing reads (kit only; a consumer project skips it)",
-    category: "Development",
-    reference: ["", "developer", ["none"]]
-  },
-  "test:unit": {
-    script: "scripts/test/test-unit-guard.ts",
-    description: "Run unit tests with Vitest (without Vitest: a basic project runs its own test script, others skip; fails when Vitest has no tests)",
-    category: "Development",
-    reference: [FILTER_ARGUMENTS, "developer", ["processes"]],
-    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,
-    memory_mb: gate_plan.direct_unit_memory
-  },
-  "test:declared": {
-    script: "scripts/test/test-declared.ts",
-    description: "Report whether the working-tree change needs a test (required/exempt/satisfied); --match checks Step 0 declarations on stdin",
-    category: "Development",
-    reference: [MATCH_ARGUMENTS, "developer", ["processes"]]
-  },
-  "test:red": {
-    script: "scripts/test/test-red.ts",
-    description: "Run the changed unit tests against the pre-fix tree (merge-base worktree) and report red/green/no-test/test-only",
-    category: "Development",
-    reference: ["", "developer", ["git", "processes"]]
-  },
-  disposition: {
-    script: "scripts/review/disposition-cli.ts",
-    description: "Say whether a review finding reaches a runtime path (runtime) or is inert (non-runtime)",
-    category: "AI tools",
-    reference: [PATH_ARGUMENTS, "automation", ["none"]]
-  },
-  "e2e:retry-check": {
-    script: "scripts/test/e2e-retry-check.ts",
-    description: "Report whether the preview server crashed during a failed E2E attempt (CI)",
-    category: "Development",
-    reference: ["", "automation", ["none"]]
-  },
-  "test:e2e": {
-    script: "scripts/test/test-e2e-guard.ts",
-    description: "Run E2E tests with Playwright (skips when absent or no e2e files)",
-    category: "Development",
-    reference: [FILTER_ARGUMENTS, "developer", ["processes"]]
-  },
-  test: {
-    shell: ["sh", "-c", "pnpm josh test:unit && pnpm josh test:e2e"],
-    description: "Run unit and E2E tests",
-    category: "Development",
-    reference: ["", "developer", ["processes"]],
-    argument_targets: ["test:unit", "test:e2e"]
-  },
-  check: {
-    script: "scripts/gate/type-check-command.ts",
-    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,
-    memory_mb: core_budget.MEMORY_MB.type_check
-  },
-  port: {
-    script: "scripts/ports/port-command.ts",
-    description: "Print the PORT_SEED-resolved dev or preview port",
-    category: "Development",
-    reference: ["<dev|preview>", "developer", ["none"]]
-  }
-};
-
-// scripts/josh/josh-commands-hooks.ts
-var HOOKS_COMMANDS = {
-  "prevent-main-commit": {
-    script: "scripts/hooks/prevent-main-commit.ts",
-    description: "Git hook: block commits to main",
-    category: "Git hooks",
-    reference: ["", "automation", ["none"]]
-  },
-  "check-commit-message": {
-    script: "scripts/hooks/check-commit-message.ts",
-    description: "Git hook: validate commit message",
-    category: "Git hooks",
-    reference: ["[<message-file>]", "automation", ["none"]]
-  },
-  "secretlint-scan": {
-    script: "scripts/security/secretlint-scan.ts",
-    description: "Git hook: scan staged files for secrets",
-    category: "Git hooks",
-    reference: ["[paths...]", "automation", ["none"]]
-  },
-  "pre-commit-lint": {
-    script: "scripts/hooks/pre-commit-lint.ts",
-    description: "Git hook: run cspell, prettier or eslint over staged files from a content cache",
-    category: "Git hooks",
-    reference: ["<cspell|prettier|eslint> [paths...]", "automation", ["files"]]
-  },
-  "pre-push-unit": {
-    script: "scripts/hooks/pre-push-unit.ts",
-    description: "Git hook: run unit tests, reusing a green gate recorded on the pushed tree",
-    category: "Git hooks",
-    reference: ["", "automation", ["processes"]]
-  },
-  "reserved-run": {
-    script: "scripts/hooks/reserved-run.ts",
-    description: "Git hook: run a command while holding a place in the machine-wide core budget",
-    category: "Git hooks",
-    reference: ["<weight> -- <command...>", "automation", ["processes"]]
-  },
-  "pre-commit-type-check": {
-    script: "scripts/gate/pre-commit-type-check.ts",
-    description: "Git hook: type-check, reusing a green gate recorded on the committed tree",
-    category: "Git hooks",
-    reference: ["", "automation", ["processes"]]
-  }
-};
-
-// scripts/josh/josh-commands-lint.ts
-var LINT_COMMANDS = {
-  "issue:lint": {
-    script: "scripts/issue/issue-lint-cli.ts",
-    description: "Check an issue body file for the template's required headings",
-    category: "AI tools",
-    reference: ["<path>", "automation", ["files"]]
-  },
-  "issue:backlinks": {
-    script: "scripts/issue/issue-backlinks-cli.ts",
-    description: "Classify an origin issue\u2019s upstream backlinks: ok, missing, or wrong heading",
-    category: "AI tools",
-    reference: ["<issue>", "automation", ["network"]]
-  },
-  "report:lint": {
-    script: "scripts/report/report-lint-cli.ts",
-    description: "Check a two-layer work summary on stdin against its mechanical format rules",
-    category: "AI tools",
-    reference: ["(reads stdin)", "automation", ["none"]]
-  },
-  cases: {
-    script: "scripts/cases/cases-cli.ts",
-    description: "Read changed paths and print the I/O boundaries crossed and their mandatory abnormal cases: network | process | fs | none",
-    category: "AI tools",
-    reference: ["<path...>", "automation", ["files"]]
-  }
-};
-
-// scripts/josh/josh-commands-maintenance.ts
-var MAINTENANCE_COMMANDS = {
-  doctor: {
-    script: "scripts/doctor/doctor.ts",
-    description: "Diagnose PATH shadowing of the global josh and show the discovered repository map (--fix reclaims a stale shim)",
-    category: "Maintenance",
-    reference: ["[--fix]", "developer", ["files"]],
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS
-  },
-  "ruleset:check": {
-    script: "scripts/repo/ruleset-check-cli.ts",
-    description: "Check that the default branch requires every status check kit's workflows report (--apply adds the missing ones)",
-    category: "Maintenance",
-    reference: ["[--apply]", "maintainer", ["network"]]
-  },
-  overrides: {
-    script: "scripts/overrides/overrides-check.ts",
-    description: "Check pnpm overrides for drift",
-    category: "Maintenance",
-    reference: ["[--save]", "developer", ["files"]]
-  },
-  audit: {
-    script: "scripts/security/security-audit.ts",
-    description: "Run security audit",
-    category: "Maintenance",
-    reference: ["", "developer", ["processes"]]
-  },
-  "audit:provision": {
-    script: "scripts/security/security-audit-provision.ts",
-    description: "Install the pinned osv-scanner when the audit cannot find one (no-op if present)",
-    category: "Maintenance",
-    reference: ["", "automation", ["files", "network"]]
-  },
-  "reconcile-templates": {
-    script: "scripts/sync/reconcile-templates.ts",
-    description: "Record template source hashes (--check to verify drift)",
-    category: "Maintenance",
-    reference: ["", "maintainer", ["files"]]
-  },
-  latest: {
-    shell: [
-      "sh",
-      "-c",
-      "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 dependencies, run security audit, then update pnpm",
-    category: "Maintenance",
-    reference: ["", "developer", ["files", "network", "processes"]],
-    argument_targets: ["latest:corepack", "latest:update", "audit"]
-  },
-  "latest:scope": {
-    script: "scripts/version/latest-scope-cli.ts",
-    description: "Say whether this run has to update dependencies, from when josh latest last finished (--record notes a run)",
-    category: "Maintenance",
-    reference: ["[--record] [--json]", "automation", ["files"]],
-    // `JOSH_LATEST_MAX_AGE_HOURS` is documented as a project setting, so it has to be readable
-    // where the project keeps its settings — a variable that only works when exported from the
-    // shell is one a user follows the documentation for and gets the default from, silently.
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS
-  },
-  "latest:guard": {
-    script: "scripts/version/latest-lane-guard.ts",
-    description: "Refuse josh latest inside a lane (the update stamp is keyed to the project root)",
-    category: "Maintenance",
-    reference: ["", "automation", ["files"]]
-  },
-  "latest:corepack": {
-    script: "scripts/version/latest-corepack.ts",
-    description: "Update pnpm on the current major while preserving the integrity pin",
-    category: "Maintenance",
-    reference: ["", "developer", ["files", "network"]]
-  },
-  "latest:update": {
-    script: "scripts/version/latest-update.ts",
-    description: "Update all dependencies to latest",
-    category: "Maintenance",
-    reference: ["", "developer", ["files", "network"]],
-    // `JOSH_PLAYWRIGHT_BROWSERS` widens the browsers a Playwright bump installs, and a project
-    // keeps that setting in its `.env`.
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS
-  }
-};
-
-// scripts/josh/josh-commands-project.ts
-var PROFILE_ARGUMENTS = "[--profile basic|full]";
-var PROJECT_COMMANDS = {
-  profile: {
-    script: "scripts/init/project-profile-cli.ts",
-    description: "Show the project profile and the reason for it",
-    category: "Project",
-    reference: [PROFILE_ARGUMENTS, "developer", ["files"]]
-  },
-  start: {
-    script: "scripts/init/start.ts",
-    description: "Set a project up for the GitHub Issue workflow, from git init to the setup PR",
-    category: "Project",
-    reference: [
-      `${PROFILE_ARGUMENTS} [--yes] [--github] [--public] [--dry-run] [--init-command <command>] [--push-preflight-command <command>]`,
-      "developer",
-      ["files", "git", "network", "processes"]
-    ]
-  },
-  "dogfood:commit": {
-    script: "scripts/dogfood/dogfood-commit-cli.ts",
-    description: "Make the first commit of a dogfood run's own kit-test-* project",
-    category: "Project",
-    reference: ["<dir>", "automation", ["files", "git"]],
-    is_kit_only: true
-  },
-  "fresh:run": {
-    script: "scripts/fresh-machine/fresh-machine-cli.ts",
-    description: "Run an install scenario in a Docker container of a machine with nothing installed, and keep the log",
-    category: "Project",
-    reference: [
-      "<pattern> | --spec <file.json> [--package-version <version>] [--log-dir <dir>] [--rebuild] | --list",
-      "maintainer",
-      ["files", "network", "processes"]
-    ]
-  },
-  "auth:setup": {
-    script: "scripts/auth/auth-setup-cli.ts",
-    description: "Save the long-lived Claude Code token `claude setup-token` prints in the macOS keychain, for josh fresh:run",
-    category: "Project",
-    reference: ["[--check]", "maintainer", ["network", "processes"]]
-  },
-  init: {
-    script: "scripts/init/init.ts",
-    description: "Initialize config in a new project",
-    category: "Project",
-    reference: [
-      `${PROFILE_ARGUMENTS} [--no-install] [--dry-run]`,
-      "developer",
-      ["files", "network", "processes"]
-    ]
-  },
-  sync: {
-    script: "scripts/sync/sync.ts",
-    description: "Sync config files",
-    category: "Project",
-    reference: ["", "developer", ["files"]]
-  },
-  uninstall: {
-    script: "scripts/uninstall/uninstall.ts",
-    description: "Remove what kit added to a project and list what is left to review by hand",
-    category: "Project",
-    reference: [`${PROFILE_ARGUMENTS} [--yes]`, "developer", ["files", "processes"]]
-  },
-  "registry:migrate": {
-    script: "scripts/registry-migration/migrate.ts",
-    description: "Migrate a project from GitHub Packages to public npm",
-    category: "Project",
-    reference: ["", "developer", ["files", "network", "processes"]]
-  },
-  "sync:scope": {
-    script: "scripts/sync/managed-config-scope-cli.ts",
-    description: "Say whether this change touches a file josh sync distributes",
-    category: "Project",
-    reference: ["[--staged] [--json]", "automation", ["none"]]
-  },
-  "sonar:hotspots": {
-    script: "scripts/sonar/sonar-hotspots-cli.ts",
-    description: "Fetch SonarCloud hotspots on a pull request and print each one's Step B disposition",
-    category: "Project",
-    reference: ["<PR>", "automation", ["network"]]
-  },
-  "sonar:new-code": {
-    script: "scripts/sonar/sonar-new-code-cli.ts",
-    description: "Fail when a pull request adds any new SonarCloud issue or duplicated block",
-    category: "Project",
-    reference: ["<PR>", "automation", ["network"]]
-  },
-  "ui:routes": {
-    script: "scripts/ui/ui-routes-cli.ts",
-    description: "List the screenshot-target routes the current change touches",
-    category: "Project",
-    reference: ["[--staged]", "automation", ["none"]]
-  },
-  propagate: {
-    script: "scripts/propagate/propagate.ts",
-    description: "Carry the published release into every consumer repository next to this one",
-    category: "Project",
-    reference: [
-      "[--dry-run] [--skip-publish-wait] [--target <repo>]",
-      "maintainer",
-      ["files", "network"]
-    ]
-  },
-  adopt: {
-    script: "scripts/adopt/adopt.ts",
-    description: "Upgrade the @joshuafolkken toolkits and other dependencies here, open the PR",
-    category: "Project",
-    reference: ["[--dry-run]", "developer", ["files", "git", "network", "processes"]]
-  }
-};
-
-// scripts/josh/josh-commands-versioning.ts
-var VERSIONING_COMMANDS = {
-  bump: {
-    script: "scripts/version/bump-version.ts",
-    description: "Bump package version",
-    category: "Versioning",
-    reference: ["[major|minor|patch]", "maintainer", ["files"]]
-  },
-  version: {
-    script: "scripts/version/version-check.ts",
-    description: "Show kit versions; --upgrade updates the global and project install",
-    category: "Versioning",
-    reference: ["[--upgrade]", "developer", ["files", "network", "processes"]]
-  },
-  // A `script` entry, not a shell one: script paths resolve against the kit package root, so this
-  // keeps working from a consumer repo where the file lives under node_modules. The registry
-  // probes need NODE_AUTH_TOKEN for any `@joshuafolkken/*` dependency; `josh latest` exports it
-  // before chaining here, exactly as it already does for `latest:update`.
-  ranges: {
-    script: "scripts/version/publishable-range-check.ts",
-    description: "Check that every published dependency range still resolves for a consumer and no peer range falls below an installed toolkit",
-    category: "Versioning",
-    reference: ["", "developer", ["network"]]
-  },
-  // 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: ["[--dry-run]", "maintainer", ["git", "network", "release"]]
-  },
-  // 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": {
-    script: "scripts/release/release-scope-cli.ts",
-    description: "Say whether a release is owed, from the unreleased merges on main",
-    category: "Versioning",
-    reference: ["[--json]", "automation", ["none"]]
-  },
-  // 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",
-    category: "Versioning",
-    reference: ["", "automation", ["network", "release"]]
-  }
-};
-
-// scripts/josh/josh-commands-workflow.ts
-var GIT_WORKFLOW_SCRIPT = "scripts/git/git-workflow.ts";
-var GIT_MESSAGE_ARGUMENTS = "[-y] <message>";
-var WORKFLOW_COMMANDS = {
-  git: {
-    script: GIT_WORKFLOW_SCRIPT,
-    description: "Git workflow helper",
-    category: "Workflow",
-    reference: [GIT_MESSAGE_ARGUMENTS, "developer", ["git", "network"]]
-  },
-  pr: {
-    script: GIT_WORKFLOW_SCRIPT,
-    description: "Create PR only (skip commit and push)",
-    category: "Workflow",
-    // Not `GIT_MESSAGE_ARGUMENTS`: `-y` is already in the default arguments below, so advertising
-    // it would document a flag that cannot change what this command does.
-    reference: ["<message>", "developer", ["network"]],
-    default_script_arguments: ["-y", "--skip-commit", "--skip-push"]
-  },
-  // **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.
-  //
-  // **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",
-    category: "Workflow",
-    reference: [
-      "<title> [--notify-message <text>]",
-      "automation",
-      ["git", "network", "notifications"]
-    ],
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS
-  },
-  notify: {
-    script: "scripts/notify/telegram-test.ts",
-    description: "Send Telegram notification",
-    category: "Workflow",
-    reference: [
-      "[--task-type <type>] [--body <text> | --body-file <path>] [--issue-url <url>] [--pr-url <url>] [--issue-title <text>] [--repo-name <name>] [--recommended <text>] [--alternative <text>]...",
-      "automation",
-      ["notifications"]
-    ],
-    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS
-  },
-  // 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",
-    description: "Commit the observation ledger as a pull request of its own, and merge it",
-    category: "Workflow",
-    reference: ["", "automation", ["git", "network"]]
-  },
-  // 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": {
-    script: "scripts/review/review-record-cli.ts",
-    description: "Record a review round\u2019s findings, or check a round was recorded",
-    category: "Workflow",
-    reference: [
-      "--issue <N> [--comment] [<category>:<severity>:<file> ...] | --check --issue <N>",
-      "automation",
-      ["files", "network"]
-    ]
-  },
-  // 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",
-    description: "Count review findings by category from the observation ledger",
-    category: "Workflow",
-    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.
-  "measure:rerun": {
-    script: "scripts/issue/measure-rerun-cli.ts",
-    description: "Re-run a merged issue\u2019s baseline command and print the before/after pair",
-    category: "Workflow",
-    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.
-  "main:sync": {
-    script: "scripts/git/main-sync.ts",
-    description: "Checkout default branch, pull latest, and prune merged remote-gone branches (refuses inside a lane)",
-    category: "Workflow",
-    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: a bare `git pull` aborts with `Need to specify how to reconcile
-  // divergent branches` on exactly the diverged branch the command exists for.
-  //
-  // **It declares no core weight, by measurement** (joshuafolkken/kit#3944): its own work is git, and
-  // the catalog it may regenerate took 0.6s of CPU. The heavy processes seen beside it are commit
-  // hooks — its regenerated catalog's commit runs them — which reserve themselves, and a weight here
-  // would set the held mark they inherit, folding the parallel hook tools into this one place.
-  "main:merge": {
-    script: "scripts/git/main-merge.ts",
-    description: "Merge origin default branch into the current branch",
-    category: "Workflow",
-    reference: ["", "developer", ["git", "network"]]
-  }
-};
-
-// scripts/josh/josh-command-map.ts
-var COMMAND_MAP = {
-  ...DEV_COMMANDS,
-  ...PROJECT_COMMANDS,
-  ...WORKFLOW_COMMANDS,
-  ...VERSIONING_COMMANDS,
-  ...MAINTENANCE_COMMANDS,
-  ...HOOKS_COMMANDS,
-  ...AI_COMMANDS,
-  ...LINT_COMMANDS,
-  ...CLONE_COMMANDS
-};
-var ALIASES = {
-  ga: "gate",
-  l: "lint",
-  lr: "lint:related",
-  ln: "lines",
-  by: "bytes",
-  mt: "metrics",
-  f: "format",
-  sd: "cspell:dot",
-  bh: "behavior",
-  eu: "exports:unused",
-  t: "test",
-  tu: "test:unit",
-  tr: "test:related",
-  td: "test:declared",
-  trd: "test:red",
-  te: "test:e2e",
-  c: "check",
-  pt: "port",
-  i: "init",
-  pf: "profile",
-  st: "start",
-  sy: "sync",
-  un: "uninstall",
-  rmi: "registry:migrate",
-  g: "git",
-  gp: "pr",
-  ms: "main:sync",
-  mm: "main:merge",
-  bp: "bump",
-  re: "release",
-  v: "version",
-  r: "ranges",
-  dr: "doctor",
-  rc: "ruleset:check",
-  pg: "propagate",
-  ad: "adopt",
-  ov: "overrides",
-  a: "audit",
-  rt: "reconcile-templates",
-  u: "latest",
-  lc: "latest:corepack",
-  lu: "latest:update",
-  tm: "time",
-  tmd: "time:density",
-  rtr: "retrospective",
-  ca: "cost:audit",
-  rvf: "review:findings",
-  ruv: "rule:value",
-  ev: "eval",
-  fr: "fresh:run",
-  as: "auth:setup",
-  lsm: "lane:sample",
-  lst: "lane:stats",
-  lli: "lane:limit",
-  lrs: "lane:restart",
-  lwd: "lane:withdraw",
-  blr: "backlogrun"
-};
-function canonical_command(name) {
-  if (!Object.hasOwn(ALIASES, name)) return name;
-  return ALIASES[name] ?? name;
-}
-
-// scripts/time-runtime/time-shell.ts
-var BASH_SEPARATOR = ": ";
-var WHITESPACE_PATTERN = /\s+/u;
-var SEGMENT_PATTERN = /&&|\|\||;|\|/u;
-var PIPE_PATTERN = /(?<!\|)\|(?!\|)/u;
-var CHAIN_PATTERN = /&&|\|\||;|\n/u;
-var QUOTED_SPAN_PATTERN = /\\[\s\S]|'[^']*'|"(?:\\[\s\S]|[^"\\])*"/gu;
-var HEREDOC_MARKER = /(?<!<)<<-?\s*(['"]?)(\w+)\1/u;
-var HEREDOC_DELIMITER_GROUP = 2;
-var LINE_BREAK = "\n";
-var PIPEFAIL_PATTERN = /\bset\s+-[a-z]*o\s+pipefail\b/u;
-var COMMAND_WORD_PATTERN = /^[\w./@:+][\w./@:+-]*$/u;
-var ASSIGNMENT_PATTERN = /^\w+=/u;
-var SUBSHELL_OPENER = "$(";
-var FLAG_PREFIX = "-";
-var WRAPPER_COMMANDS = /* @__PURE__ */ new Set(["time", "env", "sudo"]);
-var NAVIGATION_COMMANDS = /* @__PURE__ */ new Set(["cd", "pushd", "popd", "export", "source", "set", "."]);
-var JOSH_PATTERN = /^(?:pnpm\s+(?:exec\s+)?)?josh\s+([a-z][\w:-]*)/u;
-var JOSH_PREFIX = "josh ";
-var COMMAND_KEY2 = "command";
-function bash_command(input) {
-  if (!json_value.is_record(input)) return "";
-  const command = input[COMMAND_KEY2];
-  return typeof command === "string" ? command : "";
-}
-function is_skippable(word) {
-  if (word.startsWith(FLAG_PREFIX)) return true;
-  return ASSIGNMENT_PATTERN.test(word) || WRAPPER_COMMANDS.has(word);
-}
-function command_words(segment) {
-  const words = segment.replaceAll(SUBSHELL_OPENER, " ").trim().split(WHITESPACE_PATTERN);
-  const start = words.findIndex((word) => !is_skippable(word));
-  return start === -1 ? [] : words.slice(start);
-}
-function segment_command(segment) {
-  const [head] = command_words(segment);
-  if (head === void 0 || NAVIGATION_COMMANDS.has(head)) return "";
-  return COMMAND_WORD_PATTERN.test(head) ? head : "";
-}
-function command_segment(command) {
-  return command.split(SEGMENT_PATTERN).find((segment) => segment_command(segment) !== "") ?? "";
-}
-function leading_word(command) {
-  return segment_command(command_segment(command));
-}
-function open_heredoc(line, kept) {
-  kept.push(line.replace(HEREDOC_MARKER, " "));
-  return HEREDOC_MARKER.exec(line)?.[HEREDOC_DELIMITER_GROUP];
-}
-function close_heredoc(line, delimiter) {
-  return line.trim() === delimiter ? void 0 : delimiter;
-}
-function without_heredoc_bodies(command) {
-  const kept = [];
-  const body = {};
-  for (const line of command.split(LINE_BREAK)) {
-    body.delimiter = body.delimiter === void 0 ? open_heredoc(line, kept) : close_heredoc(line, body.delimiter);
-  }
-  return kept.join(LINE_BREAK);
-}
-function unquoted(command) {
-  return without_heredoc_bodies(command).replaceAll(QUOTED_SPAN_PATTERN, " ");
-}
-function blanked(command) {
-  if (HEREDOC_MARKER.test(command)) return void 0;
-  return command.replaceAll(QUOTED_SPAN_PATTERN, (span) => " ".repeat(span.length));
-}
-function discarded_commands(command) {
-  const plain = unquoted(command);
-  if (PIPEFAIL_PATTERN.test(plain)) return [];
-  return plain.split(PIPE_PATTERN).slice(0, -1).map((segment) => segment.split(CHAIN_PATTERN).at(-1) ?? "");
-}
-function bash_label(command) {
-  const word = leading_word(command);
-  return word === "" ? cost_blocks.BASH_TOOL : `${cost_blocks.BASH_TOOL}${BASH_SEPARATOR}${word}`;
-}
-function josh_command_of_segment(segment) {
-  const name = JOSH_PATTERN.exec(command_words(segment).join(" "))?.[1];
-  return name === void 0 ? "" : `${JOSH_PREFIX}${canonical_command(name)}`;
-}
-function josh_command_of(command) {
-  return josh_command_of_segment(command_segment(command));
-}
-function josh_commands_of(command) {
-  return unquoted(command).split(SEGMENT_PATTERN).map((segment) => josh_command_of_segment(segment)).filter((name) => name !== "");
-}
-var REDIRECTION_CHARACTERS = ["<", ">"];
-function is_redirection(word) {
-  return REDIRECTION_CHARACTERS.some((character) => word.includes(character));
-}
-function ends_in_redirection(word) {
-  return REDIRECTION_CHARACTERS.some((character) => word.endsWith(character));
-}
-function drop_redirections(words) {
-  const kept = [];
-  let is_target2 = false;
-  for (const word of words) {
-    const is_dropped = is_target2 || is_redirection(word);
-    is_target2 = ends_in_redirection(word);
-    if (!is_dropped) kept.push(word);
-  }
-  return kept;
-}
-function josh_arguments_of_segment(segment) {
-  const text = command_words(segment).join(" ");
-  const match = JOSH_PATTERN.exec(text);
-  if (match === null) return [];
-  const words = text.slice(match[0].length).split(WHITESPACE_PATTERN).filter((word) => word !== "");
-  return drop_redirections(words);
-}
-function josh_arguments(command) {
-  return josh_arguments_of_segment(command_segment(command));
-}
-function josh_signature_of_segment(segment) {
-  const name = josh_command_of_segment(segment);
-  if (name === "") return "";
-  return [name, ...josh_arguments_of_segment(segment)].join(" ");
-}
-function josh_signatures_of(command) {
-  return unquoted(command).split(SEGMENT_PATTERN).map((segment) => josh_signature_of_segment(segment)).filter((signature) => signature !== "");
-}
-var time_shell = {
-  JOSH_PREFIX,
-  bash_command,
-  bash_label,
-  blanked,
-  command_segment,
-  discarded_commands,
-  josh_arguments,
-  josh_command_of,
-  josh_commands_of,
-  josh_signatures_of,
-  leading_word,
-  unquoted
-};
-
-// scripts/time-runtime/time-background.ts
-var NO_BACKGROUND = "";
-var NO_FINISH = 0;
-var LAUNCH_PATTERN = /(?:running in background with ID:|moved to the background \(ID:)\s*([\w-]+)/iu;
-var AGENT_LAUNCH_PATTERN = /^Async agent launched[\s\S]*?\bagentId:\s*([\w-]+)/u;
-var FINISH_PATTERN = /^<task-notification>[\s\S]*?<task-id>([\w-]+)<\/task-id>/u;
-var OUTPUT_PATTERN = /tasks\/([\w-]+)\.output/u;
-var BASH_ID_KEY = "bash_id";
-function read_id(command) {
-  return OUTPUT_PATTERN.exec(time_shell.unquoted(command))?.[1] ?? NO_BACKGROUND;
-}
-function read_id_of(input) {
-  if (!json_value.is_record(input)) return NO_BACKGROUND;
-  const id = input[BASH_ID_KEY];
-  return typeof id === "string" ? id : read_id(time_shell.bash_command(input));
-}
-function launch_id(text) {
-  return LAUNCH_PATTERN.exec(text)?.[1] ?? NO_BACKGROUND;
-}
-function agent_launch_id(text) {
-  return AGENT_LAUNCH_PATTERN.exec(text)?.[1] ?? NO_BACKGROUND;
-}
-function finished_id(text) {
-  return FINISH_PATTERN.exec(text)?.[1] ?? NO_BACKGROUND;
-}
-function finished_at(lines) {
-  const notices = lines.filter((one) => one.finished_background !== NO_BACKGROUND).toSorted((left, right) => right.timestamp_ms - left.timestamp_ms);
-  return new Map(notices.map((one) => [one.finished_background, one.timestamp_ms]));
-}
-function started_ms(span) {
-  return span.ended_ms - span.duration_ms;
-}
-function read_end_ms(spans, run) {
-  if (run.background_ended_ms === NO_FINISH) return void 0;
-  const found = spans.find(
-    (span) => span.reads_background === run.background_id && span.ended_ms >= run.background_ended_ms
-  );
-  return found?.ended_ms;
-}
-function to_run(spans, launch) {
-  const read = read_end_ms(spans, launch);
-  return {
-    id: launch.background_id,
-    josh_command: launch.josh_command,
-    started_ms: started_ms(launch),
-    ended_ms: read ?? launch.ended_ms,
-    is_read: read !== void 0
-  };
-}
-function is_launch(span) {
-  return span.background_id !== NO_BACKGROUND;
-}
-function runs(spans) {
-  return spans.filter((span) => is_launch(span)).map((launch) => to_run(spans, launch));
-}
-function is_within(span, run) {
-  const start = started_ms(span);
-  return start >= run.started_ms && start < run.ended_ms;
-}
-function latest_first(all) {
-  return all.filter((run) => run.is_read).toSorted((left, right) => right.started_ms - left.started_ms);
-}
-function own_run(span, all) {
-  return is_launch(span) ? all.find((run) => run.id === span.background_id) : void 0;
-}
-function placed(span, all, ordered) {
-  const own = own_run(span, all);
-  const run = own ?? ordered.find((one) => is_within(span, one));
-  if (run === void 0) return span;
-  const beside = { ...span, background_command: run.josh_command };
-  return own === void 0 ? beside : { ...beside, own_duration_ms: own.ended_ms - own.started_ms };
-}
-function positioned(spans) {
-  const all = runs(spans);
-  if (all.length === 0) return [...spans];
-  const ordered = latest_first(all);
-  return spans.map((span) => placed(span, all, ordered));
-}
-function unread_phases(spans) {
-  const names = runs(spans).filter((run) => !run.is_read).map((run) => COMMAND_PHASES.get(run.josh_command));
-  return new Set(names.filter((phase) => phase !== void 0));
-}
-var time_background = {
-  NO_BACKGROUND,
-  NO_FINISH,
-  launch_id,
-  agent_launch_id,
-  finished_id,
-  finished_at,
-  read_id,
-  read_id_of,
-  runs,
-  positioned,
-  unread_phases
-};
-
-// scripts/gh/git-pr-checks-parse.ts
-var CHECK_STATUS_PASS = "pass";
-var CHECK_STATUS_PENDING = "pending";
-var CHECK_STATUS_FAIL = "fail";
-var CHECK_STATUS_MISSING = "missing";
-var PASSING_CONCLUSIONS = /* @__PURE__ */ new Set(["success", "skipped", "neutral"]);
-var KEY_TYPE_NAME = "__typename";
-var KEY_STATE = "state";
-var KEY_STATUS = "status";
-var KEY_CONCLUSION = "conclusion";
-var KEY_NAME = "name";
-var KEY_CONTEXT = "context";
-var KEY_DESCRIPTION = "description";
-function read_string(value) {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  if (trimmed.length === 0) return void 0;
-  return trimmed;
-}
-var PENDING_STATUS_STATES = /* @__PURE__ */ new Set(["pending", "expected"]);
-function parse_status_context(item) {
-  const state = read_string(item[KEY_STATE])?.toLowerCase();
-  if (state === "success") return CHECK_STATUS_PASS;
-  if (state !== void 0 && PENDING_STATUS_STATES.has(state)) return CHECK_STATUS_PENDING;
-  return CHECK_STATUS_FAIL;
-}
-function is_passing_conclusion(item) {
-  const conclusion = read_string(item[KEY_CONCLUSION])?.toLowerCase();
-  return conclusion !== void 0 && PASSING_CONCLUSIONS.has(conclusion);
-}
-function parse_check_run(item) {
-  const status = read_string(item[KEY_STATUS])?.toLowerCase();
-  if (status !== "completed") return CHECK_STATUS_PENDING;
-  return is_passing_conclusion(item) ? CHECK_STATUS_PASS : CHECK_STATUS_FAIL;
-}
-function parse_rollup_status(item) {
-  const type_name = read_string(item[KEY_TYPE_NAME]);
-  if (type_name === "StatusContext") return parse_status_context(item);
-  return parse_check_run(item);
-}
-function read_rollup_array(parsed) {
-  const result = pr_raw_schema.safeParse(parsed);
-  if (!result.success) return [];
-  return result.data.statusCheckRollup ?? [];
-}
-function parse_rollup_item(item) {
-  const name = read_string(item[KEY_NAME]) ?? read_string(item[KEY_CONTEXT]);
-  if (name === void 0) return void 0;
-  const check = { name, status: parse_rollup_status(item) };
-  const description = read_string(item[KEY_DESCRIPTION]);
-  return description === void 0 ? check : { ...check, description };
-}
-function parse_rollup_checks(raw_json) {
-  const parsed = json_value.parse_or_undefined(raw_json);
-  const rollup = read_rollup_array(parsed);
-  const checks = [];
-  for (const item of rollup) {
-    const parsed_item = parse_rollup_item(item);
-    if (parsed_item !== void 0) checks.push(parsed_item);
-  }
-  return checks;
-}
-function parse_pr_state_snapshot(raw_json) {
-  const parsed = json_value.parse_or_undefined(raw_json);
-  const result = pr_raw_schema.safeParse(parsed);
-  const data = result.success ? result.data : void 0;
-  return {
-    rollup: parse_rollup_checks(raw_json),
-    merge_state_status: read_string(data?.mergeStateStatus),
-    review_decision: read_string(data?.reviewDecision)
-  };
-}
-
-// scripts/gh/git-pr-checks-eval.ts
-var DEFAULT_REQUIRED_CHECKS = ["SonarQube"];
-var CODERABBIT_CHECK_NAME = "CodeRabbit";
-var REQUIRED_CHECKS_ENV_VAR = "JOSH_REQUIRED_CHECKS";
-function parse_required_checks() {
-  const raw = process.env[REQUIRED_CHECKS_ENV_VAR];
-  if (!raw) return DEFAULT_REQUIRED_CHECKS;
-  return raw.split(",").map((check) => check.trim()).filter((check) => check.length > 0);
-}
-var REQUIRED_CHECKS = parse_required_checks();
-var MERGE_STATE_CLEAN = "CLEAN";
-var MERGE_STATE_UNSTABLE = "UNSTABLE";
-var MERGE_STATE_DIRTY = "DIRTY";
-var REVIEW_CHANGES_REQUESTED = "CHANGES_REQUESTED";
-var CHECK_SUITE_SEPARATOR = " / ";
-var FAILURE_MESSAGE_PREFIX = "PR checks failed";
-var FAILURE_REASON_REVIEW = "review requested changes";
-var FAILURE_REASON_CHECKS = "failed checks";
-var FAILURE_REASON_CONFLICT = "merge conflict";
-function is_required_match(check_name, required_name) {
-  if (check_name === required_name) return true;
-  return check_name.startsWith(`${required_name}${CHECK_SUITE_SEPARATOR}`);
-}
-function find_required_check(checks, required_name) {
-  return checks.find((check) => is_required_match(check.name, required_name));
-}
-function read_required_statuses(checks) {
-  return REQUIRED_CHECKS.map(
-    (name) => find_required_check(checks, name)?.status ?? CHECK_STATUS_MISSING
-  );
-}
-function is_review_blocked(review_decision) {
-  return review_decision === REVIEW_CHANGES_REQUESTED;
-}
-function is_merge_conflict(merge_state_status) {
-  return merge_state_status === MERGE_STATE_DIRTY;
-}
-function evaluate_failure_state(input) {
-  if (is_merge_conflict(input.merge_state_status) || is_review_blocked(input.review_decision) || input.failed_checks.length > 0) {
-    return "failure";
-  }
-  return void 0;
-}
-function is_merge_state_clean(merge_state_status) {
-  return merge_state_status === MERGE_STATE_CLEAN;
-}
-function is_every_required_passing(statuses) {
-  return statuses.every((status) => status === CHECK_STATUS_PASS);
-}
-function is_coderabbit_check(check_name) {
-  return is_required_match(check_name, CODERABBIT_CHECK_NAME);
-}
-function is_unstable_only_from_coderabbit(snapshot) {
-  if (snapshot.merge_state_status !== MERGE_STATE_UNSTABLE) return false;
-  const non_passing = snapshot.rollup.filter((check) => check.status !== CHECK_STATUS_PASS);
-  if (non_passing.length === 0) return false;
-  return non_passing.every((check) => is_coderabbit_check(check.name));
-}
-function is_required_check(check_name) {
-  return REQUIRED_CHECKS.some((required) => is_required_match(check_name, required));
-}
-function is_blocking_failure(check) {
-  if (check.status !== CHECK_STATUS_FAIL) return false;
-  return !is_coderabbit_check(check.name) || is_required_check(check.name);
-}
-function collect_blocking_failures(snapshot) {
-  return snapshot.rollup.filter((check) => is_blocking_failure(check)).map((check) => check.name);
-}
-function is_mergeable_state(snapshot) {
-  if (is_merge_state_clean(snapshot.merge_state_status)) return true;
-  return is_unstable_only_from_coderabbit(snapshot);
-}
-function collect_failure_reasons(snapshot) {
-  const reasons = [];
-  if (is_merge_conflict(snapshot.merge_state_status)) reasons.push(FAILURE_REASON_CONFLICT);
-  if (is_review_blocked(snapshot.review_decision)) reasons.push(FAILURE_REASON_REVIEW);
-  const failed = collect_blocking_failures(snapshot);
-  if (failed.length > 0) reasons.push(`${FAILURE_REASON_CHECKS}: ${failed.join(", ")}`);
-  return reasons;
-}
-function describe_pr_failure(snapshot) {
-  const reasons = collect_failure_reasons(snapshot);
-  if (reasons.length === 0) return `${FAILURE_MESSAGE_PREFIX}.`;
-  return `${FAILURE_MESSAGE_PREFIX} (${reasons.join("; ")}).`;
-}
-function evaluate_pr_state(snapshot) {
-  const statuses = read_required_statuses(snapshot.rollup);
-  const failure = evaluate_failure_state({
-    review_decision: snapshot.review_decision,
-    failed_checks: collect_blocking_failures(snapshot),
-    merge_state_status: snapshot.merge_state_status
-  });
-  if (failure !== void 0) return failure;
-  if (is_mergeable_state(snapshot) && is_every_required_passing(statuses)) return "success";
-  return "pending";
-}
-function is_review_decision_decisive(snapshot) {
-  return evaluate_pr_state(snapshot) !== "pending";
-}
-var PrConflictError = class extends Error {
-  name = "PrConflictError";
-};
-
-// scripts/lane/lane-ledger.ts
-import { closeSync, constants, openSync, writeSync } from "node:fs";
-import { z as z3 } 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",
-  STOP: "stop",
-  OVERLAP: "overlap"
-};
-var merge_schema = z3.object({ kind: z3.literal(KIND.MERGE), at: z3.string(), issue: z3.number() });
-var check_schema = z3.object({
-  label: z3.string(),
-  elapsed_ms: z3.number(),
-  is_passed: z3.boolean(),
-  is_reused: z3.boolean().optional()
-});
-var gate_schema = z3.object({
-  kind: z3.literal(KIND.GATE),
-  at: z3.string(),
-  elapsed_ms: z3.number(),
-  is_passed: z3.boolean(),
-  // The unit suite's own duration, present when this gate ran it — the one
-  // record of a full vitest run `josh metrics` reads, so the suite is never timed twice.
-  unit_ms: z3.number().optional(),
-  // The whole cores busy outside this gate, beyond the machine's baseline, at its start or its end —
-  // whichever was higher. Absent when the machine could not be read.
-  external_cores: z3.number().optional(),
-  // Each check's own duration and verdict, so `josh lane:stats` can name the check a slow gate waited
-  // on. A reused check started no process: its row says so, and its zero is no timing.
-  checks: z3.array(check_schema).optional()
-});
-var process_kind_schema = z3.object({
-  kind: z3.string(),
-  cpu_percent: z3.number(),
-  rss_mb: z3.number(),
-  count: z3.number()
-});
-var load_schema = z3.object({
-  kind: z3.literal(KIND.LOAD),
-  at: z3.string(),
-  load: z3.number(),
-  available_mb: z3.number().optional(),
-  swapped_mb: z3.number().optional(),
-  lanes: z3.number().optional(),
-  // The heaviest process kinds at the instant of the sample (`lane-process-load.ts`), so the load the
-  // core budget's ledger does not explain can be read back by what made it (joshuafolkken/kit#3874).
-  processes: z3.array(process_kind_schema).optional()
-});
-var dispatch_schema = z3.object({
-  kind: z3.literal(KIND.DISPATCH),
-  at: z3.string(),
-  issue: z3.number()
-});
-var stage_schema = z3.object({
-  kind: z3.literal(KIND.STAGE),
-  at: z3.string(),
-  stage: z3.string(),
-  elapsed_ms: z3.number(),
-  issue: z3.number().optional()
-});
-var stop_schema = z3.object({
-  kind: z3.literal(KIND.STOP),
-  at: z3.string(),
-  issue: z3.number(),
-  reason: z3.string()
-});
-var overlap_schema = z3.object({
-  kind: z3.literal(KIND.OVERLAP),
-  at: z3.string(),
-  issue: z3.number(),
-  lanes: z3.array(z3.number()),
-  paths: z3.array(z3.string()),
-  waited_ms: z3.number(),
-  is_cleared: z3.boolean()
-});
-var entry_schema = z3.discriminatedUnion("kind", [
-  merge_schema,
-  gate_schema,
-  load_schema,
-  dispatch_schema,
-  stage_schema,
-  stop_schema,
-  overlap_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(path5, entry) {
-  const descriptor = openSync(path5, APPEND_FLAGS, LEDGER_FILE_MODE);
-  try {
-    if (stamp_file.is_own_regular_file(path5)) {
-      writeSync(descriptor, `${JSON.stringify(entry)}${LINE_SEPARATOR}`);
-    }
-  } finally {
-    closeSync(descriptor);
-  }
-}
-async function record(entry, path5) {
-  try {
-    const destination = path5 ?? await target();
-    if (destination !== void 0) append(destination, entry);
-  } catch {
-  }
-}
-function now_iso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-async function record_gate(path5, gate) {
-  await record({ kind: KIND.GATE, at: now_iso(), ...gate }, path5);
-}
-async function record_merge(issue) {
-  await record({ kind: KIND.MERGE, at: now_iso(), issue });
-}
-async function record_dispatch(issue, path5) {
-  await record({ kind: KIND.DISPATCH, at: now_iso(), issue }, path5);
-}
-async function record_stage(stage, path5) {
-  await record({ kind: KIND.STAGE, at: now_iso(), ...stage }, path5);
-}
-async function record_stop(stop, path5) {
-  await record({ kind: KIND.STOP, at: now_iso(), ...stop }, path5);
-}
-async function record_overlap(overlap, path5) {
-  await record({ kind: KIND.OVERLAP, at: now_iso(), ...overlap }, path5);
-}
-function parse_line2(line) {
-  return entry_schema.safeParse(json_value.parse_or_undefined(line)).data;
-}
-function is_present(entry) {
-  return entry !== void 0;
-}
-function read_entries(path5) {
-  const raw = stamp_file.read_stamp_text(path5);
-  if (raw === void 0) return [];
-  return raw.split(LINE_SEPARATOR).map((line) => parse_line2(line.trim())).filter(is_present);
-}
-var lane_ledger = {
-  CI_WAIT_STAGE,
-  KIND,
-  append,
-  read_entries,
-  record,
-  record_dispatch,
-  record_gate,
-  record_merge,
-  record_overlap,
-  record_stage,
-  record_stop,
-  target,
-  target_of
-};
-
-// scripts/time-runtime/time-format.ts
-var MS_PER_MINUTE = 6e4;
-var MS_PER_SECOND2 = 1e3;
-var MINUTE_DECIMALS = 1;
-var SECOND_DECIMALS = 1;
-var PERCENT_SCALE = 100;
-var PERCENT_DECIMALS = 1;
-var LABEL_WIDTH = 24;
-var MINUTES_WIDTH = 9;
-var NOT_MEASURED = "not measured";
-var NO_CALLS = "no tool call to divide";
-var MAX_ROWS = 15;
-function overflow_line(row_count) {
-  if (row_count <= MAX_ROWS) return [];
-  return [
-    `  \u2026 and ${String(row_count - MAX_ROWS)} more (--json carries every row this report holds)`
-  ];
-}
-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_SECOND2).toFixed(SECOND_DECIMALS)} s`;
-}
-function format_share(part, whole) {
-  if (whole === 0) return "n/a";
-  return `${(part / whole * PERCENT_SCALE).toFixed(PERCENT_DECIMALS)}%`;
-}
-function usd(amount, decimals) {
-  return `$${amount.toFixed(decimals)}`;
-}
-function format_columns(label, minutes, suffix) {
-  return `  ${label.padEnd(LABEL_WIDTH)}${minutes.padStart(MINUTES_WIDTH)}   ${suffix}`;
-}
-function format_row(label, duration_ms, suffix) {
-  return format_columns(label, format_minutes(duration_ms), suffix);
-}
-function unmeasured_row(label) {
-  return format_columns(label, "", NOT_MEASURED);
-}
-var time_format = {
-  MAX_ROWS,
-  NO_CALLS,
-  overflow_line,
-  format_seconds,
-  format_share,
-  usd,
-  format_columns,
-  format_row,
-  // `format_clock` stays private: `format_window` is its only caller, and a namespace that offers
-  // both invites a second renderer to join the two with its own arrow.
-  unmeasured_row
-};
-
-// scripts/followup/git-followup-stages.ts
-var STAGE_LINE_PREFIX = "followup stage: ";
-var STAGE_TOTAL_PREFIX = "followup stages total: ";
-var STAGE_NAME_WIDTH = 26;
-var VALUE_COLUMN = STAGE_LINE_PREFIX.length + STAGE_NAME_WIDTH;
-var NO_DURATION = 0;
-var STAGE = {
-  closes_and_context: "closes-and-context",
-  checks_wait: "checks-wait",
-  coderabbit_comments: "coderabbit-comments",
-  ai_review_comments: "ai-review-comments",
-  telegram: "telegram",
-  merge: "merge",
-  completion_and_epic_close: "completion-and-epic-close",
-  // The lap that was still running when a stage threw. `followup` exits non-zero on an AI-review
-  // 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, so the
-  // stage block names the cause a resumed session would otherwise look up with `gh pr view`.
-  conflict: "conflict"
-};
-function stopped_lap(error) {
-  return error instanceof PrConflictError ? STAGE.conflict : STAGE.interrupted;
-}
-function new_log() {
-  return { stages: [], last_ms: performance.now() };
-}
-function lap(log, name) {
-  const now_ms = performance.now();
-  log.stages.push({ name, duration_ms: now_ms - log.last_ms });
-  log.last_ms = now_ms;
-}
-function total_ms(stages) {
-  return stages.reduce((sum, stage) => sum + stage.duration_ms, NO_DURATION);
-}
-function format_stage(stage) {
-  const name = stage.name.padEnd(STAGE_NAME_WIDTH);
-  return `${STAGE_LINE_PREFIX}${name}${time_format.format_seconds(stage.duration_ms)}`;
-}
-function format_stages(log) {
-  if (log.stages.length === 0) return [];
-  const rows = log.stages.map((stage) => format_stage(stage));
-  const total = time_format.format_seconds(total_ms(log.stages));
-  return ["", ...rows, `${STAGE_TOTAL_PREFIX.padEnd(VALUE_COLUMN)}${total}`];
-}
-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,
-  STAGE_TOTAL_PREFIX,
-  new_log,
-  lap,
-  total_ms,
-  format_stages,
-  print_stages,
-  record_ci_wait,
-  stopped_lap
-};
-
-// scripts/time-runtime/time-followup-stage.ts
-var LINE_SEPARATOR2 = "\n";
-var SECONDS_SUFFIX = " s";
-var DIGIT_OR_POINT = /[\d.]/u;
-var MS_PER_SECOND3 = 1e3;
-var NO_STAGES = [];
-function stage_body(line) {
-  const trimmed = line.trimStart();
-  if (!trimmed.startsWith(git_followup_stages.STAGE_LINE_PREFIX)) return void 0;
-  return trimmed.slice(git_followup_stages.STAGE_LINE_PREFIX.length);
-}
-function digits_start(head) {
-  let index = head.length;
-  while (index > 0 && DIGIT_OR_POINT.test(head.charAt(index - 1))) index -= 1;
-  return index;
-}
-function is_duration(digits) {
-  return digits !== "" && Number.isFinite(Number(digits));
-}
-function to_stage(body) {
-  const text = body.trimEnd();
-  if (!text.endsWith(SECONDS_SUFFIX)) return void 0;
-  const head = text.slice(0, -SECONDS_SUFFIX.length);
-  const start = digits_start(head);
-  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_SECOND3 };
-}
-function read_stages(text) {
-  if (!text.includes(git_followup_stages.STAGE_LINE_PREFIX)) return NO_STAGES;
-  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 };
-
-// scripts/time-runtime/time-reported-failure.ts
-import { z as z4 } from "zod";
-var TEXT_BLOCK_SCHEMA = z4.object({ text: z4.string().nullish() });
-var CONTENT_SCHEMA = z4.union([z4.string(), z4.array(z4.unknown())]);
-var LINE_SEPARATOR3 = "\n";
-function block_text(block) {
-  const parsed = TEXT_BLOCK_SCHEMA.safeParse(block);
-  return parsed.success ? parsed.data.text ?? "" : "";
-}
-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_SEPARATOR3);
-}
-function is_failure_line(line) {
-  return line.trimStart().startsWith(status_icons.FAIL_ICON);
-}
-function is_failed_verdict(line) {
-  return josh_verdict.read_verdict(line) === josh_verdict.FAILED_VERDICT;
-}
-var GREEN_VERDICTS = /* @__PURE__ */ new Set([
-  josh_verdict.PASSED_VERDICT,
-  josh_verdict.UNVERIFIED_VERDICT
-]);
-function is_green_verdict(line) {
-  return GREEN_VERDICTS.has(josh_verdict.read_verdict(line));
-}
-function new_scan() {
-  return {
-    did_find: false,
-    has_failure_before_region: false,
-    has_failure_in_region: false,
-    is_region_open: false
-  };
-}
-function close_region(scan) {
-  scan.did_find ||= scan.is_region_open && scan.has_failure_before_region;
-  scan.has_failure_before_region = false;
-  scan.has_failure_in_region = false;
-  scan.is_region_open = false;
-}
-function note_failure(scan) {
-  if (scan.is_region_open) {
-    scan.has_failure_in_region = true;
-    return;
-  }
-  scan.has_failure_before_region = true;
-}
-function scan_line(scan, line) {
-  if (is_green_verdict(line)) {
-    close_region(scan);
-    return;
-  }
-  if (is_failure_line(line)) {
-    note_failure(scan);
-    return;
-  }
-  if (josh_verdict.is_gate_opening(line)) scan.is_region_open = true;
-}
-function scan_body(lines) {
-  const scan = new_scan();
-  for (const line of lines) scan_line(scan, line);
-  return scan;
-}
-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_SEPARATOR3);
-  if (lines.some((line) => is_failed_verdict(line))) return true;
-  return did_scan_find(scan_body(lines));
-}
-function is_reported_failure(josh_command, did_print_failure) {
-  return josh_command !== "" && did_print_failure;
-}
-var time_reported_failure = { result_text: result_text2, has_failure_line, is_reported_failure };
-
-// scripts/time-runtime/time-bundle-call.ts
-var { BASH_TOOL: BASH_TOOL2 } = cost_blocks;
-var BUNDLEABLE_TOOLS = /* @__PURE__ */ new Set(["Edit", "Glob", "Grep", "Read", "WebFetch", "WebSearch", "Write"]);
-var LAUNCH_TOOLS = /* @__PURE__ */ new Set(["Agent", "Task"]);
-var PRIOR_REFERENCE_MARKERS = [
-  "previous finding",
-  "prior finding",
-  "earlier finding",
-  "previous result",
-  "prior result",
-  "earlier result",
-  "based on the previous",
-  "based on the earlier",
-  "from the previous agent",
-  "from the prior agent",
-  "the finding above",
-  "as found earlier",
-  "as found above",
-  "building on the previous"
-];
-var READ_COMMANDS = /* @__PURE__ */ new Set([
-  "awk",
-  "basename",
-  "cat",
-  "comm",
-  "cut",
-  "diff",
-  "dirname",
-  "du",
-  "echo",
-  "file",
-  "find",
-  "gh",
-  "grep",
-  "head",
-  "jq",
-  "ls",
-  "nl",
-  "printf",
-  "pwd",
-  "realpath",
-  "rg",
-  // **`sed -i` is deliberately not excluded.** An in-place edit is what `Edit` does, and `Edit` is on
-  // the allow-list above — a turn may issue several of them, so rejecting the shell spelling of the
-  // same thing would exclude a call the tool form counts. Two in-place edits of the *same* file are
-  // caught by the target test instead, which is where that ordering actually lives.
-  "sed",
-  "sort",
-  "stat",
-  "tail",
-  "tree",
-  "uniq",
-  "wc",
-  "which"
-]);
-var MUTATION_WORDS = /* @__PURE__ */ new Set([
-  "--field",
-  "--method",
-  "--raw-field",
-  "-F",
-  "-X",
-  "-delete",
-  "-exec",
-  "-f",
-  "add",
-  "chmod",
-  "chown",
-  "close",
-  "comment",
-  "cp",
-  "create",
-  "dd",
-  "delete",
-  "edit",
-  "git",
-  "install",
-  "kill",
-  "ln",
-  "merge",
-  "mkdir",
-  "mv",
-  "node",
-  "npm",
-  "npx",
-  "pkill",
-  "pnpm",
-  "remove",
-  "rm",
-  "scp",
-  "secret",
-  "set",
-  "ssh",
-  "sudo",
-  "tee",
-  "touch",
-  "truncate",
-  "tsx",
-  "upload",
-  "wget"
-]);
-var READ_JOSH_SUBCOMMANDS = /* @__PURE__ */ new Set([
-  "backlog:budget",
-  "backlog:next",
-  "cost",
-  "delegate",
-  "epic:audit",
-  "epic:bundle",
-  "epic:check",
-  "epic:next",
-  "issue:read",
-  "issue:scout",
-  "issue:state",
-  "lane:list",
-  "latest:scope",
-  "release:scope",
-  "review:brief",
-  "review:round2",
-  "run:liveness"
-]);
-var JOSH_WORD = "josh";
-var JOSH_SCRIPT_SUFFIX = "josh.ts";
-var COMMAND_CHAIN = /[|;&`>]|\$\(/u;
-var WHITESPACE_PATTERN2 = /\s+/u;
-var TARGET_FIELDS = ["file_path", "notebook_path", "path", "url"];
-var TARGET_ARRAY_FIELD = "file_paths";
-var MAX_TARGETS = 8;
-var WORD_PATTERN = /[\s'"=(),;:|&]+/u;
-var EXTENSION_PATTERN = /^[A-Za-z]+$/u;
-var MAX_EXTENSION = 5;
-var AFTER_DOT = 1;
-var FIRST_INDEX = 0;
-var CURRENT_DIRECTORY = "./";
-var LAST_CHARACTER = -1;
-var FLAG_PREFIX2 = "-";
-var PATH_SEPARATOR = "/";
-var MIN_TARGET_LENGTH = 3;
-var WRITING_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "NotebookEdit"]);
-var WRITING_WORDS = /* @__PURE__ */ new Set(["dd", "sed", "tee"]);
-var REDIRECTION = ">";
-var IN_PLACE_COMMAND = "sed";
-var IN_PLACE_FLAG_PATTERN = /^--in-place\b|^-[A-Za-z]*i/u;
-function not_bundleable() {
-  return {
-    is_bundleable: false,
-    targets: [],
-    is_writing: false,
-    may_write: false,
-    has_prior_reference: false
-  };
-}
-function is_launch_tool(name) {
-  return LAUNCH_TOOLS.has(name);
-}
-function words_of(command) {
-  return command.split(WORD_PATTERN).filter((word) => word !== "");
-}
-function has_mutation(command) {
-  return words_of(command).some((word) => MUTATION_WORDS.has(word));
-}
-function josh_subcommand(command) {
-  const tokens = command.split(WHITESPACE_PATTERN2).filter((token) => token !== "");
-  const josh_index = tokens.findIndex(
-    (token) => token === JOSH_WORD || token.endsWith(JOSH_SCRIPT_SUFFIX)
-  );
-  return josh_index < FIRST_INDEX ? void 0 : tokens[josh_index + 1];
-}
-function is_read_josh(command) {
-  if (COMMAND_CHAIN.test(command)) return false;
-  const subcommand = josh_subcommand(command);
-  if (subcommand === void 0) return false;
-  return READ_JOSH_SUBCOMMANDS.has(canonical_command(subcommand));
-}
-function may_write_command(command) {
-  if (command.includes(REDIRECTION)) return true;
-  return words_of(command).some((word) => WRITING_WORDS.has(word));
-}
-function write_segment(command) {
-  return time_shell.command_segment(time_shell.unquoted(command));
-}
-function is_in_place_sed(segment) {
-  if (time_shell.leading_word(segment) !== IN_PLACE_COMMAND) return false;
-  return words_of(segment).some((word) => IN_PLACE_FLAG_PATTERN.test(word));
-}
-function normalize(word) {
-  const head = word.startsWith(CURRENT_DIRECTORY) ? word.slice(CURRENT_DIRECTORY.length) : word;
-  return head.endsWith(PATH_SEPARATOR) ? head.slice(0, LAST_CHARACTER) : head;
-}
-function has_extension(word) {
-  const dot = word.lastIndexOf(".");
-  if (dot <= FIRST_INDEX) return false;
-  const suffix = word.slice(dot + AFTER_DOT);
-  return suffix.length <= MAX_EXTENSION && EXTENSION_PATTERN.test(suffix);
-}
-function is_target(word) {
-  if (word.startsWith(FLAG_PREFIX2) || word.length < MIN_TARGET_LENGTH) return false;
-  return word.includes(PATH_SEPARATOR) || has_extension(word);
-}
-function targets_in(text) {
-  return words_of(text).map((word) => normalize(word)).filter((word) => is_target(word)).slice(0, MAX_TARGETS);
-}
-function field_text(input, field) {
-  if (!json_value.is_record(input)) return "";
-  const value = input[field];
-  return typeof value === "string" ? value : "";
-}
-function field_targets(input) {
-  if (!json_value.is_record(input)) return [];
-  const value = input[TARGET_ARRAY_FIELD];
-  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
-}
-function tool_targets(input) {
-  const scalar_targets = TARGET_FIELDS.map((field) => field_text(input, field));
-  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();
-  return PRIOR_REFERENCE_MARKERS.some((marker) => prompt.includes(marker));
-}
-function tool_facts(name, input) {
-  const writes = { is_writing: WRITING_TOOLS.has(name), may_write: WRITING_TOOLS.has(name) };
-  const has_prior_reference = LAUNCH_TOOLS.has(name) && prompt_references_prior(input);
-  if (!BUNDLEABLE_TOOLS.has(name)) return { ...not_bundleable(), ...writes, has_prior_reference };
-  return { is_bundleable: true, targets: tool_targets(input), ...writes, has_prior_reference };
-}
-function bash_facts(command) {
-  const writes = {
-    is_writing: is_in_place_sed(write_segment(command)),
-    may_write: may_write_command(command)
-  };
-  if (is_read_josh(command)) {
-    return {
-      is_bundleable: true,
-      targets: targets_in(time_shell.unquoted(command)),
-      ...writes,
-      has_prior_reference: false
-    };
-  }
-  if (!READ_COMMANDS.has(time_shell.leading_word(command)) || has_mutation(command)) {
-    return { ...not_bundleable(), ...writes };
-  }
-  return {
-    is_bundleable: true,
-    targets: targets_in(time_shell.unquoted(command)),
-    ...writes,
-    has_prior_reference: false
-  };
-}
-function call_facts(name, input) {
-  if (name !== BASH_TOOL2) return tool_facts(name, input);
-  return bash_facts(time_shell.bash_command(input));
-}
-var time_bundle_call = {
-  MAX_TARGETS,
-  not_bundleable,
-  bash_facts,
-  call_facts,
-  tool_facts,
-  // 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`, 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, 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, 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`, 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`, which pins that
-  // every name here is a real `josh` command and none of them writes.
-  READ_JOSH_SUBCOMMANDS
-};
-
-// scripts/cost-runtime/cost-attribute.ts
-var ISSUE_BRANCH_PATTERN = /^(\d+)-/u;
-var UNATTRIBUTED_KEY = -1;
-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(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);
-  const order = declared.map((_value, index) => is_reverse ? declared.length - 1 - index : index);
-  let carried = UNATTRIBUTED_KEY;
-  for (const index of order) {
-    const own = declared[index] ?? UNATTRIBUTED_KEY;
-    carried = own === UNATTRIBUTED_KEY ? carried : own;
-    filled[index] = carried;
-  }
-  return filled;
-}
-function is_attributed(value) {
-  return value !== void 0 && value !== UNATTRIBUTED_KEY;
-}
-function pick(own, carried, next, previous) {
-  if (is_attributed(own)) return own;
-  if (is_attributed(carried)) return carried;
-  if (is_attributed(next)) return next;
-  return previous ?? UNATTRIBUTED_KEY;
-}
-function announcements(records) {
-  return fill(
-    records.map((record2) => record2.issue ?? UNATTRIBUTED_KEY),
-    false
-  );
-}
-function attribute(records) {
-  const declared = records.map((record2) => declared_issue(record2));
-  const carried = announcements(records);
-  const next = fill(declared, true);
-  const previous = fill(declared, false);
-  return declared.map(
-    (own, index) => pick(own, carried[index] ?? UNATTRIBUTED_KEY, next[index], previous[index])
-  );
-}
-function group_by_issue(records) {
-  const issues = attribute(records);
-  const grouped = /* @__PURE__ */ new Map();
-  for (const [index, record2] of records.entries()) {
-    const bucket = grouped.get(issues[index] ?? UNATTRIBUTED_KEY) ?? [];
-    bucket.push(record2);
-    grouped.set(issues[index] ?? UNATTRIBUTED_KEY, bucket);
-  }
-  return [...grouped].toSorted(([left], [right]) => left - right).map(([issue, bucket]) => ({ issue, records: bucket }));
-}
-function records_for_issue(records, issue_number) {
-  const issues = attribute(records);
-  return records.filter((_record, index) => issues[index] === issue_number);
-}
-var cost_attribute = {
-  UNATTRIBUTED_KEY,
-  issue_from_branch,
-  declared_issue,
-  attribute,
-  group_by_issue,
-  records_for_issue
-};
-
-// scripts/time-runtime/time-markers.ts
-var NO_MARKER = "none";
-var PLAN_MARKER = "plan";
-var EDIT_MARKER = "edit";
-var REVIEW_MARKER = "review";
-var WORKFLOW_MARKER = "workflow";
-var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
-var SKILL_TOOL = "Skill";
-var SKILL_KEY = "skill";
-var REVIEW_SKILL = "code-review";
-var WORKFLOW_SKILL = "workflow-commands";
-var AGENT_TOOL = "Agent";
-var PROMPT_KEY = "prompt";
-var REVIEW_INVOCATION = "/code-review";
-var REVIEW_ATTEST = "review:attest";
-var SKILL_MARKERS = /* @__PURE__ */ new Map([
-  [REVIEW_SKILL, REVIEW_MARKER],
-  [WORKFLOW_SKILL, WORKFLOW_MARKER]
-]);
-var ISSUE_API_PATTERN = /repos\/\S+\/issues\/\d+/u;
-var BODY_FIELD_PATTERN = /\bbody=/u;
-var ISSUE_COMMENT_PATTERN = /\bgh\s+issue\s+comment\b/u;
-var BODY_FLAG_PATTERN = /--body(?:-file)?\b/u;
-var ISSUE_LABELS_PATTERN = /repos\/\S+\/issues\/(\d+)\/labels\b(?!\/)/u;
-var IN_PROGRESS_FIELD = "labels[]=in-progress";
-var RUN_ENTRY_PATTERN = /\bjosh\s+run:entry\s+(\d+)\b/u;
-var NO_ISSUE = cost_attribute.UNATTRIBUTED_KEY;
-function string_field(input, key) {
-  if (!json_value.is_record(input)) return "";
-  const value = input[key];
-  return typeof value === "string" ? value : "";
-}
-function skill_name(input) {
-  return string_field(input, SKILL_KEY);
-}
-function agent_marker(input) {
-  const prompt = string_field(input, PROMPT_KEY);
-  const is_review = prompt.includes(REVIEW_INVOCATION) && prompt.includes(REVIEW_ATTEST);
-  return is_review ? REVIEW_MARKER : NO_MARKER;
-}
-function tool_marker(name, input) {
-  if (EDIT_TOOLS.has(name)) return EDIT_MARKER;
-  if (name === AGENT_TOOL) return agent_marker(input);
-  if (name !== SKILL_TOOL) return NO_MARKER;
-  return SKILL_MARKERS.get(skill_name(input)) ?? NO_MARKER;
-}
-function is_api_body_write(command) {
-  return ISSUE_API_PATTERN.test(command) && BODY_FIELD_PATTERN.test(command);
-}
-function is_issue_comment(command) {
-  return ISSUE_COMMENT_PATTERN.test(command) && BODY_FLAG_PATTERN.test(command);
-}
-function is_in_progress_label(command) {
-  return ISSUE_LABELS_PATTERN.test(command) && command.includes(IN_PROGRESS_FIELD);
-}
-function is_run_start(command) {
-  return is_in_progress_label(command) || RUN_ENTRY_PATTERN.test(command);
-}
-var COMMAND_SEPARATOR = /&&|\|\||;/u;
-function declared_issue2(part) {
-  const pattern = is_in_progress_label(part) ? ISSUE_LABELS_PATTERN : RUN_ENTRY_PATTERN;
-  const matched = pattern.exec(part);
-  return matched?.[1] === void 0 ? NO_ISSUE : Number(matched[1]);
-}
-function bash_issue(command) {
-  for (const part of command.split(COMMAND_SEPARATOR)) {
-    if (is_run_start(part)) return declared_issue2(part);
-  }
-  return NO_ISSUE;
-}
-function bash_marker(command) {
-  if (is_run_start(command)) return WORKFLOW_MARKER;
-  return is_api_body_write(command) || is_issue_comment(command) ? PLAN_MARKER : NO_MARKER;
-}
-var time_markers = {
-  NO_MARKER,
-  PLAN_MARKER,
-  EDIT_MARKER,
-  REVIEW_MARKER,
-  WORKFLOW_MARKER,
-  NO_ISSUE,
-  tool_marker,
-  bash_marker,
-  bash_issue
-};
-
-// scripts/time-runtime/time-single-check.ts
-var CHECK_COMMANDS = /* @__PURE__ */ new Set([
-  "josh check",
-  "josh cspell",
-  "josh cspell:dot",
-  "josh lint",
-  "josh lint:related",
-  "josh test:related",
-  "josh test:unit"
-]);
-var NO_CHECK = "";
-var KEY_SEPARATOR = " ";
-function argument_key(command) {
-  return [...new Set(time_shell.josh_arguments(command))].toSorted(
-    (left, right) => left.localeCompare(right)
-  );
-}
-function check_key(josh_command, command) {
-  if (!CHECK_COMMANDS.has(josh_command)) return NO_CHECK;
-  return [josh_command, ...argument_key(command)].join(KEY_SEPARATOR);
-}
-var time_single_check = { NO_CHECK, check_key };
-
-// scripts/time-runtime/time-transcript-line.ts
-import { z as z5 } from "zod";
-var BLOCK_SCHEMA2 = z5.object({
-  type: z5.string().nullish(),
-  name: z5.string().nullish(),
-  id: z5.string().nullish(),
-  tool_use_id: z5.string().nullish(),
-  input: z5.unknown().nullish(),
-  // Whether the harness wrote this result back as a failure. Present on a
-  // `tool_result` block and on nothing else, and absent even there for the tools that never report
-  // one — which is why it is read as three answers rather than as a boolean with a default.
-  is_error: z5.boolean().nullish(),
-  // What the call printed. Read only to recover the outcome a pipeline threw away:
-  // it is kept as flattened text rather than as blocks, because that is
-  // the whole of what `time-reported-failure.ts` asks of it.
-  content: z5.unknown().nullish()
-});
-var CONTENT_SCHEMA2 = z5.union([z5.string(), z5.array(BLOCK_SCHEMA2)]);
-var MESSAGE_SCHEMA2 = z5.object({ id: z5.string().nullish(), content: CONTENT_SCHEMA2.nullish() });
-var LINE_SCHEMA = z5.object({
-  type: z5.string().nullish(),
-  timestamp: z5.string().nullish(),
-  // The branch the line was written on, which is where the issue number lives — `josh git` names a
-  // branch `<N>-<slug>`. Read here rather than re-parsed by a second reader so `josh time --issue`
-  // and `josh cost --issue` answer from the same field.
-  gitBranch: z5.string().nullish(),
-  // The two fields outside `message` that the harness writes an end-of-task notice on.
-  // **Both are read as `unknown` rather than as strings**: a schema
-  // insisting on a string here would reject every line whose `content` is a list of blocks — which is
-  // most of them — and a rejected line is dropped from the timeline entirely, so the shares would stop
-  // reconstructing the elapsed time. The shape is checked at the read below instead.
-  content: z5.unknown().nullish(),
-  attachment: z5.unknown().nullish(),
-  message: MESSAGE_SCHEMA2.nullish()
-});
-var UNKNOWN_BRANCH = "";
-var PROMPT_KEY2 = "prompt";
-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) {
-  return {
-    type: raw.type ?? "",
-    name: raw.name ?? "",
-    id: raw.id ?? "",
-    result_id: raw.tool_use_id ?? ""
-  };
-}
-function guard_from_refusal(text) {
-  const trimmed = text.trimStart().replace(HOOK_ERROR_LABEL, "");
-  if (!trimmed.startsWith(REFUSAL_MARKER)) return "";
-  const headline = trimmed.slice(REFUSAL_MARKER.length).split("\n", 1)[0]?.trimStart() ?? "";
-  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);
-}
-function to_block2(raw) {
-  const text = time_reported_failure.result_text(raw.content);
-  const is_error = raw.is_error ?? void 0;
-  return {
-    ...block_names(raw),
-    input: raw.input,
-    is_error,
-    has_failure_line: time_reported_failure.has_failure_line(text),
-    followup_stages: time_followup_stage.read_stages(text),
-    error_text: is_error === true ? text.slice(0, ERROR_TEXT_LIMIT) : "",
-    refusal_guard: is_error === true ? guard_from_refusal(text) : "",
-    token_lines: is_error === true ? [] : token_lines_of(text),
-    background_id: time_background.launch_id(text),
-    agent_id: time_background.agent_launch_id(text)
-  };
-}
-function to_blocks2(content) {
-  return typeof content === "string" || content === null || content === void 0 ? [] : content.map((block) => to_block2(block));
-}
-function message_fields(message) {
-  return { message_id: message?.id ?? NO_MESSAGE_ID, blocks: to_blocks2(message?.content) };
-}
-function notice_text(data) {
-  const attachment = json_value.is_record(data.attachment) ? data.attachment[PROMPT_KEY2] : void 0;
-  const carried = [data.message?.content, data.content, attachment];
-  return carried.find((one) => typeof one === "string") ?? "";
-}
-function to_line(data) {
-  const timestamp_ms = time_instant.parse_instant(data.timestamp);
-  if (timestamp_ms === void 0) return void 0;
-  return {
-    type: data.type ?? "",
-    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_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_line3,
-  parse_text
-};
-
-// scripts/time-runtime/time-writes.ts
-function bash_writes(command) {
-  const segment = time_bundle_call.write_segment(command);
-  return time_bundle_call.is_in_place_sed(segment) ? time_bundle_call.targets_in(segment) : [];
-}
-function tool_writes(name, input) {
-  if (time_markers.tool_marker(name, input) !== time_markers.EDIT_MARKER) return [];
-  return time_bundle_call.tool_targets(input);
-}
-var time_writes = {
-  bash_writes,
-  tool_writes
-};
-
-// scripts/time-runtime/time-tool-call.ts
-var { NO_MESSAGE_ID: NO_MESSAGE_ID2 } = time_transcript_line;
-var UNKNOWN_TOOL = "unknown";
-var NO_CALL = {
-  label: "",
-  josh_command: "",
-  josh_commands: [],
-  josh_signatures: [],
-  check_key: time_single_check.NO_CHECK,
-  marker: time_markers.NO_MARKER,
-  message_id: NO_MESSAGE_ID2,
-  writes: [],
-  issue: time_markers.NO_ISSUE,
-  reads_background: time_background.NO_BACKGROUND,
-  ...time_bundle_call.not_bundleable()
-};
-var UNKNOWN_CALL = {
-  label: UNKNOWN_TOOL,
-  josh_command: "",
-  josh_commands: [],
-  josh_signatures: [],
-  check_key: time_single_check.NO_CHECK,
-  marker: time_markers.NO_MARKER,
-  message_id: NO_MESSAGE_ID2,
-  writes: [],
-  issue: time_markers.NO_ISSUE,
-  reads_background: time_background.NO_BACKGROUND,
-  ...time_bundle_call.not_bundleable()
-};
-function non_bash_call(name, input, message_id) {
-  return {
-    label: name,
-    josh_command: "",
-    josh_commands: [],
-    josh_signatures: [],
-    check_key: time_single_check.NO_CHECK,
-    marker: time_markers.tool_marker(name, input),
-    message_id,
-    writes: time_writes.tool_writes(name, input),
-    issue: time_markers.NO_ISSUE,
-    // A non-Bash tool joins a backgrounded command too — `BashOutput` carries the shell id in a
-    // field of its own, `Monitor` names the same `…/tasks/<id>.output` path in a command — so the
-    // same reader is asked here rather than the field being left empty for every tool but `Bash`.
-    reads_background: time_background.read_id_of(input),
-    ...time_bundle_call.tool_facts(name, input)
-  };
-}
-function bash_call(input, message_id) {
-  const command = time_shell.bash_command(input);
-  const josh_command = time_shell.josh_command_of(command);
-  return {
-    label: time_shell.bash_label(command),
-    josh_command,
-    josh_commands: time_shell.josh_commands_of(command),
-    josh_signatures: time_shell.josh_signatures_of(command),
-    check_key: time_single_check.check_key(josh_command, command),
-    marker: time_markers.bash_marker(command),
-    message_id,
-    writes: time_writes.bash_writes(command),
-    issue: time_markers.bash_issue(command),
-    reads_background: time_background.read_id_of(input),
-    ...time_bundle_call.bash_facts(command)
-  };
-}
-function to_tool_call(name, input, message_id) {
-  if (name !== cost_blocks.BASH_TOOL) return non_bash_call(name, input, message_id);
-  return bash_call(input, message_id);
-}
-var time_tool_call = {
-  UNKNOWN_TOOL,
-  NO_CALL,
-  UNKNOWN_CALL,
-  to_tool_call
-};
-
-// scripts/time-runtime/time-spans.ts
-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";
-var MODEL_CATEGORY = "model";
-var TOOL_CATEGORY = "tool";
-var HUMAN_CATEGORY = "human";
-var OK_OUTCOME = "ok";
-var FAILED_OUTCOME = "failed";
-var UNKNOWN_OUTCOME = "unknown";
-var NO_RESULT = {
-  call_id: "",
-  outcome: UNKNOWN_OUTCOME,
-  refusal_guard: "",
-  background_id: time_background.NO_BACKGROUND,
-  followup_stages: time_followup_stage.NO_STAGES
-};
-function tool_use_blocks(lines) {
-  return lines.flatMap(
-    (line) => line.blocks.filter((block) => block.type === cost_blocks.TOOL_USE_TYPE && block.id !== "").map((block) => ({ block, message_id: line.message_id }))
-  );
-}
-function collect_calls(lines) {
-  return new Map(
-    tool_use_blocks(lines).map(({ block, message_id }) => [
-      block.id,
-      to_tool_call2(block.name, block.input, message_id)
-    ])
-  );
-}
-function result_block(line) {
-  return line.blocks.find((block) => block.type === cost_blocks.TOOL_RESULT_TYPE);
-}
-function event_of(line, category, call, result = NO_RESULT) {
-  return { timestamp_ms: line.timestamp_ms, branch: line.branch, category, ...result, ...call };
-}
-function outcome_of(result, call) {
-  if (time_reported_failure.is_reported_failure(call.josh_command, result.has_failure_line)) {
-    return FAILED_OUTCOME;
-  }
-  if (result.is_error === void 0) return UNKNOWN_OUTCOME;
-  return result.is_error ? FAILED_OUTCOME : OK_OUTCOME;
-}
-function facts_of(result, call) {
-  return {
-    call_id: result.result_id,
-    outcome: outcome_of(result, call),
-    refusal_guard: result.refusal_guard,
-    background_id: result.background_id,
-    followup_stages: result.followup_stages
-  };
-}
-function user_event(line, calls) {
-  const result = result_block(line);
-  if (result === void 0) return event_of(line, HUMAN_CATEGORY, NO_CALL2);
-  const call = calls.get(result.result_id) ?? UNKNOWN_CALL2;
-  return event_of(line, TOOL_CATEGORY, call, facts_of(result, call));
-}
-function to_event(line, calls) {
-  if (line.type === ASSISTANT_TYPE) {
-    return event_of(line, MODEL_CATEGORY, { ...NO_CALL2, message_id: line.message_id });
-  }
-  return line.type === USER_TYPE ? user_event(line, calls) : void 0;
-}
-function to_events(lines, calls) {
-  return lines.map((line) => to_event(line, calls)).filter((event) => event !== void 0).toSorted((left, right) => left.timestamp_ms - right.timestamp_ms);
-}
-function equal_durations(duration_ms) {
-  return { duration_ms, own_duration_ms: duration_ms };
-}
-function no_background() {
-  const none = time_background.NO_BACKGROUND;
-  return {
-    background_id: none,
-    reads_background: none,
-    background_command: none,
-    background_ended_ms: time_background.NO_FINISH
-  };
-}
-function background_fields(event, finished) {
-  return {
-    background_id: event.background_id,
-    reads_background: event.reads_background,
-    background_command: time_background.NO_BACKGROUND,
-    background_ended_ms: finished.get(event.background_id) ?? time_background.NO_FINISH
-  };
-}
-function result_facts_of(event) {
-  return {
-    call_id: event.call_id,
-    outcome: event.outcome,
-    refusal_guard: event.refusal_guard,
-    followup_stages: event.followup_stages
-  };
-}
-function to_spans(events, finished) {
-  return events.slice(1).map((event, index) => ({
-    category: event.category,
-    label: event.label,
-    josh_command: event.josh_command,
-    josh_commands: event.josh_commands,
-    josh_signatures: event.josh_signatures,
-    check_key: event.check_key,
-    marker: event.marker,
-    is_bundleable: event.is_bundleable,
-    targets: event.targets,
-    is_writing: event.is_writing,
-    may_write: event.may_write,
-    has_prior_reference: event.has_prior_reference,
-    writes: event.writes,
-    message_id: event.message_id,
-    issue: event.issue,
-    branch: event.branch,
-    ...result_facts_of(event),
-    is_continuation: false,
-    ...background_fields(event, finished),
-    ended_ms: event.timestamp_ms,
-    ...equal_durations(event.timestamp_ms - (events[index]?.timestamp_ms ?? event.timestamp_ms))
-  }));
-}
-function parse_timeline(text) {
-  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**: 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)))
-  };
-}
-function has_transcript_data(span_count) {
-  return span_count > 0;
-}
-var time_spans = {
-  ASSISTANT_TYPE,
-  MODEL_CATEGORY,
-  TOOL_CATEGORY,
-  HUMAN_CATEGORY,
-  OK_OUTCOME,
-  FAILED_OUTCOME,
-  UNKNOWN_OUTCOME,
-  NO_MESSAGE_ID: NO_MESSAGE_ID3,
-  UNKNOWN_TOOL: UNKNOWN_TOOL2,
-  has_transcript_data,
-  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.
-  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_line4,
-  parse_timeline
-};
-
-// scripts/time-runtime/time-round-trips.ts
-var CALLS_PER_ROUND_TRIP_FLOOR = 1.5;
-var DENSITY_DECIMALS = 2;
-var NONE = 0;
-function is_tool(span) {
-  return span.category === time_spans.TOOL_CATEGORY;
-}
-function is_model(span) {
-  return span.category === time_spans.MODEL_CATEGORY;
-}
-function started_ms2(span) {
-  return span.ended_ms - span.duration_ms;
-}
-function in_time_order(spans) {
-  return spans.toSorted((left, right) => started_ms2(left) - started_ms2(right));
-}
-function is_tool_at(spans, index) {
-  const span = spans[index];
-  return span !== void 0 && is_tool(span);
-}
-function is_call(span) {
-  return is_tool(span) && !span.is_continuation;
-}
-function count_calls(spans) {
-  return spans.filter((span) => is_call(span)).length;
-}
-function previous_break(spans, index) {
-  for (let back = index - 1; back >= 0; back -= 1) {
-    const span = spans[back];
-    if (span === void 0 || !is_model(span)) return span;
-  }
-  return void 0;
-}
-function continues_turn(spans, index, message_id) {
-  if (message_id === time_spans.NO_MESSAGE_ID) return false;
-  const earlier = previous_break(spans, index);
-  return earlier !== void 0 && !earlier.is_continuation && earlier.message_id === message_id;
-}
-function opens_round_trip(spans, index) {
-  const span = spans[index];
-  if (span === void 0 || !is_tool(span) || span.is_continuation || is_tool_at(spans, index - 1)) {
-    return false;
-  }
-  return !continues_turn(spans, index, span.message_id);
-}
-function open_trip(walk) {
-  walk.open = [];
-  walk.trips.push(walk.open);
-}
-function place_call(walk, span) {
-  if (is_call(span)) walk.open?.push(span);
-}
-function step_trip(walk, span, is_opener) {
-  if (is_opener) open_trip(walk);
-  if (is_tool(span)) place_call(walk, span);
-  else if (!is_model(span)) walk.open = void 0;
-}
-function group_round_trips(spans) {
-  const ordered = in_time_order(spans);
-  const walk = { trips: [], open: void 0 };
-  for (const [index, span] of ordered.entries()) {
-    step_trip(walk, span, opens_round_trip(ordered, index));
-  }
-  return walk.trips;
-}
-function count_round_trips(spans) {
-  return group_round_trips(spans).length;
-}
-function turn_key(span, index) {
-  return span.message_id === time_spans.NO_MESSAGE_ID ? `#${String(index)}` : span.message_id;
-}
-function count_turns(spans) {
-  const keys = spans.filter((span) => is_model(span)).map((span, index) => turn_key(span, index));
-  return new Set(keys).size;
-}
-function per_round_trip(total, round_trip_count) {
-  if (round_trip_count === NONE) return NONE;
-  return total / round_trip_count;
-}
-function format_density(density) {
-  return density.toFixed(DENSITY_DECIMALS);
-}
-function is_below_floor(density) {
-  return density > NONE && density < CALLS_PER_ROUND_TRIP_FLOOR;
-}
-var time_round_trips = {
-  CALLS_PER_ROUND_TRIP_FLOOR,
-  count_calls,
-  count_round_trips,
-  // 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 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 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,
-  // 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
-};
-
-// scripts/time-runtime/time-agent-bundles.ts
-var NONE2 = 0;
-var ONE = 1;
-var MIN_GROUP = 2;
-function is_launch2(span) {
-  return span.category === time_spans.TOOL_CATEGORY && !span.is_continuation && time_bundle_call.is_launch_tool(span.label);
-}
-function new_walk() {
-  return { closed: [], open: NONE2, wrote_since: false, turn_id: time_spans.NO_MESSAGE_ID };
-}
-function close_group(walk) {
-  if (walk.open >= MIN_GROUP) walk.closed.push(walk.open);
-  walk.open = NONE2;
-}
-function is_same_turn(walk, span) {
-  return span.message_id !== time_spans.NO_MESSAGE_ID && span.message_id === walk.turn_id;
-}
-function open_turn(walk, span) {
-  if (walk.wrote_since || span.has_prior_reference) close_group(walk);
-  walk.open += ONE;
-  walk.turn_id = span.message_id;
-  walk.wrote_since = false;
-}
-function step(walk, span) {
-  if (span.is_writing) {
-    walk.wrote_since = true;
-    return;
-  }
-  if (!is_launch2(span) || is_same_turn(walk, span)) return;
-  open_turn(walk, span);
-}
-function agent_bundles(spans) {
-  const walk = new_walk();
-  for (const span of time_round_trips.in_time_order(spans)) step(walk, span);
-  close_group(walk);
-  return walk.closed;
-}
-var time_agent_bundles = { agent_bundles };
-
-// scripts/time-runtime/time-bundles.ts
-var { unmeasured_row: unmeasured_row2 } = time_format;
-var HEADING = "Bundling:";
-var SEQUENCE_LABEL = "bundleable sequences";
-var RECOVERABLE_LABEL = "recoverable round trips";
-var SAVING_LABEL = "recoverable wait";
-var BY_TOOL_LABEL = "recoverable by tool";
-var AGENT_ROW_LABEL = "Agent";
-var ROW_INDENT = "  ";
-var MIN_SEQUENCE = 2;
-var ONE_CALL = 1;
-var NONE3 = 0;
-var PATH_SEPARATOR2 = "/";
-var FIRST_CALL = 1;
-var NO_LABEL = "";
-var NO_BUNDLES = {
-  sequence_count: 0,
-  longest_sequence: 0,
-  recoverable_round_trips: 0,
-  by_tool: [],
-  unattributed_round_trips: 0,
-  is_measured: false
-};
-function contains_segments(whole, part) {
-  if (whole.startsWith(`${part}${PATH_SEPARATOR2}`)) return true;
-  return whole.endsWith(`${PATH_SEPARATOR2}${part}`) || whole.includes(`${PATH_SEPARATOR2}${part}${PATH_SEPARATOR2}`);
-}
-function is_related(left, right) {
-  if (left === right) return true;
-  return contains_segments(left, right) || contains_segments(right, left);
-}
-function shares_target(left, right) {
-  return left.some((one) => right.some((other) => is_related(one, other)));
-}
-function is_dependent(earlier, later) {
-  if (earlier.is_writing && later.is_writing) return false;
-  return shares_target(earlier.targets, later.targets);
-}
-function conflicts(span, sequence) {
-  return sequence.some((earlier) => is_dependent(earlier, span));
-}
-function is_call2(span) {
-  return span.category === time_spans.TOOL_CATEGORY && !span.is_continuation;
-}
-function is_turn_boundary(span) {
-  return span.category === time_spans.MODEL_CATEGORY;
-}
-function new_walk2() {
-  return { pending: [], sequence: [], closed: [] };
-}
-function flush(walk) {
-  if (walk.sequence.length >= MIN_SEQUENCE) walk.closed.push(walk.sequence);
-  walk.sequence = [];
-}
-function extend(walk, span) {
-  if (conflicts(span, walk.sequence)) flush(walk);
-  walk.sequence.push(span);
-}
-function close_trip(walk) {
-  const [only] = walk.pending;
-  if (walk.pending.length === ONE_CALL && only?.is_bundleable === true) extend(walk, only);
-  else if (walk.pending.length > NONE3) flush(walk);
-  walk.pending = [];
-}
-function is_same_turn2(span, pending) {
-  const [first] = pending;
-  if (first === void 0 || span.is_continuation || span.message_id === time_spans.NO_MESSAGE_ID) {
-    return false;
-  }
-  return span.message_id === first.message_id;
-}
-function step2(walk, span) {
-  if (is_call2(span)) {
-    walk.pending.push(span);
-    return;
-  }
-  if (is_same_turn2(span, walk.pending)) return;
-  close_trip(walk);
-  if (!is_turn_boundary(span)) flush(walk);
-}
-function longest_of(sizes) {
-  return sizes.length === NONE3 ? NONE3 : Math.max(...sizes);
-}
-function recoverable_of(sizes) {
-  return sizes.reduce((sum, size) => sum + size - ONE_CALL, NONE3);
-}
-function sizes_of(closed) {
-  return closed.map((sequence) => sequence.length);
-}
-function tally_for(tallies, label) {
-  const found = tallies.get(label);
-  if (found !== void 0) return found;
-  const created = { sequence_count: NONE3, recoverable_round_trips: NONE3 };
-  tallies.set(label, created);
-  return created;
-}
-function count_trip(tallies, counted, label) {
-  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) {
-  const counted = /* @__PURE__ */ new Set();
-  for (const span of sequence.slice(FIRST_CALL)) {
-    if (span.label !== NO_LABEL) count_trip(tallies, counted, span.label);
-  }
-}
-function by_weight(left, right) {
-  if (left.recoverable_round_trips !== right.recoverable_round_trips) {
-    return right.recoverable_round_trips - left.recoverable_round_trips;
-  }
-  return left.label.localeCompare(right.label);
-}
-function tool_rows(closed) {
-  const tallies = /* @__PURE__ */ new Map();
-  for (const sequence of closed) tally_sequence(tallies, sequence);
-  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);
-}
-function with_agent_row(rows, agent_sizes) {
-  const recoverable_round_trips = recoverable_of(agent_sizes);
-  if (recoverable_round_trips === NONE3) return [...rows];
-  const row = {
-    label: AGENT_ROW_LABEL,
-    sequence_count: agent_sizes.length,
-    recoverable_round_trips
-  };
-  return [...rows, row].toSorted(by_weight);
-}
-function build_bundles(spans) {
-  const walk = new_walk2();
-  for (const span of time_round_trips.in_time_order(spans)) step2(walk, span);
-  close_trip(walk);
-  flush(walk);
-  const sizes = sizes_of(walk.closed);
-  const agent_sizes = time_agent_bundles.agent_bundles(spans);
-  const by_tool = with_agent_row(tool_rows(walk.closed), agent_sizes);
-  const recoverable_round_trips = recoverable_of(sizes) + recoverable_of(agent_sizes);
-  return {
-    sequence_count: sizes.length + agent_sizes.length,
-    longest_sequence: Math.max(longest_of(sizes), longest_of(agent_sizes)),
-    recoverable_round_trips,
-    by_tool,
-    unattributed_round_trips: recoverable_round_trips - attributed_of(by_tool),
-    is_measured: time_spans.has_transcript_data(spans.length)
-  };
-}
-function open_sequence(spans) {
-  const walk = new_walk2();
-  for (const span of time_round_trips.in_time_order(spans)) step2(walk, span);
-  return walk.sequence;
-}
-function sequence_suffix(totals) {
-  return `longest ${String(totals.longest_sequence)} turn(s)`;
-}
-function recoverable_suffix(totals, round_trip_count) {
-  const share = time_format.format_share(totals.recoverable_round_trips, round_trip_count);
-  return `${share} of ${String(round_trip_count)} round trip(s)`;
-}
-function saving_line(totals, model_ms_per_round_trip) {
-  const saved_ms = totals.recoverable_round_trips * model_ms_per_round_trip;
-  const rate = `at ${time_format.format_seconds(model_ms_per_round_trip)} model time per round trip`;
-  return time_format.format_row(SAVING_LABEL, saved_ms, rate);
-}
-function by_tool_suffix(totals) {
-  const attributed = totals.recoverable_round_trips - totals.unattributed_round_trips;
-  return `${String(attributed)} of ${String(totals.recoverable_round_trips)} attributed`;
-}
-function tool_row(row) {
-  return time_format.format_columns(
-    `${ROW_INDENT}${row.label}`,
-    String(row.recoverable_round_trips),
-    `in ${String(row.sequence_count)} sequence(s)`
-  );
-}
-function by_tool_lines(totals) {
-  const heading = time_format.format_columns(
-    BY_TOOL_LABEL,
-    String(totals.by_tool.length),
-    by_tool_suffix(totals)
-  );
-  const rows = totals.by_tool.slice(NONE3, time_format.MAX_ROWS).map((row) => tool_row(row));
-  return [heading, ...rows, ...time_format.overflow_line(totals.by_tool.length)];
-}
-function measured_lines(totals, price) {
-  return [
-    time_format.format_columns(
-      SEQUENCE_LABEL,
-      String(totals.sequence_count),
-      sequence_suffix(totals)
-    ),
-    time_format.format_columns(
-      RECOVERABLE_LABEL,
-      String(totals.recoverable_round_trips),
-      recoverable_suffix(totals, price.round_trip_count)
-    ),
-    saving_line(totals, price.model_ms_per_round_trip),
-    ...by_tool_lines(totals)
-  ];
-}
-var LABELS = [SEQUENCE_LABEL, RECOVERABLE_LABEL, SAVING_LABEL, BY_TOOL_LABEL];
-function no_divisor_lines() {
-  return LABELS.map((label) => time_format.format_columns(label, "", time_format.NO_CALLS));
-}
-function bundle_lines(totals, price) {
-  const heading = ["", HEADING];
-  if (!totals.is_measured) return [...heading, ...LABELS.map((label) => unmeasured_row2(label))];
-  if (price.round_trip_count === NONE3) return [...heading, ...no_divisor_lines()];
-  return [...heading, ...measured_lines(totals, price)];
-}
-var time_bundles = {
-  HEADING,
-  BY_TOOL_LABEL,
-  NO_BUNDLES,
-  build_bundles,
-  bundle_lines,
-  is_dependent,
-  open_sequence,
-  shares_target
-};
-
-// scripts/time-runtime/time-command-key.ts
-var UNNAMED_KEY = "";
-function command_key(span) {
-  if (span.label === time_spans.UNKNOWN_TOOL) return UNNAMED_KEY;
-  return span.josh_command === "" ? span.label : span.josh_command;
-}
-var time_command_key = { UNNAMED_KEY, command_key };
-
-// scripts/time-runtime/time-call-identity.ts
-var IDENTITY_SEPARATOR = "\0";
-function identity_of(call) {
-  return [
-    time_command_key.command_key(call),
-    call.check_key,
-    [...call.targets].toSorted((left, right) => left.localeCompare(right)).join(",")
-  ].join(IDENTITY_SEPARATOR);
-}
-var time_call_identity = { identity_of };
-
-// scripts/time-runtime/time-batch-guard.ts
-var CONSECUTIVE_LIMIT = 3;
-var REFIRE_EVERY = CONSECUTIVE_LIMIT;
-var ONE_TURN = 1;
-var NONE4 = 0;
-var NOTICE_REFIRE_EVERY = ONE_TURN;
-var NAMED_CANDIDATE_COUNT = 3;
-var SEQUENCE_BEFORE_LIMIT = CONSECUTIVE_LIMIT - ONE_TURN;
-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); it never authorizes weakening a verification gate or a review. Nothing to pair? Reissue it unchanged. ${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) {
-  if (call.name === WHOLE_FILE_WRITE_TOOL) return false;
-  return time_bundle_call.call_facts(call.name, call.input).is_bundleable;
-}
-function is_notice_call(call) {
-  return call.name === WHOLE_FILE_WRITE_TOOL;
-}
-function is_read_only_call(call) {
-  const facts = time_bundle_call.call_facts(call.name, call.input);
-  return facts.is_bundleable && !facts.may_write;
-}
-function depends_on_sequence(sequence, facts) {
-  return sequence.some((span) => time_bundles.shares_target(span.targets, facts.targets));
-}
-function sequence_started_ms(sequence) {
-  return sequence[0]?.ended_ms ?? NONE4;
-}
-function turns_since(sequence, last_fired_ms) {
-  return sequence.filter((span) => span.ended_ms > last_fired_ms).length;
-}
-function is_sequence_at_limit(sequence, facts, last_fired_ms, refire_every) {
-  if (sequence.length < SEQUENCE_BEFORE_LIMIT || depends_on_sequence(sequence, facts)) return false;
-  if (last_fired_ms < sequence_started_ms(sequence)) return true;
-  return turns_since(sequence, last_fired_ms) >= refire_every;
-}
-function is_at_limit(spans, call, last_fired_ms, refire_every) {
-  return is_sequence_at_limit(
-    time_bundles.open_sequence(spans),
-    time_bundle_call.call_facts(call.name, call.input),
-    last_fired_ms,
-    refire_every
-  );
-}
-var GUARD_LABEL = time_transcript_line.guard_from_refusal(REASON);
-function is_reissued_refusal(spans, call) {
-  const identity = time_call_identity.identity_of(
-    time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID)
-  );
-  return spans.some(
-    (span) => span.refusal_guard === GUARD_LABEL && time_call_identity.identity_of(span) === identity
-  );
-}
-function should_block(text, call, refused_at_ms, refire_every = REFIRE_EVERY) {
-  if (!is_guarded_call(call)) return false;
-  const { spans } = time_spans.parse_timeline(text);
-  if (is_reissued_refusal(spans, call)) return false;
-  return is_at_limit(spans, call, refused_at_ms, refire_every);
-}
-function should_notify(text, call, notified_at_ms) {
-  if (!is_notice_call(call)) return false;
-  const { spans } = time_spans.parse_timeline(text);
-  return is_at_limit(spans, call, notified_at_ms, NOTICE_REFIRE_EVERY);
-}
-function describe_span(span) {
-  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((path5) => path5 !== "" && time_bundle_call.has_extension(path5));
-  return [...new Set(paths)];
-}
-function read_fold_directive(sequence) {
-  const paths = read_targets(sequence);
-  if (paths.length < FOLD_MINIMUM) return "";
-  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((path5) => path5 !== "" && time_bundle_call.has_extension(path5));
-  return [...new Set(paths)];
-}
-function write_fold_directive(sequence) {
-  const paths = write_targets(sequence);
-  if (paths.length < FOLD_MINIMUM) return "";
-  return ` Fold them into one \`pnpm josh edit:files\` call with a plan over: ${paths.join(" ")}.`;
-}
-function name_candidates(calls) {
-  if (calls.length === NONE4) return "";
-  const named = calls.map((call) => describe_span(call)).join(", ");
-  const folds = `${read_fold_directive(calls)}${write_fold_directive(calls)}`;
-  return ` Just issued one per turn, so at least these could have shared a turn: ${named}.${folds}`;
-}
-function recent_candidates(tail) {
-  return name_candidates(
-    time_bundles.open_sequence(time_spans.parse_timeline(tail).spans).slice(-NAMED_CANDIDATE_COUNT)
-  );
-}
-function pairing_candidates(tail, call) {
-  const sequence = time_bundles.open_sequence(time_spans.parse_timeline(tail).spans);
-  if (call === void 0 || sequence.length === NONE4) {
-    return name_candidates(sequence.slice(-NAMED_CANDIDATE_COUNT));
-  }
-  const facts = time_bundle_call.call_facts(call.name, call.input);
-  if (!facts.is_bundleable || depends_on_sequence(sequence, facts)) return "";
-  const current = time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID);
-  return name_candidates([...sequence.slice(ONE_TURN - NAMED_CANDIDATE_COUNT), current]);
-}
-var STAMP_PREFIX = "josh-batch-guard-";
-var NOTICE_STAMP_PREFIX = "josh-batch-guard-notice-";
-var time_batch_guard = {
-  CONSECUTIVE_LIMIT,
-  GUARD_LABEL,
-  LANE_NOTICE,
-  NOTICE,
-  NOTICE_REFIRE_EVERY,
-  NOTICE_STAMP_PREFIX,
-  REASON,
-  REFIRE_EVERY,
-  SEQUENCE_BEFORE_LIMIT,
-  STAMP_PREFIX,
-  is_guarded_call,
-  is_notice_call,
-  is_read_only_call,
-  pairing_candidates,
-  recent_candidates,
-  should_block,
-  should_notify
-};
-
-// scripts/time-runtime/time-hook-transcript.ts
-import path4 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 = path4.dirname(transcript_path);
-  const session_id = path4.basename(transcript_path, TRANSCRIPT_EXTENSION);
-  const file_name = `${AGENT_PREFIX}${agent_id}${TRANSCRIPT_EXTENSION}`;
-  return path4.join(cost_transcript.unit_directory(directory, session_id), file_name);
-}
-function transcript_of(transcript_path, agent_id) {
-  if (!is_agent_id(agent_id) || !transcript_path.endsWith(TRANSCRIPT_EXTENSION)) {
-    return transcript_path;
-  }
-  return fork_path(transcript_path, agent_id);
-}
-var time_hook_transcript = {
-  fork_path,
-  transcript_of
-};
-
-// scripts/time-runtime/time-density-hook.ts
-import { closeSync as closeSync2, fstatSync, openSync as openSync2, readSync } from "node:fs";
-import { z as z6 } from "zod";
-
-// scripts/time-runtime/time-density.ts
-var MIN_ROUND_TRIPS = 10;
-var NOTICE_INTERVAL_MS = 3e5;
-var ONE_CALL2 = 1;
-var NONE5 = 0;
-function has_whole_tail(text) {
-  const last = text.split("\n").findLast((line) => line.trim() !== "");
-  return last !== void 0 && time_spans.parse_line(last) !== void 0;
-}
-function assistant_lines(text) {
-  return text.split("\n").map((line) => time_spans.parse_line(line)).filter((line) => line?.type === time_spans.ASSISTANT_TYPE);
-}
-function last_turn_calls(text) {
-  if (!has_whole_tail(text)) return NONE5;
-  const lines = assistant_lines(text);
-  const message_id = lines.at(-1)?.message_id;
-  if (message_id === void 0 || message_id === time_spans.NO_MESSAGE_ID) return NONE5;
-  return lines.filter((line) => line.message_id === message_id).flatMap((line) => line.blocks).filter((block) => block.type === cost_blocks.TOOL_USE_TYPE).length;
-}
-function read_window(text) {
-  const { spans } = time_spans.parse_timeline(text);
-  const round_trip_count = time_round_trips.count_round_trips(spans);
-  const call_count = time_round_trips.count_calls(spans);
-  return {
-    density: time_round_trips.per_round_trip(call_count, round_trip_count),
-    round_trip_count,
-    turn_calls: last_turn_calls(text)
-  };
-}
-function is_due(reading, since_last_ms) {
-  if (reading.round_trip_count < MIN_ROUND_TRIPS || reading.turn_calls !== ONE_CALL2 || !time_round_trips.is_below_floor(reading.density)) {
-    return false;
-  }
-  return since_last_ms >= NOTICE_INTERVAL_MS;
-}
-function format_notice(reading, candidates = "") {
-  const density = time_round_trips.format_density(reading.density);
-  const floor = time_round_trips.format_density(time_round_trips.CALLS_PER_ROUND_TRIP_FLOOR);
-  return `\u26A0 batching: ${density} calls per round trip over the last ${String(reading.round_trip_count)}, under the ${floor} floor, and this turn issued one call. Independent reads, greps, gh queries and edits go out together; the criterion is whether this call's input needs another call's result, not what kind of call it is \u2014 prompts/collaboration-workflow/turn-batching.md.${candidates}`;
-}
-var time_density = {
-  MIN_ROUND_TRIPS,
-  NOTICE_INTERVAL_MS,
-  format_notice,
-  is_due,
-  last_turn_calls,
-  read_window
-};
-
-// scripts/time-runtime/time-density-hook.ts
-var TAIL_BYTES = 262144;
-var FILE_START = 0;
-var NOTICE_PREFIX = "josh-density-notice-";
-var NEVER_MS = 0;
-var payload_schema = z6.object({
-  transcript_path: z6.string().min(1).optional(),
-  // **`nullish`, not `optional`.** A payload spelling the absent agent as `null` has to read as "no
-  // fork"; rejected, it would fail `safeParse` for the whole payload and silence the line for every
-  // edit of the main line — the opposite of this module's stated failure direction.
-  agent_id: z6.string().nullish()
-});
-var notice_schema = z6.object({ notified_at_ms: z6.number() });
-var call_schema = z6.object({ tool_name: z6.string().min(1), tool_input: z6.unknown() });
-function parse_transcript_path(raw_payload) {
-  const parsed = payload_schema.safeParse(JSON.parse(raw_payload));
-  if (!parsed.success || parsed.data.transcript_path === void 0) return void 0;
-  return time_hook_transcript.transcript_of(parsed.data.transcript_path, parsed.data.agent_id);
-}
-function parse_call(raw_payload) {
-  const parsed = call_schema.safeParse(JSON.parse(raw_payload));
-  if (!parsed.success) return void 0;
-  return { name: parsed.data.tool_name, input: parsed.data.tool_input };
-}
-function read_tail(file_path, max_bytes = TAIL_BYTES) {
-  const descriptor = openSync2(file_path, "r");
-  try {
-    const { size } = fstatSync(descriptor);
-    const length = Math.min(size, max_bytes);
-    const buffer = Buffer.alloc(length);
-    const read = readSync(descriptor, buffer, FILE_START, length, size - length);
-    return buffer.subarray(FILE_START, read).toString("utf8");
-  } finally {
-    closeSync2(descriptor);
-  }
-}
-function notice_path(transcript_path) {
-  return stamp_file.stamp_path(NOTICE_PREFIX, transcript_path);
-}
-function last_notice_ms(source) {
-  const raw = stamp_file.read_stamp_text(source);
-  if (raw === void 0) return NEVER_MS;
-  return json_value.parse_with(raw, notice_schema)?.notified_at_ms ?? NEVER_MS;
-}
-function arm_throttle(target2, now_ms) {
-  try {
-    stamp_file.write_stamp(target2, { notified_at_ms: now_ms });
-  } catch {
-  }
-}
-function notice_for(raw_payload, now_ms) {
-  const transcript_path = parse_transcript_path(raw_payload);
-  if (transcript_path === void 0) return void 0;
-  const tail = read_tail(transcript_path);
-  const reading = time_density.read_window(tail);
-  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(target2, now_ms);
-  return time_density.format_notice(reading, candidates);
-}
-function density_notice(raw_payload, now_ms = Date.now()) {
-  try {
-    return notice_for(raw_payload, now_ms);
-  } catch {
-    return void 0;
-  }
-}
-var time_density_hook = {
-  density_notice,
-  notice_path,
-  read_tail
-};
-
-export {
-  cost_blocks,
-  ESLINT_EDIT_CACHE_FLAGS,
-  time_shell,
-  time_bundle_call,
-  CHECK_STATUS_PENDING,
-  CHECK_STATUS_FAIL,
-  read_string,
-  parse_pr_state_snapshot,
-  is_merge_conflict,
-  is_coderabbit_check,
-  is_required_check,
-  describe_pr_failure,
-  evaluate_pr_state,
-  is_review_decision_decisive,
-  PrConflictError,
-  time_reported_failure,
-  cost_attribute,
-  time_transcript_line,
-  time_spans,
-  time_batch_guard,
-  time_hook_transcript,
-  time_density_hook
-};