@joshuafolkken/kit 1.872.0 → 1.881.0

package/dist/hooks/chunk-HCF3OGEE.js

@@ -1,1829 +0,0 @@
-import {
-  batch_outcome
-} from "./chunk-VK5JKFAR.js";
-import {
-  investigation_reads,
-  investigation_refusal
-} from "./chunk-SJPJ6VSI.js";
-import {
-  hook_decision,
-  time_batch_guard
-} from "./chunk-U652FXTN.js";
-import {
-  cost_blocks,
-  json_value,
-  lane_paths,
-  stamp_file,
-  time_shell,
-  time_transcript_line
-} from "./chunk-REQAQLRC.js";
-
-// scripts/hooks/pretool-guard.ts
-import { text } from "node:stream/consumers";
-import { fileURLToPath } from "node:url";
-
-// scripts/run/run-progress.ts
-var DEFAULT_INTERVAL_MINUTES = 20;
-var INTERVAL_KEY = "JOSH_PROGRESS_INTERVAL_MINUTES";
-var MS_PER_MINUTE = 6e4;
-var MS_PER_SECOND = 1e3;
-var DEFAULT_INTERVAL_MS = DEFAULT_INTERVAL_MINUTES * MS_PER_MINUTE;
-var NO_LANES = "none";
-var NO_CHILD_YET = "no in-progress child yet";
-var NO_NEXT = "none";
-var QUIET_MARKER = "\u23F3";
-var STAMP_END = 16;
-var PAD_WIDTH = 2;
-var MINUTES_PER_HOUR = 60;
-function to_minutes(elapsed_ms) {
-  return Math.floor(elapsed_ms / MS_PER_MINUTE);
-}
-function format_minutes(elapsed_ms) {
-  return `${String(to_minutes(elapsed_ms))}m`;
-}
-function pad(value) {
-  return String(value).padStart(PAD_WIDTH, "0");
-}
-function offset_minutes(date) {
-  return Math.round(-date.getTimezoneOffset());
-}
-function format_offset(total_minutes) {
-  const sign = total_minutes < 0 ? "-" : "+";
-  const absolute = Math.abs(total_minutes);
-  return `${sign}${pad(Math.floor(absolute / MINUTES_PER_HOUR))}:${pad(absolute % MINUTES_PER_HOUR)}`;
-}
-function format_observed_at(now_ms) {
-  const minutes = offset_minutes(new Date(now_ms));
-  const local = new Date(now_ms + minutes * MS_PER_MINUTE);
-  const day = `${String(local.getUTCFullYear())}-${pad(local.getUTCMonth() + 1)}-${pad(local.getUTCDate())}`;
-  const clock = `${pad(local.getUTCHours())}:${pad(local.getUTCMinutes())}${format_offset(minutes)}`;
-  return `${day} ${clock} / ${new Date(now_ms).toISOString().slice(0, STAMP_END)}Z`;
-}
-function observation_key(observations) {
-  return JSON.stringify({ children: observations.children, lanes: observations.lanes });
-}
-function next_state(previous, key, now_ms) {
-  if (previous?.key === key) return previous;
-  return { key, unchanged_since_ms: now_ms };
-}
-function format_child(child) {
-  const labels = child.labels.length > 0 ? child.labels.join(",") : "(no labels)";
-  return `#${child.issue} ${labels} PR:${child.pr_state}`;
-}
-function format_children(children) {
-  if (children.length === 0) return NO_CHILD_YET;
-  return children.map((child) => format_child(child)).join(" \xB7 ");
-}
-function format_lanes(lanes) {
-  if (lanes.length === 0) return NO_LANES;
-  return lanes.map((lane) => `${lane.issue}:${lane.state}`).join(" ");
-}
-function format_record(record_age_ms) {
-  return record_age_ms === void 0 ? "unread" : `+${format_minutes(record_age_ms)}`;
-}
-function format_next_report(now_ms, interval_ms) {
-  return format_observed_at(now_ms + interval_ms);
-}
-function format_next_line(next) {
-  return `next ${next ?? NO_NEXT}`;
-}
-function format_report(fields) {
-  return [
-    `${QUIET_MARKER} at ${fields.observed_at}`,
-    `quiet ${fields.quiet} \xB7 unchanged ${fields.unchanged}`,
-    `children ${fields.children}`,
-    `lanes ${fields.lanes} \xB7 load ${fields.load} \xB7 record ${fields.record}`,
-    format_next_line(fields.next)
-  ].join("\n");
-}
-function format_line(observations, timing) {
-  return format_report({
-    observed_at: format_observed_at(timing.now_ms),
-    quiet: format_minutes(timing.now_ms - timing.quiet_since_ms),
-    unchanged: format_minutes(timing.now_ms - timing.unchanged_since_ms),
-    children: format_children(observations.children),
-    lanes: format_lanes(observations.lanes),
-    load: observations.load_average.toFixed(1),
-    record: format_record(observations.record_age_ms),
-    next: format_next_report(timing.now_ms, timing.interval_ms)
-  });
-}
-function is_due(last_report_ms, now_ms, interval_ms) {
-  return now_ms - last_report_ms >= interval_ms;
-}
-function minutes_from(raw) {
-  const minutes = Number(raw);
-  if (raw === void 0 || raw.trim() === "" || !Number.isFinite(minutes) || minutes <= 0) {
-    return void 0;
-  }
-  return minutes;
-}
-var run_progress = {
-  DEFAULT_INTERVAL_MINUTES,
-  DEFAULT_INTERVAL_MS,
-  INTERVAL_KEY,
-  MS_PER_MINUTE,
-  MS_PER_SECOND,
-  NO_CHILD_YET,
-  NO_NEXT,
-  format_child,
-  format_children,
-  format_lanes,
-  format_line,
-  format_next_line,
-  format_next_report,
-  format_record,
-  format_report,
-  is_due,
-  minutes_from,
-  next_state,
-  observation_key
-};
-
-// scripts/git/constants.ts
-import { platform } from "node:os";
-var GIT_COMMAND_UNIX = "/usr/bin/git";
-var PORCELAIN_FLAG = "--porcelain";
-function get_git_command() {
-  if (platform() === "win32") {
-    return String.raw`"C:\Program Files\Git\cmd\git.exe"`;
-  }
-  return GIT_COMMAND_UNIX;
-}
-function get_git_command_for_spawn() {
-  if (platform() === "win32") {
-    return String.raw`C:\Program Files\Git\cmd\git.exe`;
-  }
-  return GIT_COMMAND_UNIX;
-}
-var git_utilities = {
-  get_git_command,
-  get_git_command_for_spawn
-};
-
-// scripts/run/run-progress-clock.ts
-import { execaSync } from "execa";
-import { z } from "zod";
-var PROGRESS_PREFIX = "josh-run-progress-";
-var LIFE_PREFIX = "josh-run-progress-life-";
-var GIT_TIMEOUT_MS = 5e3;
-var GIT_DIRECTORY_ARGUMENTS = ["rev-parse", "--absolute-git-dir"];
-var report_stamp_schema = z.object({ reported_at: z.string(), line: z.string().optional() });
-function parse_stamp(raw) {
-  const parsed = report_stamp_schema.safeParse(JSON.parse(raw));
-  if (!parsed.success) return void 0;
-  const reported_at = Date.parse(parsed.data.reported_at);
-  return Number.isNaN(reported_at) ? void 0 : reported_at;
-}
-function read_last_line(target) {
-  const raw = stamp_file.read_stamp_text(target);
-  if (raw === void 0) return void 0;
-  try {
-    return report_stamp_schema.safeParse(JSON.parse(raw)).data?.line;
-  } catch {
-    return void 0;
-  }
-}
-function read_last_report(target) {
-  const raw = stamp_file.read_stamp_text(target);
-  if (raw === void 0) return void 0;
-  try {
-    return parse_stamp(raw);
-  } catch {
-    return void 0;
-  }
-}
-function mark(target, now_ms, line) {
-  const reported_at = new Date(now_ms).toISOString();
-  const kept = line ?? read_last_line(target);
-  stamp_file.write_stamp(target, kept === void 0 ? { reported_at } : { reported_at, line: kept });
-}
-function stamp_target_of(git_directory) {
-  return stamp_file.stamp_path(PROGRESS_PREFIX, git_directory);
-}
-function life_target_of(git_directory) {
-  return stamp_file.stamp_path(LIFE_PREFIX, git_directory);
-}
-function begin_life(target) {
-  stamp_file.write_stamp(target, { alive: true });
-}
-function is_life_ended(target) {
-  return stamp_file.read_stamp_text(target) === void 0;
-}
-function end_life(target) {
-  stamp_file.remove_stamp(target);
-}
-function git_directory_sync() {
-  const git_binary = git_utilities.get_git_command_for_spawn();
-  const result = execaSync(git_binary, GIT_DIRECTORY_ARGUMENTS, {
-    reject: false,
-    timeout: GIT_TIMEOUT_MS
-  });
-  if (result.exitCode !== 0) return void 0;
-  const output = result.stdout.trim();
-  return output === "" ? void 0 : output;
-}
-function stamp_target_sync() {
-  const directory = git_directory_sync();
-  return directory === void 0 ? void 0 : stamp_target_of(directory);
-}
-function read_last_report_sync() {
-  const target = stamp_target_sync();
-  return target === void 0 ? void 0 : read_last_report(target);
-}
-var run_progress_clock = {
-  LIFE_PREFIX,
-  PROGRESS_PREFIX,
-  begin_life,
-  end_life,
-  is_life_ended,
-  life_target_of,
-  mark,
-  parse_stamp,
-  read_last_line,
-  read_last_report,
-  read_last_report_sync,
-  stamp_target_of,
-  stamp_target_sync
-};
-
-// scripts/run/run-progress-config.ts
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import { z as z2 } from "zod";
-var PACKAGE_FILE = "package.json";
-var CONFIG_FIELD = "josh";
-var INTERVAL_FIELD = "progress_interval_minutes";
-var MAX_DEPTH = 10;
-var package_schema = z2.object({
-  josh: z2.object({ progress_interval_minutes: z2.number().positive() }).optional()
-});
-function ancestors_of(start) {
-  const directories = [];
-  let current = path.resolve(start);
-  while (directories.length < MAX_DEPTH && !directories.includes(current)) {
-    directories.push(current);
-    current = path.dirname(current);
-  }
-  return directories;
-}
-function read_declared_minutes(directory) {
-  try {
-    const raw = readFileSync(path.join(directory, PACKAGE_FILE), "utf8");
-    const parsed = package_schema.safeParse(JSON.parse(raw));
-    return parsed.success ? parsed.data.josh?.progress_interval_minutes : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function read_package_minutes(start) {
-  for (const directory of ancestors_of(start)) {
-    const minutes = read_declared_minutes(directory);
-    if (minutes !== void 0) return minutes;
-  }
-  return void 0;
-}
-function to_ms(minutes) {
-  return minutes === void 0 ? void 0 : minutes * run_progress.MS_PER_MINUTE;
-}
-function resolve_interval_ms(raw, directory = process.cwd()) {
-  return to_ms(run_progress.minutes_from(raw)) ?? to_ms(run_progress.minutes_from(process.env[run_progress.INTERVAL_KEY])) ?? to_ms(read_package_minutes(directory)) ?? run_progress.DEFAULT_INTERVAL_MS;
-}
-function configured_interval_ms(directory = process.cwd()) {
-  return resolve_interval_ms(void 0, directory);
-}
-var run_progress_config = {
-  CONFIG_FIELD,
-  INTERVAL_FIELD,
-  PACKAGE_FILE,
-  configured_interval_ms,
-  read_package_minutes,
-  resolve_interval_ms
-};
-
-// scripts/rules/shell-segments.ts
-var SEGMENT_SEPARATOR = /&&|\|\||;|\n/u;
-function segments_of(command) {
-  return command.split(SEGMENT_SEPARATOR).map((segment) => segment.trim());
-}
-function is_josh_command(segment, names) {
-  const named = time_shell.josh_command_of(segment);
-  if (!named.startsWith(time_shell.JOSH_PREFIX)) return false;
-  return names.has(named.slice(time_shell.JOSH_PREFIX.length));
-}
-var shell_segments = {
-  SEGMENT_SEPARATOR,
-  is_josh_command,
-  segments_of
-};
-
-// scripts/rules/early-heartbeat.ts
-var ARM_PREFIX = "josh-heartbeat-arm-";
-var SEGMENT_SEPARATOR2 = /&&|\|\||;|&|\n/u;
-var SLEEP_SEGMENT = /^sleep\s+(\d+(?:\.\d+)?)([smhd]?)$/u;
-var INERT_SEGMENT = /^(?::|true|(?:echo|printf|date)\b.*)$/u;
-var LOOP_KEYWORD = /\b(?:while|until|for|do|done)\b/u;
-var SECONDS_PER_UNIT = { d: 86400, h: 3600, m: 60, s: 1 };
-var BARE_NUMBER_SECONDS = 1;
-var AMOUNT_GROUP = 1;
-var UNIT_GROUP = 2;
-var NO_SECONDS = 0;
-var ARM_RECORD = hook_decision.create_refusal_stamp(ARM_PREFIX);
-function segments_of2(command) {
-  return command.split(SEGMENT_SEPARATOR2).map((segment) => segment.trim()).filter((segment) => segment !== "");
-}
-function sleep_seconds(segment) {
-  const matched = SLEEP_SEGMENT.exec(segment);
-  if (matched === null) return void 0;
-  const unit = matched[UNIT_GROUP] ?? "";
-  return Number(matched[AMOUNT_GROUP]) * (SECONDS_PER_UNIT[unit] ?? BARE_NUMBER_SECONDS);
-}
-function is_wait_or_inert(segment) {
-  return sleep_seconds(segment) !== void 0 || INERT_SEGMENT.test(segment);
-}
-function is_wait_timer(command) {
-  if (LOOP_KEYWORD.test(command)) return false;
-  const segments = segments_of2(command);
-  if (segments.every((segment) => sleep_seconds(segment) === void 0)) return false;
-  return segments.every((segment) => is_wait_or_inert(segment));
-}
-function wait_duration_ms(command) {
-  const seconds = segments_of2(command).reduce(
-    (total, segment) => total + (sleep_seconds(segment) ?? NO_SECONDS),
-    NO_SECONDS
-  );
-  return seconds * run_progress.MS_PER_SECOND;
-}
-function is_armed(target, now_ms) {
-  return now_ms < ARM_RECORD.last_ms(target);
-}
-function landing_ms(command, now_ms, last_report_ms) {
-  const interval_ms = run_progress_config.configured_interval_ms();
-  const duration_ms = wait_duration_ms(command);
-  if (duration_ms > interval_ms) return void 0;
-  const lands_ms = now_ms + duration_ms;
-  return run_progress.is_due(last_report_ms, lands_ms, interval_ms) ? lands_ms : void 0;
-}
-function decide(call, run, can_record) {
-  const last_report_ms = run_progress_clock.read_last_report_sync();
-  if (last_report_ms === void 0) return false;
-  const target = ARM_RECORD.path(run.transcript);
-  if (is_armed(target, run.now_ms)) return true;
-  const lands_ms = landing_ms(time_shell.bash_command(call.input), run.now_ms, last_report_ms);
-  if (lands_ms === void 0) return true;
-  if (can_record) ARM_RECORD.record(target, lands_ms);
-  return false;
-}
-var EARLY_HEARTBEAT_REASON = '\u26D4 early heartbeat: this call arms a wait timer of its own, and the progress clock is not yours to keep. `pnpm josh run:progress --wait` waits the interval out for you (`JOSH_PROGRESS_INTERVAL_MINUTES`, or `josh.progress_interval_minutes` in `package.json`, default 20 minutes), prints the five labelled lines and exits \u2014 start it in the background, relay the lines it printed when it exits, and start the next one. Two timers armed at once is what produced reports 3\u20135 minutes apart on a 15-minute setting (joshuafolkken/kit#1570): a new one was armed on the turn a timer fired and again on the turn a child\'s completion woke the run, and `--mark` recorded each report without anything refusing the early ones. **An explicit ask is not a heartbeat**: if the person asked for progress now, run `pnpm josh run:progress --once`, which prints the five labelled lines whatever the clock says. If you are waiting on something rather than on a clock, wait on the thing itself \u2014 `pnpm josh followup` waits for CI. The procedure is `.claude/skills/workflow-commands/backlogrun.md` \u2192 "Progress while the run is quiet". **This rule fires on every early arm, not once per run**, so reissuing the same sleep will be refused again.';
-var PROGRESS_NAMES = /* @__PURE__ */ new Set(["run:progress"]);
-var WATCH_FLAG = /(?:^|\s)--(?:wait|once)(?=\s|$)/u;
-function is_progress_watch_segment(segment) {
-  return shell_segments.is_josh_command(segment, PROGRESS_NAMES) && WATCH_FLAG.test(segment);
-}
-function is_progress_watch(command) {
-  return segments_of2(time_shell.unquoted(command)).some(
-    (segment) => is_progress_watch_segment(segment)
-  );
-}
-function waits_for_progress(command) {
-  return is_wait_timer(command) || is_progress_watch(command);
-}
-var early_heartbeat = {
-  ARM_PREFIX,
-  EARLY_HEARTBEAT_REASON,
-  decide,
-  is_progress_watch,
-  is_wait_timer,
-  wait_duration_ms,
-  waits_for_progress
-};
-
-// scripts/git/issue-labels.ts
-var NEEDS_DECISION_LABEL = "needs-decision";
-
-// scripts/run/run-issue-number.ts
-var ISSUE_NUMBER_PATTERN = /^[1-9]\d*$/u;
-var BAD_ISSUE_MESSAGE = "Not an issue number: ";
-function require_issue_number(issue) {
-  if (!ISSUE_NUMBER_PATTERN.test(issue)) throw new Error(`${BAD_ISSUE_MESSAGE}${issue}`);
-}
-var run_issue_number = { BAD_ISSUE_MESSAGE, ISSUE_NUMBER_PATTERN, require_issue_number };
-
-// scripts/lane/lane-child-marker.ts
-var KEY = "JOSH_LANE_CHILD";
-function environment_for(issue) {
-  run_issue_number.require_issue_number(issue);
-  return { [KEY]: issue };
-}
-function marked_issue(source = process.env) {
-  const value = source[KEY];
-  if (value === void 0) return void 0;
-  return run_issue_number.ISSUE_NUMBER_PATTERN.test(value) ? value : void 0;
-}
-function is_child_of(directory, source = process.env) {
-  const marked = marked_issue(source);
-  return marked !== void 0 && marked === lane_paths.lane_issue_of(directory, { ...source });
-}
-var lane_child_marker = { KEY, env_for: environment_for, is_child_of, marked_issue };
-
-// scripts/rules/lane-park.ts
-var NOTIFY_COMMANDS = /* @__PURE__ */ new Set(["notify"]);
-var CONFIRMATION_TASK_TYPE = /(?:^|\s)--task-type[=\s]+["']?confirmation\b/u;
-function is_confirmation_notify(command) {
-  return shell_segments.segments_of(command).some(
-    (segment) => shell_segments.is_josh_command(segment, NOTIFY_COMMANDS) && CONFIRMATION_TASK_TYPE.test(segment)
-  );
-}
-function is_unparked_stop(command, is_lane_child = lane_child_marker.is_child_of(process.cwd())) {
-  if (!is_confirmation_notify(command)) return false;
-  return is_lane_child;
-}
-var APPLIES_NEEDS_DECISION = new RegExp(
-  String.raw`(?:labels\[\]=|--add-label[= ]'?)${NEEDS_DECISION_LABEL}\b`,
-  "u"
-);
-function records_the_park(command) {
-  return APPLIES_NEEDS_DECISION.test(command);
-}
-var LANE_PARK_REASON = '\u26D4 lane child park: this session is a dispatched lane child, and a stop that waits on a person must leave the question on the Issue before it sends this Telegram \u2014 otherwise the parent finds an OPEN Issue with `in-progress` and no question, and a person cannot tell what to answer (joshuafolkken/kit#2034 measured this twice in one run). The child is the only process that knows the question, the options and whether it stashed, so it records the park itself rather than leaving the parent to guess from a log. Before you notify and stop: apply `needs-decision` and post a comment carrying the question, the options, and whether work was stashed \u2014 `gh api repos/{owner}/{repo}/issues/<N>/labels -f \'labels[]=needs-decision\'` then `gh api repos/{owner}/{repo}/issues/<N>/comments --field body=@<path>`. If this stop is a `needs-human-review` or `already-done` one, that label is already on the Issue and there is nothing to add. Then reissue this notify \u2014 it fires once per run and cannot repeat on the call in hand. The procedure is `.claude/skills/workflow-commands/pre-gate-cut.md` \u2192 "A lane child records its park before it stops", and the park itself is `backlogrun-park.md` \u2192 "park and continue".';
-var lane_park = {
-  LANE_PARK_REASON,
-  is_confirmation_notify,
-  is_unparked_stop,
-  records_the_park
-};
-
-// scripts/rules/piped-verification.ts
-var VERIFICATION_COMMANDS = /* @__PURE__ */ new Set([
-  "check",
-  "cspell",
-  "cspell:dot",
-  "eval",
-  "gate",
-  "lint",
-  "lint:eslint",
-  "lint:prettier",
-  "lint:related",
-  "overrides",
-  "ranges",
-  "test",
-  "test:e2e",
-  "test:related",
-  "test:unit"
-]);
-function is_verification_command(segment) {
-  return shell_segments.is_josh_command(segment, VERIFICATION_COMMANDS);
-}
-function is_masked_verification(command) {
-  return time_shell.discarded_commands(command).some((segment) => is_verification_command(segment));
-}
-var PIPED_VERIFICATION_REASON = "\u26D4 piped verification: a pipeline exits with its last command's status, so `pnpm josh gate | tail` reports success on a gate that failed, and the verdict is discarded before anything reads it. Run the check without the pipe \u2014 josh prints its verdict line last, so the harness output cap keeps it even when the middle is elided. Where the output genuinely has to be narrowed, redirect it to a file and read ranges from that file, or prefix `set -o pipefail` so the pipeline carries the check's status. Read the printed verdict either way, never the exit code alone. Read-only listings are untouched \u2014 this fires only on a command whose result means pass or fail. The rule is in `prompts/collaboration-workflow/output-bounds.md`. Reissue this call with no pipe \u2014 it fires once per run and cannot repeat on the call in hand.";
-function command_pieces(command) {
-  return shell_segments.segments_of(time_shell.unquoted(command)).flatMap((segment) => segment.split("|")).map((piece) => piece.trim());
-}
-function runs_verification(command) {
-  return command_pieces(command).some((piece) => is_verification_command(piece));
-}
-function keeps_verdict_intact(command) {
-  return runs_verification(command) && !is_masked_verification(command);
-}
-var piped_verification = {
-  PIPED_VERIFICATION_REASON,
-  VERIFICATION_COMMANDS,
-  is_masked_verification,
-  keeps_verdict_intact,
-  runs_verification
-};
-
-// scripts/run/run-cut.ts
-import { execFileSync } from "node:child_process";
-
-// scripts/backlog/backlog-budget.ts
-var MS_PER_MINUTE2 = 6e4;
-var MINUTES_PER_HOUR2 = 60;
-var WHOLE_RUN_BUDGET_HOURS = 8;
-var WHOLE_RUN_BUDGET_MINUTES = WHOLE_RUN_BUDGET_HOURS * MINUTES_PER_HOUR2;
-var WHOLE_RUN_BUDGET_MS = WHOLE_RUN_BUDGET_MINUTES * MS_PER_MINUTE2;
-var DEFAULT_IDLE_MINUTES = 30;
-var DEFAULT_IDLE_MS = DEFAULT_IDLE_MINUTES * MS_PER_MINUTE2;
-var IDLE_POLL_MINUTES = 5;
-var RUN_VERDICT = "run";
-var WATCH_VERDICT = "watch";
-var STOP_VERDICT = "stop";
-var ANSWERS = ["blocked", "candidates", "exhausted", "parked", "unreadable"];
-var WHOLE_RUN_REASON = `The whole-run bound of ${String(WHOLE_RUN_BUDGET_HOURS)} hours has passed. An unattended run that has not finished overnight needs a person, not more waiting.`;
-var PARKED_REASON = "Nothing opted in can proceed without a person. Report the parked issues and finish.";
-var UNREADABLE_REASON = "The backlog listing could not be read, so nothing was offered. Report what the command printed and finish \u2014 it is not an empty backlog.";
-var BLOCKED_REASON = "Everything opted in is blocked or already running, so waiting can still change the answer. Poll again at the polling interval.";
-var NO_IDLE_WATCH_REASON = "The backlog is empty and the idle watch was turned off with `--idle 0`, so the run finishes here.";
-function to_minutes2(duration_ms) {
-  return String(Math.ceil(duration_ms / MS_PER_MINUTE2));
-}
-function max_reached_reason(merged, max_issues) {
-  return `This run's maximum of ${String(max_issues)} is reached, with ${String(merged)} merged. Report what was done, including how many were picked up during an idle watch, and finish.`;
-}
-function draining_reason(running, reason) {
-  return `Start nothing more and poll until the running children merge (running: ${String(running)}). Then report and finish \u2014 ${reason}`;
-}
-function idle_expired_reason(idle_budget_ms) {
-  return `The backlog stayed empty for the whole ${to_minutes2(idle_budget_ms)}-minute idle watch. Report what was done, including how many were picked up during the watch, and finish.`;
-}
-function next_ask_minutes(left_ms) {
-  const left_minutes = Number(to_minutes2(left_ms));
-  return String(Math.min(IDLE_POLL_MINUTES, left_minutes));
-}
-function idle_watch_reason(left_ms) {
-  return `The backlog is empty and the idle watch has about ${to_minutes2(left_ms)} minutes left. Release the working tree, ask again in ${next_ask_minutes(left_ms)} minutes, and restart the watch the moment a candidate appears.`;
-}
-function running_watch_reason(running, left_ms) {
-  return `The backlog is empty and the idle watch has about ${to_minutes2(left_ms)} minutes left, with ${String(running)} still running. Keep the working tree until they merge and poll at the polling interval, not the idle poll \u2014 the watch is running down meanwhile.`;
-}
-function watching_reason(input, left_ms) {
-  if (input.running === 0) return idle_watch_reason(left_ms);
-  return running_watch_reason(input.running, left_ms);
-}
-function taken_by(input) {
-  return input.merged + input.running;
-}
-function run_reason(input) {
-  const { max_issues } = input;
-  if (max_issues === void 0) return "No maximum was given, so start every issue offered.";
-  return `Start at most ${String(max_issues - taken_by(input))} more: this run's maximum is ${String(max_issues)}, with ${String(input.merged)} merged and ${String(input.running)} running.`;
-}
-var ANSWER_STOP_REASONS = {
-  parked: PARKED_REASON,
-  unreadable: UNREADABLE_REASON
-};
-function whole_run_reason(input) {
-  if (input.now_ms - input.started_at_ms < WHOLE_RUN_BUDGET_MS) return void 0;
-  return WHOLE_RUN_REASON;
-}
-function stop_reason(input) {
-  return ANSWER_STOP_REASONS[input.answer] ?? whole_run_reason(input);
-}
-function stopping(input, reason) {
-  if (input.running === 0) return { verdict: STOP_VERDICT, reason };
-  return { verdict: WATCH_VERDICT, reason: draining_reason(input.running, reason) };
-}
-function max_decision(input) {
-  const { max_issues } = input;
-  if (max_issues === void 0 || taken_by(input) < max_issues) return void 0;
-  return stopping(input, max_reached_reason(input.merged, max_issues));
-}
-function idle_decision(input) {
-  const { idle_budget_ms } = input;
-  if (idle_budget_ms === void 0) return stopping(input, NO_IDLE_WATCH_REASON);
-  const left_ms = idle_budget_ms - (input.now_ms - input.active_at_ms);
-  if (left_ms <= 0) return stopping(input, idle_expired_reason(idle_budget_ms));
-  return { verdict: WATCH_VERDICT, reason: watching_reason(input, left_ms) };
-}
-function decide2(input) {
-  const reason = stop_reason(input);
-  if (reason !== void 0) return stopping(input, reason);
-  const capped = max_decision(input);
-  if (capped !== void 0) return capped;
-  if (input.answer === "candidates") return { verdict: RUN_VERDICT, reason: run_reason(input) };
-  if (input.answer === "blocked") return { verdict: WATCH_VERDICT, reason: BLOCKED_REASON };
-  return idle_decision(input);
-}
-var backlog_budget = {
-  ANSWERS,
-  ANSWER_STOP_REASONS,
-  BLOCKED_REASON,
-  DEFAULT_IDLE_MINUTES,
-  DEFAULT_IDLE_MS,
-  IDLE_POLL_MINUTES,
-  MS_PER_MINUTE: MS_PER_MINUTE2,
-  NO_IDLE_WATCH_REASON,
-  PARKED_REASON,
-  RUN_VERDICT,
-  STOP_VERDICT,
-  UNREADABLE_REASON,
-  WATCH_VERDICT,
-  WHOLE_RUN_BUDGET_HOURS,
-  WHOLE_RUN_BUDGET_MINUTES,
-  WHOLE_RUN_BUDGET_MS,
-  WHOLE_RUN_REASON,
-  decide: decide2,
-  draining_reason,
-  idle_expired_reason,
-  idle_watch_reason,
-  max_reached_reason,
-  run_reason,
-  running_watch_reason,
-  taken_by
-};
-
-// scripts/cost-runtime/context-cut-threshold.ts
-var CONTEXT_CUT_THRESHOLD = 15e4;
-
-// scripts/git/git-push-transport.ts
-import { execa } from "execa";
-
-// scripts/git/git-execa-error.ts
-function get_exit_code(error) {
-  if (typeof error !== "object" || error === null) return void 0;
-  if (!("exitCode" in error)) return void 0;
-  const { exitCode: exit_code } = error;
-  return typeof exit_code === "number" ? exit_code : void 0;
-}
-function has_timed_out(error) {
-  if (typeof error !== "object" || error === null) return false;
-  if (!("timedOut" in error)) return false;
-  return error.timedOut === true;
-}
-function create_spawn_error(command, exit_code) {
-  const exit_code_string = exit_code === void 0 ? "unknown" : String(exit_code);
-  const error_message = `git ${command} exited with code ${exit_code_string}`;
-  return new Error(error_message, { cause: { exit_code: exit_code_string } });
-}
-
-// scripts/git/git-push-transport.ts
-var MS_PER_SECOND2 = 1e3;
-var PUSH_TIMEOUT_SECONDS = 120;
-var PUSH_TIMEOUT_MS = PUSH_TIMEOUT_SECONDS * MS_PER_SECOND2;
-var PUSH_TIMEOUT_LABEL = `${String(PUSH_TIMEOUT_SECONDS)}s`;
-var PUSH_TIMEOUT_MESSAGE = "git push timed out";
-var PUSH_TIMEOUT_EXIT_CODE = "timeout";
-var SSH_KEEPALIVE_OPTIONS = "-o ServerAliveInterval=15 -o ServerAliveCountMax=3";
-var SSH_COMMAND_VARIABLE = "GIT_SSH_COMMAND";
-var SSH_LEGACY_VARIABLE = "GIT_SSH";
-var KEEPALIVE_SSH_COMMAND = `ssh ${SSH_KEEPALIVE_OPTIONS}`;
-var SSH_COMMAND_CONFIG_KEY = "core.sshCommand";
-var PUSH_SUBCOMMAND = "push";
-function to_environment_value(name) {
-  return process.env[name]?.trim() ?? "";
-}
-function to_configured_ssh_command() {
-  const from_command = to_environment_value(SSH_COMMAND_VARIABLE);
-  return from_command === "" ? to_environment_value(SSH_LEGACY_VARIABLE) : from_command;
-}
-async function has_configured_ssh_command() {
-  if (to_configured_ssh_command() !== "") return true;
-  try {
-    const git_command_bin = git_utilities.get_git_command_for_spawn();
-    const { stdout } = await execa(git_command_bin, ["config", "--get", SSH_COMMAND_CONFIG_KEY]);
-    return stdout.trim() !== "";
-  } catch {
-    return false;
-  }
-}
-async function to_push_options() {
-  const should_keep_alive = !await has_configured_ssh_command();
-  return {
-    stdio: "inherit",
-    timeout: PUSH_TIMEOUT_MS,
-    env: should_keep_alive ? { [SSH_COMMAND_VARIABLE]: KEEPALIVE_SSH_COMMAND } : {}
-  };
-}
-async function did_push_time_out(arguments_list) {
-  const git_command_bin = git_utilities.get_git_command_for_spawn();
-  const options = await to_push_options();
-  try {
-    await execa(git_command_bin, [PUSH_SUBCOMMAND, ...arguments_list], options);
-    return false;
-  } catch (error) {
-    if (has_timed_out(error)) return true;
-    throw create_spawn_error(PUSH_SUBCOMMAND, get_exit_code(error));
-  }
-}
-function to_manual_command(arguments_list) {
-  return ["git", PUSH_SUBCOMMAND, ...arguments_list].join(" ");
-}
-function to_retry_notice(arguments_list) {
-  return `${PUSH_TIMEOUT_MESSAGE} after ${PUSH_TIMEOUT_LABEL} \u2014 retrying once: ${to_manual_command(arguments_list)}`;
-}
-function create_timeout_error(arguments_list) {
-  const message = `${PUSH_TIMEOUT_MESSAGE} twice (${PUSH_TIMEOUT_LABEL} each). Re-run it by hand: ${to_manual_command(arguments_list)}`;
-  return new Error(message, { cause: { exit_code: PUSH_TIMEOUT_EXIT_CODE } });
-}
-async function push(arguments_list) {
-  if (!await did_push_time_out(arguments_list)) return;
-  console.warn(to_retry_notice(arguments_list));
-  if (!await did_push_time_out(arguments_list)) return;
-  throw create_timeout_error(arguments_list);
-}
-var git_push_transport = {
-  push
-};
-
-// scripts/git/git-spawn.ts
-import { execa as execa2 } from "execa";
-async function read(arguments_) {
-  const git_cmd = git_utilities.get_git_command_for_spawn();
-  const { stdout } = await execa2(git_cmd, arguments_);
-  return stdout.trimEnd();
-}
-async function with_output(command, arguments_list) {
-  const git_command_bin = git_utilities.get_git_command_for_spawn();
-  try {
-    await execa2(git_command_bin, [command, ...arguments_list], { stdio: "inherit" });
-  } catch (error) {
-    throw create_spawn_error(command, get_exit_code(error));
-  }
-}
-var git_spawn = {
-  read,
-  with_output
-};
-
-// scripts/git/git-command.ts
-async function branch() {
-  return await git_spawn.read(["rev-parse", "--abbrev-ref", "HEAD"]);
-}
-async function status() {
-  return await git_spawn.read(["status", PORCELAIN_FLAG, "--untracked-files=normal"]);
-}
-async function repository_root() {
-  return await git_spawn.read(["rev-parse", "--show-toplevel"]);
-}
-async function head_commit() {
-  return await git_spawn.read(["rev-parse", "HEAD"]);
-}
-var GIT_DIRECTORY_ARGUMENTS2 = [
-  "rev-parse",
-  "--absolute-git-dir",
-  "--path-format=absolute",
-  "--git-common-dir"
-];
-async function git_directories() {
-  const output = await git_spawn.read([...GIT_DIRECTORY_ARGUMENTS2]);
-  return output.split("\n").filter((line) => line !== "");
-}
-async function diff_cached(file_path) {
-  return await git_spawn.read(["diff", "--cached", file_path]);
-}
-var REFS_REMOTES_ORIGIN_PREFIX = "refs/remotes/origin/";
-var NAME_ONLY_FLAG = "--name-only";
-var DEFAULT_BRANCH_FALLBACK = "main";
-async function get_default_branch() {
-  try {
-    const output = await git_spawn.read(["symbolic-ref", "refs/remotes/origin/HEAD"]);
-    const trimmed = output.trim();
-    if (trimmed.startsWith(REFS_REMOTES_ORIGIN_PREFIX)) {
-      return trimmed.slice(REFS_REMOTES_ORIGIN_PREFIX.length);
-    }
-  } catch {
-  }
-  return DEFAULT_BRANCH_FALLBACK;
-}
-var MERGE_BASE_COMMAND = "merge-base";
-async function reference_exists(reference) {
-  try {
-    await git_spawn.read(["rev-parse", "--verify", "--quiet", reference]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function default_branch_reference() {
-  const default_branch = await get_default_branch();
-  const remote_reference = `${REFS_REMOTES_ORIGIN_PREFIX}${default_branch}`;
-  return await reference_exists(remote_reference) ? remote_reference : default_branch;
-}
-async function change_base() {
-  const default_branch = await default_branch_reference();
-  try {
-    return await git_spawn.read([MERGE_BASE_COMMAND, default_branch, "HEAD"]);
-  } catch {
-    return default_branch;
-  }
-}
-async function diff_main(file_path) {
-  return await git_spawn.read(["diff", await change_base(), "--", file_path]);
-}
-var NO_PATH_QUOTING = ["-c", "core.quotePath=false"];
-var NO_RELATIVE_PATHS = "--no-relative";
-var NO_RENAME_DETECTION = "--no-renames";
-async function change_base_commit() {
-  return await git_spawn.read(["rev-parse", await change_base()]);
-}
-async function diff_main_names() {
-  return await git_spawn.read([
-    ...NO_PATH_QUOTING,
-    "diff",
-    NAME_ONLY_FLAG,
-    NO_RELATIVE_PATHS,
-    NO_RENAME_DETECTION,
-    await change_base(),
-    "--"
-  ]);
-}
-async function diff_cached_names() {
-  return await git_spawn.read([
-    ...NO_PATH_QUOTING,
-    "diff",
-    "--cached",
-    NAME_ONLY_FLAG,
-    NO_RELATIVE_PATHS,
-    NO_RENAME_DETECTION
-  ]);
-}
-var WHOLE_TREE_PATHSPEC = ":/";
-async function untracked_names() {
-  return await git_spawn.read([
-    ...NO_PATH_QUOTING,
-    "ls-files",
-    "--others",
-    "--exclude-standard",
-    "--full-name",
-    WHOLE_TREE_PATHSPEC
-  ]);
-}
-async function fetch_branch(branch_name) {
-  const refspec = `+refs/heads/${branch_name}:refs/remotes/origin/${branch_name}`;
-  return await git_spawn.read(["fetch", "origin", refspec]);
-}
-async function merge_fast_forward(branch_name) {
-  return await git_spawn.read(["merge", "--ff-only", `origin/${branch_name}`]);
-}
-async function merge_branch(branch_name) {
-  await git_spawn.with_output("merge", [`origin/${branch_name}`]);
-}
-async function checkout_b(branch_name) {
-  return await git_spawn.read(["checkout", "-b", branch_name]);
-}
-async function checkout(branch_name) {
-  return await git_spawn.read(["checkout", branch_name]);
-}
-async function commit(message) {
-  await git_spawn.with_output("commit", ["-m", message]);
-}
-async function delete_branch(branch_name) {
-  await git_spawn.read(["branch", "-d", branch_name]);
-}
-async function commit_count_beyond(base, tip) {
-  const range = `${base}..${tip}`;
-  const output = await git_spawn.read(["rev-list", "--count", range]);
-  const parsed = Number(output);
-  if (output.length > 0 && Number.isFinite(parsed)) return parsed;
-  throw new Error(`\`git rev-list --count ${range}\` printed \`${output}\` rather than a count`);
-}
-function is_exit_code_128(cause) {
-  return typeof cause === "object" && cause !== null && "exit_code" in cause && cause.exit_code === "128";
-}
-function is_upstream_not_set_error(error) {
-  if (!(error instanceof Error)) return false;
-  const { cause } = error;
-  return cause !== void 0 && is_exit_code_128(cause);
-}
-async function push_with_upstream(branch_name) {
-  await git_push_transport.push(["--set-upstream", "origin", branch_name]);
-}
-async function push2() {
-  try {
-    await git_push_transport.push([]);
-  } catch (error) {
-    if (is_upstream_not_set_error(error)) {
-      const current_branch = await branch();
-      await push_with_upstream(current_branch);
-      return;
-    }
-    throw error;
-  }
-}
-async function pull_fast_forward() {
-  await git_spawn.with_output("pull", ["--ff-only"]);
-}
-var SHORT_NAME_FORMAT = "--format=%(refname:short)";
-var REMOTES_FLAG = "--remotes";
-async function list_branches(flags, pattern) {
-  try {
-    const output = await git_spawn.read([
-      "branch",
-      "--list",
-      SHORT_NAME_FORMAT,
-      ...flags,
-      pattern
-    ]);
-    return output.split("\n").filter((line) => line.trim() !== "");
-  } catch {
-    return [];
-  }
-}
-async function branch_names(pattern) {
-  return await list_branches([], pattern);
-}
-async function branch_names_remote(pattern) {
-  return await list_branches([REMOTES_FLAG], pattern);
-}
-async function branch_exists(branch_name) {
-  const names = await branch_names(branch_name);
-  return names.length > 0;
-}
-var ALL_PATHS_PATHSPEC = ":/";
-function exclude_pathspec(file_path) {
-  return `:(exclude,top)${file_path}`;
-}
-async function add_tracked(excluded_paths) {
-  const exclusions = excluded_paths.map((file_path) => exclude_pathspec(file_path));
-  await git_spawn.read(["add", "-u", "--", ALL_PATHS_PATHSPEC, ...exclusions]);
-}
-async function add_path(file_path) {
-  await git_spawn.with_output("add", ["--", file_path]);
-}
-var FIRST_PARENT_FLAG = "--first-parent";
-async function log_first_parent(limit, file_path, tip = "HEAD") {
-  const output = await git_spawn.read([
-    "log",
-    FIRST_PARENT_FLAG,
-    "--format=%H",
-    `-n`,
-    String(limit),
-    tip,
-    "--",
-    file_path
-  ]);
-  return output.split("\n").filter((line) => line.length > 0);
-}
-async function show_file(spec) {
-  return await git_spawn.read(["show", spec]);
-}
-var MERGE_COUNT_ARGUMENTS = [
-  "rev-list",
-  "--count",
-  "--merges",
-  FIRST_PARENT_FLAG
-];
-function merge_count_arguments(range) {
-  return [...MERGE_COUNT_ARGUMENTS, range];
-}
-async function count_merges(range) {
-  const output = await git_spawn.read(merge_count_arguments(range));
-  const parsed = Number(output.trim());
-  return Number.isFinite(parsed) ? parsed : 0;
-}
-var git_command = {
-  GIT_DIRECTORY_ARGUMENTS: GIT_DIRECTORY_ARGUMENTS2,
-  branch,
-  status,
-  repository_root,
-  head_commit,
-  git_directories,
-  diff_cached,
-  diff_cached_names,
-  diff_main,
-  change_base,
-  change_base_commit,
-  diff_main_names,
-  untracked_names,
-  get_default_branch,
-  default_branch_reference,
-  fetch_branch,
-  merge_fast_forward,
-  merge_branch,
-  checkout_b,
-  checkout,
-  commit,
-  commit_count_beyond,
-  delete_branch,
-  push: push2,
-  pull_fast_forward,
-  branch_exists,
-  branch_names,
-  branch_names_remote,
-  add_tracked,
-  add_path,
-  log_first_parent,
-  show_file,
-  count_merges,
-  merge_count_arguments,
-  is_upstream_not_set_error
-};
-
-// scripts/lane/lane-child-invocation.ts
-var CHILD_INVOCATION = "fullrun";
-var RESUME_GUIDE = ".claude/skills/workflow-commands/pre-gate-cut.md";
-function child_invocation(issue) {
-  run_issue_number.require_issue_number(issue);
-  return `${CHILD_INVOCATION} #${issue}`;
-}
-function resume_invocation(issue) {
-  const preamble = `Resuming the lane child for issue #${issue} \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Run \`pnpm josh run:cut --resume ${issue}\` before anything else and follow the matching verdict in ${RESUME_GUIDE}: \`resume\` goes to the gate, \`resume-impl\` continues implementation. Only on \`fresh\` proceed as an ordinary`;
-  return `${preamble} ${child_invocation(issue)}`;
-}
-var lane_child_invocation = { CHILD_INVOCATION, child_invocation, resume_invocation };
-
-// scripts/run/run-cut.ts
-import { z as z4 } from "zod";
-
-// scripts/run/run-hold.ts
-import { z as z3 } from "zod";
-var HOLD_PREFIX = "josh-run-hold-";
-var UNNUMBERED_ISSUE = "new";
-var HOLD_MAX_AGE_HOURS = 8;
-var MILLISECONDS_PER_HOUR = 36e5;
-var HOLD_MAX_AGE_MS = HOLD_MAX_AGE_HOURS * MILLISECONDS_PER_HOUR;
-var RELEASE_COMMAND = "pnpm josh run:release";
-var FORCE_RELEASE_COMMAND = `${RELEASE_COMMAND} --force`;
-var NOT_IDLE = 'that is not "nothing is running here"';
-var FREE_READ = { kind: "free" };
-var UNREADABLE_READ = { kind: "unreadable" };
-function hold_path(git_directory) {
-  return stamp_file.stamp_path(HOLD_PREFIX, git_directory);
-}
-async function worktree_directory() {
-  const directories = await git_command.git_directories();
-  return directories[0];
-}
-async function is_linked_worktree() {
-  const directories = await git_command.git_directories();
-  return directories[0] !== void 0 && directories[0] !== directories[1];
-}
-var run_hold_schema = z3.object({
-  issue: z3.string(),
-  taken_at: z3.string(),
-  pid: z3.number()
-});
-function parse_hold(raw) {
-  try {
-    const parsed = run_hold_schema.safeParse(JSON.parse(raw));
-    return parsed.success ? parsed.data : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function is_stale(hold, now) {
-  const taken = Date.parse(hold.taken_at);
-  if (Number.isNaN(taken)) return true;
-  return now.getTime() - taken > HOLD_MAX_AGE_MS;
-}
-function classify(raw, now) {
-  if (raw === void 0) return FREE_READ;
-  const hold = parse_hold(raw);
-  if (hold === void 0) return UNREADABLE_READ;
-  return is_stale(hold, now) ? { kind: "stale", hold } : { kind: "held", hold };
-}
-function read_hold(target, now = /* @__PURE__ */ new Date()) {
-  return classify(stamp_file.read_stamp_text(target), now);
-}
-function build_hold(issue, now) {
-  return { issue, taken_at: now.toISOString(), pid: process.pid };
-}
-function write_hold(target, issue, now = /* @__PURE__ */ new Date()) {
-  const hold = build_hold(issue, now);
-  stamp_file.write_stamp(target, hold);
-  return hold;
-}
-function create_hold(target, issue, now = /* @__PURE__ */ new Date()) {
-  return stamp_file.create_stamp(target, build_hold(issue, now));
-}
-async function is_tree_dirty() {
-  try {
-    const status2 = await git_command.status();
-    return status2.trim() !== "";
-  } catch {
-    return true;
-  }
-}
-function release_hold(target) {
-  stamp_file.remove_stamp(target);
-}
-function describe_holder(hold) {
-  const holder = hold.issue === UNNUMBERED_ISSUE ? "an unnumbered run" : `#${hold.issue}`;
-  return `${holder}, recorded ${hold.taken_at} (pid ${String(hold.pid)})`;
-}
-function own_release_command(issue) {
-  return issue === UNNUMBERED_ISSUE ? RELEASE_COMMAND : `${RELEASE_COMMAND} ${issue}`;
-}
-function is_own_hold(hold, claimant) {
-  return hold.issue === claimant;
-}
-function held_message(hold) {
-  return `This working tree is already held by ${describe_holder(hold)}. One run at a time per working tree: a second run here commits its files onto the other run's branch. If that record is stale, run \`${FORCE_RELEASE_COMMAND}\` in this working tree \u2014 it removes a record this run did not write, so be sure the run that did has ended \u2014 and ask again.`;
-}
-function foreign_release_message(hold) {
-  return `This working tree is held by ${describe_holder(hold)}, and this release did not claim it \u2014 nothing was removed. Release it as that run with \`${own_release_command(hold.issue)}\`, or, once you are sure it has ended, remove the record with \`${FORCE_RELEASE_COMMAND}\`.`;
-}
-function forced_release_message(hold) {
-  return `Forced: removed the run record held by ${describe_holder(hold)}.`;
-}
-function unreadable_message() {
-  return `This working tree's run record could not be read \u2014 ${NOT_IDLE}. Run \`${FORCE_RELEASE_COMMAND}\` in this working tree to clear it, then ask again.`;
-}
-function stale_message(hold) {
-  return `Replaced a stale run record held by ${describe_holder(hold)}: older than ${String(HOLD_MAX_AGE_HOURS)} hours, so the run that wrote it has ended without releasing it.`;
-}
-function uncommitted_message(hold) {
-  return `This working tree still has uncommitted changes, and its run record \u2014 held by ${describe_holder(hold)} \u2014 has expired. That is a run which stopped for a person rather than one that finished, so the tree is not free: commit or stash the work, or run \`${own_release_command(hold.issue)}\` once you are done with it, then ask again.`;
-}
-function race_message(read2, target) {
-  if (read2.kind === "held") return held_message(read2.hold);
-  return `A record already exists at ${target} and this run did not write it \u2014 ${NOT_IDLE}. Either another run claimed the tree at the same moment, or the record belongs to another account. Run \`${FORCE_RELEASE_COMMAND}\`, and remove that file by hand if it is still there.`;
-}
-function unknown_message() {
-  return `Could not read this working tree's git directory \u2014 ${NOT_IDLE}. Run this from inside the checkout the run will edit.`;
-}
-var run_hold = {
-  FORCE_RELEASE_COMMAND,
-  HOLD_MAX_AGE_HOURS,
-  HOLD_MAX_AGE_MS,
-  RELEASE_COMMAND,
-  UNNUMBERED_ISSUE,
-  classify,
-  create_hold,
-  describe_holder,
-  foreign_release_message,
-  forced_release_message,
-  held_message,
-  hold_path,
-  is_linked_worktree,
-  is_own_hold,
-  is_tree_dirty,
-  own_release_command,
-  parse_hold,
-  race_message,
-  read_hold,
-  release_hold,
-  stale_message,
-  uncommitted_message,
-  unknown_message,
-  unreadable_message,
-  worktree_directory,
-  write_hold
-};
-
-// scripts/run/run-cut.ts
-var CUT_PREFIX = "josh-run-cut-";
-var PRE_GATE_PHASE = "pre-gate";
-var IMPLEMENTATION_PHASE = "implementation";
-var IMPLEMENTATION_CONTEXT_THRESHOLD = CONTEXT_CUT_THRESHOLD;
-var CUT_MAX_AGE_MS = backlog_budget.WHOLE_RUN_BUDGET_MS;
-var CUT_MAX_AGE_HOURS = backlog_budget.WHOLE_RUN_BUDGET_HOURS;
-var GIT_READ_TIMEOUT_MS = 5e3;
-var END_COMMAND = "pnpm josh run:cut --end";
-var READ_COMMAND = "pnpm josh run:cut --json";
-var NONE_READ = { kind: "none" };
-var UNREADABLE_READ2 = { kind: "unreadable" };
-var run_cut_schema = z4.object({
-  invocation: z4.string(),
-  issue: z4.string(),
-  branch: z4.string(),
-  phase: z4.string(),
-  cut_at: z4.string(),
-  is_handed_off: z4.boolean().optional()
-});
-function cut_path(git_directory) {
-  return stamp_file.stamp_path(CUT_PREFIX, git_directory);
-}
-var { worktree_directory: worktree_directory2 } = run_hold;
-function invocation_for(issue) {
-  return lane_child_invocation.child_invocation(issue);
-}
-function parse_cut(raw) {
-  try {
-    const parsed = run_cut_schema.safeParse(JSON.parse(raw));
-    return parsed.success ? parsed.data : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function is_expired(cut, now) {
-  const started = Date.parse(cut.cut_at);
-  if (Number.isNaN(started)) return true;
-  return now.getTime() - started > CUT_MAX_AGE_MS;
-}
-function classify2(raw, now) {
-  if (raw === void 0) return NONE_READ;
-  const cut = parse_cut(raw);
-  if (cut === void 0) return UNREADABLE_READ2;
-  return is_expired(cut, now) ? { kind: "expired", cut } : { kind: "carried", cut };
-}
-function read_cut(target, now = /* @__PURE__ */ new Date()) {
-  return classify2(stamp_file.read_stamp_text(target), now);
-}
-function worktree_git_directory_sync() {
-  try {
-    const output = execFileSync(
-      git_utilities.get_git_command_for_spawn(),
-      [...git_command.GIT_DIRECTORY_ARGUMENTS],
-      // git's own diagnostics are discarded: a checkout it cannot describe is already the
-      // `undefined` below, and a hook that let `fatal: not a git repository` through would print it
-      // in front of a tool call that is about to be allowed.
-      // A `PreToolUse` hook holds the tool call while it runs, so the read is bounded rather than
-      // left to whatever git does.
-      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: GIT_READ_TIMEOUT_MS }
-    );
-    return output.split("\n").find((line) => line !== "");
-  } catch {
-    return void 0;
-  }
-}
-function carried_cut_sync(now = /* @__PURE__ */ new Date(), directory = worktree_git_directory_sync()) {
-  if (directory === void 0) return void 0;
-  const read2 = read_cut(cut_path(directory), now);
-  return read2.kind === "carried" ? read2.cut : void 0;
-}
-function fresh_cut(spec, now) {
-  return {
-    invocation: invocation_for(spec.issue),
-    issue: spec.issue,
-    branch: spec.branch,
-    phase: spec.phase,
-    cut_at: now.toISOString(),
-    is_handed_off: true
-  };
-}
-function begin_cut(target, spec, now = /* @__PURE__ */ new Date()) {
-  const cut = fresh_cut(spec, now);
-  return stamp_file.create_stamp(target, cut) ? cut : void 0;
-}
-function is_declared_cut(cut, issue) {
-  return cut.is_handed_off === true && cut.invocation === invocation_for(issue);
-}
-function matches_state(cut, request) {
-  return cut.branch === request.current_branch && cut.issue === request.issue && request.is_dirty && request.is_held;
-}
-function is_adopted_cut(cut, issue) {
-  return cut.is_handed_off === false && cut.invocation === invocation_for(issue);
-}
-function classify_resume(cut, request) {
-  if (is_adopted_cut(cut, request.issue)) return "handed-off";
-  if (!is_declared_cut(cut, request.issue)) return "stale";
-  return matches_state(cut, request) ? "resume" : "stale";
-}
-function adopt_cut(target, cut) {
-  const next = { ...cut, is_handed_off: false };
-  stamp_file.remove_stamp(target);
-  return stamp_file.create_stamp(target, next) ? next : void 0;
-}
-function end_cut(target) {
-  stamp_file.remove_stamp(target);
-}
-function tree_is_held(directory) {
-  if (directory === void 0) return false;
-  const read2 = run_hold.read_hold(run_hold.hold_path(directory));
-  return read2.kind === "held" || read2.kind === "stale";
-}
-async function current_state() {
-  const branch2 = await git_command.branch();
-  const is_dirty = await run_hold.is_tree_dirty();
-  const directory = await worktree_directory2();
-  return { branch: branch2, is_dirty, is_held: tree_is_held(directory) };
-}
-function describe_cut(cut) {
-  return `${cut.invocation} cut at ${cut.cut_at} on ${cut.branch} (${cut.phase})`;
-}
-function busy_message(cut) {
-  return `Another process already resumed this cut \u2014 ${describe_cut(cut)}. Nothing was resumed here; a double launch was detected.`;
-}
-function handed_off_message(cut) {
-  return `This cut was already handed off to a successor \u2014 ${describe_cut(cut)}. Nothing was resumed here; the run is being carried on by the process that adopted it, so this one has nothing to do.`;
-}
-function stale_message2(cut) {
-  return `This cut does not match the current tree \u2014 ${describe_cut(cut)}. Resume failed; verify the branch and the uncommitted work, then clear it with \`${END_COMMAND}\` if the run is over.`;
-}
-function unreadable_message2() {
-  return `A cut record is here but could not be read; clear it with \`${END_COMMAND}\` once you know no run is using it. Read it with \`${READ_COMMAND}\`.`;
-}
-function unknown_message2() {
-  return "This working tree\u2019s git directory could not be read, so no cut record was acted on.";
-}
-var run_cut = {
-  CUT_MAX_AGE_HOURS,
-  CUT_MAX_AGE_MS,
-  END_COMMAND,
-  IMPLEMENTATION_CONTEXT_THRESHOLD,
-  IMPLEMENTATION_PHASE,
-  PRE_GATE_PHASE,
-  adopt_cut,
-  begin_cut,
-  busy_message,
-  carried_cut_sync,
-  classify: classify2,
-  classify_resume,
-  current_state,
-  cut_path,
-  describe_cut,
-  end_cut,
-  fresh_cut,
-  handed_off_message,
-  invocation_for,
-  is_expired,
-  read_cut,
-  stale_message: stale_message2,
-  unknown_message: unknown_message2,
-  unreadable_message: unreadable_message2,
-  worktree_directory: worktree_directory2,
-  worktree_git_directory_sync
-};
-
-// scripts/rules/pre-gate-cut.ts
-var GATE_COMMANDS = /* @__PURE__ */ new Set(["gate"]);
-var CUT_COMMANDS = /* @__PURE__ */ new Set(["run:cut"]);
-var CUT_MODE_FLAG = /(?:^|\s)--(?:resume|end|json)(?:[=\s]|$)/u;
-var HOLD_COMMANDS = /* @__PURE__ */ new Set(["run:hold"]);
-var HOLD_MODE_FLAG = /(?:^|\s)--release(?:[=\s]|$)/u;
-function invokes_josh(command, names, mode_flag) {
-  return shell_segments.segments_of(command).some(
-    (segment) => shell_segments.is_josh_command(segment, names) && mode_flag?.test(segment) !== true
-  );
-}
-function runs_the_gate(command) {
-  return invokes_josh(command, GATE_COMMANDS);
-}
-function takes_the_cut(command) {
-  return invokes_josh(command, CUT_COMMANDS, CUT_MODE_FLAG);
-}
-function claims_the_hold(command) {
-  return invokes_josh(command, HOLD_COMMANDS, HOLD_MODE_FLAG);
-}
-function asks_about_the_cut(command) {
-  return invokes_josh(command, CUT_COMMANDS);
-}
-function current_state2() {
-  return {
-    directory: process.cwd(),
-    carried: run_cut.carried_cut_sync,
-    marked_issue: lane_child_marker.marked_issue()
-  };
-}
-function uncut_lane_issue(state) {
-  const issue = lane_paths.lane_issue_of(state.directory);
-  if (issue === void 0) return void 0;
-  if (state.marked_issue !== issue) return void 0;
-  return state.carried()?.issue === issue ? void 0 : issue;
-}
-function is_uncut_gate(command, state = current_state2()) {
-  if (!runs_the_gate(command)) return false;
-  return uncut_lane_issue(state) !== void 0;
-}
-var PRE_GATE_CUT_REASON = "\u26D4 pre-gate cut: this checkout is a lane dispatched for this issue and the gate is the boundary to cut at, so take the cut before running it. `pnpm josh run:cut <N>` ends this process and relaunches a fresh one that resumes from the gate, dropping the thinking built up while implementing rather than carrying it on every later request \u2014 joshuafolkken/kit#1839 measured 176K of 204K output riding across that boundary, and joshuafolkken/kit#1864 measured the step itself firing 0 times in 6 lane children while it was carried as prose. Issue `pnpm josh run:cut <N>` now, and read the verdict: on `cut`, **end the turn immediately** \u2014 the fresh process owns the run from there and must not be waited for; on `not-a-lane`, `unready`, `busy`, `failed` or `unknown`, this process carries the run on and the gate is simply the next call. Never relaunch a second process after `busy`. This fired because the dispatch mark names this lane; a person working here carries no mark and sees no refusal, so there is no human-or-child judgement left to make. The procedure is `.claude/skills/workflow-commands/pre-gate-cut.md`. Reissue the gate once the cut has answered \u2014 this fires once per run, so it cannot repeat on the call in hand.";
-var pre_gate_cut = {
-  PRE_GATE_CUT_REASON,
-  asks_about_the_cut,
-  claims_the_hold,
-  is_uncut_gate,
-  runs_the_gate,
-  takes_the_cut,
-  uncut_lane_issue
-};
-
-// scripts/rules/prior-comment-read.ts
-var ISSUE_PATH_NUMBER = /issues\/(\d+)/gu;
-var ISSUE_VIEW_NUMBER = /\bissue\s+view\s+(?:-{1,2}\S+\s+)*(\d+)/u;
-var ISSUE_READ_ARGUMENTS = /\bissue:read\b([\s\d]*)/u;
-var A_NUMBER = /^\d+$/u;
-var COMMENTS_ENDPOINT = /issues\/\d+\/comments\b/u;
-var VIEW_WITH_COMMENTS = /\bissue\s+view\b[^\n]*--comments\b/u;
-var ISSUE_READ_COMMAND = /\bissue:read\b/u;
-function add_issue_read_numbers(command, numbers) {
-  const match = ISSUE_READ_ARGUMENTS.exec(command);
-  if (match === null) return;
-  const tokens = (match[1] ?? "").split(/\s+/u);
-  for (const token of tokens) {
-    if (A_NUMBER.test(token)) numbers.add(Number(token));
-  }
-}
-function issue_numbers_of(command) {
-  const numbers = /* @__PURE__ */ new Set();
-  for (const match of command.matchAll(ISSUE_PATH_NUMBER)) numbers.add(Number(match[1]));
-  const view = ISSUE_VIEW_NUMBER.exec(command);
-  if (view !== null) numbers.add(Number(view[1]));
-  add_issue_read_numbers(command, numbers);
-  return numbers;
-}
-function fetches_comments(command) {
-  return COMMENTS_ENDPOINT.test(command) || VIEW_WITH_COMMENTS.test(command) || ISSUE_READ_COMMAND.test(command);
-}
-function reads_target_comments(command, target) {
-  if (!fetches_comments(command)) return false;
-  for (const number of issue_numbers_of(command)) {
-    if (target.has(number)) return true;
-  }
-  return false;
-}
-function is_bash_call(block) {
-  return block.type === cost_blocks.TOOL_USE_TYPE && block.name === cost_blocks.BASH_TOOL;
-}
-function bash_commands_of(line) {
-  const parsed = time_transcript_line.parse_line(line);
-  if (parsed === void 0) return [];
-  return parsed.blocks.filter((block) => is_bash_call(block)).map((block) => time_shell.bash_command(block.input));
-}
-function prior_commands(tail) {
-  return tail.split("\n").flatMap((line) => bash_commands_of(line));
-}
-function already_read_comments_for(tail, command) {
-  const target = issue_numbers_of(command);
-  if (target.size === 0) return false;
-  return prior_commands(tail).some((prior) => reads_target_comments(prior, target));
-}
-function already_read_for_call(tail, call) {
-  if (call.name !== cost_blocks.BASH_TOOL) return false;
-  return already_read_comments_for(tail, time_shell.bash_command(call.input));
-}
-var prior_comment_read = {
-  already_read_comments_for,
-  already_read_for_call,
-  fetches_comments,
-  issue_numbers_of
-};
-
-// scripts/rules/run-tail.ts
-var SEGMENT_PREFIX = String.raw`(?:\(\s*)?(?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)*(?:npx\s+|pnpm\s+(?:exec\s+|run\s+)?)?`;
-var WORD_END = String.raw`(?=\s|$|\))`;
-var PUSH_STEP_SEGMENT = new RegExp(String.raw`^${SEGMENT_PREFIX}josh\s+(?:git|g)${WORD_END}`, "u");
-var CONFIRMED_FLAG = new RegExp(String.raw`(?:^|\s)(?:-y|--yes)${WORD_END}`, "u");
-var SKIPS_THE_PUSH = new RegExp(String.raw`(?:^|\s)--skip-push${WORD_END}`, "u");
-var BACKGROUND_KEY = "run_in_background";
-var QUOTED_SPAN = /"[^"]*"|'[^']*'/gu;
-function flags_of(segment) {
-  return segment.replaceAll(QUOTED_SPAN, " ");
-}
-function is_push_step_segment(segment) {
-  if (!PUSH_STEP_SEGMENT.test(segment)) return false;
-  const flags = flags_of(segment);
-  if (SKIPS_THE_PUSH.test(flags)) return false;
-  return CONFIRMED_FLAG.test(flags);
-}
-function is_push_step(command) {
-  return shell_segments.segments_of(command).some((segment) => is_push_step_segment(segment));
-}
-function is_backgrounded(input) {
-  if (!json_value.is_record(input)) return false;
-  return input[BACKGROUND_KEY] === true;
-}
-function is_push_step_call(call) {
-  if (call.name !== cost_blocks.BASH_TOOL) return false;
-  return is_push_step(time_shell.bash_command(call.input));
-}
-function is_backgrounded_push_step(call) {
-  if (!is_backgrounded(call.input)) return false;
-  return is_push_step_call(call);
-}
-function is_foreground_push_step(call) {
-  if (is_backgrounded(call.input)) return false;
-  return is_push_step_call(call);
-}
-function decide3() {
-  return true;
-}
-var RUN_TAIL_REASON = '\u26D4 run tail: this issues the commit-push-PR step in the foreground, where the harness decides when to stop waiting. Reissue it with `run_in_background` set. In `fullrun #1501` this call was given a 900-second timeout, the harness detached it at its own 600-second cap, and nothing read the output for a further 6m28s \u2014 45m03s of wall clock on about 17 minutes of work (joshuafolkken/kit#1510). **Never give a foreground call a timeout above the harness cap**: the cap decides, not the number. A backgrounded call re-invokes you when it exits, so the completion notification is what resumes the run. **When it arrives, the turn that reads it goes straight through any branch-2 filing and `pnpm josh epic:bundle` to `pnpm josh followup` \u2014 the turn never ends at the push.** CI went green 6m06s before the merge started in that run, and it started only because the person asked; joshuafolkken/kit#1333 had already settled that the merge is issued in the turn the review closes. While the push runs, do the work that writes nothing \u2014 drafting the completion body to a file, deciding the branch-2 disposition. `pnpm josh followup` itself stays in the **foreground** \u2014 nearly every step after it reads its result. But a tail does follow the merge, measured at 3.0 min and 5.9% of a run (joshuafolkken/kit#1462), so empty it beforehand: the steps that read the merge result stay after `followup`, and the rest are composed in the turn that issues it, bar the one exception background-commands.md names. The procedure is `.claude/skills/workflow-commands/background-commands.md`, "A command that can take minutes is issued in the background". **This rule fires on every foreground push, not once per run**, so reissuing the same call in the foreground will be refused again.';
-var run_tail = {
-  RUN_TAIL_REASON,
-  decide: decide3,
-  is_backgrounded_push_step,
-  is_foreground_push_step,
-  is_push_step,
-  is_push_step_call
-};
-
-// scripts/rules/shell-body-trigger.ts
-var FIELD_FLAGS = "(?:-f|-F|--field|--raw-field)";
-var MESSAGE_FLAGS = "(?:--body|--notify-message)";
-var FIELD_OPENING = String.raw`${FIELD_FLAGS}[\s=]*(?:'?body="|"body=)`;
-var MESSAGE_OPENING = String.raw`${MESSAGE_FLAGS}[\s=]+"`;
-var NESTED_SUBSTITUTION = String.raw`\$\([^()]*\)`;
-var SUBSTITUTION = String.raw`\$\((?:[^()$]|\$(?!\()|${NESTED_SUBSTITUTION})*\)`;
-var QUOTED_VALUE = String.raw`(?:[^"\\$]|\\.|\$(?!\()|${SUBSTITUTION})*`;
-var INLINE_BODY_VALUE = new RegExp(
-  `(?:${FIELD_OPENING}|${MESSAGE_OPENING})(${QUOTED_VALUE})"`,
-  "gu"
-);
-var SHELL_EVALUATED = /[`$]/u;
-var WHOLE_VALUE_SUBSTITUTION = new RegExp(`^${SUBSTITUTION}$`, "u");
-var BACKTICK = "`";
-var WHOLE_VALUE_FILE_REFERENCE = /^@\S+$/u;
-var ESCAPED_PAIR = /\\./gu;
-function is_whole_value_substitution(literal) {
-  return WHOLE_VALUE_SUBSTITUTION.test(literal) && !literal.includes(BACKTICK);
-}
-function is_body_already_in_a_file(literal) {
-  return WHOLE_VALUE_FILE_REFERENCE.test(literal) || is_whole_value_substitution(literal);
-}
-function is_evaluated_value(raw_value) {
-  const literal = raw_value.replaceAll(ESCAPED_PAIR, "");
-  if (is_body_already_in_a_file(literal)) return false;
-  return SHELL_EVALUATED.test(literal);
-}
-function is_shell_evaluated_body(command) {
-  for (const match of command.matchAll(INLINE_BODY_VALUE)) {
-    if (is_evaluated_value(match[1] ?? "")) return true;
-  }
-  return false;
-}
-var FILE_FLAG = /(?:--body-file|--notify-message-file)(?:[\s=]|$)/u;
-var FIELD_FILE_REFERENCE = new RegExp(String.raw`${FIELD_FLAGS}[\s=]*body=@\S`, "u");
-var ANSI_C_BODY = /(?:(?:--body|--notify-message)[\s=]+|body=)\$'/u;
-var DOUBLE_QUOTED_SPAN = /"[^"]*"/gu;
-var BODY_FLAG = new RegExp(
-  String.raw`${FIELD_FLAGS}[\s=]*'?"?body=|${MESSAGE_FLAGS}[\s=]|--body-file[\s=]|--notify-message-file[\s=]`,
-  "u"
-);
-var QUOTED_SPAN2 = /"[^"]*"|'[^']*'/gu;
-function inline_body_literals(command) {
-  return Array.from(
-    command.matchAll(INLINE_BODY_VALUE),
-    (match) => (match[1] ?? "").replaceAll(ESCAPED_PAIR, "")
-  );
-}
-function is_safe_body_form(command) {
-  if (ANSI_C_BODY.test(command.replaceAll(DOUBLE_QUOTED_SPAN, " "))) return true;
-  const flags = command.replaceAll(QUOTED_SPAN2, " ");
-  if (FILE_FLAG.test(flags) || FIELD_FILE_REFERENCE.test(flags)) return true;
-  return inline_body_literals(command).some((literal) => is_body_already_in_a_file(literal));
-}
-function keeps_body_safe(command) {
-  return is_safe_body_form(command) && !is_shell_evaluated_body(command);
-}
-function carries_a_body(command) {
-  if (BODY_FLAG.test(command.replaceAll(QUOTED_SPAN2, " "))) return true;
-  return inline_body_literals(command).length > 0;
-}
-var shell_body_trigger = {
-  carries_a_body,
-  is_safe_body_form,
-  is_shell_evaluated_body,
-  keeps_body_safe
-};
-
-// scripts/rules/delivered-rules.ts
-var SWITCH_ENV_KEY = "JOSH_RULE_GUARD";
-var STAMP_PREFIX = "josh-rule-guard-";
-var ISSUE_CREATE_COMMAND = /\bgh\s+(?:\S+\s+)*?issue\s+create\b/u;
-var ISSUES_ENDPOINT = /repos\/[^\s'"]*\/issues(?=$|["'\s])/u;
-var TITLE_FIELD = /(?:-f|-F|--field|--raw-field)\s*'?title=/u;
-function is_issue_filing(command) {
-  if (ISSUE_CREATE_COMMAND.test(command)) return true;
-  return ISSUES_ENDPOINT.test(command) && TITLE_FIELD.test(command);
-}
-function on_bash_command(is_match) {
-  return function is_trigger(call) {
-    if (call.name !== cost_blocks.BASH_TOOL) return false;
-    return is_match(time_shell.bash_command(call.input));
-  };
-}
-var WIP_CAP_REASON = "\u26D4 backlog WIP cap: count the target repository's open Issues before filing. With more than 30 open, close one first; nothing honestly closable means do not file. Two filings are exempt and proceed while stating the overage \u2014 one the run is blocked by, and an interrupt, decided by three tests rather than judgement: a verification answers wrongly, a documented workflow cannot complete, or data is lost or written outside the repository. Meeting none of the three, the finding is discretionary and waits. The count command and both procedures are in `prompts/collaboration-workflow/wip-cap.md`. Reissue this call once you have counted \u2014 it fires once per run and cannot repeat on the call in hand.";
-var GH_FLAGS = String.raw`(?:-{1,2}[\w-]+(?:[= ][^\s]+)?\s+)*`;
-var ISSUE_VIEW_COMMAND = new RegExp(String.raw`^gh\s+${GH_FLAGS}issue\s+view\s`, "u");
-var GH_API_COMMAND = new RegExp(String.raw`^gh\s+${GH_FLAGS}api\s`, "u");
-var ISSUE_BODY_PATH = /repos\/[^\s'"]*\/issues\/\d+(?=$|["'\s])/u;
-var API_METHOD = /(?:^|\s)(?:--method|-X)[= ]([A-Za-z]+)/u;
-var API_FIELD = /(?:^|\s)(?:--raw-field|--field|--input|-F|-f)(?:[= ]|$)/u;
-var FETCHES_COMMENTS = /--comments\b|--json\s[\w,]*\bcomments\b|\/comments\b/u;
-var ISSUES_PATH = /repos\/[^\s'"]*\/issues\//u;
-function is_api_read(segment) {
-  const method = API_METHOD.exec(segment)?.[1];
-  if (method !== void 0) return method.toUpperCase() === "GET";
-  return !API_FIELD.test(segment);
-}
-var FIELD_PROJECTION = /(?:--jq|--json)[= ]\s*('[^']*'|"[^"]*"|\S+)/u;
-var NAMES_THE_BODY = /\bbody\b/u;
-function projects_away_body(segment) {
-  const projection = FIELD_PROJECTION.exec(segment);
-  if (projection === null) return false;
-  return !NAMES_THE_BODY.test(projection[1] ?? "");
-}
-function is_body_read_segment(segment) {
-  if (projects_away_body(segment)) return false;
-  if (ISSUE_VIEW_COMMAND.test(segment)) return true;
-  return GH_API_COMMAND.test(segment) && ISSUE_BODY_PATH.test(segment) && is_api_read(segment);
-}
-function fetches_issue_comments(segment) {
-  if (!FETCHES_COMMENTS.test(segment)) return false;
-  return ISSUE_VIEW_COMMAND.test(segment) || GH_API_COMMAND.test(segment) && ISSUES_PATH.test(segment);
-}
-function is_body_only_issue_read(command) {
-  const segments = shell_segments.segments_of(command);
-  if (segments.some((segment) => fetches_issue_comments(segment))) return false;
-  return segments.some((segment) => is_body_read_segment(segment));
-}
-var ISSUE_COMMENTS_REASON = "\u26D4 an Issue's comments are part of the Issue: read them before implementing, not only the body. A decision recorded after the body was written lives only in a comment \u2014 a corrected diagnosis (joshuafolkken/kit#1537), a changed default and an added acceptance criterion (joshuafolkken/kit#1520), a scope handed to another Issue (joshuafolkken/kit#1304) \u2014 and nothing in the body says it was superseded, so a body-only reader builds the wrong thing and sees no contradiction. Reissue this read with the comments included: `gh api repos/{owner}/{repo}/issues/<N>/comments --jq '.[] | {user: .user.login, created_at, body}'` beside the body read, or `gh issue view <N> --comments` where GraphQL is reachable. Then the later text is the agreement in force \u2014 a comment supersedes the body it contradicts \u2014 except for two answers that are not the run's to make: work a comment reassigns to another Issue is out of scope and is not implemented, and a comment saying the Issue no longer has a reason to exist stops the run with a `confirmation` Telegram. The procedure is `.claude/skills/workflow-commands/SKILL.md` \u2192 \"An Issue's comments are part of the Issue\". It fires once per run and cannot repeat on the call in hand.";
-var { carries_a_body: carries_a_body2, is_shell_evaluated_body: is_shell_evaluated_body2, keeps_body_safe: keeps_body_safe2 } = shell_body_trigger;
-var SHELL_BODY_REASON = "\u26D4 shell-evaluated body: this command carries a body inline in double quotes, and that body contains a backtick or a `$`. The shell evaluates both before the command runs, so the text is executed rather than merely mangled \u2014 joshuafolkken/kit#1198 recorded a PR comment whose own words ran as git commands and switched a lane's work tree onto main. Write the body to a file and pass it by path: `gh api repos/{owner}/{repo}/issues/<N>/comments --field body=@<path>` (a PR comment is an issue comment), `pnpm josh followup --notify-message-file <path>`, `pnpm josh notify --body-file <path>`, and `--body-file <path>` wherever a command offers it. `$'\u2026'` quoting is the other safe form and is unchanged. The rule and what the trigger cannot see are in `prompts/collaboration-workflow/shell-body.md`. Reissue this call once the body is in a file \u2014 it fires once per run and cannot repeat on the call in hand.";
-var ISSUE_LISTING = /^gh\s+(?:-{1,2}[\w-]+(?:[= ]\S+)?\s+)*issue\s+list\b/u;
-var ISSUES_QUERY = /repos\/[^\s'"]*\/issues\?[^\s'"]*state=open/u;
-var OPEN_STATE = /--state[= ]open|state=open/u;
-var LABEL_FILTER = /--label\b|[?&]labels=/u;
-function counts_open_issues(command) {
-  return shell_segments.segments_of(command).some((segment) => {
-    if (LABEL_FILTER.test(segment)) return false;
-    return ISSUE_LISTING.test(segment) && OPEN_STATE.test(segment) || ISSUES_QUERY.test(segment);
-  });
-}
-function reads_issue_comments(command) {
-  return shell_segments.segments_of(command).some((segment) => fetches_issue_comments(segment));
-}
-var ASKS_ABOUT_THE_CUT = on_bash_command(pre_gate_cut.asks_about_the_cut);
-var CLAIMS_THE_HOLD = on_bash_command(pre_gate_cut.claims_the_hold);
-function reaches_the_pre_gate_boundary(call, _turn, run) {
-  if (!ASKS_ABOUT_THE_CUT(call)) return false;
-  return run.some((issued) => CLAIMS_THE_HOLD(issued));
-}
-var DELIVERED_RULES = [
-  {
-    id: "wip-cap",
-    is_trigger: on_bash_command(is_issue_filing),
-    reason: WIP_CAP_REASON,
-    keeps: on_bash_command(counts_open_issues)
-  },
-  {
-    id: "issue-comments",
-    is_trigger: on_bash_command(is_body_only_issue_read),
-    reason: ISSUE_COMMENTS_REASON,
-    already_satisfied: prior_comment_read.already_read_for_call,
-    keeps: on_bash_command(reads_issue_comments)
-  },
-  {
-    id: "shell-body",
-    is_trigger: on_bash_command(is_shell_evaluated_body2),
-    reason: SHELL_BODY_REASON,
-    keeps: on_bash_command(keeps_body_safe2),
-    reaches: on_bash_command(carries_a_body2)
-  },
-  {
-    id: "piped-verification",
-    is_trigger: on_bash_command(piped_verification.is_masked_verification),
-    reason: piped_verification.PIPED_VERIFICATION_REASON,
-    keeps: on_bash_command(piped_verification.keeps_verdict_intact),
-    reaches: on_bash_command(piped_verification.runs_verification)
-  },
-  {
-    id: "early-heartbeat",
-    is_trigger: on_bash_command(early_heartbeat.is_wait_timer),
-    reason: early_heartbeat.EARLY_HEARTBEAT_REASON,
-    decide: early_heartbeat.decide,
-    keeps: on_bash_command(early_heartbeat.is_progress_watch),
-    reaches: on_bash_command(early_heartbeat.waits_for_progress)
-  },
-  // **The one row whose trigger reads a field of the input beside the command**, so it supplies its
-  // own tool-name check rather than going through `on_bash_command`: a push step already issued with
-  // `run_in_background` is the rule obeyed, and refusing it would charge a run for doing the right
-  // thing. It supplies `decide` because a push is a recurring act — one per child in a batch, and a
-  // second inside one `fullrun` when round 2 fixes a finding in place.
-  {
-    id: "run-tail",
-    is_trigger: run_tail.is_foreground_push_step,
-    reason: run_tail.RUN_TAIL_REASON,
-    decide: run_tail.decide,
-    keeps: run_tail.is_backgrounded_push_step,
-    reaches: run_tail.is_push_step_call
-  },
-  // **The one row whose trigger consults the world beside the command**, because "is this a lane that
-  // has not cut" is not readable from the call: it is the working directory's own name and the cut
-  // record on disk. Both reads are synchronous, and the command match runs first, so a run that never
-  // types `pnpm josh gate` pays nothing for it.
-  //
-  // **Once per run rather than `decide`, and the direction of the error is why.** Taking the cut ends
-  // the process, so this is not the recurring act joshuafolkken/kit#1570 wrote `decide` for — and the
-  // five verdicts that legitimately leave a run at the gate (`not-a-lane`, `unready`, `busy`,
-  // `failed`, `unknown`) all need the reissue to go through. A row that refused every time would wedge exactly
-  // those runs; a row that refuses once cannot.
-  //
-  // **`pnpm josh rule:value` read this row with a ceiling of about 50%, and joshuafolkken/kit#1867 is
-  // what removed it** (the ceiling was recorded here by joshuafolkken/kit#1864's review round 2). A
-  // cut relaunches a *new session*, which the measurement groups as a run of its own, and that
-  // resumed run issues the entry check — so scored on the asking alone it joined the denominator
-  // while never being able to satisfy `keeps`, which only the cutting run can, and ten perfectly
-  // obedient children read as ten kept out of twenty. **The two halves are separable, just not from
-  // one call**: both processes issue byte-identical `--resume` strings, but the `fresh` verdict sends
-  // a run on to claim the working-tree hold while the `resume` verdict tells its counterpart to skip
-  // that claim. `reaches_the_pre_gate_boundary` is that conjunction, and it is why `CallTest` is
-  // handed the run's calls beside the turn's rather than a second predicate slot of its own.
-  // Dropping `reaches` altogether is still strictly worse — the trigger evaluates against the
-  // *measuring* process's working directory, so it is always false from the main checkout and the row
-  // would read as no runs at all.
-  //
-  // **It overlaps `piped-verification` on a piped gate call, and the order is safe in both
-  // directions.** `pnpm josh gate | tail` in an uncut lane is a real instance of both defects; the
-  // earlier row speaks, its own reason says to reissue, and this one delivers on the reissue — the
-  // reading "the losing rule's delivery is still correct one call later" that the comment below
-  // requires of any admissible overlap.
-  {
-    id: "pre-gate-cut",
-    is_trigger: on_bash_command(pre_gate_cut.is_uncut_gate),
-    reason: pre_gate_cut.PRE_GATE_CUT_REASON,
-    keeps: on_bash_command(pre_gate_cut.takes_the_cut),
-    reaches: reaches_the_pre_gate_boundary
-  },
-  // **The second row whose trigger consults the world beside the command** (joshuafolkken/kit#2034):
-  // "is this a dispatched lane child" is the dispatch mark against this checkout's own issue, read
-  // synchronously by `lane_child_marker.is_child_of`, and the command match runs first so an ordinary
-  // run pays nothing for it.
-  //
-  // **Once per run rather than `decide`, and no `already_satisfied`.** The stop ends the turn, so it
-  // is not the recurring act joshuafolkken/kit#1570 wrote `decide` for. It carries no
-  // `already_satisfied` because the park it asks for is a GitHub label a synchronous guard cannot
-  // read, and the transcript-tail alternative would read a child that merely *read*
-  // `backlogrun-park.md` — whose prose carries the `labels[]=needs-decision` command — as compliant
-  // and fall silent on a real violation. `lane-park.ts` states why one wasted reissue on the compliant
-  // path is the safe direction. `keeps` reads an actual label-application `Bash` command, never the
-  // tail, so it is not fooled the same way; `reaches` stays `is_trigger`, since a compliant run issues
-  // the same confirmation notify and belongs in the denominator.
-  {
-    id: "lane-park",
-    is_trigger: on_bash_command(lane_park.is_unparked_stop),
-    reason: lane_park.LANE_PARK_REASON,
-    keeps: on_bash_command(lane_park.records_the_park)
-  }
-];
-var ALONE_IN_TURN = 1;
-function batches_the_turn(call, turn) {
-  return time_batch_guard.is_guarded_call(call) && turn.length > ALONE_IN_TURN;
-}
-var BATCHING_RULE = {
-  id: "batching",
-  reason: time_batch_guard.REASON,
-  keeps: batches_the_turn,
-  reaches: time_batch_guard.is_guarded_call
-};
-var INVESTIGATION_RULE = {
-  id: "investigation",
-  reason: investigation_reads.REASON,
-  reaches: investigation_reads.is_refusable_call
-};
-var MEASURED_RULES = [
-  ...DELIVERED_RULES,
-  BATCHING_RULE,
-  INVESTIGATION_RULE
-];
-var BATCH_STAMP = hook_decision.create_refusal_stamp(time_batch_guard.STAMP_PREFIX);
-var BATCH_REFUSAL_WINDOW_MS = 1e4;
-function will_batch_guard_refuse(tail, call, run) {
-  const refused_at_ms = BATCH_STAMP.last_ms(BATCH_STAMP.path(run.transcript));
-  if (run.now_ms - refused_at_ms < BATCH_REFUSAL_WINDOW_MS) return true;
-  return time_batch_guard.should_block(tail, call, refused_at_ms);
-}
-function is_first_delivery(tail, call, delivered_at_ms, run) {
-  if (delivered_at_ms !== hook_decision.NEVER_MS) return false;
-  return !will_batch_guard_refuse(tail, call, run);
-}
-function delivery_decision(rule) {
-  const { decide: decide4, already_satisfied } = rule;
-  if (decide4 === void 0 && already_satisfied === void 0) return is_first_delivery;
-  return function should_block(tail, call, delivered_at_ms, run) {
-    if (already_satisfied?.(tail, call) === true) return false;
-    if (decide4 === void 0) return is_first_delivery(tail, call, delivered_at_ms, run);
-    return decide4(call, run, !will_batch_guard_refuse(tail, call, run));
-  };
-}
-function guard_of(rule) {
-  return hook_decision.create_transcript_guard({
-    prefix: `${STAMP_PREFIX}${rule.id}-`,
-    switch_key: SWITCH_ENV_KEY,
-    is_candidate: rule.is_trigger,
-    should_block: delivery_decision(rule),
-    reason: rule.reason
-  });
-}
-var GUARDS = new Map(DELIVERED_RULES.map((rule) => [rule.id, guard_of(rule)]));
-function delivery_path(rule_id, transcript_path) {
-  const guard = GUARDS.get(rule_id);
-  return guard === void 0 ? "" : guard.refusal_path(transcript_path);
-}
-function delivery(raw_payload, now_ms = Date.now()) {
-  for (const guard of GUARDS.values()) {
-    const reason = guard.refusal(raw_payload, now_ms);
-    if (reason !== void 0) return reason;
-  }
-  return void 0;
-}
-function is_enabled() {
-  return hook_decision.is_switch_enabled(SWITCH_ENV_KEY);
-}
-var delivered_rules = {
-  DELIVERED_RULES,
-  EARLY_HEARTBEAT_REASON: early_heartbeat.EARLY_HEARTBEAT_REASON,
-  ISSUE_COMMENTS_REASON,
-  LANE_PARK_REASON: lane_park.LANE_PARK_REASON,
-  MEASURED_RULES,
-  PIPED_VERIFICATION_REASON: piped_verification.PIPED_VERIFICATION_REASON,
-  PRE_GATE_CUT_REASON: pre_gate_cut.PRE_GATE_CUT_REASON,
-  RUN_TAIL_REASON: run_tail.RUN_TAIL_REASON,
-  SHELL_BODY_REASON,
-  SWITCH_ENV_KEY,
-  WIP_CAP_REASON,
-  delivery,
-  delivery_path,
-  is_body_only_issue_read,
-  is_enabled,
-  is_issue_filing,
-  is_masked_verification: piped_verification.is_masked_verification,
-  is_wait_timer: early_heartbeat.is_wait_timer
-};
-
-// scripts/hooks/pretool-guard.ts
-function combine_outcomes(batch, extra_reason) {
-  if (batch.reason !== void 0) return batch;
-  if (extra_reason !== void 0) {
-    return { reason: extra_reason, notice: void 0, fault: void 0 };
-  }
-  return batch;
-}
-function pretool_outcome(raw_payload) {
-  const batch = batch_outcome(raw_payload);
-  const investigation = investigation_refusal(raw_payload);
-  const rule = delivered_rules.delivery(raw_payload);
-  return combine_outcomes(batch, investigation ?? rule);
-}
-var pretool_guard = { combine_outcomes, pretool_outcome };
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  if (process.stdin.isTTY) hook_decision.report_no_payload("pretool:guard");
-  else hook_decision.write_outcome(await text(process.stdin), pretool_outcome);
-}
-
-export {
-  pretool_outcome,
-  pretool_guard
-};