@joshuafolkken/kit 1.2116.0 → 1.3000.0

package/dist/hooks/chunk-NUPVO7RI.js

@@ -0,0 +1,3054 @@
+import {
+  error_text,
+  repo_discovery,
+  repo_origin
+} from "./chunk-LRD2ERRI.js";
+import {
+  agent_provider,
+  durable_state,
+  file_reader,
+  issue_number_shape,
+  lane_ledger_write,
+  process_identity,
+  run_carry
+} from "./chunk-FOW4B7OQ.js";
+import {
+  MS_PER_MINUTE,
+  PROBE_TIMEOUT_MS,
+  durable_state_root,
+  external_exports,
+  git_command,
+  git_common_directory,
+  git_diff_reads,
+  git_spawn,
+  json_value,
+  stamp_file
+} from "./chunk-CY3ADSDR.js";
+
+// scripts/time-runtime/transcript-tail.ts
+import { closeSync, fstatSync, openSync, readSync } from "node:fs";
+var TAIL_BYTES = 262144;
+var FILE_START = 0;
+function read_tail(file_path, max_bytes = TAIL_BYTES) {
+  const descriptor = openSync(file_path, "r");
+  try {
+    const { size } = fstatSync(descriptor);
+    const length = Math.min(size, max_bytes);
+    const buffer = Buffer.alloc(length);
+    const read3 = readSync(descriptor, buffer, FILE_START, length, size - length);
+    return buffer.subarray(FILE_START, read3).toString("utf8");
+  } finally {
+    closeSync(descriptor);
+  }
+}
+var transcript_tail = { TAIL_BYTES, read_tail };
+
+// scripts/josh/josh-environment-file.ts
+import { readFileSync } from "node:fs";
+import { parseEnv } from "node:util";
+
+// ports/index.js
+import { existsSync } from "node:fs";
+import path from "node:path";
+var PORT_SEED_KEY = "PORT_SEED";
+var LANE_SEAT_KEY = "JOSH_LANE_SEAT";
+var ENV_FILE_NAME = ".env";
+var PACKAGE_FILE_NAME = "package.json";
+var PROJECT_ENVIRONMENT_KEYS = /* @__PURE__ */ new Set([PORT_SEED_KEY, LANE_SEAT_KEY, "PLAYWRIGHT_REUSE_SERVER"]);
+var DEV_PORT_BASE = 5173;
+var PREVIEW_PORT_BASE = 4173;
+var MIN_SEED = 0;
+var SEED_LANE_MULTIPLIER = 10;
+var MAX_LANE = 9;
+var MAX_SEED = 99;
+var INTEGER_PATTERN = /^\d+$/u;
+function fail_invalid(key, raw, max) {
+  throw new Error(
+    `${key} must be an integer between ${MIN_SEED} and ${max}, got ${JSON.stringify(raw)}. Unset it to use the default ports (dev ${DEV_PORT_BASE}, preview ${PREVIEW_PORT_BASE}).`
+  );
+}
+function read_trimmed(environment, key) {
+  const raw = environment[key];
+  return raw === void 0 ? "" : raw.trim();
+}
+function resolve_bounded(environment, key, max) {
+  const trimmed = read_trimmed(environment, key);
+  if (trimmed.length === 0) return MIN_SEED;
+  if (!INTEGER_PATTERN.test(trimmed)) fail_invalid(key, trimmed, max);
+  const value = Number(trimmed);
+  if (value > max) fail_invalid(key, trimmed, max);
+  return value;
+}
+function resolve_seed(environment = process.env) {
+  return resolve_bounded(environment, PORT_SEED_KEY, MAX_SEED);
+}
+function resolve_lane(environment = process.env) {
+  return resolve_bounded(environment, LANE_SEAT_KEY, MAX_LANE);
+}
+function resolve_offset(environment = process.env) {
+  return resolve_seed(environment) * SEED_LANE_MULTIPLIER + resolve_lane(environment);
+}
+function offset_from(base, environment) {
+  return base + resolve_offset(environment);
+}
+function resolve_development_port(environment = process.env) {
+  return offset_from(DEV_PORT_BASE, environment);
+}
+function resolve_preview_port(environment = process.env) {
+  return offset_from(PREVIEW_PORT_BASE, environment);
+}
+function resolve_project_directory(directory) {
+  const start = path.resolve(directory);
+  let current = start;
+  while (!existsSync(path.join(current, PACKAGE_FILE_NAME))) {
+    const parent = path.dirname(current);
+    if (parent === current) return start;
+    current = parent;
+  }
+  return current;
+}
+function discard_loaded_keys(snapshot) {
+  for (const key of Object.keys(process.env)) {
+    if (!PROJECT_ENVIRONMENT_KEYS.has(key) && !Object.hasOwn(snapshot, key)) {
+      Reflect.deleteProperty(process.env, key);
+    }
+  }
+}
+function load_environment_file(directory = process.cwd()) {
+  const file = path.join(resolve_project_directory(directory), ENV_FILE_NAME);
+  if (!existsSync(file)) return false;
+  const snapshot = { ...process.env };
+  process.loadEnvFile(file);
+  discard_loaded_keys(snapshot);
+  return true;
+}
+var ports = {
+  load_environment_file,
+  resolve_project_directory,
+  resolve_seed,
+  resolve_lane,
+  resolve_development_port,
+  resolve_preview_port
+};
+
+// scripts/josh/josh-command-types.ts
+var OPTIONAL_ENV_FILE_FLAGS = [`--env-file-if-exists=${ENV_FILE_NAME}`];
+var GATE_COMMAND = "gate";
+var ESLINT_CACHE_FILE = ".eslintcache";
+var TS_BUILD_INFO_FILE = ".tsbuildinfo";
+var CSPELL_CACHE_FILE = ".cspellcache";
+var ESLINT_EDIT_CACHE_FILE = ".eslintcache.edit";
+var ESLINT_RELATED_CACHE_FILE = ".eslintcache.related";
+var PRETTIER_CACHE_FILE = ".prettiercache";
+var PRETTIER_RELATED_CACHE_FILE = ".prettiercache.related";
+var CSPELL_COMMIT_CACHE_FILE = ".cspellcache.commit";
+var ESLINT_COMMIT_CACHE_FILE = ".eslintcache.commit";
+var ROOTED_JSON_PORTABILITY = "rooted-json";
+var ESLINT_CACHE_SPEC = {
+  cache_file: ESLINT_CACHE_FILE,
+  portability: ROOTED_JSON_PORTABILITY
+};
+var TS_CACHE_SPEC = {
+  cache_file: TS_BUILD_INFO_FILE,
+  portability: "raw"
+};
+var CSPELL_CACHE_SPEC = {
+  cache_file: CSPELL_CACHE_FILE,
+  portability: "raw"
+};
+var GATE_CACHE_SPECS = [
+  ESLINT_CACHE_SPEC,
+  TS_CACHE_SPEC,
+  CSPELL_CACHE_SPEC
+];
+var GATE_CACHE_FILES = GATE_CACHE_SPECS.map((spec) => spec.cache_file);
+var IGNORED_CACHE_FILES = [
+  ...GATE_CACHE_FILES,
+  ESLINT_EDIT_CACHE_FILE,
+  ESLINT_RELATED_CACHE_FILE,
+  PRETTIER_CACHE_FILE,
+  PRETTIER_RELATED_CACHE_FILE,
+  CSPELL_COMMIT_CACHE_FILE,
+  ESLINT_COMMIT_CACHE_FILE
+];
+var CONTENT_CACHE_FLAGS = ["--cache", "--cache-strategy", "content"];
+var CACHE_LOCATION_FLAG = "--cache-location";
+function content_cache_flags(cache_file) {
+  return [...CONTENT_CACHE_FLAGS, CACHE_LOCATION_FLAG, cache_file];
+}
+var ESLINT_CACHE_FLAGS = content_cache_flags(ESLINT_CACHE_FILE);
+var ESLINT_EDIT_CACHE_FLAGS = content_cache_flags(ESLINT_EDIT_CACHE_FILE);
+var ESLINT_RELATED_CACHE_FLAGS = content_cache_flags(ESLINT_RELATED_CACHE_FILE);
+var CSPELL_CACHE_FLAGS = content_cache_flags(CSPELL_CACHE_FILE);
+var PRETTIER_CACHE_FLAGS = content_cache_flags(PRETTIER_CACHE_FILE);
+var PRETTIER_RELATED_CACHE_FLAGS = content_cache_flags(PRETTIER_RELATED_CACHE_FILE);
+var CSPELL_COMMIT_CACHE_FLAGS = content_cache_flags(CSPELL_COMMIT_CACHE_FILE);
+var ESLINT_COMMIT_CACHE_FLAGS = content_cache_flags(ESLINT_COMMIT_CACHE_FILE);
+var LINT_RULE_DIRECTORY = "node_modules/.cache/josh/lint-rule";
+var LINT_RULE_CACHE_FILE = `${LINT_RULE_DIRECTORY}/.eslintcache`;
+var LINT_RULE_CACHE_FLAGS = content_cache_flags(LINT_RULE_CACHE_FILE);
+var LINT_RULE_PATHS_CACHE_FILE = `${LINT_RULE_DIRECTORY}/.eslintcache-paths`;
+var LINT_RULE_PATHS_CACHE_FLAGS = content_cache_flags(LINT_RULE_PATHS_CACHE_FILE);
+var LINT_RULE_WORKERS = 2;
+
+// scripts/josh/josh-environment-file.ts
+var LAUNCH_ONLY_KEY = /^JOSH_(?:\w+_GUARD|\w+_FORCE|SCOPED_GREEN)$/u;
+function is_launch_only_key(key) {
+  return LAUNCH_ONLY_KEY.test(key);
+}
+function read_environment_file() {
+  try {
+    return readFileSync(ENV_FILE_NAME, "utf8");
+  } catch {
+    return "";
+  }
+}
+function load_environment_file2() {
+  const entries = Object.entries(parseEnv(read_environment_file()));
+  for (const [key, value] of entries) {
+    if (!is_launch_only_key(key) && process.env[key] === void 0) process.env[key] = value;
+  }
+}
+function apply_node_flags(flags) {
+  const [environment_flag] = OPTIONAL_ENV_FILE_FLAGS;
+  if (!flags.includes(environment_flag ?? "")) return flags;
+  load_environment_file2();
+  return flags.filter((flag) => flag !== environment_flag);
+}
+var josh_environment_file = {
+  apply_node_flags,
+  is_launch_only_key,
+  load_environment_file: load_environment_file2
+};
+
+// scripts/josh/session-language.ts
+var ENV_KEY = "JOSH_SESSION_LANG";
+var DEFAULT_SESSION_LANG = "ja";
+function resolve_session_lang() {
+  const value = process.env[ENV_KEY]?.trim();
+  if (value) return { lang: value, is_default: false };
+  return { lang: DEFAULT_SESSION_LANG, is_default: true };
+}
+function is_japanese(lang) {
+  return lang.toLowerCase().startsWith(DEFAULT_SESSION_LANG);
+}
+var session_language = { DEFAULT_SESSION_LANG, ENV_KEY, resolve_session_lang, is_japanese };
+
+// scripts/issue/issue-cite.ts
+var GITHUB_URL_PREFIX = "https://github.com/";
+var ISSUE_PATH = "/issues/";
+var SUMMARY_SEPARATOR = " \u2014 ";
+var REPO_QUALIFIED = /^([^\s/#]+\/[^\s/#]+)#(\d+)$/u;
+var BARE_NUMBER = /^#?(\d+)$/u;
+function plain(number, repo = "") {
+  return `${repo}#${String(number)}`;
+}
+function plain_for(_reason, number, repo = "") {
+  return plain(number, repo);
+}
+function issue_url(slug, number) {
+  return `${GITHUB_URL_PREFIX}${slug}${ISSUE_PATH}${number}`;
+}
+function citation_line(slug, number, summary) {
+  return `[${plain(number)}](${issue_url(slug, number)})${SUMMARY_SEPARATOR}${summary}`;
+}
+function reference(slug, number, title) {
+  if (slug === void 0) return plain(number);
+  return title === void 0 ? `[${plain(number)}](${issue_url(slug, number)})` : citation_line(slug, number, title);
+}
+function citer(slug, titles) {
+  return function cite(number) {
+    return reference(slug, number, titles.get(number));
+  };
+}
+function qualified_target(token) {
+  const match = REPO_QUALIFIED.exec(token);
+  if (match === null) return void 0;
+  const [, repo = "", number = ""] = match;
+  return { number, repo };
+}
+function bare_target(token, default_repo) {
+  const match = BARE_NUMBER.exec(token);
+  if (match === null) return void 0;
+  const [, number = ""] = match;
+  return { number, repo: default_repo };
+}
+function parse_target(token, default_repo) {
+  return qualified_target(token) ?? bare_target(token, default_repo);
+}
+function label(target2) {
+  return plain(target2.number, target2.repo);
+}
+function missing_line(target2) {
+  return `\u2716 ${label(target2)}: issue does not resolve \u2014 check the number and the repository`;
+}
+function unreadable_line(target2) {
+  return `\u2716 ${label(target2)}: could not be read \u2014 a rate limit, expired auth, or a dropped connection`;
+}
+function no_repo_line(target2) {
+  return `\u2716 ${label(target2)}: could not read this repository \u2014 check gh auth and the origin remote`;
+}
+var issue_cite = {
+  citation_line,
+  citer,
+  issue_url,
+  missing_line,
+  no_repo_line,
+  parse_target,
+  plain_for,
+  reference,
+  unreadable_line
+};
+
+// scripts/run/ship/run-ship-stage.ts
+var STAGE = {
+  PREFLIGHT: "preflight",
+  REVIEW: "review",
+  GATE: "gate",
+  SYNC: "sync",
+  COMMIT: "commit",
+  ROUND_TWO: "round-2",
+  FOLLOWUP: "followup",
+  REPORT: "report"
+};
+var PHASE = {
+  START: "start",
+  DONE: "done",
+  FAILED: "failed",
+  SKIPPED: "skipped"
+};
+var RECORD_PREFIX = "josh-ship-stages-";
+var RECORD_SEPARATOR = "-";
+var SKIP_COMMIT_FLAG = "--skip-commit";
+var SKIP_PUSH_FLAG = "--skip-push";
+var WORD_SEPARATOR = " ";
+var STARTED_SEPARATOR = ",";
+var STARTED_INDEX = 3;
+var WORD_COUNT = STARTED_INDEX + 1;
+var REASON_SEPARATOR = " | ";
+var record_schema = external_exports.object({
+  done: external_exports.array(external_exports.string()),
+  started: external_exports.array(external_exports.string()).default([]),
+  is_merge_waiting: external_exports.boolean().default(false),
+  is_place_waiting: external_exports.boolean().default(false)
+});
+var EMPTY_RECORD = {
+  done: [],
+  started: [],
+  is_merge_waiting: false,
+  is_place_waiting: false
+};
+function record_path(repository, issue2) {
+  return stamp_file.stamp_path(`${RECORD_PREFIX}${issue2}${RECORD_SEPARATOR}`, repository);
+}
+function parse_record(raw) {
+  return json_value.parse_with(raw, record_schema) ?? EMPTY_RECORD;
+}
+function read_record(target2) {
+  const raw = stamp_file.read_stamp_text(target2);
+  return raw === void 0 ? EMPTY_RECORD : parse_record(raw);
+}
+function read_done(target2) {
+  return new Set(read_record(target2).done);
+}
+function mark_done(target2, stage) {
+  const record2 = read_record(target2);
+  stamp_file.replace_stamp(target2, { ...record2, done: [.../* @__PURE__ */ new Set([...record2.done, stage])] });
+}
+function read_started(target2) {
+  return read_record(target2).started;
+}
+function mark_started(target2, stage) {
+  const record2 = read_record(target2);
+  stamp_file.replace_stamp(target2, { ...record2, started: [.../* @__PURE__ */ new Set([...record2.started, stage])] });
+}
+function end_attempt(target2) {
+  stamp_file.replace_stamp(target2, { ...read_record(target2), started: [], is_merge_waiting: false });
+}
+function read_merge_waiting(target2) {
+  return read_record(target2).is_merge_waiting;
+}
+function mark_merge_waiting(target2, is_merge_waiting) {
+  stamp_file.replace_stamp(target2, { ...read_record(target2), is_merge_waiting });
+}
+function read_place_waiting(target2) {
+  return read_record(target2).is_place_waiting;
+}
+function mark_place_waiting(target2, is_place_waiting) {
+  stamp_file.replace_stamp(target2, { ...read_record(target2), is_place_waiting });
+}
+function clear_waits(target2) {
+  stamp_file.replace_stamp(target2, {
+    ...read_record(target2),
+    is_merge_waiting: false,
+    is_place_waiting: false
+  });
+}
+function clear(target2) {
+  stamp_file.remove_stamp(target2);
+}
+function is_shipped(state) {
+  return state.is_committed && state.is_pushed;
+}
+var DONE_BY = {
+  // The preflight asks what the commit stage would refuse on, so a commit is
+  // its output; a resumed commit stage still asks `git -y`'s own preflight.
+  [STAGE.PREFLIGHT]: (done, state) => state.is_merged || done.has(STAGE.PREFLIGHT) && state.is_committed,
+  // The sync stage commits locally before the review round and the gate, without pushing
+  // (`run-ship-sync.ts`), so a commit is neither's output: a pushed one on a clean tree is, as only the
+  // commit stage after the gate pushes — unless the issue changed since.
+  [STAGE.REVIEW]: (done, state) => state.is_merged || done.has(STAGE.REVIEW) && is_shipped(state) && state.is_review_stale !== true,
+  [STAGE.GATE]: (done, state) => state.is_merged || done.has(STAGE.GATE) && is_shipped(state),
+  // The merge of the default branch before the gate: once pushed, a default branch that
+  // moved is the followup's to merge again.
+  [STAGE.SYNC]: (done, state) => state.is_merged || done.has(STAGE.SYNC) && is_shipped(state),
+  [STAGE.COMMIT]: (done, state) => state.is_merged || done.has(STAGE.COMMIT) && is_shipped(state),
+  // The final review precedes the push. Its own tree stamp decides reuse after a stop.
+  [STAGE.ROUND_TWO]: (_done, state) => state.is_merged,
+  // A recorded followup still needs the shipped state: a record left by a merged ship whose report
+  // failed must not pass over the followup of new, not-yet-pushed work on the same issue.
+  [STAGE.FOLLOWUP]: (done, state) => state.is_merged || done.has(STAGE.FOLLOWUP) && is_shipped(state),
+  [STAGE.REPORT]: (done) => done.has(STAGE.REPORT)
+};
+function is_done(stage, done, state, has_body = false) {
+  if (has_body && stage === STAGE.COMMIT && !state.is_merged) return false;
+  return DONE_BY[stage](done, state);
+}
+function commit_flags(state) {
+  if (!state.is_committed) return [];
+  return state.is_pushed ? [SKIP_COMMIT_FLAG, SKIP_PUSH_FLAG] : [SKIP_COMMIT_FLAG];
+}
+function event_text(issue2, stage, phase, started = []) {
+  const words = [issue_cite.plain_for("program", issue2), stage, phase];
+  const listed = [...new Set(started)].join(STARTED_SEPARATOR);
+  const full = started.length > 0 ? [...words, listed] : words;
+  return full.join(WORD_SEPARATOR);
+}
+function with_reason(text2, reason) {
+  return reason === void 0 ? text2 : `${text2}${REASON_SEPARATOR}${reason}`;
+}
+function words_part(text2) {
+  return text2.split(REASON_SEPARATOR, 1)[0] ?? "";
+}
+function started_of(text2) {
+  return words_part(text2).split(WORD_SEPARATOR, WORD_COUNT)[STARTED_INDEX]?.split(STARTED_SEPARATOR);
+}
+function words_of(text2) {
+  const [, stage = "", phase = ""] = words_part(text2).split(WORD_SEPARATOR, WORD_COUNT);
+  return { stage, phase };
+}
+function reason_of(text2) {
+  const at = text2.indexOf(REASON_SEPARATOR);
+  return at === -1 ? void 0 : text2.slice(at + REASON_SEPARATOR.length);
+}
+var CONFLICT = "conflict";
+function stop_reason(stage, conflicts = []) {
+  return conflicts.length > 0 ? CONFLICT : stage;
+}
+var run_ship_stage = {
+  CONFLICT,
+  PHASE,
+  STAGE,
+  clear,
+  clear_waits,
+  commit_flags,
+  end_attempt,
+  event_text,
+  is_done,
+  is_shipped,
+  mark_done,
+  mark_merge_waiting,
+  mark_place_waiting,
+  mark_started,
+  read_done,
+  read_merge_waiting,
+  read_place_waiting,
+  read_started,
+  reason_of,
+  record_path,
+  started_of,
+  with_reason,
+  words_of,
+  stop_reason
+};
+
+// scripts/agent/agent-safe-text.ts
+var FIRST_PRINTABLE_CODE = 32;
+var DELETE_CODE = 127;
+var FIRST_CODE_POINT = 0;
+var EMPTY_LENGTH = 0;
+var MAX_VALUE_LENGTH = 4096;
+var MAX_PROMPT_LENGTH = 65536;
+var LINE_FEED = "\n";
+var SPACE = " ";
+function is_control_character(character) {
+  const code = character.codePointAt(FIRST_CODE_POINT) ?? FIRST_PRINTABLE_CODE;
+  return code < FIRST_PRINTABLE_CODE || code === DELETE_CODE;
+}
+function is_line_feed(character) {
+  return character === LINE_FEED;
+}
+function is_never_allowed() {
+  return false;
+}
+function is_refused(character, is_allowed2) {
+  return is_control_character(character) && !is_allowed2(character);
+}
+function is_safe_text(value, is_allowed2, max_length) {
+  if (value.length === EMPTY_LENGTH || value.length > max_length) return false;
+  for (const character of value) if (is_refused(character, is_allowed2)) return false;
+  return true;
+}
+function is_safe_value(value) {
+  return is_safe_text(value, is_never_allowed, MAX_VALUE_LENGTH);
+}
+function is_safe_prompt(value) {
+  return is_safe_text(value, is_line_feed, MAX_PROMPT_LENGTH);
+}
+function printable_character(character) {
+  return is_refused(character, is_line_feed) ? SPACE : character;
+}
+function printable(text2) {
+  return Array.from(text2, printable_character).join("");
+}
+var agent_safe_text = {
+  MAX_PROMPT_LENGTH,
+  MAX_VALUE_LENGTH,
+  is_safe_prompt,
+  is_safe_value,
+  printable
+};
+
+// scripts/lib/shell-quote.ts
+var QUOTE = "'";
+var ESCAPED_QUOTE = String.raw`'\''`;
+function single_quoted(text2) {
+  return QUOTE + text2.split(QUOTE).join(ESCAPED_QUOTE) + QUOTE;
+}
+var BARE_WORD = /^[\w%+,./:=@-]+$/u;
+function word(token) {
+  return BARE_WORD.test(token) ? token : single_quoted(token);
+}
+var shell_quote = { single_quoted, word };
+
+// scripts/run/ship/run-ship-next.ts
+var { STAGE: STAGE2 } = run_ship_stage;
+var COMMAND = {
+  LOG: "pnpm josh ship --log",
+  DETACH: "pnpm josh ship --detach",
+  DETACH_REVIEW: "pnpm josh ship --detach --review"
+};
+function resume_of(args) {
+  const cites = args.cites.flatMap((cite) => ["--cite", cite]);
+  return {
+    title: args.title,
+    flags: [...args.notify, ...args.body, ...cites],
+    is_review: args.is_review,
+    unpinned_ok: args.unpinned_ok
+  };
+}
+function ship_command(command, resume, review_flags = []) {
+  const words = [...review_flags, ...resume.flags, resume.title].map(
+    (token) => shell_quote.word(token)
+  );
+  return [command, ...words].join(" ");
+}
+function review_command(resume) {
+  return ship_command(COMMAND.DETACH_REVIEW, resume, resume.unpinned_ok);
+}
+function detach_again(resume) {
+  return `leave the fix uncommitted and run \`${ship_command(COMMAND.DETACH, resume)}\`.`;
+}
+function detach_as_started(resume) {
+  const command = resume.is_review ? review_command(resume) : ship_command(COMMAND.DETACH, resume);
+  return `leave the fix uncommitted and run \`${command}\`.`;
+}
+var AFTER_FIX = {
+  [STAGE2.PREFLIGHT]: detach_as_started,
+  [STAGE2.REVIEW]: detach_as_started,
+  [STAGE2.GATE]: detach_as_started,
+  [STAGE2.SYNC]: detach_as_started,
+  [STAGE2.COMMIT]: detach_as_started,
+  [STAGE2.ROUND_TWO]: detach_again,
+  [STAGE2.FOLLOWUP]: detach_again,
+  [STAGE2.REPORT]: detach_again
+};
+function detach_review_again(resume) {
+  return `leave the fix uncommitted and run \`${review_command(resume)}\` \u2014 the review read the issue before its update, so the supervisor reviews round 1 again.`;
+}
+function after_fix(stage, resume) {
+  return resume.is_review_stale === true ? detach_review_again(resume) : AFTER_FIX[stage](resume);
+}
+function conflict_step(conflicts) {
+  return `Resolve the conflict with origin/main in ${conflicts.join(", ")} (the merge is left in progress: remove the conflict markers in those files), then`;
+}
+function fix_step(issue2, stage, is_excerpted) {
+  if (is_excerpted) return `Fix the ${stage} failure shown in the output below`;
+  return `Read the stopped report with \`${COMMAND.LOG} ${issue2}\`, fix the ${stage} failure`;
+}
+function next_step(issue2, stage, resume, is_excerpted = false) {
+  const conflicts = resume.conflicts ?? [];
+  if (conflicts.length > 0) return `${conflict_step(conflicts)} ${after_fix(stage, resume)}`;
+  return `${fix_step(issue2, stage, is_excerpted)}, then ${after_fix(stage, resume)}`;
+}
+var run_ship_next = { COMMAND, next_step, resume_of };
+
+// scripts/run/ship/run-ship-stop-context.ts
+import { stripVTControlCharacters } from "node:util";
+
+// scripts/git/change-base.ts
+async function resolved() {
+  try {
+    return await git_command.change_base_commit();
+  } catch {
+    return void 0;
+  }
+}
+async function incoming_base() {
+  try {
+    const reference2 = await git_command.default_branch_reference();
+    return await git_spawn.read([...git_diff_reads.incoming_base_arguments(reference2)]);
+  } catch {
+    return void 0;
+  }
+}
+async function later_of(base, incoming) {
+  const kept = await git_spawn.read([...git_diff_reads.later_base_arguments(base, incoming)]);
+  return git_diff_reads.later_base_of(kept, base);
+}
+async function resolved_through_merge() {
+  const [base, incoming] = await Promise.all([resolved(), incoming_base()]);
+  if (base === void 0 || incoming === void 0) return base;
+  return await later_of(base, incoming);
+}
+var change_base = { resolved, resolved_through_merge };
+
+// scripts/git/changed-paths.ts
+function to_paths(raw) {
+  return raw.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+}
+async function tracked_names() {
+  const base = await change_base.resolved_through_merge();
+  if (base === void 0) {
+    return { tracked: to_paths(await git_command.diff_main_names()), base: "fallback" };
+  }
+  return { tracked: to_paths(await git_command.diff_names_since(base)), base: "merge_base" };
+}
+async function read_changed_parts() {
+  const { tracked, base } = await tracked_names();
+  const untracked = to_paths(await git_command.untracked_names());
+  return { tracked, untracked, base };
+}
+async function read_changed_paths(is_staged) {
+  if (is_staged) return to_paths(await git_command.diff_cached_names());
+  const { tracked, untracked } = await read_changed_parts();
+  return [...tracked, ...untracked];
+}
+async function read_changed_since(commit) {
+  const tracked = to_paths(await git_command.diff_names_since(commit));
+  const untracked = to_paths(await git_command.untracked_names());
+  return [.../* @__PURE__ */ new Set([...tracked, ...untracked])];
+}
+async function read_held_at(commit, paths) {
+  if (paths.length === 0) return [];
+  return to_paths(await git_command.tree_names_at(commit, paths));
+}
+var changed_paths = {
+  read_changed_parts,
+  read_changed_paths,
+  read_changed_since,
+  read_held_at,
+  to_paths
+};
+
+// scripts/review/review-stop-log.ts
+import { mkdirSync } from "node:fs";
+import path2 from "node:path";
+var LOG_FILE = "review-stops.jsonl";
+var LINE_SEPARATOR = "\n";
+var stop_line_schema = external_exports.object({
+  at: external_exports.string(),
+  issue: external_exports.number(),
+  stage: external_exports.string(),
+  kind: external_exports.string(),
+  location: external_exports.string(),
+  sentence: external_exports.string(),
+  fixed: external_exports.boolean().optional()
+});
+function target() {
+  if (process.env["VITEST"] !== void 0) return void 0;
+  const common = git_common_directory.repository();
+  return common === void 0 ? void 0 : path2.join(common, git_common_directory.STATE_DIRECTORY, LOG_FILE);
+}
+function write(destination, stop) {
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const mark = stop.is_fixed === true ? { fixed: true } : {};
+  mkdirSync(path2.dirname(destination), { recursive: true });
+  for (const finding of stop.findings) {
+    lane_ledger_write.append(destination, {
+      at,
+      issue: stop.issue,
+      stage: stop.stage,
+      ...finding,
+      ...mark
+    });
+  }
+}
+function record(stop, log_path = target()) {
+  if (log_path === void 0 || stop.findings.length === 0) return;
+  try {
+    write(log_path, stop);
+  } catch {
+  }
+}
+function parse_line(line) {
+  return stop_line_schema.safeParse(json_value.parse_or_undefined(line)).data;
+}
+function is_present(line) {
+  return line !== void 0;
+}
+function read(log_path = target()) {
+  const raw = log_path === void 0 ? void 0 : stamp_file.read_stamp_text(log_path);
+  if (raw === void 0) return [];
+  return raw.split(LINE_SEPARATOR).map((line) => parse_line(line.trim())).filter(is_present);
+}
+var review_stop_log = { read, record, target };
+
+// scripts/review/review-prior-findings.ts
+var PRIOR_LIMIT = 5;
+var ENTRY_LENGTH_LIMIT = 400;
+var LINE_SUFFIX = /:\d.*$/u;
+var KEY_SEPARATOR = " \u2014 ";
+var LINE_BREAKS = /[\n\r]+/gu;
+function file_of(location) {
+  return location.replace(LINE_SUFFIX, "");
+}
+function key_of(finding) {
+  return `${finding.location}${KEY_SEPARATOR}${finding.sentence}`;
+}
+function entry_text(line) {
+  const disposition = line.fixed === true ? "fixed in place" : "stopped";
+  const text2 = `${key_of(line)} (${line.kind}, ${disposition} in the ${line.stage} stage)`;
+  return agent_safe_text.printable(text2.replaceAll(LINE_BREAKS, " ")).slice(0, ENTRY_LENGTH_LIMIT);
+}
+function latest(issue2, is_kept, log_path) {
+  return review_stop_log.read(log_path).filter((line) => String(line.issue) === issue2 && is_kept(line)).slice(-PRIOR_LIMIT).map((line) => entry_text(line));
+}
+function on_files(issue2, current, log_path) {
+  const files = new Set(current.map((finding) => file_of(finding.location)));
+  const own = new Set(current.map((finding) => key_of(finding)));
+  return latest(
+    issue2,
+    (line) => files.has(file_of(line.location)) && !own.has(key_of(line)),
+    log_path
+  );
+}
+function fix_lines(entries) {
+  if (entries === void 0 || entries.length === 0) return [];
+  return [
+    "Earlier review findings on the same files in this lane \u2014 confirm the fix still meets each before shipping again:",
+    ...entries.map((entry) => `- ${entry}`)
+  ];
+}
+function prompt_clauses(issue2, log_path) {
+  const entries = latest(issue2, () => true, log_path);
+  if (entries.length === 0) return [];
+  return [
+    `Earlier review rounds in this lane recorded these findings: ${entries.join("; ")}.`,
+    "Check that the change still meets each of them, and report a change that breaks one as a finding."
+  ];
+}
+var review_prior_findings = {
+  ENTRY_LENGTH_LIMIT,
+  PRIOR_LIMIT,
+  fix_lines,
+  latest,
+  on_files,
+  prompt_clauses
+};
+
+// scripts/run/ship/run-ship-stop-context.ts
+var EXCERPT_LINE_LIMIT = 40;
+var EXCERPT_LINE_WIDTH = 240;
+var CHANGED_PATH_LIMIT = 30;
+var OUTPUT_PREFIX = "josh-ship-stop-";
+var OUTPUT_SUFFIX = ".log";
+var KEY_SEPARATOR2 = "-";
+var LINE_BREAK = "\n";
+var CARRIAGE_RETURN = "\r";
+var omitted_schema = external_exports.object({ path: external_exports.string().optional(), last_line: external_exports.number().int() }).strict();
+var stop_context_schema = external_exports.object({
+  excerpt: external_exports.array(external_exports.string()).readonly(),
+  omitted: omitted_schema.optional(),
+  changed: external_exports.array(external_exports.string()).readonly().optional(),
+  more_changed: external_exports.number().int(),
+  prior: external_exports.array(external_exports.string()).readonly().optional()
+}).strict();
+function shown_frame(line) {
+  return line.trimEnd().split(CARRIAGE_RETURN).at(-1) ?? "";
+}
+function output_lines(output) {
+  return stripVTControlCharacters(output).trimEnd().split(LINE_BREAK).map((line) => agent_safe_text.printable(shown_frame(line)));
+}
+async function keep_full_output(issue2, output) {
+  const repository = await git_common_directory.read_repository();
+  if (repository === void 0) return void 0;
+  const target2 = stamp_file.stamp_path(
+    `${OUTPUT_PREFIX}${issue2}${KEY_SEPARATOR2}`,
+    repository,
+    OUTPUT_SUFFIX
+  );
+  try {
+    return stamp_file.replace_text_stamp(target2, output);
+  } catch {
+    return void 0;
+  }
+}
+async function omitted_range(issue2, lines) {
+  const path8 = await keep_full_output(issue2, lines.join(LINE_BREAK));
+  const last_line = lines.length - EXCERPT_LINE_LIMIT;
+  return path8 === void 0 ? { last_line } : { path: path8, last_line };
+}
+function clipped(lines) {
+  return lines.map((line) => line.slice(0, EXCERPT_LINE_WIDTH));
+}
+async function excerpt_of(issue2, output) {
+  const lines = output.trim() === "" ? [] : output_lines(output);
+  if (lines.length <= EXCERPT_LINE_LIMIT) return { excerpt: clipped(lines) };
+  return {
+    excerpt: clipped(lines.slice(-EXCERPT_LINE_LIMIT)),
+    omitted: await omitted_range(issue2, lines)
+  };
+}
+async function read_paths() {
+  try {
+    return await changed_paths.read_changed_paths(false);
+  } catch {
+    return void 0;
+  }
+}
+async function changed_of() {
+  const paths = await read_paths();
+  if (paths === void 0) return { more_changed: 0 };
+  return {
+    changed: paths.slice(0, CHANGED_PATH_LIMIT),
+    more_changed: Math.max(0, paths.length - CHANGED_PATH_LIMIT)
+  };
+}
+async function build(issue2, output, findings = []) {
+  const prior = review_prior_findings.on_files(issue2, findings);
+  return {
+    ...await excerpt_of(issue2, output),
+    ...await changed_of(),
+    ...prior.length > 0 && { prior }
+  };
+}
+function has_excerpt(context) {
+  return context !== void 0 && context.excerpt.length > 0;
+}
+function excerpt_heading(issue2, omitted, shown) {
+  if (omitted === void 0) return "The failed stage output:";
+  const source = omitted.path ?? `the stopped report (\`${run_ship_next.COMMAND.LOG} ${issue2}\`)`;
+  const range = `lines 1-${String(omitted.last_line)} are in ${source}`;
+  return `The failed stage output (its last ${String(shown)} lines; ${range}):`;
+}
+function with_dropped(omitted, dropped) {
+  if (dropped === 0) return omitted;
+  return { ...omitted, last_line: (omitted?.last_line ?? 0) + dropped };
+}
+function excerpt_block(issue2, context, changed, dropped) {
+  const shown = context.excerpt.slice(dropped);
+  const heading = excerpt_heading(issue2, with_dropped(context.omitted, dropped), shown.length);
+  return [heading, ...shown, changed].join(LINE_BREAK);
+}
+function changed_text(context) {
+  if (context.changed === void 0) return "The changed files could not be read from git.";
+  if (context.changed.length === 0) return "No files changed against the default branch.";
+  const more = context.more_changed > 0 ? ` (and ${String(context.more_changed)} more)` : "";
+  return `Changed files on the branch: ${context.changed.join(", ")}${more}.`;
+}
+function trailer_text(context) {
+  return [changed_text(context), ...review_prior_findings.fix_lines(context.prior)].join(LINE_BREAK);
+}
+function fitted_block(issue2, context, budget) {
+  const changed = trailer_text(context);
+  if (!has_excerpt(context)) return changed;
+  let dropped = 0;
+  let block = excerpt_block(issue2, context, changed, dropped);
+  while (block.length > budget && dropped < context.excerpt.length - 1) {
+    dropped += 1;
+    block = excerpt_block(issue2, context, changed, dropped);
+  }
+  return block;
+}
+function has_prior(context) {
+  return context.prior !== void 0 && context.prior.length > 0;
+}
+function describe(issue2, context, budget = agent_safe_text.MAX_VALUE_LENGTH) {
+  let fitted = context;
+  let block = fitted_block(issue2, fitted, budget);
+  while (block.length > budget && has_prior(fitted)) {
+    fitted = { ...fitted, prior: fitted.prior?.slice(1) };
+    block = fitted_block(issue2, fitted, budget);
+  }
+  return block;
+}
+var run_ship_stop_context = {
+  CHANGED_PATH_LIMIT,
+  EXCERPT_LINE_LIMIT,
+  build,
+  describe,
+  has_excerpt,
+  stop_context_schema
+};
+
+// scripts/lane/lane-child-invocation.ts
+var CHILD_INVOCATION = "fullrun";
+var LINE_BREAK2 = "\n";
+var REVIEW_INVOCATION = "the reviewer of lane";
+var RESUME_GUIDE = ".claude/skills/workflow-commands/pre-gate-cut.md";
+var SHIP_PROCESS = String.raw`(josh(\.[jt]s)? ship|run-ship-cli\.ts)`;
+function child_invocation(issue2) {
+  issue_number_shape.require_issue_number(issue2);
+  return `${CHILD_INVOCATION} ${issue_cite.plain_for("program", issue2)}`;
+}
+function process_pattern(issue2) {
+  issue_number_shape.require_issue_number(issue2);
+  return `(${CHILD_INVOCATION}|${REVIEW_INVOCATION}|${SHIP_PROCESS} .*) ${issue_cite.plain_for("program", issue2)}$`;
+}
+function ship_pattern(issue2) {
+  issue_number_shape.require_issue_number(issue2);
+  return `${SHIP_PROCESS} .* ${issue_cite.plain_for("program", issue2)}$`;
+}
+function review_invocation(issue2) {
+  issue_number_shape.require_issue_number(issue2);
+  return `${REVIEW_INVOCATION} ${issue_cite.plain_for("program", issue2)}`;
+}
+function resume_invocation(issue2) {
+  const preamble = `Resuming the lane child for issue ${issue_cite.plain_for("program", issue2)} \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Run \`pnpm josh run:entry ${issue2}\` once before anything else; it checks the carried cut and completes the entry on \`fresh\`. Follow its resume verdict in ${RESUME_GUIDE}: \`resume\` goes to the gate, \`resume-impl\` continues implementation. Continue this`;
+  return `${preamble} ${child_invocation(issue2)}`;
+}
+function outage_resume_invocation(issue2) {
+  const preamble = `Resuming the lane child for issue ${issue_cite.plain_for("program", issue2)} after an API disconnection \u2014 your session was restored with its full context, so do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Continue the run from where it stopped: run \`pnpm josh run:step ${issue2}\` to find the next action, redoing only the last step if it did not complete.`;
+  return `${preamble} ${child_invocation(issue2)}`;
+}
+function known_stop_lines(issue2, stop, frame) {
+  const { context } = stop;
+  const is_excerpted = run_ship_stop_context.has_excerpt(context);
+  const next = run_ship_next.next_step(issue2, stop.stage, stop, is_excerpted);
+  if (context === void 0) return [next];
+  const fixed = [...frame, next].join(LINE_BREAK2).length + LINE_BREAK2.length;
+  const budget = agent_safe_text.MAX_VALUE_LENGTH - fixed;
+  return [next, run_ship_stop_context.describe(issue2, context, budget)];
+}
+function ship_stop_invocation(issue2, stop) {
+  const opening = `Resuming the lane child for issue ${issue_cite.plain_for("program", issue2)} after its detached ship supervisor stopped at a failed stage \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md).`;
+  const closing = `Do not re-plan or re-implement what is already on the branch. ${child_invocation(issue2)}`;
+  const middle = stop === void 0 ? [
+    `Run \`pnpm josh run:step ${issue2}\` and read the stopped report it names, fix what stopped the ship, then hand the region back per chain-rule.md.`
+  ] : known_stop_lines(issue2, stop, [opening, closing]);
+  return [opening, ...middle, closing].join(LINE_BREAK2);
+}
+function ship_stop_note(issue2, stop) {
+  return known_stop_lines(issue2, stop, []).join(LINE_BREAK2);
+}
+var lane_child_invocation = {
+  child_invocation,
+  outage_resume_invocation,
+  process_pattern,
+  resume_invocation,
+  review_invocation,
+  ship_pattern,
+  ship_stop_invocation,
+  ship_stop_note
+};
+
+// scripts/lane/lane-reap.ts
+import { execFileSync } from "node:child_process";
+
+// scripts/lane/process-tools.ts
+import path3 from "node:path";
+var NOT_FOUND_CODE = "ENOENT";
+var PACKAGE_HINT = "install the package that provides it (procps on Debian/Ubuntu: `apt-get install procps`)";
+function is_not_found(error) {
+  return error instanceof Error && "code" in error && error.code === NOT_FOUND_CODE;
+}
+function missing_notice(command) {
+  return `\`${path3.basename(command)}\` is not installed \u2014 kit's lane commands read processes with ps and pgrep; ${PACKAGE_HINT}`;
+}
+function throw_if_missing(command, error) {
+  if (is_not_found(error)) throw new Error(missing_notice(command), { cause: error });
+}
+var process_tools = { missing_notice, throw_if_missing };
+
+// scripts/lane/lane-reap.ts
+var PGREP_COMMAND = "pgrep";
+var MATCH_FULL_COMMAND_LINE = "-f";
+var CHILDREN_OF_FLAG = "-P";
+var PS_COMMAND = "/bin/ps";
+var PARENT_FORMAT = ["-o", "ppid=", "-p"];
+var TERMINATE_SIGNAL = "SIGTERM";
+var CONTINUE_SIGNAL = "SIGCONT";
+var LOWEST_CHILD_PID = 2;
+function parse_pids(printed) {
+  return printed.split("\n").map((line) => Number(line.trim())).filter((pid) => Number.isSafeInteger(pid) && pid >= LOWEST_CHILD_PID);
+}
+function run_probe(command, args) {
+  try {
+    return execFileSync(command, [...args], {
+      encoding: "utf8",
+      timeout: PROBE_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch (error) {
+    process_tools.throw_if_missing(command, error);
+    return "";
+  }
+}
+function parent_of(pid) {
+  return parse_pids(run_probe(PS_COMMAND, [...PARENT_FORMAT, String(pid)]))[0];
+}
+function send(pid, name) {
+  try {
+    process.kill(pid, name);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function terminate(pid) {
+  if (!send(pid, TERMINATE_SIGNAL)) return false;
+  send(pid, CONTINUE_SIGNAL);
+  return true;
+}
+var SYSTEM_PROBES = {
+  matching: (pattern) => parse_pids(run_probe(PGREP_COMMAND, [MATCH_FULL_COMMAND_LINE, pattern])),
+  children_of: (pid) => parse_pids(run_probe(PGREP_COMMAND, [CHILDREN_OF_FLAG, String(pid)])),
+  parent_of,
+  terminate
+};
+function ancestry_of(pid, probes = SYSTEM_PROBES) {
+  const ancestry = /* @__PURE__ */ new Set([pid]);
+  let current = probes.parent_of(pid);
+  while (current !== void 0 && !ancestry.has(current)) {
+    ancestry.add(current);
+    current = probes.parent_of(current);
+  }
+  return ancestry;
+}
+function own_ancestry(probes = SYSTEM_PROBES) {
+  return ancestry_of(process.pid, probes);
+}
+function tree_of(roots, probes) {
+  const tree = [];
+  const pending = [...roots];
+  let next = pending.shift();
+  while (next !== void 0) {
+    if (!tree.includes(next)) {
+      tree.push(next);
+      pending.push(...probes.children_of(next));
+    }
+    next = pending.shift();
+  }
+  return tree;
+}
+function roots_of(issue2, own, probes) {
+  const pattern = lane_child_invocation.process_pattern(issue2);
+  return probes.matching(pattern).filter((pid) => !own.has(pid));
+}
+function lane_tree(issue2, probes = SYSTEM_PROBES) {
+  const own = own_ancestry(probes);
+  return tree_of(roots_of(issue2, own, probes), probes).filter((pid) => !own.has(pid));
+}
+function reap_child(lane, probes = SYSTEM_PROBES) {
+  return lane_tree(lane.issue, probes).filter((pid) => probes.terminate(pid));
+}
+function is_child_running(issue2, probes = SYSTEM_PROBES) {
+  return roots_of(issue2, own_ancestry(probes), probes).length > 0;
+}
+var lane_reap = {
+  ancestry_of,
+  is_child_running,
+  lane_tree,
+  own_ancestry,
+  parse_pids,
+  PS_COMMAND,
+  reap_child,
+  run_probe,
+  SYSTEM_PROBES
+};
+
+// scripts/lib/transcript-record.ts
+var TEXT_TYPE = "text";
+var TOOL_USE_TYPE = "tool_use";
+var TOOL_RESULT_TYPE = "tool_result";
+var BLOCK_SCHEMA = external_exports.object({
+  type: external_exports.string().nullish(),
+  text: external_exports.string().nullish(),
+  name: external_exports.string().nullish(),
+  id: external_exports.string().nullish(),
+  tool_use_id: external_exports.string().nullish(),
+  input: external_exports.unknown().nullish(),
+  // Whether the harness wrote a `tool_result` back as a failure — absent on every other block, and
+  // on the results of tools that never report one.
+  is_error: external_exports.boolean().nullish(),
+  // A result's body: a string or a list of blocks. Read as `unknown` because each reader flattens it
+  // its own way, and a narrower type here would drop the whole line over one odd item.
+  content: external_exports.unknown().nullish()
+});
+var CONTENT_SCHEMA = external_exports.union([external_exports.string(), external_exports.array(BLOCK_SCHEMA)]);
+var MESSAGE_SCHEMA = external_exports.object({ id: external_exports.string().nullish(), content: CONTENT_SCHEMA.nullish() });
+var LINE_SCHEMA = external_exports.object({
+  type: external_exports.string().nullish(),
+  timestamp: external_exports.string().nullish(),
+  gitBranch: external_exports.string().nullish(),
+  // The billed request an assistant line belongs to and the reasoning effort it ran at, written on
+  // assistant lines only.
+  requestId: external_exports.string().nullish(),
+  effort: external_exports.string().nullish(),
+  // The two fields outside `message` the harness writes an end-of-task notice on. `unknown`, since a
+  // string here would reject every line whose `content` is a list of blocks.
+  content: external_exports.unknown().nullish(),
+  attachment: external_exports.unknown().nullish(),
+  message: MESSAGE_SCHEMA.nullish()
+});
+function read2(value) {
+  return LINE_SCHEMA.safeParse(value).data;
+}
+function parse(line) {
+  return read2(json_value.parse_or_undefined(line));
+}
+function blocks_of(record2) {
+  const content = record2.message?.content;
+  return Array.isArray(content) ? content : [];
+}
+function is_tool_call(block) {
+  return block.type === TOOL_USE_TYPE && typeof block.name === "string";
+}
+function tool_calls_of(record2) {
+  return blocks_of(record2).filter((block) => is_tool_call(block));
+}
+var transcript_record = {
+  TEXT_TYPE,
+  TOOL_USE_TYPE,
+  TOOL_RESULT_TYPE,
+  read: read2,
+  parse,
+  blocks_of,
+  tool_calls_of
+};
+
+// scripts/cost-runtime/cost-blocks.ts
+var CONTENT_ITEM_SCHEMA = external_exports.object({ text: external_exports.string().nullish() });
+var RESULT_CONTENT_SCHEMA = external_exports.union([external_exports.string(), external_exports.array(CONTENT_ITEM_SCHEMA)]);
+var { TEXT_TYPE: TEXT_TYPE2, TOOL_USE_TYPE: TOOL_USE_TYPE2, TOOL_RESULT_TYPE: TOOL_RESULT_TYPE2 } = transcript_record;
+var BASH_TOOL = "Bash";
+var COMMAND_KEY = "command";
+function json_of(value) {
+  return value === void 0 || value === null ? "" : JSON.stringify(value);
+}
+function split_bash_input(input) {
+  if (!json_value.is_record(input)) return { command: "", rest: json_of(input) };
+  const command = input[COMMAND_KEY];
+  const rest = Object.entries(input).filter(([key]) => key !== COMMAND_KEY);
+  return {
+    command: typeof command === "string" ? command : "",
+    rest: json_of(Object.fromEntries(rest))
+  };
+}
+function to_tool_use(block) {
+  const tool_name = block.name ?? "";
+  const is_bash = tool_name === BASH_TOOL;
+  const { command, rest } = is_bash ? split_bash_input(block.input) : { command: "", rest: json_of(block.input) };
+  return { type: TOOL_USE_TYPE2, tool_name, command, text: rest };
+}
+function result_text(content) {
+  const parsed = RESULT_CONTENT_SCHEMA.safeParse(content);
+  if (!parsed.success) return "";
+  if (typeof parsed.data === "string") return parsed.data;
+  return parsed.data.map((item) => item.text ?? "").join("");
+}
+function to_plain_block(block) {
+  const base = { type: block.type ?? "", tool_name: "", command: "" };
+  const text2 = block.type === TOOL_RESULT_TYPE2 ? result_text(block.content) : block.text ?? "";
+  return { ...base, text: text2 };
+}
+function to_block(block) {
+  return block.type === TOOL_USE_TYPE2 ? to_tool_use(block) : to_plain_block(block);
+}
+function to_blocks(content) {
+  if (typeof content === "string") {
+    return [{ type: TEXT_TYPE2, tool_name: "", command: "", text: content }];
+  }
+  return content.map((block) => to_block(block));
+}
+function content_of(line) {
+  return transcript_record.parse(line)?.message?.content ?? void 0;
+}
+function parse_line2(line) {
+  const content = content_of(line);
+  return content === void 0 ? [] : to_blocks(content);
+}
+function parse_content(text2) {
+  return text2.split("\n").flatMap((line) => parse_line2(line));
+}
+var cost_blocks = {
+  BASH_TOOL,
+  TEXT_TYPE: TEXT_TYPE2,
+  TOOL_USE_TYPE: TOOL_USE_TYPE2,
+  TOOL_RESULT_TYPE: TOOL_RESULT_TYPE2,
+  parse_line: parse_line2,
+  parse_content
+};
+
+// scripts/time-runtime/time-shell.ts
+var BASH_SEPARATOR = ": ";
+var WHITESPACE_PATTERN = /\s+/u;
+var SEGMENT_PATTERN = /&&|\|\||;|\|/u;
+var PIPE_PATTERN = /(?<!\|)\|(?!\|)/u;
+var CHAIN_PATTERN = /&&|\|\||;|\n/u;
+var SUBSTITUTION_ATOM = /\$\([^()]*\)/u;
+var LONE_DOLLAR = /\$(?!\([^()]*\))/u;
+var QUOTED_SPAN_PATTERN = new RegExp(
+  String.raw`\\[\s\S]|'[^']*'|"(?:\\[\s\S]|${SUBSTITUTION_ATOM.source}|${LONE_DOLLAR.source}|[^"\\$])*"`,
+  "gu"
+);
+var HEREDOC_MARKER = /(?<!<)<<-?\s*(['"]?)(\w+)\1/u;
+var HEREDOC_DELIMITER_GROUP = 2;
+var LINE_BREAK3 = "\n";
+var DOUBLE_QUOTE = '"';
+var SUBSTITUTION_PATTERN = /(?<!\\)\$\((?<dollar>[^()]*)\)|(?<!\\)`(?<tick>[^`]*)`/gu;
+var PIPEFAIL_PATTERN = /\bset\s+-[a-z]*o\s+pipefail\b/u;
+var COMMAND_WORD_PATTERN = /^[\w./@:+][\w./@:+-]*$/u;
+var ASSIGNMENT_PATTERN = /^\w+=/u;
+var SUBSHELL_OPENER = "$(";
+var FLAG_PREFIX = "-";
+var WRAPPER_COMMANDS = /* @__PURE__ */ new Map([
+  ["time", { valued: /* @__PURE__ */ new Set(["-f", "-o", "--format", "--output"]), operands: 0 }],
+  ["env", { valued: /* @__PURE__ */ new Set(["-u", "-C", "-S", "--unset", "--chdir"]), operands: 0 }],
+  ["sudo", { valued: /* @__PURE__ */ new Set(["-u", "-g", "-C", "-D"]), operands: 0 }],
+  ["timeout", { valued: /* @__PURE__ */ new Set(["-s", "-k", "--signal", "--kill-after"]), operands: 1 }],
+  ["nohup", { valued: /* @__PURE__ */ new Set(), operands: 0 }],
+  ["nice", { valued: /* @__PURE__ */ new Set(["-n", "--adjustment"]), operands: 0 }],
+  ["command", { valued: /* @__PURE__ */ new Set(), operands: 0 }],
+  ["exec", { valued: /* @__PURE__ */ new Set(["-a"]), operands: 0 }],
+  ["stdbuf", { valued: /* @__PURE__ */ new Set(["-i", "-o", "-e"]), operands: 0 }]
+]);
+var NAVIGATION_COMMANDS = /* @__PURE__ */ new Set(["cd", "pushd", "popd", "export", "source", "set", "."]);
+var PATH_SEPARATOR = "/";
+var FLAG_AND_VALUE = 2;
+var JOSH_LAUNCHER = String.raw`^(?:(?:pnpm|npx)\s+(?:exec\s+)?)?josh`;
+var JOSH_PATTERN = new RegExp(String.raw`${JOSH_LAUNCHER}\s+([a-z][\w:-]*)`, "u");
+var JOSH_LAUNCHER_PATTERN = new RegExp(String.raw`${JOSH_LAUNCHER}(?:\s|$)`, "u");
+var JOSH_PREFIX = "josh ";
+var COMMAND_KEY2 = "command";
+function bash_command(input) {
+  if (!json_value.is_record(input)) return "";
+  const command = input[COMMAND_KEY2];
+  return typeof command === "string" ? command : "";
+}
+function after_flags(words, start, valued) {
+  let index = start;
+  while (words[index]?.startsWith(FLAG_PREFIX) === true) {
+    index += valued.has(words[index] ?? "") ? FLAG_AND_VALUE : 1;
+  }
+  return index;
+}
+function after_prefix_word(words, index) {
+  const word2 = words[index] ?? "";
+  if (word2.startsWith(FLAG_PREFIX) || ASSIGNMENT_PATTERN.test(word2)) return index + 1;
+  const wrapper = WRAPPER_COMMANDS.get(word2.slice(word2.lastIndexOf(PATH_SEPARATOR) + 1));
+  if (wrapper === void 0) return index;
+  return after_flags(words, index + 1, wrapper.valued) + wrapper.operands;
+}
+function command_words(segment) {
+  const words = segment.replaceAll(SUBSHELL_OPENER, " ").trim().split(WHITESPACE_PATTERN);
+  let start = 0;
+  for (let next = after_prefix_word(words, start); next !== start; ) {
+    start = next;
+    next = after_prefix_word(words, start);
+  }
+  return words.slice(start);
+}
+function segment_command(segment) {
+  const [head] = command_words(segment);
+  if (head === void 0 || NAVIGATION_COMMANDS.has(head)) return "";
+  return COMMAND_WORD_PATTERN.test(head) ? head : "";
+}
+function command_segment(command) {
+  return command.split(SEGMENT_PATTERN).find((segment) => segment_command(segment) !== "") ?? "";
+}
+function leading_word(command) {
+  return segment_command(command_segment(command));
+}
+function open_heredoc(line, kept) {
+  kept.push(line.replace(HEREDOC_MARKER, " "));
+  return HEREDOC_MARKER.exec(line)?.[HEREDOC_DELIMITER_GROUP];
+}
+function close_heredoc(line, delimiter) {
+  return line.trim() === delimiter ? void 0 : delimiter;
+}
+function without_heredoc_bodies(command) {
+  const kept = [];
+  const body = {};
+  for (const line of command.split(LINE_BREAK3)) {
+    body.delimiter = body.delimiter === void 0 ? open_heredoc(line, kept) : close_heredoc(line, body.delimiter);
+  }
+  return kept.join(LINE_BREAK3);
+}
+function spoken_substitutions(span) {
+  if (!span.startsWith(DOUBLE_QUOTE)) return " ";
+  const inner = [...span.matchAll(SUBSTITUTION_PATTERN)].map(
+    (match) => (match.groups?.["dollar"] ?? match.groups?.["tick"] ?? "").replaceAll(QUOTED_SPAN_PATTERN, " ")
+  );
+  return inner.length === 0 ? " " : ` ; ${inner.join(" ; ")} ; `;
+}
+function unquoted(command) {
+  return without_heredoc_bodies(command).replaceAll(
+    QUOTED_SPAN_PATTERN,
+    (span) => spoken_substitutions(span)
+  );
+}
+function has_heredoc(command) {
+  return HEREDOC_MARKER.test(command);
+}
+function blanked(command) {
+  if (has_heredoc(command)) return void 0;
+  return command.replaceAll(QUOTED_SPAN_PATTERN, (span) => " ".repeat(span.length));
+}
+function literal_blanked(command) {
+  return command.replaceAll(
+    QUOTED_SPAN_PATTERN,
+    (span) => span.startsWith(DOUBLE_QUOTE) ? span : " ".repeat(span.length)
+  );
+}
+function discarded_commands(command) {
+  const plain2 = unquoted(command);
+  if (PIPEFAIL_PATTERN.test(plain2)) return [];
+  return plain2.split(PIPE_PATTERN).slice(0, -1).map((segment) => segment.split(CHAIN_PATTERN).at(-1) ?? "");
+}
+function bash_label(command) {
+  const word2 = leading_word(command);
+  return word2 === "" ? cost_blocks.BASH_TOOL : `${cost_blocks.BASH_TOOL}${BASH_SEPARATOR}${word2}`;
+}
+function josh_command_of_segment(segment) {
+  const name = JOSH_PATTERN.exec(command_words(segment).join(" "))?.[1];
+  return name === void 0 ? "" : `${JOSH_PREFIX}${name}`;
+}
+function runs_josh(segment) {
+  return JOSH_LAUNCHER_PATTERN.test(command_words(segment).join(" "));
+}
+function josh_command_of(command) {
+  return josh_command_of_segment(command_segment(command));
+}
+function josh_commands_of(command) {
+  return unquoted(command).split(SEGMENT_PATTERN).map((segment) => josh_command_of_segment(segment)).filter((name) => name !== "");
+}
+var REDIRECTION_CHARACTERS = ["<", ">"];
+function is_redirection(word2) {
+  return REDIRECTION_CHARACTERS.some((character) => word2.includes(character));
+}
+function ends_in_redirection(word2) {
+  return REDIRECTION_CHARACTERS.some((character) => word2.endsWith(character));
+}
+function drop_redirections(words) {
+  const kept = [];
+  let is_target = false;
+  for (const word2 of words) {
+    const is_dropped = is_target || is_redirection(word2);
+    is_target = ends_in_redirection(word2);
+    if (!is_dropped) kept.push(word2);
+  }
+  return kept;
+}
+function josh_arguments_of_segment(segment) {
+  const text2 = command_words(segment).join(" ");
+  const match = JOSH_PATTERN.exec(text2);
+  if (match === null) return [];
+  const words = text2.slice(match[0].length).split(WHITESPACE_PATTERN).filter((word2) => word2 !== "");
+  return drop_redirections(words);
+}
+function josh_arguments(command) {
+  return josh_arguments_of_segment(command_segment(command));
+}
+function josh_signature_of_segment(segment) {
+  const name = josh_command_of_segment(segment);
+  if (name === "") return "";
+  return [name, ...josh_arguments_of_segment(segment)].join(" ");
+}
+function josh_signatures_of(command) {
+  return unquoted(command).split(SEGMENT_PATTERN).map((segment) => josh_signature_of_segment(segment)).filter((signature) => signature !== "");
+}
+var time_shell = {
+  JOSH_PREFIX,
+  bash_command,
+  bash_label,
+  blanked,
+  command_segment,
+  command_words,
+  discarded_commands,
+  has_heredoc,
+  josh_arguments,
+  runs_josh,
+  josh_command_of,
+  josh_command_of_segment,
+  josh_commands_of,
+  josh_signatures_of,
+  leading_word,
+  literal_blanked,
+  unquoted,
+  without_heredoc_bodies
+};
+
+// scripts/git/repository-lock.ts
+import { randomUUID } from "node:crypto";
+import { linkSync, renameSync, rmSync } from "node:fs";
+
+// scripts/josh/process-owner.ts
+var process_owner_schema = external_exports.object({ pid: external_exports.number(), process_start: external_exports.string().optional() });
+
+// scripts/lib/poll.ts
+async function sleep(duration_ms) {
+  await new Promise((resolve) => {
+    setTimeout(resolve, duration_ms);
+  });
+}
+var POLL_BACKOFF = { initial_ms: 3e4, factor: 1.5, max_ms: 12e4 };
+var PR_POLL_SCHEDULES = {
+  // CI does not finish right after it starts, so the lead reads coarsely; after it a fixed interval
+  // bounds the detection delay that a lengthening wait would stretch toward its cap.
+  checks: {
+    lead: { count: 4, interval_ms: 3e4 },
+    initial_ms: 2e4,
+    factor: 1,
+    max_ms: 2e4
+  },
+  // The CI completion wait and its watch: a poll where the head's checks did not move costs only
+  // two conditional reads (`git-pr-checks-gate.ts`), so after the same lead it polls twice as often
+  // (joshuafolkken/kit#7238). `checks` stays the CodeRabbit retrigger wait's, which has no gate.
+  checks_gated: {
+    lead: { count: 4, interval_ms: 3e4 },
+    initial_ms: 1e4,
+    factor: 1,
+    max_ms: 1e4
+  },
+  // A merge lands soon after the checks pass, so its wait starts fine and keeps a low cap that
+  // bounds the delay between the merge landing and its detection (joshuafolkken/kit#7237).
+  merge: { initial_ms: 1e4, factor: 1.5, max_ms: 15e3 }
+};
+function fixed_cadence(options) {
+  return function next_wait(attempt) {
+    return attempt < options.attempts - 1 ? options.interval_ms : void 0;
+  };
+}
+function next_backoff_interval(schedule, previous, seen) {
+  if (seen !== previous.seen) return schedule.initial_ms;
+  return Math.min(previous.interval_ms * schedule.factor, schedule.max_ms);
+}
+function next_backoff_step(schedule, previous, tick, seen) {
+  const { lead } = schedule;
+  if (lead !== void 0 && tick < lead.count) {
+    return { interval_ms: lead.interval_ms, seen: void 0 };
+  }
+  return { interval_ms: next_backoff_interval(schedule, previous, seen), seen };
+}
+function backoff_cadence(options, backoff) {
+  const schedule = backoff.schedule ?? POLL_BACKOFF;
+  const budget_ms = (options.attempts - 1) * options.interval_ms;
+  const state = { waited_ms: 0, step: { interval_ms: 0, seen: void 0 } };
+  return function next_wait(tick) {
+    if (state.waited_ms >= budget_ms) return void 0;
+    const step = next_backoff_step(schedule, state.step, tick, backoff.seen?.() ?? "");
+    const wait_ms = Math.min(step.interval_ms, budget_ms - state.waited_ms);
+    Object.assign(state, { waited_ms: state.waited_ms + wait_ms, step });
+    return wait_ms;
+  };
+}
+function to_cadence(options) {
+  return options.backoff === void 0 ? fixed_cadence(options) : backoff_cadence(options, options.backoff);
+}
+function wait_after(value, next_wait, attempt) {
+  return value === void 0 ? next_wait(attempt) : void 0;
+}
+async function poll_for(read3, options) {
+  const wait = options.sleeper ?? sleep;
+  const next_wait = to_cadence(options);
+  for (let attempt = 0; ; attempt += 1) {
+    const value = await read3();
+    const wait_ms = wait_after(value, next_wait, attempt);
+    if (wait_ms === void 0) return value;
+    await wait(wait_ms);
+  }
+}
+async function poll_until(is_done2, options) {
+  const is_reached = await poll_for(async () => await is_done2() ? true : void 0, options);
+  return is_reached === true;
+}
+async function wait_for(read3, options) {
+  const value = await poll_for(read3, { ...options, attempts: Infinity });
+  if (value === void 0) throw new Error("an unbounded poll ran out of attempts");
+  return value;
+}
+var poll = { poll_for, poll_until, sleep, wait_for };
+
+// scripts/git/repository-lock.ts
+var POLL_INTERVAL_MS = 200;
+var SYNC_POLL_INTERVAL_MS = 10;
+var SLEEP_CELL = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+function lock_path(prefix, cwd) {
+  return stamp_file.stamp_path(prefix, git_common_directory.repository(cwd) ?? cwd ?? process.cwd());
+}
+function parse_owner(raw) {
+  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 read_owner(target2) {
+  return parse_owner(stamp_file.read_stamp_text(target2));
+}
+function is_owner_gone(owner) {
+  return process_identity.is_same_process(owner.pid, owner.process_start) === false;
+}
+function restore(aside, target2) {
+  try {
+    linkSync(aside, target2);
+  } catch {
+  }
+}
+function stale_record(target2, is_gone) {
+  const raw = stamp_file.read_stamp_text(target2);
+  const owner = parse_owner(raw);
+  return owner !== void 0 && is_gone(owner) ? raw : void 0;
+}
+function move_aside(target2) {
+  const aside = `${target2}.${String(process.pid)}.${randomUUID()}`;
+  try {
+    renameSync(target2, aside);
+    return aside;
+  } catch {
+    return void 0;
+  }
+}
+function clear_stale(target2, is_gone = is_owner_gone) {
+  const raw = stale_record(target2, is_gone);
+  if (raw === void 0) return;
+  const aside = move_aside(target2);
+  if (aside === void 0) return;
+  if (stamp_file.read_stamp_text(aside) !== raw) restore(aside, target2);
+  rmSync(aside, { force: true });
+}
+function claim(target2) {
+  clear_stale(target2);
+  return stamp_file.create_stamp(target2, process_identity.own_fields());
+}
+function release(target2) {
+  const owner = read_owner(target2);
+  if (owner !== void 0 && process_identity.is_own_process(owner.pid, owner.process_start)) {
+    stamp_file.remove_stamp(target2);
+  }
+}
+async function acquire(target2, max_wait_ms) {
+  const deadline = Date.now() + max_wait_ms;
+  return await poll.wait_for(
+    () => {
+      if (claim(target2)) return true;
+      return Date.now() >= deadline ? false : void 0;
+    },
+    { interval_ms: POLL_INTERVAL_MS }
+  );
+}
+function sleep_sync(ms) {
+  Atomics.wait(SLEEP_CELL, 0, 0, ms);
+}
+function acquire_sync(target2, max_wait_ms) {
+  const deadline = Date.now() + max_wait_ms;
+  while (!claim(target2)) {
+    if (Date.now() >= deadline) return false;
+    sleep_sync(SYNC_POLL_INTERVAL_MS);
+  }
+  return true;
+}
+async function with_lock(work, target2, max_wait_ms) {
+  if (!await acquire(target2, max_wait_ms)) return void 0;
+  try {
+    return await work();
+  } finally {
+    release(target2);
+  }
+}
+function with_lock_sync(work, target2, max_wait_ms) {
+  if (!acquire_sync(target2, max_wait_ms)) return void 0;
+  try {
+    return work();
+  } finally {
+    release(target2);
+  }
+}
+var repository_lock = { clear_stale, lock_path, with_lock, with_lock_sync };
+
+// scripts/run/event/run-event-stream.ts
+var EVENT_PREFIX = durable_state.PREFIX.EVENTS;
+var EVENT_SUFFIX = ".jsonl";
+var EVENT_CAP = 15e3;
+var FIRST_POSITION = 0;
+var POSITION_INCREMENT = 1;
+var LINE_SEPARATOR2 = "\n";
+var WORD_SEPARATOR2 = " ";
+var STAGE_PHASE_INDEX = 2;
+var LOCK_SUFFIX = ".lock";
+var LOCK_WAIT_MS = 5e3;
+var EVENT_KIND = {
+  PLAN: "plan",
+  CHILD_LAUNCH: "child-launch",
+  MERGE: "merge",
+  PARK: "park",
+  HUMAN_REVIEW: "human-review",
+  SPLIT: "split",
+  OUTAGE: "outage",
+  // A Claude usage limit stopped a lane child (joshuafolkken/kit#4745). Its text names the reset time,
+  // which `backlog:drive` reads to hold launches until then; it counts against no streak, so it is not an
+  // `OUTAGE`.
+  USAGE_LIMIT: "usage-limit",
+  CUT: "cut",
+  // A fresh session adopted an implementation cut — `run:cut --resume` answered `resume-impl`. The
+  // resume clears the cut record, so without this the `cut` would stay the newest position and
+  // `run:step` would keep answering the resume command it had just run.
+  RESUME: "resume",
+  // A person stopped a running lane child and re-dispatched its issue in a fresh session
+  // (`lane:restart`). It follows the fresh dispatch's `CHILD_LAUNCH`, so it is a launch to the parent and
+  // the board, and — like that launch — a batch record a lane child never reads as its own position.
+  RESTART: "restart",
+  // A person withdrew a lane child — stopped it and left its issue open for the next run (`lane:withdraw`).
+  // It is written before the stop, so `run:merge` settles the child as withdrawn whatever GitHub says
+  // by the time the parent collects it, and counts it as neither a merge, a failure nor an outage.
+  WITHDRAW: "withdraw",
+  // The backlog emptied while nothing of the run's own was in flight — the drain. It marks the position
+  // at which the end-of-run retrospective is owed, *before* the idle watch opens, so `run:step` fires
+  // the retrospective at the drain rather than after the watch runs its course. It is not itself a
+  // stop: the run watches on once the retrospective has run, and the real `STOP` follows when the watch
+  // expires.
+  DRAIN: "drain",
+  STOP: "stop",
+  PR_OPENED: "pr-opened",
+  REVIEW_ROUND: "review-round",
+  // The end-of-run retrospective's result, recorded when the run marks the retrospective done. A
+  // retrospective that files zero improvements and one that never ran look
+  // the same from outside — no new Issue either way — so the result is put on the stream the report is
+  // generated from: the issues filed (or that none were), and the candidates dropped with why. It is
+  // emitted from the `run:carry --retrospective` close, so marking the retrospective done and recording
+  // what it found are one action rather than two the run could do only one of.
+  RETROSPECTIVE: "retrospective",
+  // Ready backlog work is sitting undispatched while a lane is free and nothing has dispatched for a
+  // while. Emitted once per stall episode by the stop-time detector, it is both the dedup marker —
+  // `emit_once_since` refuses a second until a `CHILD_LAUNCH` intervenes — and the line a terminal
+  // reader following the stream sees. `run:step` reads it as `backlog:next`, so a run that
+  // stalled is pointed straight at dispatching the work rather than left waiting.
+  STALL: "stall",
+  // The run's own driver is gone: the cut handed the budget off, the owner has died, and no supervisor
+  // is watching. Emitted once per strand episode by the stop-time detector — or by the `run:wake`
+  // supervisor as it fails, leaves that state behind and has warned of it —
+  // exactly as `STALL` is — the newest-event dedup keeps a run polled every stop from notifying more
+  // than once, and a terminal reader following the stream sees the line. The strand is the step before
+  // the stall: a stalled run still has a driver that could dispatch, a stranded one has none.
+  STRANDED: "stranded",
+  // One `josh ship` stage starting, succeeding or failing. It is a trace of the
+  // composite's progress rather than a position the run is at — the positions a ship leaves behind are
+  // the closed issue its `followup` merges, or a detached supervisor's `SHIP_LAUNCH` / `SHIP_STOP` below
+  // — so it is one of the `TRACE_KINDS` the last-event read skips.
+  SHIP_STAGE: "ship-stage",
+  // One progress watcher line — the `at … / next …` heartbeat `run:progress` prints. Printed only to
+  // the watcher's own output, a headless successor's heartbeat would be buried in its log after a cut;
+  // on the stream it reaches the attached session's relay. It says
+  // the run is alive rather than where it is, so it is a trace kind like `SHIP_STAGE`.
+  HEARTBEAT: "heartbeat",
+  // The post-implementation region handed to a detached `josh ship --detach` supervisor. Unlike a stage
+  // trace it is a position: the agent has ended and the
+  // supervisor carries the run, so `run:step` answers `wait` until it stops or the issue closes.
+  SHIP_LAUNCH: "ship-launch",
+  // The supervisor stopped at a failed stage — a red gate, a High/Medium review, a failed push, red CI
+  // The position that hands control back: `run:step` prints the command that
+  // shows the stopped report, so the agent fixes it and relaunches rather than rebuilding the context.
+  SHIP_STOP: "ship-stop",
+  // The relaunch meant to answer a `SHIP_STOP` started nothing — the broker refused it, or the direct
+  // spawn failed (joshuafolkken/kit#4765). `run:merge` reads it, not the transcript's mtime, to tell the
+  // stop went unanswered, and a re-dispatch cap's park names its reason. A trace: the stop stays the
+  // position `run:step` answers.
+  RELAUNCH_FAILED: "relaunch-failed",
+  // An Issue the run filed on its way, written by `issue:file`, so a run started from the command line
+  // still surfaces what it found — `run:board`'s findings section reads it.
+  FILED: "filed",
+  // A one-line observation short of an Issue, written with `run:event --append note` and shown in the
+  // same section.
+  NOTE: "note",
+  // A lane child reached a phase no other event marks — its first implementation edit, written by the
+  // PreToolUse hook — so `run:board` draws how far the child has got. The backlog driver writes its own
+  // `collect` / `launch` steps on a child as this kind too, which no reader draws as a phase
+  // (`backlog-drive-trace.ts`). A trace, like `SHIP_STAGE`: it says where the child's work is, not where
+  // the run is.
+  LANE_PHASE: "lane-phase",
+  // The fullrun step `run:step` or `run:entry` computed for an issue: `#<N> step <n>/<total> <name>`,
+  // written once per change of step (`run-event-step.ts`), so `run:board` draws it (joshuafolkken/kit#6598).
+  // A trace: it says which step the issue's run reached, not where the run is.
+  STEP: "step",
+  // An issue `run:add` put into the live run. The parent's `--wait` watcher
+  // ends on it, so the issue takes the next free lane without waiting out the arrival probe's minute. A
+  // trace: it says what the run was handed, not where the run is.
+  ADD: "add",
+  // `josh lane:limit` raised a live run's lane limit. The `--wait` watcher's
+  // arrival probe reads it as a wake: the lanes a raise frees are new room for a pool its baseline
+  // already holds. A trace: it says the run gained room, not where the run is.
+  LANE_LIMIT: "lane-limit",
+  // One stage of the run's start — the session starting, the plan, the hand-off to the supervisor, a
+  // lane opening (`run-event-setup.ts`). `run:board` draws it while the run stands at it, so the
+  // minutes before one read as work rather than as a run that has stopped. A trace: it says the run is
+  // getting ready, not where the run is.
+  SETUP: "setup",
+  // A child's pull request checks as `josh followup` last polled them — the CI counts and CodeRabbit's
+  // state (`run-event-checks.ts`), written only when they change, so `run:board` draws a child waiting
+  // in followup without asking GitHub (joshuafolkken/kit#3770). A trace: it says how the checks stand,
+  // not where the run is.
+  PR_CHECKS: "pr-checks",
+  // `backlog:drive` reached a watch with no child running and nothing to dispatch — the point a person's
+  // hand is wanted. Emitted once per idle episode (`emit_once_since_with`, reset by `CHILD_LAUNCH`), it
+  // is the dedup marker for the one idle Telegram. A trace: a drain's retrospective is read off the
+  // position beneath it, so the marker must not stand over it.
+  IDLE_NOTICE: "idle-notice",
+  // A person paused or resumed a lane child (`lane:pause` / `lane:resume`), so who halted a lane and
+  // when is on the stream rather than only in a shell history (joshuafolkken/kit#4268). A trace: it
+  // says what a lane's processes were told, not where the run is.
+  LANE_STATE: "lane-state",
+  // `backlog:drive` found nothing of the run in flight and only paused lanes left, paused past the
+  // silent window (joshuafolkken/kit#4270). Emitted once per pause episode (`emit_once_since_with`,
+  // reset by `LANE_STATE`), it is the dedup marker for the one paused-lane Telegram. A trace.
+  PAUSED_NOTICE: "paused-notice",
+  // `backlog:drive` ran a due issue's measurement declaration itself, found it within its bound and
+  // closed the issue through `issue:measured` — no lane was launched for it (joshuafolkken/kit#4621).
+  // `run:board` draws it merged. A trace: the parent's position is the drive's, not this close.
+  MEASURED: "measured",
+  // `backlog:drive` ran a due issue's measurement declaration and found no sample to read yet, so the
+  // issue waits without a lane (joshuafolkken/kit#6503). A trace: `offer_exclude` keeps it out of the
+  // run's offers, the way the drive's own `waiting` list does.
+  SAMPLE_WAIT: "sample-wait",
+  // The host slept while `backlog:drive` sampled its load (joshuafolkken/kit#5032): the sampler's timer
+  // ran late by more than a few intervals. `at` is the wake and `elapsed_ms` how long the sleep
+  // lasted; every lane's net time takes it out (`lane-sleep.ts`). A trace.
+  SLEEP: "sleep",
+  // A lane's `lane:plan` blocking on a holder of its files (joshuafolkken/kit#6140): `#<N> start #<M>`
+  // as one ask begins to wait, `#<N> end #<M>` as it ends, so `lane:breakdown` counts
+  // the wait under its own row rather than the stage it fell in (`lane-plan-wait-event.ts`). A trace.
+  PLAN_WAIT: "plan-wait",
+  // GitHub's REST core rate limit read around one `backlog:drive` offer cycle (joshuafolkken/kit#6558):
+  // JSON text with the cycle's `used_delta`, `remaining` and `reset`, or `is_missing` when a read failed
+  // (`backlog-drive-rate.ts`). A trace written every cycle, so the bound rolls it off with the heartbeats.
+  RATE_LIMIT: "rate-limit"
+};
+var EVENT_KINDS = Object.values(EVENT_KIND);
+var TRACE_KINDS = /* @__PURE__ */ new Set([
+  EVENT_KIND.SHIP_STAGE,
+  EVENT_KIND.HEARTBEAT,
+  EVENT_KIND.FILED,
+  EVENT_KIND.NOTE,
+  EVENT_KIND.LANE_PHASE,
+  EVENT_KIND.STEP,
+  EVENT_KIND.ADD,
+  EVENT_KIND.LANE_LIMIT,
+  EVENT_KIND.SETUP,
+  EVENT_KIND.PR_CHECKS,
+  EVENT_KIND.IDLE_NOTICE,
+  EVENT_KIND.LANE_STATE,
+  EVENT_KIND.PAUSED_NOTICE,
+  EVENT_KIND.MEASURED,
+  EVENT_KIND.SAMPLE_WAIT,
+  EVENT_KIND.RELAUNCH_FAILED,
+  EVENT_KIND.SLEEP,
+  EVENT_KIND.PLAN_WAIT,
+  EVENT_KIND.RATE_LIMIT
+]);
+var DISPOSABLE_KINDS = /* @__PURE__ */ new Set([
+  EVENT_KIND.SHIP_STAGE,
+  EVENT_KIND.HEARTBEAT,
+  EVENT_KIND.SETUP,
+  EVENT_KIND.PR_CHECKS,
+  EVENT_KIND.RATE_LIMIT
+]);
+var event_schema = external_exports.object({
+  pos: external_exports.number(),
+  at: external_exports.string(),
+  kind: external_exports.string(),
+  text: external_exports.string(),
+  // The child's time on a lane, recorded once by the writer of an ending (joshuafolkken/kit#4481), so a
+  // reader never has to find its launch again. An event written before it has none. A `sleep` event
+  // carries the sleep's length here.
+  elapsed_ms: external_exports.number().optional(),
+  // The ship stop a park was taken at — its stage and `Cause` class (joshuafolkken/kit#6864) — so a
+  // reader re-dispatching the park reads them without parsing text. Free strings: an event a later
+  // version wrote with a new class still parses. A park written before it, or no ship's, has none —
+  // as does one a lane on older code rewrote, since its schema drops the key, so none is a normal read.
+  stop: external_exports.object({ stage: external_exports.string(), cause: external_exports.string() }).optional()
+});
+function is_event_kind(value) {
+  return EVENT_KINDS.includes(value);
+}
+function target_of(repository) {
+  return durable_state.path(EVENT_PREFIX, repository, EVENT_SUFFIX);
+}
+function is_present2(event) {
+  return event !== void 0;
+}
+function parse_line3(line) {
+  return event_schema.safeParse(json_value.parse_or_undefined(line)).data;
+}
+function lines_of(raw) {
+  return raw.split(LINE_SEPARATOR2).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => parse_line3(line)).filter(is_present2);
+}
+function events_of_text(raw) {
+  return lines_of(raw).filter((event) => is_event_kind(event.kind));
+}
+function read_lines(target2, is_required = false) {
+  const raw = stamp_file.read_stamp_text(target2);
+  if (raw === void 0 && is_required) throw new Error("Could not read the run event stream.");
+  if (raw === void 0) return [];
+  return lines_of(raw);
+}
+function read_events(target2, is_required = false) {
+  return read_lines(target2, is_required).filter((event) => is_event_kind(event.kind));
+}
+function last_position(events) {
+  return events[events.length - POSITION_INCREMENT]?.pos ?? FIRST_POSITION;
+}
+function issue_of(event) {
+  return event.text.split(WORD_SEPARATOR2)[FIRST_POSITION] ?? "";
+}
+function newest_by_issue(events, kind) {
+  const newest = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.kind === kind) newest.set(issue_of(event), event);
+  }
+  return new Set(newest.values());
+}
+function is_stage_start(event) {
+  if (event.kind !== EVENT_KIND.SHIP_STAGE) return false;
+  return event.text.split(WORD_SEPARATOR2)[STAGE_PHASE_INDEX] === run_ship_stage.PHASE.START;
+}
+function drawn_lines(events) {
+  const setup = events.findLast((event) => event.kind === EVENT_KIND.SETUP);
+  return /* @__PURE__ */ new Set([
+    ...newest_by_issue(events, EVENT_KIND.SHIP_STAGE),
+    ...newest_by_issue(events, EVENT_KIND.PR_CHECKS),
+    ...setup === void 0 ? [] : [setup]
+  ]);
+}
+function droppable(events) {
+  const kept = drawn_lines(events);
+  const disposable = events.filter((event) => DISPOSABLE_KINDS.has(event.kind) && !kept.has(event));
+  return [
+    ...disposable.filter((event) => !is_stage_start(event)),
+    ...disposable.filter((event) => is_stage_start(event))
+  ];
+}
+function bounded(events) {
+  const excess = events.length - EVENT_CAP;
+  if (excess <= 0) return events;
+  const dropped = new Set(droppable(events).slice(0, excess));
+  return events.filter((event) => !dropped.has(event)).slice(-EVENT_CAP);
+}
+function serialize(events) {
+  return `${events.map((event) => JSON.stringify(event)).join(LINE_SEPARATOR2)}${LINE_SEPARATOR2}`;
+}
+function append_held(target2, event) {
+  const position = last_position(read_lines(target2)) + POSITION_INCREMENT;
+  const events = bounded([...read_events(target2), { pos: position, ...event }]);
+  stamp_file.replace_text_stamp(target2, serialize(events));
+  return position;
+}
+function append_event(target2, event) {
+  if (!is_event_kind(event.kind)) return { appended: false, position: FIRST_POSITION };
+  const lock = `${target2}${LOCK_SUFFIX}`;
+  const position = repository_lock.with_lock_sync(
+    () => append_held(target2, event),
+    lock,
+    LOCK_WAIT_MS
+  );
+  if (position === void 0) {
+    const message = `run event stream: gave up waiting for the lock at ${lock}`;
+    process.stderr.write(`${message}
+`);
+    throw new Error(message);
+  }
+  return { appended: true, position };
+}
+function append(target2, kind, text2, at) {
+  return append_event(target2, { at, kind, text: text2 });
+}
+function read_from(target2, position) {
+  const events = read_events(target2);
+  return {
+    events: events.filter((event) => event.pos > position),
+    next_position: last_position(events)
+  };
+}
+function read_last(target2) {
+  return read_events(target2).findLast((event) => !TRACE_KINDS.has(event.kind));
+}
+function since(events, reset_kind) {
+  const reset_at = events.findLastIndex((event) => event.kind === reset_kind);
+  return events.slice(reset_at + POSITION_INCREMENT);
+}
+function has_since(events, kind, reset_kind) {
+  return since(events, reset_kind).some((event) => event.kind === kind);
+}
+var FIELD_SEPARATOR = " \xB7 ";
+function format_event(event) {
+  return [event.at, event.kind, event.text].join(FIELD_SEPARATOR);
+}
+var run_event_stream = {
+  EVENT_CAP,
+  EVENT_KIND,
+  EVENT_KINDS,
+  TRACE_KINDS,
+  append,
+  append_event,
+  events_of_text,
+  format_event,
+  has_since,
+  is_stage_start,
+  read_events,
+  read_from,
+  read_last,
+  since,
+  target_of
+};
+
+// scripts/rules/issue-citation.ts
+var ISSUE_NUMBER = /#\d+/gu;
+var REFERENCE_BOUNDARY = /[\s#()[\]<>|]/u;
+var OWNER_REPO = /^[^\s/#]+\/[^\s/#]+$/u;
+var MARKDOWN_LINK = /\[[^[\]]*\]\([^()]*\)/gu;
+var NUMBER_CONTINUATION = /^(?:\w|-[a-z])/iu;
+var CONTINUATION_WIDTH = 2;
+var GLUED_LEAD = /[&./]/u;
+var FENCE_MARKER = /^\s*(?:`{3,}|~{3,})/u;
+var QUOTE_LINE = /^\s*>/u;
+var PR_PREFIX = /\b(?:pr|pull request)\s*$/iu;
+var BACKTICK_PAIR = 2;
+function link_covers(link, index) {
+  const start = link.index ?? 0;
+  return index >= start && index < start + link[0].length;
+}
+function is_linked_at(line, index) {
+  for (const link of line.matchAll(MARKDOWN_LINK)) {
+    if (link_covers(link, index)) return true;
+  }
+  return false;
+}
+function lead_token(message, hash_index) {
+  let start = hash_index;
+  while (start > 0 && !REFERENCE_BOUNDARY.test(message.charAt(start - 1))) start -= 1;
+  return message.slice(start, hash_index);
+}
+function repo_prefix(message, hash_index) {
+  const token = lead_token(message, hash_index);
+  return OWNER_REPO.test(token) ? token : "";
+}
+function is_inline_code_at(line, index) {
+  const backticks = line.slice(0, index).split("`").length - 1;
+  return backticks % BACKTICK_PAIR === 1;
+}
+function is_bare_at(line, index) {
+  if (is_linked_at(line, index) || is_inline_code_at(line, index)) return false;
+  return !PR_PREFIX.test(line.slice(0, index));
+}
+function is_glued(line, reference2) {
+  const end = reference2.index + reference2.text.length;
+  if (NUMBER_CONTINUATION.test(line.slice(end, end + CONTINUATION_WIDTH))) return true;
+  return reference2.prefix === "" && GLUED_LEAD.test(lead_token(line, reference2.index));
+}
+function line_references(line) {
+  const references = [];
+  for (const match of line.matchAll(ISSUE_NUMBER)) {
+    const reference2 = { index: match.index, prefix: repo_prefix(line, match.index), text: match[0] };
+    if (!is_glued(line, reference2) && is_bare_at(line, match.index)) references.push(reference2);
+  }
+  return references;
+}
+function collect_line_references(line, found) {
+  for (const reference2 of line_references(line)) found.push(`${reference2.prefix}${reference2.text}`);
+}
+function lines_outside_fences(message) {
+  const lines = [];
+  let is_in_fence = false;
+  for (const line of message.split("\n")) {
+    if (FENCE_MARKER.test(line)) is_in_fence = !is_in_fence;
+    else if (!is_in_fence) lines.push(line);
+  }
+  return lines;
+}
+function prose_lines(message) {
+  return lines_outside_fences(message).filter((line) => !QUOTE_LINE.test(line));
+}
+function bare_references(message) {
+  const found = [];
+  for (const line of prose_lines(message)) collect_line_references(line, found);
+  return [...new Set(found)];
+}
+function has_bare_reference(message) {
+  return bare_references(message).length > 0;
+}
+function reference_link(reference2, default_slug) {
+  const slug = reference2.prefix === "" ? default_slug : reference2.prefix;
+  const number = reference2.text.slice(1);
+  return `[${reference2.prefix}${reference2.text}](${issue_cite.issue_url(slug, number)})`;
+}
+function linkify_line(line, slug) {
+  let result = "";
+  let cursor = 0;
+  for (const reference2 of line_references(line)) {
+    const start = reference2.index - reference2.prefix.length;
+    result += line.slice(cursor, start) + reference_link(reference2, slug);
+    cursor = reference2.index + reference2.text.length;
+  }
+  return result + line.slice(cursor);
+}
+function rewrite_line(line, slug, is_in_fence) {
+  if (is_in_fence || FENCE_MARKER.test(line) || QUOTE_LINE.test(line)) return line;
+  return linkify_line(line, slug);
+}
+function linkify(message, slug) {
+  const out = [];
+  let is_in_fence = false;
+  for (const line of message.split("\n")) {
+    if (FENCE_MARKER.test(line)) is_in_fence = !is_in_fence;
+    out.push(rewrite_line(line, slug, is_in_fence));
+  }
+  return out.join("\n");
+}
+var issue_citation = {
+  bare_references,
+  has_bare_reference,
+  linkify,
+  prose_lines
+};
+
+// scripts/issue/session-cite.ts
+function session_repo() {
+  const url = repo_discovery.read_origin_url(process.cwd());
+  const identity = url === void 0 ? void 0 : repo_origin.parse_origin_url(url);
+  return identity === void 0 ? void 0 : `${identity.owner}/${identity.repo}`;
+}
+function issue(number, title, repo = session_repo()) {
+  return issue_cite.reference(repo, String(number), title);
+}
+function text(message) {
+  const repo = session_repo();
+  return repo === void 0 ? message : issue_citation.linkify(message, repo);
+}
+var session_cite = {
+  issue,
+  session_repo,
+  text
+};
+
+// scripts/lane/lane-state.ts
+import { readdirSync } from "node:fs";
+import path5 from "node:path";
+
+// scripts/lib/figure-format.ts
+var USD_DECIMALS = 4;
+var PERCENT_SCALE = 100;
+var PERCENT_DECIMALS = 1;
+var MINUTE_DECIMALS = 1;
+var CLOCK_WIDTH = 2;
+var CLOCK_PAD = "0";
+function format_usd(usd, decimals = USD_DECIMALS) {
+  return `$${usd.toFixed(decimals)}`;
+}
+function format_tokens(count) {
+  return count.toLocaleString("en-US");
+}
+function format_share(part, whole) {
+  if (whole === 0) return "n/a";
+  return `${(part / whole * PERCENT_SCALE).toFixed(PERCENT_DECIMALS)}%`;
+}
+function format_minutes(duration_ms) {
+  return `${(duration_ms / MS_PER_MINUTE).toFixed(MINUTE_DECIMALS)} min`;
+}
+function two_digits(value) {
+  return String(value).padStart(CLOCK_WIDTH, CLOCK_PAD);
+}
+function clock_of(ms) {
+  const date = new Date(ms);
+  return [date.getHours(), date.getMinutes(), date.getSeconds()].map((value) => two_digits(value)).join(":");
+}
+function minute_of(ms) {
+  const date = new Date(ms);
+  return [date.getHours(), date.getMinutes()].map((value) => two_digits(value)).join(":");
+}
+var figure_format = {
+  format_usd,
+  format_tokens,
+  format_share,
+  format_minutes,
+  two_digits,
+  clock_of,
+  minute_of
+};
+
+// scripts/lane/lane-state-record.ts
+import path4 from "node:path";
+var STATE_SUFFIX = ".json";
+var HUMAN_REVIEW = "human-review";
+var LANE_STATES = ["open", "running", "paused", HUMAN_REVIEW, "ended"];
+var IDLE_STATES = /* @__PURE__ */ new Set(["paused", HUMAN_REVIEW, "ended"]);
+var lane_run_schema = external_exports.object({ started_at: external_exports.string(), owner_pid: external_exports.number().optional() });
+var stuck_schema = external_exports.object({ pid: external_exports.number(), reason: external_exports.string() });
+var lane_state_schema = external_exports.object({
+  issue: external_exports.string(),
+  run: lane_run_schema.optional(),
+  state: external_exports.enum(LANE_STATES),
+  launched_at: external_exports.string().optional(),
+  changed_at: external_exports.string(),
+  changed_by: external_exports.string(),
+  stuck: external_exports.array(stuck_schema).optional()
+});
+function record_name(common, issue2) {
+  return stamp_file.stamp_name(
+    durable_state_root.PREFIX.LANE_STATE,
+    common,
+    `-${issue2}${STATE_SUFFIX}`
+  );
+}
+function read_record_file(source) {
+  const raw = stamp_file.read_stamp_text(source);
+  return raw === void 0 ? void 0 : json_value.parse_with(raw, lane_state_schema);
+}
+function is_idle(state_root, common, issue2) {
+  const record2 = read_record_file(path4.join(state_root, record_name(common, issue2)));
+  return record2 !== void 0 && IDLE_STATES.has(record2.state);
+}
+var lane_state_record = {
+  HUMAN_REVIEW,
+  LANE_STATES,
+  STATE_SUFFIX,
+  is_idle,
+  read_record_file,
+  record_name
+};
+
+// scripts/lane/lane-state.ts
+var LOCK_SUFFIX2 = ".lock";
+var LOCK_WAIT_MS2 = 5e3;
+var { HUMAN_REVIEW: HUMAN_REVIEW2, LANE_STATES: LANE_STATES2, STATE_SUFFIX: STATE_SUFFIX2 } = lane_state_record;
+var NO_STATE_HINT = "no lane state \u2014 counted in use";
+var TRANSITIONS = {
+  open: ["open", "running", HUMAN_REVIEW2, "ended"],
+  running: ["running", "paused", HUMAN_REVIEW2, "ended"],
+  paused: ["paused", "running", "ended"],
+  [HUMAN_REVIEW2]: [HUMAN_REVIEW2, "running", "ended"],
+  ended: ["ended", "open"]
+};
+function state_path(directory, issue2) {
+  return path5.join(
+    durable_state.ensure(durable_state.root()),
+    lane_state_record.record_name(directory, issue2)
+  );
+}
+function is_allowed(from, to) {
+  return from === void 0 || TRANSITIONS[from].includes(to);
+}
+function read_record2(directory, issue2) {
+  return lane_state_record.read_record_file(state_path(directory, issue2));
+}
+function write_record(directory, record2) {
+  stamp_file.replace_stamp(state_path(directory, record2.issue), record2);
+}
+function current_run(directory) {
+  const carried = run_carry.read_carry(run_carry.carry_path(directory));
+  if (carried.kind !== "carried") return void 0;
+  return { started_at: carried.carry.started_at, owner_pid: carried.carry.owner_pid };
+}
+function launch_fields(change, directory, now) {
+  if (change.is_launch !== true) return {};
+  return { run: current_run(directory), launched_at: now.toISOString() };
+}
+function next_record(change, previous, directory, now) {
+  return {
+    // An open starts a fresh life: a reopened lane keeps nothing of the run that launched it before.
+    ...change.state !== "open" && previous,
+    issue: change.issue,
+    state: change.state,
+    changed_at: now.toISOString(),
+    changed_by: change.command,
+    ...launch_fields(change, directory, now)
+  };
+}
+function apply_held(change, directory, now) {
+  const previous = read_record2(directory, change.issue);
+  if (!is_allowed(previous?.state, change.state)) {
+    return { kind: "skipped", reason: `no ${previous?.state ?? ""} \u2192 ${change.state} transition` };
+  }
+  const record2 = next_record(change, previous, directory, now);
+  write_record(directory, record2);
+  return { kind: "written", record: record2 };
+}
+var NO_DIRECTORY = { kind: "skipped", reason: "no git directory" };
+function locked(directory, issue2, held) {
+  const lock = `${state_path(directory, issue2)}${LOCK_SUFFIX2}`;
+  const outcome = repository_lock.with_lock_sync(held, lock, LOCK_WAIT_MS2);
+  return outcome ?? { kind: "skipped", reason: `gave up waiting for the lock at ${lock}` };
+}
+function apply(change, directory, now) {
+  return locked(directory, change.issue, () => apply_held(change, directory, now));
+}
+function warn(change, reason) {
+  console.warn(
+    `${change.command} ${session_cite.issue(change.issue)}: lane state not recorded \u2014 ${reason}`
+  );
+}
+async function resolve_directory(directory) {
+  return directory ?? await run_carry.repository_directory();
+}
+async function outcome_of(change, options) {
+  const directory = await resolve_directory(options.directory);
+  if (directory === void 0) return NO_DIRECTORY;
+  return apply(change, directory, options.now ?? /* @__PURE__ */ new Date());
+}
+async function settled(write2) {
+  try {
+    return await write2();
+  } catch (error) {
+    return { kind: "skipped", reason: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function record_change(change, options = {}) {
+  const outcome = await settled(async () => await outcome_of(change, options));
+  if (outcome.kind === "skipped") warn(change, outcome.reason);
+  return outcome;
+}
+async function read_state(issue2, directory) {
+  const root = await resolve_directory(directory);
+  return root === void 0 ? void 0 : read_record2(root, issue2);
+}
+function recorded_issues(directory) {
+  const empty = state_path(directory, "");
+  const head = path5.basename(empty).slice(0, -STATE_SUFFIX2.length);
+  return readdirSync(path5.dirname(empty)).filter((name) => name.startsWith(head) && name.endsWith(STATE_SUFFIX2)).map((name) => name.slice(head.length, -STATE_SUFFIX2.length)).filter((issue2) => issue2.length > 0);
+}
+async function read_records(directory) {
+  const root = await resolve_directory(directory);
+  if (root === void 0) return [];
+  const records = recorded_issues(root).map((issue2) => read_record2(root, issue2));
+  return records.filter((record2) => record2 !== void 0);
+}
+function stuck_held(issue2, stuck, directory) {
+  const previous = read_record2(directory, issue2);
+  if (previous === void 0) return { kind: "skipped", reason: "no record" };
+  const record2 = { ...previous, stuck };
+  write_record(directory, record2);
+  return { kind: "written", record: record2 };
+}
+async function record_stuck(issue2, stuck, directory) {
+  const root = await resolve_directory(directory);
+  if (root === void 0) return NO_DIRECTORY;
+  return locked(root, issue2, () => stuck_held(issue2, stuck, root));
+}
+function adopted_held(change, directory, now) {
+  if (read_record2(directory, change.issue) !== void 0) {
+    return { kind: "skipped", reason: "a record exists" };
+  }
+  return apply_held(change, directory, now);
+}
+async function adopted_outcome(change, options) {
+  const directory = await resolve_directory(options.directory);
+  if (directory === void 0) return NO_DIRECTORY;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  return locked(directory, change.issue, () => adopted_held(change, directory, now));
+}
+async function record_adopted(change, options = {}) {
+  return await settled(async () => await adopted_outcome(change, options));
+}
+async function read_states(issues, directory) {
+  const root = await resolve_directory(directory);
+  if (root === void 0) return /* @__PURE__ */ new Map();
+  const read3 = issues.map((issue2) => [
+    issue2,
+    read_record2(root, issue2)
+  ]);
+  return new Map(read3.filter((entry) => entry[1] !== void 0));
+}
+function paused_text(since_ms, changed_by) {
+  return `paused since ${figure_format.minute_of(since_ms)} by ${changed_by}`;
+}
+function paused_note(record2) {
+  if (record2?.state !== "paused") return void 0;
+  return paused_text(Date.parse(record2.changed_at), record2.changed_by);
+}
+var lane_state = {
+  LANE_STATES: LANE_STATES2,
+  NO_STATE_HINT,
+  is_allowed,
+  paused_note,
+  paused_text,
+  read_records,
+  read_state,
+  read_states,
+  record_adopted,
+  record_change,
+  record_stuck,
+  state_path
+};
+
+// scripts/run/event/run-event-scope.ts
+var SINCE_SCOPE = "since";
+var UNKNOWN_SCOPE = "unknown";
+var UNKNOWN_EVENT_SCOPE = { kind: UNKNOWN_SCOPE };
+function moment_of(at) {
+  const parsed = Date.parse(at);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function is_within(event, floor) {
+  const at = moment_of(event.at);
+  return at !== void 0 && at >= floor;
+}
+function scoped_events(events, scope) {
+  if (scope.kind === UNKNOWN_SCOPE) return void 0;
+  const floor = moment_of(scope.started_at);
+  if (floor === void 0) return void 0;
+  return events.filter((event) => is_within(event, floor));
+}
+function scope_of(read3) {
+  if (read3.kind !== "carried") return UNKNOWN_EVENT_SCOPE;
+  return { kind: SINCE_SCOPE, started_at: read3.carry.started_at };
+}
+function last_scoped_event(events, scope) {
+  return scoped_events(events, scope)?.findLast(
+    (event) => !run_event_stream.TRACE_KINDS.has(event.kind)
+  );
+}
+var SHIP_POSITION_KINDS = /* @__PURE__ */ new Set([
+  run_event_stream.EVENT_KIND.SHIP_LAUNCH,
+  run_event_stream.EVENT_KIND.SHIP_STOP
+]);
+var KIND = run_event_stream.EVENT_KIND;
+var BATCH_RECORD_KINDS = /* @__PURE__ */ new Set([
+  KIND.CHILD_LAUNCH,
+  KIND.RESTART,
+  KIND.WITHDRAW,
+  KIND.PARK,
+  KIND.HUMAN_REVIEW,
+  KIND.SPLIT,
+  KIND.RETROSPECTIVE,
+  KIND.STRANDED
+]);
+var ISSUE_REFERENCE = /#(\d+)/u;
+function is_foreign_ship_event(event, issue2) {
+  return SHIP_POSITION_KINDS.has(event.kind) && !event.text.startsWith(`${issue_cite.plain_for("program", issue2)} `);
+}
+function is_own_ship_event(event, issue2) {
+  return SHIP_POSITION_KINDS.has(event.kind) && !is_foreign_ship_event(event, issue2);
+}
+function issue_named(event) {
+  return ISSUE_REFERENCE.exec(event.text)?.[1];
+}
+function names_issue(event, issue2) {
+  return issue_named(event) === issue2;
+}
+function is_lane_position(event, issue2) {
+  return !BATCH_RECORD_KINDS.has(event.kind) && names_issue(event, issue2);
+}
+function since_own_launch(events, issue2) {
+  const launch = events.findLastIndex(
+    (event) => event.kind === KIND.CHILD_LAUNCH && names_issue(event, issue2)
+  );
+  return events.slice(launch + 1);
+}
+function is_foreign_event(event, issue2, is_lane_child) {
+  if (is_lane_child) return !is_lane_position(event, issue2);
+  return is_foreign_ship_event(event, issue2);
+}
+function last_issue_event(events, scope, issue2, is_lane_child) {
+  const attempt = is_lane_child ? since_own_launch(events, issue2) : events;
+  const own = attempt.filter((event) => !is_foreign_event(event, issue2, is_lane_child));
+  if (scope.kind === SINCE_SCOPE) return last_scoped_event(own, scope);
+  return own.findLast((event) => is_own_ship_event(event, issue2));
+}
+var LAUNCH_OR_SETTLE_KINDS = /* @__PURE__ */ new Set([
+  KIND.CHILD_LAUNCH,
+  KIND.MERGE,
+  KIND.PARK,
+  KIND.HUMAN_REVIEW,
+  KIND.SPLIT,
+  KIND.WITHDRAW
+]);
+function is_merge_owed(events, scope, issue2) {
+  const newest = (scoped_events(events, scope) ?? []).findLast(
+    (event) => LAUNCH_OR_SETTLE_KINDS.has(event.kind) && names_issue(event, issue2)
+  );
+  return newest?.kind === KIND.CHILD_LAUNCH;
+}
+function is_launch_or_withdrawal(event, issue2) {
+  const is_kind = event.kind === KIND.CHILD_LAUNCH || event.kind === KIND.WITHDRAW;
+  return is_kind && names_issue(event, issue2);
+}
+function is_withdrawn(events, issue2) {
+  const newest = events.findLast((event) => is_launch_or_withdrawal(event, issue2));
+  return newest?.kind === KIND.WITHDRAW;
+}
+var run_event_scope = {
+  UNKNOWN_EVENT_SCOPE,
+  is_merge_owed,
+  is_withdrawn,
+  issue_named,
+  last_issue_event,
+  last_scoped_event,
+  moment_of,
+  scope_of,
+  scoped_events,
+  since_own_launch
+};
+
+// scripts/lane/lane-spans.ts
+function next_start_ms(starts, issue2, from_ms) {
+  const later = starts.filter((other) => other.issue === issue2 && other.at_ms > from_ms);
+  return Math.min(...later.map((other) => other.at_ms));
+}
+function issue_spans(pair) {
+  return pair.starts.map((start) => {
+    const until_ms = next_start_ms(pair.bounds, start.issue, start.at_ms);
+    return {
+      from_ms: start.at_ms,
+      end_ms: pair.ends.find(
+        (end) => end.issue === start.issue && end.at_ms >= start.at_ms && end.at_ms < until_ms
+      )?.at_ms
+    };
+  });
+}
+var lane_spans = { issue_spans };
+
+// scripts/run/board/run-board-lane-time.ts
+var KIND2 = run_event_stream.EVENT_KIND;
+var LAUNCH_KINDS = /* @__PURE__ */ new Set([KIND2.CHILD_LAUNCH, KIND2.RESTART]);
+var OFF_LANE_KINDS = /* @__PURE__ */ new Set([
+  KIND2.MERGE,
+  KIND2.PARK,
+  KIND2.HUMAN_REVIEW,
+  KIND2.WITHDRAW,
+  KIND2.OUTAGE,
+  KIND2.USAGE_LIMIT,
+  KIND2.SPLIT,
+  KIND2.STOP
+]);
+function moments_of(events, kinds) {
+  return events.filter((event) => kinds.has(event.kind)).map((event) => ({
+    issue: Number(run_event_scope.issue_named(event)),
+    at_ms: Date.parse(event.at)
+  }));
+}
+function spans_of(events) {
+  const launches = moments_of(events, LAUNCH_KINDS);
+  const ends = moments_of(events, OFF_LANE_KINDS);
+  const issues = new Set(launches.map((launch) => launch.issue));
+  return new Map(
+    [...issues].map((issue2) => {
+      const starts = launches.filter((launch) => launch.issue === issue2);
+      return [issue2, lane_spans.issue_spans({ starts, bounds: starts, ends })];
+    })
+  );
+}
+function span_ms(span, until_ms, end_ms) {
+  return Math.max(0, Math.min(span.end_ms ?? until_ms, end_ms) - span.from_ms);
+}
+function in_lane_ms(spans, end_ms) {
+  return spans.reduce(
+    (total, span, index) => total + span_ms(span, spans[index + 1]?.from_ms ?? end_ms, end_ms),
+    0
+  );
+}
+function elapsed_of(spans, started_ms, ended_ms) {
+  return spans.length === 0 ? ended_ms - started_ms : in_lane_ms(spans, ended_ms);
+}
+function launched_ms(record2) {
+  const launched_at = record2?.launched_at;
+  return launched_at === void 0 ? void 0 : Date.parse(launched_at);
+}
+function counted_from(run, started_ms) {
+  return run === void 0 ? started_ms : Date.parse(run.started_at);
+}
+function is_ended(spans) {
+  return spans.at(-1)?.end_ms !== void 0;
+}
+function ending_elapsed(read3) {
+  const started_ms = launched_ms(read3.record);
+  if (started_ms === void 0) return void 0;
+  const from_ms = counted_from(read3.record?.run, started_ms);
+  const spans = (spans_of(read3.events).get(read3.issue) ?? []).filter(
+    (span) => span.from_ms >= from_ms
+  );
+  return is_ended(spans) ? void 0 : elapsed_of(spans, started_ms, read3.ended_ms);
+}
+var run_board_lane_time = {
+  LAUNCH_KINDS,
+  OFF_LANE_KINDS,
+  elapsed_of,
+  ending_elapsed,
+  in_lane_ms,
+  spans_of
+};
+
+// scripts/run/event/run-event-stream-emit.ts
+function now_iso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function stream_target() {
+  const repository = await run_carry.repository_directory();
+  return repository === void 0 ? void 0 : run_event_stream.target_of(repository);
+}
+async function lane_record(issue2) {
+  try {
+    return await lane_state.read_state(issue2);
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.lane_record", error);
+    return void 0;
+  }
+}
+async function ending_fields(target2, event) {
+  const issue2 = run_event_scope.issue_named(event);
+  if (issue2 === void 0 || !run_board_lane_time.OFF_LANE_KINDS.has(event.kind)) return {};
+  const elapsed_ms = run_board_lane_time.ending_elapsed({
+    events: run_event_stream.read_events(target2),
+    issue: Number(issue2),
+    record: await lane_record(issue2),
+    ended_ms: Date.parse(event.at)
+  });
+  return elapsed_ms === void 0 ? {} : { elapsed_ms };
+}
+async function append_with(target2, event) {
+  return run_event_stream.append_event(target2, {
+    ...event,
+    ...await ending_fields(target2, event)
+  });
+}
+async function append_at(target2, kind, text2, at) {
+  return await append_with(target2, { kind, text: text2, at: at.toISOString() });
+}
+async function emit(kind, text2, at = /* @__PURE__ */ new Date(), fields = {}) {
+  try {
+    const target2 = await stream_target();
+    if (target2 === void 0) return;
+    await append_with(target2, { ...fields, kind, text: text2, at: at.toISOString() });
+  } catch {
+  }
+}
+async function fresh_target(kind) {
+  const target2 = await stream_target();
+  if (target2 === void 0 || run_event_stream.read_last(target2)?.kind === kind) return void 0;
+  return target2;
+}
+async function emit_once(kind, text2, before_append) {
+  try {
+    const target2 = await fresh_target(kind);
+    if (target2 === void 0) return false;
+    await before_append?.();
+    return run_event_stream.append(target2, kind, text2, now_iso()).appended;
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.emit_once", error);
+    return false;
+  }
+}
+function invocation_events(repository, target2) {
+  const events = run_event_stream.read_events(target2);
+  const scope = run_event_scope.scope_of(run_carry.read_carry(run_carry.carry_path(repository)));
+  return run_event_scope.scoped_events(events, scope) ?? events;
+}
+async function emit_once_since_with(kind, reset_kind, compose) {
+  try {
+    const repository = await run_carry.repository_directory();
+    if (repository === void 0) return void 0;
+    const target2 = run_event_stream.target_of(repository);
+    if (run_event_stream.has_since(invocation_events(repository, target2), kind, reset_kind)) {
+      return void 0;
+    }
+    const text2 = await compose();
+    return run_event_stream.append(target2, kind, text2, now_iso()).appended ? text2 : void 0;
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.emit_once_since", error);
+    return void 0;
+  }
+}
+async function emit_once_since(kind, text2, reset_kind) {
+  const appended = await emit_once_since_with(kind, reset_kind, async () => text2);
+  return appended !== void 0;
+}
+async function emit_heartbeat(line) {
+  await emit(run_event_stream.EVENT_KIND.HEARTBEAT, line);
+}
+function read_current_events(repository, is_required) {
+  if (repository === void 0) throw new Error("Could not resolve the run event stream.");
+  const read3 = run_carry.read_carry(run_carry.carry_path(repository));
+  const scope = run_event_scope.scope_of(read3);
+  const events = run_event_stream.read_events(run_event_stream.target_of(repository), is_required);
+  const scoped = run_event_scope.scoped_events(events, scope);
+  if (scoped === void 0) throw new Error("Could not determine the run event scope.");
+  return scoped;
+}
+async function current_events(is_required = false) {
+  try {
+    return read_current_events(await run_carry.repository_directory(), is_required);
+  } catch (error) {
+    if (is_required) throw error;
+    return [];
+  }
+}
+async function invocation_or_all_events() {
+  try {
+    const repository = await run_carry.repository_directory();
+    return repository === void 0 ? [] : invocation_events(repository, run_event_stream.target_of(repository));
+  } catch {
+    return [];
+  }
+}
+async function all_events() {
+  try {
+    const target2 = await stream_target();
+    return target2 === void 0 ? [] : run_event_stream.read_events(target2);
+  } catch {
+    return [];
+  }
+}
+var run_event_stream_emit = {
+  all_events,
+  append_at,
+  current_events,
+  emit,
+  emit_heartbeat,
+  emit_once,
+  emit_once_since,
+  emit_once_since_with,
+  invocation_or_all_events,
+  stream_target
+};
+
+// scripts/josh/josh-aliases.ts
+var ALIASES = {
+  ga: "gate",
+  l: "lint",
+  lr: "lint:related",
+  lrr: "lint:rule",
+  cr: "check:related",
+  ln: "lines",
+  by: "bytes",
+  mt: "metrics",
+  f: "format",
+  sd: "cspell:dot",
+  bh: "behavior",
+  eu: "exports:unused",
+  t: "test",
+  tu: "test:unit",
+  tr: "test:related",
+  td: "test:declared",
+  trd: "test:red",
+  tpn: "test:pinned",
+  te: "test:e2e",
+  c: "check",
+  pt: "port",
+  i: "init",
+  pf: "profile",
+  st: "start",
+  sy: "sync",
+  un: "uninstall",
+  g: "git",
+  gp: "pr",
+  ms: "main:sync",
+  mm: "main:merge",
+  ckf: "checks:failed",
+  bp: "bump",
+  re: "release",
+  v: "version",
+  r: "ranges",
+  dr: "doctor",
+  rc: "ruleset:check",
+  pg: "propagate",
+  ad: "adopt",
+  ov: "overrides",
+  a: "audit",
+  rt: "reconcile-templates",
+  cdv: "command:derive",
+  u: "latest",
+  lc: "latest:corepack",
+  lu: "latest:update",
+  tm: "time",
+  tmd: "time:density",
+  rtr: "retrospective",
+  ca: "cost:audit",
+  cit: "ci:timing",
+  ghu: "gh:usage",
+  rvf: "review:findings",
+  rvs: "review:stops",
+  ruv: "rule:value",
+  hkl: "hook:ledger",
+  ev: "eval",
+  fr: "fresh:run",
+  as: "auth:setup",
+  lsm: "lane:sample",
+  lst: "lane:stats",
+  lva: "lane:value",
+  lnt: "lane:net",
+  lbd: "lane:breakdown",
+  lwy: "lane:why",
+  lli: "lane:limit",
+  lrs: "lane:restart",
+  lwd: "lane:withdraw",
+  lrv: "lane:resolve",
+  lps: "lane:pause",
+  lru: "lane:resume",
+  lad: "lane:adopt",
+  blr: "backlogrun"
+};
+function canonical_command(name) {
+  if (!Object.hasOwn(ALIASES, name)) return name;
+  return ALIASES[name] ?? name;
+}
+
+// scripts/time-runtime/time-josh-names.ts
+function canonical_name(name) {
+  if (name === "") return "";
+  const [subcommand = "", ...rest] = name.slice(time_shell.JOSH_PREFIX.length).split(" ");
+  return [`${time_shell.JOSH_PREFIX}${canonical_command(subcommand)}`, ...rest].join(" ");
+}
+function josh_command_of2(command) {
+  return canonical_name(time_shell.josh_command_of(command));
+}
+function josh_command_of_segment2(segment) {
+  return canonical_name(time_shell.josh_command_of_segment(segment));
+}
+function josh_commands_of2(command) {
+  return time_shell.josh_commands_of(command).map((name) => canonical_name(name));
+}
+function josh_signatures_of2(command) {
+  return time_shell.josh_signatures_of(command).map((signature) => canonical_name(signature));
+}
+var time_josh_names = {
+  josh_command_of: josh_command_of2,
+  josh_command_of_segment: josh_command_of_segment2,
+  josh_commands_of: josh_commands_of2,
+  josh_signatures_of: josh_signatures_of2
+};
+
+// scripts/agent/agent-model-alias.ts
+var CLAUDE_MODEL_PATTERN = /^claude-(?<family>opus|sonnet|haiku|fable)-/u;
+function alias_of(model) {
+  return CLAUDE_MODEL_PATTERN.exec(model)?.groups?.["family"];
+}
+function suffix_of(model) {
+  const alias = alias_of(model);
+  return alias === void 0 ? "" : ` (${alias})`;
+}
+var agent_model_alias = { alias_of, suffix_of };
+
+// scripts/agent/agent-profile-schema.ts
+var ROLE_SCHEMA = external_exports.enum(["scheduler", "worker", "reviewer"]);
+var EFFORT_SCHEMA = external_exports.enum(["low", "medium", "high", "xhigh", "max"]);
+var PHASE_SCHEMA = external_exports.enum(["implementation", "pre-gate"]);
+var PROFILE_SCHEMA = external_exports.object({
+  provider: agent_provider.PROVIDER_SCHEMA.default("anthropic"),
+  role: ROLE_SCHEMA,
+  model: external_exports.string(),
+  effort: EFFORT_SCHEMA
+});
+var SCHEDULER = "scheduler";
+var WORKER = "worker";
+var REVIEWER = "reviewer";
+var IMPLEMENTATION_PHASE = "implementation";
+var PRE_GATE_PHASE = "pre-gate";
+var OPENAI_MODEL = "gpt-6.1-sol";
+var ANTHROPIC_MODEL = "claude-opus-5-5";
+var REVIEW_EFFORT = "medium";
+var { ANTHROPIC_PROVIDER, OPENAI_PROVIDER } = agent_provider;
+var { is_safe_value: is_safe_value2 } = agent_safe_text;
+function role_profiles(provider, model) {
+  return {
+    scheduler: { provider, role: SCHEDULER, model, effort: "medium" },
+    worker: { provider, role: WORKER, model, effort: "medium" },
+    reviewer: { provider, role: REVIEWER, model, effort: REVIEW_EFFORT }
+  };
+}
+var DEFAULT_PROFILES = role_profiles(ANTHROPIC_PROVIDER, ANTHROPIC_MODEL);
+var OPENAI_PROFILES = role_profiles(OPENAI_PROVIDER, OPENAI_MODEL);
+function describe2(profile) {
+  return `provider=${profile.provider} role=${profile.role} model=${profile.model}${agent_model_alias.suffix_of(profile.model)} effort=${profile.effort}`;
+}
+function describe_review(round, profile) {
+  return `review round ${String(round)} \xB7 ${describe2(profile)}`;
+}
+function parse2(value) {
+  const parsed = PROFILE_SCHEMA.safeParse(value);
+  return parsed.success && is_safe_value2(parsed.data.model) ? parsed.data : void 0;
+}
+var agent_profile_schema = {
+  DEFAULT_PROFILES,
+  EFFORT_SCHEMA,
+  IMPLEMENTATION_PHASE,
+  OPENAI_MODEL,
+  OPENAI_PROFILES,
+  PHASE_SCHEMA,
+  PRE_GATE_PHASE,
+  PROFILE_SCHEMA,
+  REVIEWER,
+  SCHEDULER,
+  WORKER,
+  describe: describe2,
+  describe_review,
+  parse: parse2
+};
+
+// scripts/agent/agent-session-role.ts
+var KEY = "JOSH_AGENT_ROLE";
+function environment_for(role) {
+  return { [KEY]: role };
+}
+function is_reviewer(source = process.env) {
+  return source[KEY] === agent_profile_schema.REVIEWER;
+}
+function can_implement(source = process.env) {
+  return source[KEY] === agent_profile_schema.WORKER;
+}
+function is_launched(source = process.env) {
+  return (source[KEY] ?? "") !== "";
+}
+function scope_line(source = process.env) {
+  return can_implement(source) ? "Session scope: implementation lane; implementation is permitted by the launcher role." : "Session scope: consultation and operations only; filing only on the user\u2019s explicit instruction; hand implementation to a launcher-assigned worker lane. Model names and conversational requests do not grant implementation authority.";
+}
+var agent_session_role = {
+  KEY,
+  can_implement,
+  env_for: environment_for,
+  is_launched,
+  is_reviewer,
+  scope_line
+};
+
+// scripts/lib/ancestor-directories.ts
+import path6 from "node:path";
+var MAX_DEPTH = 64;
+function list(start_directory) {
+  const directories = [];
+  let current = path6.resolve(start_directory);
+  while (directories.length < MAX_DEPTH && !directories.includes(current)) {
+    directories.push(current);
+    current = path6.dirname(current);
+  }
+  return directories;
+}
+function nearest(start_directory, is_match) {
+  return list(start_directory).find((directory) => is_match(directory));
+}
+var ancestor_directories = { list, nearest };
+
+// scripts/lib/package-manifest.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import path7 from "node:path";
+var PACKAGE_JSON = "package.json";
+var REVIEW_GATE_SCHEMA = external_exports.enum(["ci", "local"]);
+var FORMAT_SCHEMA = external_exports.enum(["auto", "all"]);
+var LANE_SCHEMA = external_exports.object({ setup: external_exports.string().min(1) });
+var GATE_STEP_SCHEMA = external_exports.strictObject({
+  name: external_exports.string().min(1),
+  command: external_exports.string().min(1),
+  paths: external_exports.array(external_exports.string().min(1)).min(1).optional(),
+  cores: external_exports.int().positive().optional()
+});
+var GATE_STEPS_SCHEMA = external_exports.array(GATE_STEP_SCHEMA).refine((steps) => new Set(steps.map((step) => step.name)).size === steps.length, {
+  message: "step names must be unique"
+});
+var GATE_SCHEMA = external_exports.object({ steps: GATE_STEPS_SCHEMA.optional() });
+var josh_schemas = {
+  format: external_exports.object({ josh: external_exports.object({ format: FORMAT_SCHEMA.optional() }).optional() }),
+  gate_steps: external_exports.object({ josh: external_exports.object({ gate: GATE_SCHEMA.optional() }).optional() }),
+  lane_setup: external_exports.object({ josh: external_exports.object({ lane: LANE_SCHEMA.optional() }).optional() }),
+  progress_interval_minutes: external_exports.object({
+    josh: external_exports.object({ progress_interval_minutes: external_exports.number().positive() }).optional()
+  }),
+  review_gate: external_exports.object({ josh: external_exports.object({ review_gate: REVIEW_GATE_SCHEMA }).optional() })
+};
+function manifest_path(directory) {
+  return path7.join(directory, PACKAGE_JSON);
+}
+function read_manifest(directory, schema) {
+  const text2 = readFileSync2(manifest_path(directory), "utf8");
+  return schema.parse(JSON.parse(text2));
+}
+function read_manifest_if_valid(directory, schema) {
+  const text2 = file_reader.read_if_readable(manifest_path(directory));
+  if (text2 === void 0) return void 0;
+  return json_value.parse_with(text2, schema);
+}
+function read_nearest_value(start, schema, select) {
+  const value_schema = schema.transform(select);
+  for (const directory of ancestor_directories.list(start)) {
+    const value = read_manifest_if_valid(directory, value_schema);
+    if (value !== void 0) return value;
+  }
+  return void 0;
+}
+var package_manifest = {
+  josh_schemas,
+  manifest_path,
+  read_manifest,
+  read_manifest_if_valid,
+  read_nearest_value
+};
+
+// scripts/josh/package-directory.ts
+import { existsSync as existsSync2 } from "node:fs";
+function find_package_directory(start_directory) {
+  return ancestor_directories.nearest(
+    start_directory,
+    (directory) => existsSync2(package_manifest.manifest_path(directory))
+  ) ?? start_directory;
+}
+
+// scripts/git/git-schemas.ts
+var package_name_schema = external_exports.object({ name: external_exports.string().min(1) });
+var rollup_item_schema = external_exports.looseObject({
+  // eslint-disable-next-line @typescript-eslint/naming-convention -- GraphQL field name from GitHub API
+  __typename: external_exports.string().nullish(),
+  state: external_exports.string().nullish(),
+  status: external_exports.string().nullish(),
+  conclusion: external_exports.string().nullish(),
+  name: external_exports.string().nullish(),
+  context: external_exports.string().nullish(),
+  description: external_exports.string().nullish()
+});
+var pr_raw_schema = external_exports.object({
+  statusCheckRollup: external_exports.array(rollup_item_schema).optional(),
+  // The base branch's required status check contexts, read from its rules — empty where none are
+  // set or they could not be read (`git-gh-branch-rules.ts`).
+  requiredContexts: external_exports.array(external_exports.string()).optional(),
+  mergeStateStatus: external_exports.string().optional(),
+  reviewDecision: external_exports.string().optional(),
+  headRefOid: external_exports.string().optional(),
+  merged: external_exports.boolean().optional()
+});
+var pull_comment_schema = external_exports.object({
+  body: external_exports.string().optional(),
+  html_url: external_exports.string().optional(),
+  user: external_exports.object({ login: external_exports.string().optional() }).optional()
+});
+var ai_review_pull_comment_schema = external_exports.object({
+  body: external_exports.string().optional(),
+  url: external_exports.string().optional(),
+  author: external_exports.object({ login: external_exports.string().optional() }).optional(),
+  updatedAt: external_exports.string().optional()
+});
+var pr_info_schema = external_exports.object({
+  mergeable: external_exports.union([external_exports.boolean(), external_exports.string()]).nullable().optional(),
+  mergeStateStatus: external_exports.string().nullable().optional(),
+  state: external_exports.string().optional()
+});
+var epic_issue_schema = external_exports.object({
+  number: external_exports.number(),
+  body: external_exports.string().optional(),
+  // REST answers null for an issue never closed and `reopened` for one a person reopened.
+  stateReason: external_exports.string().nullish()
+});
+var blocking_issue_schema = external_exports.object({
+  number: external_exports.number(),
+  state: external_exports.string().optional(),
+  repository_url: external_exports.string().optional()
+});
+var blocked_by_schema = external_exports.object({
+  nodes: external_exports.array(blocking_issue_schema).default([]),
+  totalCount: external_exports.number().optional()
+}).optional();
+var epic_child_schema = external_exports.object({
+  state: external_exports.string().optional(),
+  blockedBy: blocked_by_schema
+});
+var rest_comment_schema = external_exports.looseObject({
+  body: external_exports.string().nullish(),
+  html_url: external_exports.string().optional(),
+  user: external_exports.looseObject({ login: external_exports.string().optional() }).nullish(),
+  updated_at: external_exports.string().optional()
+});
+var issue_label_schema = external_exports.object({ name: external_exports.string() });
+var epic_subject_schema = external_exports.object({
+  number: external_exports.number(),
+  state: external_exports.string().optional(),
+  labels: external_exports.array(issue_label_schema).optional(),
+  body: external_exports.string().optional()
+});
+var author_fields_schema = {
+  author_association: external_exports.string().nullish(),
+  user: external_exports.looseObject({ login: external_exports.string() }).nullish()
+};
+var open_issue_schema = external_exports.object({
+  number: external_exports.number(),
+  title: external_exports.string(),
+  labels: external_exports.array(issue_label_schema).optional(),
+  createdAt: external_exports.string(),
+  blockedBy: blocked_by_schema,
+  // Present only on the pickup listing, which reads it for the paths each issue declares.
+  body: external_exports.string().optional(),
+  ...author_fields_schema,
+  // Assembled by the pickup from the author above, never read off the listing: whether the author
+  // has write access. Absent on every other listing.
+  author_trusted: external_exports.boolean().optional()
+});
+
+export {
+  agent_safe_text,
+  issue_cite,
+  shell_quote,
+  run_ship_stage,
+  change_base,
+  changed_paths,
+  review_stop_log,
+  lane_child_invocation,
+  process_tools,
+  lane_reap,
+  transcript_tail,
+  PORT_SEED_KEY,
+  LANE_SEAT_KEY,
+  ENV_FILE_NAME,
+  ports,
+  OPTIONAL_ENV_FILE_FLAGS,
+  GATE_COMMAND,
+  ESLINT_RELATED_CACHE_FILE,
+  ESLINT_EDIT_CACHE_FLAGS,
+  ESLINT_RELATED_CACHE_FLAGS,
+  PRETTIER_RELATED_CACHE_FLAGS,
+  LINT_RULE_WORKERS,
+  josh_environment_file,
+  transcript_record,
+  cost_blocks,
+  canonical_command,
+  time_shell,
+  figure_format,
+  pr_raw_schema,
+  epic_issue_schema,
+  blocking_issue_schema,
+  blocked_by_schema,
+  rest_comment_schema,
+  issue_label_schema,
+  author_fields_schema,
+  open_issue_schema,
+  process_owner_schema,
+  PR_POLL_SCHEDULES,
+  poll,
+  repository_lock,
+  run_event_stream,
+  issue_citation,
+  session_cite,
+  lane_state_record,
+  lane_state,
+  lane_spans,
+  run_event_scope,
+  run_event_stream_emit,
+  time_josh_names,
+  agent_profile_schema,
+  agent_session_role,
+  ancestor_directories,
+  PACKAGE_JSON,
+  package_manifest,
+  find_package_directory,
+  session_language
+};