@joshuafolkken/kit 1.1784.0 → 1.2116.0

package/dist/hooks/chunk-YCDOIR3I.js

@@ -1,3456 +0,0 @@
-import {
-  ENV_FILE_NAME,
-  LANE_SEAT_KEY,
-  PORCELAIN_FLAG,
-  PORT_SEED_KEY,
-  agent_session_environment,
-  blocking_issue_schema,
-  file_reader,
-  git_command,
-  git_spawn,
-  has_timed_out,
-  issue_cite,
-  issue_number_shape,
-  json_value,
-  lane_paths,
-  ports,
-  process_identity,
-  repo_discovery,
-  repository_lock,
-  rest_comment_schema,
-  run_carry,
-  run_ship_stage,
-  session_cite
-} from "./chunk-WR2KQAYZ.js";
-import {
-  COMMAND_TIMEOUT_MS,
-  INSTALL_TIMEOUT_MS,
-  PLATFORM_TEMP_ROOT,
-  PROBE_TIMEOUT_MS,
-  PROJECT_ROOT,
-  SUITE_TIMEOUT_MS,
-  error_text,
-  stamp_file
-} from "./chunk-AZX4FGQ3.js";
-
-// scripts/josh/josh-environment-file.ts
-function load_environment_file() {
-  try {
-    process.loadEnvFile(ENV_FILE_NAME);
-  } catch {
-  }
-}
-var josh_environment_file = {
-  load_environment_file
-};
-
-// scripts/lane/lane-child-marker.ts
-var KEY = "JOSH_LANE_CHILD";
-var CACHE_TTL_KEY = "CLAUDE_CODE_PROMPT_CACHE_TTL";
-var CACHE_TTL = "5m";
-function environment_for(issue) {
-  issue_number_shape.require_issue_number(issue);
-  return { [KEY]: issue, [CACHE_TTL_KEY]: CACHE_TTL };
-}
-function marked_issue(source = process.env) {
-  const value = source[KEY];
-  if (value === void 0) return void 0;
-  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(value) ? value : void 0;
-}
-function is_child_of(directory, source = process.env) {
-  const marked = marked_issue(source);
-  return marked !== void 0 && marked === lane_paths.lane_issue_of(directory, { ...source });
-}
-var lane_child_marker = {
-  KEY,
-  env_for: environment_for,
-  is_child_of,
-  marked_issue
-};
-
-// scripts/josh/stamp-record.ts
-var NONE_READ = { kind: "none" };
-var UNREADABLE_READ = { kind: "unreadable" };
-function is_older_than(iso, max_age_ms, now) {
-  const at = Date.parse(iso);
-  if (Number.isNaN(at)) return true;
-  return now.getTime() - at > max_age_ms;
-}
-function classify(raw, spec, now) {
-  if (raw === void 0) return NONE_READ;
-  const record = spec.parse(raw);
-  if (record === void 0) return UNREADABLE_READ;
-  const is_expired2 = is_older_than(spec.timestamp_of(record), spec.max_age_ms, now);
-  return { kind: is_expired2 ? "expired" : "carried", record };
-}
-var stamp_record = { classify, is_older_than };
-
-// scripts/run/hold/run-hold.ts
-import { z } from "zod";
-var HOLD_PREFIX = "josh-run-hold-";
-var UNNUMBERED_ISSUE = "new";
-var HOLD_MAX_AGE_HOURS = 8;
-var MILLISECONDS_PER_HOUR = 36e5;
-var HOLD_MAX_AGE_MS = HOLD_MAX_AGE_HOURS * MILLISECONDS_PER_HOUR;
-var RELEASE_COMMAND = "pnpm josh run:release";
-var FORCE_RELEASE_COMMAND = `${RELEASE_COMMAND} --force`;
-var NOT_IDLE = 'that is not "nothing is running here"';
-var FREE_READ = { kind: "free" };
-var UNREADABLE_READ2 = { kind: "unreadable" };
-function hold_path(git_directory) {
-  return stamp_file.stamp_path(HOLD_PREFIX, git_directory);
-}
-async function worktree_directory() {
-  const directories = await git_command.git_directories();
-  return directories[0];
-}
-async function is_linked_worktree() {
-  const directories = await git_command.git_directories();
-  return directories[0] !== void 0 && directories[0] !== directories[1];
-}
-var run_hold_schema = z.object({
-  issue: z.string(),
-  taken_at: z.string(),
-  pid: z.number(),
-  is_fullrun: z.boolean().optional(),
-  is_halfrun_stop: z.boolean().optional(),
-  prrun_stop_head: z.string().optional(),
-  owner_pid: z.number().optional(),
-  owner_start: z.string().optional(),
-  notified_at: z.string().optional()
-});
-function parse_hold(raw) {
-  return json_value.parse_with(raw, run_hold_schema);
-}
-function is_expired(hold, now) {
-  return stamp_record.is_older_than(hold.taken_at, HOLD_MAX_AGE_MS, now);
-}
-function is_stop_marked(hold) {
-  return hold.is_halfrun_stop === true || hold.prrun_stop_head !== void 0;
-}
-function is_owner_gone(hold) {
-  if (is_stop_marked(hold) || hold.owner_pid === void 0) return false;
-  return process_identity.is_same_process(hold.owner_pid, hold.owner_start) === false;
-}
-function is_stale(hold, now) {
-  return is_expired(hold, now) || is_owner_gone(hold);
-}
-function classify2(raw, now) {
-  if (raw === void 0) return FREE_READ;
-  const hold = parse_hold(raw);
-  if (hold === void 0) return UNREADABLE_READ2;
-  return { kind: is_stale(hold, now) ? "stale" : "held", hold };
-}
-function read_hold(target, now = /* @__PURE__ */ new Date()) {
-  return classify2(stamp_file.read_stamp_text(target), now);
-}
-function session_owner(environment3 = process.env) {
-  const pid = Number(environment3[agent_session_environment.AGENT_PID_KEY]);
-  if (!Number.isSafeInteger(pid) || pid <= 0) return {};
-  return { owner_pid: pid, owner_start: process_identity.read_start(pid) };
-}
-function build_hold(issue, now, is_fullrun) {
-  return { issue, taken_at: now.toISOString(), pid: process.pid, is_fullrun, ...session_owner() };
-}
-function write_hold(target, issue, now = /* @__PURE__ */ new Date()) {
-  const hold = build_hold(issue, now);
-  stamp_file.write_stamp(target, hold);
-  return hold;
-}
-function create_hold(target, issue, now = /* @__PURE__ */ new Date(), is_fullrun) {
-  return stamp_file.create_stamp(target, build_hold(issue, now, is_fullrun));
-}
-var HALFRUN_STOP_FIELDS = { is_halfrun_stop: true };
-function create_stop_hold(target, issue, mark, now = /* @__PURE__ */ new Date()) {
-  return stamp_file.create_stamp(target, { ...build_hold(issue, now), ...mark });
-}
-function create_halfrun_stop_hold(target, issue, now = /* @__PURE__ */ new Date()) {
-  return create_stop_hold(target, issue, HALFRUN_STOP_FIELDS, now);
-}
-async function is_tree_dirty(directory) {
-  try {
-    const status = await git_command.status(directory);
-    return status.trim() !== "";
-  } catch (error) {
-    error_text.trace_swallowed("run_hold.is_tree_dirty", error);
-    return true;
-  }
-}
-function release_hold(target) {
-  stamp_file.remove_stamp(target);
-}
-function describe_holder(hold) {
-  const holder = hold.issue === UNNUMBERED_ISSUE ? "an unnumbered run" : session_cite.issue(hold.issue);
-  return `${holder}, recorded ${hold.taken_at} (pid ${String(hold.owner_pid ?? hold.pid)})`;
-}
-function own_release_command(issue) {
-  return issue === UNNUMBERED_ISSUE ? RELEASE_COMMAND : `${RELEASE_COMMAND} ${issue}`;
-}
-function is_own_hold(hold, claimant) {
-  return hold.issue === claimant;
-}
-function is_reentry(hold, claimant) {
-  return claimant !== UNNUMBERED_ISSUE && is_own_hold(hold, claimant);
-}
-function held_message(hold) {
-  return `This working tree is already held by ${describe_holder(hold)}. One run at a time per working tree: a second run here commits its files onto the other run's branch. If that record is stale, run \`${FORCE_RELEASE_COMMAND}\` in this working tree \u2014 it removes a record this run did not write, so be sure the run that did has ended \u2014 and ask again.`;
-}
-function foreign_release_message(hold) {
-  return `This working tree is held by ${describe_holder(hold)}, and this release did not claim it \u2014 nothing was removed. Release it as that run with \`${own_release_command(hold.issue)}\`, or, once you are sure it has ended, remove the record with \`${FORCE_RELEASE_COMMAND}\`.`;
-}
-function forced_release_message(hold) {
-  return `Forced: removed the run record held by ${describe_holder(hold)}.`;
-}
-function unreadable_message() {
-  return `This working tree's run record could not be read \u2014 ${NOT_IDLE}. Run \`${FORCE_RELEASE_COMMAND}\` in this working tree to clear it, then ask again.`;
-}
-function stale_message(hold) {
-  const why = is_owner_gone(hold) ? "the session that wrote it has ended" : `older than ${String(HOLD_MAX_AGE_HOURS)} hours`;
-  return `Replaced a stale run record held by ${describe_holder(hold)}: ${why}, so the run that wrote it has ended without releasing it.`;
-}
-function uncommitted_message(hold) {
-  return `This working tree still has uncommitted changes, and its run record \u2014 held by ${describe_holder(hold)} \u2014 has expired or outlived its session. That is a run which stopped for a person rather than one that finished, so the tree is not free: commit or stash the work, or run \`${own_release_command(hold.issue)}\` once you are done with it, then ask again.`;
-}
-function race_message(read, target) {
-  if (read.kind === "held") return held_message(read.hold);
-  return `A record already exists at ${target} and this run did not write it \u2014 ${NOT_IDLE}. Either another run claimed the tree at the same moment, or the record belongs to another account. Run \`${FORCE_RELEASE_COMMAND}\`, and remove that file by hand if it is still there.`;
-}
-function unknown_message() {
-  return `Could not read this working tree's git directory \u2014 ${NOT_IDLE}. Run this from inside the checkout the run will edit.`;
-}
-var run_hold = {
-  is_stop_marked,
-  FORCE_RELEASE_COMMAND,
-  HOLD_MAX_AGE_HOURS,
-  HOLD_MAX_AGE_MS,
-  RELEASE_COMMAND,
-  UNNUMBERED_ISSUE,
-  classify: classify2,
-  create_halfrun_stop_hold,
-  create_stop_hold,
-  HALFRUN_STOP_FIELDS,
-  create_hold,
-  foreign_release_message,
-  forced_release_message,
-  held_message,
-  hold_path,
-  is_linked_worktree,
-  is_own_hold,
-  is_reentry,
-  is_tree_dirty,
-  own_release_command,
-  race_message,
-  read_hold,
-  release_hold,
-  session_owner,
-  stale_message,
-  uncommitted_message,
-  unknown_message,
-  unreadable_message,
-  worktree_directory,
-  write_hold
-};
-
-// scripts/agent/agent-headless.ts
-var KEY2 = "JOSH_AGENT_HEADLESS";
-var VALUE = "1";
-function environment() {
-  return { [KEY2]: VALUE };
-}
-function is_headless(source = process.env) {
-  return source[KEY2] === VALUE;
-}
-var agent_headless = { KEY: KEY2, environment, is_headless };
-
-// 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/lane/lane-reap.ts
-import { execFileSync } from "node:child_process";
-
-// scripts/agent/agent-role-profile.ts
-import { z as z2 } from "zod";
-
-// 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 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_allowed) {
-  return is_control_character(character) && !is_allowed(character);
-}
-function is_safe_text(value, is_allowed) {
-  if (value.length === EMPTY_LENGTH || value.length > MAX_VALUE_LENGTH) return false;
-  for (const character of value) if (is_refused(character, is_allowed)) return false;
-  return true;
-}
-function is_safe_value(value) {
-  return is_safe_text(value, is_never_allowed);
-}
-function is_safe_prompt(value) {
-  return is_safe_text(value, is_line_feed);
-}
-function printable_character(character) {
-  return is_refused(character, is_line_feed) ? SPACE : character;
-}
-function printable(text) {
-  return Array.from(text, printable_character).join("");
-}
-var agent_safe_text = { MAX_VALUE_LENGTH, is_safe_prompt, is_safe_value, printable };
-
-// scripts/agent/agent-role-profile.ts
-var EMPTY_LENGTH2 = 0;
-var ROLE_SCHEMA = z2.enum(["scheduler", "worker", "reviewer"]);
-var PROVIDER_SCHEMA = z2.enum(["anthropic", "openai"]);
-var EFFORT_SCHEMA = z2.enum(["low", "medium", "high", "xhigh", "max"]);
-var PHASE_SCHEMA = z2.enum(["implementation", "pre-gate"]);
-var PROFILE_SCHEMA = z2.object({
-  provider: PROVIDER_SCHEMA.default("anthropic"),
-  role: ROLE_SCHEMA,
-  model: z2.string(),
-  effort: EFFORT_SCHEMA
-});
-var SCHEDULER = "scheduler";
-var WORKER = "worker";
-var REVIEWER = "reviewer";
-var IMPLEMENTATION_PHASE = "implementation";
-var PRE_GATE_PHASE = "pre-gate";
-var ANTHROPIC_PROVIDER = "anthropic";
-var OPENAI_PROVIDER = "openai";
-var OPENAI_MODEL = "gpt-6.1-sol";
-var ANTHROPIC_MODEL = "claude-opus-5-5";
-var CODEX_SESSION_KEY = "CODEX_THREAD_ID";
-var DEFAULT_PROFILES = {
-  scheduler: {
-    provider: ANTHROPIC_PROVIDER,
-    role: SCHEDULER,
-    model: ANTHROPIC_MODEL,
-    effort: "medium"
-  },
-  worker: { provider: ANTHROPIC_PROVIDER, role: WORKER, model: ANTHROPIC_MODEL, effort: "medium" },
-  reviewer: {
-    provider: ANTHROPIC_PROVIDER,
-    role: REVIEWER,
-    model: ANTHROPIC_MODEL,
-    effort: "high"
-  }
-};
-var OPENAI_PROFILES = {
-  scheduler: { provider: OPENAI_PROVIDER, role: SCHEDULER, model: OPENAI_MODEL, effort: "medium" },
-  worker: { provider: OPENAI_PROVIDER, role: WORKER, model: OPENAI_MODEL, effort: "medium" },
-  reviewer: { provider: OPENAI_PROVIDER, role: REVIEWER, model: OPENAI_MODEL, effort: "high" }
-};
-var PROVIDER_PROFILES = { anthropic: DEFAULT_PROFILES, openai: OPENAI_PROFILES };
-var FIRST_REVIEW_ROUND = 1;
-var VERIFICATION_MODEL = "claude-sonnet-5-5";
-var VERIFICATION_PROFILES = {
-  anthropic: { ...DEFAULT_PROFILES.reviewer, model: VERIFICATION_MODEL },
-  openai: OPENAI_PROFILES.reviewer
-};
-var VERIFICATION_KEYS = {
-  model: "JOSH_REVIEWER_VERIFICATION_MODEL",
-  effort: "JOSH_REVIEWER_VERIFICATION_EFFORT"
-};
-var SHIP_EFFORT = "low";
-var PHASE_EFFORT = {
-  worker: { [PRE_GATE_PHASE]: SHIP_EFFORT }
-};
-var ENV_KEYS = {
-  scheduler: { model: "JOSH_SCHEDULER_MODEL", effort: "JOSH_SCHEDULER_EFFORT" },
-  worker: { model: "JOSH_WORKER_MODEL", effort: "JOSH_WORKER_EFFORT" },
-  reviewer: { model: "JOSH_REVIEWER_MODEL", effort: "JOSH_REVIEWER_EFFORT" }
-};
-var LEGACY_WORKER_KEYS = { model: "JOSH_LANE_MODEL", effort: "JOSH_LANE_EFFORT" };
-var { MAX_VALUE_LENGTH: MAX_VALUE_LENGTH2, is_safe_prompt: is_safe_prompt2, is_safe_value: is_safe_value2, printable: printable2 } = agent_safe_text;
-function trimmed(value) {
-  const result = value?.trim();
-  return result === void 0 || result.length === EMPTY_LENGTH2 ? void 0 : result;
-}
-function is_verification(role, round) {
-  return role === REVIEWER && round !== void 0 && round > FIRST_REVIEW_ROUND;
-}
-function override_keys(role, field, round) {
-  const key = ENV_KEYS[role][field];
-  if (role === WORKER) return [key, LEGACY_WORKER_KEYS[field]];
-  return is_verification(role, round) ? [VERIFICATION_KEYS[field], key] : [key];
-}
-function override_value(role, field, environment3, round) {
-  const keys = override_keys(role, field, round);
-  const key = keys.find((candidate) => trimmed(environment3[candidate]) !== void 0);
-  return key === void 0 ? { key: keys[0], value: void 0 } : { key, value: trimmed(environment3[key]) };
-}
-function model_override(role, environment3, provider, round) {
-  return provider === OPENAI_PROVIDER ? { key: ENV_KEYS[role].model, value: void 0 } : override_value(role, "model", environment3, round);
-}
-function rejection(key, value, expected) {
-  return { kind: "rejected", note: `${key}=${value} ${expected}, so the agent was not started` };
-}
-function resolved_effort(override, fallback) {
-  const parsed = EFFORT_SCHEMA.safeParse(override.value ?? fallback);
-  return parsed.success ? { kind: "effort", effort: parsed.data } : rejection(override.key, override.value ?? "", "is not an allowed effort");
-}
-function has_session(environment3, keys) {
-  return keys.some((key) => trimmed(environment3[key]) !== void 0);
-}
-var CONFLICTING_SESSIONS = {
-  kind: "rejected",
-  note: "both Codex and Claude Code sessions were detected"
-};
-var HANDED_PROVIDER_KEY = "JOSH_AGENT_PROVIDER";
-var DEFAULT_PROVIDER = {
-  kind: "provider",
-  provider: ANTHROPIC_PROVIDER,
-  is_default: true
-};
-var DEFAULT_NOTICE = ` No agent session or ${HANDED_PROVIDER_KEY} was found, so the provider defaulted to ${ANTHROPIC_PROVIDER} (Claude Code).`;
-function handed_provider(environment3) {
-  const value = trimmed(environment3[HANDED_PROVIDER_KEY]);
-  if (value === void 0) return DEFAULT_PROVIDER;
-  const parsed = PROVIDER_SCHEMA.safeParse(value);
-  return parsed.success ? { kind: "provider", provider: parsed.data } : rejection(HANDED_PROVIDER_KEY, value, "is not an allowed provider");
-}
-function detected_provider(environment3) {
-  const has_codex = has_session(environment3, [CODEX_SESSION_KEY]);
-  const has_claude = has_session(environment3, agent_session_environment.PARENT_SESSION_KEYS);
-  if (has_codex === has_claude) return has_codex ? CONFLICTING_SESSIONS : void 0;
-  return { kind: "provider", provider: has_codex ? OPENAI_PROVIDER : ANTHROPIC_PROVIDER };
-}
-function resolve_provider(environment3 = process.env) {
-  return detected_provider(environment3) ?? handed_provider(environment3);
-}
-function default_notice(environment3 = process.env) {
-  const selected = resolve_provider(environment3);
-  return selected.kind === "provider" && selected.is_default === true ? DEFAULT_NOTICE : "";
-}
-function warn_of_default(environment3 = process.env) {
-  const notice = default_notice(environment3).trim();
-  if (notice !== "") console.error(notice);
-}
-function has_completion_callback(environment3 = process.env) {
-  const selected = resolve_provider(environment3);
-  return selected.kind !== "provider" || selected.provider !== OPENAI_PROVIDER;
-}
-function handoff_environment(environment3 = process.env) {
-  const selected = resolve_provider(environment3);
-  return selected.kind === "provider" ? { [HANDED_PROVIDER_KEY]: selected.provider } : {};
-}
-function validate(profile, model_key) {
-  if (!is_safe_value2(profile.model)) {
-    return rejection(model_key, profile.model, "is not a safe model");
-  }
-  return { kind: "profile", profile };
-}
-function phase_effort(role, phase, fallback) {
-  const parsed = PHASE_SCHEMA.safeParse(phase);
-  if (!parsed.success) return fallback;
-  return PHASE_EFFORT[role]?.[parsed.data] ?? fallback;
-}
-function overridden_effort(profile, phase, environment3) {
-  const parsed = EFFORT_SCHEMA.safeParse(override_value(profile.role, "effort", environment3).value);
-  return parsed.success ? parsed.data : phase_effort(profile.role, phase, profile.effort);
-}
-function with_phase_effort(profile, phase, environment3 = process.env) {
-  return { ...profile, effort: overridden_effort(profile, phase, environment3) };
-}
-function stage_defaults(provider, role, round) {
-  return is_verification(role, round) ? VERIFICATION_PROFILES[provider] : PROVIDER_PROFILES[provider][role];
-}
-function resolve_stage(role, environment3, stage) {
-  const selected = resolve_provider(environment3);
-  if (selected.kind === "rejected") return selected;
-  const defaults = stage_defaults(selected.provider, role, stage.round);
-  const model = model_override(role, environment3, selected.provider, stage.round);
-  const effort = override_value(role, "effort", environment3, stage.round);
-  const resolved = resolved_effort(effort, phase_effort(role, stage.phase, defaults.effort));
-  if (resolved.kind === "rejected") return resolved;
-  const profile = {
-    provider: selected.provider,
-    role,
-    model: model.value ?? defaults.model,
-    effort: resolved.effort
-  };
-  return validate(profile, model.key);
-}
-function resolve(role, environment3 = process.env, phase) {
-  return resolve_stage(role, environment3, { phase });
-}
-function resolve_review(round, environment3 = process.env) {
-  return resolve_stage(REVIEWER, environment3, { round });
-}
-function describe(profile) {
-  return `provider=${profile.provider} role=${profile.role} model=${profile.model} effort=${profile.effort}`;
-}
-function describe_review(round, profile) {
-  return `review round ${String(round)} \xB7 ${describe(profile)}`;
-}
-function parse(value) {
-  const parsed = PROFILE_SCHEMA.safeParse(value);
-  return parsed.success && is_safe_value2(parsed.data.model) ? parsed.data : void 0;
-}
-var agent_role_profile = {
-  CODEX_SESSION_KEY,
-  DEFAULT_PROFILES,
-  HANDED_PROVIDER_KEY,
-  IMPLEMENTATION_PHASE,
-  MAX_VALUE_LENGTH: MAX_VALUE_LENGTH2,
-  OPENAI_PROFILES,
-  PRE_GATE_PHASE,
-  PROFILE_SCHEMA,
-  REVIEWER,
-  SCHEDULER,
-  VERIFICATION_PROFILES,
-  WORKER,
-  default_notice,
-  describe,
-  describe_review,
-  handoff_environment,
-  has_completion_callback,
-  is_safe_prompt: is_safe_prompt2,
-  is_safe_value: is_safe_value2,
-  parse,
-  printable: printable2,
-  resolve,
-  resolve_provider,
-  resolve_review,
-  warn_of_default,
-  with_phase_effort
-};
-
-// scripts/run/ship/run-ship-next.ts
-var { STAGE } = run_ship_stage;
-var COMMAND = {
-  LOG: "pnpm josh ship --log",
-  DETACH: "pnpm josh ship --detach",
-  DETACH_REVIEW: "pnpm josh ship --detach --review"
-};
-var ESCAPED_QUOTE = String.raw`'\''`;
-var BARE_WORD = /^[\w%+,./:=@-]+$/u;
-function quoted(title) {
-  return `'${title.split("'").join(ESCAPED_QUOTE)}'`;
-}
-function shell_word(token) {
-  return BARE_WORD.test(token) ? token : quoted(token);
-}
-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
-  };
-}
-function ship_command(command, resume) {
-  const words = [...resume.flags, resume.title].map((token) => shell_word(token));
-  return [command, ...words].join(" ");
-}
-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 ? COMMAND.DETACH_REVIEW : COMMAND.DETACH;
-  return `leave the fix uncommitted and run \`${ship_command(command, resume)}\`.`;
-}
-var AFTER_FIX = {
-  [STAGE.PREFLIGHT]: detach_as_started,
-  [STAGE.REVIEW]: detach_as_started,
-  [STAGE.GATE]: detach_as_started,
-  [STAGE.SYNC]: detach_as_started,
-  [STAGE.COMMIT]: detach_as_started,
-  [STAGE.ROUND_TWO]: detach_again,
-  [STAGE.FOLLOWUP]: detach_again,
-  [STAGE.REPORT]: detach_again
-};
-function detach_review_again(resume) {
-  return `leave the fix uncommitted and run \`${ship_command(COMMAND.DETACH_REVIEW, 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(issue, stage, is_excerpted) {
-  if (is_excerpted) return `Fix the ${stage} failure shown in the output below`;
-  return `Read the stopped report with \`${COMMAND.LOG} ${issue}\`, fix the ${stage} failure`;
-}
-function next_step(issue, stage, resume, is_excerpted = false) {
-  const conflicts = resume.conflicts ?? [];
-  if (conflicts.length > 0) return `${conflict_step(conflicts)} ${after_fix(stage, resume)}`;
-  return `${fix_step(issue, stage, is_excerpted)}, then ${after_fix(stage, resume)}`;
-}
-var run_ship_next = { COMMAND, next_step, quoted, resume_of };
-
-// scripts/run/ship/run-ship-stop-context.ts
-import { stripVTControlCharacters } from "node:util";
-
-// scripts/git/changed-paths.ts
-function to_paths(raw) {
-  return raw.split("\n").map((line) => line.trim()).filter((line) => line !== "");
-}
-async function read_changed_paths(is_staged) {
-  if (is_staged) return to_paths(await git_command.diff_cached_names());
-  const tracked = to_paths(await git_command.diff_main_names());
-  const untracked = to_paths(await git_command.untracked_names());
-  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_paths, read_changed_since, read_held_at, to_paths };
-
-// scripts/run/ship/run-ship-stop-context.ts
-import { z as z10 } from "zod";
-
-// scripts/git/git-ls-remote.ts
-var LS_REMOTE_COMMAND = "ls-remote";
-var HEADS_FLAG = "--heads";
-var ORIGIN_REMOTE = "origin";
-var HEADS_REF_PREFIX = "refs/heads/";
-function ls_remote_branch_arguments(branch_name) {
-  return [LS_REMOTE_COMMAND, HEADS_FLAG, ORIGIN_REMOTE, `${HEADS_REF_PREFIX}${branch_name}`];
-}
-
-// scripts/git/git-worktree.ts
-var WORKTREE = "worktree";
-var WORKTREE_LOCK_PREFIX = "josh-worktree-lock-";
-var WORKTREE_LOCK_MAX_WAIT_MS = 12e4;
-async function locked(arguments_, timeout_ms) {
-  const target = repository_lock.lock_path(WORKTREE_LOCK_PREFIX);
-  const output = await repository_lock.with_lock(
-    async () => await git_spawn.read(arguments_, timeout_ms),
-    target,
-    WORKTREE_LOCK_MAX_WAIT_MS
-  );
-  if (output === void 0) {
-    throw new Error(
-      `git ${arguments_.join(" ")}: timed out waiting for the work-tree lock ${target}`
-    );
-  }
-  return output;
-}
-async function worktree_list() {
-  return await git_spawn.read([WORKTREE, "list", PORCELAIN_FLAG]);
-}
-async function worktree_add(directory, branch_name, start_point) {
-  const flags = start_point === void 0 ? ["add"] : ["add", "--no-track", "-b", branch_name];
-  return await locked([WORKTREE, ...flags, directory, start_point ?? branch_name], SUITE_TIMEOUT_MS);
-}
-async function worktree_add_detached(directory, commit) {
-  return await locked([WORKTREE, "add", "--detach", directory, commit], SUITE_TIMEOUT_MS);
-}
-async function worktree_remove(directory) {
-  return await locked([WORKTREE, "remove", "--force", directory], INSTALL_TIMEOUT_MS);
-}
-async function worktree_prune() {
-  return await locked([WORKTREE, "prune"]);
-}
-async function ls_remote_branch(branch_name) {
-  return await git_spawn.read_remote(ls_remote_branch_arguments(branch_name));
-}
-async function branch_delete(branch_name) {
-  return await git_spawn.read(["branch", "-D", branch_name]);
-}
-var git_worktree = {
-  branch_delete,
-  ls_remote_branch,
-  worktree_add,
-  worktree_add_detached,
-  worktree_list,
-  worktree_prune,
-  worktree_remove
-};
-
-// scripts/review/review-attest.ts
-import { randomBytes } from "node:crypto";
-import { lstatSync } from "node:fs";
-
-// scripts/review/review-checkout.ts
-async function read_checkout() {
-  const [root, branch, head] = await Promise.all([
-    git_command.repository_root(),
-    git_command.branch(),
-    git_command.head_commit()
-  ]);
-  return { root, branch, head };
-}
-function is_same_checkout(expected, actual) {
-  return expected.root === actual.root && expected.branch === actual.branch && expected.head === actual.head;
-}
-function describe_checkout(checkout) {
-  return `${checkout.root} (branch ${checkout.branch}, HEAD ${checkout.head})`;
-}
-var review_checkout = { describe_checkout, is_same_checkout, read_checkout };
-
-// scripts/review/review-attest.ts
-var POINTER_PREFIX = "josh-review-target-";
-var EXPECT_PREFIX = "josh-review-expect-";
-var ATTEST_PREFIX = "josh-review-attest-";
-var NONCE_BYTES = 8;
-var HOURS_BEFORE_STALE = 8;
-var MILLISECONDS_PER_HOUR2 = 36e5;
-var STALE_AFTER_MS = HOURS_BEFORE_STALE * MILLISECONDS_PER_HOUR2;
-function pointer_path(root = PROJECT_ROOT) {
-  return stamp_file.stamp_path(POINTER_PREFIX, root);
-}
-function expect_path(nonce) {
-  return stamp_file.stamp_path(EXPECT_PREFIX, nonce);
-}
-function attest_path(nonce) {
-  return stamp_file.stamp_path(ATTEST_PREFIX, nonce);
-}
-function read_json(source) {
-  const raw = stamp_file.read_stamp_text(source);
-  return raw === void 0 ? void 0 : json_value.parse_or_undefined(raw);
-}
-function string_field(value, key) {
-  const field = value[key];
-  return typeof field === "string" ? field : void 0;
-}
-function to_checkout(value) {
-  if (!json_value.is_record(value)) return void 0;
-  const root = string_field(value, "root");
-  const branch = string_field(value, "branch");
-  const head = string_field(value, "head");
-  if (root === void 0 || branch === void 0 || head === void 0) return void 0;
-  return { root, branch, head };
-}
-function to_pointer(value) {
-  if (!json_value.is_record(value)) return void 0;
-  const nonce = string_field(value, "nonce");
-  const taken_at = string_field(value, "taken_at");
-  if (nonce !== void 0 && taken_at !== void 0) return { nonce, taken_at };
-  return void 0;
-}
-function read_pointer(root) {
-  return to_pointer(read_json(pointer_path(root)));
-}
-function read_expectation(nonce) {
-  return to_checkout(read_json(expect_path(nonce)));
-}
-function read_attestation(nonce) {
-  return to_checkout(read_json(attest_path(nonce)));
-}
-function drop_records(pointer) {
-  if (pointer === void 0) return;
-  stamp_file.remove_stamp(expect_path(pointer.nonce));
-  stamp_file.remove_stamp(attest_path(pointer.nonce));
-}
-function is_stale2(taken_at, now) {
-  const taken = Date.parse(taken_at);
-  return Number.isNaN(taken) || now - taken > STALE_AFTER_MS;
-}
-function record_target(checkout, root) {
-  const nonce = randomBytes(NONCE_BYTES).toString("hex");
-  const taken_at = (/* @__PURE__ */ new Date()).toISOString();
-  drop_records(read_pointer(root));
-  stamp_file.write_stamp(expect_path(nonce), { ...checkout, taken_at });
-  stamp_file.write_stamp(pointer_path(root), { nonce, taken_at });
-  return nonce;
-}
-function attest(nonce, actual) {
-  const expected = read_expectation(nonce);
-  if (expected === void 0) return { status: "missing", nonce, actual };
-  stamp_file.write_stamp(attest_path(nonce), { ...actual, taken_at: (/* @__PURE__ */ new Date()).toISOString() });
-  if (review_checkout.is_same_checkout(expected, actual)) {
-    return { status: "ok", nonce, expected, actual };
-  }
-  return { status: "mismatch", nonce, expected, actual };
-}
-function not_required() {
-  return { status: "not-required" };
-}
-function verdict_for(nonce) {
-  const expected = read_expectation(nonce);
-  if (expected === void 0) return { status: "missing", nonce };
-  const actual = read_attestation(nonce);
-  if (actual === void 0) return { status: "missing", nonce, expected };
-  if (review_checkout.is_same_checkout(expected, actual)) {
-    return { status: "ok", nonce, expected, actual };
-  }
-  return { status: "mismatch", nonce, expected, actual };
-}
-function check(now = Date.now(), root) {
-  const pointer = read_pointer(root);
-  if (pointer === void 0) return not_required();
-  const verdict = verdict_for(pointer.nonce);
-  if (verdict.status === "missing" && is_stale2(pointer.taken_at, now)) return not_required();
-  return verdict;
-}
-function is_written_since(source, taken_at) {
-  try {
-    const stats = lstatSync(source);
-    return stats.isFile() && stats.mtimeMs >= Date.parse(taken_at);
-  } catch {
-    return false;
-  }
-}
-function is_reviewed_on(checkout, findings_path, root) {
-  const pointer = read_pointer(root);
-  if (pointer === void 0) return false;
-  const verdict = verdict_for(pointer.nonce);
-  if (verdict.status !== "ok" || verdict.expected?.branch !== checkout.branch) return false;
-  return is_written_since(findings_path, pointer.taken_at);
-}
-function is_briefed_since(written_at, root) {
-  const pointer = read_pointer(root);
-  return pointer !== void 0 && written_at >= pointer.taken_at;
-}
-async function check_here(now = Date.now()) {
-  return check(now, await git_command.repository_root());
-}
-function clear(root) {
-  const pointer = read_pointer(root);
-  stamp_file.remove_stamp(pointer_path(root));
-  drop_records(pointer);
-}
-async function clear_here() {
-  clear(await git_command.repository_root());
-}
-var MISMATCH_VERDICT = "REVIEW TARGET MISMATCH";
-function describe_side(label, checkout) {
-  if (checkout === void 0) return `${label}: unknown`;
-  return `${label}: ${review_checkout.describe_checkout(checkout)}`;
-}
-var MISSING_REASON = "The review left no attestation, so there is no evidence it read this checkout at all. A review that read the wrong tree finds nothing wrong and reports no findings, which is indistinguishable from a clean review \u2014 so an absent attestation is treated as no review (joshuafolkken/kit#1522).";
-var MISMATCH_REASON = `${MISMATCH_VERDICT}: the review attested a different checkout from the one it was briefed on. Its findings \u2014 including "no findings" \u2014 describe another tree.`;
-var REMEDY = "Re-run `/code-review` with the brief `pnpm josh review:brief` prints, against the checkout named above, and let it run `pnpm josh review:attest <nonce>` from there before it reports.";
-function refusal_message(verdict) {
-  const reason = verdict.status === "mismatch" ? MISMATCH_REASON : MISSING_REASON;
-  return [
-    reason,
-    describe_side("Briefed on", verdict.expected),
-    describe_side("Reviewed", verdict.actual),
-    REMEDY
-  ].join("\n");
-}
-var review_attest = {
-  attest,
-  attest_path,
-  check,
-  check_here,
-  clear,
-  clear_here,
-  expect_path,
-  is_briefed_since,
-  is_reviewed_on,
-  MISMATCH_VERDICT,
-  MISSING_REASON,
-  pointer_path,
-  read_attestation,
-  read_expectation,
-  read_pointer,
-  record_target,
-  refusal_message,
-  STALE_AFTER_MS
-};
-
-// scripts/gh/git-gh-api-path.ts
-var FULL_PAGE_QUERY = "?per_page=100";
-function repo_api_path(repo = "{owner}/{repo}") {
-  return `repos/${repo}`;
-}
-function issues_api_path(repo) {
-  return `${repo_api_path(repo)}/issues`;
-}
-function issue_api_path(issue_number, repo) {
-  return `${issues_api_path(repo)}/${issue_number}`;
-}
-function issue_labels_api_path(issue_number, repo) {
-  return `${issue_api_path(issue_number, repo)}/labels`;
-}
-function blocked_by_api_path(issue_number, repo) {
-  return `${issue_api_path(issue_number, repo)}/dependencies/blocked_by`;
-}
-function issue_comments_api_path(issue_number, repo) {
-  return `${issue_api_path(issue_number, repo)}/comments`;
-}
-function pulls_api_path(repo) {
-  return `${repo_api_path(repo)}/pulls`;
-}
-function pull_api_path(pr_number, repo) {
-  return `${pulls_api_path(repo)}/${pr_number}`;
-}
-function pull_merge_api_path(pr_number, repo) {
-  return `${pull_api_path(pr_number, repo)}/merge`;
-}
-function pull_comments_api_path(pr_number, repo) {
-  return `${pull_api_path(pr_number, repo)}/comments`;
-}
-function pull_reviews_api_path(pr_number, repo) {
-  return `${pull_api_path(pr_number, repo)}/reviews`;
-}
-function commit_api_path(commit_sha, repo) {
-  return `${repo_api_path(repo)}/commits/${commit_sha}`;
-}
-function commit_check_runs_api_path(commit_sha, repo) {
-  return `${commit_api_path(commit_sha, repo)}/check-runs`;
-}
-function commit_status_api_path(commit_sha, repo) {
-  return `${commit_api_path(commit_sha, repo)}/status`;
-}
-function branch_rules_api_path(branch_name, repo) {
-  return `${repo_api_path(repo)}/rules/branches/${branch_name}`;
-}
-function tag_reference_api_path(tag, repo) {
-  return `${repo_api_path(repo)}/git/ref/tags/${tag}`;
-}
-function release_by_tag_api_path(tag, repo) {
-  return `${repo_api_path(repo)}/releases/tags/${tag}`;
-}
-var git_gh_api_path = {
-  FULL_PAGE_QUERY,
-  repo_api_path,
-  tag_ref_api_path: tag_reference_api_path,
-  release_by_tag_api_path,
-  issues_api_path,
-  issue_api_path,
-  issue_labels_api_path,
-  blocked_by_api_path,
-  issue_comments_api_path,
-  pulls_api_path,
-  pull_api_path,
-  pull_merge_api_path,
-  pull_comments_api_path,
-  pull_reviews_api_path,
-  commit_api_path,
-  commit_check_runs_api_path,
-  commit_status_api_path,
-  branch_rules_api_path
-};
-
-// scripts/gh/git-gh-exec.ts
-import { execa as execa2, execaSync } from "execa";
-
-// scripts/gh/git-gh-check.ts
-import { execa } from "execa";
-var GH_NOT_INSTALLED_MSG = "gh CLI is not installed. Install it from https://cli.github.com/";
-var gh_check = {};
-async function run_gh_check() {
-  try {
-    await execa("gh", ["--version"], { timeout: COMMAND_TIMEOUT_MS });
-  } catch {
-    delete gh_check.promise;
-    throw new Error(GH_NOT_INSTALLED_MSG);
-  }
-}
-async function check_gh_installed() {
-  gh_check.promise ??= run_gh_check();
-  await gh_check.promise;
-}
-
-// scripts/git/parse-json-array.ts
-function parse_json_loose(raw_json) {
-  return json_value.parse_or_undefined(raw_json);
-}
-function parse_json_array_or_undefined(raw_json, element_schema) {
-  const value = parse_json_loose(raw_json);
-  if (!Array.isArray(value)) return void 0;
-  return element_schema.array().parse(value);
-}
-function read_json_listing(raw_json, element_schema) {
-  try {
-    const rows = parse_json_array_or_undefined(raw_json, element_schema);
-    return rows === void 0 ? { kind: "unreadable" } : { kind: "read", rows };
-  } catch {
-    return { kind: "unexpected_shape" };
-  }
-}
-function parse_json_array_safe(raw_json, element_schema) {
-  const value = parse_json_loose(raw_json);
-  if (value === void 0) return [];
-  return element_schema.array().parse(value);
-}
-function parse_json_object_or_undefined(raw_json, schema) {
-  const value = parse_json_loose(raw_json);
-  if (value === void 0) return void 0;
-  return schema.parse(value);
-}
-var parse_json = {
-  parse_json_object_or_undefined
-};
-
-// scripts/gh/git-gh-failure.ts
-import { z as z3 } from "zod";
-var error_document_schema = z3.object({ status: z3.union([z3.string(), z3.number()]).optional() }).catch({});
-var GH_FAILURE_FIELD = "gh_failure";
-function has_gh_failure(error) {
-  return error instanceof Error && Object.hasOwn(error, GH_FAILURE_FIELD);
-}
-function parse_response_status(stdout) {
-  const document = parse_json.parse_json_object_or_undefined(stdout, error_document_schema);
-  if (document?.status === void 0) return void 0;
-  const status = Number(document.status);
-  return Number.isSafeInteger(status) ? status : void 0;
-}
-function classify_stdout(stdout) {
-  return { status: parse_response_status(stdout) };
-}
-function attach(error, failure) {
-  Object.defineProperty(error, GH_FAILURE_FIELD, {
-    value: failure,
-    enumerable: false,
-    configurable: true
-  });
-  return error;
-}
-function failure_of(error) {
-  return has_gh_failure(error) ? error.gh_failure : void 0;
-}
-var gh_failure = { attach, classify_stdout, failure_of, parse_response_status };
-
-// scripts/gh/git-gh-exec.ts
-var BODY_FROM_STDIN = "-";
-var GH_REQUEST_TIMEOUT_MS = 6e4;
-function to_timeout_option(timeout_ms) {
-  return { timeout: timeout_ms ?? GH_REQUEST_TIMEOUT_MS };
-}
-function direct_environment() {
-  const removed = agent_session_environment.removed_proxy_environment();
-  return Object.keys(removed).length > 0 ? { env: removed } : {};
-}
-function to_spawn_options(timeout_ms, cwd) {
-  return {
-    ...to_timeout_option(timeout_ms),
-    ...direct_environment(),
-    ...cwd !== void 0 && { cwd }
-  };
-}
-var GH_REQUEST_TIMEOUT_MESSAGE = "gh request timed out";
-function has_stderr_field(error) {
-  return error instanceof Error && "stderr" in error && typeof error.stderr === "string";
-}
-function has_stdout_field(error) {
-  return error instanceof Error && "stdout" in error && typeof error.stdout === "string";
-}
-function to_timeout_prefix(error) {
-  return has_timed_out(error) ? `${GH_REQUEST_TIMEOUT_MESSAGE}: ` : "";
-}
-function to_gh_error(error) {
-  const stderr = has_stderr_field(error) ? error.stderr.trim() : "";
-  const stdout = has_stdout_field(error) ? error.stdout.trim() : "";
-  const summary = stderr.length > 0 ? stderr : error_text.message_of(error);
-  const detail = stdout.length > 0 ? `${summary}
-${stdout}` : summary;
-  return gh_failure.attach(
-    new Error(`${to_timeout_prefix(error)}${detail}`, { cause: error }),
-    gh_failure.classify_stdout(stdout)
-  );
-}
-async function exec_gh_command(arguments_, timeout_ms, cwd) {
-  await check_gh_installed();
-  const options = to_spawn_options(timeout_ms, cwd);
-  try {
-    const { stdout } = await execa2("gh", arguments_, options);
-    return stdout.trimEnd();
-  } catch (error) {
-    throw to_gh_error(error);
-  }
-}
-async function exec_gh_command_with_stdin(input) {
-  await check_gh_installed();
-  const options = { input: input.stdin_body, ...to_spawn_options(input.timeout_ms, input.cwd) };
-  try {
-    const { stdout } = await execa2("gh", input.args, options);
-    return stdout.trimEnd();
-  } catch (error) {
-    throw to_gh_error(error);
-  }
-}
-var STATUS_LINE_PATTERN = /^HTTP\/[\d.]+ (?<status>\d{3})\b/u;
-function parse_status_line(output) {
-  const { status } = STATUS_LINE_PATTERN.exec(output)?.groups ?? {};
-  return status === void 0 ? void 0 : Number(status);
-}
-function status_of_failure(error) {
-  return has_stdout_field(error) ? parse_status_line(error.stdout) : void 0;
-}
-async function exec_gh_api_status(path5, timeout_ms) {
-  const options = to_spawn_options(timeout_ms);
-  try {
-    await check_gh_installed();
-    const { stdout } = await execa2("gh", ["api", "--include", "--silent", path5], options);
-    return parse_status_line(stdout);
-  } catch (error) {
-    return status_of_failure(error);
-  }
-}
-function exec_gh_api_status_sync(path5, timeout_ms) {
-  const options = to_spawn_options(timeout_ms);
-  try {
-    const { stdout } = execaSync("gh", ["api", "--include", "--silent", path5], options);
-    return parse_status_line(stdout);
-  } catch (error) {
-    return status_of_failure(error);
-  }
-}
-var METHOD_FLAG = "--method";
-var INPUT_FLAG = "--input";
-var PAGINATE_FLAG = "--paginate";
-var SLURP_FLAG = "--slurp";
-var JQ_FLAG = "--jq";
-function optional_flag(flag, value) {
-  return value === void 0 ? [] : [flag, value];
-}
-function to_gh_api_args(request) {
-  const body_args = request.body === void 0 ? [] : [INPUT_FLAG, BODY_FROM_STDIN];
-  const paginate_args = request.should_paginate === true ? [PAGINATE_FLAG] : [];
-  const slurp_args = request.should_slurp === true ? [SLURP_FLAG] : [];
-  return [
-    "api",
-    request.path,
-    ...optional_flag(METHOD_FLAG, request.method),
-    ...body_args,
-    ...paginate_args,
-    ...slurp_args,
-    ...optional_flag(JQ_FLAG, request.jq_filter)
-  ];
-}
-async function exec_gh_api(request) {
-  const args = to_gh_api_args(request);
-  if (request.body === void 0) {
-    return await exec_gh_command(args, request.timeout_ms, request.cwd);
-  }
-  return await exec_gh_command_with_stdin({
-    args,
-    stdin_body: request.body,
-    timeout_ms: request.timeout_ms,
-    cwd: request.cwd
-  });
-}
-function exec_gh_api_sync(request) {
-  const body_option = request.body === void 0 ? {} : { input: request.body };
-  const options = { ...body_option, ...to_spawn_options(request.timeout_ms, request.cwd) };
-  try {
-    const { stdout } = execaSync("gh", to_gh_api_args(request), options);
-    return stdout.trimEnd();
-  } catch (error) {
-    throw to_gh_error(error);
-  }
-}
-function read_gh_api_sync(request) {
-  try {
-    return exec_gh_api_sync(request);
-  } catch {
-    return void 0;
-  }
-}
-var git_gh_exec = {
-  direct_environment,
-  exec_gh_command,
-  exec_gh_command_with_stdin,
-  exec_gh_api,
-  exec_gh_api_sync,
-  read_gh_api_sync,
-  exec_gh_api_status,
-  exec_gh_api_status_sync,
-  parse_status_line
-};
-
-// scripts/gh/git-gh-conditional.ts
-var NOT_MODIFIED_STATUS = 304;
-var OK_STATUS = 200;
-var INCLUDE_FLAG = "--include";
-var HEADER_FLAG = "-H";
-var IF_NONE_MATCH = "If-None-Match: ";
-var HEADER_BODY_SEPARATOR = /\r?\n\r?\n/u;
-var ETAG_HEADER = /^etag: *(?<etag>[^\r\n]+)/imu;
-var UNCHANGED = { kind: "unchanged" };
-var UNREADABLE = { kind: "unreadable" };
-function to_args(path5, etag) {
-  const header = etag === void 0 ? [] : [HEADER_FLAG, `${IF_NONE_MATCH}${etag}`];
-  return ["api", INCLUDE_FLAG, ...header, path5];
-}
-function to_changed(output) {
-  const [headers = "", ...rest] = output.split(HEADER_BODY_SEPARATOR);
-  const etag = ETAG_HEADER.exec(headers)?.groups?.["etag"];
-  return { kind: "changed", etag, body: rest.join("\n\n") };
-}
-function to_read(output) {
-  return git_gh_exec.parse_status_line(output) === OK_STATUS ? to_changed(output) : UNREADABLE;
-}
-function failure_status(error) {
-  const cause = error instanceof Error ? error.cause : void 0;
-  return has_stdout_field(cause) ? git_gh_exec.parse_status_line(cause.stdout) : void 0;
-}
-async function read_conditional(path5, etag, timeout_ms) {
-  try {
-    return to_read(await git_gh_exec.exec_gh_command(to_args(path5, etag), timeout_ms));
-  } catch (error) {
-    return failure_status(error) === NOT_MODIFIED_STATUS ? UNCHANGED : { kind: "unreadable", cause: error };
-  }
-}
-var git_gh_conditional = { read_conditional, to_args };
-
-// scripts/gh/git-gh-helpers.ts
-function parse_pr_state_string(result) {
-  const trimmed2 = result.trim();
-  return trimmed2.length > 0 ? trimmed2 : void 0;
-}
-function is_pr_already_exists_message(error_message) {
-  return error_message.toLowerCase().includes("already exists");
-}
-function get_error_message_with_stderr(error) {
-  if (!(error instanceof Error)) return String(error);
-  if (has_stderr_field(error) && error.stderr.length > 0) return `${error.message}
-${error.stderr}`;
-  return error.message;
-}
-function handle_pr_create_error(error) {
-  const error_message = get_error_message_with_stderr(error);
-  if (is_pr_already_exists_message(error_message)) {
-    throw new Error("PR_ALREADY_EXISTS");
-  }
-  throw error;
-}
-var git_gh_helpers = {
-  parse_pr_state_string,
-  get_error_message_with_stderr,
-  handle_pr_create_error
-};
-
-// scripts/gh/git-gh-issue-rest.ts
-import { z as z4 } from "zod";
-
-// scripts/gh/git-gh-rest-state.ts
-var MERGED_STATE = "MERGED";
-function to_gh_state(state) {
-  return state?.toUpperCase();
-}
-
-// scripts/gh/git-gh-issue-rest.ts
-var rest_issue_schema = z4.looseObject({
-  number: z4.number(),
-  issue_dependencies_summary: z4.looseObject({ total_blocked_by: z4.number().optional() }).nullish(),
-  // Present only on a pull request, which this endpoint serves as readily as an issue.
-  pull_request: z4.looseObject({ merged_at: z4.string().nullish() }).nullish()
-});
-var REPOSITORY_URL = /\/repos\/([\w.-]+\/[\w.-]+)$/u;
-var REPOSITORY_URL_GROUP = 1;
-var BLOCKED_BY_FIELD = "blockedBy";
-var BLOCKED_BY_COUNT_FIELD = "blocked_by_count";
-var STATE_FIELD = "state";
-var BODY_FIELD = "body";
-var FIELD_SEPARATOR = ",";
-var EMPTY_BODY = "";
-var REST_FIELD_NAMES = /* @__PURE__ */ new Map([
-  ["url", "html_url"],
-  ["createdAt", "created_at"],
-  ["closedAt", "closed_at"],
-  ["stateReason", "state_reason"],
-  ["updatedAt", "updated_at"]
-]);
-var NOT_AN_ISSUE_MESSAGE = "gh api answered something other than an issue object";
-var NOT_AN_ISSUE_LISTING_MESSAGE = "gh api answered something other than an issue listing";
-var NOT_A_BLOCKER_LISTING_MESSAGE = "gh api answered something other than a blocked-by listing";
-function rest_field_name(field) {
-  return REST_FIELD_NAMES.get(field) ?? field;
-}
-function split_fields(fields) {
-  return fields.split(FIELD_SEPARATOR).map((field) => field.trim()).filter((field) => field.length > 0);
-}
-function to_issue_state(rest, value) {
-  if (typeof rest.pull_request?.merged_at === "string") return MERGED_STATE;
-  return typeof value === "string" ? to_gh_state(value) : value;
-}
-function total_blocked_by(rest) {
-  return rest.issue_dependencies_summary?.total_blocked_by;
-}
-function to_gh_field_value(field, rest) {
-  if (field === BLOCKED_BY_COUNT_FIELD) return total_blocked_by(rest);
-  const value = rest[rest_field_name(field)];
-  if (field === STATE_FIELD) return to_issue_state(rest, value);
-  return field === BODY_FIELD ? value ?? EMPTY_BODY : value;
-}
-function parse_rest_issue(rest_json) {
-  const parsed = parse_json_object_or_undefined(rest_json, rest_issue_schema);
-  if (parsed === void 0) throw new Error(NOT_AN_ISSUE_MESSAGE);
-  return parsed;
-}
-function is_pull_request(rest) {
-  return rest.pull_request !== void 0 && rest.pull_request !== null;
-}
-function parse_rest_issues(rest_json) {
-  const parsed = parse_json_array_or_undefined(rest_json, rest_issue_schema);
-  if (parsed === void 0) throw new Error(NOT_AN_ISSUE_LISTING_MESSAGE);
-  return parsed;
-}
-function empty_blocked_by() {
-  return { nodes: [], totalCount: 0 };
-}
-function repo_of_url(repository_url = "") {
-  const match = REPOSITORY_URL.exec(repository_url);
-  return match?.[REPOSITORY_URL_GROUP];
-}
-function to_blocked_by(blockers_json, exact_total) {
-  const parsed = parse_json_array_or_undefined(blockers_json, blocking_issue_schema);
-  if (parsed === void 0) throw new Error(NOT_A_BLOCKER_LISTING_MESSAGE);
-  const nodes = parsed.map((blocker) => ({ ...blocker, state: to_gh_state(blocker.state) }));
-  return { nodes, totalCount: exact_total ?? nodes.length };
-}
-function to_gh_issue(rest, fields, blocked_by) {
-  return Object.fromEntries(
-    fields.map((field) => [
-      field,
-      field === BLOCKED_BY_FIELD ? blocked_by : to_gh_field_value(field, rest)
-    ])
-  );
-}
-function to_field_text(value) {
-  if (typeof value === "string") return value;
-  return value === void 0 || value === null ? EMPTY_BODY : JSON.stringify(value);
-}
-var CLOSED = "CLOSED";
-function reference_of_blocker(node, fallback_repo) {
-  const repo = repo_of_url(node.repository_url) ?? fallback_repo;
-  if (node.state === void 0) return { repo, number: node.number };
-  return { repo, number: node.number, state: node.state.toUpperCase() === CLOSED ? CLOSED : "OPEN" };
-}
-var git_gh_issue_rest = {
-  empty_blocked_by,
-  repo_of_url,
-  reference_of_blocker,
-  split_fields,
-  is_pull_request,
-  parse_rest_issue,
-  parse_rest_issues,
-  total_blocked_by,
-  to_blocked_by,
-  to_gh_issue,
-  to_field_text
-};
-
-// scripts/gh/git-gh-reachability.ts
-var RATE_LIMITED_STATUS = 429;
-var SERVER_ERROR_FLOOR = 500;
-function is_retryable_status(status) {
-  if (status >= SERVER_ERROR_FLOOR) return true;
-  return status === RATE_LIMITED_STATUS;
-}
-function classify_status(status) {
-  if (status === void 0) return "unreachable";
-  return is_retryable_status(status) ? "unreachable" : "reachable";
-}
-var gh_reachability = { classify_status };
-
-// scripts/gh/git-gh-issue-read.ts
-async function read_blocked_by_listing(issue_number, repo, exact_total) {
-  const json = await git_gh_exec.exec_gh_api({
-    path: `${git_gh_api_path.blocked_by_api_path(issue_number, repo)}${git_gh_api_path.FULL_PAGE_QUERY}`
-  });
-  return git_gh_issue_rest.to_blocked_by(json, exact_total);
-}
-async function read_blocked_by(issue_number, rest, repo) {
-  if (git_gh_issue_rest.is_pull_request(rest)) return git_gh_issue_rest.empty_blocked_by();
-  const exact_total = git_gh_issue_rest.total_blocked_by(rest);
-  if (exact_total === 0) return git_gh_issue_rest.empty_blocked_by();
-  return await read_blocked_by_listing(issue_number, repo, exact_total);
-}
-function mark_followup(error) {
-  if (!(error instanceof Error)) return error;
-  const failure = gh_failure.failure_of(error);
-  if (failure === void 0) return error;
-  return gh_failure.attach(error, { ...failure, is_followup: true });
-}
-async function read_relations(issue_number, rest, repo) {
-  try {
-    return await read_blocked_by(issue_number, rest, repo);
-  } catch (error) {
-    throw mark_followup(error);
-  }
-}
-async function read_issue_fields(issue_number, fields, repo) {
-  const rest = git_gh_issue_rest.parse_rest_issue(
-    await git_gh_exec.exec_gh_api({ path: git_gh_api_path.issue_api_path(issue_number, repo) })
-  );
-  const requested = git_gh_issue_rest.split_fields(fields);
-  const blocked_by = requested.includes(BLOCKED_BY_FIELD) ? await read_relations(issue_number, rest, repo) : void 0;
-  return git_gh_issue_rest.to_gh_issue(rest, requested, blocked_by);
-}
-var NOT_FOUND_STATUS = 404;
-function is_number_unresolved(failure) {
-  return failure.status === NOT_FOUND_STATUS && failure.is_followup !== true;
-}
-function to_unreadable_reason(status) {
-  return gh_reachability.classify_status(status) === "unreachable" ? "unreachable" : "rejected";
-}
-function to_read_failure(error) {
-  const failure = gh_failure.failure_of(error);
-  if (failure === void 0) return { kind: "unreadable", reason: "malformed", status: void 0 };
-  if (is_number_unresolved(failure)) return { kind: "missing" };
-  return {
-    kind: "unreadable",
-    reason: to_unreadable_reason(failure.status),
-    status: failure.status
-  };
-}
-async function issue_view_json_classified(issue_number, fields, repo) {
-  try {
-    const issue = await read_issue_fields(issue_number, fields, repo);
-    return { kind: "read", json: JSON.stringify(issue) };
-  } catch (error) {
-    return to_read_failure(error);
-  }
-}
-async function issue_view_field_classified(issue_number, field, repo) {
-  try {
-    const issue = await read_issue_fields(issue_number, field, repo);
-    return { kind: "read", text: git_gh_issue_rest.to_field_text(issue[field]) };
-  } catch (error) {
-    return to_read_failure(error);
-  }
-}
-async function issue_view_field(issue_number, field, repo) {
-  const read = await issue_view_field_classified(issue_number, field, repo);
-  return read.kind === "read" ? read.text : void 0;
-}
-async function issue_get_title(issue_number, repo) {
-  const result = await issue_view_field(issue_number, "title", repo);
-  return result === void 0 ? void 0 : git_gh_helpers.parse_pr_state_string(result);
-}
-async function issue_get_body(issue_number, repo) {
-  return await issue_view_field(issue_number, "body", repo);
-}
-async function issue_get_body_classified(issue_number, repo) {
-  return await issue_view_field_classified(issue_number, "body", repo);
-}
-async function issue_view_json(issue_number, fields, repo) {
-  const read = await issue_view_json_classified(issue_number, fields, repo);
-  return read.kind === "read" ? read.json : void 0;
-}
-var STATE_AND_RELATIONS_FIELDS = "number,state,labels,blockedBy,body";
-async function issue_get_state_and_relations(issue_number, repo) {
-  return await issue_view_json(issue_number, STATE_AND_RELATIONS_FIELDS, repo);
-}
-async function issue_get_state_and_relations_classified(issue_number, repo) {
-  return await issue_view_json_classified(issue_number, STATE_AND_RELATIONS_FIELDS, repo);
-}
-function is_unreachable_read(failure) {
-  return failure.kind === "unreadable" && failure.reason === "unreachable";
-}
-var PLAN_FIELDS = "number,title,body,state,url,labels,blockedBy";
-async function issue_get_plan_fields(issue_number) {
-  return await issue_view_json(issue_number, PLAN_FIELDS);
-}
-async function issue_get_plan_fields_classified(issue_number) {
-  return await issue_view_json_classified(issue_number, PLAN_FIELDS);
-}
-async function issue_get_labels_and_body(issue_number) {
-  return await issue_view_json(issue_number, "number,state,labels,body");
-}
-async function issue_list_comments(issue_number, timeout_ms) {
-  const path5 = `${git_gh_api_path.issue_comments_api_path(issue_number)}${git_gh_api_path.FULL_PAGE_QUERY}`;
-  try {
-    return await git_gh_exec.exec_gh_api({ path: path5, should_paginate: true, timeout_ms });
-  } catch {
-    return void 0;
-  }
-}
-async function has_no_relations_endpoint(issue_number, repo) {
-  const status = await git_gh_exec.exec_gh_api_status(
-    git_gh_api_path.blocked_by_api_path(issue_number, repo)
-  );
-  return status === NOT_FOUND_STATUS;
-}
-async function issue_blocked_by_references(issue_number, own_repo, repo) {
-  try {
-    const listing = await read_blocked_by_listing(issue_number, repo);
-    return listing.nodes.map((blocker) => git_gh_issue_rest.reference_of_blocker(blocker, own_repo));
-  } catch (error) {
-    if (await has_no_relations_endpoint(issue_number, repo)) return [];
-    throw error;
-  }
-}
-async function issue_blocked_by_numbers(issue_number, repo) {
-  const references = await issue_blocked_by_references(issue_number, "", repo);
-  return references.map((blocker) => blocker.number);
-}
-var git_gh_issue_read = {
-  issue_blocked_by_numbers,
-  issue_blocked_by_references,
-  issue_get_title,
-  issue_get_body,
-  issue_get_body_classified,
-  issue_view_json,
-  issue_view_json_classified,
-  issue_get_state_and_relations,
-  issue_get_state_and_relations_classified,
-  is_unreachable_read,
-  issue_get_plan_fields,
-  issue_get_plan_fields_classified,
-  issue_get_labels_and_body,
-  issue_list_comments
-};
-
-// scripts/issue/issue-watch.ts
-import { z as z7 } from "zod";
-
-// scripts/gh/gh-author-association.ts
-import { z as z5 } from "zod";
-var OWNER = "OWNER";
-var ASKED_ASSOCIATIONS = /* @__PURE__ */ new Set(["MEMBER", "COLLABORATOR"]);
-var WRITE_ROLES = /* @__PURE__ */ new Set(["admin", "maintain", "write"]);
-var LOGIN_PATTERN = /^[\da-z](?:[\w-]*[\da-z])?$/iu;
-var TRUSTED_LIST = "OWNER, or MEMBER / COLLABORATOR with write access";
-var permission_schema = z5.looseObject({
-  permission: z5.string().nullish(),
-  role_name: z5.string().nullish()
-});
-var answers = /* @__PURE__ */ new Map();
-function permission_path(login) {
-  return `${git_gh_api_path.repo_api_path()}/collaborators/${login}/permission`;
-}
-function has_write_role(raw) {
-  const parsed = parse_json.parse_json_object_or_undefined(raw, permission_schema);
-  const roles = [parsed?.role_name, parsed?.permission];
-  return roles.some((role) => typeof role === "string" && WRITE_ROLES.has(role));
-}
-async function ask_permission(login, timeout_ms) {
-  try {
-    const raw = await git_gh_exec.exec_gh_api({ path: permission_path(login), timeout_ms });
-    return has_write_role(raw);
-  } catch {
-    return void 0;
-  }
-}
-async function can_write(login, timeout_ms) {
-  const asked = answers.get(login) ?? ask_permission(login, timeout_ms);
-  answers.set(login, asked);
-  const has_write = await asked;
-  if (has_write === void 0 && answers.get(login) === asked) answers.delete(login);
-  return has_write;
-}
-function is_user_login(login) {
-  return login !== void 0 && LOGIN_PATTERN.test(login);
-}
-function is_asked(author) {
-  return ASKED_ASSOCIATIONS.has(author.association ?? "") && is_user_login(author.login);
-}
-async function trust_of(author) {
-  if (author.association === OWNER) return true;
-  if (author.login === void 0 || !is_asked(author)) return false;
-  return await can_write(author.login, author.timeout_ms);
-}
-async function is_trusted(author) {
-  return await trust_of(author) === true;
-}
-var gh_author_association = { TRUSTED_LIST, is_trusted, trust_of };
-
-// scripts/issue/issue-watch-diff.ts
-import { z as z6 } from "zod";
-var RUN_MARKER = "<!-- josh:run -->";
-var BOT_TYPE = "Bot";
-var BOT_SUFFIX = "[bot]";
-var NO_COMMENT_ID = 0;
-var UNKNOWN_AUTHOR = "(unknown)";
-var UNKNOWN_TIME = "(undated)";
-var UNVERIFIED_BODY = "(body withheld \u2014 the author's write access could not be checked; read it with `josh issue:read`)";
-var BODY_HEADING = "Body edited:";
-var REMOVED_PREFIX = "- ";
-var ADDED_PREFIX = "+ ";
-var COMMENT_HEADING = "New comment by ";
-var AT = " at ";
-var SECTION_SEPARATOR = "\n\n";
-var LINE_SEPARATOR = "\n";
-var CRLF = "\r\n";
-var comment_schema = z6.looseObject({
-  id: z6.number(),
-  user: z6.looseObject({ login: z6.string(), type: z6.string().optional() }).nullish(),
-  created_at: z6.string().optional(),
-  body: z6.string().nullish(),
-  author_association: z6.string().nullish()
-});
-function is_bot(user) {
-  return user?.type === BOT_TYPE || (user?.login.endsWith(BOT_SUFFIX) ?? false);
-}
-function is_automated(raw, is_trusted2) {
-  return is_bot(raw.user) || is_trusted2 === true && (raw.body?.includes(RUN_MARKER) ?? false);
-}
-async function to_comment(raw, timeout_ms) {
-  const login = raw.user?.login;
-  const is_trusted2 = await gh_author_association.trust_of({
-    login,
-    association: raw.author_association,
-    timeout_ms
-  });
-  return {
-    id: raw.id,
-    author: login ?? UNKNOWN_AUTHOR,
-    is_trusted: is_trusted2,
-    is_automated: is_automated(raw, is_trusted2),
-    created_at: raw.created_at ?? UNKNOWN_TIME,
-    body: raw.body ?? ""
-  };
-}
-async function parse_comments(json, timeout_ms) {
-  if (json === void 0) return void 0;
-  const listing = read_json_listing(json, comment_schema);
-  if (listing.kind !== "read") return void 0;
-  return await Promise.all(listing.rows.map(async (row) => await to_comment(row, timeout_ms)));
-}
-function last_comment_id(comments) {
-  return Math.max(NO_COMMENT_ID, ...comments.map((comment) => comment.id));
-}
-function baseline_of(snapshot) {
-  return { body: snapshot.body, last_comment_id: last_comment_id(snapshot.comments) };
-}
-function lines_missing_from(source, other) {
-  const present = new Set(other.split(LINE_SEPARATOR));
-  return source.split(LINE_SEPARATOR).filter((line) => line.trim() !== "" && !present.has(line));
-}
-function to_lf(body) {
-  return body.split(CRLF).join(LINE_SEPARATOR);
-}
-function body_section(previous_raw, current_raw) {
-  const previous = to_lf(previous_raw);
-  const current = to_lf(current_raw);
-  if (previous === current) return void 0;
-  const removed = lines_missing_from(previous, current).map((line) => `${REMOVED_PREFIX}${line}`);
-  const added = lines_missing_from(current, previous).map((line) => `${ADDED_PREFIX}${line}`);
-  return [BODY_HEADING, ...removed, ...added].join(LINE_SEPARATOR);
-}
-function comment_section(comment) {
-  const body = comment.is_trusted === true ? comment.body : UNVERIFIED_BODY;
-  return `${COMMENT_HEADING}${comment.author}${AT}${comment.created_at}${LINE_SEPARATOR}${body}`;
-}
-function new_person_comments(baseline, snapshot) {
-  return snapshot.comments.filter(
-    (comment) => comment.id > baseline.last_comment_id && comment.is_trusted !== false && !comment.is_automated
-  );
-}
-function unread_diff(baseline, snapshot) {
-  const body = body_section(baseline.body, snapshot.body);
-  const comments = new_person_comments(baseline, snapshot).map(
-    (comment) => comment_section(comment)
-  );
-  const sections = [...body === void 0 ? [] : [body], ...comments];
-  return sections.length === 0 ? void 0 : sections.join(SECTION_SEPARATOR);
-}
-var issue_watch_diff = {
-  RUN_MARKER,
-  baseline_of,
-  parse_comments,
-  unread_diff
-};
-
-// scripts/issue/issue-watch.ts
-var RECORD_PREFIX = "josh-issue-watch-";
-var CLOSED_STATE = "closed";
-var record_schema = z7.object({
-  issue: z7.string(),
-  body: z7.string(),
-  last_comment_id: z7.number(),
-  acknowledged_at: z7.string(),
-  checked_at: z7.string(),
-  etag: z7.string().optional(),
-  pending: z7.string().optional(),
-  shown: z7.string().optional()
-});
-var issue_schema = z7.looseObject({ body: z7.string().nullish(), state: z7.string() });
-var UNREADABLE2 = { kind: "unreadable" };
-function record_path(root = PROJECT_ROOT) {
-  return stamp_file.stamp_path(RECORD_PREFIX, root);
-}
-function read_record(root) {
-  const raw = stamp_file.read_stamp_text(record_path(root));
-  return raw === void 0 ? void 0 : json_value.parse_with(raw, record_schema);
-}
-function write_record(record, root) {
-  stamp_file.replace_stamp(record_path(root), record);
-  return record;
-}
-function clear2(root) {
-  stamp_file.remove_stamp(record_path(root));
-}
-async function read_snapshot(request, body, etag) {
-  const comments = await issue_watch_diff.parse_comments(
-    await git_gh_issue_read.issue_list_comments(request.issue, request.timeout_ms),
-    request.timeout_ms
-  );
-  return comments === void 0 ? UNREADABLE2 : { kind: "read", snapshot: { body, comments }, etag };
-}
-async function fetch_issue(request) {
-  const read = await git_gh_conditional.read_conditional(
-    git_gh_api_path.issue_api_path(request.issue),
-    request.etag,
-    request.timeout_ms
-  );
-  if (read.kind !== "changed") return read;
-  const fields = json_value.parse_with(read.body, issue_schema);
-  if (fields === void 0) return UNREADABLE2;
-  if (fields.state === CLOSED_STATE) return { kind: "closed" };
-  return await read_snapshot(request, fields.body ?? "", read.etag);
-}
-function fresh_record(issue, fetched, now, acknowledged_at = now.toISOString()) {
-  const baseline = issue_watch_diff.baseline_of(fetched.snapshot);
-  const checked_at = now.toISOString();
-  return { issue, ...baseline, acknowledged_at, checked_at, etag: fetched.etag };
-}
-async function record_baseline(issue, root, now = /* @__PURE__ */ new Date()) {
-  const fetched = await fetch_issue({ issue });
-  if (fetched.kind !== "read") return false;
-  write_record(fresh_record(issue, fetched, now), root);
-  return true;
-}
-async function record_baseline_here(issue) {
-  return await record_baseline(issue, await git_command.repository_root());
-}
-async function clear_here2() {
-  clear2(await git_command.repository_root());
-}
-function with_fetched(record, fetched, checked_at) {
-  if (fetched.kind !== "read") return { ...record, checked_at };
-  const pending = issue_watch_diff.unread_diff(record, fetched.snapshot);
-  return { ...record, checked_at, etag: fetched.etag, pending };
-}
-function is_due(record, options, now) {
-  return now.getTime() - Date.parse(record.checked_at) >= options.interval_ms;
-}
-async function refresh(record, options, now, root) {
-  const fetched = await fetch_issue({
-    issue: record.issue,
-    etag: record.etag,
-    timeout_ms: options.timeout_ms
-  });
-  if (fetched.kind === "closed") {
-    clear2(root);
-    return void 0;
-  }
-  return write_record(with_fetched(record, fetched, now.toISOString()), root);
-}
-async function poll(options, root) {
-  const record = read_record(root);
-  const now = options.now ?? /* @__PURE__ */ new Date();
-  if (record === void 0 || !is_due(record, options, now)) return record;
-  return await refresh(record, options, now, root);
-}
-function mark_shown(record, root) {
-  return write_record({ ...record, shown: record.pending }, root);
-}
-async function acknowledge(root, now = /* @__PURE__ */ new Date()) {
-  const record = read_record(root);
-  if (record === void 0) return void 0;
-  const fetched = await fetch_issue({ issue: record.issue });
-  if (fetched.kind !== "read") return void 0;
-  const diff = issue_watch_diff.unread_diff(record, fetched.snapshot);
-  const acknowledged_at = diff === void 0 ? record.acknowledged_at : now.toISOString();
-  write_record(fresh_record(record.issue, fetched, now, acknowledged_at), root);
-  return { issue: record.issue, diff };
-}
-var issue_watch = {
-  acknowledge,
-  clear: clear2,
-  clear_here: clear_here2,
-  mark_shown,
-  poll,
-  read_record,
-  record_baseline,
-  record_baseline_here,
-  record_path
-};
-
-// scripts/issue/issue-watch-gate.ts
-var EVERY_CALL_MS = 0;
-function ack_command(issue) {
-  return `pnpm josh issue:ack ${issue}`;
-}
-function unread_message(record) {
-  return [
-    `A person updated issue ${session_cite.issue(record.issue)} after this run read it, and the run has not taken the update in:`,
-    record.pending ?? "",
-    `Read it, compare it with the acceptance criteria, fix what it changes, then run \`${ack_command(record.issue)}\` to record that it was read.`
-  ].join("\n\n");
-}
-function review_message(record, briefed_at) {
-  return [
-    `Issue ${session_cite.issue(record.issue)} was updated after the review was briefed (taken in at ${record.acknowledged_at}, briefed at ${briefed_at}), so the review read the earlier specification.`,
-    "Re-run `/code-review` with a fresh `pnpm josh review:brief`, so the review reads the change against the updated issue."
-  ].join("\n");
-}
-async function polled(root) {
-  return await issue_watch.poll({ interval_ms: EVERY_CALL_MS }, root);
-}
-async function unread_refusal(root) {
-  const record = await polled(root);
-  return record?.pending === void 0 ? void 0 : unread_message(record);
-}
-async function review_refusal(root) {
-  const record = await polled(root);
-  if (record === void 0) return void 0;
-  if (record.pending !== void 0) return unread_message(record);
-  const pointer = review_attest.read_pointer(root);
-  if (pointer === void 0 || record.acknowledged_at <= pointer.taken_at) return void 0;
-  return review_message(record, pointer.taken_at);
-}
-async function review_refusal_here() {
-  return await review_refusal(await git_command.repository_root());
-}
-async function assert_read_here() {
-  const refusal = await unread_refusal(await git_command.repository_root());
-  if (refusal !== void 0) throw new Error(refusal);
-}
-var issue_watch_gate = {
-  assert_read_here,
-  review_refusal,
-  review_refusal_here,
-  unread_message,
-  unread_refusal
-};
-
-// scripts/gh/git-gh-pr-rest.ts
-import { z as z8 } from "zod";
-var rest_repo_schema = z8.looseObject({ full_name: z8.string().optional() }).nullish();
-var rest_pull_side_schema = z8.looseObject({ ref: z8.string().optional(), repo: rest_repo_schema });
-var rest_pull_schema = z8.looseObject({
-  number: z8.number(),
-  html_url: z8.string().optional(),
-  body: z8.string().nullish(),
-  state: z8.string().optional(),
-  merged: z8.boolean().nullish(),
-  merged_at: z8.string().nullish(),
-  mergeable: z8.boolean().nullish(),
-  mergeable_state: z8.string().optional(),
-  // `sha` is the head commit, which is what both halves of the merge-gate rollup are keyed by —
-  // REST hangs the check runs and the status contexts off the commit rather than off the pull
-  // request.
-  head: z8.looseObject({ ref: z8.string().optional(), sha: z8.string().optional(), repo: rest_repo_schema }).nullish(),
-  base: rest_pull_side_schema.nullish(),
-  // `node_id` is what the GraphQL auto-merge mutation addresses a pull request by, and `auto_merge`
-  // is `null` until auto-merge is enabled — both read by `git-gh-pr-auto-merge.ts`.
-  node_id: z8.string().optional(),
-  auto_merge: z8.looseObject({}).nullish()
-});
-var NOT_A_PULL_MESSAGE = "gh api answered something other than a pull request object";
-var NOT_A_PULL_LISTING_MESSAGE = "gh api answered something other than a pull request listing";
-var NOT_A_COMMENT_LISTING_MESSAGE = "gh api answered something other than a comment listing";
-var OPEN_STATE = "open";
-var EMPTY_BODY2 = "";
-function parse_rest_pull(rest_json) {
-  const parsed = parse_json_object_or_undefined(rest_json, rest_pull_schema);
-  if (parsed === void 0) throw new Error(NOT_A_PULL_MESSAGE);
-  return parsed;
-}
-function parse_rest_pulls(rest_json) {
-  const parsed = parse_json_array_or_undefined(rest_json, rest_pull_schema);
-  if (parsed === void 0) throw new Error(NOT_A_PULL_LISTING_MESSAGE);
-  return parsed;
-}
-function select_pull(pulls) {
-  return pulls.find((pull) => pull.state === OPEN_STATE) ?? pulls[0];
-}
-function is_merged(pull) {
-  return pull.merged === true || typeof pull.merged_at === "string";
-}
-function to_pr_state(pull) {
-  return is_merged(pull) ? MERGED_STATE : to_gh_state(pull.state);
-}
-function to_repo_name(side) {
-  return side?.repo?.full_name;
-}
-function is_same_repository_head(pull) {
-  const head_repo = to_repo_name(pull.head);
-  return head_repo !== void 0 && head_repo === to_repo_name(pull.base);
-}
-function to_pr_info(pull) {
-  return {
-    mergeable: pull.mergeable,
-    mergeStateStatus: to_gh_state(pull.mergeable_state),
-    state: to_pr_state(pull)
-  };
-}
-function to_pr_comments(rest_json) {
-  const parsed = parse_json_array_or_undefined(rest_json, rest_comment_schema);
-  if (parsed === void 0) throw new Error(NOT_A_COMMENT_LISTING_MESSAGE);
-  return parsed.map((comment) => ({
-    body: comment.body ?? EMPTY_BODY2,
-    url: comment.html_url,
-    author: { login: comment.user?.login }
-  }));
-}
-var git_gh_pr_rest = {
-  parse_rest_pull,
-  parse_rest_pulls,
-  select_pull,
-  is_same_repository_head,
-  is_merged,
-  to_pr_state,
-  to_pr_info,
-  to_pr_comments
-};
-
-// scripts/gh/git-gh-pr-read.ts
-var pr_number_by_branch = /* @__PURE__ */ new Map();
-var LOOKUP_QUERY = "state=all&sort=created&direction=desc&per_page=100";
-var COMMENTS_QUERY = FULL_PAGE_QUERY;
-var OWNER_PLACEHOLDER = "{owner}";
-var NO_PULL_REQUEST_MESSAGE = "gh api found no pull request for branch";
-var UNREADABLE_PULL_REQUEST_MESSAGE = "gh api could not read the pull requests for branch";
-function lookup_path(branch_name) {
-  const head = `${OWNER_PLACEHOLDER}:${encodeURIComponent(branch_name)}`;
-  return `${git_gh_api_path.pulls_api_path()}?head=${head}&${LOOKUP_QUERY}`;
-}
-async function fetch_pr_number(branch_name) {
-  const json = await git_gh_exec.exec_gh_api({ path: lookup_path(branch_name) });
-  return git_gh_pr_rest.select_pull(git_gh_pr_rest.parse_rest_pulls(json))?.number;
-}
-var pending_pr_number_by_branch = /* @__PURE__ */ new Map();
-var pull_by_number = /* @__PURE__ */ new Map();
-async function fetch_pr_number_read(branch_name) {
-  try {
-    const pr_number = await fetch_pr_number(branch_name);
-    if (pr_number === void 0) return { kind: "missing" };
-    pr_number_by_branch.set(branch_name, pr_number);
-    return { kind: "read", pr_number };
-  } catch (error) {
-    return { kind: "unreadable", cause: error };
-  }
-}
-async function start_pr_number_read(branch_name) {
-  const pending = pending_pr_number_by_branch.get(branch_name);
-  if (pending !== void 0) return await pending;
-  const lookup = fetch_pr_number_read(branch_name);
-  pending_pr_number_by_branch.set(branch_name, lookup);
-  try {
-    return await lookup;
-  } finally {
-    pending_pr_number_by_branch.delete(branch_name);
-  }
-}
-function forget_pr_numbers() {
-  pr_number_by_branch.clear();
-  pending_pr_number_by_branch.clear();
-  pull_by_number.clear();
-}
-async function read_pr_number(branch_name) {
-  const cached = pr_number_by_branch.get(branch_name);
-  if (cached !== void 0) return { kind: "read", pr_number: cached };
-  return await start_pr_number_read(branch_name);
-}
-async function resolve_pr_number(branch_name) {
-  const read = await read_pr_number(branch_name);
-  return read.kind === "read" ? read.pr_number : void 0;
-}
-function to_unreadable_error(branch_name, cause) {
-  return new Error(`${UNREADABLE_PULL_REQUEST_MESSAGE}: ${branch_name}`, { cause });
-}
-async function require_pr_number(branch_name) {
-  const read = await read_pr_number(branch_name);
-  if (read.kind === "read") return read.pr_number;
-  if (read.kind === "missing") throw new Error(`${NO_PULL_REQUEST_MESSAGE}: ${branch_name}`);
-  throw to_unreadable_error(branch_name, read.cause);
-}
-async function read_pull(pr_number) {
-  const json = await git_gh_exec.exec_gh_api({
-    path: git_gh_api_path.pull_api_path(String(pr_number))
-  });
-  return git_gh_pr_rest.parse_rest_pull(json);
-}
-async function read_remembered_pull(pr_number) {
-  const pending = pull_by_number.get(pr_number) ?? read_pull(pr_number);
-  pull_by_number.set(pr_number, pending);
-  try {
-    return await pending;
-  } catch (error) {
-    if (pull_by_number.get(pr_number) === pending) pull_by_number.delete(pr_number);
-    throw error;
-  }
-}
-async function read_pull_of_branch(branch_name, read = read_remembered_pull) {
-  const number_read = await read_pr_number(branch_name);
-  if (number_read.kind !== "read") return number_read;
-  try {
-    return { kind: "read", pull: await read(number_read.pr_number) };
-  } catch (error) {
-    return { kind: "unreadable", cause: error };
-  }
-}
-async function read_pull_or_undefined(branch_name) {
-  const read = await read_pull_of_branch(branch_name);
-  return read.kind === "read" ? read.pull : void 0;
-}
-async function pr_exists(branch_name) {
-  const read = await read_pr_number(branch_name);
-  if (read.kind === "unreadable") throw to_unreadable_error(branch_name, read.cause);
-  return read.kind === "read";
-}
-async function pr_get_number(branch_name) {
-  return await resolve_pr_number(branch_name);
-}
-async function pr_get_url(branch_name) {
-  const pull = await read_pull_or_undefined(branch_name);
-  if (pull?.html_url === void 0) return void 0;
-  return git_gh_helpers.parse_pr_state_string(pull.html_url);
-}
-async function pr_get_merge_state(branch_name) {
-  const read = await read_pull_of_branch(branch_name, read_pull);
-  if (read.kind !== "read") return void 0;
-  const { pull } = read;
-  return {
-    is_merged: git_gh_pr_rest.is_merged(pull),
-    merged_at: pull.merged_at ?? void 0,
-    head_sha: pull.head?.sha,
-    merge_state_status: to_gh_state(pull.mergeable_state)
-  };
-}
-async function pr_get_body(branch_name) {
-  const pull = await read_pull_or_undefined(branch_name);
-  const body = pull?.body;
-  return typeof body === "string" && body.length > 0 ? body : void 0;
-}
-async function pr_view(branch_name) {
-  const read = await read_pull_of_branch(branch_name, read_pull);
-  if (read.kind === "unreadable") throw to_unreadable_error(branch_name, read.cause);
-  if (read.kind === "missing") return "";
-  return JSON.stringify(git_gh_pr_rest.to_pr_info(read.pull));
-}
-async function read_comments(branch_name, to_path, to_json) {
-  const pr_number = await resolve_pr_number(branch_name);
-  if (pr_number === void 0) return void 0;
-  const path5 = `${to_path(String(pr_number))}${COMMENTS_QUERY}`;
-  try {
-    return to_json(await git_gh_exec.exec_gh_api({ path: path5, should_paginate: true }));
-  } catch {
-    return void 0;
-  }
-}
-function to_comments_json(raw) {
-  return JSON.stringify(git_gh_pr_rest.to_pr_comments(raw));
-}
-function as_served(raw) {
-  return raw;
-}
-async function pr_get_comments(branch_name) {
-  return await read_comments(branch_name, git_gh_api_path.issue_comments_api_path, to_comments_json);
-}
-async function pr_get_review_comments(branch_name) {
-  return await read_comments(branch_name, git_gh_api_path.pull_comments_api_path, as_served);
-}
-var git_gh_pr_read = {
-  pr_exists,
-  pr_get_number,
-  pr_get_url,
-  pr_get_body,
-  pr_get_merge_state,
-  pr_view,
-  pr_get_comments,
-  pr_get_review_comments
-};
-
-// scripts/observations/observation-ledger.ts
-var OBSERVATION_LEDGER_DIRECTORY = ".josh/observations";
-var LEGACY_OBSERVATION_LEDGER_DIRECTORY = "docs/maintainers/observations";
-var LEDGER_DIRECTORIES = [
-  OBSERVATION_LEDGER_DIRECTORY,
-  LEGACY_OBSERVATION_LEDGER_DIRECTORY
-];
-var LEDGER_FILE_EXTENSION = ".md";
-var LEGACY_LEDGER_FILE = `legacy${LEDGER_FILE_EXTENSION}`;
-var LEGACY_OBSERVATION_LEDGER_PATHS = [
-  "docs/maintainers/observations.md",
-  "docs/observations.md"
-];
-var STATUS_PATH_INDEX = 3;
-function status_path(line) {
-  return line.slice(STATUS_PATH_INDEX).trim();
-}
-function ledger_file(name) {
-  return `${OBSERVATION_LEDGER_DIRECTORY}/${String(name)}${LEDGER_FILE_EXTENSION}`;
-}
-function is_ledger_file_name(name) {
-  return name.endsWith(LEDGER_FILE_EXTENSION);
-}
-var MIGRATION_CLAIM_SUFFIX = ".migrating";
-function is_legacy_directory_file(file_path) {
-  return file_path.startsWith(`${LEGACY_OBSERVATION_LEDGER_DIRECTORY}/`);
-}
-function is_migration_claim(file_path) {
-  if (!file_path.endsWith(MIGRATION_CLAIM_SUFFIX)) return false;
-  return is_legacy_directory_file(file_path) || LEGACY_OBSERVATION_LEDGER_PATHS.some((legacy) => file_path.startsWith(`${legacy}.`));
-}
-function is_in_directory(file_path) {
-  return LEDGER_DIRECTORIES.some((directory) => file_path.startsWith(`${directory}/`));
-}
-function is_ledger_path(file_path) {
-  return is_in_directory(file_path) || LEGACY_OBSERVATION_LEDGER_PATHS.includes(file_path) || is_migration_claim(file_path);
-}
-var LEDGER_EXCLUSION_PATHSPEC = [
-  ":/",
-  ...LEDGER_DIRECTORIES.map((directory) => `:(top,exclude)${directory}`),
-  ...LEGACY_OBSERVATION_LEDGER_PATHS.map((legacy) => `:(top,exclude)${legacy}`),
-  ...LEGACY_OBSERVATION_LEDGER_PATHS.map(
-    (legacy) => `:(top,exclude,glob)${legacy}.*${MIGRATION_CLAIM_SUFFIX}`
-  )
-];
-function is_ledger_line(line) {
-  return is_ledger_path(status_path(line));
-}
-function ledger_paths(status_output) {
-  return status_output.split("\n").filter((line) => is_ledger_line(line)).map((line) => status_path(line));
-}
-function has_pending_append(status_output) {
-  return status_output.split("\n").some((line) => is_ledger_line(line));
-}
-var observation_ledger = {
-  has_pending_append,
-  is_ledger_file_name,
-  is_ledger_line,
-  is_ledger_path,
-  is_migration_claim,
-  ledger_file,
-  ledger_paths,
-  status_path
-};
-
-// scripts/git/stash/git-stash.ts
-var ENTRY_SEPARATOR = "\n";
-var FIELD_SEPARATOR2 = "\0";
-var LIST_FORMAT = "--format=%gd%x00%gs";
-var SUBJECT_MESSAGE_SEPARATOR = ": ";
-var HASH_FORMAT = "--format=%H%x00%gs";
-var HASH_POSITION_FORMAT = "--format=%H%x00%gd";
-var NAME_ONLY_FLAG = "--name-only";
-var ADDED_PREFIX2 = "+";
-var FILE_HEADER_PREFIX = "+++";
-function to_entry(line) {
-  const [selector, subject] = line.split(FIELD_SEPARATOR2);
-  if (selector === void 0 || subject === void 0) return void 0;
-  return { selector, subject };
-}
-function parse_entries(raw) {
-  if (raw === "") return [];
-  return raw.split(ENTRY_SEPARATOR).map((line) => to_entry(line)).filter((entry) => entry !== void 0);
-}
-function matches(subject, message) {
-  return subject === message || subject.endsWith(`${SUBJECT_MESSAGE_SEPARATOR}${message}`);
-}
-function select(entries, message) {
-  const found = entries.filter((entry) => matches(entry.subject, message));
-  const [first] = found;
-  if (first === void 0) return { kind: "none" };
-  if (found.length > 1) {
-    return { kind: "ambiguous", selectors: found.map((entry) => entry.selector) };
-  }
-  return { kind: "match", selector: first.selector };
-}
-function git_args(directory, args) {
-  return directory === void 0 ? args : ["-C", directory, ...args];
-}
-async function list(directory) {
-  return parse_entries(await git_spawn.read(git_args(directory, ["stash", "list", LIST_FORMAT])));
-}
-async function pop(selector, directory) {
-  await git_spawn.read(git_args(directory, ["stash", "pop", selector]));
-}
-async function has_conflict(directory) {
-  const unmerged = await git_spawn.read(
-    git_args(directory, ["diff", NAME_ONLY_FLAG, "--diff-filter=U"])
-  );
-  return unmerged !== "";
-}
-async function has_changes(directory, pathspec = []) {
-  const status = await git_spawn.read(git_args(directory, ["status", "--porcelain", ...pathspec]));
-  return status !== "";
-}
-var STASHABLE_PATHSPEC = ["--", ...LEDGER_EXCLUSION_PATHSPEC];
-async function has_stashable_changes(directory) {
-  return await has_changes(directory, STASHABLE_PATHSPEC);
-}
-async function push(message, directory, pathspec = []) {
-  await git_spawn.read(git_args(directory, ["stash", "push", "-u", "-m", message, ...pathspec]));
-}
-async function list_by_hash(directory) {
-  return parse_entries(await git_spawn.read(git_args(directory, ["stash", "list", HASH_FORMAT])));
-}
-async function changed_paths2(hash, directory) {
-  const raw = await git_spawn.read(
-    git_args(directory, ["stash", "show", "--include-untracked", NAME_ONLY_FLAG, hash])
-  );
-  return raw === "" ? [] : raw.split(ENTRY_SEPARATOR);
-}
-async function untracked_lines(hash, file, directory) {
-  try {
-    const raw = await git_spawn.read(git_args(directory, ["show", `${hash}^3:${file}`]));
-    return raw === "" ? [] : raw.split(ENTRY_SEPARATOR);
-  } catch {
-    return [];
-  }
-}
-async function added_lines(hash, file, directory) {
-  const diff = await git_spawn.read(git_args(directory, ["diff", `${hash}^1`, hash, "--", file]));
-  if (diff === "") return await untracked_lines(hash, file, directory);
-  return diff.split(ENTRY_SEPARATOR).filter((line) => line.startsWith(ADDED_PREFIX2) && !line.startsWith(FILE_HEADER_PREFIX)).map((line) => line.slice(ADDED_PREFIX2.length));
-}
-async function drop_by_hash(hash, directory) {
-  const raw = await git_spawn.read(git_args(directory, ["stash", "list", HASH_POSITION_FORMAT]));
-  const entry = parse_entries(raw).find((candidate) => candidate.selector === hash);
-  if (entry === void 0) return false;
-  await git_spawn.read(git_args(directory, ["stash", "drop", entry.subject]));
-  return true;
-}
-function work_message(issue, occasion) {
-  return `${issue}: uncommitted work at ${occasion}`;
-}
-var git_stash = {
-  added_lines,
-  changed_paths: changed_paths2,
-  drop_by_hash,
-  has_changes,
-  has_conflict,
-  has_stashable_changes,
-  list,
-  list_by_hash,
-  matches,
-  parse_entries,
-  pop,
-  push,
-  select,
-  STASHABLE_PATHSPEC,
-  work_message
-};
-
-// scripts/lane/lane-registry.ts
-import { existsSync, statSync } from "node:fs";
-import path from "node:path";
-
-// scripts/lane/lane-environment.ts
-var LANE_OUTPUT_KEY = "JOSH_LANE_OUTPUT";
-var LANE_PROVIDER_KEY = "JOSH_LANE_AGENT_PROVIDER";
-var LANE_ROLE_KEY = "JOSH_LANE_AGENT_ROLE";
-var LANE_MODEL_KEY = "JOSH_LANE_AGENT_MODEL";
-var LANE_EFFORT_KEY = "JOSH_LANE_AGENT_EFFORT";
-var ASSIGNMENT_SEPARATOR = "=";
-var EXPORT_PREFIX = "export ";
-var QUOTE_CHARACTERS = /* @__PURE__ */ new Set(['"', "'"]);
-var MIN_QUOTED_LENGTH = 2;
-var FIRST_CHARACTER_END = 1;
-var LAST_CHARACTER_START = -1;
-function strip_export(line) {
-  const trimmed2 = line.trimStart();
-  return trimmed2.startsWith(EXPORT_PREFIX) ? trimmed2.slice(EXPORT_PREFIX.length).trimStart() : trimmed2;
-}
-function is_key_line(line, key) {
-  const body = strip_export(line);
-  if (!body.startsWith(key)) return false;
-  return body.slice(key.length).trimStart().startsWith(ASSIGNMENT_SEPARATOR);
-}
-function is_seat_line(line) {
-  return is_key_line(line, LANE_SEAT_KEY);
-}
-function is_output_line(line) {
-  return is_key_line(line, LANE_OUTPUT_KEY);
-}
-function split_lines(content) {
-  const trimmed2 = content.trimEnd();
-  return trimmed2.length === 0 ? [] : trimmed2.split("\n");
-}
-function is_quoted(raw) {
-  const first = raw.slice(0, FIRST_CHARACTER_END);
-  if (!QUOTE_CHARACTERS.has(first)) return false;
-  return raw.length >= MIN_QUOTED_LENGTH && raw.endsWith(first);
-}
-function unquote(raw) {
-  return is_quoted(raw) ? raw.slice(FIRST_CHARACTER_END, LAST_CHARACTER_START) : raw;
-}
-function assignment_value(line) {
-  return unquote(line.slice(line.indexOf(ASSIGNMENT_SEPARATOR) + FIRST_CHARACTER_END).trim());
-}
-function read_assignment(content, key) {
-  const line = split_lines(content).findLast((entry) => is_key_line(entry, key));
-  return line === void 0 ? void 0 : assignment_value(line);
-}
-function read_root_seed(content) {
-  return ports.resolve_seed({ [PORT_SEED_KEY]: read_assignment(content, PORT_SEED_KEY) });
-}
-function read_lane_seat(content) {
-  const raw = read_assignment(content, LANE_SEAT_KEY);
-  return raw === void 0 ? void 0 : ports.resolve_lane({ [LANE_SEAT_KEY]: raw });
-}
-function read_lane_ports(content) {
-  const environment3 = {
-    [PORT_SEED_KEY]: read_assignment(content, PORT_SEED_KEY),
-    [LANE_SEAT_KEY]: read_assignment(content, LANE_SEAT_KEY)
-  };
-  return {
-    development: ports.resolve_development_port(environment3),
-    preview: ports.resolve_preview_port(environment3)
-  };
-}
-function read_lane_output(content) {
-  const line = split_lines(content).findLast((entry) => is_output_line(entry));
-  const raw = line === void 0 ? void 0 : assignment_value(line);
-  return raw === void 0 || raw.length === 0 ? void 0 : raw;
-}
-function read_lane_profile(content) {
-  return agent_role_profile.parse({
-    provider: read_assignment(content, LANE_PROVIDER_KEY),
-    role: read_assignment(content, LANE_ROLE_KEY),
-    model: read_assignment(content, LANE_MODEL_KEY),
-    effort: read_assignment(content, LANE_EFFORT_KEY)
-  });
-}
-function replace_assignment(lines, keep, assignment, key) {
-  return lines.flatMap((entry, index) => {
-    if (index === keep) return [assignment];
-    if (is_key_line(entry, key)) return [];
-    return [entry];
-  });
-}
-function upsert_assignment(content, key, value) {
-  const assignment = `${key}${ASSIGNMENT_SEPARATOR}${value}`;
-  const lines = split_lines(content);
-  const last = lines.findLastIndex((entry) => is_key_line(entry, key));
-  const body = last === -1 ? [...lines, assignment] : replace_assignment(lines, last, assignment, key);
-  return `${body.join("\n")}
-`;
-}
-function lane_file_content(root_content, seat) {
-  return upsert_assignment(root_content, LANE_SEAT_KEY, String(seat));
-}
-function with_lane_output(content, output, profile) {
-  const recorded = upsert_assignment(content, LANE_OUTPUT_KEY, `"${output}"`);
-  if (profile === void 0) return recorded;
-  const with_provider = upsert_assignment(recorded, LANE_PROVIDER_KEY, profile.provider);
-  const with_role = upsert_assignment(with_provider, LANE_ROLE_KEY, profile.role);
-  const with_model = upsert_assignment(with_role, LANE_MODEL_KEY, profile.model);
-  return upsert_assignment(with_model, LANE_EFFORT_KEY, profile.effort);
-}
-var lane_environment = {
-  is_seat_line,
-  lane_file_content,
-  read_lane_output,
-  read_lane_profile,
-  read_lane_ports,
-  read_lane_seat,
-  read_root_seed,
-  with_lane_output
-};
-
-// scripts/lane/lane-registry.ts
-var WORKTREE_PREFIX = "worktree ";
-var BRANCH_PREFIX = "branch refs/heads/";
-var BLOCK_SEPARATOR = "\n\n";
-function line_value(lines, prefix) {
-  return lines.find((line) => line.startsWith(prefix))?.slice(prefix.length);
-}
-function seat_from_content(content) {
-  const seat = lane_environment.read_lane_seat(content);
-  if (seat === void 0) return void 0;
-  const port_pair = lane_environment.read_lane_ports(content);
-  return { seat, development_port: port_pair.development, preview_port: port_pair.preview };
-}
-var EMPTY_SEAT = {
-  seat: void 0,
-  development_port: void 0,
-  preview_port: void 0
-};
-function held_seat(content) {
-  if (content === void 0) return EMPTY_SEAT;
-  return seat_from_content(content) ?? EMPTY_SEAT;
-}
-function read_environment(directory) {
-  return file_reader.read_if_readable(path.join(directory, ENV_FILE_NAME));
-}
-function dispatched_at(directory) {
-  return statSync(path.join(directory, ENV_FILE_NAME), { throwIfNoEntry: false })?.mtimeMs;
-}
-function branch_issue(branch) {
-  if (!branch?.endsWith(lane_paths.LANE_BRANCH_SUFFIX)) return void 0;
-  const issue = branch.slice(0, -lane_paths.LANE_BRANCH_SUFFIX.length);
-  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue) ? issue : void 0;
-}
-function is_gone(directory) {
-  return !existsSync(directory);
-}
-function build_lane(issue, branch, directory, is_stranded) {
-  const content = is_stranded ? void 0 : read_environment(directory);
-  const held = held_seat(content);
-  const output = content === void 0 ? void 0 : lane_environment.read_lane_output(content);
-  const profile = content === void 0 ? void 0 : lane_environment.read_lane_profile(content);
-  return {
-    issue,
-    branch,
-    directory,
-    seat: held.seat,
-    development_port: held.development_port,
-    preview_port: held.preview_port,
-    output,
-    profile,
-    dispatched_ms: is_stranded ? void 0 : dispatched_at(directory),
-    is_stranded
-  };
-}
-function is_lane_directory(root, issue, directory) {
-  return directory === lane_paths.lane_directory(root, issue);
-}
-function parse_block(block, root) {
-  const lines = block.split("\n");
-  const directory = line_value(lines, WORKTREE_PREFIX);
-  const branch = line_value(lines, BRANCH_PREFIX);
-  const issue = branch_issue(branch);
-  if (directory === void 0 || branch === void 0 || issue === void 0 || !is_lane_directory(root, issue, directory)) {
-    return void 0;
-  }
-  return build_lane(issue, branch, directory, is_gone(directory));
-}
-function is_lane(lane) {
-  return lane !== void 0;
-}
-async function worktree_blocks() {
-  const listing = await git_worktree.worktree_list();
-  return listing.split(BLOCK_SEPARATOR);
-}
-async function main_repository_root() {
-  return repo_discovery.main_worktree(await git_command.repository_root());
-}
-async function lane_root_directory() {
-  return lane_paths.lane_root(await main_repository_root());
-}
-async function lane_location(issue) {
-  return { issue, directory: lane_paths.lane_directory(await lane_root_directory(), issue) };
-}
-async function list_lanes(main_root) {
-  const root = lane_paths.lane_root(main_root ?? await main_repository_root());
-  const blocks = await worktree_blocks();
-  const lanes = blocks.map((block) => parse_block(block, root)).filter(is_lane);
-  return lanes.toSorted((left, right) => Number(left.issue) - Number(right.issue));
-}
-async function registered_directories() {
-  const blocks = await worktree_blocks();
-  return blocks.flatMap((block) => line_value(block.split("\n"), WORKTREE_PREFIX) ?? []);
-}
-async function has_lanes_in_flight() {
-  const lanes = await list_lanes();
-  return lanes.some((lane) => !lane.is_stranded);
-}
-function used_seats(lanes) {
-  return lanes.map((lane) => lane.seat).filter((seat) => seat !== void 0);
-}
-function unreadable_lanes(lanes) {
-  return lanes.filter((lane) => !lane.is_stranded && lane.seat === void 0);
-}
-function find_lane(lanes, issue) {
-  return lanes.find((lane) => lane.issue === issue);
-}
-async function find_open_lane(issue) {
-  return find_lane(await list_lanes(), issue);
-}
-var lane_registry = {
-  find_lane,
-  find_open_lane,
-  has_lanes_in_flight,
-  lane_location,
-  lane_root_directory,
-  list_lanes,
-  main_repository_root,
-  parse_block,
-  read_environment,
-  registered_directories,
-  unreadable_lanes,
-  used_seats
-};
-
-// scripts/run/run-preflight.ts
-import { z as z9 } from "zod";
-var CLEAN_VERDICT = "clean";
-var RECLAIM_VERDICT = "reclaim";
-var RESUME_VERDICT = "resume";
-var PARK_VERDICT = "park";
-var NO_PR = "none";
-var OPEN_PR = "open";
-var MERGED_PR = "merged";
-var CLOSED_PR = "closed";
-var NO_CHILD_WORK = { branch_name: void 0, pr_state: NO_PR };
-var pr_info_schema = z9.object({ state: z9.string().optional() });
-var GH_PR_STATES = /* @__PURE__ */ new Map([
-  ["CLOSED", CLOSED_PR],
-  ["MERGED", MERGED_PR],
-  ["OPEN", OPEN_PR]
-]);
-var CLEAN_REASON = "Nothing was left behind: the tree is clean, HEAD is on the default branch, and this issue has no pull request and no branch holding work.";
-var CLEAN_ADVICE = "Start the child.";
-var RESUME_ADVICE = "Reuse the branch and run the whole verification gate from the start \u2014 refactor, `pnpm josh gate`, `/code-review` \u2014 never only the part the interrupted run had not reached. Nobody verified what it already committed.";
-var PARK_ADVICE = "Park the child: add `needs-decision` and comment what was found. Do not delete the branch, do not reopen the pull request, and do not commit on top of it.";
-var STASH_LABEL_PREFIX = "run:hold reclaimed before #";
-var { require_issue_number } = issue_number_shape;
-var UNREADABLE_PR_MESSAGE = "The pull request could not be read for branch ";
-function needs_reclaim(tree) {
-  return tree.is_dirty || tree.branch !== tree.default_branch;
-}
-function is_pr_decided(state) {
-  return state === MERGED_PR || state === CLOSED_PR;
-}
-function has_leftover_work(child) {
-  return child.branch_name !== void 0 || child.pr_state === OPEN_PR;
-}
-function to_verdict(tree, child) {
-  if (needs_reclaim(tree)) return RECLAIM_VERDICT;
-  if (is_pr_decided(child.pr_state)) return PARK_VERDICT;
-  if (has_leftover_work(child)) return RESUME_VERDICT;
-  return CLEAN_VERDICT;
-}
-function reclaim_reason(tree) {
-  const findings = [
-    tree.is_dirty ? "uncommitted changes" : void 0,
-    tree.branch === tree.default_branch ? void 0 : `HEAD on ${tree.branch}`
-  ].filter((entry) => entry !== void 0);
-  return `An earlier run left ${findings.join(" and ")} in this working tree.`;
-}
-function park_reason(state) {
-  return `The pull request for this issue is ${state}, so whether any work is still owed is a person's call.`;
-}
-function resume_reason(child) {
-  const branch_part = child.branch_name === void 0 ? "" : ` on branch ${child.branch_name}`;
-  const pr_part = child.pr_state === OPEN_PR ? ", and its pull request is still open" : "";
-  return `An earlier run left a partial implementation${branch_part}${pr_part}.`;
-}
-function to_reason(verdict, tree, child) {
-  if (verdict === RECLAIM_VERDICT) return reclaim_reason(tree);
-  if (verdict === PARK_VERDICT) return park_reason(child.pr_state);
-  if (verdict === RESUME_VERDICT) return resume_reason(child);
-  return CLEAN_REASON;
-}
-function reclaim_steps(tree, issue) {
-  if (!tree.is_dirty) return [];
-  return [
-    `pnpm josh stash:push "${STASH_LABEL_PREFIX}${issue}"`,
-    `Record the stash on ${session_cite.issue(issue)} \u2014 the comment is what gets it popped; nothing pops it for you.`
-  ];
-}
-function reclaim_advice(tree, issue) {
-  return [
-    ...reclaim_steps(tree, issue),
-    "pnpm josh ms",
-    "Then ask this command again: it is re-askable, and the clean tree gets its own answer."
-  ].join("\n");
-}
-function to_advice(verdict, issue, tree) {
-  if (verdict === RECLAIM_VERDICT) return reclaim_advice(tree, issue);
-  if (verdict === RESUME_VERDICT) return RESUME_ADVICE;
-  if (verdict === PARK_VERDICT) return PARK_ADVICE;
-  return CLEAN_ADVICE;
-}
-function decide(tree, child, issue) {
-  const verdict = to_verdict(tree, child);
-  return {
-    advice: to_advice(verdict, issue, tree),
-    reason: to_reason(verdict, tree, child),
-    verdict
-  };
-}
-function read_pr_field(raw) {
-  return json_value.parse_with(raw, pr_info_schema)?.state;
-}
-function to_pr_state2(raw) {
-  const state = read_pr_field(raw);
-  return (state === void 0 ? void 0 : GH_PR_STATES.get(state)) ?? NO_PR;
-}
-async function has_stashable_work() {
-  try {
-    return await git_stash.has_stashable_changes();
-  } catch (error) {
-    error_text.trace_swallowed("run_preflight.has_stashable_work", error);
-    return true;
-  }
-}
-async function read_tree_state() {
-  const [is_dirty, current, default_branch] = await Promise.all([
-    has_stashable_work(),
-    git_command.branch(),
-    git_command.get_default_branch()
-  ]);
-  return { branch: current, default_branch, is_dirty };
-}
-async function read_pr_state(branch_name) {
-  if (!await git_gh_pr_read.pr_exists(branch_name)) return NO_PR;
-  const raw = await git_gh_pr_read.pr_view(branch_name);
-  if (raw === "") throw new Error(`${UNREADABLE_PR_MESSAGE}${branch_name}`);
-  return to_pr_state2(raw);
-}
-function is_pr_open(state) {
-  return state === OPEN_PR;
-}
-async function read_pr_of_branch(branch_name) {
-  return { branch_name, pr_state: await read_pr_state(branch_name) };
-}
-function pick_child_state(reads) {
-  const decided = reads.find((read) => is_pr_decided(read.pr_state));
-  const open = reads.find((read) => is_pr_open(read.pr_state));
-  return decided ?? open ?? { branch_name: reads[0]?.branch_name, pr_state: NO_PR };
-}
-var ISSUE_BRANCH_SUFFIX = "-*";
-var ANY_REMOTE_PREFIX = "*/";
-var REMOTE_SEPARATOR = "/";
-var NOT_FOUND_INDEX = -1;
-function to_head_branch(name) {
-  const separator_index = name.indexOf(REMOTE_SEPARATOR);
-  return separator_index === NOT_FOUND_INDEX ? name : name.slice(separator_index + 1);
-}
-function group_by_head(pairs) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const [name, reference] of pairs) groups.set(name, [...groups.get(name) ?? [], reference]);
-  return groups;
-}
-async function read_branch_candidates(issue) {
-  const pattern = `${issue}${ISSUE_BRANCH_SUFFIX}`;
-  const [local, remote] = await Promise.all([
-    git_command.branch_names(pattern),
-    git_command.branch_names_remote(`${ANY_REMOTE_PREFIX}${pattern}`)
-  ]);
-  return group_by_head([
-    ...local.map((name) => [name, name]),
-    ...remote.map((reference) => [to_head_branch(reference), reference])
-  ]);
-}
-async function has_commits_beyond(base, references) {
-  const counts = await Promise.all(
-    references.map(async (reference) => await git_command.commit_count_beyond(base, reference))
-  );
-  return counts.some((count) => count > 0);
-}
-async function is_held_dirty(name, lane) {
-  if (lane?.branch !== name || lane.is_stranded) return false;
-  return await run_hold.is_tree_dirty(lane.directory);
-}
-async function read_candidate(name, references, context) {
-  const state = await read_pr_of_branch(name);
-  if (state.pr_state !== NO_PR || await has_commits_beyond(context.base, references)) return state;
-  return await is_held_dirty(name, context.lane) ? state : void 0;
-}
-async function read_child_state(issue) {
-  const candidates = await read_branch_candidates(issue);
-  if (candidates.size === 0) return NO_CHILD_WORK;
-  const [base, lane] = await Promise.all([
-    git_command.default_branch_reference(),
-    lane_registry.find_open_lane(issue)
-  ]);
-  const reads = await Promise.all(
-    [...candidates].map(
-      async ([name, references]) => await read_candidate(name, references, { base, lane })
-    )
-  );
-  return pick_child_state(reads.filter((read) => read !== void 0));
-}
-async function check2(issue) {
-  require_issue_number(issue);
-  const tree = await read_tree_state();
-  if (needs_reclaim(tree)) return decide(tree, NO_CHILD_WORK, issue);
-  return decide(tree, await read_child_state(issue), issue);
-}
-var run_preflight = {
-  CLEAN_VERDICT,
-  RESUME_ADVICE,
-  MERGED_PR,
-  STASH_LABEL_PREFIX,
-  check: check2,
-  decide,
-  read_child_state,
-  read_pr_state,
-  to_pr_state: to_pr_state2
-};
-
-// scripts/run/ship/run-ship-probe.ts
-var REPOSITORY_DIRECTORY_INDEX = 1;
-var REMOTE_SHA_INDEX = 0;
-var REMOTE_FIELD_SEPARATOR = /\s/u;
-var HEAD_REFERENCE = "HEAD";
-async function or_false(is_true) {
-  try {
-    return await is_true();
-  } catch (error) {
-    error_text.trace_swallowed("run_ship_probe.or_false", error);
-    return false;
-  }
-}
-async function read_committed() {
-  if (await run_hold.is_tree_dirty()) return false;
-  const base = await git_command.default_branch_reference();
-  return await git_command.commit_count_beyond(base, HEAD_REFERENCE) > 0;
-}
-async function read_pushed(branch_name) {
-  const [remote, head] = await Promise.all([
-    git_worktree.ls_remote_branch(branch_name),
-    git_command.head_commit()
-  ]);
-  return remote.split(REMOTE_FIELD_SEPARATOR)[REMOTE_SHA_INDEX] === head;
-}
-async function read_merged(branch_name) {
-  if (await run_preflight.read_pr_state(branch_name) !== run_preflight.MERGED_PR) return false;
-  const base = await git_command.default_branch_reference();
-  return await git_command.commit_count_beyond(base, HEAD_REFERENCE) === 0;
-}
-async function read_review_stale() {
-  return await or_false(async () => await issue_watch_gate.review_refusal_here() !== void 0);
-}
-var NOTHING_DONE = { is_committed: false, is_pushed: false, is_merged: false };
-async function read_branch_state(branch_name) {
-  const [is_committed, is_pushed, is_merged2, is_review_stale] = await Promise.all([
-    or_false(read_committed),
-    or_false(async () => await read_pushed(branch_name)),
-    or_false(async () => await read_merged(branch_name)),
-    read_review_stale()
-  ]);
-  return { is_committed, is_pushed, is_merged: is_merged2, is_review_stale };
-}
-async function read_state() {
-  try {
-    return await read_branch_state(await git_command.branch());
-  } catch {
-    return NOTHING_DONE;
-  }
-}
-async function repository_directory() {
-  try {
-    const directories = await git_command.git_directories();
-    return directories[REPOSITORY_DIRECTORY_INDEX];
-  } catch {
-    return void 0;
-  }
-}
-async function record_target2(issue) {
-  const repository = await repository_directory();
-  return repository === void 0 ? void 0 : run_ship_stage.record_path(repository, issue);
-}
-var run_ship_probe = { read_review_stale, read_state, record_target: record_target2, repository_directory };
-
-// 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_SEPARATOR = "-";
-var LINE_BREAK = "\n";
-var CARRIAGE_RETURN = "\r";
-var omitted_schema = z10.object({ path: z10.string().optional(), last_line: z10.number().int() }).strict();
-var stop_context_schema = z10.object({
-  excerpt: z10.array(z10.string()).readonly(),
-  omitted: omitted_schema.optional(),
-  changed: z10.array(z10.string()).readonly().optional(),
-  more_changed: z10.number().int()
-}).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_role_profile.printable(shown_frame(line)));
-}
-async function keep_full_output(issue, output) {
-  const repository = await run_ship_probe.repository_directory();
-  if (repository === void 0) return void 0;
-  const target = stamp_file.stamp_path(
-    `${OUTPUT_PREFIX}${issue}${KEY_SEPARATOR}`,
-    repository,
-    OUTPUT_SUFFIX
-  );
-  try {
-    return stamp_file.replace_text_stamp(target, output);
-  } catch {
-    return void 0;
-  }
-}
-async function omitted_range(issue, lines) {
-  const path5 = await keep_full_output(issue, lines.join(LINE_BREAK));
-  const last_line = lines.length - EXCERPT_LINE_LIMIT;
-  return path5 === void 0 ? { last_line } : { path: path5, last_line };
-}
-function clipped(lines) {
-  return lines.map((line) => line.slice(0, EXCERPT_LINE_WIDTH));
-}
-async function excerpt_of(issue, 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(issue, 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(issue, output) {
-  return { ...await excerpt_of(issue, output), ...await changed_of() };
-}
-function has_excerpt(context) {
-  return context !== void 0 && context.excerpt.length > 0;
-}
-function excerpt_heading(issue, omitted, shown) {
-  if (omitted === void 0) return "The failed stage output:";
-  const source = omitted.path ?? `the stopped report (\`${run_ship_next.COMMAND.LOG} ${issue}\`)`;
-  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(issue, context, changed, dropped) {
-  const shown = context.excerpt.slice(dropped);
-  const heading = excerpt_heading(issue, 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 describe2(issue, context, budget = agent_role_profile.MAX_VALUE_LENGTH) {
-  const changed = changed_text(context);
-  if (!has_excerpt(context)) return changed;
-  let dropped = 0;
-  let block = excerpt_block(issue, context, changed, dropped);
-  while (block.length > budget && dropped < context.excerpt.length - 1) {
-    dropped += 1;
-    block = excerpt_block(issue, context, changed, dropped);
-  }
-  return block;
-}
-var run_ship_stop_context = {
-  CHANGED_PATH_LIMIT,
-  EXCERPT_LINE_LIMIT,
-  build,
-  describe: describe2,
-  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(issue) {
-  issue_number_shape.require_issue_number(issue);
-  return `${CHILD_INVOCATION} ${issue_cite.plain(issue)}`;
-}
-function process_pattern(issue) {
-  issue_number_shape.require_issue_number(issue);
-  return `(${CHILD_INVOCATION}|${REVIEW_INVOCATION}|${SHIP_PROCESS} .*) ${issue_cite.plain(issue)}$`;
-}
-function ship_pattern(issue) {
-  issue_number_shape.require_issue_number(issue);
-  return `${SHIP_PROCESS} .* ${issue_cite.plain(issue)}$`;
-}
-function review_invocation(issue) {
-  issue_number_shape.require_issue_number(issue);
-  return `${REVIEW_INVOCATION} ${issue_cite.plain(issue)}`;
-}
-function resume_invocation(issue) {
-  const preamble = `Resuming the lane child for issue ${issue_cite.plain(issue)} \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Run \`pnpm josh run:cut --resume ${issue}\` before anything else and follow the matching verdict in ${RESUME_GUIDE}: \`resume\` goes to the gate, \`resume-impl\` continues implementation. Only on \`fresh\` proceed as an ordinary`;
-  return `${preamble} ${child_invocation(issue)}`;
-}
-function outage_resume_invocation(issue) {
-  const preamble = `Resuming the lane child for issue ${issue_cite.plain(issue)} 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 ${issue}\` to find the next action, redoing only the last step if it did not complete.`;
-  return `${preamble} ${child_invocation(issue)}`;
-}
-function known_stop_lines(issue, stop, frame) {
-  const { context } = stop;
-  const is_excerpted = run_ship_stop_context.has_excerpt(context);
-  const next = run_ship_next.next_step(issue, 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_role_profile.MAX_VALUE_LENGTH - fixed;
-  return [next, run_ship_stop_context.describe(issue, context, budget)];
-}
-function ship_stop_invocation(issue, stop) {
-  const opening = `Resuming the lane child for issue ${issue_cite.plain(issue)} 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(issue)}`;
-  const middle = stop === void 0 ? [
-    `Run \`pnpm josh run:step ${issue}\` and read the stopped report it names, fix what stopped the ship, then hand the region back per chain-rule.md.`
-  ] : known_stop_lines(issue, stop, [opening, closing]);
-  return [opening, ...middle, closing].join(LINE_BREAK2);
-}
-var lane_child_invocation = {
-  child_invocation,
-  outage_resume_invocation,
-  process_pattern,
-  resume_invocation,
-  review_invocation,
-  ship_pattern,
-  ship_stop_invocation
-};
-
-// scripts/lane/process-tools.ts
-import path2 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 `\`${path2.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) {
-  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(issue, own, probes) {
-  const pattern = lane_child_invocation.process_pattern(issue);
-  return probes.matching(pattern).filter((pid) => !own.has(pid));
-}
-function lane_tree(issue, probes = SYSTEM_PROBES) {
-  const own = own_ancestry(probes);
-  return tree_of(roots_of(issue, 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(issue, probes = SYSTEM_PROBES) {
-  return roots_of(issue, own_ancestry(probes), probes).length > 0;
-}
-var lane_reap = {
-  is_child_running,
-  lane_tree,
-  own_ancestry,
-  parse_pids,
-  PS_COMMAND,
-  reap_child,
-  run_probe,
-  SYSTEM_PROBES
-};
-
-// scripts/run/run-headless.ts
-var HEADLESS_ENV_KEY = "JOSH_RUN_HEADLESS";
-var HEADLESS_VALUE = "1";
-function environment2() {
-  return { [HEADLESS_ENV_KEY]: HEADLESS_VALUE };
-}
-function is_headless2(source = process.env) {
-  return source[HEADLESS_ENV_KEY] === HEADLESS_VALUE;
-}
-function is_headless_parent(source) {
-  return is_headless2(source) && lane_child_marker.marked_issue(source) === void 0;
-}
-function is_cut_capped(carry, source = process.env) {
-  return !is_headless_parent(source) && run_carry.is_at_cut_cap(carry);
-}
-function is_driving(read) {
-  return read?.kind === "carried" && read.carry.is_handed_off !== true;
-}
-async function read_carry_here() {
-  const repository = await run_carry.repository_directory();
-  return repository === void 0 ? void 0 : run_carry.read_carry(run_carry.carry_path(repository));
-}
-async function must_keep_waiting(source = process.env) {
-  if (!is_headless_parent(source) || !await lane_registry.has_lanes_in_flight()) return false;
-  return is_driving(await read_carry_here());
-}
-async function current_carry() {
-  const read = await read_carry_here();
-  return read?.kind === "carried" ? read.carry : void 0;
-}
-function is_owned_here(carry, ancestry) {
-  return carry.owner_pid !== void 0 && ancestry().has(carry.owner_pid);
-}
-function driven_here(read, ancestry) {
-  if (read?.kind !== "carried" || !is_driving(read)) return void 0;
-  return is_owned_here(read.carry, ancestry) ? read.carry : void 0;
-}
-async function driving_carry(source = process.env, ancestry = lane_reap.own_ancestry) {
-  if (lane_child_marker.marked_issue(source) !== void 0) return void 0;
-  return driven_here(await read_carry_here(), ancestry);
-}
-async function is_backlog_parent(source = process.env, ancestry = lane_reap.own_ancestry) {
-  return await driving_carry(source, ancestry) !== void 0;
-}
-var run_headless = {
-  HEADLESS_ENV_KEY,
-  current_carry,
-  driven_here,
-  driving_carry,
-  environment: environment2,
-  is_backlog_parent,
-  is_cut_capped,
-  is_headless: is_headless2,
-  is_headless_parent,
-  is_owned_here,
-  must_keep_waiting
-};
-
-// scripts/agent/agent-session-role.ts
-var KEY3 = "JOSH_AGENT_ROLE";
-function environment_for2(role) {
-  return { [KEY3]: role };
-}
-function is_reviewer(source = process.env) {
-  return source[KEY3] === agent_role_profile.REVIEWER;
-}
-var agent_session_role = { KEY: KEY3, env_for: environment_for2, is_reviewer };
-
-// scripts/run/detached-launch.ts
-import { spawn } from "node:child_process";
-import { closeSync, constants, openSync, writeSync } from "node:fs";
-
-// scripts/agent/agent-launch-environment.ts
-import { existsSync as existsSync2, lstatSync as lstatSync2, mkdirSync, readlinkSync, symlinkSync, unlinkSync } from "node:fs";
-import path4 from "node:path";
-
-// scripts/gh/gh-cli-token.ts
-import { execaSync as execaSync2 } from "execa";
-var GH_CLI_TIMEOUT_MS = 5e3;
-function get() {
-  try {
-    const { stdout } = execaSync2("gh", ["auth", "token"], { timeout: GH_CLI_TIMEOUT_MS });
-    const token = stdout.trim();
-    return token.length > 0 ? token : void 0;
-  } catch {
-    return void 0;
-  }
-}
-var gh_cli_token = { get };
-
-// scripts/agent/codex-home-source.ts
-import os from "node:os";
-import path3 from "node:path";
-function default_home() {
-  return path3.join(os.homedir(), ".codex");
-}
-var codex_home_source = { default_home };
-
-// scripts/agent/agent-launch-environment.ts
-var OPENAI_PROVIDER2 = "openai";
-var REVIEWER_HOME = ["node_modules", ".cache", "josh", "openai", "reviewer-home"];
-var HOME_FILES = ["auth.json", "config.toml"];
-var PRIVATE_DIRECTORY_MODE = 448;
-function openai_environment() {
-  const token = gh_cli_token.get();
-  return token === void 0 ? { TMPDIR: PLATFORM_TEMP_ROOT } : { GH_TOKEN: token, TMPDIR: PLATFORM_TEMP_ROOT };
-}
-function remove_old_home_link(source, target) {
-  const current = lstatSync2(target, { throwIfNoEntry: false });
-  if (current === void 0) return false;
-  if (!current.isSymbolicLink()) throw new Error(`Reviewer home file is not a link: ${target}`);
-  if (existsSync2(source) && readlinkSync(target) === source) return true;
-  unlinkSync(target);
-  return false;
-}
-function link_home_file(source_home, target_home, name) {
-  const source = path4.join(source_home, name);
-  const target = path4.join(target_home, name);
-  if (!remove_old_home_link(source, target) && existsSync2(source)) symlinkSync(source, target);
-}
-function reviewer_home(cwd, environment3) {
-  const source = environment3["CODEX_HOME"] ?? process.env["CODEX_HOME"] ?? codex_home_source.default_home();
-  const target = path4.resolve(cwd, ...REVIEWER_HOME);
-  mkdirSync(target, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
-  for (const name of HOME_FILES) link_home_file(source, target, name);
-  return target;
-}
-function build2(cwd, profile, environment3 = {}) {
-  if (profile === void 0) return environment3;
-  const marked = {
-    ...agent_headless.environment(),
-    ...agent_session_role.env_for(profile.role),
-    ...environment3
-  };
-  if (profile.provider !== OPENAI_PROVIDER2) return marked;
-  const base = { ...openai_environment(), ...marked };
-  return profile.role === agent_role_profile.REVIEWER ? { ...base, CODEX_HOME: reviewer_home(cwd, environment3) } : base;
-}
-var agent_launch_environment = { build: build2 };
-
-// scripts/run/launch-priority.ts
-import { setPriority } from "node:os";
-var LANE_NICENESS = 10;
-function lower(pid, set_priority = setPriority) {
-  if (pid === void 0) return;
-  try {
-    set_priority(pid, LANE_NICENESS);
-  } catch {
-  }
-}
-var launch_priority = {
-  LANE_NICENESS,
-  lower
-};
-
-// scripts/run/detached-launch.ts
-var NO_PID_NOTE = "the process started without a pid";
-var UNSAFE_NOTE = "the wake command or its arguments contain characters that are not safe to execute";
-var { is_safe_prompt: is_safe_prompt3, is_safe_value: is_safe_value3 } = agent_role_profile;
-var LAST = -1;
-function is_safe_element(argv, value, index) {
-  const is_prompt = argv.ends_with_prompt === true && index === argv.args.length + LAST;
-  return is_prompt ? is_safe_prompt3(value) : is_safe_value3(value);
-}
-function is_safe_argv(argv) {
-  return is_safe_value3(argv.command) && argv.args.every((value, index) => is_safe_element(argv, value, index));
-}
-function note_of(error) {
-  return error instanceof Error ? error.message : JSON.stringify(error);
-}
-function launched(pid) {
-  return { kind: "launched", pid };
-}
-var LOG_FLAGS = constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW;
-var LOG_MODE = 384;
-function profile_suffix(profile) {
-  return profile === void 0 ? "" : ` \xB7 ${agent_role_profile.describe(profile)}`;
-}
-function log_header(argv, profile) {
-  const stamp = (/* @__PURE__ */ new Date()).toISOString();
-  return `
-=== ${stamp} \xB7 started by process ${String(process.pid)} \xB7 ${argv.command}${profile_suffix(profile)} ===
-`;
-}
-function opened_log(log_path, on_error) {
-  const descriptor = openSync(log_path, LOG_FLAGS, LOG_MODE);
-  if (!stamp_file.is_own_regular_file(log_path)) {
-    closeSync(descriptor);
-    on_error(`${log_path} is not this account's own file, so nothing is kept there`);
-    return void 0;
-  }
-  return descriptor;
-}
-function stamped(descriptor, argv, profile, on_error) {
-  if (descriptor === void 0) return;
-  try {
-    writeSync(descriptor, log_header(argv, profile));
-  } catch (error) {
-    on_error(`the session log could not be written: ${note_of(error)}`);
-  }
-}
-function open_log(log_path, on_error) {
-  if (log_path === void 0) return void 0;
-  try {
-    return opened_log(log_path, on_error);
-  } catch (error) {
-    on_error(`the session log at ${log_path} could not be opened: ${note_of(error)}`);
-    return void 0;
-  }
-}
-function ensure_log(log_path, on_error) {
-  const descriptor = open_log(log_path, on_error);
-  if (descriptor !== void 0) closeSync(descriptor);
-}
-function spawn_options(cwd, log, environment3 = {}, is_detached = true) {
-  return {
-    cwd,
-    detached: is_detached,
-    stdio: log === void 0 ? "ignore" : ["ignore", log, log],
-    env: { ...process.env, ...agent_session_environment.removed_environment(), ...environment3 }
-  };
-}
-function notify_spawn(pid, on_spawn, on_error) {
-  if (pid === void 0) return;
-  try {
-    on_spawn(pid);
-  } catch (error) {
-    on_error(`the child state could not be recorded: ${note_of(error)}`);
-  }
-}
-async function attached_spawn(request, log, on_error, on_spawn) {
-  return await new Promise((resolve2) => {
-    const environment3 = agent_launch_environment.build(request.cwd, request.profile, request.env);
-    const child = spawn(
-      request.argv.command,
-      [...request.argv.args],
-      spawn_options(request.cwd, log, environment3, false)
-    );
-    child.once("error", (error) => {
-      on_error(note_of(error));
-      resolve2({ kind: "failed", note: note_of(error) });
-    });
-    child.once("exit", (exit_code) => {
-      resolve2({ kind: "completed", pid: child.pid ?? 0, exit_code });
-    });
-    launch_priority.lower(child.pid);
-    notify_spawn(child.pid, on_spawn, on_error);
-  });
-}
-function ignore_spawn(_pid) {
-}
-function spawned(request, log, on_error) {
-  const { command, args } = request.argv;
-  const environment3 = agent_launch_environment.build(request.cwd, request.profile, request.env);
-  const child = spawn(command, [...args], spawn_options(request.cwd, log, environment3));
-  child.on("error", (error) => {
-    on_error(note_of(error));
-  });
-  child.unref();
-  launch_priority.lower(child.pid);
-  return child.pid === void 0 ? { kind: "failed", note: NO_PID_NOTE } : launched(child.pid);
-}
-function launch(request, on_error) {
-  if (!is_safe_argv(request.argv)) return { kind: "failed", note: UNSAFE_NOTE };
-  const log = open_log(request.log_path, on_error);
-  try {
-    stamped(log, request.argv, request.profile, on_error);
-    return spawned(request, log, on_error);
-  } catch (error) {
-    return { kind: "failed", note: note_of(error) };
-  } finally {
-    if (log !== void 0) closeSync(log);
-  }
-}
-async function launch_attached(request, on_error, on_spawn = ignore_spawn) {
-  if (!is_safe_argv(request.argv)) return { kind: "failed", note: UNSAFE_NOTE };
-  const log = open_log(request.log_path, on_error);
-  try {
-    stamped(log, request.argv, request.profile, on_error);
-    return await attached_spawn(request, log, on_error, on_spawn);
-  } catch (error) {
-    return { kind: "failed", note: note_of(error) };
-  } finally {
-    if (log !== void 0) closeSync(log);
-  }
-}
-var detached_launch = {
-  UNSAFE_NOTE,
-  ensure_log,
-  is_safe_argv,
-  is_safe_value: is_safe_value3,
-  launch,
-  launch_attached,
-  log_header,
-  note_of
-};
-
-// scripts/init/distributed-paths.ts
-var KIT_PACKAGE_PATH_PREFIX = "node_modules/@joshuafolkken/kit/";
-var PROMPTS_PACKAGE_PREFIX = `${KIT_PACKAGE_PATH_PREFIX}prompts/`;
-var ESLINT_PACKAGE_PREFIX = `${KIT_PACKAGE_PATH_PREFIX}eslint/`;
-var GITHUB_REPO_BLOB_BASE = "https://github.com/joshuafolkken/kit/blob/main/";
-var GITHUB_REPO_TREE_BASE = "https://github.com/joshuafolkken/kit/tree/main/";
-var CLAUDE_MD_IMPORT_LINE = "@node_modules/@joshuafolkken/kit/dist/CLAUDE.md";
-var OLD_CLAUDE_MD_BOOTSTRAP = "> Fresh checkout: if kit is not installed, run `pnpm install` first, then reread this file before doing any other work.";
-var CLAUDE_MD_BOOTSTRAP = '> Fresh checkout: before `pnpm install`, run `pnpm config get "@joshuafolkken:registry"` from the project root to check the effective registry, including user-level settings. If it points to GitHub Packages, [set up authentication](https://github.com/joshuafolkken/kit/blob/main/docs/authentication.md#1-get-a-token-from-the-gh-cli) first. Then run `pnpm install` and reread this file before doing any other work.';
-function transform_prompt_paths(content) {
-  return content.replaceAll(
-    /`prompts\/([^`*]+)`/gu,
-    (_match, prompt_path) => `\`${PROMPTS_PACKAGE_PREFIX}${prompt_path}\``
-  );
-}
-function transform_eslint_paths(content) {
-  return content.replaceAll(
-    /`eslint\/([^`*]+)`/gu,
-    (_match, eslint_path) => `\`${ESLINT_PACKAGE_PREFIX}${eslint_path}\``
-  );
-}
-function transform_test_file_paths(content) {
-  return content.replaceAll(
-    /`([^`*]+\.(?:test|spec)\.ts)`/gu,
-    (_match, test_path) => `\`${GITHUB_REPO_BLOB_BASE}${test_path}\``
-  );
-}
-function github_url_base(reference_path) {
-  return reference_path.endsWith("/") ? GITHUB_REPO_TREE_BASE : GITHUB_REPO_BLOB_BASE;
-}
-function transform_documentation_paths(content) {
-  return content.replaceAll(
-    /`(docs\/[^`*]*)`/gu,
-    (_match, documentation_path) => `\`${github_url_base(documentation_path)}${documentation_path}\``
-  );
-}
-function transform_distributed_paths(content) {
-  const with_prompts = transform_prompt_paths(content);
-  const with_eslint = transform_eslint_paths(with_prompts);
-  const with_tests = transform_test_file_paths(with_eslint);
-  return transform_documentation_paths(with_tests);
-}
-function ensure_claude_md_import(existing) {
-  if (existing === void 0) return `${CLAUDE_MD_BOOTSTRAP}
-
-${CLAUDE_MD_IMPORT_LINE}
-`;
-  const updated = existing.replace(OLD_CLAUDE_MD_BOOTSTRAP, () => CLAUDE_MD_BOOTSTRAP);
-  if (updated.includes(CLAUDE_MD_IMPORT_LINE)) {
-    if (updated.includes(CLAUDE_MD_BOOTSTRAP)) return updated;
-    return `${CLAUDE_MD_BOOTSTRAP}
-
-${updated}`;
-  }
-  return `${CLAUDE_MD_BOOTSTRAP}
-
-${CLAUDE_MD_IMPORT_LINE}
-
-${updated}`;
-}
-var FULL_CLAUDE_MD_LINES = /* @__PURE__ */ new Set([
-  CLAUDE_MD_BOOTSTRAP,
-  OLD_CLAUDE_MD_BOOTSTRAP,
-  CLAUDE_MD_IMPORT_LINE
-]);
-function remove_claude_md_import(content) {
-  const lines = content.split("\n");
-  return lines.filter((line, index) => {
-    if (FULL_CLAUDE_MD_LINES.has(line)) return false;
-    return line !== "" || !FULL_CLAUDE_MD_LINES.has(lines[index - 1] ?? "");
-  }).join("\n");
-}
-var distributed_paths = {
-  transform_prompt_paths,
-  transform_distributed_paths,
-  ensure_claude_md_import,
-  remove_claude_md_import,
-  CLAUDE_MD_IMPORT_LINE
-};
-
-export {
-  josh_environment_file,
-  lane_child_marker,
-  agent_role_profile,
-  agent_session_role,
-  FULL_PAGE_QUERY,
-  git_gh_api_path,
-  parse_json_array_or_undefined,
-  read_json_listing,
-  parse_json_array_safe,
-  parse_json_object_or_undefined,
-  parse_json,
-  gh_failure,
-  has_stderr_field,
-  git_gh_exec,
-  git_gh_conditional,
-  git_gh_helpers,
-  to_gh_state,
-  BLOCKED_BY_FIELD,
-  BLOCKED_BY_COUNT_FIELD,
-  git_gh_issue_rest,
-  read_blocked_by,
-  git_gh_issue_read,
-  issue_watch_diff,
-  issue_watch,
-  review_checkout,
-  issue_watch_gate,
-  stamp_record,
-  changed_paths,
-  git_worktree,
-  run_hold,
-  git_gh_pr_rest,
-  forget_pr_numbers,
-  require_pr_number,
-  read_pull,
-  git_gh_pr_read,
-  OBSERVATION_LEDGER_DIRECTORY,
-  LEGACY_OBSERVATION_LEDGER_DIRECTORY,
-  LEDGER_FILE_EXTENSION,
-  LEGACY_LEDGER_FILE,
-  LEGACY_OBSERVATION_LEDGER_PATHS,
-  MIGRATION_CLAIM_SUFFIX,
-  observation_ledger,
-  git_stash,
-  lane_registry,
-  run_preflight,
-  lane_child_invocation,
-  agent_headless,
-  detached_launch,
-  distributed_paths,
-  session_language,
-  process_tools,
-  lane_reap,
-  run_headless
-};