@joshuafolkken/kit 1.1471.0 → 1.1514.0

package/dist/hooks/{chunk-43ZHT22P.js → chunk-SYOTDYCI.js}

@@ -1,22 +1,43 @@
 import {
-  agent_role_profile,
+  FULL_PAGE_QUERY,
+  MERGED_STATE,
   detached_launch,
+  forget_pr_numbers,
+  gh_failure,
   git_common_directory,
+  git_gh_api_path,
+  git_gh_exec,
+  git_gh_helpers,
+  git_gh_pr_read,
+  git_gh_pr_rest,
   issue_cite,
   lane_child_invocation,
+  parse_json_array_or_undefined,
+  parse_json_object_or_undefined,
+  read_json_listing,
+  read_pull,
   repo_discovery,
   repo_origin,
+  require_pr_number,
   run_event_stream,
-  run_event_stream_emit
-} from "./chunk-EUMACUK2.js";
+  run_event_stream_emit,
+  run_hold,
+  session_cite,
+  stamp_record,
+  to_gh_state
+} from "./chunk-WK6SMBIC.js";
 import {
   error_text
 } from "./chunk-CDY4NFQG.js";
+import {
+  agent_role_profile,
+  agent_session_role
+} from "./chunk-UPUZF3AN.js";
 import {
   CHECK_STATUS_FAIL,
   CHECK_STATUS_PENDING,
   PrConflictError,
-  blocking_issue_schema,
+  cost_attribute,
   cost_blocks,
   describe_pr_failure,
   evaluate_pr_state,
@@ -26,25 +47,28 @@ import {
   is_review_decision_decisive,
   parse_pr_state_snapshot,
   read_string,
-  rest_comment_schema,
   time_density_hook,
   time_shell,
   time_transcript_line
-} from "./chunk-AS74OU3D.js";
+} from "./chunk-TNUMY6NL.js";
 import {
   lane_child_marker
-} from "./chunk-K4EOONYM.js";
+} from "./chunk-LAOV7NLM.js";
 import {
-  agent_session_environment,
   backlog_budget,
+  blocking_issue_schema,
+  cli_flags,
+  cost_transcript,
   cost_usage,
   git_command,
-  has_timed_out,
+  issue_number_shape,
   json_value,
+  lane_paths,
+  own_session,
   process_identity
-} from "./chunk-E7OIKX5Z.js";
+} from "./chunk-APUO6U4J.js";
 import {
-  COMMAND_TIMEOUT_MS,
+  PLATFORM_TEMP_ROOT,
   PROJECT_ROOT,
   stamp_file
 } from "./chunk-DGT54IH5.js";
@@ -84,6 +108,27 @@ async function bounded_map(items, limit, worker) {
 }
 var bounded_pool = { bounded_map, pool_width };
 
+// scripts/rules/tail-commands.ts
+function is_bash_use(block) {
+  return block.type === cost_blocks.TOOL_USE_TYPE && block.name === cost_blocks.BASH_TOOL;
+}
+function bash_commands_of(line) {
+  const parsed = time_transcript_line.parse_line(line);
+  if (parsed === void 0) return [];
+  return parsed.blocks.filter((block) => is_bash_use(block)).map((block) => time_shell.bash_command(block.input));
+}
+function prior_bash_commands(tail) {
+  return tail.split("\n").flatMap((line) => bash_commands_of(line));
+}
+function answered(text, is_call, token) {
+  const blocks = time_transcript_line.parse_text(text).flatMap((line) => line.blocks);
+  const call_ids = new Set(
+    blocks.filter((block) => is_call(time_shell.bash_command(block.input))).map((block) => block.id)
+  );
+  return blocks.some((block) => call_ids.has(block.result_id) && block.token_lines.includes(token));
+}
+var tail_commands = { answered, is_bash_use, prior_bash_commands };
+
 // scripts/rules/shell-segments.ts
 var SEGMENT_SEPARATOR = /&&|\|\||;|\n/u;
 var SEGMENT_PARTS = new RegExp(`(${SEGMENT_SEPARATOR.source})`, "u");
