@joshuafolkken/kit 1.1166.0 → 1.1229.0

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

@@ -1,6 +1,11 @@
 import {
   ENV_FILE_NAME
 } from "./chunk-RKUAD3I6.js";
+import {
+  PLATFORM_TEMP_ROOT,
+  PROBE_TIMEOUT_MS,
+  stamp_file
+} from "./chunk-ELCN5LCH.js";
 
 // scripts/lib/json-value.ts
 function parse_or_undefined(text) {
@@ -176,6 +181,9 @@ var BACKLOG_COMMANDS = {
   },
   "backlog:stalled": {
     script: "scripts/backlog/backlog-stalled-cli.ts",
+    // A stall sends one Telegram warning (joshuafolkken/kit#3357). The `Stop` hook calls the detector
+    // 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"]]
@@ -194,7 +202,8 @@ var DOCUMENT_COMMANDS = {
     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"]]
+    reference: ["<file> <heading>", "automation", ["none"]],
+    is_bundled: true
   },
   "read:set": {
     script: "scripts/document/read-set-cli.ts",
@@ -311,6 +320,10 @@ var ISSUE_COMMANDS = {
 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,
@@ -366,11 +379,27 @@ var LANE_COMMANDS = {
     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"]]
+  },
+  // The lane-limit measurement (joshuafolkken/kit#3355): `.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",
+    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",
+    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/run-hold-cli.ts";
+var RUN_HOLD_SCRIPT = "scripts/run/hold/run-hold-cli.ts";
 var RUN_COMMANDS = {
   "run:hold": {
     script: RUN_HOLD_SCRIPT,
@@ -386,19 +415,22 @@ var RUN_COMMANDS = {
     default_script_arguments: ["--release"]
   },
   "run:tidy": {
-    script: "scripts/run/run-tidy-cli.ts",
+    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/run-carry-cli.ts",
+    script: "scripts/run/carry/run-carry-cli.ts",
+    // `--stopped` sends the stop confirmation, so the Telegram credentials come from `.env` as for
+    // `run:wake` below (joshuafolkken/kit#3357).
+    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:wake": {
-    script: "scripts/run/run-wake-cli.ts",
+    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.
@@ -408,7 +440,7 @@ var RUN_COMMANDS = {
     reference: ["[options]", "automation", ["processes", "notifications"]]
   },
   "run:cut": {
-    script: "scripts/run/run-cut-cli.ts",
+    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"]]
@@ -426,7 +458,7 @@ var RUN_COMMANDS = {
     reference: ["<issue> --output <path> [--repo <owner/repo>]", "automation", ["network"]]
   },
   "run:progress": {
-    script: "scripts/run/run-progress-cli.ts",
+    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: [
@@ -445,7 +477,9 @@ var RUN_COMMANDS = {
   // 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/run-entry-cli.ts",
+    script: "scripts/run/entry/run-entry-cli.ts",
+    // A `busy` hold or an `over` budget sends the stop confirmation (joshuafolkken/kit#3357).
+    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"]]
@@ -609,13 +643,13 @@ var AI_COMMANDS = {
     reference: ["[<owner/repo>]", "automation", ["none"]]
   },
   "run:merge": {
-    script: "scripts/run/run-merge-cli.ts",
+    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/run-review-cli.ts",
+    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"]]
@@ -634,7 +668,7 @@ var AI_COMMANDS = {
   // (`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/run-ship-cli.ts",
+    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: [
@@ -644,7 +678,7 @@ var AI_COMMANDS = {
     ]
   },
   "run:event": {
-    script: "scripts/run/run-event-cli.ts",
+    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: [
@@ -704,6 +738,614 @@ var CLONE_COMMANDS = {
   }
 };
 
+// scripts/gate/core-budget.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { readdirSync as readdirSync2 } from "node:fs";
+import { availableParallelism as availableParallelism2 } from "node:os";
+import path3 from "node:path";
+
+// scripts/josh/process-identity.ts
+import { execFileSync, spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { readFileSync, rmSync } from "node:fs";
+import { createServer } from "node:net";
+import path from "node:path";
+var PS_COMMAND = "/bin/ps";
+var FORMAT_FLAG = "-o";
+var START_TIME_FORMAT = "lstart=";
+var PID_FLAG = "-p";
+var PROBE_ENVIRONMENT = { TZ: "UTC", LC_ALL: "C" };
+var LIVENESS_SIGNAL = 0;
+var LOWEST_REAL_PID = 1;
+var PROC_START_FIELD_INDEX = 19;
+var BEACON_SCHEME = "socket:";
+var BEACON_SUFFIX = ".sock";
+var BEACON_PREFIX = `josh-process-identity-${String(process.getuid?.() ?? "")}-`;
+var BEACON_ID_LENGTH = 36;
+var BEACON_ID_PATTERN = /^[\da-f-]+$/u;
+var WINDOWS_PLATFORM = "win32";
+var SOCKET_PROBE_SOURCE = "const net=require('node:net');const socket=net.createConnection(process.argv[1]);socket.once('connect',()=>process.exit(0));socket.once('error',()=>process.exit(1));socket.setTimeout(1000,()=>process.exit(1));";
+var beacons = /* @__PURE__ */ new Map();
+var exit_cleanup = { is_registered: false };
+function is_live_pid(pid) {
+  if (pid < LOWEST_REAL_PID) return false;
+  try {
+    process.kill(pid, LIVENESS_SIGNAL);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function read_proc_start(pid) {
+  try {
+    const stat = readFileSync(`/proc/${String(pid)}/stat`, "utf8");
+    const fields = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/u);
+    const start = fields[PROC_START_FIELD_INDEX];
+    return start === void 0 ? void 0 : `proc:${start}`;
+  } catch {
+    return void 0;
+  }
+}
+function read_ps_start(pid) {
+  try {
+    const printed = execFileSync(
+      PS_COMMAND,
+      [FORMAT_FLAG, START_TIME_FORMAT, PID_FLAG, String(pid)],
+      {
+        encoding: "utf8",
+        timeout: PROBE_TIMEOUT_MS,
+        stdio: ["ignore", "pipe", "ignore"],
+        env: PROBE_ENVIRONMENT
+      }
+    ).trim();
+    return printed.length > 0 ? printed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var START_PROBES = { read_proc_start, read_ps_start };
+function safe_probe(probe, pid) {
+  try {
+    return probe(pid);
+  } catch {
+    return void 0;
+  }
+}
+function read_start(pid, probes = START_PROBES) {
+  return safe_probe(probes.read_proc_start, pid) ?? safe_probe(probes.read_ps_start, pid);
+}
+function close_beacon(token) {
+  const server = beacons.get(token);
+  if (server === void 0) return;
+  beacons.delete(token);
+  server.close();
+  rmSync(token.slice(BEACON_SCHEME.length), { force: true });
+}
+function close_beacons() {
+  for (const token of beacons.keys()) close_beacon(token);
+}
+function ensure_exit_cleanup() {
+  if (exit_cleanup.is_registered) return;
+  exit_cleanup.is_registered = true;
+  process.once("exit", close_beacons);
+}
+function ignore_beacon_error() {
+}
+function bind_beacon(target) {
+  return createServer().on("error", ignore_beacon_error).listen(target);
+}
+function try_bind_beacon(bind, target) {
+  try {
+    const server = bind(target);
+    return server.listening ? server : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function open_beacon(bind = bind_beacon) {
+  const target = path.join(PLATFORM_TEMP_ROOT, `${BEACON_PREFIX}${randomUUID()}${BEACON_SUFFIX}`);
+  const token = `${BEACON_SCHEME}${target}`;
+  const server = try_bind_beacon(bind, target);
+  if (server === void 0) return void 0;
+  server.unref();
+  beacons.set(token, server);
+  ensure_exit_cleanup();
+  return token;
+}
+function resolve_own_start(probes = START_PROBES, platform = process.platform) {
+  const start = read_start(process.pid, probes);
+  if (start !== void 0 || platform === WINDOWS_PLATFORM) return start;
+  return open_beacon();
+}
+function is_valid_beacon_name(name) {
+  if (!name.startsWith(BEACON_PREFIX) || !name.endsWith(BEACON_SUFFIX)) return false;
+  const id = name.slice(BEACON_PREFIX.length, -BEACON_SUFFIX.length);
+  return id.length === BEACON_ID_LENGTH && BEACON_ID_PATTERN.test(id);
+}
+function beacon_target(token) {
+  if (!token.startsWith(BEACON_SCHEME)) return void 0;
+  const target = token.slice(BEACON_SCHEME.length);
+  if (path.dirname(target) !== PLATFORM_TEMP_ROOT) return void 0;
+  return is_valid_beacon_name(path.basename(target)) ? target : void 0;
+}
+function is_live_beacon(target) {
+  return spawnSync(process.execPath, ["-e", SOCKET_PROBE_SOURCE, target], {
+    stdio: "ignore",
+    timeout: PROBE_TIMEOUT_MS
+  }).status === 0;
+}
+function has_matching_start(pid, recorded_start, read) {
+  const observed = read(pid);
+  return observed === void 0 ? void 0 : observed === recorded_start;
+}
+function matches_recorded_start(pid, recorded_start, read) {
+  const target = beacon_target(recorded_start);
+  return target === void 0 ? has_matching_start(pid, recorded_start, read) : is_live_beacon(target);
+}
+var own_probe = /* @__PURE__ */ new Map();
+function own_start() {
+  if (!own_probe.has(process.pid)) own_probe.set(process.pid, resolve_own_start());
+  return own_probe.get(process.pid);
+}
+function own_fields() {
+  const start = own_start();
+  return { pid: process.pid, ...start !== void 0 && { process_start: start } };
+}
+function is_same_process(pid, recorded_start, read = read_start) {
+  if (pid === void 0 || !is_live_pid(pid)) return false;
+  if (recorded_start === void 0) return void 0;
+  return matches_recorded_start(pid, recorded_start, read);
+}
+function is_own_process(pid, recorded_start) {
+  return pid === process.pid && recorded_start === own_start();
+}
+var process_identity = {
+  close_beacon,
+  is_live_pid,
+  is_own_process,
+  is_same_process,
+  open_beacon,
+  own_fields,
+  own_start,
+  read_start,
+  resolve_own_start
+};
+
+// scripts/josh/process-owner.ts
+import { z as z2 } from "zod";
+var process_owner_schema = z2.object({ pid: z2.number(), process_start: z2.string().optional() });
+
+// scripts/test/unit-worker-share.ts
+import { readdirSync } from "node:fs";
+import { availableParallelism } from "node:os";
+import path2 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(path2.join(directory, name))).length;
+}
+var NESTED_KEY = "JOSH_UNIT_RUN_MARKED";
+var NESTED_VALUE = "1";
+function is_nested_run() {
+  return process.env[NESTED_KEY] === NESTED_VALUE;
+}
+function resolve_unit_workers(available_cores, runs2) {
+  if (runs2 <= SOLO_RUNS) return void 0;
+  return Math.max(MIN_WORKERS, Math.floor(available_cores / runs2));
+}
+function current_share(available_cores = availableParallelism(), live_runs = live_run_count()) {
+  const own_run2 = is_nested_run() ? 0 : SOLO_RUNS;
+  return resolve_unit_workers(available_cores, live_runs + own_run2);
+}
+function is_worker_flag(argument) {
+  return WORKER_FLAGS.some((flag) => argument === flag || argument.startsWith(`${flag}=`));
+}
+function worker_arguments(vitest_arguments, share) {
+  if (share === void 0) return [];
+  if (vitest_arguments.some((argument) => is_worker_flag(argument))) return [];
+  return [`${WORKER_FLAG}=${String(share)}`];
+}
+function mark_run_started(target) {
+  try {
+    stamp_file.write_stamp(target, process_identity.own_fields());
+  } catch {
+  }
+}
+async function with_run_marker(run) {
+  if (is_nested_run()) return await run();
+  const target = marker_path();
+  mark_run_started(target);
+  process.env[NESTED_KEY] = NESTED_VALUE;
+  try {
+    return await run();
+  } finally {
+    process.env[NESTED_KEY] = "";
+    stamp_file.remove_stamp(target);
+  }
+}
+var unit_worker_share = {
+  MIN_WORKERS,
+  NESTED_KEY,
+  NESTED_VALUE,
+  RUN_PREFIX,
+  SOLO_RUNS,
+  current_share,
+  is_nested_run,
+  live_run_count,
+  marker_path,
+  read_marker,
+  resolve_unit_workers,
+  with_run_marker,
+  worker_arguments
+};
+
+// scripts/gate/core-budget.ts
+import { z as z3 } from "zod";
+var RESERVED_PREFIX = "josh-core-reserved-";
+var RESERVED_SUFFIX = ".json";
+var POLL_INTERVAL_MS = 50;
+var WAIT_CAP_MS = 12e4;
+var MIN_BUDGET = 1;
+var CORE_WEIGHTS = {
+  lint: 2,
+  type_check: 1,
+  spell_check: 1,
+  eslint_scan: 1
+};
+var HELD_KEY = "JOSH_CORE_RESERVED";
+var HELD_VALUE = "1";
+var reservation_schema = process_owner_schema.extend({
+  weight: z3.number(),
+  claimed_at: z3.number()
+});
+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;
+  try {
+    const parsed = reservation_schema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+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));
+  } 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 compare_claim(left, right) {
+  const by_time = left.reservation.claimed_at - right.reservation.claimed_at;
+  return by_time === 0 ? left.key.localeCompare(right.key) : by_time;
+}
+function admitted_keys(reservations, budget) {
+  const admitted = /* @__PURE__ */ new Set();
+  let cumulative = 0;
+  for (const [index, entry] of reservations.toSorted(compare_claim).entries()) {
+    cumulative += entry.reservation.weight;
+    if (index !== 0 && cumulative > budget) break;
+    admitted.add(entry.key);
+  }
+  return admitted;
+}
+function is_admitted(key, reservations, budget) {
+  return admitted_keys(reservations, budget).has(key);
+}
+function admitted_load(reservations, budget) {
+  const admitted = admitted_keys(reservations, budget);
+  return reservations.filter((entry) => admitted.has(entry.key)).reduce((total, entry) => total + entry.reservation.weight, 0);
+}
+function normalize_budget(budget) {
+  return Number.isFinite(budget) ? Math.max(MIN_BUDGET, Math.floor(budget)) : MIN_BUDGET;
+}
+async function default_sleep(ms) {
+  await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function write_reservation(target, weight, claimed_at) {
+  stamp_file.write_stamp(target, { ...process_identity.own_fields(), weight, claimed_at });
+}
+function resolve_timing(options) {
+  return {
+    now: options.now ?? Date.now,
+    sleep: options.sleep ?? default_sleep,
+    poll_interval_ms: options.poll_interval_ms ?? POLL_INTERVAL_MS
+  };
+}
+async function await_admission(context) {
+  while (!is_admitted(context.key, live_reservations(context.directory), context.budget)) {
+    if (context.now() >= context.deadline) return;
+    await context.sleep(context.poll_interval_ms);
+  }
+}
+async function reserve(weight, options = {}) {
+  const timing = resolve_timing(options);
+  const directory = options.directory ?? PLATFORM_TEMP_ROOT;
+  const budget = normalize_budget(options.budget ?? availableParallelism2());
+  const claimed_at = timing.now();
+  const name = marker_name(randomUUID2());
+  const target = path3.join(directory, name);
+  write_reservation(target, weight, claimed_at);
+  await await_admission({
+    ...timing,
+    key: name,
+    directory,
+    budget,
+    deadline: claimed_at + (options.wait_cap_ms ?? WAIT_CAP_MS)
+  });
+  return { target };
+}
+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();
+  } finally {
+    release(handle);
+  }
+}
+function is_held() {
+  return process.env[HELD_KEY] === HELD_VALUE;
+}
+function set_held_mark(value) {
+  process.env[HELD_KEY] = value;
+}
+async function with_held_mark(run) {
+  const previous = process.env[HELD_KEY] ?? "";
+  set_held_mark(HELD_VALUE);
+  try {
+    return await run();
+  } finally {
+    set_held_mark(previous);
+  }
+}
+async function with_command_reservation(weight, run, options = {}) {
+  if (is_held() || unit_worker_share.is_nested_run()) return await run();
+  return await with_core_reservation(weight, async () => await with_held_mark(run), options);
+}
+var core_budget = {
+  CORE_WEIGHTS,
+  HELD_KEY,
+  HELD_VALUE,
+  RESERVED_PREFIX,
+  admitted_keys,
+  admitted_load,
+  is_held,
+  live_reservations,
+  release,
+  reserve,
+  with_command_reservation,
+  with_core_reservation,
+  with_held_mark
+};
+
+// scripts/gate/gate-plan.ts
+import { availableParallelism as availableParallelism3 } from "node:os";
+
+// scripts/lib/status-icons.ts
+var FAIL_ICON = "\u2717";
+var PASS_ICON = "\u2714";
+var status_icons = { FAIL_ICON, PASS_ICON };
+
+// scripts/josh/josh-verdict.ts
+var { FAIL_ICON: FAIL_ICON2, PASS_ICON: PASS_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 PASSED_VERDICT = "passed";
+var FAILED_VERDICT = "failed";
+function format_gate_passed(step_count, total) {
+  return `${GATE_PASSED_PREFIX} (${step_count} checks) 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;
+  return void 0;
+}
+var josh_verdict = {
+  PASSED_VERDICT,
+  FAILED_VERDICT,
+  format_gate_passed,
+  format_gate_failed,
+  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 WARNING_CHECKER_LABELS = [LINT_LABEL, TYPE_CHECK_LABEL];
+var STATIC_CHECKS = [
+  { label: LINT_LABEL, target: "lint", reserved_cores: core_budget.CORE_WEIGHTS.lint },
+  {
+    label: TYPE_CHECK_LABEL,
+    target: "check",
+    reserved_cores: core_budget.CORE_WEIGHTS.type_check
+  },
+  { label: "cspell", target: "cspell:dot", reserved_cores: core_budget.CORE_WEIGHTS.spell_check },
+  { label: BEHAVIOR_LABEL, target: BEHAVIOR_LABEL, reserved_cores: 0 },
+  // **The unused-member check reserves no core** (joshuafolkken/kit#2987): it builds one TypeScript
+  // program and walks it for about 5s, and it is over well before lint and the type check. A
+  // reservation would only take a place from the four-core CI runner's fan-out and a worker from the
+  // unit suite for the whole gate.
+  { label: "exports", target: "exports:unused", reserved_cores: 0 }
+];
+var GATE_CHECKS = [
+  ...STATIC_CHECKS,
+  { label: UNIT_LABEL, target: UNIT_LABEL, reserved_cores: 0 }
+];
+function select_gate_checks(is_unit_included) {
+  return is_unit_included ? GATE_CHECKS : STATIC_CHECKS;
+}
+function 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 direct_unit_weight(available_cores = availableParallelism3(), 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 plan_of(concurrency, unit_worker_cap, checks = GATE_CHECKS) {
+  return { checks, concurrency, unit_worker_cap };
+}
+function resolve_gate_plan(available_cores = availableParallelism3(), concurrent_runs = unit_worker_share.SOLO_RUNS, is_unit_included = true) {
+  const checks = select_gate_checks(is_unit_included);
+  return {
+    checks,
+    concurrency: resolve_concurrency(available_cores, concurrent_runs, checks),
+    unit_worker_cap: is_unit_included ? resolve_unit_worker_cap(available_cores, concurrent_runs) : void 0
+  };
+}
+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 = availableParallelism3(), 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 = {
+  GATE_CHECKS,
+  LINT_LABEL,
+  MEASURED_CORES,
+  RESERVED_CORES,
+  STATIC_CHECKS,
+  TYPE_CHECK_LABEL,
+  UNIT_LABEL,
+  WARNING_CHECKER_LABELS,
+  check_weight,
+  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...>";
@@ -727,25 +1369,29 @@ var DEV_COMMANDS = {
     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"]]
+    reference: ["", "developer", ["processes"]],
+    core_weight: core_budget.CORE_WEIGHTS.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"]]
+    reference: [FILE_ARGUMENTS, "developer", ["processes"]],
+    core_weight: core_budget.CORE_WEIGHTS.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"]]
+    reference: [REQUIRED_FILE_ARGUMENTS, "developer", ["none"]],
+    core_weight: core_budget.CORE_WEIGHTS.eslint_scan
   },
   "refactor:scan": {
     script: "scripts/refactor/refactor-scan-cli.ts",
     description: "List refactoring candidates in the changed scope by category and answer clear/candidates",
     category: "Development",
-    reference: ["", "automation", ["processes"]]
+    reference: ["", "automation", ["processes"]],
+    core_weight: core_budget.CORE_WEIGHTS.eslint_scan
   },
   bytes: {
     script: "scripts/lines/bytes-command.ts",
@@ -824,7 +1470,8 @@ var DEV_COMMANDS = {
     script: "scripts/lint/cspell-cached.ts",
     description: "Run spell check including dotfiles",
     category: "Development",
-    reference: ["", "developer", ["processes"]]
+    reference: ["", "developer", ["processes"]],
+    core_weight: core_budget.CORE_WEIGHTS.spell_check
   },
   behavior: {
     script: "scripts/behavior/behavior-cli.ts",
@@ -842,13 +1489,15 @@ var DEV_COMMANDS = {
     script: "scripts/test/test-unit-guard.ts",
     description: "Run unit tests with Vitest (skips when Vitest is absent; fails when it has no tests)",
     category: "Development",
-    reference: [FILTER_ARGUMENTS, "developer", ["processes"]]
+    reference: [FILTER_ARGUMENTS, "developer", ["processes"]],
+    core_weight: gate_plan.direct_unit_weight
   },
   "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"]]
+    reference: [FILE_ARGUMENTS, "developer", ["processes"]],
+    core_weight: gate_plan.direct_unit_weight
   },
   "test:declared": {
     script: "scripts/test/test-declared.ts",
@@ -858,7 +1507,7 @@ var DEV_COMMANDS = {
   },
   "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",
+    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"]]
   },
@@ -891,7 +1540,8 @@ var DEV_COMMANDS = {
     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"]]
+    reference: ["[arguments...]", "developer", ["processes"]],
+    core_weight: core_budget.CORE_WEIGHTS.type_check
   },
   port: {
     script: "scripts/ports/port-command.ts",
@@ -988,7 +1638,7 @@ var MAINTENANCE_COMMANDS = {
     script: "scripts/overrides/overrides-check.ts",
     description: "Check pnpm overrides for drift",
     category: "Maintenance",
-    reference: ["[--save]", "maintainer", ["files"]]
+    reference: ["[--save]", "developer", ["files"]]
   },
   audit: {
     script: "scripts/security/security-audit.ts",
@@ -1016,7 +1666,7 @@ var MAINTENANCE_COMMANDS = {
     ],
     description: "Update pnpm, dependencies, and run security audit",
     category: "Maintenance",
-    reference: ["", "maintainer", ["files", "network", "processes"]],
+    reference: ["", "developer", ["files", "network", "processes"]],
     argument_targets: ["latest:corepack", "latest:update", "audit"]
   },
   "latest:scope": {
@@ -1039,13 +1689,13 @@ var MAINTENANCE_COMMANDS = {
     script: "scripts/version/latest-corepack.ts",
     description: "Update pnpm on the current major while preserving the integrity pin",
     category: "Maintenance",
-    reference: ["", "maintainer", ["files", "network"]]
+    reference: ["", "developer", ["files", "network"]]
   },
   "latest:update": {
     script: "scripts/version/latest-update.ts",
     description: "Update all dependencies to latest",
     category: "Maintenance",
-    reference: ["", "maintainer", ["files", "network"]]
+    reference: ["", "developer", ["files", "network"]]
   }
 };
 
@@ -1359,7 +2009,9 @@ var ALIASES = {
   rtr: "retrospective",
   rvf: "review:findings",
   ruv: "rule:value",
-  ev: "eval"
+  ev: "eval",
+  lsm: "lane:sample",
+  lst: "lane:stats"
 };
 function canonical_command(name) {
   if (!Object.hasOwn(ALIASES, name)) return name;
@@ -1488,7 +2140,7 @@ var time_shell = {
 // scripts/time-runtime/time-background.ts
 var NO_BACKGROUND = "";
 var NO_FINISH = 0;
-var LAUNCH_PATTERN = /running in background with ID:\s*([\w-]+)/iu;
+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;
@@ -1581,74 +2233,542 @@ var time_background = {
   unread_phases
 };
 
-// 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",
+// scripts/git/git-schemas.ts
+import { z as z4 } from "zod";
+var package_name_schema = z4.object({ name: z4.string().min(1) });
+var rollup_item_schema = z4.looseObject({
+  // eslint-disable-next-line @typescript-eslint/naming-convention -- GraphQL field name from GitHub API
+  __typename: z4.string().optional(),
+  state: z4.string().optional(),
+  status: z4.string().optional(),
+  conclusion: z4.string().optional(),
+  name: z4.string().optional(),
+  context: z4.string().optional()
+});
+var pr_raw_schema = z4.object({
+  statusCheckRollup: z4.array(rollup_item_schema).optional(),
+  mergeStateStatus: z4.string().optional(),
+  reviewDecision: z4.string().optional()
+});
+var pull_comment_schema = z4.object({
+  body: z4.string().optional(),
+  html_url: z4.string().optional(),
+  user: z4.object({ login: z4.string().optional() }).optional()
+});
+var ai_review_pull_comment_schema = z4.object({
+  body: z4.string().optional(),
+  url: z4.string().optional(),
+  author: z4.object({ login: z4.string().optional() }).optional()
+});
+var pr_info_schema = z4.object({
+  mergeable: z4.union([z4.boolean(), z4.string()]).nullable().optional(),
+  mergeStateStatus: z4.string().nullable().optional(),
+  state: z4.string().optional()
+});
+var epic_issue_schema = z4.object({
+  number: z4.number(),
+  body: z4.string().optional()
+});
+var blocking_issue_schema = z4.object({
+  number: z4.number(),
+  state: z4.string().optional(),
+  repository_url: z4.string().optional()
+});
+var blocked_by_schema = z4.object({
+  nodes: z4.array(blocking_issue_schema).default([]),
+  totalCount: z4.number().optional()
+}).optional();
+var epic_child_schema = z4.object({
+  state: z4.string().optional(),
+  blockedBy: blocked_by_schema
+});
+var rest_comment_schema = z4.looseObject({
+  body: z4.string().nullish(),
+  html_url: z4.string().optional(),
+  user: z4.looseObject({ login: z4.string().optional() }).nullish()
+});
+var issue_label_schema = z4.object({ name: z4.string() });
+var epic_subject_schema = z4.object({
+  number: z4.number(),
+  state: z4.string().optional(),
+  labels: z4.array(issue_label_schema).optional(),
+  body: z4.string().optional()
+});
+var open_issue_schema = z4.object({
+  number: z4.number(),
+  title: z4.string(),
+  labels: z4.array(issue_label_schema).optional(),
+  createdAt: z4.string(),
+  blockedBy: blocked_by_schema,
+  // Present only on the pickup listing, which reads it for the restructures each issue declares.
+  body: z4.string().optional()
+});
+
+// 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";
+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;
+  return { name, status: parse_rollup_status(item) };
+}
+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/time-runtime/time-format.ts
+var MS_PER_MINUTE = 6e4;
+var MS_PER_SECOND = 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_SECOND).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 (joshuafolkken/kit#3221), so the
+  // stage block names the cause a resumed session used to 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);
+}
+var git_followup_stages = {
+  STAGE,
+  STAGE_LINE_PREFIX,
+  STAGE_TOTAL_PREFIX,
+  new_log,
+  lap,
+  total_ms,
+  format_stages,
+  print_stages,
+  stopped_lap
+};
+
+// scripts/time-runtime/time-followup-stage.ts
+var LINE_SEPARATOR = "\n";
+var SECONDS_SUFFIX = " s";
+var DIGIT_OR_POINT = /[\d.]/u;
+var MS_PER_SECOND2 = 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_SECOND2 };
+}
+function read_stages(text) {
+  if (!text.includes(git_followup_stages.STAGE_LINE_PREFIX)) return NO_STAGES;
+  return text.split(LINE_SEPARATOR).map((line) => stage_body(line)).filter((body) => body !== void 0).map((body) => to_stage(body)).filter((stage) => stage !== void 0);
+}
+var time_followup_stage = { NO_STAGES, read_stages };
+
+// scripts/time-runtime/time-reported-failure.ts
+import { z as z5 } from "zod";
+var TEXT_BLOCK_SCHEMA = z5.object({ text: z5.string().nullish() });
+var CONTENT_SCHEMA = z5.union([z5.string(), z5.array(z5.unknown())]);
+var LINE_SEPARATOR2 = "\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_SEPARATOR2);
+}
+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;
+}
+function is_passed_verdict(line) {
+  return josh_verdict.read_verdict(line) === josh_verdict.PASSED_VERDICT;
+}
+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_passed_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_SEPARATOR2);
+  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",
@@ -1810,202 +2930,59 @@ 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` (joshuafolkken/kit#1854), which asks the launch question of a
-  // span's `label` — the tool name for a non-Bash call — so the set lives in one place.
-  is_launch_tool,
-  // Exported for `time-writes.ts` (joshuafolkken/kit#1472), which asks what a call *wrote* rather
-  // than what it named. The extraction is the same one either way — a second copy of it would let a
-  // path be recognized as a target when read and missed when written.
-  targets_in,
-  tool_targets,
-  // Exported for the batching guard's own word scan (joshuafolkken/kit#1390), so the two scanners
-  // cannot come to disagree about where one word of a shell line ends and the next begins.
-  // Exported for the read-fold notice (joshuafolkken/kit#2311), which offers `read:files <path>` only
-  // over file-shaped targets — a bare directory like `scripts/` is a target here but not something
-  // `read:files` can read, so the notice reuses this test rather than keep a second copy that could
-  // drift from what counts as a file path.
-  has_extension,
-  // Exported for `time-writes.ts` (joshuafolkken/kit#1509), which needs the same two answers to say
-  // *which* files an in-place `sed` wrote. Two copies of this test disagreed in both directions at
-  // once — one called a piped `grep -i` a write, the other missed a bundled `sed -ni`.
-  write_segment,
-  is_in_place_sed,
-  // Exported for the drift test in `time-bundle-call.test.ts` (joshuafolkken/kit#1875), which pins that
-  // every name here is a real `josh` command and none of them writes.
-  READ_JOSH_SUBCOMMANDS
-};
-
-// scripts/time-runtime/time-format.ts
-var MS_PER_MINUTE = 6e4;
-var MS_PER_SECOND = 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_SECOND).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"
-};
-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);
-}
-var git_followup_stages = {
-  STAGE,
-  STAGE_LINE_PREFIX,
-  STAGE_TOTAL_PREFIX,
-  new_log,
-  lap,
-  total_ms,
-  format_stages,
-  print_stages
-};
-
-// scripts/time-runtime/time-followup-stage.ts
-var LINE_SEPARATOR = "\n";
-var SECONDS_SUFFIX = " s";
-var DIGIT_OR_POINT = /[\d.]/u;
-var MS_PER_SECOND2 = 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_SECOND2 };
+  };
+  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 read_stages(text) {
-  if (!text.includes(git_followup_stages.STAGE_LINE_PREFIX)) return NO_STAGES;
-  return text.split(LINE_SEPARATOR).map((line) => stage_body(line)).filter((body) => body !== void 0).map((body) => to_stage(body)).filter((stage) => stage !== void 0);
+function call_facts(name, input) {
+  if (name !== BASH_TOOL2) return tool_facts(name, input);
+  return bash_facts(time_shell.bash_command(input));
 }
-var time_followup_stage = { NO_STAGES, read_stages };
+var time_bundle_call = {
+  MAX_TARGETS,
+  not_bundleable,
+  bash_facts,
+  call_facts,
+  tool_facts,
+  // Exported for `time-agent-bundles.ts` (joshuafolkken/kit#1854), which asks the launch question of a
+  // span's `label` — the tool name for a non-Bash call — so the set lives in one place.
+  is_launch_tool,
+  // Exported for `time-writes.ts` (joshuafolkken/kit#1472), which asks what a call *wrote* rather
+  // than what it named. The extraction is the same one either way — a second copy of it would let a
+  // path be recognized as a target when read and missed when written.
+  targets_in,
+  tool_targets,
+  // Exported for the batching guard's own word scan (joshuafolkken/kit#1390), so the two scanners
+  // cannot come to disagree about where one word of a shell line ends and the next begins.
+  // Exported for the read-fold notice (joshuafolkken/kit#2311), which offers `read:files <path>` only
+  // over file-shaped targets — a bare directory like `scripts/` is a target here but not something
+  // `read:files` can read, so the notice reuses this test rather than keep a second copy that could
+  // drift from what counts as a file path.
+  has_extension,
+  // Exported for `time-writes.ts` (joshuafolkken/kit#1509), which needs the same two answers to say
+  // *which* files an in-place `sed` wrote. Two copies of this test disagreed in both directions at
+  // once — one called a piped `grep -i` a write, the other missed a bundled `sed -ni`.
+  write_segment,
+  is_in_place_sed,
+  // Exported for the drift test in `time-bundle-call.test.ts` (joshuafolkken/kit#1875), which pins that
+  // 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;
@@ -2162,121 +3139,6 @@ var time_markers = {
   bash_issue
 };
 
-// scripts/lib/status-icons.ts
-var FAIL_ICON = "\u2717";
-var PASS_ICON = "\u2714";
-var status_icons = { FAIL_ICON, PASS_ICON };
-
-// scripts/josh/josh-verdict.ts
-var { FAIL_ICON: FAIL_ICON2, PASS_ICON: PASS_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 PASSED_VERDICT = "passed";
-var FAILED_VERDICT = "failed";
-function format_gate_passed(step_count, total) {
-  return `${GATE_PASSED_PREFIX} (${step_count} checks) 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;
-  return void 0;
-}
-var josh_verdict = {
-  PASSED_VERDICT,
-  FAILED_VERDICT,
-  format_gate_passed,
-  format_gate_failed,
-  GATE_OPENING_MARK,
-  GATE_OPENING_PREFIX,
-  is_gate_opening,
-  read_verdict
-};
-
-// scripts/time-runtime/time-reported-failure.ts
-import { z as z2 } from "zod";
-var TEXT_BLOCK_SCHEMA = z2.object({ text: z2.string().nullish() });
-var CONTENT_SCHEMA = z2.union([z2.string(), z2.array(z2.unknown())]);
-var LINE_SEPARATOR2 = "\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_SEPARATOR2);
-}
-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;
-}
-function is_passed_verdict(line) {
-  return josh_verdict.read_verdict(line) === josh_verdict.PASSED_VERDICT;
-}
-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_passed_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_SEPARATOR2);
-  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-single-check.ts
 var CHECK_COMMANDS = /* @__PURE__ */ new Set([
   "josh check",
@@ -2301,47 +3163,48 @@ function check_key(josh_command, command) {
 var time_single_check = { NO_CHECK, check_key };
 
 // scripts/time-runtime/time-transcript-line.ts
-import { z as z3 } from "zod";
+import { z as z6 } from "zod";
 
 // scripts/time-runtime/time-instant.ts
 function parse_instant(raw) {
-  const parsed = Date.parse(raw ?? "");
+  if (raw === null || raw === void 0) return void 0;
+  const parsed = Date.parse(raw);
   return Number.isNaN(parsed) ? void 0 : parsed;
 }
 var time_instant = { parse_instant };
 
 // scripts/time-runtime/time-transcript-line.ts
-var BLOCK_SCHEMA2 = z3.object({
-  type: z3.string().nullish(),
-  name: z3.string().nullish(),
-  id: z3.string().nullish(),
-  tool_use_id: z3.string().nullish(),
-  input: z3.unknown().nullish(),
+var BLOCK_SCHEMA2 = z6.object({
+  type: z6.string().nullish(),
+  name: z6.string().nullish(),
+  id: z6.string().nullish(),
+  tool_use_id: z6.string().nullish(),
+  input: z6.unknown().nullish(),
   // Whether the harness wrote this result back as a failure (joshuafolkken/kit#1309). Present on a
   // `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: z3.boolean().nullish(),
+  is_error: z6.boolean().nullish(),
   // What the call printed. Read only to recover the outcome a pipeline threw away
   // (joshuafolkken/kit#1361): it is kept as flattened text rather than as blocks, because that is
   // the whole of what `time-reported-failure.ts` asks of it.
-  content: z3.unknown().nullish()
+  content: z6.unknown().nullish()
 });
-var CONTENT_SCHEMA2 = z3.union([z3.string(), z3.array(BLOCK_SCHEMA2)]);
-var MESSAGE_SCHEMA2 = z3.object({ id: z3.string().nullish(), content: CONTENT_SCHEMA2.nullish() });
-var LINE_SCHEMA = z3.object({
-  type: z3.string().nullish(),
-  timestamp: z3.string().nullish(),
+var CONTENT_SCHEMA2 = z6.union([z6.string(), z6.array(BLOCK_SCHEMA2)]);
+var MESSAGE_SCHEMA2 = z6.object({ id: z6.string().nullish(), content: CONTENT_SCHEMA2.nullish() });
+var LINE_SCHEMA = z6.object({
+  type: z6.string().nullish(),
+  timestamp: z6.string().nullish(),
   // The branch the line was written on, which is where the issue number lives — `josh git` names a
   // branch `<N>-<slug>`. Read here rather than re-parsed by a second reader so `josh time --issue`
   // and `josh cost --issue` answer from the same field (joshuafolkken/kit#1268).
-  gitBranch: z3.string().nullish(),
+  gitBranch: z6.string().nullish(),
   // The two fields outside `message` that the harness writes an end-of-task notice on
   // (joshuafolkken/kit#1696). **Both are read as `unknown` rather than as strings**: a schema
   // 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: z3.unknown().nullish(),
-  attachment: z3.unknown().nullish(),
+  content: z6.unknown().nullish(),
+  attachment: z6.unknown().nullish(),
   message: MESSAGE_SCHEMA2.nullish()
 });
 var UNKNOWN_BRANCH = "";
@@ -2349,6 +3212,9 @@ 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 TOKEN_LINE = /^[a-z][a-z-]*$/u;
+var TOKEN_LINE_LIMIT = 8;
 function block_names(raw) {
   return {
     type: raw.type ?? "",
@@ -2358,12 +3224,15 @@ function block_names(raw) {
   };
 }
 function guard_from_refusal(text) {
-  const trimmed = text.trimStart();
+  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 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;
@@ -2375,6 +3244,7 @@ function to_block2(raw) {
     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)
   };
@@ -2408,6 +3278,7 @@ function parse_line2(line) {
 var time_transcript_line = {
   ERROR_TEXT_LIMIT,
   NO_MESSAGE_ID,
+  TOKEN_LINE_LIMIT,
   guard_from_refusal,
   parse_line: parse_line2
 };
@@ -2426,24 +3297,9 @@ var time_writes = {
   tool_writes
 };
 
-// scripts/time-runtime/time-spans.ts
-var { NO_MESSAGE_ID: NO_MESSAGE_ID2, parse_line: parse_line3 } = time_transcript_line;
-var ASSISTANT_TYPE = "assistant";
-var USER_TYPE = "user";
+// scripts/time-runtime/time-tool-call.ts
+var { NO_MESSAGE_ID: NO_MESSAGE_ID2 } = time_transcript_line;
 var UNKNOWN_TOOL = "unknown";
-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
-};
 var NO_CALL = {
   label: "",
   josh_command: "",
@@ -2505,6 +3361,31 @@ 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_line3 } = 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 }))
@@ -2514,7 +3395,7 @@ function collect_calls(lines) {
   return new Map(
     tool_use_blocks(lines).map(({ block, message_id }) => [
       block.id,
-      to_tool_call(block.name, block.input, message_id)
+      to_tool_call2(block.name, block.input, message_id)
     ])
   );
 }
@@ -2542,13 +3423,13 @@ function facts_of(result, call) {
 }
 function user_event(line, calls) {
   const result = result_block(line);
-  if (result === void 0) return event_of(line, HUMAN_CATEGORY, NO_CALL);
-  const call = calls.get(result.result_id) ?? UNKNOWN_CALL;
+  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_CALL, message_id: line.message_id });
+    return event_of(line, MODEL_CATEGORY, { ...NO_CALL2, message_id: line.message_id });
   }
   return line.type === USER_TYPE ? user_event(line, calls) : void 0;
 }
@@ -2630,8 +3511,8 @@ var time_spans = {
   OK_OUTCOME,
   FAILED_OUTCOME,
   UNKNOWN_OUTCOME,
-  NO_MESSAGE_ID: NO_MESSAGE_ID2,
-  UNKNOWN_TOOL,
+  NO_MESSAGE_ID: NO_MESSAGE_ID3,
+  UNKNOWN_TOOL: UNKNOWN_TOOL2,
   has_transcript_data,
   equal_durations,
   no_background,
@@ -2640,7 +3521,7 @@ var time_spans = {
   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_call: to_tool_call2,
   parse_line: parse_line3,
   parse_timeline
 };
@@ -3109,7 +3990,7 @@ function describe_span(span) {
 }
 var FOLD_MINIMUM = 2;
 function read_targets(sequence) {
-  const paths = sequence.filter((span) => span.is_bundleable && !span.is_writing).map((span) => span.targets[0] ?? "").filter((path6) => path6 !== "" && time_bundle_call.has_extension(path6));
+  const paths = sequence.filter((span) => span.is_bundleable && !span.is_writing).map((span) => span.targets[0] ?? "").filter((path7) => path7 !== "" && time_bundle_call.has_extension(path7));
   return [...new Set(paths)];
 }
 function read_fold_directive(sequence) {
@@ -3118,7 +3999,7 @@ function read_fold_directive(sequence) {
   return ` Fold them into one call: \`pnpm josh read:files ${paths.join(" ")}\`.`;
 }
 function write_targets(sequence) {
-  const paths = sequence.filter((span) => span.label === EDIT_TOOL).map((span) => span.targets[0] ?? "").filter((path6) => path6 !== "" && time_bundle_call.has_extension(path6));
+  const paths = sequence.filter((span) => span.label === EDIT_TOOL).map((span) => span.targets[0] ?? "").filter((path7) => path7 !== "" && time_bundle_call.has_extension(path7));
   return [...new Set(paths)];
 }
 function write_fold_directive(sequence) {
@@ -3170,41 +4051,41 @@ var time_batch_guard = {
 };
 
 // scripts/time-runtime/time-hook-transcript.ts
-import path3 from "node:path";
+import path6 from "node:path";
 
 // scripts/cost-runtime/cost-transcript.ts
-import { readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { readdirSync as readdirSync3, readFileSync as readFileSync3, statSync } from "node:fs";
 import { homedir } from "node:os";
-import path2 from "node:path";
+import path5 from "node:path";
 
 // scripts/lane/lane-paths.ts
-import path from "node:path";
+import path4 from "node:path";
 var LANE_ROOT_KEY = "JOSH_LANE_ROOT";
 var LANE_DIRECTORY_SUFFIX = "-lanes";
 var LANE_BRANCH_SUFFIX = "-lane";
 function default_lane_root(repository_root) {
-  const name = path.basename(repository_root);
-  return path.join(path.dirname(repository_root), `.${name}${LANE_DIRECTORY_SUFFIX}`);
+  const name = path4.basename(repository_root);
+  return path4.join(path4.dirname(repository_root), `.${name}${LANE_DIRECTORY_SUFFIX}`);
 }
 function lane_root(repository_root, environment = process.env) {
   const configured = environment[LANE_ROOT_KEY]?.trim() ?? "";
-  return configured.length === 0 ? default_lane_root(repository_root) : path.resolve(configured);
+  return configured.length === 0 ? default_lane_root(repository_root) : path4.resolve(configured);
 }
 function lane_directory(root, issue) {
-  return path.join(root, issue);
+  return path4.join(root, issue);
 }
 var LANE_ISSUE_PATTERN = /^\d+$/u;
 var DEFAULT_LANE_ROOT_PATTERN = new RegExp(String.raw`^\..+${LANE_DIRECTORY_SUFFIX}$`, "u");
 function is_lane_root(directory, environment) {
   const configured = environment[LANE_ROOT_KEY]?.trim() ?? "";
-  if (configured.length > 0) return path.resolve(configured) === directory;
-  return DEFAULT_LANE_ROOT_PATTERN.test(path.basename(directory));
+  if (configured.length > 0) return path4.resolve(configured) === directory;
+  return DEFAULT_LANE_ROOT_PATTERN.test(path4.basename(directory));
 }
 function lane_issue_of(directory, environment = process.env) {
-  const resolved = path.resolve(directory);
-  const issue = path.basename(resolved);
+  const resolved = path4.resolve(directory);
+  const issue = path4.basename(resolved);
   if (!LANE_ISSUE_PATTERN.test(issue)) return void 0;
-  return is_lane_root(path.dirname(resolved), environment) ? issue : void 0;
+  return is_lane_root(path4.dirname(resolved), environment) ? issue : void 0;
 }
 function lane_branch(issue) {
   return `${issue}${LANE_BRANCH_SUFFIX}`;
@@ -3220,25 +4101,25 @@ var lane_paths = {
 };
 
 // scripts/lib/read-file.ts
-import { readFileSync } from "node:fs";
+import { readFileSync as readFileSync2 } from "node:fs";
 var ABSENT_CODE = "ENOENT";
 function is_absent(error) {
   return error instanceof Error && "code" in error && error.code === ABSENT_CODE;
 }
-function read_optional(path6) {
+function read_optional(path7) {
   try {
-    return readFileSync(path6, "utf8");
+    return readFileSync2(path7, "utf8");
   } catch (error) {
     if (is_absent(error)) return void 0;
     throw error;
   }
 }
-function read_file_or_empty(path6) {
-  return read_optional(path6) ?? "";
+function read_file_or_empty(path7) {
+  return read_optional(path7) ?? "";
 }
-function read_if_readable(path6) {
+function read_if_readable(path7) {
   try {
-    return readFileSync(path6, "utf8");
+    return readFileSync2(path7, "utf8");
   } catch {
     return void 0;
   }
@@ -3246,30 +4127,30 @@ function read_if_readable(path6) {
 var file_reader = { read_optional, read_file_or_empty, read_if_readable };
 
 // scripts/cost-runtime/cost-usage.ts
-import { z as z4 } from "zod";
-var CACHE_CREATION_SCHEMA = z4.object({
-  ephemeral_1h_input_tokens: z4.number().nullish(),
-  ephemeral_5m_input_tokens: z4.number().nullish()
+import { z as z7 } from "zod";
+var CACHE_CREATION_SCHEMA = z7.object({
+  ephemeral_1h_input_tokens: z7.number().nullish(),
+  ephemeral_5m_input_tokens: z7.number().nullish()
 });
-var USAGE_SCHEMA = z4.object({
-  input_tokens: z4.number(),
-  cache_creation_input_tokens: z4.number().nullish(),
-  cache_read_input_tokens: z4.number().nullish(),
-  output_tokens: z4.number(),
-  output_tokens_details: z4.object({ thinking_tokens: z4.number().nullish() }).nullish(),
+var USAGE_SCHEMA = z7.object({
+  input_tokens: z7.number(),
+  cache_creation_input_tokens: z7.number().nullish(),
+  cache_read_input_tokens: z7.number().nullish(),
+  output_tokens: z7.number(),
+  output_tokens_details: z7.object({ thinking_tokens: z7.number().nullish() }).nullish(),
   cache_creation: CACHE_CREATION_SCHEMA.nullish()
 });
-var MESSAGE_SCHEMA3 = z4.object({
-  id: z4.string().nullish(),
-  model: z4.string().nullish(),
+var MESSAGE_SCHEMA3 = z7.object({
+  id: z7.string().nullish(),
+  model: z7.string().nullish(),
   usage: USAGE_SCHEMA.nullish()
 });
-var LINE_SCHEMA2 = z4.object({
-  type: z4.string(),
-  requestId: z4.string().nullish(),
-  uuid: z4.string().nullish(),
-  gitBranch: z4.string().nullish(),
-  timestamp: z4.string().nullish(),
+var LINE_SCHEMA2 = z7.object({
+  type: z7.string(),
+  requestId: z7.string().nullish(),
+  uuid: z7.string().nullish(),
+  gitBranch: z7.string().nullish(),
+  timestamp: z7.string().nullish(),
   message: MESSAGE_SCHEMA3.nullish()
 });
 var SYNTHETIC_MODEL = "<synthetic>";
@@ -3383,7 +4264,7 @@ var cost_usage = {
 };
 
 // scripts/cost-runtime/cost-transcript.ts
-var TRANSCRIPT_ROOT = path2.join(".claude", "projects");
+var TRANSCRIPT_ROOT = path5.join(".claude", "projects");
 var TRANSCRIPT_EXTENSION = ".jsonl";
 var SLUG_PATTERN = /[^a-zA-Z0-9-]/gu;
 var UNIT_DIRECTORY = "subagents";
@@ -3392,7 +4273,7 @@ function project_slug(cwd) {
   return cwd.replaceAll(SLUG_PATTERN, "-");
 }
 function transcript_directory(cwd, home = homedir()) {
-  return path2.join(home, TRANSCRIPT_ROOT, project_slug(cwd));
+  return path5.join(home, TRANSCRIPT_ROOT, project_slug(cwd));
 }
 var GIT_ENTRY = ".git";
 var GITDIR_PREFIX = "gitdir:";
@@ -3400,7 +4281,7 @@ var WORKTREE_SEGMENT = `/${GIT_ENTRY}/worktrees/`;
 var NOT_FOUND = -1;
 function linked_worktree_gitdir(cwd) {
   try {
-    const contents = readFileSync2(path2.join(cwd, GIT_ENTRY), "utf8").trim();
+    const contents = readFileSync3(path5.join(cwd, GIT_ENTRY), "utf8").trim();
     return contents.startsWith(GITDIR_PREFIX) ? contents.slice(GITDIR_PREFIX.length).trim() : "";
   } catch {
     return "";
@@ -3408,22 +4289,22 @@ function linked_worktree_gitdir(cwd) {
 }
 function session_cwd(cwd) {
   const gitdir = linked_worktree_gitdir(cwd);
-  const absolute = gitdir === "" ? "" : path2.resolve(cwd, gitdir);
+  const absolute = gitdir === "" ? "" : path5.resolve(cwd, gitdir);
   const segment = absolute.indexOf(WORKTREE_SEGMENT);
   return segment === NOT_FOUND ? cwd : absolute.slice(0, segment);
 }
 function read_directory(directory) {
   try {
-    return readdirSync(directory);
+    return readdirSync3(directory);
   } catch {
     return [];
   }
 }
 var LANE_ISSUE_SLUG = /^\d+$/u;
 function lane_transcript_directories(main_cwd, home) {
-  const projects = path2.join(home, TRANSCRIPT_ROOT);
+  const projects = path5.join(home, TRANSCRIPT_ROOT);
   const prefix = `${project_slug(lane_paths.lane_root(main_cwd))}-`;
-  return read_directory(projects).filter((name) => name.startsWith(prefix) && LANE_ISSUE_SLUG.test(name.slice(prefix.length))).map((name) => path2.join(projects, name));
+  return read_directory(projects).filter((name) => name.startsWith(prefix) && LANE_ISSUE_SLUG.test(name.slice(prefix.length))).map((name) => path5.join(projects, name));
 }
 function transcript_directories(cwd, home = homedir()) {
   const own = transcript_directory(cwd, home);
@@ -3454,16 +4335,16 @@ function without_extension(name) {
   return name.slice(0, -TRANSCRIPT_EXTENSION.length);
 }
 function own_files(directory, names) {
-  return names.filter((name) => is_transcript(name)).map((name) => to_session_file(path2.join(directory, name), without_extension(name), OWN_DEPTH)).filter((file) => file !== void 0);
+  return names.filter((name) => is_transcript(name)).map((name) => to_session_file(path5.join(directory, name), without_extension(name), OWN_DEPTH)).filter((file) => file !== void 0);
 }
 function unit_directory(directory, session_id) {
-  return path2.join(directory, session_id, UNIT_DIRECTORY);
+  return path5.join(directory, session_id, UNIT_DIRECTORY);
 }
 var UNIT_DEPTH = 1;
 function level_units(subagents_directory, prefix, depth) {
   return read_directory(subagents_directory).filter((name) => is_transcript(name)).map(
     (name) => to_session_file(
-      path2.join(subagents_directory, name),
+      path5.join(subagents_directory, name),
       `${prefix}${UNIT_ID_SEPARATOR}${without_extension(name)}`,
       depth
     )
@@ -3605,10 +4486,10 @@ function is_agent_id(value) {
   return typeof value === "string" && AGENT_ID_PATTERN.test(value);
 }
 function fork_path(transcript_path, agent_id) {
-  const directory = path3.dirname(transcript_path);
-  const session_id = path3.basename(transcript_path, TRANSCRIPT_EXTENSION2);
+  const directory = path6.dirname(transcript_path);
+  const session_id = path6.basename(transcript_path, TRANSCRIPT_EXTENSION2);
   const file_name = `${AGENT_PREFIX}${agent_id}${TRANSCRIPT_EXTENSION2}`;
-  return path3.join(cost_transcript.unit_directory(directory, session_id), file_name);
+  return path6.join(cost_transcript.unit_directory(directory, session_id), file_name);
 }
 function transcript_of(transcript_path, agent_id) {
   if (!is_agent_id(agent_id)) return transcript_path;
@@ -3622,127 +4503,7 @@ var time_hook_transcript = {
 
 // scripts/time-runtime/time-density-hook.ts
 import { closeSync, fstatSync, openSync, readSync } from "node:fs";
-
-// scripts/josh/stamp-file.ts
-import { createHash, randomUUID } from "node:crypto";
-import { lstatSync, readFileSync as readFileSync3, renameSync, rmSync, writeFileSync } from "node:fs";
-import path5 from "node:path";
-
-// scripts/init/init-paths.ts
-import path4 from "node:path";
-import { fileURLToPath } from "node:url";
-var PACKAGE_DIR = path4.join(path4.dirname(fileURLToPath(import.meta.url)), "..", "..");
-var PROJECT_ROOT = process.cwd();
-
-// scripts/josh/platform-temporary.ts
-import { accessSync, constants } from "node:fs";
-import { tmpdir } from "node:os";
-var POSIX_TEMP_ROOT = "/tmp";
-var WINDOWS_PLATFORM = "win32";
-function is_writable_directory(directory) {
-  try {
-    accessSync(directory, constants.W_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function resolve_temporary_root(platform, can_write = is_writable_directory) {
-  if (platform === WINDOWS_PLATFORM) return tmpdir();
-  return can_write(POSIX_TEMP_ROOT) ? POSIX_TEMP_ROOT : tmpdir();
-}
-var TEMP_ROOT_KEY = "JOSH_TEMP_ROOT";
-function temporary_root(override, platform) {
-  return override === void 0 || override === "" ? resolve_temporary_root(platform) : override;
-}
-var PLATFORM_TEMP_ROOT = temporary_root(process.env[TEMP_ROOT_KEY], process.platform);
-
-// scripts/josh/stamp-file.ts
-var HASH_ALGORITHM = "sha256";
-var STAMP_SUFFIX = ".json";
-var STAMP_KEY_LENGTH = 16;
-var STAMP_FILE_MODE = 384;
-var STAMP_WRITE_FLAG = "wx";
-var STAMP_CREATE_FLAG = STAMP_WRITE_FLAG;
-var EXISTS_ERROR_CODE = "EEXIST";
-var ACCOUNT_KEY_SEPARATOR = ":";
-function digest(content) {
-  return createHash(HASH_ALGORITHM).update(content).digest("hex");
-}
-function account_key() {
-  return String(process.getuid?.() ?? "");
-}
-function stamp_path(prefix, root = PACKAGE_DIR, suffix = STAMP_SUFFIX) {
-  const key = digest(`${account_key()}${ACCOUNT_KEY_SEPARATOR}${root}`).slice(0, STAMP_KEY_LENGTH);
-  return path5.join(PLATFORM_TEMP_ROOT, `${prefix}${key}${suffix}`);
-}
-function write_exclusively(target, content) {
-  rmSync(target, { force: true });
-  writeFileSync(target, content, { flag: STAMP_WRITE_FLAG, mode: STAMP_FILE_MODE });
-  return target;
-}
-function write_stamp(target, payload) {
-  return write_exclusively(target, JSON.stringify(payload));
-}
-function replace_stamp(target, payload) {
-  const temporary = `${target}.${String(process.pid)}.${randomUUID()}`;
-  try {
-    writeFileSync(temporary, JSON.stringify(payload), {
-      flag: STAMP_CREATE_FLAG,
-      mode: STAMP_FILE_MODE
-    });
-    renameSync(temporary, target);
-    return target;
-  } finally {
-    rmSync(temporary, { force: true });
-  }
-}
-function write_text_stamp(target, text) {
-  return write_exclusively(target, text);
-}
-function create_stamp(target, payload) {
-  try {
-    writeFileSync(target, JSON.stringify(payload), {
-      flag: STAMP_CREATE_FLAG,
-      mode: STAMP_FILE_MODE
-    });
-    return true;
-  } catch (error) {
-    if (error.code === EXISTS_ERROR_CODE) return false;
-    throw error;
-  }
-}
-function remove_stamp(target) {
-  rmSync(target, { force: true });
-}
-function is_own_regular_file(source) {
-  const stats = lstatSync(source);
-  if (!stats.isFile()) return false;
-  const uid = process.getuid?.();
-  return uid === void 0 || stats.uid === uid;
-}
-function read_stamp_text(source) {
-  try {
-    if (!is_own_regular_file(source)) return void 0;
-    return readFileSync3(source, "utf8");
-  } catch {
-    return void 0;
-  }
-}
-var stamp_file = {
-  create_stamp,
-  digest,
-  is_own_regular_file,
-  read_stamp_text,
-  replace_stamp,
-  remove_stamp,
-  stamp_path,
-  write_stamp,
-  write_text_stamp
-};
-
-// scripts/time-runtime/time-density-hook.ts
-import { z as z5 } from "zod";
+import { z as z8 } from "zod";
 
 // scripts/time-runtime/time-density.ts
 var MIN_ROUND_TRIPS = 10;
@@ -3798,15 +4559,15 @@ var TAIL_BYTES = 262144;
 var FILE_START = 0;
 var NOTICE_PREFIX = "josh-density-notice-";
 var NEVER_MS = 0;
-var payload_schema = z5.object({
-  transcript_path: z5.string().min(1).optional(),
+var payload_schema = z8.object({
+  transcript_path: z8.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: z5.string().nullish()
+  agent_id: z8.string().nullish()
 });
-var notice_schema = z5.object({ notified_at_ms: z5.number() });
-var call_schema = z5.object({ tool_name: z5.string().min(1), tool_input: z5.unknown() });
+var notice_schema = z8.object({ notified_at_ms: z8.number() });
+var call_schema = z8.object({ tool_name: z8.string().min(1), tool_input: z8.unknown() });
 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;
@@ -3873,16 +4634,29 @@ var time_density_hook = {
 };
 
 export {
-  PROJECT_ROOT,
-  PLATFORM_TEMP_ROOT,
-  stamp_file,
   json_value,
   cost_blocks,
   ESLINT_EDIT_CACHE_FLAGS,
+  process_identity,
+  process_owner_schema,
   time_shell,
   time_bundle_call,
-  cost_attribute,
+  blocking_issue_schema,
+  rest_comment_schema,
+  open_issue_schema,
+  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,