@joshuafolkken/kit 1.1455.0 → 1.1514.0

package/dist/hooks/{chunk-7WQBPLUN.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-Z4XI7CZS.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-LIAFCXL7.js";
+} from "./chunk-TNUMY6NL.js";
 import {
   lane_child_marker
-} from "./chunk-OLMO72ON.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-3C4XRYG6.js";
+} from "./chunk-APUO6U4J.js";
 import {
-  COMMAND_TIMEOUT_MS,
+  PLATFORM_TEMP_ROOT,
   PROJECT_ROOT,
   stamp_file
 } from "./chunk-DGT54IH5.js";
@@ -84,18 +108,51 @@ 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");
 function segments_of(command) {
   return command.split(SEGMENT_SEPARATOR).map((segment) => segment.trim());
 }
+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
 };
 
@@ -119,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;
@@ -171,10 +214,10 @@ 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 \u2014 on reaching it, stop and report rather than filing more. Automatic filing is capped so a run cannot manufacture Issues faster than they can be closed (\`.claude/skills/workflow-commands/SKILL.md\` \u2192 \`prerequisite.md\`, \`observation-filing.md\`). A further Issue that genuinely must exist is a person's call, not this run's. **This rule fires on every filing past the cap, not once per run**, so reissuing the same filing will be refused again.`;
+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 = {
   id: "filing-cap",
   is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
@@ -185,337 +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_owner_gone(hold) {
-  const is_stop_mark = hold.is_halfrun_stop === true || hold.prrun_stop_head !== void 0;
-  if (is_stop_mark || 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 = {
-  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;
@@ -660,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";
@@ -677,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(", ")}}`;
@@ -747,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);
@@ -775,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);
@@ -825,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);
@@ -859,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;
@@ -871,8 +589,14 @@ 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());
-  return { branch, is_dirty, is_held: hold !== void 0, held_issue: fullrun_issue(hold) };
+  const hold = hold_of(await worktree_directory());
+  return {
+    branch,
+    is_dirty,
+    is_held: hold !== void 0,
+    held_issue: fullrun_issue(hold),
+    hold_taken_at: hold?.taken_at
+  };
 }
 function describe_cut(cut) {
   return `${cut.invocation} cut at ${cut.cut_at} on ${cut.branch} (${cut.phase})`;
@@ -883,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 = {
@@ -907,7 +631,7 @@ var run_cut = {
   begin_cut,
   busy_message,
   carried_cut_sync,
-  classify: classify3,
+  classify,
   classify_resume,
   current_state,
   cut_path,
@@ -918,20 +642,21 @@ var run_cut = {
   handed_off_message,
   has_required_handoff,
   held_issue_sync,
+  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
 };
 
@@ -974,7 +699,7 @@ function is_foreground_push_step(call) {
 function decide2() {
   return true;
 }
-var RUN_TAIL_REASON = '\u26D4 run tail: this issues the commit-push-PR step in the foreground, where the harness decides when to stop waiting. Reissue it with `run_in_background` set. In `fullrun #1501` this call was given a 900-second timeout, the harness detached it at its own 600-second cap, and nothing read the output for a further 6m28s \u2014 45m03s of wall clock on about 17 minutes of work (joshuafolkken/kit#1510). **Never give a foreground call a timeout above the harness cap**: the cap decides, not the number. A backgrounded call re-invokes you when it exits, so the completion notification is what resumes the run. **When it arrives, the turn that reads it goes straight through any branch-2 filing and `pnpm josh epic:bundle` to `pnpm josh followup` \u2014 the turn never ends at the push.** CI went green 6m06s before the merge started in that run, and it started only because the person asked; joshuafolkken/kit#1333 had already settled that the merge is issued in the turn the review closes. While the push runs, do the work that writes nothing \u2014 drafting the completion body to a file, deciding the branch-2 disposition. `pnpm josh followup` itself stays in the **foreground** \u2014 nearly every step after it reads its result. But a tail does follow the merge, measured at 3.0 min and 5.9% of a run (joshuafolkken/kit#1462), so empty it beforehand: the steps that read the merge result stay after `followup`, and the rest are composed in the turn that issues it, bar the one exception background-commands.md names. The procedure is `.claude/skills/workflow-commands/background-commands.md`, "A command that can take minutes is issued in the background". **This rule fires on every foreground push, not once per run**, so reissuing the same call in the foreground will be refused again.';
+var RUN_TAIL_REASON = "\u26D4 run tail: this issues the commit-push-PR step in the foreground, where the harness decides when to stop waiting. Reissue it with `run_in_background` set; when it exits, go straight on to `pnpm josh followup` in the foreground \u2014 the turn never ends at the push (`.claude/skills/workflow-commands/background-commands.md`). It fires on every foreground push, not once per run.";
 var run_tail_rule = {
   RUN_TAIL_REASON,
   decide: decide2,
@@ -1021,11 +746,12 @@ function is_background_long_run(call, is_lane_child = () => lane_child_marker.is
   return is_candidate(call) && is_lane_child();
 }
 function foreground_input(call, is_lane_child = () => lane_child_marker.is_child_of(process.cwd())) {
-  if (!is_backgrounded_ship(call) || !json_value.is_record(call.input)) return void 0;
-  if (!is_lane_child()) return void 0;
+  if (!is_backgrounded_ship(call) || !json_value.is_record(call.input) || !is_lane_child()) {
+    return void 0;
+  }
   return { ...call.input, [BACKGROUND_KEY2]: false, [TIMEOUT_KEY]: FOREGROUND_TIMEOUT_MS };
 }
-var FOREGROUND_NOTE = "lane background: this lane child backgrounded `josh ship`, which would die with the headless turn before its supervisor exists \u2014 so it was run in the foreground instead, where it detaches itself after the preflight. End the turn on `launched` / `busy` (joshuafolkken/kit#3154).";
+var FOREGROUND_NOTE = "lane background: this lane child backgrounded `josh ship`, which would die with the headless turn before its supervisor exists \u2014 so it was run in the foreground instead, where it detaches itself after the preflight. End the turn on `launched` / `busy`.";
 function unfinished_ids(tail, launched_ids) {
   const lines = tail.split("\n").map((line) => time_transcript_line.parse_line(line));
   const finished = new Set(lines.map((line) => line?.finished_background ?? ""));
@@ -1039,8 +765,8 @@ function pending_background_ids(tail) {
 function pending_agent_ids(tail) {
   return unfinished_ids(tail, (block) => [block.agent_id]);
 }
-var LANE_BACKGROUND_REASON = '\u26D4 lane background: this session is a dispatched lane child (`JOSH_LANE_CHILD`), a headless `claude -p` process whose background Bash tasks are killed when the turn ends \u2014 so a backgrounded `josh gate` / `josh git` / `josh followup` / `josh ship` never re-invokes you; it dies at `exit code 143` (joshuafolkken/kit#2704, measured on the #2606 child: implementation, review and live verification done, the run parked instead of merged). Hand the gate-to-merge region to the detached supervisor instead: `pnpm josh ship --detach --review "<title> #<N>"` (add `--cite <N>`) issued in the foreground \u2014 its preflight runs in this process before the supervisor exists, so a backgrounded `ship` dies with the turn (joshuafolkken/kit#3027; a backgrounded `ship` issued alone is moved to the foreground for you, joshuafolkken/kit#3154) \u2014 then end the turn on `launched` / `busy`. `.claude/skills/workflow-commands/chain-rule.md` step 0 is the single source. A single check you must read before continuing runs in the foreground within the tool timeout; the commit-push step does not \u2014 in a child it too belongs to the detached ship, in either spelling. This rule fires on every occurrence, not once per run.';
-var LANE_BACKGROUND_STOP_REASON = "\u26D4 lane background stop: this is a dispatched lane child (`JOSH_LANE_CHILD`) and a background task it launched has not finished \u2014 ending this headless turn kills it, and nothing re-invokes you afterwards (joshuafolkken/kit#2704). Do not send a notification and do not stop: wait for the task in the foreground and act on its result, or re-issue the work through `pnpm josh ship --detach`, whose supervisor outlives the turn (`.claude/skills/workflow-commands/chain-rule.md` step 0). Do not repeat your previous reply.";
+var LANE_BACKGROUND_REASON = '\u26D4 lane background: this session is a dispatched lane child (`JOSH_LANE_CHILD`), a headless process whose background tasks die when the turn ends. Hand over to `pnpm josh ship --detach --review "<title> #<N>"`, issued in the foreground, then end the turn on `launched` / `busy`. It fires on every occurrence (`.claude/skills/workflow-commands/chain-rule.md` step 0).';
+var LANE_BACKGROUND_STOP_REASON = "\u26D4 lane background stop: this is a dispatched lane child (`JOSH_LANE_CHILD`) and a background task it launched has not finished, and ending this turn kills it. Wait for it in the foreground, or re-issue the work through `pnpm josh ship --detach` \u2014 do not notify, stop or repeat your reply.";
 var ROW2 = {
   id: "lane-background",
   is_trigger: (call) => is_background_long_run(call),
@@ -1061,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-";
@@ -1082,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";
@@ -1152,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;
 }
@@ -1259,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;
@@ -1285,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, issue)?.result === "running";
+}
+function ship_running_since(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 ? 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";
@@ -1466,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);
@@ -1484,7 +1219,7 @@ var APPLIES_NEEDS_DECISION = new RegExp(
 function records_the_park(command) {
   return APPLIES_NEEDS_DECISION.test(command);
 }
-var LANE_PARK_REASON = '\u26D4 lane child park: this session is a dispatched lane child, and a stop that waits on a person must leave the question on the Issue before it sends this Telegram \u2014 otherwise the parent finds an OPEN Issue with `in-progress` and no question, and a person cannot tell what to answer (joshuafolkken/kit#2034 measured this twice in one run). The child is the only process that knows the question, the options and whether it stashed, so it records the park itself rather than leaving the parent to guess from a log. Before you notify and stop: apply `needs-decision` and post a comment carrying the question, the options, and whether work was stashed \u2014 `gh api repos/{owner}/{repo}/issues/<N>/labels -f \'labels[]=needs-decision\'` then `pnpm josh issue:comment <N> --body-file <path>`. If this stop is a `needs-human-review` or `already-done` one, that label is already on the Issue and there is nothing to add. Then reissue this notify \u2014 it fires once per run and cannot repeat on the call in hand. The procedure is `.claude/skills/workflow-commands/pre-gate-cut.md` \u2192 "A lane child records its park before it stops", and the park itself is `backlogrun-park.md` \u2192 "park and continue".';
+var LANE_PARK_REASON = "\u26D4 lane child park: this session is a dispatched lane child, so a stop for a person parks first: `gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=needs-decision'`; `pnpm josh issue:comment <N> --body-file <path>` (question, options, stash); a `needs-human-review` / `already-done` stop already is. Reissue this notify, once per run (`.claude/skills/workflow-commands/pre-gate-cut.md`).";
 var ROW3 = {
   id: "lane-park",
   is_trigger: bash_triggers.on_bash_command(is_unparked_stop),
@@ -1502,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;
@@ -1882,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";
@@ -2030,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);
@@ -2059,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) {
@@ -2083,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;
   }
@@ -2160,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
@@ -2213,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]";
@@ -2228,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);
@@ -2304,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";
@@ -2336,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;
 }
@@ -2458,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,
@@ -2527,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()));
@@ -2563,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(", ")}`);
@@ -2586,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);
@@ -2596,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);
@@ -2620,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) {
@@ -2638,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) {
@@ -2920,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";
@@ -2945,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;
@@ -2963,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);
@@ -2997,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
   });
 }
@@ -3023,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 {
@@ -3065,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}`,
@@ -3147,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 });
@@ -3219,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;
@@ -3309,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 };
@@ -3359,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;
@@ -3441,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
 };