@@ -93,12 +138,19 @@ function segments_of(command) {
 function parts_of(command) {
   return command.split(SEGMENT_PARTS);
 }
+function first_of(command) {
+  const plain = time_shell.blanked(command);
+  if (plain === void 0) return void 0;
+  const cut = plain.search(SEGMENT_SEPARATOR);
+  return (cut === -1 ? command : command.slice(0, cut)).trim();
+}
 function is_josh_command(segment, names) {
   const named = time_shell.josh_command_of(segment);
   if (!named.startsWith(time_shell.JOSH_PREFIX)) return false;
   return names.has(named.slice(time_shell.JOSH_PREFIX.length));
 }
 var shell_segments = {
+  first_of,
   is_josh_command,
   parts_of,
   segments_of
@@ -124,20 +176,6 @@ function is_issue_filing(command) {
 }
 var bash_triggers = { is_direct_filing, is_issue_filing, on_bash_command };
 
-// scripts/rules/tail-commands.ts
-function is_bash_use(block) {
-  return block.type === cost_blocks.TOOL_USE_TYPE && block.name === cost_blocks.BASH_TOOL;
-}
-function bash_commands_of(line) {
-  const parsed = time_transcript_line.parse_line(line);
-  if (parsed === void 0) return [];
-  return parsed.blocks.filter((block) => is_bash_use(block)).map((block) => time_shell.bash_command(block.input));
-}
-function prior_bash_commands(tail) {
-  return tail.split("\n").flatMap((line) => bash_commands_of(line));
-}
-var tail_commands = { is_bash_use, prior_bash_commands };
-
 // scripts/rules/filing-cap.ts
 var FILING_CAP = 10;
 var CAP_REACHED = FILING_CAP;
@@ -176,8 +214,8 @@ function current_turn(tail) {
 function turn_filing_count(tail) {
   return prior_filing_count(current_turn(tail));
 }
-function decide(_call, run) {
-  return prior_filing_count(time_density_hook.read_tail(run.transcript)) >= CAP_REACHED;
+function decide(_call, run2) {
+  return prior_filing_count(time_density_hook.read_tail(run2.transcript)) >= CAP_REACHED;
 }
 var FILING_CAP_REASON = `\u26D4 filing cap: this run has already filed ${String(FILING_CAP)} Issues, the per-run ceiling. Stop filing and report; a further Issue is a person's call. It fires on every occurrence (\`.claude/skills/workflow-commands/observation-filing.md\`).`;
 var ROW = {
@@ -190,340 +228,12 @@ var filing_cap = {
   FILING_CAP,
   FILING_CAP_REASON,
   ROW,
+  current_turn,
   is_prompt_line,
   prior_filing_count,
   turn_filing_count
 };
 
-// scripts/rules/issue-citation.ts
-var ISSUE_NUMBER = /#\d+/gu;
-var REFERENCE_BOUNDARY = /[\s#()[\]<>|]/u;
-var OWNER_REPO = /^[^\s/#]+\/[^\s/#]+$/u;
-var MARKDOWN_LINK = /\[[^[\]]*\]\([^()]*\)/gu;
-var NUMBER_CONTINUATION = /^(?:\w|-[a-z])/iu;
-var CONTINUATION_WIDTH = 2;
-var GLUED_LEAD = /[&./]/u;
-var FENCE_MARKER = /^\s*(?:`{3,}|~{3,})/u;
-var QUOTE_LINE = /^\s*>/u;
-var PR_PREFIX = /\b(?:pr|pull request)\s*$/iu;
-var BACKTICK_PAIR = 2;
-function link_covers(link, index) {
-  const start = link.index ?? 0;
-  return index >= start && index < start + link[0].length;
-}
-function is_linked_at(line, index) {
-  for (const link of line.matchAll(MARKDOWN_LINK)) {
-    if (link_covers(link, index)) return true;
-  }
-  return false;
-}
-function lead_token(message, hash_index) {
-  let start = hash_index;
-  while (start > 0 && !REFERENCE_BOUNDARY.test(message.charAt(start - 1))) start -= 1;
-  return message.slice(start, hash_index);
-}
-function repo_prefix(message, hash_index) {
-  const token = lead_token(message, hash_index);
-  return OWNER_REPO.test(token) ? token : "";
-}
-function is_inline_code_at(line, index) {
-  const backticks = line.slice(0, index).split("`").length - 1;
-  return backticks % BACKTICK_PAIR === 1;
-}
-function is_bare_at(line, index) {
-  if (is_linked_at(line, index) || is_inline_code_at(line, index)) return false;
-  return !PR_PREFIX.test(line.slice(0, index));
-}
-function is_glued(line, reference) {
-  const end = reference.index + reference.text.length;
-  if (NUMBER_CONTINUATION.test(line.slice(end, end + CONTINUATION_WIDTH))) return true;
-  return reference.prefix === "" && GLUED_LEAD.test(lead_token(line, reference.index));
-}
-function line_references(line) {
-  const references = [];
-  for (const match of line.matchAll(ISSUE_NUMBER)) {
-    const reference = { index: match.index, prefix: repo_prefix(line, match.index), text: match[0] };
-    if (!is_glued(line, reference) && is_bare_at(line, match.index)) references.push(reference);
-  }
-  return references;
-}
-function collect_line_references(line, found) {
-  for (const reference of line_references(line)) found.push(`${reference.prefix}${reference.text}`);
-}
-function lines_outside_fences(message) {
-  const lines = [];
-  let is_in_fence = false;
-  for (const line of message.split("\n")) {
-    if (FENCE_MARKER.test(line)) is_in_fence = !is_in_fence;
-    else if (!is_in_fence) lines.push(line);
-  }
-  return lines;
-}
-function prose_lines(message) {
-  return lines_outside_fences(message).filter((line) => !QUOTE_LINE.test(line));
-}
-function bare_references(message) {
-  const found = [];
-  for (const line of prose_lines(message)) collect_line_references(line, found);
-  return [...new Set(found)];
-}
-function prompt_references(prompt) {
-  const found = /* @__PURE__ */ new Set();
-  for (const match of prompt.matchAll(ISSUE_NUMBER)) {
-    found.add(repo_prefix(prompt, match.index) + match[0]);
-  }
-  return found;
-}
-function unquoted_references(message, prompt) {
-  const quoted = prompt_references(prompt);
-  return bare_references(message).filter((reference) => !quoted.has(reference));
-}
-function has_bare_reference(message) {
-  return bare_references(message).length > 0;
-}
-function cite_argument(reference) {
-  return reference.startsWith("#") ? reference.slice(1) : reference;
-}
-function cite_arguments(references) {
-  return references.map((reference) => cite_argument(reference));
-}
-function reference_link(reference, default_slug) {
-  const slug = reference.prefix === "" ? default_slug : reference.prefix;
-  const number = reference.text.slice(1);
-  return `[${reference.prefix}${reference.text}](${issue_cite.issue_url(slug, number)})`;
-}
-function linkify_line(line, slug) {
-  let result = "";
-  let cursor = 0;
-  for (const reference of line_references(line)) {
-    const start = reference.index - reference.prefix.length;
-    result += line.slice(cursor, start) + reference_link(reference, slug);
-    cursor = reference.index + reference.text.length;
-  }
-  return result + line.slice(cursor);
-}
-function rewrite_line(line, slug, is_in_fence) {
-  if (is_in_fence || FENCE_MARKER.test(line) || QUOTE_LINE.test(line)) return line;
-  return linkify_line(line, slug);
-}
-function linkify(message, slug) {
-  const out = [];
-  let is_in_fence = false;
-  for (const line of message.split("\n")) {
-    if (FENCE_MARKER.test(line)) is_in_fence = !is_in_fence;
-    out.push(rewrite_line(line, slug, is_in_fence));
-  }
-  return out.join("\n");
-}
-var issue_citation = {
-  bare_references,
-  cite_arguments,
-  has_bare_reference,
-  linkify,
-  prose_lines,
-  unquoted_references
-};
-
-// scripts/issue/session-cite.ts
-function session_repo() {
-  const url = repo_discovery.read_origin_url(process.cwd());
-  const identity = url === void 0 ? void 0 : repo_origin.parse_origin_url(url);
-  return identity === void 0 ? void 0 : `${identity.owner}/${identity.repo}`;
-}
-function issue(number, title, repo = session_repo()) {
-  return issue_cite.reference(repo, String(number), title);
-}
-function text(message) {
-  const repo = session_repo();
-  return repo === void 0 ? message : issue_citation.linkify(message, repo);
-}
-var session_cite = {
-  issue,
-  session_repo,
-  text
-};
-
-// scripts/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_expired3 = is_older_than(spec.timestamp_of(record), spec.max_age_ms, now);
-  return { kind: is_expired3 ? "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()
-});
-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(environment = process.env) {
-  const pid = Number(environment[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(issue2, now, is_fullrun) {
-  return { issue: issue2, taken_at: now.toISOString(), pid: process.pid, is_fullrun, ...session_owner() };
-}
-function write_hold(target, issue2, now = /* @__PURE__ */ new Date()) {
-  const hold = build_hold(issue2, now);
-  stamp_file.write_stamp(target, hold);
-  return hold;
-}
-function create_hold(target, issue2, now = /* @__PURE__ */ new Date(), is_fullrun) {
-  return stamp_file.create_stamp(target, build_hold(issue2, now, is_fullrun));
-}
-var HALFRUN_STOP_FIELDS = { is_halfrun_stop: true };
-function create_stop_hold(target, issue2, mark, now = /* @__PURE__ */ new Date()) {
-  return stamp_file.create_stamp(target, { ...build_hold(issue2, now), ...mark });
-}
-function create_halfrun_stop_hold(target, issue2, now = /* @__PURE__ */ new Date()) {
-  return create_stop_hold(target, issue2, 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(issue2) {
-  return issue2 === UNNUMBERED_ISSUE ? RELEASE_COMMAND : `${RELEASE_COMMAND} ${issue2}`;
-}
-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,
-  stale_message,
-  uncommitted_message,
-  unknown_message,
-  unreadable_message,
-  worktree_directory,
-  write_hold
-};
-
 // scripts/cost-runtime/cost-pricing.ts
 var CACHE_WRITE_5M_MULTIPLIER = 1.25;
 var CACHE_WRITE_1H_MULTIPLIER = 2;
@@ -668,16 +378,16 @@ var context_cut_payback = {
 var CONTEXT_CUT_THRESHOLD = context_cut_payback.break_even_context();
 
 // scripts/run/cut/run-cut.ts
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 
 // scripts/run/cut/run-cut-handoff.ts
 import { readFileSync } from "node:fs";
-import { z as z2 } from "zod";
-var handoff_schema = z2.object({
-  instruction: z2.string(),
-  completed: z2.array(z2.string()),
-  remaining: z2.array(z2.string()),
-  untouched: z2.array(z2.string())
+import { z } from "zod";
+var handoff_schema = z.object({
+  instruction: z.string(),
+  completed: z.array(z.string()),
+  remaining: z.array(z.string()),
+  untouched: z.array(z.string())
 });
 var COMPLETED_LABEL = "Completed";
 var REMAINING_LABEL = "Remaining";
@@ -685,7 +395,7 @@ var UNTOUCHED_LABEL = "Deliberately untouched";
 var INSTRUCTION_LABEL = "Instruction (verbatim)";
 var EMPTY_LIST_NOTE = "(none)";
 function describe_key(key2) {
-  const value = handoff_schema.shape[key2] instanceof z2.ZodArray ? '["\u2026"]' : '"\u2026"';
+  const value = handoff_schema.shape[key2] instanceof z.ZodArray ? '["\u2026"]' : '"\u2026"';
   return `"${key2}": ${value}`;
 }
 var HANDOFF_FORMAT = `a JSON object {${handoff_schema.keyof().options.map((key2) => describe_key(key2)).join(", ")}}`;
@@ -755,22 +465,22 @@ var CUT_MAX_AGE_HOURS = backlog_budget.IDLE_WAIT_HOURS;
 var END_COMMAND = "pnpm josh run:cut --end";
 var READ_COMMAND = "pnpm josh run:cut --json";
 var MAX_HANDOFF_BYTES = 8192;
-var run_cut_schema = z3.object({
-  invocation: z3.string(),
-  issue: z3.string(),
-  branch: z3.string(),
-  phase: z3.string(),
-  cut_at: z3.string(),
-  is_handed_off: z3.boolean().optional(),
+var run_cut_schema = z2.object({
+  invocation: z2.string(),
+  issue: z2.string(),
+  branch: z2.string(),
+  phase: z2.string(),
+  cut_at: z2.string(),
+  is_handed_off: z2.boolean().optional(),
   handoff: run_cut_handoff.handoff_schema.optional(),
-  is_merge_relaunched: z3.boolean().optional()
+  is_merge_relaunched: z2.boolean().optional()
 });
 function cut_path(git_directory) {
   return stamp_file.stamp_path(CUT_PREFIX, git_directory);
 }
-var { worktree_directory: worktree_directory2 } = run_hold;
-function invocation_for(issue2) {
-  return lane_child_invocation.child_invocation(issue2);
+var { worktree_directory } = run_hold;
+function invocation_for(issue) {
+  return lane_child_invocation.child_invocation(issue);
 }
 function parse_cut(raw) {
   return json_value.parse_with(raw, run_cut_schema);
@@ -783,24 +493,24 @@ var CUT_SPEC = {
   timestamp_of: cut_at_of,
   max_age_ms: CUT_MAX_AGE_MS
 };
-function is_expired2(cut, now) {
+function is_expired(cut, now) {
   return stamp_record.is_older_than(cut_at_of(cut), CUT_MAX_AGE_MS, now);
 }
-function classify3(raw, now) {
-  const read = stamp_record.classify(raw, CUT_SPEC, now);
-  if (!("record" in read)) return read;
-  return { kind: read.kind, cut: read.record };
+function classify(raw, now) {
+  const read2 = stamp_record.classify(raw, CUT_SPEC, now);
+  if (!("record" in read2)) return read2;
+  return { kind: read2.kind, cut: read2.record };
 }
 function read_cut(target, now = /* @__PURE__ */ new Date()) {
-  return classify3(stamp_file.read_stamp_text(target), now);
+  return classify(stamp_file.read_stamp_text(target), now);
 }
 function worktree_git_directory_sync() {
   return git_common_directory.own();
 }
 function carried_cut_sync(now = /* @__PURE__ */ new Date(), directory = worktree_git_directory_sync()) {
   if (directory === void 0) return void 0;
-  const read = read_cut(cut_path(directory), now);
-  return read.kind === "carried" ? read.cut : void 0;
+  const read2 = read_cut(cut_path(directory), now);
+  return read2.kind === "carried" ? read2.cut : void 0;
 }
 function lane_cut_sync(lane_directory) {
   const directory = git_common_directory.own(lane_directory);
@@ -833,20 +543,20 @@ function begin_cut(target, spec, now = /* @__PURE__ */ new Date()) {
   if (!within_handoff_bound(cut)) return void 0;
   return stamp_file.create_stamp(target, cut) ? cut : void 0;
 }
-function is_declared_cut(cut, issue2) {
-  return cut.is_handed_off === true && cut.invocation === invocation_for(issue2);
+function is_declared_cut(cut, issue) {
+  return cut.is_handed_off === true && cut.invocation === invocation_for(issue);
 }
 function matches_state(cut, request) {
   return cut.branch === request.current_branch && cut.issue === request.issue && request.is_dirty && request.is_held;
 }
-function is_adopted_cut(cut, issue2) {
-  return cut.is_handed_off === false && cut.invocation === invocation_for(issue2);
+function is_adopted_cut(cut, issue) {
+  return cut.is_handed_off === false && cut.invocation === invocation_for(issue);
 }
 function has_required_handoff(cut) {
   return !resumes_into_implementation(cut.phase) || run_cut_handoff.is_complete_handoff(cut.handoff);
 }
-function is_relaunchable(cut, issue2) {
-  return is_declared_cut(cut, issue2) && has_required_handoff(cut) && cut.is_merge_relaunched !== true;
+function is_relaunchable(cut, issue) {
+  return is_declared_cut(cut, issue) && has_required_handoff(cut) && cut.is_merge_relaunched !== true;
 }
 function mark_merge_relaunched(target, cut) {
   stamp_file.remove_stamp(target);
@@ -867,8 +577,8 @@ function end_cut(target) {
 }
 function hold_of(directory) {
   if (directory === void 0) return void 0;
-  const read = run_hold.read_hold(run_hold.hold_path(directory));
-  return read.kind === "held" || read.kind === "stale" ? read.hold : void 0;
+  const read2 = run_hold.read_hold(run_hold.hold_path(directory));
+  return read2.kind === "held" || read2.kind === "stale" ? read2.hold : void 0;
 }
 function fullrun_issue(hold) {
   return hold?.is_fullrun === true ? hold.issue : void 0;
@@ -879,7 +589,7 @@ function held_issue_sync() {
 async function current_state() {
   const branch = await git_command.branch();
   const is_dirty = await run_hold.is_tree_dirty();
-  const hold = hold_of(await worktree_directory2());
+  const hold = hold_of(await worktree_directory());
   return {
     branch,
     is_dirty,
@@ -897,16 +607,16 @@ function busy_message(cut) {
 function handed_off_message(cut) {
   return `This cut was already handed off to a successor \u2014 ${describe_cut(cut)}. Nothing was resumed here; the run is being carried on by the process that adopted it, so this one has nothing to do.`;
 }
-function stale_message2(cut) {
+function stale_message(cut) {
   return `This cut does not match the current tree \u2014 ${describe_cut(cut)}. Resume failed; verify the branch and the uncommitted work, then clear it with \`${END_COMMAND}\` if the run is over.`;
 }
 function incomplete_message(cut) {
   return `This cut carries no instruction to resume on \u2014 ${describe_cut(cut)}. Resume was refused rather than continuing without it; recover the run's instruction and work state before implementing, and clear the record with \`${END_COMMAND}\` if the run is over.`;
 }
-function unreadable_message2() {
+function unreadable_message() {
   return `A cut record is here but could not be read; clear it with \`${END_COMMAND}\` once you know no run is using it. Read it with \`${READ_COMMAND}\`.`;
 }
-function unknown_message2() {
+function unknown_message() {
   return "This working tree\u2019s git directory could not be read, so no cut record was acted on.";
 }
 var run_cut = {
@@ -921,7 +631,7 @@ var run_cut = {
   begin_cut,
   busy_message,
   carried_cut_sync,
-  classify: classify3,
+  classify,
   classify_resume,
   current_state,
   cut_path,
@@ -935,18 +645,18 @@ var run_cut = {
   hold_of,
   incomplete_message,
   invocation_for,
-  is_expired: is_expired2,
+  is_expired,
   is_relaunchable,
   lane_cut_sync,
   mark_merge_relaunched,
   read_cut,
   record_within_bound,
   resumes_into_implementation,
-  stale_message: stale_message2,
-  unknown_message: unknown_message2,
-  unreadable_message: unreadable_message2,
+  stale_message,
+  unknown_message,
+  unreadable_message,
   within_handoff_bound,
-  worktree_directory: worktree_directory2,
+  worktree_directory,
   worktree_git_directory_sync
 };
 
@@ -1077,7 +787,7 @@ var lane_background = {
 // scripts/run/ship/run-ship-detach.ts
 import { randomUUID } from "node:crypto";
 import { setTimeout as sleep } from "node:timers/promises";
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 var LOG_PREFIX = "josh-ship-log-";
 var PID_PREFIX = "josh-ship-pid-";
 var BODY_PREFIX = "josh-ship-notify-";
@@ -1098,14 +808,14 @@ var RESULT_PREFIX = "josh-ship-result-";
 var RECORD_POLL_MS = 25;
 var RECORD_WAIT_ATTEMPTS = 200;
 var CLAIM_WINDOW_MS = 12e4;
-var ship_record_schema = z4.object({
-  pid: z4.number().int().positive().optional(),
-  process_start: z4.string().optional(),
-  launched_at: z4.number().optional(),
-  launcher_pid: z4.number().int().positive().optional(),
-  launcher_start: z4.string().optional(),
-  launch_id: z4.string(),
-  result: z4.enum(["success", "failed"]).optional()
+var ship_record_schema = z3.object({
+  pid: z3.number().int().positive().optional(),
+  process_start: z3.string().optional(),
+  launched_at: z3.number().optional(),
+  launcher_pid: z3.number().int().positive().optional(),
+  launcher_start: z3.string().optional(),
+  launch_id: z3.string(),
+  result: z3.enum(["success", "failed"]).optional()
 });
 var LAUNCH_MARK = " \xB7 started by process ";
 var HEADER_START = "\n";
@@ -1168,6 +878,10 @@ function current_record(repository, number) {
   const record = read_record(repository, number);
   return record?.launch_id === process.env[LAUNCH_ID_KEY] ? record : void 0;
 }
+function running_since(repository, number) {
+  const record = read_record(repository, number);
+  return record !== void 0 && result_of(record) === "running" ? record.launched_at : void 0;
+}
 function is_pending(record) {
   return record !== void 0 && record.pid === void 0;
 }
@@ -1275,14 +989,14 @@ async function detach(request) {
   }
   return result;
 }
-function last_launch(text2) {
-  const mark = text2.lastIndexOf(LAUNCH_MARK);
-  if (mark === -1) return text2;
-  return text2.slice(text2.lastIndexOf(HEADER_START, mark) + HEADER_START.length);
+function last_launch(text) {
+  const mark = text.lastIndexOf(LAUNCH_MARK);
+  if (mark === -1) return text;
+  return text.slice(text.lastIndexOf(HEADER_START, mark) + HEADER_START.length);
 }
 function read_log(repository, number) {
-  const text2 = stamp_file.read_stamp_text(log_path(repository, number));
-  return text2 === void 0 ? void 0 : last_launch(text2);
+  const text = stamp_file.read_stamp_text(log_path(repository, number));
+  return text === void 0 ? void 0 : last_launch(text);
 }
 function is_supervised(source = process.env) {
   return source[SUPERVISED_KEY] === SUPERVISED_VALUE;
@@ -1301,20 +1015,25 @@ var run_ship_detach = {
   last_launch,
   log_path,
   read_log,
+  running_since,
   supervisor_argv
 };
 
 // scripts/lane/lane-handoff.ts
-function is_ship_running(issue2, directory) {
+function is_ship_running(issue, directory) {
   const repository = git_common_directory.repository(directory);
-  return repository !== void 0 && run_ship_detach.read_result(repository, issue2)?.result === "running";
+  return repository !== void 0 && run_ship_detach.read_result(repository, issue)?.result === "running";
+}
+function ship_running_since(issue, directory) {
+  const repository = git_common_directory.repository(directory);
+  return repository === void 0 ? void 0 : run_ship_detach.running_since(repository, issue);
 }
 function is_handed_off(directory, source = process.env) {
-  const issue2 = lane_child_marker.marked_issue(source);
-  if (issue2 === void 0 || !lane_child_marker.is_child_of(directory, source)) return false;
-  return is_ship_running(issue2, directory);
+  const issue = lane_child_marker.marked_issue(source);
+  if (issue === void 0 || !lane_child_marker.is_child_of(directory, source)) return false;
+  return is_ship_running(issue, directory);
 }
-var lane_handoff = { is_handed_off, is_ship_running };
+var lane_handoff = { is_handed_off, is_ship_running, ship_running_since };
 
 // scripts/issue/issue-labels.ts
 var EPIC_LABEL = "epic";
@@ -1482,9 +1201,9 @@ function is_confirmation_notify(command) {
 }
 var NOTIFY_INVOCATION = /josh\s+(?:notify|nf)\b/u;
 var COMMAND_NOTIFY_MARKER = "stop notified: a confirmation Telegram was sent by this command";
-function mentions_confirmation_notify(text2) {
-  if (text2.includes(COMMAND_NOTIFY_MARKER)) return true;
-  return NOTIFY_INVOCATION.test(text2) && CONFIRMATION_TASK_TYPE.test(text2);
+function mentions_confirmation_notify(text) {
+  if (text.includes(COMMAND_NOTIFY_MARKER)) return true;
+  return NOTIFY_INVOCATION.test(text) && CONFIRMATION_TASK_TYPE.test(text);
 }
 function is_parking_child(directory = process.cwd()) {
   return lane_child_marker.is_child_of(directory) && !lane_handoff.is_handed_off(directory);
@@ -1518,373 +1237,494 @@ var lane_park = {
   records_the_park
 };
 
-// scripts/discovery/repo-party.ts
-var FIRST_PARTY = "first-party";
-var THIRD_PARTY = "third-party";
-var UNKNOWN = "unknown";
-var GH_REPO_ENV_KEY = "GH_REPO";
-var GH_REPO_PATH_SEGMENTS = 2;
-function classify4(session_owner2, target) {
-  if (session_owner2 === void 0 || target === void 0) return UNKNOWN;
-  return session_owner2.toLowerCase() === target.toLowerCase() ? FIRST_PARTY : THIRD_PARTY;
-}
-function target_owner(owner_repo) {
-  return repo_origin.parse_origin_url(`https://${repo_origin.GITHUB_HOST}/${owner_repo}`)?.owner;
+// scripts/cost-runtime/cost-cli.ts
+import { fileURLToPath } from "node:url";
+
+// scripts/cost-runtime/codex-usage.ts
+import { globSync, readFileSync as readFileSync2 } from "node:fs";
+import path from "node:path";
+import { z as z4 } from "zod";
+var THREAD_ID_PATTERN = /^[A-Za-z0-9-]+$/u;
+var SESSION_META_SCHEMA = z4.looseObject({
+  type: z4.literal("session_meta"),
+  payload: z4.looseObject({ id: z4.string(), cwd: z4.string() })
+});
+var TOTAL_USAGE_SCHEMA = z4.looseObject({ input_tokens: z4.number().nonnegative() });
+var TOKEN_COUNT_SCHEMA = z4.looseObject({
+  type: z4.literal("event_msg"),
+  payload: z4.looseObject({
+    type: z4.literal("token_count"),
+    info: z4.looseObject({
+      total_token_usage: TOTAL_USAGE_SCHEMA,
+      last_token_usage: TOTAL_USAGE_SCHEMA
+    })
+  })
+});
+function same_project(cwd, target) {
+  return cost_transcript.session_cwd(cwd) === cost_transcript.session_cwd(target);
 }
-function current_owner(repository_path = process.cwd()) {
-  return repo_discovery.resolve_current_owner(repository_path);
+function billed_per_request(usages) {
+  return usages.map((usage) => usage.last_token_usage.input_tokens);
 }
-function gh_repo_owners(gh_repo) {
-  return [target_owner(gh_repo.split("/").slice(-GH_REPO_PATH_SEGMENTS).join("/"))];
+function measurement_from(content, target, thread_id) {
+  const values = content.split("\n").map((line) => json_value.parse_or_undefined(line));
+  const metadata = values.flatMap((value) => {
+    const parsed = SESSION_META_SCHEMA.safeParse(value);
+    return parsed.success ? [parsed.data] : [];
+  });
+  const usages = values.flatMap((value) => {
+    const parsed = TOKEN_COUNT_SCHEMA.safeParse(value);
+    return parsed.success ? [parsed.data.payload.info] : [];
+  });
+  const session = metadata.find((entry) => entry.payload.id === thread_id);
+  if (session === void 0 || usages.length === 0 || !same_project(session.payload.cwd, target)) {
+    return void 0;
+  }
+  return { billed_input_per_request: billed_per_request(usages) };
 }
-function remote_owners(repository_path) {
-  return repo_discovery.read_remote_urls(repository_path).map((url) => repo_origin.parse_origin_url(url)?.owner);
+function rollout_files(home, thread_id) {
+  if (!THREAD_ID_PATTERN.test(thread_id)) return [];
+  return globSync(`sessions/**/*${thread_id}.jsonl`, { cwd: home }).map(
+    (file) => path.join(home, file)
+  );
 }
-function placeholder_owners(repository_path = process.cwd(), environment = process.env) {
-  const gh_repo = environment[GH_REPO_ENV_KEY];
-  return gh_repo === void 0 || gh_repo === "" ? remote_owners(repository_path) : gh_repo_owners(gh_repo);
+function read_measurement(file, target, thread_id) {
+  try {
+    return measurement_from(readFileSync2(file, "utf8"), target, thread_id);
+  } catch {
+    return void 0;
+  }
 }
-var repo_party = {
-  FIRST_PARTY,
-  THIRD_PARTY,
-  UNKNOWN,
-  classify: classify4,
-  current_owner,
-  placeholder_owners,
-  target_owner
-};
-
-// 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 latest_measurement(files, target, thread_id) {
+  for (const file of files.toReversed()) {
+    const measured = read_measurement(file, target, thread_id);
+    if (measured !== void 0) return measured;
+  }
+  return void 0;
 }
-function issues_api_path(repo) {
-  return `${repo_api_path(repo)}/issues`;
+function measurement(target, default_home, environment = process.env) {
+  const thread_id = environment["CODEX_THREAD_ID"];
+  if (thread_id === void 0) return void 0;
+  const home = environment["CODEX_HOME"] ?? path.join(default_home, ".codex");
+  return latest_measurement(rollout_files(home, thread_id), target, thread_id);
 }
-function issue_api_path(issue_number, repo) {
-  return `${issues_api_path(repo)}/${issue_number}`;
+var codex_usage = { measurement };
+
+// scripts/cost-runtime/cost-corpus.ts
+function accumulate_missing(sessions) {
+  return {
+    no_usage_lines: sessions.reduce((sum, session) => sum + session.no_usage_lines, 0),
+    malformed_lines: sessions.reduce((sum, session) => sum + session.malformed_lines, 0),
+    unreadable_sessions: sessions.filter((session) => !session.is_readable).length,
+    // Filled by the attribution, which is the only step that knows a unit could not follow its
+    // parent; a per-session tally cannot see it, so it is zero here and set for an issue scope below.
+    unattributed_sessions: 0
+  };
 }
-function blocked_by_api_path(issue_number, repo) {
-  return `${issue_api_path(issue_number, repo)}/dependencies/blocked_by`;
+function load_corpus(cwd) {
+  const files = cost_transcript.list_sessions_across(cost_transcript.transcript_directories(cwd));
+  const sessions = files.map((file) => cost_transcript.read_session(file));
+  return { sessions, files, missing: accumulate_missing(sessions) };
 }
-function issue_comments_api_path(issue_number, repo) {
-  return `${issue_api_path(issue_number, repo)}/comments`;
+function session_meta(corpus) {
+  return new Map(
+    corpus.files.map((file) => [
+      file.session_id,
+      { is_delegated: file.is_delegated, owner: cost_transcript.owning_session_id(file) }
+    ])
+  );
 }
-function pulls_api_path(repo) {
-  return `${repo_api_path(repo)}/pulls`;
+function issue_set(records) {
+  const issues = cost_attribute.group_by_issue(records).map((group) => group.issue).filter((issue) => issue !== cost_attribute.UNATTRIBUTED_KEY);
+  return new Set(issues);
 }
-function pull_api_path(pr_number, repo) {
-  return `${pulls_api_path(repo)}/${pr_number}`;
+function sole_of(issues) {
+  if (issues.size !== 1) return cost_attribute.UNATTRIBUTED_KEY;
+  return [...issues][0] ?? cost_attribute.UNATTRIBUTED_KEY;
 }
-function pull_merge_api_path(pr_number, repo) {
-  return `${pull_api_path(pr_number, repo)}/merge`;
+function owner_sets(corpus, meta) {
+  const own = corpus.sessions.filter(
+    (session) => meta.get(session.session_id)?.is_delegated !== true
+  );
+  return new Map(own.map((session) => [session.session_id, issue_set(session.records)]));
+}
+function pairs_with_inherited(session, inherited, is_delegated) {
+  return cost_attribute.group_by_issue(session.records).flatMap(
+    (group) => group.records.map((record) => ({
+      record,
+      issue: group.issue === cost_attribute.UNATTRIBUTED_KEY ? inherited : group.issue,
+      baseline_tokens: session.baseline_tokens,
+      session_id: session.session_id,
+      is_delegated
+    }))
+  );
 }
-function pull_comments_api_path(pr_number, repo) {
-  return `${pull_api_path(pr_number, repo)}/comments`;
+var NO_ISSUES = /* @__PURE__ */ new Set();
+function parent_issues(session, meta, owners) {
+  const entry = meta.get(session.session_id);
+  if (entry?.is_delegated !== true) return NO_ISSUES;
+  return owners.get(entry.owner) ?? NO_ISSUES;
+}
+function pairs_of_session(session, meta, owners) {
+  const is_delegated = meta.get(session.session_id)?.is_delegated === true;
+  const candidates = parent_issues(session, meta, owners);
+  const inherited = is_delegated ? sole_of(candidates) : cost_attribute.UNATTRIBUTED_KEY;
+  const pairs = pairs_with_inherited(session, inherited, is_delegated);
+  const has_unattributed = pairs.some((pair) => pair.issue === cost_attribute.UNATTRIBUTED_KEY);
+  if (!is_delegated || !has_unattributed) return { pairs };
+  return { pairs, unattributed_candidates: candidates };
+}
+function attribute_corpus(corpus) {
+  const meta = session_meta(corpus);
+  const owners = owner_sets(corpus, meta);
+  const per_session = corpus.sessions.map((session) => pairs_of_session(session, meta, owners));
+  return {
+    pairs: per_session.flatMap((one) => one.pairs),
+    unattributed: per_session.flatMap(
+      (one) => one.unattributed_candidates === void 0 ? [] : [one.unattributed_candidates]
+    )
+  };
 }
-function pull_reviews_api_path(pr_number, repo) {
-  return `${pull_api_path(pr_number, repo)}/reviews`;
+function floor_for_issue(unattributed, issue_number) {
+  return unattributed.filter((set) => set.size === 0 || set.has(issue_number)).length;
 }
-function commit_api_path(commit_sha, repo) {
-  return `${repo_api_path(repo)}/commits/${commit_sha}`;
+function is_better(candidate, existing) {
+  const { UNATTRIBUTED_KEY } = cost_attribute;
+  return existing.issue === UNATTRIBUTED_KEY && candidate.issue !== UNATTRIBUTED_KEY;
 }
-function commit_check_runs_api_path(commit_sha, repo) {
-  return `${commit_api_path(commit_sha, repo)}/check-runs`;
+function values_of(best) {
+  const collected = [];
+  for (const [, pair] of best) collected.push(pair);
+  return collected;
 }
-function commit_status_api_path(commit_sha, repo) {
-  return `${commit_api_path(commit_sha, repo)}/status`;
+function dedupe_across_sessions(pairs) {
+  const best = /* @__PURE__ */ new Map();
+  for (const pair of pairs) {
+    const existing = best.get(pair.record.request_id);
+    if (existing === void 0 || is_better(pair, existing)) {
+      best.set(pair.record.request_id, pair);
+    }
+  }
+  return values_of(best);
 }
-function tag_reference_api_path(tag, repo) {
-  return `${repo_api_path(repo)}/git/ref/tags/${tag}`;
+function attributed(corpus) {
+  return dedupe_across_sessions(attribute_corpus(corpus).pairs);
 }
-function release_by_tag_api_path(tag, repo) {
-  return `${repo_api_path(repo)}/releases/tags/${tag}`;
+function mainline_records(pairs) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const pair of pairs) {
+    if (pair.is_delegated) continue;
+    groups.set(pair.session_id, [...groups.get(pair.session_id) ?? [], pair.record]);
+  }
+  return [...groups.values()];
 }
-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,
-  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
+var cost_corpus = {
+  load_corpus,
+  attribute_corpus,
+  floor_for_issue,
+  attributed,
+  mainline_records
 };
 
-// scripts/gh/git-gh-exec.ts
-import { execa as execa2, execaSync } from "execa";
+// scripts/cost-runtime/cost-verdict.ts
+var FAILURE_EXIT_CODE = 1;
+var OVER_VERDICT = "over";
+var UNDER_VERDICT = "under";
+function per_request_cost(measurement2) {
+  return measurement2.billed_input_per_request.at(-1) ?? 0;
+}
+function classify2(measurement2, limit) {
+  return per_request_cost(measurement2) > limit ? OVER_VERDICT : UNDER_VERDICT;
+}
+function over_summary(measurement2, limit) {
+  const total = measurement2.billed_input_per_request.length;
+  return `${String(per_request_cost(measurement2))} billed input tokens per request, on the newest of ${String(total)} request(s); limit ${String(limit)}`;
+}
+function report_over(measurement2, limit) {
+  if (measurement2 === void 0 || measurement2.billed_input_per_request.length === 0) {
+    console.error("No requests in this session; there is nothing to hand off.");
+    return FAILURE_EXIT_CODE;
+  }
+  console.info(classify2(measurement2, limit));
+  console.error(over_summary(measurement2, limit));
+  return 0;
+}
+var cost_verdict = {
+  OVER_VERDICT,
+  UNDER_VERDICT,
+  classify: classify2,
+  per_request_cost,
+  report_over
+};
 
-// 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/cost-runtime/transcript-cwd.ts
+import path2 from "node:path";
+function resolve(target, cwd) {
+  return target === void 0 ? cwd : path2.resolve(target);
 }
+var transcript_cwd = { resolve };
 
-// scripts/git/parse-json-array.ts
-function parse_json_loose(raw_json) {
-  return json_value.parse_or_undefined(raw_json);
+// scripts/cost-runtime/cost-cli.ts
+var ARGV_OFFSET = 2;
+var FAILURE_EXIT_CODE2 = 1;
+var USAGE = "Usage: josh cost (--cut | --over <tokens-per-request>) [--path <dir>]";
+var UNMEASURABLE_VERDICT = "unmeasurable";
+function to_threshold(raw) {
+  if (raw === void 0 || raw.trim() === "") return void 0;
+  const parsed = Number(raw);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
+}
+function is_unparsed(raw, parsed) {
+  return parsed === void 0 && raw !== void 0;
+}
+function selected_threshold(values) {
+  if (values.cut === true) return CONTEXT_CUT_THRESHOLD;
+  return to_threshold(values.over);
+}
+function threshold_option(over) {
+  return over === void 0 ? {} : { over };
+}
+function path_option(path4) {
+  return path4 === void 0 ? {} : { path: path4 };
+}
+function to_options(values) {
+  if (values.cut === true && values.over !== void 0) return void 0;
+  const over = selected_threshold(values);
+  if (is_unparsed(values.over, over)) return void 0;
+  return { ...threshold_option(over), ...path_option(values.path) };
+}
+var PARSE_ARGS_OPTIONS = {
+  cut: { type: "boolean" },
+  over: { type: "string" },
+  path: { type: "string" }
+};
+function parse_options(argv) {
+  const values = cli_flags.values_of(argv, PARSE_ARGS_OPTIONS);
+  return values === void 0 ? void 0 : to_options(values);
 }
-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 report_empty(cwd, session_id) {
+  const searched = cost_transcript.searched_directories(cost_transcript.transcript_directories(cwd));
+  for (const line of cost_transcript.missing_message(searched, session_id)) console.error(line);
+  return FAILURE_EXIT_CODE2;
 }
-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 provider_of(environment) {
+  const resolved = agent_role_profile.resolve_provider(environment);
+  if (resolved.kind !== "provider" || resolved.is_default === true) return void 0;
+  return resolved.provider;
 }
-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 z5 } from "zod";
-var error_document_schema = z5.object({ status: z5.union([z5.string(), z5.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 measurement_of(session) {
+  return {
+    billed_input_per_request: session.records.map(
+      (record) => cost_usage.billed_input(record.totals)
+    )
+  };
 }
-function failure_of(error) {
-  return has_gh_failure(error) ? error.gh_failure : void 0;
+function anthropic_own(target, environment) {
+  const corpus = cost_corpus.load_corpus(target);
+  const selection = own_session.select_own_session(corpus.files, environment);
+  if (selection.kind === "absent") return { kind: "absent", session_id: selection.session_id };
+  const session = corpus.sessions[selection.index];
+  if (session === void 0) return { kind: "empty" };
+  return { kind: "measured", measurement: measurement_of(session) };
 }
-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 anthropic_measurement(target, environment) {
+  const own = anthropic_own(target, environment);
+  return own.kind === "measured" ? own.measurement : void 0;
 }
-function direct_environment() {
-  const removed = agent_session_environment.removed_proxy_environment();
-  return Object.keys(removed).length > 0 ? { env: removed } : {};
+function same_openai_project(target, cwd) {
+  return cost_transcript.session_cwd(target) === cost_transcript.session_cwd(cwd);
 }
-function to_spawn_options(timeout_ms, cwd) {
-  return {
-    ...to_timeout_option(timeout_ms),
-    ...direct_environment(),
-    ...cwd !== void 0 && { cwd }
-  };
+function reject_openai_cross_project(context, target, cwd) {
+  if (context.provider !== "openai" || context.path === void 0 || same_openai_project(target, cwd)) {
+    return false;
+  }
+  console.error(
+    "OpenAI --path cannot select a thread from another project; run josh cost in that project."
+  );
+  return true;
 }
-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)
+function measure(target, provider, environment) {
+  return provider === "openai" ? codex_usage.measurement(target, cost_transcript.home_directory(), environment) : anthropic_measurement(target, environment);
+}
+function run_over_anthropic(own, target, limit) {
+  if (own.kind === "measured") return cost_verdict.report_over(own.measurement, limit);
+  return report_empty(target, own.kind === "absent" ? own.session_id : void 0);
+}
+function run_over_codex(target, limit, environment) {
+  const measurement2 = measure(target, "openai", environment);
+  if (measurement2 !== void 0) return cost_verdict.report_over(measurement2, limit);
+  console.error(`No Codex usage found for the current OpenAI thread under ${target}.`);
+  return FAILURE_EXIT_CODE2;
+}
+function run_over(target, limit, provider, environment) {
+  if (provider === "anthropic") {
+    return run_over_anthropic(anthropic_own(target, environment), target, limit);
+  }
+  return run_over_codex(target, limit, environment);
+}
+function verdict_of(measurement2) {
+  if (measurement2 === void 0 || measurement2.billed_input_per_request.length === 0) {
+    return UNMEASURABLE_VERDICT;
+  }
+  return cost_verdict.classify(measurement2, CONTEXT_CUT_THRESHOLD);
+}
+function session_verdict(cwd = process.cwd(), environment = process.env) {
+  const provider = provider_of(environment);
+  if (provider === void 0) return UNMEASURABLE_VERDICT;
+  return verdict_of(measure(cwd, provider, environment));
+}
+function run_context(argv, environment) {
+  const options = parse_options(argv);
+  if (options?.over === void 0) return void 0;
+  const provider = provider_of(environment);
+  if (provider === void 0) return void 0;
+  return { over: options.over, path: options.path, provider };
+}
+function run(argv, cwd = process.cwd(), environment = process.env) {
+  const context = run_context(argv, environment);
+  if (context === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE2;
+  }
+  const target = transcript_cwd.resolve(context.path, cwd);
+  if (reject_openai_cross_project(context, target, cwd)) return FAILURE_EXIT_CODE2;
+  return run_over(target, context.over, context.provider, environment);
+}
+function main(argv) {
+  process.exitCode = run(argv);
+}
+var cost_cli = {
+  UNMEASURABLE_VERDICT,
+  USAGE,
+  parse_options,
+  to_threshold,
+  run,
+  session_verdict
+};
+if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(ARGV_OFFSET));
+
+// scripts/rules/pre-gate-cut.ts
+var GATE_COMMANDS = /* @__PURE__ */ new Set(["gate"]);
+var CUT_COMMANDS = /* @__PURE__ */ new Set(["run:cut"]);
+var CUT_MODE_FLAG = /(?:^|\s)--(?:resume|end|json)(?:[=\s]|$)/u;
+var HOLD_COMMANDS = /* @__PURE__ */ new Set(["run:hold"]);
+var HOLD_MODE_FLAG = /(?:^|\s)--release(?:[=\s]|$)/u;
+function invokes_josh(command, names, mode_flag) {
+  return shell_segments.segments_of(command).some(
+    (segment) => shell_segments.is_josh_command(segment, names) && mode_flag?.test(segment) !== true
   );
 }
-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);
-  }
+function runs_the_gate(command) {
+  return invokes_josh(command, GATE_COMMANDS);
 }
-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);
-  }
+function takes_the_cut(command) {
+  return invokes_josh(command, CUT_COMMANDS, CUT_MODE_FLAG);
 }
-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 claims_the_hold(command) {
+  return invokes_josh(command, HOLD_COMMANDS, HOLD_MODE_FLAG);
 }
-function status_of_failure(error) {
-  return has_stdout_field(error) ? parse_status_line(error.stdout) : void 0;
+function asks_about_the_cut(command) {
+  return invokes_josh(command, CUT_COMMANDS);
 }
-async function exec_gh_api_status(path, timeout_ms) {
-  const options = to_spawn_options(timeout_ms);
-  try {
-    await check_gh_installed();
-    const { stdout } = await execa2("gh", ["api", "--include", "--silent", path], options);
-    return parse_status_line(stdout);
-  } catch (error) {
-    return status_of_failure(error);
-  }
+function current_state2() {
+  return {
+    directory: process.cwd(),
+    carried: run_cut.carried_cut_sync,
+    marked_issue: lane_child_marker.marked_issue(),
+    is_reviewer: agent_session_role.is_reviewer(),
+    context_verdict: cost_cli.session_verdict
+  };
 }
-function exec_gh_api_status_sync(path, timeout_ms) {
-  const options = to_spawn_options(timeout_ms);
-  try {
-    const { stdout } = execaSync("gh", ["api", "--include", "--silent", path], options);
-    return parse_status_line(stdout);
-  } catch (error) {
-    return status_of_failure(error);
-  }
+function dispatched_issue(state) {
+  return state.is_reviewer ? void 0 : state.marked_issue;
+}
+function uncut_lane_issue(state) {
+  const issue = lane_paths.lane_issue_of(state.directory);
+  if (issue === void 0 || dispatched_issue(state) !== issue) return void 0;
+  return state.carried()?.issue === issue ? void 0 : issue;
+}
+function warrants_the_cut(verdict) {
+  return verdict !== cost_verdict.UNDER_VERDICT;
+}
+function is_uncut_gate(command, state = current_state2()) {
+  if (!runs_the_gate(command) || uncut_lane_issue(state) === void 0) return false;
+  return warrants_the_cut(state.context_verdict());
+}
+var PRE_GATE_CUT_REASON = "\u26D4 pre-gate cut: this checkout is a lane dispatched for this issue and the gate is the boundary to cut at. Issue `pnpm josh run:cut <N>`: on `cut`, end the turn immediately \u2014 no Telegram is owed; on any other verdict (`not-a-lane`, `busy`, \u2026), reissue the gate \u2014 this fires once per run (`.claude/skills/workflow-commands/pre-gate-cut.md`).";
+function reaches_the_pre_gate_boundary(call, _turn, run2) {
+  if (!bash_triggers.on_bash_command(asks_about_the_cut)(call)) return false;
+  return run2.some((issued) => bash_triggers.on_bash_command(claims_the_hold)(issued));
+}
+var pre_gate_cut = {
+  PRE_GATE_CUT_REASON,
+  asks_about_the_cut,
+  claims_the_hold,
+  is_uncut_gate,
+  reaches_the_pre_gate_boundary,
+  runs_the_gate,
+  takes_the_cut,
+  uncut_lane_issue
+};
+
+// scripts/discovery/repo-party.ts
+var FIRST_PARTY = "first-party";
+var THIRD_PARTY = "third-party";
+var UNKNOWN = "unknown";
+var GH_REPO_ENV_KEY = "GH_REPO";
+var GH_REPO_PATH_SEGMENTS = 2;
+function classify3(session_owner, target) {
+  if (session_owner === void 0 || target === void 0) return UNKNOWN;
+  return session_owner.toLowerCase() === target.toLowerCase() ? FIRST_PARTY : THIRD_PARTY;
 }
-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)
-  ];
+function target_owner(owner_repo) {
+  return repo_origin.parse_origin_url(`https://${repo_origin.GITHUB_HOST}/${owner_repo}`)?.owner;
 }
-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 current_owner(repository_path = process.cwd()) {
+  return repo_discovery.resolve_current_owner(repository_path);
 }
-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 gh_repo_owners(gh_repo) {
+  return [target_owner(gh_repo.split("/").slice(-GH_REPO_PATH_SEGMENTS).join("/"))];
 }
-function read_gh_api_sync(request) {
-  try {
-    return exec_gh_api_sync(request);
-  } catch {
-    return void 0;
-  }
+function remote_owners(repository_path) {
+  return repo_discovery.read_remote_urls(repository_path).map((url) => repo_origin.parse_origin_url(url)?.owner);
+}
+function placeholder_owners(repository_path = process.cwd(), environment = process.env) {
+  const gh_repo = environment[GH_REPO_ENV_KEY];
+  return gh_repo === void 0 || gh_repo === "" ? remote_owners(repository_path) : gh_repo_owners(gh_repo);
 }
-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
+var repo_party = {
+  FIRST_PARTY,
+  THIRD_PARTY,
+  UNKNOWN,
+  classify: classify3,
+  current_owner,
+  placeholder_owners,
+  target_owner
 };
 
-// scripts/gh/git-gh-helpers.ts
-function parse_pr_state_string(result) {
-  const trimmed = result.trim();
-  return trimmed.length > 0 ? trimmed : 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");
+// scripts/gh/git-gh-repo.ts
+async function repo_get_name_with_owner() {
+  try {
+    const result = await git_gh_exec.exec_gh_api({
+      path: git_gh_api_path.repo_api_path(),
+      jq_filter: ".full_name"
+    });
+    return git_gh_helpers.parse_pr_state_string(result);
+  } catch {
+    return void 0;
   }
-  throw error;
 }
-var git_gh_helpers = {
-  parse_pr_state_string,
-  get_error_message_with_stderr,
-  handle_pr_create_error
+var git_gh_repo = {
+  repo_get_name_with_owner
 };
 
 // scripts/gh/git-gh-issue-rest.ts
-import { z as z6 } 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 = z6.looseObject({
-  number: z6.number(),
-  issue_dependencies_summary: z6.looseObject({ total_blocked_by: z6.number().optional() }).nullish(),
+import { z as z5 } from "zod";
+var rest_issue_schema = z5.looseObject({
+  number: z5.number(),
+  issue_dependencies_summary: z5.looseObject({ total_blocked_by: z5.number().optional() }).nullish(),
   // Present only on a pull request, which this endpoint serves as readily as an issue.
-  pull_request: z6.looseObject({ merged_at: z6.string().nullish() }).nullish()
+  pull_request: z5.looseObject({ merged_at: z5.string().nullish() }).nullish()
 });
 var REPOSITORY_URL = /\/repos\/([\w.-]+\/[\w.-]+)$/u;
 var REPOSITORY_URL_GROUP = 1;
@@ -1898,6 +1738,7 @@ 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";
@@ -2046,23 +1887,23 @@ function to_read_failure(error) {
 }
 async function issue_view_json_classified(issue_number, fields, repo) {
   try {
-    const issue2 = await read_issue_fields(issue_number, fields, repo);
-    return { kind: "read", json: JSON.stringify(issue2) };
+    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 issue2 = await read_issue_fields(issue_number, field, repo);
-    return { kind: "read", text: git_gh_issue_rest.to_field_text(issue2[field]) };
+    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;
+  const read2 = await issue_view_field_classified(issue_number, field, repo);
+  return read2.kind === "read" ? read2.text : void 0;
 }
 async function issue_get_title(issue_number, repo) {
   const result = await issue_view_field(issue_number, "title", repo);
@@ -2075,8 +1916,8 @@ 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;
+  const read2 = await issue_view_json_classified(issue_number, fields, repo);
+  return read2.kind === "read" ? read2.json : void 0;
 }
 var STATE_AND_RELATIONS_FIELDS = "number,state,labels,blockedBy";
 async function issue_get_state_and_relations(issue_number, repo) {
@@ -2099,9 +1940,9 @@ 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 path = `${git_gh_api_path.issue_comments_api_path(issue_number)}${git_gh_api_path.FULL_PAGE_QUERY}`;
+  const path4 = `${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, should_paginate: true, timeout_ms });
+    return await git_gh_exec.exec_gh_api({ path: path4, should_paginate: true, timeout_ms });
   } catch {
     return void 0;
   }
@@ -2176,8 +2017,8 @@ function is_selected(rest, request) {
   return !git_gh_issue_rest.is_pull_request(rest) && matches_body(rest, request.body_term);
 }
 async function fetch_page(request, page) {
-  const path = listing_path(request, page);
-  const rows = git_gh_issue_rest.parse_rest_issues(await git_gh_exec.exec_gh_api({ path }));
+  const path4 = listing_path(request, page);
+  const rows = git_gh_issue_rest.parse_rest_issues(await git_gh_exec.exec_gh_api({ path: path4 }));
   return {
     selected: rows.filter((row) => is_selected(row, request)),
     is_full: rows.length >= PER_PAGE
@@ -2229,7 +2070,7 @@ var git_gh_issue_list = {
 };
 
 // scripts/issue/issue-watch-diff.ts
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 var RUN_MARKER = "<!-- josh:run -->";
 var BOT_TYPE = "Bot";
 var BOT_SUFFIX = "[bot]";
@@ -2244,11 +2085,11 @@ var AT = " at ";
 var SECTION_SEPARATOR = "\n\n";
 var LINE_SEPARATOR = "\n";
 var CRLF = "\r\n";
-var comment_schema = z7.looseObject({
-  id: z7.number(),
-  user: z7.looseObject({ login: z7.string(), type: z7.string().optional() }).nullish(),
-  created_at: z7.string().optional(),
-  body: z7.string().nullish()
+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()
 });
 function is_bot(user) {
   return user?.type === BOT_TYPE || (user?.login.endsWith(BOT_SUFFIX) ?? false);
@@ -2320,6 +2161,7 @@ var LABEL_NAMES_FILTER = ".[].name";
 var LABELS_SEGMENT = "/labels";
 var COMMENTS_SEGMENT = "/comments";
 var CLOSED_STATE = "closed";
+var NOT_PLANNED_REASON = "not_planned";
 var COLOR_HASH = "#";
 var UNPROCESSABLE_STATUS = 422;
 var ALREADY_EXISTS_CODE = "already_exists";
@@ -2352,16 +2194,25 @@ ${issue_watch_diff.RUN_MARKER}` }),
 async function issue_try_comment(issue_number, body) {
   return await did_write_succeed(async () => await issue_comment(issue_number, body));
 }
-async function issue_close(issue_number, comment) {
+async function close_with(issue_number, comment, state) {
   return await did_write_succeed(async () => {
     if (comment !== void 0) await issue_comment(issue_number, comment);
     await git_gh_exec.exec_gh_api({
       path: git_gh_api_path.issue_api_path(issue_number),
       method: PATCH_METHOD,
-      body: JSON.stringify({ state: CLOSED_STATE })
+      body: JSON.stringify(state)
     });
   });
 }
+async function issue_close(issue_number, comment) {
+  return await close_with(issue_number, comment, { state: CLOSED_STATE });
+}
+async function issue_close_not_planned(issue_number, comment) {
+  return await close_with(issue_number, comment, {
+    state: CLOSED_STATE,
+    state_reason: NOT_PLANNED_REASON
+  });
+}
 function to_label_color(color) {
   return color.startsWith(COLOR_HASH) ? color.slice(COLOR_HASH.length) : color;
 }
@@ -2474,6 +2325,7 @@ var git_gh_issue_write = {
   issue_comment,
   issue_try_comment,
   issue_close,
+  issue_close_not_planned,
   label_ensure,
   issue_create_request,
   issue_create_with_label,
@@ -2543,20 +2395,20 @@ var git_gh_issue = {
 };
 
 // scripts/ci/pr-classification.ts
-import { readFileSync as readFileSync2 } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { z as z8 } from "zod";
+import { readFileSync as readFileSync3 } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { z as z7 } from "zod";
 var CLASSIFICATION_SET = new Set(RELEASE_CLASSIFICATION_NAMES);
 var ISSUE_BUG_LABEL = "bug";
 var DECLARATION_PREFIX = "- \u30EA\u30EA\u30FC\u30B9\u5206\u985E: ";
 var DECLARATION = new RegExp(`^${DECLARATION_PREFIX}(.+)$`, "gmu");
 var LEGACY_LABELS = /* @__PURE__ */ new Set(["semver-major", "semver-minor"]);
-var LABEL = z8.object({ name: z8.string() });
-var USER = z8.object({ login: z8.string() });
-var PULL_REQUEST = z8.object({ number: z8.number(), user: USER });
-var EVENT = z8.object({
+var LABEL = z7.object({ name: z7.string() });
+var USER = z7.object({ login: z7.string() });
+var PULL_REQUEST = z7.object({ number: z7.number(), user: USER });
+var EVENT = z7.object({
   pull_request: PULL_REQUEST,
-  repository: z8.object({ full_name: z8.string() })
+  repository: z7.object({ full_name: z7.string() })
 });
 function classification_error(labels, author) {
   const legacy = labels.filter((label) => LEGACY_LABELS.has(label.toLowerCase()));
@@ -2579,9 +2431,9 @@ function release_candidates(candidates) {
   return candidates.filter((candidate) => candidate !== ENHANCEMENT_LABEL);
 }
 function issue_candidates(issue_json) {
-  const issue2 = z8.object({ labels: z8.array(LABEL), body: z8.string().nullable() }).parse(JSON.parse(issue_json));
-  const names = issue2.labels.map((label) => label.name.toLowerCase());
-  const declared = [...(issue2.body ?? "").matchAll(DECLARATION)].map((match) => match[1] ?? "");
+  const issue = z7.object({ labels: z7.array(LABEL), body: z7.string().nullable() }).parse(JSON.parse(issue_json));
+  const names = issue.labels.map((label) => label.name.toLowerCase());
+  const declared = [...(issue.body ?? "").matchAll(DECLARATION)].map((match) => match[1] ?? "");
   const candidates = [...release_candidates([...names, ...declared].filter(is_classification))];
   const unknown = declared.filter((value) => !is_classification(value));
   if (unknown.length > 0) throw new Error(`Unknown release classification: ${unknown.join(", ")}`);
@@ -2602,9 +2454,9 @@ function select_issue_classification(issue_json) {
   return label;
 }
 function fetch_current_labels(repository, pull_number) {
-  const path = `repos/${repository}/issues/${String(pull_number)}/labels`;
+  const path4 = `repos/${repository}/issues/${String(pull_number)}/labels`;
   try {
-    const names = git_gh_exec.exec_gh_api_sync({ path, jq_filter: ".[].name" });
+    const names = git_gh_exec.exec_gh_api_sync({ path: path4, jq_filter: ".[].name" });
     return names.split("\n").filter((name) => name !== "");
   } catch (error) {
     const detail = error_text.message_of(error);
@@ -2612,11 +2464,11 @@ function fetch_current_labels(repository, pull_number) {
   }
 }
 function check_event(event_path, read_labels = fetch_current_labels) {
-  const event = EVENT.parse(JSON.parse(readFileSync2(event_path, "utf8")));
+  const event = EVENT.parse(JSON.parse(readFileSync3(event_path, "utf8")));
   const labels = read_labels(event.repository.full_name, event.pull_request.number);
   return classification_error(labels, event.pull_request.user.login);
 }
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
+if (process.argv[1] === fileURLToPath2(import.meta.url)) {
   const event_path = process.env["GITHUB_EVENT_PATH"];
   if (!event_path) throw new Error("GITHUB_EVENT_PATH is required");
   const error = check_event(event_path);
@@ -2636,8 +2488,8 @@ var pr_classification = {
 
 // scripts/lib/poll.ts
 async function sleep2(duration_ms) {
-  await new Promise((resolve) => {
-    setTimeout(resolve, duration_ms);
+  await new Promise((resolve2) => {
+    setTimeout(resolve2, duration_ms);
   });
 }
 async function wait_between(wait, interval_ms, attempt, attempts) {
@@ -2654,256 +2506,17 @@ async function poll_until(is_done, options) {
 var poll = { poll_until, sleep: sleep2 };
 
 // scripts/gh/git-gh-pr.ts
-import { z as z12 } from "zod";
-
-// scripts/gh/git-gh-pr-rest.ts
-import { z as z9 } from "zod";
-var rest_repo_schema = z9.looseObject({ full_name: z9.string().optional() }).nullish();
-var rest_pull_side_schema = z9.looseObject({ repo: rest_repo_schema });
-var rest_pull_schema = z9.looseObject({
-  number: z9.number(),
-  html_url: z9.string().optional(),
-  body: z9.string().nullish(),
-  state: z9.string().optional(),
-  merged: z9.boolean().nullish(),
-  merged_at: z9.string().nullish(),
-  mergeable: z9.boolean().nullish(),
-  mergeable_state: z9.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: z9.looseObject({ ref: z9.string().optional(), sha: z9.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: z9.string().optional(),
-  auto_merge: z9.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 path = `${to_path(String(pr_number))}${COMMENTS_QUERY}`;
-  try {
-    return to_json(await git_gh_exec.exec_gh_api({ path, 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
-};
+import { z as z10 } from "zod";
 
 // scripts/gh/git-gh-pr-review.ts
-import { z as z10 } from "zod";
+import { z as z8 } from "zod";
 var REVIEW_APPROVED = "APPROVED";
 var REVIEW_CHANGES_REQUESTED = "CHANGES_REQUESTED";
 var REVIEW_NONE = "";
 var STATE_CHANGING_REVIEWS = /* @__PURE__ */ new Set([REVIEW_APPROVED, REVIEW_CHANGES_REQUESTED]);
-var rest_review_schema = z10.looseObject({
-  state: z10.string().optional(),
-  user: z10.looseObject({ login: z10.string().optional() }).nullish()
+var rest_review_schema = z8.looseObject({
+  state: z8.string().optional(),
+  user: z8.looseObject({ login: z8.string().optional() }).nullish()
 });
 var NOT_A_REVIEW_LISTING = "gh api answered something other than a review listing";
 function parse_rest_reviews(reviews_json) {
@@ -2936,18 +2549,18 @@ function to_review_decision(reviews_json) {
 var git_gh_pr_review = { to_review_decision };
 
 // scripts/gh/git-gh-pr-rollup.ts
-import { z as z11 } from "zod";
+import { z as z9 } from "zod";
 var STATUS_CONTEXT_TYPE_NAME = "StatusContext";
 var TYPE_NAME_KEY = "__typename";
-var rollup_element_schema = z11.looseObject({});
-var check_runs_page_schema = z11.looseObject({
+var rollup_element_schema = z9.looseObject({});
+var check_runs_page_schema = z9.looseObject({
   // Required, not optional: GitHub always names the key, and accepting a page without one would
   // answer an empty rollup — which `git-pr-followup.ts` reports as "this branch has no checks".
-  check_runs: z11.array(rollup_element_schema)
+  check_runs: z9.array(rollup_element_schema)
 });
-var id_holder_schema = z11.object({ id: z11.number() });
-var status_page_schema = z11.looseObject({
-  statuses: z11.array(rollup_element_schema)
+var id_holder_schema = z9.object({ id: z9.number() });
+var status_page_schema = z9.looseObject({
+  statuses: z9.array(rollup_element_schema)
 });
 var NOT_A_CHECK_RUNS_LISTING = "gh api answered something other than a check run listing";
 var NOT_A_STATUS_LISTING = "gh api answered something other than a commit status listing";
@@ -2961,15 +2574,15 @@ function read_id(value) {
   const parsed = id_holder_schema.safeParse(value);
   return parsed.success ? parsed.data.id : void 0;
 }
-function check_run_group_key(run) {
-  const { name, app } = run;
+function check_run_group_key(run2) {
+  const { name, app } = run2;
   if (typeof name !== "string") return void 0;
   return JSON.stringify([name, read_id(app)]);
 }
-function read_rank(run) {
-  const id = read_id(run);
+function read_rank(run2) {
+  const id = read_id(run2);
   if (id === void 0) return void 0;
-  return { suite: read_id(run["check_suite"]) ?? NO_SUITE, run: id };
+  return { suite: read_id(run2["check_suite"]) ?? NO_SUITE, run: id };
 }
 function is_ranked_above(candidate, current) {
   if (candidate.suite !== current.suite) return candidate.suite > current.suite;
@@ -2979,23 +2592,23 @@ function should_replace(previous, rank) {
   const previous_rank = previous === void 0 ? void 0 : read_rank(previous);
   return previous_rank === void 0 || is_ranked_above(rank, previous_rank);
 }
-function remember_newest_run(run, newest) {
-  const key2 = check_run_group_key(run);
-  const rank = read_rank(run);
+function remember_newest_run(run2, newest) {
+  const key2 = check_run_group_key(run2);
+  const rank = read_rank(run2);
   if (key2 === void 0 || rank === void 0) return;
-  if (should_replace(newest.get(key2), rank)) newest.set(key2, run);
+  if (should_replace(newest.get(key2), rank)) newest.set(key2, run2);
 }
-function is_newest_run(run, newest) {
-  const key2 = check_run_group_key(run);
-  if (key2 === void 0 || read_rank(run) === void 0) return true;
-  return newest.get(key2) === run;
+function is_newest_run(run2, newest) {
+  const key2 = check_run_group_key(run2);
+  if (key2 === void 0 || read_rank(run2) === void 0) return true;
+  return newest.get(key2) === run2;
 }
 function to_check_run_items(check_runs_json) {
   const pages = read_pages(check_runs_json, check_runs_page_schema, NOT_A_CHECK_RUNS_LISTING);
   const runs = pages.flatMap((page) => page.check_runs);
   const newest = /* @__PURE__ */ new Map();
-  for (const run of runs) remember_newest_run(run, newest);
-  return runs.filter((run) => is_newest_run(run, newest));
+  for (const run2 of runs) remember_newest_run(run2, newest);
+  return runs.filter((run2) => is_newest_run(run2, newest));
 }
 function to_status_context_items(status_json) {
   const pages = read_pages(status_json, status_page_schema, NOT_A_STATUS_LISTING);
@@ -3013,16 +2626,16 @@ var git_gh_pr_rollup = {
 
 // scripts/gh/git-gh-pr-snapshot.ts
 var NO_HEAD_SHA_MESSAGE = "gh api answered a pull request with no head commit";
-async function read_object_pages(path) {
+async function read_object_pages(path4) {
   return await git_gh_exec.exec_gh_api({
-    path: `${path}${FULL_PAGE_QUERY}`,
+    path: `${path4}${FULL_PAGE_QUERY}`,
     should_paginate: true,
     should_slurp: true
   });
 }
-async function read_array_pages(path) {
+async function read_array_pages(path4) {
   return await git_gh_exec.exec_gh_api({
-    path: `${path}${FULL_PAGE_QUERY}`,
+    path: `${path4}${FULL_PAGE_QUERY}`,
     should_paginate: true
   });
 }
@@ -3039,8 +2652,8 @@ async function read_status_check_rollup(commit_sha) {
   return git_gh_pr_rollup.to_status_check_rollup({ check_runs_json, status_json });
 }
 async function pr_get_review_decision(pr_number) {
-  const path = git_gh_api_path.pull_reviews_api_path(String(pr_number));
-  return git_gh_pr_review.to_review_decision(await read_array_pages(path));
+  const path4 = git_gh_api_path.pull_reviews_api_path(String(pr_number));
+  return git_gh_pr_review.to_review_decision(await read_array_pages(path4));
 }
 async function build_checks_fields(pull) {
   return {
@@ -3081,7 +2694,7 @@ var MERGE_READ_BACK_ATTEMPTS = 3;
 var MERGE_READ_BACK_INTERVAL_MS = 1e3;
 var PR_NUMBER_PATTERN = /\/pull\/([1-9]\d*)$/u;
 var LABELS_SEGMENT2 = "/labels";
-var PR_LABELS = z12.array(z12.object({ name: z12.string() }));
+var PR_LABELS = z10.array(z10.object({ name: z10.string() }));
 async function add_pr_classification(number, label) {
   await git_gh_exec.exec_gh_api({
     path: `${git_gh_api_path.issue_api_path(number)}${LABELS_SEGMENT2}`,
@@ -3163,8 +2776,8 @@ async function sleep_between_read_backs(attempt) {
 }
 async function has_merge_landed(pr_number, merge_error) {
   for (let attempt = 0; attempt < MERGE_READ_BACK_ATTEMPTS; attempt += 1) {
-    const is_merged2 = await read_merge_state(pr_number);
-    if (is_merged2 !== void 0) return is_merged2;
+    const is_merged = await read_merge_state(pr_number);
+    if (is_merged !== void 0) return is_merged;
     await sleep_between_read_backs(attempt);
   }
   throw new Error(MERGE_UNCONFIRMED_MESSAGE, { cause: merge_error });
@@ -3235,22 +2848,6 @@ var git_gh_pr_auto_merge = {
   pr_list_open_with_head_prefix
 };
 
-// scripts/gh/git-gh-repo.ts
-async function repo_get_name_with_owner() {
-  try {
-    const result = await git_gh_exec.exec_gh_api({
-      path: git_gh_api_path.repo_api_path(),
-      jq_filter: ".full_name"
-    });
-    return git_gh_helpers.parse_pr_state_string(result);
-  } catch {
-    return void 0;
-  }
-}
-var git_gh_repo = {
-  repo_get_name_with_owner
-};
-
 // scripts/gh/git-pr-checks.ts
 var SECONDS_TO_MS = 1e3;
 var CHECK_WAIT_INTERVAL_MS = 1e4;
@@ -3325,16 +2922,16 @@ function to_exhaustion_error(last_read_failure) {
 }
 async function attempt_pr_success_poll(input) {
   const evaluator = input.options.evaluator ?? MERGE_GATE_EVALUATOR;
-  const read = await read_pr_state(input, evaluator);
-  if (read.kind === "unreadable") return await retry_after_unreadable(input, read.cause);
+  const read2 = await read_pr_state(input, evaluator);
+  if (read2.kind === "unreadable") return await retry_after_unreadable(input, read2.cause);
   const classification = classify_poll_result({
-    snapshot: read.snapshot,
+    snapshot: read2.snapshot,
     stable_count: input.stable_count,
     required_stable_reads: input.options.required_stable_reads,
     evaluator
   });
   if (classification.is_done) {
-    return { snapshot: read.snapshot, next_stable_count: 0, next_failure_count: 0 };
+    return { snapshot: read2.snapshot, next_stable_count: 0, next_failure_count: 0 };
   }
   await sleep_before_next_attempt(input);
   return { next_stable_count: classification.next_stable_count, next_failure_count: 0 };
@@ -3375,20 +2972,20 @@ var PR_CHECKS_WATCH_TIMEOUT_MS = 12e4;
 var WATCH_TIMED_OUT_NOTE = "\u23F1\uFE0F pr checks --watch timed out.";
 var NO_CHECKS_MESSAGE = "gh api reported no checks on the branch";
 var CHECKS_FAILED_MESSAGE = "gh api reported a failing check on the branch";
-function is_awaited_check(check) {
-  return !is_coderabbit_check(check.name) || is_required_check(check.name);
+function is_awaited_check(check2) {
+  return !is_coderabbit_check(check2.name) || is_required_check(check2.name);
 }
 function evaluate_checks_settled(snapshot) {
-  const awaited = snapshot.rollup.filter((check) => is_awaited_check(check));
+  const awaited = snapshot.rollup.filter((check2) => is_awaited_check(check2));
   const considered = awaited.length === 0 ? snapshot.rollup : awaited;
-  if (considered.length === 0 || considered.some((check) => check.status === CHECK_STATUS_PENDING)) {
+  if (considered.length === 0 || considered.some((check2) => check2.status === CHECK_STATUS_PENDING)) {
     return "pending";
   }
-  return snapshot.rollup.some((check) => check.status === CHECK_STATUS_FAIL) ? "failure" : "success";
+  return snapshot.rollup.some((check2) => check2.status === CHECK_STATUS_FAIL) ? "failure" : "success";
 }
 function describe_checks_failure(snapshot) {
-  const failed = snapshot.rollup.filter((check) => check.status === CHECK_STATUS_FAIL);
-  return `${CHECKS_FAILED_MESSAGE}: ${failed.map((check) => check.name).join(", ")}`;
+  const failed = snapshot.rollup.filter((check2) => check2.status === CHECK_STATUS_FAIL);
+  return `${CHECKS_FAILED_MESSAGE}: ${failed.map((check2) => check2.name).join(", ")}`;
 }
 function should_never_read_review_decision() {
   return false;
@@ -3457,39 +3054,480 @@ function get_repo_name_with_owner_within(timeout_ms) {
 }
 var gh_spawn = { get_repo_name_with_owner, get_repo_name_with_owner_within };
 
+// scripts/issue/issue-state.ts
+import { z as z11 } from "zod";
+var NO_LABELS = "(none)";
+var LABEL_SEPARATOR = ", ";
+var STATE_LABEL = "state: ";
+var LABELS_LABEL = "labels: ";
+var HUMAN_REVIEW_LABEL_LINE = "human_review: ";
+var YES = "yes";
+var NO = "no";
+var ISSUE_LABEL = "issue: ";
+var HUMAN_REVIEW_LABELS = /* @__PURE__ */ new Set([NEEDS_HUMAN_REVIEW_LABEL]);
+var label_schema = z11.looseObject({ name: z11.string() });
+var issue_state_schema = z11.looseObject({
+  state: z11.string(),
+  labels: label_schema.array().optional()
+});
+function parse_issue_state(json) {
+  try {
+    const parsed = parse_json_object_or_undefined(json, issue_state_schema);
+    if (parsed === void 0) return void 0;
+    const labels = parsed.labels ?? [];
+    return {
+      state: parsed.state,
+      labels: labels.map((label) => label.name),
+      is_human_review: has_any_label(labels, HUMAN_REVIEW_LABELS)
+    };
+  } catch {
+    return void 0;
+  }
+}
+function format_labels(labels) {
+  return labels.length === 0 ? NO_LABELS : labels.join(LABEL_SEPARATOR);
+}
+function format_issue_state(state) {
+  const human_review = `${HUMAN_REVIEW_LABEL_LINE}${state.is_human_review ? YES : NO}`;
+  return `${STATE_LABEL}${state.state}
+${LABELS_LABEL}${format_labels(state.labels)}
+${human_review}`;
+}
+function format_attributed_issue_state(issue_number, state) {
+  return `${ISSUE_LABEL}${issue_number}
+${format_issue_state(state)}`;
+}
+var issue_state = {
+  NO_LABELS,
+  parse_issue_state,
+  format_issue_state,
+  format_attributed_issue_state
+};
+
+// scripts/run/run-liveness.ts
+import { readFileSync as readFileSync4, realpathSync, statSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import path3 from "node:path";
+import { setTimeout as sleep3 } from "node:timers/promises";
+
+// scripts/agent/agent-event.ts
+import { z as z14 } from "zod";
+
+// scripts/agent/claude-result-event.ts
+import { z as z13 } from "zod";
+
+// scripts/agent/interactive-ask.ts
+import { z as z12 } from "zod";
+var INTERACTIVE_TOOLS = /* @__PURE__ */ new Set(["AskUserQuestion"]);
+function is_interactive_tool(name) {
+  return INTERACTIVE_TOOLS.has(name);
+}
+var OPTION_SCHEMA = z12.looseObject({ label: z12.string().optional() });
+var QUESTION_SCHEMA = z12.looseObject({
+  question: z12.string().optional(),
+  options: z12.array(OPTION_SCHEMA).optional()
+});
+var ASK_INPUT_SCHEMA = z12.looseObject({ questions: z12.array(QUESTION_SCHEMA).optional() });
+var DENIAL_SCHEMA = z12.looseObject({
+  tool_name: z12.string().optional(),
+  tool_input: z12.unknown().optional()
+});
+var UNKNOWN_QUESTION = "(question text unavailable)";
+var OPTION_SEPARATOR = " / ";
+var QUESTION_SEPARATOR = "; ";
+function labels_of(question) {
+  return (question.options ?? []).map((option) => option.label ?? "").filter((label) => label !== "");
+}
+function render_question(question) {
+  const labels = labels_of(question);
+  const text = question.question ?? UNKNOWN_QUESTION;
+  return labels.length === 0 ? text : `${text} [${labels.join(OPTION_SEPARATOR)}]`;
+}
+function interactive_input(raw) {
+  const denial = DENIAL_SCHEMA.safeParse(raw);
+  if (!denial.success || !is_interactive_tool(denial.data.tool_name ?? "")) return void 0;
+  const input = ASK_INPUT_SCHEMA.safeParse(denial.data.tool_input);
+  return input.success ? input.data : void 0;
+}
+function refused_ask_of(permission_denials) {
+  if (!Array.isArray(permission_denials)) return void 0;
+  const input = permission_denials.map((raw) => interactive_input(raw)).find((one) => one !== void 0);
+  const questions = input?.questions ?? [];
+  if (questions.length === 0) return void 0;
+  return questions.map((question) => render_question(question)).join(QUESTION_SEPARATOR);
+}
+var interactive_ask = { is_interactive_tool, refused_ask_of };
+
+// scripts/agent/claude-result-event.ts
+var RESULT_EVENT_SCHEMA = z13.looseObject({
+  type: z13.literal("result"),
+  is_error: z13.unknown().optional(),
+  subtype: z13.unknown().optional(),
+  num_turns: z13.unknown().optional(),
+  permission_denials: z13.unknown().optional(),
+  result: z13.unknown().optional(),
+  session_id: z13.unknown().optional(),
+  usage: z13.unknown().optional()
+});
+var USAGE_SCHEMA = z13.looseObject({
+  input_tokens: z13.unknown().optional(),
+  cache_read_input_tokens: z13.unknown().optional(),
+  output_tokens: z13.unknown().optional()
+});
+function usable_reason(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+function numeric_value(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function denial_count(value) {
+  return Array.isArray(value) ? value.length : 0;
+}
+function usage_of(value) {
+  const parsed = USAGE_SCHEMA.safeParse(value);
+  if (!parsed.success) return void 0;
+  const usage = {
+    input_tokens: numeric_value(parsed.data.input_tokens),
+    cached_input_tokens: numeric_value(parsed.data.cache_read_input_tokens),
+    output_tokens: numeric_value(parsed.data.output_tokens)
+  };
+  return Object.values(usage).some((count) => count !== void 0) ? usage : void 0;
+}
+function decode(value) {
+  const parsed = RESULT_EVENT_SCHEMA.safeParse(value);
+  if (!parsed.success) return void 0;
+  const is_error = parsed.data.is_error === true;
+  return {
+    is_error,
+    subtype: usable_reason(parsed.data.subtype),
+    num_turns: numeric_value(parsed.data.num_turns),
+    permission_denials: denial_count(parsed.data.permission_denials),
+    refused_ask: interactive_ask.refused_ask_of(parsed.data.permission_denials),
+    reason: is_error ? usable_reason(parsed.data.result) ?? usable_reason(parsed.data.subtype) : void 0,
+    session_id: usable_reason(parsed.data.session_id),
+    usage: usage_of(parsed.data.usage)
+  };
+}
+var claude_result_event = { decode };
+
+// scripts/agent/agent-event.ts
+var TEXT_BLOCK_SCHEMA = z14.looseObject({ type: z14.literal("text"), text: z14.string() });
+var CLAUDE_MESSAGE_SCHEMA = z14.looseObject({ content: z14.array(z14.unknown()).optional() });
+var CLAUDE_INIT_SCHEMA = z14.looseObject({ type: z14.literal("system"), subtype: z14.literal("init") });
+var CLAUDE_ASSISTANT_SCHEMA = z14.looseObject({
+  type: z14.literal("assistant"),
+  message: CLAUDE_MESSAGE_SCHEMA
+});
+var USAGE_SCHEMA2 = z14.looseObject({
+  input_tokens: z14.number().optional(),
+  cached_input_tokens: z14.number().optional(),
+  output_tokens: z14.number().optional()
+});
+var CODEX_START_SCHEMA = z14.looseObject({ type: z14.enum(["thread.started", "turn.started"]) });
+var CODEX_PROGRESS_SCHEMA = z14.looseObject({
+  type: z14.enum(["item.started", "item.updated", "item.completed"]),
+  item: z14.looseObject({ type: z14.string(), text: z14.string().optional() }).optional()
+});
+var CODEX_COMPLETE_SCHEMA = z14.looseObject({
+  type: z14.literal("turn.completed"),
+  usage: USAGE_SCHEMA2.optional()
+});
+var CODEX_FAILURE_SCHEMA = z14.looseObject({
+  type: z14.enum(["turn.failed", "error"]),
+  error: z14.looseObject({ message: z14.string().optional() }).optional(),
+  message: z14.string().optional()
+});
+var EMPTY_STATE = {
+  provider: void 0,
+  launch: "pending",
+  progress: void 0,
+  result: "running",
+  reason: void 0,
+  usage: void 0
+};
+var LAUNCH_HEADER_PREFIX = "=== ";
+var LAUNCH_HEADER_MARKER = " \xB7 started by process ";
+function usable_text(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+function claude_progress(content) {
+  return content.map((block) => TEXT_BLOCK_SCHEMA.safeParse(block)).filter((parsed) => parsed.success).map((parsed) => parsed.data.text).findLast((text) => text.trim() !== "");
+}
+function claude_result(value, state) {
+  const result = claude_result_event.decode(value);
+  if (result === void 0) return void 0;
+  return {
+    ...state,
+    provider: "anthropic",
+    result: result.is_error ? "failed" : "completed",
+    reason: result.is_error ? result.reason ?? state.reason : state.reason,
+    usage: result.usage
+  };
+}
+function claude_assistant(value, state) {
+  const assistant = CLAUDE_ASSISTANT_SCHEMA.safeParse(value);
+  if (!assistant.success) return void 0;
+  const progress = claude_progress(assistant.data.message.content ?? []) ?? state.progress;
+  return { ...state, provider: "anthropic", progress };
+}
+function claude_terminal(value, state) {
+  return claude_result(value, state);
+}
+function claude_event(value, state) {
+  if (CLAUDE_INIT_SCHEMA.safeParse(value).success) {
+    return { ...state, provider: "anthropic", launch: "started" };
+  }
+  return claude_assistant(value, state) ?? claude_terminal(value, state);
+}
+function codex_progress(value, state) {
+  const parsed = CODEX_PROGRESS_SCHEMA.safeParse(value);
+  if (!parsed.success) return void 0;
+  const progress = usable_text(parsed.data.item?.text) ?? state.progress;
+  return { ...state, provider: "openai", progress };
+}
+function codex_completed(value, state) {
+  const completed = CODEX_COMPLETE_SCHEMA.safeParse(value);
+  if (!completed.success) return void 0;
+  return { ...state, provider: "openai", result: "completed", usage: completed.data.usage };
+}
+function codex_failed(value, state) {
+  const failed = CODEX_FAILURE_SCHEMA.safeParse(value);
+  if (!failed.success) return void 0;
+  const reason = usable_text(failed.data.error?.message) ?? usable_text(failed.data.message);
+  return { ...state, provider: "openai", result: "failed", reason: reason ?? state.reason };
+}
+function codex_terminal(value, state) {
+  return codex_completed(value, state) ?? codex_failed(value, state);
+}
+function codex_event(value, state) {
+  if (CODEX_START_SCHEMA.safeParse(value).success) {
+    return { ...state, provider: "openai", launch: "started" };
+  }
+  return codex_progress(value, state) ?? codex_terminal(value, state);
+}
+function normalized(value, state) {
+  return claude_event(value, state) ?? codex_event(value, state) ?? state;
+}
+function next_state(line, state) {
+  const is_header = line.startsWith(LAUNCH_HEADER_PREFIX) && line.includes(LAUNCH_HEADER_MARKER);
+  if (is_header) return EMPTY_STATE;
+  return normalized(json_value.parse_or_undefined(line), state);
+}
+function read(transcript) {
+  let state = EMPTY_STATE;
+  for (const line of transcript.split("\n")) state = next_state(line, state);
+  return state;
+}
+function describe(state) {
+  const progress = state.progress === void 0 ? "" : ` progress=${state.progress}`;
+  const reason = state.reason === void 0 ? "" : ` reason=${state.reason}`;
+  return `launch=${state.launch} result=${state.result}${progress}${reason}`;
+}
+var agent_event = { describe, read };
+
+// scripts/run/run-liveness.ts
+var ALIVE_VERDICT = "alive";
+var SETTLED_VERDICT = "settled";
+var STOPPED_VERDICT = "stopped";
+var UNDETERMINED_VERDICT = "undetermined";
+var PROCESS_ALIVE = "alive";
+var PROCESS_NONE = "none";
+var PROCESS_UNKNOWN = "unknown";
+var DEFAULT_SILENT_MINUTES = 30;
+var DEFAULT_GAP_SECONDS = 5;
+var MS_PER_MINUTE = 6e4;
+var MS_PER_SECOND = 1e3;
+var OPEN_STATE = "OPEN";
+var STATE_FIELDS = "state,labels";
+var REASONS = {
+  [ALIVE_VERDICT]: "The unit is still working: its output moved, or a process of the child is alive.",
+  [SETTLED_VERDICT]: "The child is closed, parked with `needs-decision`, or marked `already-done`, so there is nothing here to recover.",
+  [STOPPED_VERDICT]: "The output has been frozen past the silent window and no process of the child is alive in that checkout.",
+  [UNDETERMINED_VERDICT]: "A trace could not be read, so this says nothing about the unit. A trace that could not be read answers `undetermined`, never `stopped`."
+};
+var ALIVE_ADVICE = "Keep waiting on `pnpm josh lane:await`; do not touch the child.";
+var SETTLED_ADVICE = "Read the child with `pnpm josh issue:state <N>` and take the branch its state says.";
+var STOPPED_CLEAN_ADVICE = 'The unit ended \u2014 classify how before booking it. Run `pnpm josh run:merge <N> --output <path>` (add `--epic <E> --repo <owner/repo> --owner "$PPID"` for a named epic): it reads the child\'s exit record without waiting for the unit to return, re-dispatches a child that could not reach the API (counting the outage; a run of them trips the environment guard and stops the run), and parks an abandoned child with `needs-decision` against the consecutive-failure guard. The checkout is clean, so there is nothing to stash.';
+var STOPPED_DIRTY_ADVICE = 'Stash the half-finished work with `git stash push -u -m "backlogrun: stopped unit for #<N>"` and record it on the Issue, then classify how the unit ended with `pnpm josh run:merge <N> --output <path>` (add `--epic <E> --repo <owner/repo> --owner "$PPID"` for a named epic): it re-dispatches an API-outage child (counting the outage; a run of them trips the environment guard) and parks an abandoned child with `needs-decision` against the consecutive-failure guard, without waiting for the unit to return.';
+var UNDETERMINED_ADVICE = "Read the trace that failed and ask again. Where the process trace was given as `unknown`, leave `--process` out so the command reads it. Two of these in a row is a fault in the check itself rather than a slow unit: stop polling and report it.";
+function is_output_moving(traces) {
+  return traces.is_output_frozen === false;
+}
+function is_agent_state_finished(state) {
+  return state?.result === "completed" || state?.result === "failed";
+}
+function is_agent_finished(traces) {
+  return is_agent_state_finished(traces.agent_state);
+}
+function definitive_verdict(traces) {
+  if (traces.is_child_settled === true) return SETTLED_VERDICT;
+  if (is_agent_finished(traces)) return STOPPED_VERDICT;
+  if (is_output_moving(traces)) return ALIVE_VERDICT;
+  return void 0;
+}
+function is_check_running(traces) {
+  return traces.process_trace === PROCESS_ALIVE;
+}
+function has_unreadable_trace(traces) {
+  return traces.is_child_settled === void 0 || traces.is_output_frozen === void 0 || traces.process_trace === PROCESS_UNKNOWN;
+}
+function to_verdict(traces) {
+  const definitive = definitive_verdict(traces);
+  if (definitive !== void 0) return definitive;
+  if (has_unreadable_trace(traces)) return UNDETERMINED_VERDICT;
+  return is_check_running(traces) ? ALIVE_VERDICT : STOPPED_VERDICT;
+}
+function to_advice(verdict, has_work_to_stash) {
+  if (verdict === ALIVE_VERDICT) return ALIVE_ADVICE;
+  if (verdict === SETTLED_VERDICT) return SETTLED_ADVICE;
+  if (verdict === UNDETERMINED_VERDICT) return UNDETERMINED_ADVICE;
+  return has_work_to_stash ? STOPPED_DIRTY_ADVICE : STOPPED_CLEAN_ADVICE;
+}
+function decide3(traces) {
+  const verdict = to_verdict(traces);
+  const has_work_to_stash = verdict === STOPPED_VERDICT && traces.is_tree_dirty;
+  return {
+    advice: to_advice(verdict, has_work_to_stash),
+    has_work_to_stash,
+    reason: traces.agent_state?.reason ?? REASONS[verdict],
+    verdict
+  };
+}
+function to_resolved_root(root) {
+  try {
+    return realpathSync(root);
+  } catch {
+    return root;
+  }
+}
+var ALLOWED_ROOTS = [
+  ...new Set(
+    [homedir(), tmpdir(), PLATFORM_TEMP_ROOT].flatMap((root) => [root, to_resolved_root(root)])
+  )
+];
+function is_within(candidate, root) {
+  const relative = path3.relative(root, candidate);
+  return relative !== "" && !relative.startsWith("..") && !path3.isAbsolute(relative);
+}
+function to_safe_path(output_path) {
+  const normalized2 = path3.normalize(output_path);
+  if (!path3.isAbsolute(normalized2)) return void 0;
+  return ALLOWED_ROOTS.some((root) => is_within(normalized2, root)) ? normalized2 : void 0;
+}
+function sample_output(output_path) {
+  const safe_path = to_safe_path(output_path);
+  if (safe_path === void 0) return void 0;
+  const stats = statSync(safe_path, { throwIfNoEntry: false });
+  if (!stats?.isFile()) return void 0;
+  return { mtime_ms: stats.mtimeMs, size: stats.size };
+}
+function read_agent_state(output_path) {
+  const safe_path = to_safe_path(output_path);
+  if (safe_path === void 0) return void 0;
+  try {
+    const state = agent_event.read(readFileSync4(safe_path, "utf8"));
+    return state.provider === void 0 ? void 0 : state;
+  } catch {
+    return void 0;
+  }
+}
+function describe_agent_state(output_path) {
+  const state = read_agent_state(output_path);
+  return state === void 0 ? void 0 : `agent: ${state.provider ?? "unknown"} ${agent_event.describe(state)}`;
+}
+async function read_output_frozen(request) {
+  const first = sample_output(request.output_path);
+  if (first === void 0) return void 0;
+  if (request.now_ms - first.mtime_ms < request.silent_window_ms) return false;
+  await sleep3(request.gap_ms);
+  const second = sample_output(request.output_path);
+  if (second === void 0) return void 0;
+  return second.mtime_ms === first.mtime_ms && second.size === first.size;
+}
+function carries_label(labels, wanted) {
+  return labels.some((label) => label.toLowerCase() === wanted);
+}
+var SETTLED_LABELS = [NEEDS_DECISION_LABEL, ALREADY_DONE_LABEL];
+function carries_settled_label(labels) {
+  return SETTLED_LABELS.some((label) => carries_label(labels, label));
+}
+async function read_child_settled(issue, repo) {
+  const json = await git_gh_issue_read.issue_view_json(issue, STATE_FIELDS, repo);
+  if (json === void 0) return void 0;
+  const state = issue_state.parse_issue_state(json);
+  if (state === void 0) return void 0;
+  return state.state !== OPEN_STATE || carries_settled_label(state.labels);
+}
+async function read_traces(request) {
+  const [is_initial_child_settled, is_output_frozen, is_tree_dirty] = await Promise.all([
+    read_child_settled(request.issue, request.repo),
+    read_output_frozen({
+      gap_ms: request.gap_ms ?? DEFAULT_GAP_SECONDS * MS_PER_SECOND,
+      now_ms: Date.now(),
+      output_path: request.output_path,
+      silent_window_ms: request.silent_window_ms ?? DEFAULT_SILENT_MINUTES * MS_PER_MINUTE
+    }),
+    run_hold.is_tree_dirty()
+  ]);
+  const agent_state = read_agent_state(request.output_path);
+  const is_latest_child_settled = is_agent_state_finished(agent_state) ? await read_child_settled(request.issue, request.repo) : void 0;
+  const is_child_settled = is_latest_child_settled ?? is_initial_child_settled;
+  return {
+    agent_state,
+    is_child_settled,
+    is_output_frozen,
+    is_tree_dirty,
+    process_trace: request.process_trace
+  };
+}
+async function check(request) {
+  issue_number_shape.require_issue_number(request.issue);
+  return decide3(await read_traces(request));
+}
+var run_liveness = {
+  check,
+  decide: decide3,
+  describe_agent_state,
+  read_child_settled,
+  read_output_frozen,
+  sample_output,
+  to_safe_path
+};
+
 export {
   bounded_pool,
-  git_gh_api_path,
-  read_json_listing,
-  parse_json_object_or_undefined,
-  has_stdout_field,
-  git_gh_exec,
   git_gh_issue_read,
   issue_watch_diff,
-  issue_citation,
-  session_cite,
   shell_segments,
   bash_triggers,
   tail_commands,
   filing_cap,
   CONTEXT_CUT_THRESHOLD,
-  run_hold,
+  cost_verdict,
+  cost_cli,
   run_cut_handoff,
   run_cut,
   run_tail_rule,
   lane_background,
+  interactive_ask,
   IN_PROGRESS_LABEL,
   NEEDS_DECISION_LABEL,
   RUN_SOLO_LABEL,
   RUN_LANE_LABEL,
-  NEEDS_HUMAN_REVIEW_LABEL,
   ALREADY_DONE_LABEL,
   has_any_label,
+  label_name_of,
   has_label_name,
   lane_handoff,
   lane_park,
+  pre_gate_cut,
   gh_spawn,
   repo_party,
-  git_gh_pr_read,
-  git_gh_command
+  git_gh_repo,
+  git_gh_command,
+  issue_state,
+  PROCESS_ALIVE,
+  PROCESS_NONE,
+  PROCESS_UNKNOWN,
+  run_liveness
 };