@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/hooks/stop-guard.js

@@ -1,12 +1,10 @@
 #!/usr/bin/env tsx
 import {
-  KIT_PACKAGE_NAME,
   MAX_SCANNED,
   OperationCancelledError,
   SUMMARY_FIELDS,
   backlog_overlap,
   epic_busy,
-  gh_spawn,
   git_branch,
   git_error,
   git_gh_blocked_by_graphql,
@@ -15,19 +13,16 @@ import {
   git_gh_pr_too_large,
   git_gh_repo,
   git_stash,
-  hook_launch,
   hook_ledger,
   issue_read,
   lane_background,
   lane_park,
   lane_plan,
   last_prompt,
-  load,
   markdown_section,
   observation_ledger,
   observation_ledger_home,
   pre_gate_cut,
-  project_checks,
   read_pull,
   review_attest,
   review_checkout,
@@ -37,23 +32,32 @@ import {
   stop_rules,
   tail_commands,
   turn_filings
-} from "./chunk-OV22V63P.js";
+} from "./chunk-DCILEVDR.js";
 import {
+  input_fingerprint,
+  lint_related_scope,
   machine_capacity,
   resolve_tsx_runner,
   run_board_usage_rusage,
   toolchain_inputs
-} from "./chunk-IURJANNZ.js";
+} from "./chunk-WCJ2GWYJ.js";
 import {
+  KIT_PACKAGE_NAME,
   find_local_bin_upwards,
   gate_labels,
+  gh_spawn,
+  hook_launch,
   issue_body_keys,
+  load,
+  project_checks,
   test_declared_logic
-} from "./chunk-AO4TOV4V.js";
+} from "./chunk-L6IZZ2IL.js";
 import {
   AUTO_OK_LABEL,
+  BREAKING_CHANGE_LABEL,
   BUGFIX_LABEL,
   BUG_LABEL,
+  DEFERRED_LABEL,
   ENHANCEMENT_LABEL,
   EPIC_LABEL,
   GRAPHQL_PATH,
@@ -62,6 +66,7 @@ import {
   ISSUE_FIELDS,
   JOSH_TMP_DIRECTORY,
   NEEDS_HUMAN_MERGE_LABEL,
+  NEEDS_HUMAN_REVIEW_LABEL,
   NOT_BEFORE_LABEL,
   NOT_DIRECTLY_RUNNABLE_LABELS,
   PARKED_LABELS,
@@ -71,6 +76,7 @@ import {
   PROCESS_ALIVE,
   PROCESS_NONE,
   PROCESS_UNKNOWN,
+  RELEASE_LABEL,
   REPOSITORY_LABELS,
   RUN_LANE_LABEL,
   RUN_SOLO_LABEL,
@@ -78,12 +84,9 @@ import {
   STATE_AND_RELATIONS_FIELDS,
   agent_headless,
   backlog_budget,
-  bounded_pool,
   detached_launch,
   gh_author_association,
-  git_gh_api_path,
   git_gh_etag_read,
-  git_gh_exec,
   git_gh_issue_graphql,
   git_gh_issue_read,
   git_gh_issue_rest,
@@ -95,60 +98,62 @@ import {
   issue_fields_schema,
   issue_state,
   label_name_of,
-  lane_child_marker,
   lane_handoff,
   lane_process_table,
   lane_registry,
   lane_snapshot_trace,
-  parse_json,
-  parse_json_array_or_undefined,
-  parse_json_array_safe,
-  parse_json_object_or_undefined,
-  read_json_listing,
   repo_party,
   run_cut,
   run_cut_handoff,
   run_headless,
   run_hold,
   run_liveness,
-  shared_cache,
-  token_shape
-} from "./chunk-5CUXGQT6.js";
+  shared_cache
+} from "./chunk-HVNGIM5W.js";
 import {
-  ESLINT_RELATED_CACHE_FILE,
-  ESLINT_RELATED_CACHE_FLAGS,
   PACKAGE_JSON,
-  PRETTIER_RELATED_CACHE_FLAGS,
   agent_profile_schema,
   author_fields_schema,
   blocked_by_schema,
+  bounded_pool,
   change_base,
   changed_paths,
   epic_issue_schema,
+  git_gh_api_path,
+  git_gh_exec,
   hook_decision,
   issue_citation,
   issue_cite,
   issue_label_schema,
   josh_environment_file,
   lane_child_invocation,
+  lane_reap,
   lane_spans,
   lane_state,
   open_issue_schema,
+  parse_json,
+  parse_json_array_or_undefined,
+  parse_json_array_safe,
+  parse_json_object_or_undefined,
   poll,
   process_owner_schema,
   process_tools,
+  read_json_listing,
   repository_lock,
   review_stop_log,
   run_event_scope,
   run_event_stream,
   run_event_stream_emit,
   run_ship_stage,
+  run_startup,
+  run_startup_schema,
   session_cite,
   session_language,
   shell_quote,
   time_hook_transcript,
+  token_shape,
   transcript_tail
-} from "./chunk-G5WSPYJ6.js";
+} from "./chunk-UZXMFOVK.js";
 import {
   timed_fetch
 } from "./chunk-U3ON2GBN.js";
@@ -161,20 +166,21 @@ import {
 } from "./chunk-LRD2ERRI.js";
 import {
   run_ship_lap
-} from "./chunk-6YGMIODI.js";
+} from "./chunk-5NIBRHWG.js";
 import {
   agent_provider,
   agent_session_environment,
   cli_flags,
   durable_state,
   issue_number_shape,
+  lane_child_marker,
   lane_ledger_kind,
   lane_ledger_write,
   lane_paths,
   process_identity,
   run_carry,
   run_invocation
-} from "./chunk-FOW4B7OQ.js";
+} from "./chunk-YRKS5ZKE.js";
 import {
   GH_API_TIMEOUT_MS,
   LINT_TIMEOUT_MS,
@@ -206,8 +212,8 @@ async function carry_target() {
   return repository === void 0 ? void 0 : run_carry.carry_path(repository);
 }
 function live_carry(target3) {
-  const read10 = run_carry.read_carry(target3);
-  return read10.kind === "carried" ? read10.carry : void 0;
+  const read11 = run_carry.read_carry(target3);
+  return read11.kind === "carried" ? read11.carry : void 0;
 }
 async function current_carry() {
   const target3 = await carry_target();
@@ -318,16 +324,16 @@ var lane_capacity = {
 function is_never_merge_waiting() {
   return false;
 }
-function occupied_lanes(lanes, idle2, records, is_merge_waiting = is_never_merge_waiting) {
+function occupied_lanes(lanes, idle2, records2, is_merge_waiting = is_never_merge_waiting) {
   const live = lanes.filter((lane) => !lane.is_stranded);
   const idle_issues = new Set(idle2(live));
   return live.filter((lane) => {
-    const state = records.get(lane.issue)?.state;
+    const state = records2.get(lane.issue)?.state;
     return !idle_issues.has(lane.issue) && state !== "paused" && !is_merge_waiting(lane.issue);
   });
 }
-function unknown_lanes(lanes, records) {
-  return lanes.filter((lane) => !lane.is_stranded && !records.has(lane.issue)).map((lane) => lane.issue);
+function unknown_lanes(lanes, records2) {
+  return lanes.filter((lane) => !lane.is_stranded && !records2.has(lane.issue)).map((lane) => lane.issue);
 }
 var backlog_occupied = { occupied_lanes, unknown_lanes };
 
@@ -540,6 +546,12 @@ function process_trace_default(issue) {
 function is_process_running_default(issue) {
   return process_trace_default(issue) === PROCESS_ALIVE;
 }
+async function other_process_trace(issue) {
+  if (lane_handoff.is_ship_running(issue, process.cwd())) return PROCESS_ALIVE;
+  const rows = await lane_process_table.read_table();
+  if (!rows?.some((row2) => row2.pid === process.pid)) return PROCESS_UNKNOWN;
+  return lane_reap.is_child_running(issue, lane_process_table.probes_of(rows)) ? PROCESS_ALIVE : PROCESS_NONE;
+}
 function is_shipped_default(issue, since_ms) {
   return lane_handoff.is_ship_succeeded(issue, process.cwd(), since_ms);
 }
@@ -658,6 +670,7 @@ var lane_await = {
   is_process_running_default,
   is_shipped_default,
   parse_arguments,
+  other_process_trace,
   process_trace_default,
   wait_for_any
 };
@@ -707,9 +720,9 @@ async function tree_reason(lane, probes) {
   return await probes.is_tree_dirty(lane.directory) ? "it has uncommitted changes" : void 0;
 }
 async function commit_reason(lane, probes) {
-  const count = await probes.unpushed_commits(lane.branch);
-  if (count === 0) return void 0;
-  return count === void 0 ? "its commits could not be counted" : `it has ${String(count)} commit(s) that are on no remote`;
+  const count2 = await probes.unpushed_commits(lane.branch);
+  if (count2 === 0) return void 0;
+  return count2 === void 0 ? "its commits could not be counted" : `it has ${String(count2)} commit(s) that are on no remote`;
 }
 var CHECKS = [
   child_reason,
@@ -756,15 +769,15 @@ async function occupancy_of(open, table5) {
   const rows = await table5();
   const issues = open.map((lane) => lane.issue);
   const trace = { process_trace: await lane_snapshot_trace.traces_of(issues, rows) };
-  const records = await lane_state.read_states(issues);
+  const records2 = await lane_state.read_states(issues);
   const is_merge_waiting = await lane_snapshot_trace.merge_waits_of(issues, rows);
   const occupied = backlog_occupied.occupied_lanes(
     open,
     (live) => lane_spent.idle_lanes(live, trace),
-    records,
+    records2,
     is_merge_waiting
   );
-  const unknown = backlog_occupied.unknown_lanes(open, records);
+  const unknown = backlog_occupied.unknown_lanes(open, records2);
   return { occupied, idle: lane_spent.idle_lanes(open, trace), unknown };
 }
 async function read(lanes, table5 = lane_process_table.read_table) {
@@ -783,9 +796,10 @@ var SUCCESS_EXIT_CODE = 0;
 var NONZERO_EXIT = 1;
 var FORWARDED_STDERR = ["pipe", "inherit"];
 function extra_options(timeout_ms, environment) {
+  const child_environment = { ...run_startup.environment(), ...environment };
   return {
     ...timeout_ms !== void 0 && { timeout: timeout_ms },
-    ...environment !== void 0 && { env: environment }
+    ...Object.keys(child_environment).length > 0 && { env: child_environment }
   };
 }
 async function run_with_options(args, should_forward_stderr, options) {
@@ -804,7 +818,7 @@ async function josh_run(args, should_forward_stderr = false, timeout_ms, environ
   return await run_with_options(args, should_forward_stderr, extra_options(timeout_ms, environment));
 }
 async function josh_run_at(args, cwd) {
-  return await run_with_options(args, false, { cwd });
+  return await run_with_options(args, false, { ...extra_options(void 0, void 0), cwd });
 }
 function require_success(result, command) {
   if (result.code === SUCCESS_EXIT_CODE) return;
@@ -1626,11 +1640,11 @@ function blockers_by_key(rows) {
 }
 function upstream_of(key2, blockers) {
   const seen = /* @__PURE__ */ new Set([key2]);
-  const pending = [...blockers.get(key2) ?? []];
-  for (let next = pending.pop(); next !== void 0; next = pending.pop()) {
+  const pending2 = [...blockers.get(key2) ?? []];
+  for (let next = pending2.pop(); next !== void 0; next = pending2.pop()) {
     if (seen.has(next)) continue;
     seen.add(next);
-    pending.push(...blockers.get(next) ?? []);
+    pending2.push(...blockers.get(next) ?? []);
   }
   seen.delete(key2);
   return seen;
@@ -1707,7 +1721,9 @@ var early_push_schema = external_exports.object({
   at: external_exports.string(),
   issue: external_exports.number().optional(),
   source: external_exports.enum(["review", "ship"]),
-  result: external_exports.string()
+  result: external_exports.string(),
+  head: external_exports.string().optional(),
+  slots: external_exports.number().optional()
 });
 var stop_schema = external_exports.object({
   kind: external_exports.literal(KIND3.STOP),
@@ -1869,11 +1885,23 @@ var offerable_schema = external_exports.object({
   is_offerable: external_exports.boolean()
 });
 var core_wait_schema = external_exports.object({
-  kind: external_exports.literal(KIND4.CORE_WAIT),
+  kind: external_exports.enum([KIND4.CORE_WAIT, KIND4.CORE_ADMISSION]),
   at: external_exports.string(),
   command: external_exports.string(),
   waited_ms: external_exports.number(),
-  issue: external_exports.number().optional()
+  issue: external_exports.number().optional(),
+  admission_reason: external_exports.string().optional(),
+  overflow: external_exports.boolean().optional(),
+  budget_cores: external_exports.number().optional(),
+  budget_memory_mb: external_exports.number().optional(),
+  available_mb: external_exports.number().optional(),
+  busy_cores: external_exports.number().optional(),
+  requested_cores: external_exports.number().optional(),
+  granted_cores: external_exports.number().optional(),
+  memory_mb: external_exports.number().optional(),
+  wait_reason: external_exports.string().optional(),
+  admission_waited_ms: external_exports.number().optional(),
+  memory_pressured: external_exports.boolean().optional()
 });
 var unit_file_schema = external_exports.object({ file: external_exports.string(), elapsed_ms: external_exports.number() });
 var unit_files_schema = external_exports.object({
@@ -1952,6 +1980,7 @@ var push_miss_schema = external_exports.object({
 var limit_schema = external_exports.object({ kind: external_exports.literal(KIND4.LIMIT), at: external_exports.string(), limit: external_exports.number() });
 var entry_schema = external_exports.discriminatedUnion("kind", [
   early_push_schema2,
+  run_startup_schema.entry_schema,
   merge_schema,
   gate_schema,
   load_schema2,
@@ -2022,10 +2051,10 @@ function next_tail(descriptor, snapshot2, previous) {
   const length = readSync(descriptor, bytes, 0, bytes.length, from);
   return grow(base, snapshot2, from, bytes.subarray(0, length));
 }
-function read_tail(path15, previous) {
+function read_tail(path12, previous) {
   try {
-    if (!stamp_file.is_own_regular_file(path15)) return void 0;
-    const descriptor = openSync(path15, READ_FLAGS);
+    if (!stamp_file.is_own_regular_file(path12)) return void 0;
+    const descriptor = openSync(path12, READ_FLAGS);
     try {
       return next_tail(descriptor, snapshot_of(fstatSync(descriptor)), previous);
     } finally {
@@ -2036,20 +2065,20 @@ function read_tail(path15, previous) {
   }
 }
 var tails = /* @__PURE__ */ new Map();
-function read2(path15) {
-  const tail = read_tail(path15, tails.get(path15));
+function read2(path12) {
+  const tail = read_tail(path12, tails.get(path12));
   if (tail === void 0) {
-    tails.delete(path15);
+    tails.delete(path12);
     return EMPTY;
   }
-  tails.set(path15, tail);
+  tails.set(path12, tail);
   return tail.entries;
 }
 var lane_ledger_tail = { read: read2 };
 
 // scripts/lane/lane-ledger.ts
-function read_entries(path15) {
-  return lane_ledger_tail.read(path15);
+function read_entries(path12) {
+  return lane_ledger_tail.read(path12);
 }
 var {
   CI_WAIT_STAGE,
@@ -2308,9 +2337,9 @@ async function take(context = {}) {
   return entry;
 }
 async function newest_load(ledger_path) {
-  const path15 = ledger_path ?? await lane_ledger.target();
-  if (path15 === void 0) return void 0;
-  return lane_ledger.read_entries(path15).findLast((entry) => entry.kind === lane_ledger.KIND.LOAD);
+  const path12 = ledger_path ?? await lane_ledger.target();
+  if (path12 === void 0) return void 0;
+  return lane_ledger.read_entries(path12).findLast((entry) => entry.kind === lane_ledger.KIND.LOAD);
 }
 function counter_growth(previous, current2) {
   if (previous.booted_ms !== current2.booted_ms) return 0;
@@ -2454,15 +2483,15 @@ function peak(values) {
 function lowest(values) {
   return values.length === 0 ? void 0 : Math.min(...values);
 }
-function is_working(sample2) {
-  return (sample2.lanes ?? 0) > 0;
+function is_working(sample3) {
+  return (sample3.lanes ?? 0) > 0;
 }
-function sample_pairs(samples) {
-  const sorted = samples.toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at));
+function sample_pairs(samples2) {
+  const sorted = samples2.toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at));
   return sorted.slice(1).map((next, index) => ({ sample: sorted[index] ?? next, next }));
 }
-function elapsed_ms({ sample: sample2, next }) {
-  return Date.parse(next.at) - Date.parse(sample2.at);
+function elapsed_ms({ sample: sample3, next }) {
+  return Date.parse(next.at) - Date.parse(sample3.at);
 }
 function sum_hours(gaps) {
   const active = gaps.filter((gap) => gap <= ACTIVE_GAP_MS).reduce((sum, gap) => sum + gap, 0);
@@ -2474,8 +2503,8 @@ function gap_hours(entries) {
     instants.slice(1).map((instant, index) => instant - (instants[index] ?? instant))
   );
 }
-function sampled_hours(samples) {
-  const gaps = sample_pairs(samples).filter(({ sample: sample2 }) => is_working(sample2)).map((pair) => elapsed_ms(pair));
+function sampled_hours(samples2) {
+  const gaps = sample_pairs(samples2).filter(({ sample: sample3 }) => is_working(sample3)).map((pair) => elapsed_ms(pair));
   return sum_hours(gaps);
 }
 function swap_rate(pair) {
@@ -2486,8 +2515,8 @@ function swap_rate(pair) {
   return swapped / MB_PER_GB / (elapsed / MS_PER_HOUR);
 }
 function active_hours(entries) {
-  const samples = entries.filter(is_load);
-  return samples.some((sample2) => is_working(sample2)) ? sampled_hours(samples) : gap_hours(entries);
+  const samples2 = entries.filter(is_load);
+  return samples2.some((sample3) => is_working(sample3)) ? sampled_hours(samples2) : gap_hours(entries);
 }
 function gigabytes(megabytes) {
   return megabytes === void 0 ? void 0 : megabytes / MB_PER_GB;
@@ -2527,23 +2556,23 @@ function gate_cells(entries) {
   const minutes = entries.filter(is_gate).filter((entry) => entry.is_reused !== true).map((entry) => entry.elapsed_ms / MS_PER_MINUTE);
   return [cell(median(minutes)), cell(peak(minutes))];
 }
-function swap_cells(samples) {
-  const pairs = sample_pairs(samples);
+function swap_cells(samples2) {
+  const pairs = sample_pairs(samples2);
   const rates = pairs.map((pair) => swap_rate(pair)).filter(is_number);
-  const working_rates = pairs.filter(({ sample: sample2 }) => is_working(sample2)).map((pair) => swap_rate(pair)).filter(is_number);
+  const working_rates = pairs.filter(({ sample: sample3 }) => is_working(sample3)).map((pair) => swap_rate(pair)).filter(is_number);
   return [cell(peak(rates)), cell(mean(working_rates))];
 }
-function load_cells(samples) {
-  const working = samples.filter(is_working);
-  const free = samples.map((sample2) => sample2.available_mb).filter(is_number);
-  const working_free = working.map((sample2) => sample2.available_mb).filter(is_number);
+function load_cells(samples2) {
+  const working = samples2.filter(is_working);
+  const free = samples2.map((sample3) => sample3.available_mb).filter(is_number);
+  const working_free = working.map((sample3) => sample3.available_mb).filter(is_number);
   return [
-    cell(peak(samples.map((sample2) => sample2.load))),
-    cell(mean(working.map((sample2) => sample2.load))),
-    ...swap_cells(samples),
+    cell(peak(samples2.map((sample3) => sample3.load))),
+    cell(mean(working.map((sample3) => sample3.load))),
+    ...swap_cells(samples2),
     cell(gigabytes(lowest(free))),
     cell(gigabytes(mean(working_free))),
-    String(samples.length)
+    String(samples2.length)
   ];
 }
 function to_row(cells) {
@@ -3025,13 +3054,13 @@ function partners_of(files, added) {
 }
 function units_of(files, added) {
   const artifacts = codex_hooks.GENERATED_SOURCES;
-  const sources = files.filter((file) => !files.includes(artifacts.get(file) ?? ""));
-  const partners = partners_of(sources, added);
-  return sources.flatMap((file) => {
+  const sources2 = files.filter((file) => !files.includes(artifacts.get(file) ?? ""));
+  const partners = partners_of(sources2, added);
+  return sources2.flatMap((file) => {
     const partner = partners.get(file);
     const unit = partner === void 0 ? [file] : [file, partner];
-    const generated = files.filter((path15) => unit.includes(artifacts.get(path15) ?? ""));
-    return partner !== void 0 && sources.indexOf(partner) < sources.indexOf(file) ? [] : [[...unit, ...generated]];
+    const generated = files.filter((path12) => unit.includes(artifacts.get(path12) ?? ""));
+    return partner !== void 0 && sources2.indexOf(partner) < sources2.indexOf(file) ? [] : [[...unit, ...generated]];
   });
 }
 function verdict_for(files, lines2, guide = DEFAULT_GUIDE) {
@@ -3150,8 +3179,8 @@ function is_estimate_line(text2) {
   const trimmed = text2.trim();
   return trimmed.startsWith(PREFIX) && issue_body_keys.size_counts(trimmed.slice(PREFIX.length).trim()) !== void 0;
 }
-function stated_line(record6) {
-  return markdown_section.unfenced_lines(record6).find((text2) => is_estimate_line(text2))?.trim();
+function stated_line(record7) {
+  return markdown_section.unfenced_lines(record7).find((text2) => is_estimate_line(text2))?.trim();
 }
 function declared_index(visible) {
   const start2 = visible.findIndex((text2) => text2.trim() === BACKGROUND_HEADING3) + 1;
@@ -3173,16 +3202,16 @@ function restated(body, line) {
 function is_epic(body) {
   return markdown_section.has_line(body, EPIC_HEADING);
 }
-function grown(count, axis, growth) {
-  return count * declared_growth.factor(growth, axis);
+function grown(count2, axis, growth) {
+  return count2 * declared_growth.factor(growth, axis);
 }
 function guide_for2(rate2) {
   return split_assess.guide_for(IMPLEMENT_BUDGET, rate2);
 }
 function parse(body, rate2, growth) {
-  const read10 = estimate_schema.safeParse(issue_body_keys.size_counts(declared(body, PREFIX) ?? ""));
-  if (!read10.success) return void 0;
-  const { files, lines: lines2 } = read10.data;
+  const read11 = estimate_schema.safeParse(issue_body_keys.size_counts(declared(body, PREFIX) ?? ""));
+  if (!read11.success) return void 0;
+  const { files, lines: lines2 } = read11.data;
   return {
     files,
     lines: lines2,
@@ -3375,16 +3404,111 @@ var git_next_issues = {
   fetch_next_issue_lines
 };
 
+// scripts/lane/lane-early-push-count.ts
+var MULTI_SLOT_EARLY_PUSH = "multi-slot-early-push";
+var PUSHED = "pushed";
+var MULTI_SLOT_MINIMUM = 2;
+function multi_slot_pushed(entries) {
+  return entries.filter(
+    (entry) => entry.kind === "early-push" && entry.result === PUSHED && (entry.slots ?? 0) >= MULTI_SLOT_MINIMUM
+  ).length;
+}
+var lane_early_push_count = { MULTI_SLOT_EARLY_PUSH, multi_slot_pushed };
+
+// scripts/issue/issue-observation-gate.ts
+var PREFIX2 = "<!-- josh:observation-wait";
+var DECLARATION2 = /^<!-- josh:observation-wait:v1 (?<url>https:\/\/github\.com\/(?<repo>[\w.-]+\/[\w.-]+)\/issues\/[1-9]\d*#issuecomment-(?<comment>[1-9]\d*)) (?<keys>[\w-]+(?:,[\w-]+)*) -->$/u;
+var LEDGER = / ledger:(?<metric>[\w-]+)>=(?<minimum>[1-9]\d*)(?= -->$)/u;
+var METRICS = /* @__PURE__ */ new Set([lane_early_push_count.MULTI_SLOT_EARLY_PUSH]);
+var EVIDENCE_HEADING = "## Observation evidence";
+var TASK = /^- \[(?<checked>[ xX])\] (?<key>[\w-]+): (?<description>.+)$/u;
+var EVIDENCE = /\[evidence\]\(https:\/\/github\.com\/[\w./#?=&%-]+\)$/u;
+var records = /* @__PURE__ */ new Map();
+var samples = /* @__PURE__ */ new Map();
+function is_evidenced(task) {
+  return task?.["checked"]?.toLowerCase() === "x" && EVIDENCE.test(task["description"] ?? "");
+}
+function declarations(body = "") {
+  return markdown_section.unfenced_lines(body).filter((line) => line.trimStart().startsWith(PREFIX2));
+}
+function ledger_of(line) {
+  const groups = LEDGER.exec(line)?.groups;
+  if (groups === void 0) return void 0;
+  return { metric: String(groups["metric"]), minimum: Number(groups["minimum"]) };
+}
+function is_known(ledger2) {
+  return ledger2 === void 0 || METRICS.has(ledger2.metric);
+}
+function source_of(line) {
+  const trimmed = line.trim();
+  const ledger2 = ledger_of(trimmed);
+  if (!is_known(ledger2)) return void 0;
+  const groups = DECLARATION2.exec(trimmed.replace(LEDGER, ""))?.groups;
+  if (groups === void 0) return void 0;
+  return {
+    url: String(groups["url"]),
+    repo: String(groups["repo"]),
+    comment: String(groups["comment"]),
+    keys: String(groups["keys"]).split(","),
+    ledger: ledger2
+  };
+}
+function is_sampled(ledger2) {
+  if (ledger2 === void 0) return false;
+  return (samples.get(ledger2.metric) ?? 0) >= ledger2.minimum;
+}
+function sources(bodies) {
+  return bodies.flatMap((body) => declarations(body).flatMap((line) => source_of(line) ?? []));
+}
+function pending(source, body) {
+  const lines2 = markdown_section.section_lines(body, EVIDENCE_HEADING).join("\n");
+  const tasks = markdown_section.unfenced_lines(lines2).map((line) => TASK.exec(line)?.groups);
+  return source.keys.filter((key2) => {
+    const matches = tasks.filter((task2) => task2?.["key"] === key2);
+    const [task] = matches;
+    return matches.length !== 1 || !is_evidenced(task);
+  });
+}
+function wait_for(line) {
+  const source = source_of(line);
+  if (source === void 0) {
+    return {
+      reason: "unknown observation condition; record a v1 evidence comment and required keys"
+    };
+  }
+  if (is_sampled(source.ledger)) return void 0;
+  const body = records.get(source.url);
+  if (body === void 0) {
+    return { reason: `observation evidence unread: ${source.keys.join(", ")}`, url: source.url };
+  }
+  const missing = pending(source, body);
+  return missing.length === 0 ? void 0 : { reason: `observation evidence required: ${missing.join(", ")}`, url: source.url };
+}
+function wait_of(body) {
+  return declarations(body).map((line) => wait_for(line)).find((wait) => wait !== void 0);
+}
+function record2(url, body) {
+  records.set(url, body);
+}
+function record_sample(metric, count2) {
+  samples.set(metric, count2);
+}
+function reset() {
+  records.clear();
+  samples.clear();
+}
+var issue_observation_gate = { sources, wait_of, record: record2, record_sample, reset };
+
 // scripts/issue/issue-sample-gate.ts
 var BACKGROUND_HEADING4 = issue_body_keys.heading("background");
-var PREFIX2 = issue_body_keys.prefix("sample_gate");
+var PREFIX3 = issue_body_keys.prefix("sample_gate");
 var CONDITION_PATTERN = /^#(?<cited>[1-9]\d*) (?<closing>を閉じる PR )?のマージ後 (?<count>[1-9]\d*) マージ$/u;
 var VALUE_FORMAT = "#<PR> \u306E\u30DE\u30FC\u30B8\u5F8C <K> \u30DE\u30FC\u30B8";
 var CLOSING_FORMAT = "#<issue> \u3092\u9589\u3058\u308B PR \u306E\u30DE\u30FC\u30B8\u5F8C <K> \u30DE\u30FC\u30B8";
-var DECLARATION2 = `${PREFIX2} ${VALUE_FORMAT}`;
+var DECLARATION3 = `${PREFIX3} ${VALUE_FORMAT}`;
 var MAX_COUNT = 30;
-var EXAMPLE2 = `${PREFIX2} #5198 \u306E\u30DE\u30FC\u30B8\u5F8C 10 \u30DE\u30FC\u30B8`;
-var MALFORMED2 = `\`${PREFIX2}\` must read \`${VALUE_FORMAT}\` or \`${CLOSING_FORMAT}\` with K from 1 to ${String(MAX_COUNT)}
+var EXAMPLE2 = `${PREFIX3} #5198 \u306E\u30DE\u30FC\u30B8\u5F8C 10 \u30DE\u30FC\u30B8`;
+var MALFORMED2 = `\`${PREFIX3}\` must read \`${VALUE_FORMAT}\` or \`${CLOSING_FORMAT}\` with K from 1 to ${String(MAX_COUNT)}
 ${EXAMPLE2}`;
 var pull_by_key = /* @__PURE__ */ new Map();
 function no_merges() {
@@ -3393,8 +3517,8 @@ function no_merges() {
 var ledger = { merges: no_merges };
 function declared_value(body) {
   const background2 = markdown_section.section_lines(body, BACKGROUND_HEADING4).join("\n");
-  const line = markdown_section.unfenced_lines(background2).map((text2) => text2.trim()).find((text2) => text2.startsWith(PREFIX2));
-  return line?.slice(PREFIX2.length).trim();
+  const line = markdown_section.unfenced_lines(background2).map((text2) => text2.trim()).find((text2) => text2.startsWith(PREFIX3));
+  return line?.slice(PREFIX3.length).trim();
 }
 function via_of(groups) {
   return groups["closing"] === void 0 ? "pull" : "issue";
@@ -3415,14 +3539,14 @@ function key_of2({ cited: cited3, via }) {
   return `${via}:${String(cited3)}`;
 }
 function is_well_formed(value) {
-  const count = CONDITION_PATTERN.exec(value)?.groups?.["count"];
-  return count !== void 0 && Number(count) <= MAX_COUNT;
+  const count2 = CONDITION_PATTERN.exec(value)?.groups?.["count"];
+  return count2 !== void 0 && Number(count2) <= MAX_COUNT;
 }
 function problems3(body) {
   const value = declared_value(body);
   return value === void 0 || is_well_formed(value) ? [] : [MALFORMED2];
 }
-function record2(condition, pull) {
+function record3(condition, pull) {
   const key2 = key_of2(condition);
   if (pull === void 0) pull_by_key.delete(key2);
   else pull_by_key.set(key2, pull);
@@ -3443,16 +3567,16 @@ function merges_after({ merged_at, closes }) {
   const since = Date.parse(merged_at);
   return ledger.merges().filter((merge) => merge.issue !== closes && Date.parse(merge.at) > since).length;
 }
-function wait_of(body) {
+function wait_of2(body) {
   const condition = condition_of(body);
   if (condition === void 0) return void 0;
-  const { cited: cited3, via, count } = condition;
+  const { cited: cited3, via, count: count2 } = condition;
   const pull = pull_by_key.get(key_of2(condition));
   if (pull === void 0) return { kind: "unread", cited: cited3, via };
   const { merged_at, closes } = pull;
   if (merged_at === void 0) return { kind: "unmerged", cited: cited3, via };
   const counted2 = merges_after({ merged_at, closes });
-  return counted2 >= count ? void 0 : { kind: "short", cited: cited3, via, counted: counted2, needed: count };
+  return counted2 >= count2 ? void 0 : { kind: "short", cited: cited3, via, counted: counted2, needed: count2 };
 }
 function subject_of({ cited: cited3, via }) {
   const plain = issue_cite.plain_for("linked", cited3);
@@ -3464,36 +3588,36 @@ function reason_of(wait) {
   if (wait.kind === "unmerged") return `until ${subject} merges`;
   return `${String(wait.counted)}/${String(wait.needed)} merges after ${subject}`;
 }
-function reset() {
+function reset2() {
   pull_by_key.clear();
   ledger.merges = no_merges;
 }
 var issue_sample_gate = {
-  DECLARATION: DECLARATION2,
+  DECLARATION: DECLARATION3,
   CLOSING_FORMAT,
   cited_number,
   cited_via,
   problems: problems3,
   reason_of,
-  record: record2,
-  reset,
+  record: record3,
+  reset: reset2,
   unread_of,
   use_merges,
-  wait_of
+  wait_of: wait_of2
 };
 
 // scripts/issue/measure-declaration.ts
 var BACKGROUND_HEADING5 = issue_body_keys.heading("background");
-var PREFIX3 = issue_body_keys.prefix("measure_declaration");
+var PREFIX4 = issue_body_keys.prefix("measure_declaration");
 var PREMISE_PREFIX = issue_body_keys.prefix("premise");
 var ABSENT_PREFIX = issue_body_keys.prefix("measure_absent");
 var ABSENT = `${ABSENT_PREFIX} <\u7406\u7531>`;
 var SHAPE = "`<command>` <=|<|>=|> <number>";
-var DECLARATION3 = `${PREFIX3} ${SHAPE}`;
+var DECLARATION4 = `${PREFIX4} ${SHAPE}`;
 var VALUE_PATTERN = /^`(?<command>[^`\s][^`]*)`\s*(?<operator><=|>=|<|>)\s*(?<threshold>-?\d+(?:\.\d+)?)$/u;
 var NUMBER_PATTERN = /^-?\d+(?:\.\d+)?$/u;
 var EXAMPLE_VALUE = "`pnpm josh lane:net 5168` <= 40";
-var EXAMPLE3 = `${PREFIX3} ${EXAMPLE_VALUE}`;
+var EXAMPLE3 = `${PREFIX4} ${EXAMPLE_VALUE}`;
 var PLACEHOLDER_PATTERN = /<[^\s<>./][^<>./]*>/u;
 var declaration_schema = external_exports.object({
   command: external_exports.string().trim(),
@@ -3514,15 +3638,15 @@ function background_value(body, prefix) {
   return background_values(body, prefix)[0];
 }
 function declared_value2(body) {
-  return background_value(body, PREFIX3);
+  return background_value(body, PREFIX4);
 }
 function is_stated2(body) {
   if (declared_value2(body) !== void 0) return true;
   return (background_value(body, ABSENT_PREFIX) ?? "").length > 0;
 }
 function shaped(value) {
-  const read10 = declaration_schema.safeParse(VALUE_PATTERN.exec(value)?.groups);
-  return read10.success ? read10.data : void 0;
+  const read11 = declaration_schema.safeParse(VALUE_PATTERN.exec(value)?.groups);
+  return read11.success ? read11.data : void 0;
 }
 function placeholder_of(declaration) {
   return PLACEHOLDER_PATTERN.exec(declaration.command)?.[0];
@@ -3554,7 +3678,7 @@ function premises(body) {
 }
 function problems4(body) {
   const value = declared_value2(body);
-  const declared2 = value === void 0 ? [] : value_problems(value, PREFIX3);
+  const declared2 = value === void 0 ? [] : value_problems(value, PREFIX4);
   const premised = background_values(body, PREMISE_PREFIX).flatMap(
     (premise) => value_problems(premise, PREMISE_PREFIX)
   );
@@ -3575,9 +3699,9 @@ function format(declaration) {
 }
 var measure_declaration = {
   ABSENT,
-  DECLARATION: DECLARATION3,
+  DECLARATION: DECLARATION4,
   EXAMPLE: EXAMPLE3,
-  PREFIX: PREFIX3,
+  PREFIX: PREFIX4,
   PREMISE_PREFIX,
   background_value,
   format,
@@ -3590,27 +3714,27 @@ var measure_declaration = {
 
 // scripts/issue/issue-not-before.ts
 var BACKGROUND_HEADING6 = issue_body_keys.heading("background");
-var PREFIX4 = issue_body_keys.prefix("not_before");
+var PREFIX5 = issue_body_keys.prefix("not_before");
 var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}Z$/u;
 var ISO_TAIL = ":00.000Z";
-var EXAMPLE4 = `${PREFIX4} 2099-01-01T09:00Z`;
-var MALFORMED3 = `\`${PREFIX4}\` must be a UTC time written YYYY-MM-DDTHH:MMZ
+var EXAMPLE4 = `${PREFIX5} 2099-01-01T09:00Z`;
+var MALFORMED3 = `\`${PREFIX5}\` must be a UTC time written YYYY-MM-DDTHH:MMZ
 ${EXAMPLE4}`;
 var MAX_WAIT_DAYS = 7;
 var DAY_MS = 864e5;
 var MAX_WAIT_MS = MAX_WAIT_DAYS * DAY_MS;
 var MINUTES_LENGTH = 16;
-var TOO_LATE = `\`${PREFIX4}\` of a measurement follow-up must be at most ${String(MAX_WAIT_DAYS)} days after filing \u2014 wait on samples with \`${issue_sample_gate.DECLARATION}\` instead`;
-var BOTH = `a measurement follow-up declares one of \`${PREFIX4}\` and \`${issue_body_keys.prefix("sample_gate")}\`, not both \u2014 keep the condition`;
+var TOO_LATE = `\`${PREFIX5}\` of a measurement follow-up must be at most ${String(MAX_WAIT_DAYS)} days after filing \u2014 wait on samples with \`${issue_sample_gate.DECLARATION}\` instead`;
+var BOTH = `a measurement follow-up declares one of \`${PREFIX5}\` and \`${issue_body_keys.prefix("sample_gate")}\`, not both \u2014 keep the condition`;
 var HEADING_MARKS = /^#{1,6}\s+/u;
 var STRAY_HEADINGS = [
-  { name: "\u5B9F\u65BD\u53EF\u80FD\u65E5", declaration: `${PREFIX4} YYYY-MM-DDTHH:MMZ` },
+  { name: "\u5B9F\u65BD\u53EF\u80FD\u65E5", declaration: `${PREFIX5} YYYY-MM-DDTHH:MMZ` },
   { name: "\u5B9F\u65BD\u53EF\u80FD\u6761\u4EF6", declaration: issue_sample_gate.DECLARATION }
 ];
 function declared_value3(body) {
   const background2 = markdown_section.section_lines(body, BACKGROUND_HEADING6).join("\n");
-  const line = markdown_section.unfenced_lines(background2).map((text2) => text2.trim()).find((text2) => text2.startsWith(PREFIX4));
-  return line?.slice(PREFIX4.length).trim();
+  const line = markdown_section.unfenced_lines(background2).map((text2) => text2.trim()).find((text2) => text2.startsWith(PREFIX5));
+  return line?.slice(PREFIX5.length).trim();
 }
 function is_valid2(value) {
   if (!DATE_PATTERN.test(value)) return false;
@@ -3626,7 +3750,7 @@ function is_date_due(body, now) {
   return date === void 0 || Date.parse(date) <= now;
 }
 function is_due(body, now = Date.now()) {
-  return is_date_due(body, now) && issue_sample_gate.wait_of(body) === void 0;
+  return is_date_due(body, now) && issue_sample_gate.wait_of(body) === void 0 && issue_observation_gate.wait_of(body) === void 0;
 }
 function waiting_ms(body, now = Date.now()) {
   if (is_date_due(body, now)) return void 0;
@@ -3639,7 +3763,7 @@ function waiting_reason(body, now = Date.now()) {
   const date = waiting_date(body, now);
   if (date !== void 0) return `not before ${date}`;
   const wait = issue_sample_gate.wait_of(body);
-  return wait === void 0 ? void 0 : issue_sample_gate.reason_of(wait);
+  return wait === void 0 ? issue_observation_gate.wait_of(body)?.reason : issue_sample_gate.reason_of(wait);
 }
 function stray_heading_problems(body) {
   const headings2 = markdown_section.unfenced_lines(body).map((line) => line.trim()).filter((line) => HEADING_MARKS.test(line)).map((line) => line.replace(HEADING_MARKS, ""));
@@ -3655,7 +3779,7 @@ function measurement_wait_problems(body, now) {
   if (date === void 0 || !measure_declaration.is_stated(body)) return [];
   if (issue_sample_gate.cited_number(body) !== void 0) return [BOTH];
   return Date.parse(date) > now + MAX_WAIT_MS ? [`${TOO_LATE}
-${PREFIX4} ${latest_date(now)}`] : [];
+${PREFIX5} ${latest_date(now)}`] : [];
 }
 function problems5(body, now = Date.now()) {
   const value = declared_value3(body);
@@ -3669,6 +3793,143 @@ function problems5(body, now = Date.now()) {
 }
 var issue_not_before = { is_due, problems: problems5, waiting_date, waiting_ms, waiting_reason };
 
+// scripts/issue/issue-auto-ok.ts
+var BACKGROUND_HEADING7 = issue_body_keys.heading("background");
+var JUDGEMENT_NOT_NEEDED = issue_body_keys.line("judgement", "not_needed");
+var JUDGEMENT_NEEDED = issue_body_keys.line("judgement", "needed");
+var DECLARATION_PROBLEM2 = `declare under \`${BACKGROUND_HEADING7}\` whether a person's judgement (a policy decision, an external account, a human visual check) is needed: \`${JUDGEMENT_NOT_NEEDED}\` or \`${JUDGEMENT_NEEDED}\uFF08<which one>\uFF09\` \u2014 exactly one (\`issue-template.md\`)`;
+var DECISION_RULE_PREFIX = issue_body_keys.prefix("decision_rule");
+var DECISION_PROBLEM = `a decision rule citing a measurement Issue determines the choice; declare \`${JUDGEMENT_NOT_NEEDED}\` and record the applied result and reason in an Issue comment`;
+var OPTED_OUT = { is_applied: false, reason: "--no-auto-ok declared" };
+var CROSS_REPOSITORY = {
+  is_applied: false,
+  reason: "the Issue is filed to another repository"
+};
+var JUDGEMENT = {
+  is_applied: false,
+  reason: `the body declares \`${JUDGEMENT_NEEDED}\``
+};
+var APPLIED = {
+  is_applied: true,
+  reason: "no exclusion holds and the body declares no judgement is needed"
+};
+var CONSTRAINT_HEADING = issue_body_keys.heading("auto_execution_constraint");
+var CONSTRAINT_SOURCE = `${issue_body_keys.prefix("constraint_source")} user`;
+var CONSTRAINT_REFERENCE = `${issue_body_keys.prefix("constraint_reference")} `;
+var CONSTRAINT_INSTRUCTION = `${issue_body_keys.prefix("constraint_instruction")} `;
+var CONSTRAINT_FIELDS = [CONSTRAINT_REFERENCE, CONSTRAINT_INSTRUCTION];
+var CONSTRAINT_PROBLEM = `--no-auto-ok without an exclusion needs ${CONSTRAINT_HEADING}: ${CONSTRAINT_SOURCE}, ${CONSTRAINT_REFERENCE}<original user prompt or comment URL>, ${CONSTRAINT_INSTRUCTION}<verbatim prohibition>; verify the cited user instruction, not an agent inference or a later judgement. Kickoff ending at planning is not an opt-out.`;
+var USER_CONSTRAINT = {
+  is_applied: false,
+  reason: "a user prohibition is recorded under \u81EA\u52D5\u5B9F\u884C\u306E\u5236\u7D04"
+};
+function user_constraint_of(body) {
+  const section = markdown_section.section_lines(body, CONSTRAINT_HEADING).join("\n");
+  const lines2 = markdown_section.unfenced_lines(section).map((line) => line.trim());
+  const has_fields = CONSTRAINT_FIELDS.every(
+    (prefix) => lines2.some((line) => line.startsWith(prefix) && line.slice(prefix.length).trim() !== "")
+  );
+  return has_fields && lines2.includes(CONSTRAINT_SOURCE) ? USER_CONSTRAINT : void 0;
+}
+var EXCLUDED_LABELS = [
+  [RELEASE_LABEL, "a release is Tier C"],
+  [BREAKING_CHANGE_LABEL, "a breaking change needs a person to accept the migration"],
+  [DEFERRED_LABEL, "the Issue is deferred"],
+  [NEEDS_HUMAN_REVIEW_LABEL, "a person reviews the change before it lands"],
+  [EPIC_LABEL, "an epic is opted in by a person, and that opts in every descendant"]
+];
+function exclusion_of(labels) {
+  const found = EXCLUDED_LABELS.find(([label2]) => has_label_name(labels, label2));
+  if (found === void 0) return void 0;
+  return { is_applied: false, reason: `a \`${found[0]}\` Issue \u2014 ${found[1]}` };
+}
+function background_lines2(body) {
+  const background2 = markdown_section.section_lines(body, BACKGROUND_HEADING7).join("\n");
+  return markdown_section.unfenced_lines(background2).map((line) => line.trim());
+}
+function judgement_of(body) {
+  const lines2 = background_lines2(body);
+  const is_not_needed = lines2.some((line) => line.startsWith(JUDGEMENT_NOT_NEEDED));
+  const is_needed = lines2.some((line) => line.startsWith(JUDGEMENT_NEEDED));
+  return is_not_needed === is_needed ? void 0 : is_needed;
+}
+function declaration_problem(body) {
+  return judgement_of(body) === void 0 ? DECLARATION_PROBLEM2 : void 0;
+}
+function decision_problem(body) {
+  if (judgement_of(body) !== true) return void 0;
+  const has_rule = background_lines2(body).some(
+    (line) => line.startsWith(DECISION_RULE_PREFIX) && /#[1-9]\d*\b/u.test(line)
+  );
+  return has_rule ? DECISION_PROBLEM : void 0;
+}
+function body_decision(body) {
+  return user_constraint_of(body) ?? (judgement_of(body) === false ? APPLIED : JUDGEMENT);
+}
+function decide(filing) {
+  if (filing.is_opted_out) return OPTED_OUT;
+  if (filing.is_cross_repository) return CROSS_REPOSITORY;
+  return exclusion_of(filing.labels) ?? body_decision(filing.body);
+}
+function opt_out_problem(filing) {
+  if (!filing.is_opted_out || user_constraint_of(filing.body) !== void 0) return void 0;
+  const without_opt_out = decide({ ...filing, is_opted_out: false });
+  return without_opt_out.is_applied ? CONSTRAINT_PROBLEM : void 0;
+}
+function line_of2(decision) {
+  return `auto-ok: ${decision.is_applied ? "applied" : "not applied"} \u2014 ${decision.reason}`;
+}
+var issue_auto_ok = {
+  declaration_problem,
+  decide,
+  decision_problem,
+  exclusion_of,
+  line_of: line_of2,
+  opt_out_problem,
+  user_constraint_of
+};
+
+// scripts/issue/issue-publication-state.ts
+var PREFIX6 = "<!-- josh:publication ";
+var PATTERN = /<!-- josh:publication (?<record>[^\n]*?) -->/u;
+var schema = external_exports.object({ labels: external_exports.array(external_exports.string()) });
+function is_pending(body) {
+  return body?.includes(PREFIX6) === true;
+}
+function prepare(body, labels) {
+  if (is_pending(body)) throw new Error("Issue already contains a publication record");
+  return `${body}
+
+${PREFIX6}${JSON.stringify({ labels })} -->
+`;
+}
+function public_body(body) {
+  return body.replace(PATTERN, "").trimEnd();
+}
+function intended_labels(body = "") {
+  const record7 = PATTERN.exec(body)?.groups?.["record"];
+  return schema.parse(JSON.parse(record7 ?? "null")).labels;
+}
+function labels_of(body, current2) {
+  const intended = intended_labels(body);
+  const labels = current2.filter((label2) => !has_label_name([label2], AUTO_OK_LABEL));
+  const decision = issue_auto_ok.decide({
+    is_opted_out: !has_label_name(intended, AUTO_OK_LABEL),
+    is_cross_repository: false,
+    body: public_body(body ?? ""),
+    labels
+  });
+  return decision.is_applied ? [...labels, AUTO_OK_LABEL] : labels;
+}
+function creation(body, labels, is_prepared) {
+  if (!is_prepared) return { body, labels };
+  return {
+    body: prepare(body, labels),
+    labels: labels.filter((label2) => !has_label_name([label2], AUTO_OK_LABEL))
+  };
+}
+var issue_publication_state = { is_pending, prepare, public_body, labels_of, creation };
+
 // scripts/git/git-closes-keyword.ts
 var CLOSES_PATTERN = /closes\s+#(\d+)/iu;
 function parse_closes_issue_number(body) {
@@ -3748,6 +4009,55 @@ var issue_closing_pr = {
   read_closing_pr
 };
 
+// scripts/issue/issue-observation-prime.ts
+var comment_schema = external_exports.object({
+  ...gh_author_association.author_fields_schema,
+  body: external_exports.string(),
+  html_url: external_exports.string()
+});
+async function read_ledger() {
+  const path12 = await lane_ledger.target();
+  return path12 === void 0 ? [] : lane_ledger.read_entries(path12);
+}
+async function read4(source) {
+  const path12 = `${git_gh_api_path.issues_api_path(source.repo)}/comments/${source.comment}`;
+  const raw = await git_gh_exec.exec_gh_api({ path: path12 });
+  const comment = parse_json.parse_json_object_or_undefined(raw, comment_schema);
+  if (comment?.html_url !== source.url) return void 0;
+  const author = { ...gh_author_association.author_of(comment), repo: source.repo };
+  return await gh_author_association.is_trusted(author) ? comment.body : void 0;
+}
+async function remember(source, read_source2) {
+  try {
+    issue_observation_gate.record(source.url, await read_source2(source));
+  } catch {
+    issue_observation_gate.record(source.url, void 0);
+  }
+}
+async function sample2(sources2, read_entries2) {
+  if (sources2.every((source) => source.ledger === void 0)) return;
+  let entries = [];
+  try {
+    entries = await read_entries2();
+  } catch {
+  }
+  issue_observation_gate.record_sample(
+    lane_early_push_count.MULTI_SLOT_EARLY_PUSH,
+    lane_early_push_count.multi_slot_pushed(entries)
+  );
+}
+async function prime(bodies, read_source2 = read4, read_entries2 = read_ledger) {
+  const sources2 = issue_observation_gate.sources(bodies);
+  const unique2 = new Map(sources2.map((source) => [source.url, source]));
+  await Promise.all([
+    sample2(sources2, read_entries2),
+    ...[...unique2.values()].map(async (source) => {
+      await remember(source, read_source2);
+    })
+  ]);
+}
+var issue_observation_prime = { prime };
+
 // scripts/issue/issue-sample-prime.ts
 async function read_as_issue(pr) {
   const json = await git_gh_exec.exec_gh_api({ path: git_gh_api_path.issue_api_path(String(pr)) });
@@ -3781,32 +4091,33 @@ var DEFAULT_PORTS = {
   closing: read_closing_source,
   ledger_path: lane_ledger.target
 };
-function merges_of(path15) {
+function merges_of(path12) {
   return function merges() {
-    if (path15 === void 0) return [];
-    return lane_ledger.read_entries(path15).filter((entry) => entry.kind === lane_ledger.KIND.MERGE);
+    if (path12 === void 0) return [];
+    return lane_ledger.read_entries(path12).filter((entry) => entry.kind === lane_ledger.KIND.MERGE);
   };
 }
-async function remember(condition, ports) {
-  const read10 = condition.via === "pull" ? ports.pull : ports.closing;
+async function remember2(condition, ports) {
+  const read11 = condition.via === "pull" ? ports.pull : ports.closing;
   try {
-    issue_sample_gate.record(condition, await read10(condition.cited));
+    issue_sample_gate.record(condition, await read11(condition.cited));
   } catch {
     issue_sample_gate.record(condition, void 0);
   }
 }
-async function prime(bodies, ports = DEFAULT_PORTS) {
+async function prime2(bodies, ports = DEFAULT_PORTS) {
+  await issue_observation_prime.prime(bodies);
   const unread = issue_sample_gate.unread_of(bodies);
   if (unread.length === 0) return;
   issue_sample_gate.use_merges(merges_of(await ports.ledger_path()));
   await Promise.all(
     unread.map(async (condition) => {
-      await remember(condition, ports);
+      await remember2(condition, ports);
     })
   );
 }
 var issue_sample_prime = {
-  prime,
+  prime: prime2,
   read_closing: read_closing_source,
   read_source
 };
@@ -3857,12 +4168,12 @@ function parse_options(argv2, usage = USAGE) {
   return exclude.length === 0 ? {} : { exclude };
 }
 function parse_listing(raw, is_capped) {
-  const read10 = read_json_listing(raw, open_issue_schema);
-  if (read10.kind !== "read") return { kind: read10.kind };
+  const read11 = read_json_listing(raw, open_issue_schema);
+  if (read11.kind !== "read") return { kind: read11.kind };
   return {
     kind: "read",
-    issues: read10.rows,
-    cutoff: cutoff_of(read10.rows.length, LISTING_LIMIT, is_capped)
+    issues: read11.rows,
+    cutoff: cutoff_of(read11.rows.length, LISTING_LIMIT, is_capped)
   };
 }
 async function reads_without_blocked_by() {
@@ -3881,11 +4192,11 @@ async function fetch_opted_in() {
     AUTO_OK_LABEL,
     LISTING_LIMIT
   );
-  const read10 = json === void 0 ? await classify_failed_read() : parse_listing(json, is_capped);
-  if (read10.kind !== "read") return read10;
-  const issues = await auto_ok_author.with_author_trust(read10.issues);
+  const read11 = json === void 0 ? await classify_failed_read() : parse_listing(json, is_capped);
+  if (read11.kind !== "read") return read11;
+  const issues = await auto_ok_author.with_author_trust(read11.issues);
   await issue_sample_prime.prime(issues.map((issue) => issue.body));
-  return { ...read10, issues, is_unchanged: is_unchanged2 === true };
+  return { ...read11, issues, is_unchanged: is_unchanged2 === true };
 }
 function is_page_complete(blocked_by) {
   const nodes = blocked_by?.nodes ?? [];
@@ -3905,8 +4216,8 @@ async function read_open_epics() {
     return void 0;
   }
 }
-async function fetch_tracking(count) {
-  if (count === 0) return { kind: "read", index: /* @__PURE__ */ new Map(), cutoff: NO_CUTOFF };
+async function fetch_tracking(count2) {
+  if (count2 === 0) return { kind: "read", index: /* @__PURE__ */ new Map(), cutoff: NO_CUTOFF };
   const open_epics = await read_open_epics();
   if (open_epics === void 0) return { kind: "epics_unreadable" };
   return {
@@ -3916,7 +4227,7 @@ async function fetch_tracking(count) {
   };
 }
 function is_ready(issue, options) {
-  return auto_ok_author.is_author_trusted(issue) && is_unblocked(issue) && issue_not_before.is_due(issue.body, options.now ?? Date.now());
+  return !issue_publication_state.is_pending(issue.body) && auto_ok_author.is_author_trusted(issue) && is_unblocked(issue) && issue_not_before.is_due(issue.body, options.now ?? Date.now());
 }
 function is_runnable(issue, tracked, exclude, options = {}) {
   if (tracked.has(issue.number)) return false;
@@ -3925,9 +4236,9 @@ function is_runnable(issue, tracked, exclude, options = {}) {
 function pick_next(issues, tracked = /* @__PURE__ */ new Map(), exclude = [], options = {}) {
   return git_next_issues.order(issues).find((issue) => is_runnable(issue, tracked, exclude, options));
 }
-function none_reason(count) {
-  if (count === 0) return NONE_OPTED_IN_MESSAGE;
-  return `All ${String(count)} open \`${AUTO_OK_LABEL}\` issue(s) are excluded \u2014 tracked by an opted-in epic, an epic itself, already in progress, parked, filed by an author without write access (waiting on a person), blocked by an open issue, not due until its start time, or the one just merged.`;
+function none_reason(count2) {
+  if (count2 === 0) return NONE_OPTED_IN_MESSAGE;
+  return `All ${String(count2)} open \`${AUTO_OK_LABEL}\` issue(s) are excluded \u2014 tracked by an opted-in epic, an epic itself, already in progress, parked, filed by an author without write access (waiting on a person), blocked by an open issue, not due until its start time, or the one just merged.`;
 }
 function truncation_note(cutoff, has_answer) {
   const cause = truncated_cause(cutoff);
@@ -3954,16 +4265,16 @@ function report(context) {
   console.info(String(next.number));
   return SUCCESS_EXIT_CODE2;
 }
-async function answer(read10, exclude) {
-  const tracking = await fetch_tracking(read10.issues.length);
+async function answer(read11, exclude) {
+  const tracking = await fetch_tracking(read11.issues.length);
   if (tracking.kind !== "read") {
     console.error(EPICS_UNREADABLE_MESSAGE);
     return FAILURE_EXIT_CODE;
   }
   return report({
-    issues: read10.issues,
-    cutoff: read10.cutoff,
-    tracked: epic_index.withheld_children(tracking.index, read10.issues),
+    issues: read11.issues,
+    cutoff: read11.cutoff,
+    tracked: epic_index.withheld_children(tracking.index, read11.issues),
     epic_cutoff: tracking.cutoff,
     exclude
   });
@@ -3979,12 +4290,12 @@ async function run(argv2) {
     console.error(options.usage);
     return FAILURE_EXIT_CODE;
   }
-  const read10 = await fetch_opted_in();
-  if (read10.kind !== "read") {
-    console.error(READ_FAILURE_MESSAGES[read10.kind]);
+  const read11 = await fetch_opted_in();
+  if (read11.kind !== "read") {
+    console.error(READ_FAILURE_MESSAGES[read11.kind]);
     return FAILURE_EXIT_CODE;
   }
-  return await answer(read10, options.exclude);
+  return await answer(read11, options.exclude);
 }
 var auto_ok_cli = {
   USAGE,
@@ -4077,7 +4388,7 @@ function has_human_label(child) {
   return has_parked_label(child.labels);
 }
 function is_waiting(child) {
-  return has_label(child, IN_PROGRESS_LABEL) || !issue_not_before.is_due(child.body);
+  return issue_publication_state.is_pending(child.body) || has_label(child, IN_PROGRESS_LABEL) || !issue_not_before.is_due(child.body);
 }
 function local_category(child) {
   if (child.state === CLOSED3) return "done";
@@ -4151,19 +4462,19 @@ function is_ready2(node, context) {
   return epic_graph.blockers_of(context.index, node).every((blocker) => !context.index.has(blocker) || context.memo.has(blocker));
 }
 function fill_memo(children, context) {
-  const pending = new Set(children.map((child) => epic_graph.key_of(child)));
+  const pending2 = new Set(children.map((child) => epic_graph.key_of(child)));
   function peel() {
-    const ready = [...pending].filter((node) => is_ready2(node, context));
+    const ready = [...pending2].filter((node) => is_ready2(node, context));
     for (const node of ready) {
       const child = context.index.get(node);
       if (child !== void 0) context.memo.set(node, compute_category(child, context));
-      pending.delete(node);
+      pending2.delete(node);
     }
     return ready.length;
   }
   while (peel() > 0) {
   }
-  for (const node of pending) context.memo.set(node, "time");
+  for (const node of pending2) context.memo.set(node, "time");
 }
 function new_context(children, resolve4 = resolve_by_state, running = epic_outside_blocker.running_keys(children)) {
   return {
@@ -4505,8 +4816,8 @@ async function read_each(issue_numbers, reader) {
   );
   return await Promise.all(
     issue_numbers.map(async (issue_number) => {
-      const read10 = reads.get(issue_number);
-      const value = read10?.kind === "read" ? reader.from_json(read10.json) : await reader.read_rest(issue_number);
+      const read11 = reads.get(issue_number);
+      const value = read11?.kind === "read" ? reader.from_json(read11.json) : await reader.read_rest(issue_number);
       return [issue_number, value];
     })
   );
@@ -4637,11 +4948,11 @@ async function read_child_blockers(child, current_repo) {
   );
 }
 async function fetch_epic_body(epic_number, scope) {
-  const read10 = await git_gh_command.issue_get_body_classified(String(epic_number), scope);
-  const body = read10.kind === "read" ? read10.text : void 0;
+  const read11 = await git_gh_command.issue_get_body_classified(String(epic_number), scope);
+  const body = read11.kind === "read" ? read11.text : void 0;
   return {
     body,
-    body_failure: read10.kind === "read" ? void 0 : read10,
+    body_failure: read11.kind === "read" ? void 0 : read11,
     child_numbers: epic_parse.parse_task_list_issue_numbers(body),
     external: epic_parse.parse_external_task_list_children(body)
   };
@@ -4661,11 +4972,11 @@ var NOT_READ = { child: void 0, is_unreachable: false };
 async function read_rest(issue_number, scope) {
   return await git_gh_command.issue_get_state_and_relations_classified(String(issue_number), scope);
 }
-async function to_child_read(read10, repo) {
-  if (read10.kind !== "read") {
-    return { child: void 0, is_unreachable: git_gh_command.is_unreachable_read(read10) };
+async function to_child_read(read11, repo) {
+  if (read11.kind !== "read") {
+    return { child: void 0, is_unreachable: git_gh_command.is_unreachable_read(read11) };
   }
-  const parsed2 = epic_issue.parse_epic_issue(read10.json);
+  const parsed2 = epic_issue.parse_epic_issue(read11.json);
   await issue_sample_prime.prime([parsed2?.body]);
   return { child: parsed2 === void 0 ? void 0 : to_child(parsed2, repo), is_unreachable: false };
 }
@@ -4676,22 +4987,22 @@ async function read_children(issue_numbers, repo, scope) {
     read_rest: async (issue_number) => await read_rest(issue_number, scope)
   });
   const entries = await Promise.all(
-    reads.map(async ([issue_number, read10]) => [
+    reads.map(async ([issue_number, read11]) => [
       issue_number,
-      await to_child_read(read10, repo)
+      await to_child_read(read11, repo)
     ])
   );
   return new Map(entries);
 }
 async function fetch_child(issue_number, repo, scope) {
-  const read10 = await to_child_read(await read_rest(issue_number, scope), repo);
-  return read10.child;
+  const read11 = await to_child_read(await read_rest(issue_number, scope), repo);
+  return read11.child;
 }
 function to_children(reads) {
-  return reads.map((read10) => read10.child).filter((child) => child !== void 0);
+  return reads.map((read11) => read11.child).filter((child) => child !== void 0);
 }
 function count_unreachable(reads) {
-  return reads.filter((read10) => read10.is_unreachable).length;
+  return reads.filter((read11) => read11.is_unreachable).length;
 }
 function is_body_unreachable(failure) {
   return failure !== void 0 && git_gh_command.is_unreachable_read(failure);
@@ -4713,7 +5024,7 @@ async function recheck_blockers(reads, child_numbers, known2, repo) {
   const waited = epic_child_source.waited_closed(to_children(reads), known2, repo);
   if (waited.size === 0) return reads;
   const fresh = await read_children([...waited], repo);
-  return reads.map((read10, index) => fresh.get(child_numbers[index] ?? 0) ?? read10);
+  return reads.map((read11, index) => fresh.get(child_numbers[index] ?? 0) ?? read11);
 }
 async function fetch_children(child_numbers, repo, scope, source) {
   const limited = child_numbers.slice(0, CHILD_LIMIT);
@@ -4811,8 +5122,8 @@ var epic_fetch = {
 };
 
 // scripts/epic/epic-report.ts
-function to_path_field(path15) {
-  return path15 === void 0 ? {} : { path: path15 };
+function to_path_field(path12) {
+  return path12 === void 0 ? {} : { path: path12 };
 }
 function bundle_by_repo(children, paths = /* @__PURE__ */ new Map()) {
   const grouped2 = /* @__PURE__ */ new Map();
@@ -5004,16 +5315,16 @@ function parse_events(raw) {
   if (events === void 0) throw new Error(UNPARSED_TIMELINE_MESSAGE);
   return events;
 }
-async function read_timeline(path15) {
-  return parse_events(await git_gh_etag_read.read_listing(path15, TIMELINE_PAGE));
+async function read_timeline(path12) {
+  return parse_events(await git_gh_etag_read.read_listing(path12, TIMELINE_PAGE));
 }
 function is_in_progress_labeling(event) {
   return event.event === LABELED_EVENT && event.label?.name.toLowerCase() === IN_PROGRESS_LABEL;
 }
 async function read_labeled_at(issue, repo) {
   try {
-    const path15 = `${git_gh_api_path.issue_api_path(String(issue), repo)}/timeline?per_page=${String(TIMELINE_PAGE)}`;
-    const events = timeline_schema.parse(await read_timeline(path15));
+    const path12 = `${git_gh_api_path.issue_api_path(String(issue), repo)}/timeline?per_page=${String(TIMELINE_PAGE)}`;
+    const events = timeline_schema.parse(await read_timeline(path12));
     const at = events.findLast((event) => is_in_progress_labeling(event))?.created_at;
     return typeof at === "string" ? { kind: "at", at } : { kind: "absent" };
   } catch {
@@ -5081,7 +5392,7 @@ function reconcile(issues, lanes, room) {
   };
   return { read: holders.length > 0 ? { kind: "busy", issues: holders } : { kind: "idle" }, use };
 }
-async function read4(reading2, is_this_checkout) {
+async function read5(reading2, is_this_checkout) {
   if (!is_this_checkout || reading2.kind !== "busy") return { read: reading2 };
   try {
     const lanes = await lane_registry.list_lanes();
@@ -5091,7 +5402,7 @@ async function read4(reading2, is_this_checkout) {
     return { read: reading2 };
   }
 }
-var epic_lane_occupancy = { read: read4 };
+var epic_lane_occupancy = { read: read5 };
 
 // scripts/epic/epic-rank.ts
 var CLOSED4 = "CLOSED";
@@ -5124,9 +5435,9 @@ function is_solo(child) {
 function holder_of2(running) {
   return running.find((issue) => is_solo(issue))?.number;
 }
-function solo_holder(read10) {
-  if (read10.kind !== "busy") return void 0;
-  const running = read10.issues.map((issue) => ({
+function solo_holder(read11) {
+  if (read11.kind !== "busy") return void 0;
+  const running = read11.issues.map((issue) => ({
     number: issue.number,
     labels: (issue.labels ?? []).map((label2) => label2.name)
   }));
@@ -5160,20 +5471,20 @@ function queue_of(children) {
   const solo = children[index];
   return solo === void 0 ? void 0 : { solo, index, behind: children.slice(index + 1) };
 }
-function select_candidates(children, read10, repo, occupied) {
+function select_candidates(children, read11, repo, occupied) {
   const queue = queue_of(children);
   if (queue === void 0) return first_of(children, children.length);
   if (queue.index > 0) return first_of(children, queue.index);
-  if (occupied === 0 && read10.kind === "idle") return first_of(children, 1);
+  if (occupied === 0 && read11.kind === "idle") return first_of(children, 1);
   return none_of(children, waiting_message(queue.solo.number, repo));
 }
-function select(children, read10, repo, occupied = epic_busy.occupied_lanes(read10)) {
-  if (read10.kind === "unreadable" || read10.kind === "truncated") {
-    return none_of(children, epic_busy.busy_reason(read10, repo, 0));
+function select(children, read11, repo, occupied = epic_busy.occupied_lanes(read11)) {
+  if (read11.kind === "unreadable" || read11.kind === "truncated") {
+    return none_of(children, epic_busy.busy_reason(read11, repo, 0));
   }
-  const holder = solo_holder(read10);
+  const holder = solo_holder(read11);
   if (holder !== void 0) return none_of(children, held_message(holder, repo));
-  return select_candidates(children, read10, repo, occupied);
+  return select_candidates(children, read11, repo, occupied);
 }
 function withhold(result, repo, selection) {
   return {
@@ -5184,9 +5495,9 @@ function withhold(result, repo, selection) {
     waiting: [...result.waiting, ...selection.withheld]
   };
 }
-function gate(result, read10, repo, selector = select) {
+function gate(result, read11, repo, selector = select) {
   if (result.verdict !== "run") return { result };
-  const selection = selector(epic_report.candidates_for_repo(result, repo), read10, repo);
+  const selection = selector(epic_report.candidates_for_repo(result, repo), read11, repo);
   const gated = withhold(result, repo, selection);
   return selection.notice === void 0 ? { result: gated } : { result: gated, notice: selection.notice };
 }
@@ -5227,11 +5538,11 @@ function stale_message(stale, repo) {
     repo
   );
 }
-async function release(read10, repo) {
-  if (read10.kind !== "busy") return { read: read10 };
-  const stale = await find_stale(read10.issues);
-  if (stale.length === 0) return { read: read10 };
-  const holders = read10.issues.filter((issue) => !stale.includes(issue));
+async function release(read11, repo) {
+  if (read11.kind !== "busy") return { read: read11 };
+  const stale = await find_stale(read11.issues);
+  if (stale.length === 0) return { read: read11 };
+  const holders = read11.issues.filter((issue) => !stale.includes(issue));
   const released = holders.length > 0 ? { kind: "busy", issues: holders } : { kind: "idle" };
   return { read: released, notice: stale_message(stale, repo) };
 }
@@ -5279,18 +5590,18 @@ var WAIT_VERDICT = "wait";
 var RUN_VERDICT = "run";
 var NO_LANES3 = 0;
 var ONE_LANE2 = 1;
-function is_held(read10) {
-  return read10.kind === "unreadable" || read10.kind === "truncated";
+function is_held(read11) {
+  return read11.kind === "unreadable" || read11.kind === "truncated";
 }
-function free_lanes2(read10, limit, merge_waiting) {
-  if (is_held(read10)) return NO_LANES3;
-  const holders = epic_busy.occupied_lanes(read10);
+function free_lanes2(read11, limit, merge_waiting) {
+  if (is_held(read11)) return NO_LANES3;
+  const holders = epic_busy.occupied_lanes(read11);
   return lane_capacity.free_lanes(limit, holders - merge_waiting, holders);
 }
-async function merge_waiting_holders(read10, request) {
-  if (read10.kind !== "busy" || !request.is_this_checkout) return NO_LANES3;
+async function merge_waiting_holders(read11, request) {
+  if (read11.kind !== "busy" || !request.is_this_checkout) return NO_LANES3;
   return await lane_snapshot_trace.count_merge_waiting(
-    read10.issues.map((issue) => String(issue.number))
+    read11.issues.map((issue) => String(issue.number))
   );
 }
 async function room_in(occupancy, request) {
@@ -5309,15 +5620,15 @@ function wanted_of(request, free) {
 function withheld_message(repo) {
   return `No runnable child in ${repo}: every candidate was withheld when its blocker relations were confirmed \u2014 the reason for each is above.`;
 }
-function offered_notice(children, read10, request, ages) {
+function offered_notice(children, read11, request, ages) {
   if (children.length === NO_LANES3) return withheld_message(request.repo);
-  if (read10.kind !== "busy") return "";
-  return epic_busy.occupancy_message(read10.issues, request.repo, request.limit, ages);
+  if (read11.kind !== "busy") return "";
+  return epic_busy.occupancy_message(read11.issues, request.repo, request.limit, ages);
 }
-async function holder_ages(read10, repo) {
-  if (read10.kind !== "busy") return /* @__PURE__ */ new Map();
+async function holder_ages(read11, repo) {
+  if (read11.kind !== "busy") return /* @__PURE__ */ new Map();
   return await epic_label_age.read_ages(
-    read10.issues.map((issue) => issue.number),
+    read11.issues.map((issue) => issue.number),
     repo,
     /* @__PURE__ */ new Date()
   );
@@ -5362,17 +5673,17 @@ async function collect(pools, wanted) {
   return { children, verdict: children.length > NO_LANES3 ? RUN_VERDICT : verdict };
 }
 function solo_offer(answer4, occupancy, request, ages) {
-  const { read: read10, use } = occupancy;
+  const { read: read11, use } = occupancy;
   const { offered, notice: notice2 = "" } = epic_solo.select(
     answer4.children,
-    read10,
+    read11,
     request.repo,
     use?.occupied
   );
   if (offered.length === NO_LANES3 && answer4.children.length > NO_LANES3) {
     return { children: [], verdict: WAIT_VERDICT, notice: notice2 };
   }
-  return { ...answer4, children: offered, notice: offered_notice(offered, read10, request, ages) };
+  return { ...answer4, children: offered, notice: offered_notice(offered, read11, request, ages) };
 }
 function triage_offer(pools, request) {
   if (!request.is_all_lanes) return void 0;
@@ -5401,9 +5712,9 @@ async function offer_after_triage(pools, request) {
   );
   if (released.notice !== void 0) console.error(released.notice);
   const occupancy = await epic_lane_occupancy.read(released.read, request.is_this_checkout);
-  const { read: read10 } = occupancy;
+  const { read: read11 } = occupancy;
   const free = await room_in(occupancy, request);
-  const ages = await holder_ages(read10, request.repo);
+  const ages = await holder_ages(read11, request.repo);
   if (free === NO_LANES3) {
     return {
       children: [],
@@ -5594,7 +5905,7 @@ function unreadable_anomaly(snapshot2) {
 function is_order_declared(body, links) {
   return links.length > 0 || epic_parse.has_unordered_declaration(body);
 }
-function decide(snapshot2, paths = /* @__PURE__ */ new Map(), running) {
+function decide2(snapshot2, paths = /* @__PURE__ */ new Map(), running) {
   const links = epic_parse.parse_dependency_links(snapshot2.body);
   const unreadable = body_anomaly(snapshot2) ?? unreadable_anomaly(snapshot2);
   const anomalies = unreadable === void 0 ? epic_graph.find_anomalies(
@@ -5683,16 +5994,16 @@ async function report_epics(views, options, current_repo) {
   );
   return await report2(views, request, current_repo);
 }
-function views_of(reads, running = epic_outside_blocker.running_keys(reads.flatMap((read10) => read10.snapshot.children))) {
+function views_of(reads, running = epic_outside_blocker.running_keys(reads.flatMap((read11) => read11.snapshot.children))) {
   const paths = repo_discovery.discover_repositories(PROJECT_ROOT);
   epic_cross_repo.reset_publish_cache();
   epic_classify.reset_reported();
   return epic_next_views.settle_views(
     running,
-    (settled) => reads.map((read10) => ({
-      ...read10,
+    (settled) => reads.map((read11) => ({
+      ...read11,
       running: settled,
-      result: decide(read10.snapshot, paths, settled)
+      result: decide2(read11.snapshot, paths, settled)
     }))
   );
 }
@@ -5730,7 +6041,7 @@ var epic_next = {
   views_of,
   run: run2,
   run_epics,
-  decide,
+  decide: decide2,
   report: report2
 };
 
@@ -5801,23 +6112,23 @@ var issue_not_before_label = { change_of, sweep, sync, with_label: with_label2 }
 
 // scripts/lane/lane-implement-rate-read.ts
 var PERIOD_DAYS = 3;
-async function read_ledger(context) {
-  const path15 = context.ledger_path ?? await lane_ledger.target();
-  return path15 === void 0 ? [] : lane_ledger.read_entries(path15);
+async function read_ledger2(context) {
+  const path12 = context.ledger_path ?? await lane_ledger.target();
+  return path12 === void 0 ? [] : lane_ledger.read_entries(path12);
 }
 async function implement_rate(context = {}, now_ms = Date.now()) {
   const window = lane_stats.window_of(PERIOD_DAYS, now_ms);
-  return lane_implement_rate.rate(await read_ledger(context), window);
+  return lane_implement_rate.rate(await read_ledger2(context), window);
 }
 async function measurements(context = {}, now_ms = Date.now()) {
-  const entries = await read_ledger(context);
+  const entries = await read_ledger2(context);
   const window = lane_stats.window_of(PERIOD_DAYS, now_ms);
   return {
     implement_rate: lane_implement_rate.rate(entries, window),
     growth: lane_size_stats.ratios(entries, window)
   };
 }
-var lane_implement_rate_read = { PERIOD_DAYS, implement_rate, measurements, read_ledger };
+var lane_implement_rate_read = { PERIOD_DAYS, implement_rate, measurements, read_ledger: read_ledger2 };
 
 // scripts/lane/lane-ledger-archive.ts
 import {
@@ -5848,9 +6159,9 @@ function archive_of(ledger2) {
   return `${ledger2.replace(LEDGER_SUFFIX_PATTERN, "")}${ARCHIVE_SUFFIX}`;
 }
 function is_past(line, cutoff_ms) {
-  const record6 = record_schema.safeParse(json_value.parse_or_undefined(line)).data;
-  if (record6 === void 0 || record6.kind === KIND6.MERGE) return false;
-  return Date.parse(record6.at) < cutoff_ms;
+  const record7 = record_schema.safeParse(json_value.parse_or_undefined(line)).data;
+  if (record7 === void 0 || record7.kind === KIND6.MERGE) return false;
+  return Date.parse(record7.at) < cutoff_ms;
 }
 function partition(text2, cutoff_ms) {
   const archived = [];
@@ -5864,8 +6175,8 @@ function partition(text2, cutoff_ms) {
 }
 function bytes_past(descriptor, from) {
   const buffer = Buffer.alloc(Math.max(fstatSync2(descriptor).size - from, 0));
-  const read10 = readSync2(descriptor, buffer, 0, buffer.length, from);
-  return buffer.subarray(0, read10);
+  const read11 = readSync2(descriptor, buffer, 0, buffer.length, from);
+  return buffer.subarray(0, read11);
 }
 function append_text(target3, text2) {
   const descriptor = openSync2(target3, APPEND_FLAGS, LEDGER_FILE_MODE);
@@ -5897,9 +6208,9 @@ function move(ledger2, moved) {
   }
 }
 function rotate_open(ledger2, descriptor, cutoff_ms) {
-  const read10 = bytes_past(descriptor, 0);
-  const end = read10.lastIndexOf(LINE_SEPARATOR3) + 1;
-  const split = partition(read10.toString("utf8", 0, end), cutoff_ms);
+  const read11 = bytes_past(descriptor, 0);
+  const end = read11.lastIndexOf(LINE_SEPARATOR3) + 1;
+  const split = partition(read11.toString("utf8", 0, end), cutoff_ms);
   if (split.count === 0) return 0;
   const carried = move(ledger2, { ...split, descriptor, end });
   const late = bytes_past(descriptor, carried);
@@ -6304,7 +6615,7 @@ function causes_cell(waits2) {
     count: all.filter((each) => each === cause).length
   }));
   const ranked = counted2.toSorted((left, right) => right.count - left.count);
-  return ranked.length === 0 ? NO_CAUSES : ranked.map(({ cause, count }) => `${cause} ${String(count)}`).join(", ");
+  return ranked.length === 0 ? NO_CAUSES : ranked.map(({ cause, count: count2 }) => `${cause} ${String(count2)}`).join(", ");
 }
 function reason_row(reason2, waits2) {
   const of_reason = waits2.filter((wait) => wait.reason === reason2);
@@ -6574,7 +6885,7 @@ var lane_net_time = {
 };
 
 // scripts/lane/lane-net-read.ts
-var { implement_rate: implement_rate2, measurements: measurements2, read_ledger: read_ledger2 } = lane_implement_rate_read;
+var { implement_rate: implement_rate2, measurements: measurements2, read_ledger: read_ledger3 } = lane_implement_rate_read;
 async function read_events(context) {
   if (context.events_path !== void 0) return run_event_stream.read_events(context.events_path);
   return await run_event_stream_emit.all_events();
@@ -6594,7 +6905,7 @@ var lane_net_read = {
   measurements: measurements2,
   net_minutes_of,
   read_events,
-  read_ledger: read_ledger2,
+  read_ledger: read_ledger3,
   read_records
 };
 
@@ -6615,7 +6926,7 @@ var GATE_PATHS = [
   "cspell.config"
 ];
 function names_gate_path(body) {
-  return GATE_PATHS.some((path15) => body.includes(path15));
+  return GATE_PATHS.some((path12) => body.includes(path12));
 }
 function lane_reason(child) {
   if (!has_label_name(child.labels, BUG_LABEL)) return `it carries no \`${BUG_LABEL}\` label`;
@@ -6922,6 +7233,13 @@ var FIRST_PAGE = 1;
 var SECOND_PAGE = 2;
 var SEARCH_RESULT_CEILING = 1e3;
 var PAGE_CONCURRENCY = 4;
+var WINDOW_READ_LIMIT = 15;
+var MS_PER_SECOND2 = 1e3;
+var MS_PER_DAY4 = 864e5;
+var SPLIT_DIVISOR = 2;
+function skips_pages(first, should_split) {
+  return should_split && first.total_count > SEARCH_RESULT_CEILING;
+}
 var search_item_schema = external_exports.object({
   number: external_exports.number().optional(),
   title: external_exports.string().optional(),
@@ -6946,9 +7264,10 @@ async function read_page(query, page) {
   const raw = await git_gh_exec.exec_gh_api({ path: search_path(query, page) });
   return parse_json.parse_json_object_or_undefined(raw, search_page_schema);
 }
-async function read_pages(query) {
+async function read_pages(query, should_split = false) {
   const first = await read_page(query, FIRST_PAGE);
   if (first === void 0) return void 0;
+  if (skips_pages(first, should_split)) return [first];
   const rest_numbers = Array.from(
     { length: Math.max(page_count(first) - FIRST_PAGE, 0) },
     (_value, index) => index + SECOND_PAGE
@@ -6973,7 +7292,46 @@ function to_result(pages) {
   const issues = pages.flatMap((page) => page.items.map((item) => to_issue(item)));
   const total2 = pages[0]?.total_count ?? 0;
   const is_incomplete = pages.some((page) => page.incomplete_results);
-  return { issues, is_capped: is_incomplete || total2 > issues.length };
+  const numbers = issues.map((issue) => issue.number).filter((number) => number > 0);
+  const has_duplicates = new Set(numbers).size !== numbers.length;
+  return { issues, is_capped: is_incomplete || total2 !== issues.length || has_duplicates };
+}
+function window_query(window) {
+  const original_start = Date.parse(window.qualifier.split(">=").at(-1) ?? "");
+  if (window.is_open && window.start === original_start) return window.query;
+  const start2 = new Date(window.start).toISOString().replace(".000Z", "Z");
+  const end = new Date(window.end - MS_PER_SECOND2).toISOString().replace(".000Z", "Z");
+  const range = window.is_open ? `>=${start2}` : `${start2}..${end}`;
+  return window.query.replace(
+    window.qualifier,
+    () => `${window.qualifier.split(":", 1)[0] ?? ""}:${range}`
+  );
+}
+function merge_windows(results, total2) {
+  const issues = results.flatMap((result) => result.issues);
+  const unique2 = new Map(issues.map((issue) => [issue.number, issue]));
+  const is_capped = results.some((result) => result.is_capped) || unique2.size !== total2 || unique2.size !== issues.length;
+  return { issues: [...unique2.values()], is_capped };
+}
+async function split_window(window, budget, total2, read11) {
+  const middle = Math.floor((window.start + window.end) / SPLIT_DIVISOR / MS_PER_SECOND2) * MS_PER_SECOND2;
+  const left = await read11({ ...window, end: middle, is_open: false }, budget);
+  if (left === void 0) return void 0;
+  const right = await read11({ ...window, start: middle }, budget);
+  return right === void 0 ? void 0 : merge_windows([left, right], total2);
+}
+function can_split(first, window) {
+  return !first.incomplete_results && first.total_count > SEARCH_RESULT_CEILING && window.end - window.start > MS_PER_SECOND2;
+}
+async function read_window(window, budget) {
+  if (budget.remaining === 0) return { issues: [], is_capped: true };
+  budget.remaining -= 1;
+  const pages = await read_pages(window_query(window), true);
+  if (pages === void 0) return void 0;
+  const result = to_result(pages);
+  const [first] = pages;
+  if (first === void 0 || !can_split(first, window)) return result;
+  return await split_window(window, budget, first.total_count, read_window);
 }
 async function search(query) {
   try {
@@ -6983,7 +7341,41 @@ async function search(query) {
     return void 0;
   }
 }
-var issue_search = { search, search_path };
+function rate_qualifier(query) {
+  return /\b(?:created|closed):>=\d{4}-\d{2}-\d{2}\b/u.exec(query)?.[0];
+}
+async function search_complete(query, now_ms = Date.now()) {
+  const qualifier = rate_qualifier(query);
+  if (qualifier === void 0) return await search(query);
+  const start2 = Date.parse(qualifier.split(">=").at(-1) ?? "");
+  const now = (Math.floor(now_ms / MS_PER_DAY4) + 1) * MS_PER_DAY4;
+  const end = Math.max(now, start2 + MS_PER_SECOND2);
+  try {
+    return await read_window(
+      { query, qualifier, start: start2, end, is_open: true },
+      { remaining: WINDOW_READ_LIMIT }
+    );
+  } catch {
+    return void 0;
+  }
+}
+var issue_search = { search, search_complete, search_path };
+
+// scripts/issue/issue-search-count.ts
+var count_schema = external_exports.object({
+  total_count: external_exports.number().int().nonnegative(),
+  incomplete_results: external_exports.literal(false)
+});
+async function count(query) {
+  const parameters = new URLSearchParams({ q: query, per_page: "1" });
+  try {
+    const raw = await git_gh_exec.exec_gh_api({ path: `search/issues?${parameters.toString()}` });
+    return parse_json.parse_json_object_or_undefined(raw, count_schema)?.total_count;
+  } catch {
+    return void 0;
+  }
+}
+var issue_search_count = { count };
 
 // scripts/issue/defect-rate-cli.ts
 var MS_PER_MINUTE2 = 6e4;
@@ -6999,28 +7391,31 @@ var defect_rate_schema = external_exports.object({
   enhancements: external_exports.number(),
   is_capped: external_exports.boolean()
 });
-async function measure_uncached(repo, days, since) {
+async function measure_uncached(repo, days, since, now_ms) {
   const [filed, completed] = await Promise.all([
-    issue_search.search(defect_rate.filed_query(repo, since)),
-    issue_search.search(defect_rate.completed_query(repo, since))
+    issue_search.search_complete(defect_rate.filed_query(repo, since), now_ms),
+    issue_search_count.count(defect_rate.completed_query(repo, since))
   ]);
   if (filed === void 0 || completed === void 0) return void 0;
-  const is_capped = filed.is_capped || completed.is_capped;
-  return defect_rate.measure({
+  return {
     days,
     since,
-    filed: filed.issues,
-    completed: completed.issues,
-    is_capped
-  });
+    defects: filed.issues.filter((issue) => defect_rate.is_defect(issue)).length,
+    enhancements: completed,
+    is_capped: filed.is_capped
+  };
 }
 async function measure_window(repo, days, now_ms) {
   const since = defect_rate.window_start(now_ms, days);
   const key2 = [repo, String(days), since].join(" ");
-  return await shared_cache.remember(
-    { slot: RATE_CACHE, key: key2, schema: defect_rate_schema },
-    async () => await measure_uncached(repo, days, since),
-    now_ms
+  return await run_startup.phase(
+    "defect rate",
+    async () => await shared_cache.remember(
+      { slot: RATE_CACHE, key: key2, schema: defect_rate_schema },
+      async () => await measure_uncached(repo, days, since, now_ms),
+      now_ms
+    ),
+    { edge_of: (value) => value === void 0 ? "failed" : "done" }
   );
 }
 var defect_rate_cli = { RATE_CACHE, measure_window };
@@ -7033,7 +7428,7 @@ function above_message(measured) {
   return `The defect rate ${defect_rate.rate_text(measured)} is above its baseline ${String(defect_rate.BASELINE_RATE)}, so among issues the ranking keys tie, defects are offered first and new mechanisms last.`;
 }
 function should_defer_mechanisms(measured) {
-  if (measured === void 0) {
+  if (measured === void 0 || measured.is_capped) {
     console.error(UNMEASURED_MESSAGE);
     return false;
   }
@@ -7364,11 +7759,11 @@ function yielded_keys(context, directory) {
   );
   return new Set(yielded2.map(({ number }) => epic_graph.key_of({ number, repo: context.repo })));
 }
-async function gate_scope(context, read10 = IDLE) {
+async function gate_scope(context, read11 = IDLE) {
   const { issues } = context.opted_in;
   const directory = process.cwd();
   const declared2 = await backlog_plan_comment.declared_of(issues, directory);
-  const holders = backlog_overlap.running_numbers(read10);
+  const holders = backlog_overlap.running_numbers(read11);
   return {
     standalone: standalone_keys2(context),
     declared: lane_plan.with_holder_plans(declared2, holders, directory),
@@ -7651,8 +8046,8 @@ function shorten(text2) {
 function to_hit(output_line) {
   const groups = GREP_LINE.exec(output_line)?.groups;
   if (groups === void 0) return void 0;
-  const { path: path15, line, text: text2 } = groups;
-  return { path: path15, line, excerpt: shorten(text2) };
+  const { path: path12, line, text: text2 } = groups;
+  return { path: path12, line, excerpt: shorten(text2) };
 }
 function parse3(stdout) {
   const hits = stdout.split("\n").map((line) => to_hit(line));
@@ -7738,8 +8133,8 @@ async function grep(target3) {
 async function find_files(target3) {
   try {
     const stdout = await git_spawn.read(["ls-files", "--", `${FILE_PATHSPEC}${target3}`]);
-    const paths = stdout.split("\n").filter((path15) => path15 !== "");
-    return paths.slice(0, MAX_FILES_PER_TARGET).map((path15) => ({ path: path15, ...FILE_HIT }));
+    const paths = stdout.split("\n").filter((path12) => path12 !== "");
+    return paths.slice(0, MAX_FILES_PER_TARGET).map((path12) => ({ path: path12, ...FILE_HIT }));
   } catch {
     return [];
   }
@@ -8163,22 +8558,22 @@ function offer_order(result, repo, yielded2 = /* @__PURE__ */ new Set()) {
 }
 function select2(input2) {
   const ranked = yielded_first(rank3(input2.candidates, input2.pool), input2.yielded ?? /* @__PURE__ */ new Set());
-  const { read: read10, repo, lanes } = input2;
-  const gated = epic_solo.select(ranked, read10, repo);
+  const { read: read11, repo, lanes } = input2;
+  const gated = epic_solo.select(ranked, read11, repo);
   const separated = backlog_overlap.separate(gated, input2.declared ?? /* @__PURE__ */ new Map(), {
-    read: read10,
+    read: read11,
     repo,
     lanes
   });
   return cap(separated, input2.standalone, input2.limit ?? git_next_issues.DISPLAY_LIMIT);
 }
-function gate2(result, read10, repo, scope) {
+function gate2(result, read11, repo, scope) {
   const pool = everything_in(result);
   return epic_solo.gate(
     result,
-    read10,
+    read11,
     repo,
-    (candidates) => select2({ candidates, pool, read: read10, repo, ...scope })
+    (candidates) => select2({ candidates, pool, read: read11, repo, ...scope })
   );
 }
 var backlog_rank = { everything_in, gate: gate2, offer_order, rank_result, select: select2 };
@@ -8307,24 +8702,24 @@ function references_in(text2, repo, section) {
   return parse_references3(text2, repo).map((number) => ({ number, section }));
 }
 function signal_references(body, repo = "") {
-  const read10 = [
+  const read11 = [
     ...references_in(acceptance_section(body), repo, "acceptance criteria"),
     ...references_in(parent_references(body), repo, "parent line")
   ];
-  return read10.filter((reference, index) => {
-    return read10.findIndex((other) => other.number === reference.number) === index;
+  return read11.filter((reference, index) => {
+    return read11.findIndex((other) => other.number === reference.number) === index;
   });
 }
 function collect_blockers(index, node) {
   const seen = /* @__PURE__ */ new Set();
-  const pending = [...epic_graph.blockers_of(index, node)];
-  while (pending.length > 0) {
-    const current2 = pending.pop() ?? node;
+  const pending2 = [...epic_graph.blockers_of(index, node)];
+  while (pending2.length > 0) {
+    const current2 = pending2.pop() ?? node;
     if (seen.has(current2)) {
       continue;
     }
     seen.add(current2);
-    pending.push(...epic_graph.blockers_of(index, current2));
+    pending2.push(...epic_graph.blockers_of(index, current2));
   }
   return seen;
 }
@@ -8345,10 +8740,10 @@ var epic_audit_logic = {
 };
 
 // scripts/run/pause/run-pause-comment.ts
-var comment_schema = external_exports.object({ body: external_exports.string().nullish() });
+var comment_schema2 = external_exports.object({ body: external_exports.string().nullish() });
 async function has_comment(request) {
   const json = await git_gh_issue_read.issue_list_comments(request.issue);
-  const rows = json === void 0 ? void 0 : parse_json_array_or_undefined(json, comment_schema);
+  const rows = json === void 0 ? void 0 : parse_json_array_or_undefined(json, comment_schema2);
   if (rows === void 0) {
     throw new Error(`the comments on ${session_cite.issue(request.issue)} could not be read`);
   }
@@ -8369,11 +8764,11 @@ var OPEN_PULLS_QUERY = "/pulls?state=open&per_page=100";
 var PULL_FILTER = '.[] | {body: (.body // "")}';
 var ALIAS_PREFIX2 = "i";
 var pull_schema = external_exports.object({ body: external_exports.string() });
-var comment_schema2 = external_exports.looseObject({ body: external_exports.string().nullish() });
+var comment_schema3 = external_exports.looseObject({ body: external_exports.string().nullish() });
 var page_info_schema = external_exports.looseObject({ hasPreviousPage: external_exports.boolean() });
 var comments_schema = external_exports.looseObject({
   pageInfo: page_info_schema,
-  nodes: external_exports.array(comment_schema2)
+  nodes: external_exports.array(comment_schema3)
 });
 var issue_node_schema = external_exports.looseObject({ comments: comments_schema }).nullable();
 var repository_schema2 = external_exports.record(external_exports.string(), issue_node_schema);
@@ -8461,7 +8856,7 @@ async function read_signals(result, repo) {
   ]);
   return { stashed, paused, open_pr };
 }
-async function read5(result, repo) {
+async function read6(result, repo) {
   if (result.verdict !== "run") return result;
   const signals = await read_signals(result, repo);
   const candidates = result.candidates.map((bundle) => ({
@@ -8470,7 +8865,7 @@ async function read5(result, repo) {
   }));
   return { ...result, candidates, waiting: enrich_children(result.waiting, repo, signals) };
 }
-var backlog_resumable = { read: read5 };
+var backlog_resumable = { read: read6 };
 
 // scripts/backlog/backlog-next.ts
 var FAILURE_EXIT_CODE3 = 1;
@@ -8522,7 +8917,7 @@ function settled_views(reads, running, context) {
 function views_from(reads, context, untrusted) {
   if (reads.length === 0) return [];
   const graphs = backlog_pool.trusted_graphs(
-    reads.map((read10) => read10.snapshot.children),
+    reads.map((read11) => read11.snapshot.children),
     untrusted
   );
   return settled_views(
@@ -8538,7 +8933,7 @@ async function resolve(context) {
     console.error(refusal3);
     return void 0;
   }
-  const children = reads.flatMap((read10) => read10.snapshot.children);
+  const children = reads.flatMap((read11) => read11.snapshot.children);
   const untrusted = await auto_ok_author.untrusted_child_keys(children, context.repo);
   const ordered = await backlog_defect_priority.prioritize(
     combine(views_from(reads, context, untrusted), context, untrusted),
@@ -8550,19 +8945,28 @@ function is_transport_failure(result) {
   if (result.verdict !== "error") return false;
   return result.anomalies.some((anomaly) => anomaly.is_unreachable === true);
 }
-async function gate_solo(result, context) {
+async function gate_ready(result, context) {
   if (result.verdict !== "run") return result;
   const { repo } = context;
-  const { read: read10, notice: notice2 } = await epic_solo_stale.release(
+  const { read: read11, notice: notice2 } = await epic_solo_stale.release(
     await epic_busy.read_repository(repo),
     repo
   );
   if (notice2 !== void 0) console.error(notice2);
-  const scope = await backlog_gate_scope.gate_scope(context, read10);
-  const gated = backlog_rank.gate(result, read10, repo, scope);
+  const scope = await backlog_gate_scope.gate_scope(context, read11);
+  const gated = backlog_rank.gate(result, read11, repo, scope);
   if (gated.notice !== void 0) console.error(gated.notice);
   return gated.result;
 }
+function result_edge(value) {
+  if (value === void 0 || value.verdict === "error") return "failed";
+  return value.verdict === "wait" || value.verdict === "stop" ? "waiting" : "done";
+}
+async function gate_solo(result, context) {
+  return await run_startup.phase("eligibility", async () => await gate_ready(result, context), {
+    edge_of: result_edge
+  });
+}
 async function answer_held(result, context, untriaged2) {
   const pre_gate = backlog_next_report.without_untriaged(result, context.repo);
   const gated = await gate_solo(pre_gate, context);
@@ -8570,7 +8974,13 @@ async function answer_held(result, context, untriaged2) {
   return await backlog_next_report.report_held(gated, context, untriaged2);
 }
 async function answer_pool(context) {
-  const resolved = await resolve(context);
+  const resolved = await run_startup.phase(
+    "candidate eligibility",
+    async () => await resolve(context),
+    {
+      edge_of: result_edge
+    }
+  );
   if (resolved === void 0) return FAILURE_EXIT_CODE3;
   if (is_transport_failure(resolved)) {
     await backlog_next_offer.record_retry(context);
@@ -8611,7 +9021,9 @@ async function run3(argv2) {
     console.error(options.usage);
     return FAILURE_EXIT_CODE3;
   }
-  const opted_in = await auto_ok_cli.fetch_opted_in();
+  const opted_in = await run_startup.phase("candidate listing", auto_ok_cli.fetch_opted_in, {
+    edge_of: (value) => value.kind === "read" ? "done" : "failed"
+  });
   if (opted_in.kind !== "read") {
     console.error(READ_FAILURES[opted_in.kind]);
     return FAILURE_EXIT_CODE3;
@@ -8646,6 +9058,13 @@ function is_kept2(result) {
   if (result.code !== SUCCESS_EXIT_CODE5) return false;
   return !result.out.split("\n").includes(backlog_next.VERDICT_TOKENS.retry);
 }
+function edge_of(result) {
+  const [token = ""] = result.out.split("\n", 1);
+  const { error, retry, wait, stop, triage } = backlog_next.VERDICT_TOKENS;
+  const is_failed = [error, retry].includes(token);
+  if (is_failed || result.code !== SUCCESS_EXIT_CODE5) return "failed";
+  return [wait, stop, triage].includes(token) ? "waiting" : "done";
+}
 function replay(result, should_forward_stderr) {
   if (should_forward_stderr && result.err !== void 0 && result.err !== "") {
     console.error(result.err);
@@ -8662,16 +9081,23 @@ function kept_until(key2, now_ms) {
   if (deadline !== void 0) return deadline > now_ms ? kept : void 0;
   return kept;
 }
-async function read6(argv2, should_forward_stderr = false, timeout_ms) {
+async function read7(argv2, should_forward_stderr = false, timeout_ms) {
   const key2 = await stream_key(argv2);
   const now_ms = Date.now();
   const kept = kept_until(key2, now_ms);
   if (kept !== void 0) return replay(kept, should_forward_stderr);
-  const result = await josh_command.josh_run(argv2, should_forward_stderr, timeout_ms);
+  const result = await run_startup.phase(
+    "candidate cache fill",
+    async () => {
+      run_startup.metric("cache", "fill", `${NEXT_CACHE.prefix}:${key2}`);
+      return await josh_command.josh_run(argv2, should_forward_stderr, timeout_ms);
+    },
+    { edge_of }
+  );
   if (is_kept2(result)) shared_cache.write(NEXT_CACHE, key2, result, now_ms);
   return result;
 }
-var backlog_next_shared = { NEXT_CACHE, read: read6, stream_key };
+var backlog_next_shared = { NEXT_CACHE, edge_of, read: read7, stream_key };
 
 // scripts/backlog/backlog-hold-codes.ts
 var OFFER_PREFIX = "offer";
@@ -8680,17 +9106,22 @@ var REASON_SEPARATOR = ":";
 var USAGE_LIMIT_REASON = "usage-limit";
 var MEMORY_REASON = "memory";
 var DRIVERLESS_PREFIX = "driverless:";
+var WATCH_VERDICT = "watch";
+var DRAINED_REASON = "drained";
 var backlog_hold_codes = {
+  DRAINED_REASON,
   DRIVERLESS_PREFIX,
   HAND_BACK_PREFIX,
   MEMORY_REASON,
   OFFER_PREFIX,
   REASON_SEPARATOR,
-  USAGE_LIMIT_REASON
+  USAGE_LIMIT_REASON,
+  WATCH_VERDICT
 };
 
 // scripts/backlog/backlog-hold-text.ts
 var {
+  DRAINED_REASON: DRAINED_REASON2,
   DRIVERLESS_PREFIX: DRIVERLESS_PREFIX2,
   HAND_BACK_PREFIX: HAND_BACK_PREFIX2,
   MEMORY_REASON: MEMORY_REASON2,
@@ -8706,8 +9137,10 @@ var HAND_BACK_TEXT = /* @__PURE__ */ new Map([
   ["merge", "the driver paused after a merge; the session restarts it"],
   ["launch", "a lane launch failed; the session restarts the driver"],
   ["offer", "the backlog offer failed; the session restarts the driver"],
-  ["window", "the run's time window closed; the session restarts the driver"]
+  ["window", "the run's time window closed; the session restarts the driver"],
+  [DRAINED_REASON2, "the backlog had nothing to start; the session restarts the driver"]
 ]);
+var PERSON_HAND_BACKS = /* @__PURE__ */ new Set(["judge", "triage"]);
 var OFFER_TEXT = /* @__PURE__ */ new Map([
   ["solo", "a run:solo issue must finish first"],
   ["blocked", "every queued issue is blocked"],
@@ -8758,7 +9191,12 @@ function text_of2(code) {
   }
   return prefixed_text(code) ?? whole_text(code) ?? code;
 }
-var backlog_hold_text = { text_of: text_of2 };
+function is_driver_restart(code) {
+  const own = code.startsWith(DRIVERLESS_PREFIX2) ? code.slice(DRIVERLESS_PREFIX2.length) : code;
+  const reason2 = rest_after(own, HAND_BACK_PREFIX2);
+  return reason2 !== void 0 && !PERSON_HAND_BACKS.has(reason2);
+}
+var backlog_hold_text = { is_driver_restart, text_of: text_of2 };
 
 // scripts/backlog/backlog-stalled.ts
 var STALL_THRESHOLD_MINUTES = 10;
@@ -8849,8 +9287,8 @@ async function count_in2(room) {
   return { limit: limit.limit, free: free_of(limit.limit, room.use) };
 }
 async function free_lanes_beside(lanes) {
-  const count = await count_in2(await lane_room2(lanes));
-  return count?.free;
+  const count2 = await count_in2(await lane_room2(lanes));
+  return count2?.free;
 }
 async function free_under(limit) {
   return free_of(limit, await lane_use());
@@ -8958,8 +9396,8 @@ async function real_emit_stall(text2) {
   return await run_event_stream_emit.emit_once_since(STALL, text2, CHILD_LAUNCH);
 }
 async function read_real_ledger() {
-  const path15 = await lane_ledger.target();
-  return path15 === void 0 ? [] : lane_ledger.read_entries(path15);
+  const path12 = await lane_ledger.target();
+  return path12 === void 0 ? [] : lane_ledger.read_entries(path12);
 }
 async function real_mark_offerable(is_offerable) {
   await lane_ledger_write.record_offerable(is_offerable);
@@ -9404,10 +9842,10 @@ function read_chunk(source, buffer) {
 function read_all(source = DESCRIPTOR_SOURCE) {
   const buffer = new Uint8Array(CHUNK_BYTES);
   const chunks = [];
-  let count = read_chunk(source, buffer);
-  while (count !== 0) {
-    if (count !== void 0) chunks.push(Buffer.from(buffer.subarray(0, count)));
-    count = read_chunk(source, buffer);
+  let count2 = read_chunk(source, buffer);
+  while (count2 !== 0) {
+    if (count2 !== void 0) chunks.push(Buffer.from(buffer.subarray(0, count2)));
+    count2 = read_chunk(source, buffer);
   }
   return Buffer.concat(chunks).toString("utf8");
 }
@@ -9612,9 +10050,9 @@ async function run_cli() {
 var telegram_test = { fetch_repo_name, fetch_issue_title, resolve_context, run_cli, send_values };
 
 // scripts/run/run-cli-fault.ts
-async function directory_of2(where, read10) {
+async function directory_of2(where, read11) {
   try {
-    return await read10();
+    return await read11();
   } catch (error) {
     error_text.trace_swallowed(where, error);
     return void 0;
@@ -9629,21 +10067,24 @@ var run_cli_fault = { directory_of: directory_of2, message: message2 };
 var MARKED = "marked";
 var FOREIGN = "foreign";
 var UNREADABLE2 = "unreadable";
-function hold_of(read10) {
-  return read10.kind === "held" || read10.kind === "stale" ? read10.hold : void 0;
+function hold_of(read11) {
+  return read11.kind === "held" || read11.kind === "stale" ? read11.hold : void 0;
 }
-function is_halfrun_stop(read10, issue, is_dirty) {
-  const hold = hold_of(read10);
-  return is_dirty && hold?.issue === issue && hold.is_halfrun_stop === true;
+function is_stop_record(read11, issue) {
+  const hold = hold_of(read11);
+  return hold?.issue === issue && hold.is_halfrun_stop === true;
 }
-function is_own_record(read10, issue) {
-  const hold = hold_of(read10);
+function is_halfrun_stop(read11, issue, is_dirty) {
+  return is_dirty && is_stop_record(read11, issue);
+}
+function is_own_record(read11, issue) {
+  const hold = hold_of(read11);
   return hold === void 0 || hold.issue === issue || hold.issue === run_hold.UNNUMBERED_ISSUE;
 }
 function mark_stop_at(target3, issue, mark2 = run_hold.HALFRUN_STOP_FIELDS) {
-  const read10 = run_hold.read_hold(target3);
-  if (read10.kind === "unreadable") return UNREADABLE2;
-  if (!is_own_record(read10, issue)) return FOREIGN;
+  const read11 = run_hold.read_hold(target3);
+  if (read11.kind === "unreadable") return UNREADABLE2;
+  if (!is_own_record(read11, issue)) return FOREIGN;
   run_hold.release_hold(target3);
   return run_hold.create_stop_hold(target3, issue, mark2) ? MARKED : FOREIGN;
 }
@@ -9651,6 +10092,27 @@ function take_over(target3, issue) {
   run_hold.release_hold(target3);
   return run_hold.create_hold(target3, issue, /* @__PURE__ */ new Date(), true);
 }
+function reopen_at(target3, issue) {
+  const read11 = run_hold.read_hold(target3);
+  if (read11.kind === "unreadable") return UNREADABLE2;
+  if (!is_stop_record(read11, issue)) return FOREIGN;
+  run_hold.release_hold(target3);
+  return run_hold.create_hold(target3, issue) ? MARKED : FOREIGN;
+}
+async function resume_lane(issue, command) {
+  const lane = await lane_state.read_state(issue);
+  if (lane?.state === "human-review") {
+    await lane_state.record_change({ issue, state: "running", command });
+  }
+}
+async function reopen(target3, issue) {
+  const mark2 = reopen_at(target3, issue);
+  if (mark2 === MARKED) await resume_lane(issue, "run:hold --halfrun-round");
+  return mark2;
+}
+function no_stop_message(issue) {
+  return `run:hold: this tree holds no stopped \`halfrun\` of ${session_cite.issue(issue)} \u2014 a fix round re-opens only that record.`;
+}
 function adopt_at(target3, issue, is_dirty) {
   if (!is_halfrun_stop(run_hold.read_hold(target3), issue, is_dirty)) return false;
   return take_over(target3, issue);
@@ -9663,7 +10125,7 @@ async function hold_target() {
     return void 0;
   }
 }
-async function is_pending(issue) {
+async function is_pending2(issue) {
   const target3 = await hold_target();
   if (target3 === void 0) return false;
   return is_halfrun_stop(run_hold.read_hold(target3), issue, await run_hold.is_tree_dirty());
@@ -9672,10 +10134,7 @@ async function adopt(issue) {
   const target3 = await hold_target();
   if (target3 === void 0) return false;
   const is_adopted = adopt_at(target3, issue, await run_hold.is_tree_dirty());
-  const lane = is_adopted ? await lane_state.read_state(issue) : void 0;
-  if (lane?.state === "human-review") {
-    await lane_state.record_change({ issue, state: "running", command: "run:entry" });
-  }
+  if (is_adopted) await resume_lane(issue, "run:entry");
   return is_adopted;
 }
 var run_halfrun_resume = {
@@ -9686,8 +10145,11 @@ var run_halfrun_resume = {
   adopt_at,
   hold_of,
   hold_target,
-  is_pending,
+  is_pending: is_pending2,
   mark_stop_at,
+  no_stop_message,
+  reopen,
+  reopen_at,
   take_over
 };
 
@@ -9799,12 +10261,12 @@ var PRRUN_GATE = "prrun-gate";
 function is_untouched(facts) {
   return facts.head === facts.stop_head && facts.pr_head === facts.stop_head && !facts.is_dirty;
 }
-function decide2(facts) {
+function decide3(facts) {
   if (facts.is_merged) return PRRUN_MERGED;
   return is_untouched(facts) ? PRRUN_MERGE : PRRUN_GATE;
 }
-function stop_head_of(read10, issue) {
-  const hold = run_halfrun_resume.hold_of(read10);
+function stop_head_of(read11, issue) {
+  const hold = run_halfrun_resume.hold_of(read11);
   return hold?.issue === issue ? hold.prrun_stop_head : void 0;
 }
 async function read_merge_state() {
@@ -9828,7 +10290,7 @@ async function resume_token(issue) {
   const target3 = await run_halfrun_resume.hold_target();
   if (target3 === void 0) return void 0;
   const stop_head = stop_head_of(run_hold.read_hold(target3), issue);
-  return stop_head === void 0 ? void 0 : decide2(await read_facts(stop_head));
+  return stop_head === void 0 ? void 0 : decide3(await read_facts(stop_head));
 }
 async function adopt2(issue) {
   const target3 = await run_halfrun_resume.hold_target();
@@ -9846,37 +10308,12 @@ var run_prrun_resume = {
   PRRUN_MERGE,
   PRRUN_MERGED,
   adopt: adopt2,
-  decide: decide2,
+  decide: decide3,
   mark_stop_at: mark_stop_at2,
   resume_token,
   stop_head_of
 };
 
-// scripts/gate/input-fingerprint.ts
-import { readFileSync as readFileSync2 } from "node:fs";
-import path6 from "node:path";
-var ABSENT2 = "absent";
-function of_content(content) {
-  return stamp_file.digest(content);
-}
-function of_entries(entries) {
-  return of_content([...entries].toSorted((left, right) => left.localeCompare(right)).join("\n"));
-}
-function of_file(file_path) {
-  try {
-    return of_content(readFileSync2(file_path));
-  } catch {
-    return ABSENT2;
-  }
-}
-function of_files(root, relatives) {
-  const sorted = [...new Set(relatives)].toSorted((left, right) => left.localeCompare(right));
-  return Object.fromEntries(
-    sorted.map((relative) => [relative, of_file(path6.join(root, relative))])
-  );
-}
-var input_fingerprint = { ABSENT: ABSENT2, of_entries, of_file, of_files };
-
 // scripts/review/review-tree.ts
 var ABSENT_DIGEST = input_fingerprint.ABSENT;
 function tree_of(root, paths) {
@@ -10019,8 +10456,8 @@ var ACCEPTANCE_MAP_HEADING = "PR \u672C\u6587\u306E\u53D7\u3051\u5165\u308C\u676
 var REMOVED_TESTS_HEADING = "PR \u672C\u6587\u306E\u6D88\u3048\u305F\u30C6\u30B9\u30C8\u306E\u51E6\u7F6E";
 var CHILD_SUMMARY_PATH = ".claude/skills/workflow-commands/backlogrun-child.md";
 var CHILD_SUMMARY_HEADING = "What the summary carries, and how long it may be";
-function section_pointer(path15, heading) {
-  return `${path15} \u2192 "${heading}" (read it: pnpm josh doc:section ${path15} '${heading}')`;
+function section_pointer(path12, heading) {
+  return `${path12} \u2192 "${heading}" (read it: pnpm josh doc:section ${path12} '${heading}')`;
 }
 function pointer(heading) {
   return section_pointer(REPORT_FORMAT_PATH, heading);
@@ -10236,8 +10673,8 @@ function split_text(text2, budget) {
   }
   return current2.length > 0 ? [...parts, current2] : parts;
 }
-function part_header(relative, index, count) {
-  return `# ${relative} \u2014 part ${String(index + 1)} of ${String(count)}${LINE_BREAK}`;
+function part_header(relative, index, count2) {
+  return `# ${relative} \u2014 part ${String(index + 1)} of ${String(count2)}${LINE_BREAK}`;
 }
 function part_texts(relative, diff, cap2) {
   const budget = Math.max(1, cap2 - part_header(relative, diff.length, diff.length).length);
@@ -10259,7 +10696,7 @@ function reading_block(parts, cap2) {
 var review_diff_parts = { body_of, part_texts, reading_block, split_text };
 
 // scripts/review/review-finding-ledger.ts
-var PREFIX5 = { code: "- rf:", interaction: "- ri:" };
+var PREFIX7 = { code: "- rf:", interaction: "- ri:" };
 var FIELD_SEPARATOR3 = " | ";
 var FIELD_COUNT = 5;
 var DISPOSED_FIELD_COUNT = FIELD_COUNT + 1;
@@ -10309,24 +10746,24 @@ function split_disposition(positional) {
 function issue_field(issue) {
   return issue_cite.plain_for("github", issue);
 }
-function line_of2(fields, kind) {
-  return `${PREFIX5[kind]}${fields.join(FIELD_SEPARATOR3)}`;
+function line_of3(fields, kind) {
+  return `${PREFIX7[kind]}${fields.join(FIELD_SEPARATOR3)}`;
 }
 function finding_line(finding, date, issue, kind = "code") {
   const fields = [finding.category, finding.severity, finding.file, date, issue_field(issue)];
-  return line_of2(
+  return line_of3(
     finding.disposition === void 0 ? fields : [...fields, finding.disposition],
     kind
   );
 }
 function zero_round_line(date, issue, kind = "code") {
-  return line_of2([NONE4, NONE4, NO_FILE, date, issue_field(issue)], kind);
+  return line_of3([NONE4, NONE4, NO_FILE, date, issue_field(issue)], kind);
 }
 function is_finding_line(line, kind = "code") {
-  return line.trimStart().startsWith(PREFIX5[kind]);
+  return line.trimStart().startsWith(PREFIX7[kind]);
 }
 function fields_of(line, kind = "code") {
-  return line.trimStart().slice(PREFIX5[kind].length).split(FIELD_SEPARATOR3);
+  return line.trimStart().slice(PREFIX7[kind].length).split(FIELD_SEPARATOR3);
 }
 function well_formed_fields(line, kind = "code") {
   const fields = fields_of(line, kind);
@@ -10352,7 +10789,7 @@ function tally(content) {
   return counts;
 }
 function category_counts(content) {
-  return [...tally(content)].map(([category, count]) => ({ category, count })).toSorted(
+  return [...tally(content)].map(([category, count2]) => ({ category, count: count2 })).toSorted(
     (left, right) => right.count - left.count || left.category.localeCompare(right.category)
   );
 }
@@ -10466,21 +10903,21 @@ var review_finding_text = {
 };
 
 // scripts/gate/verification-inputs.ts
-import { readFileSync as readFileSync4 } from "node:fs";
-import path10 from "node:path";
+import { readFileSync as readFileSync3 } from "node:fs";
+import path7 from "node:path";
 
 // eslint/config-fingerprint.js
 import { createHash as createHash2 } from "node:crypto";
-import { readFileSync as readFileSync3, realpathSync, statSync as statSync4 } from "node:fs";
+import { readFileSync as readFileSync2, realpathSync, statSync as statSync4 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import path7 from "node:path";
+import path6 from "node:path";
 import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "node:url";
 import { resolve as resolve3 } from "import-meta-resolve";
 import ts from "typescript";
 var HASH_ALGORITHM = "sha256";
 var FINGERPRINT_LENGTH = 32;
 var SETTINGS_KEY = "kit_config_fingerprint";
-var PRESET_DIRECTORY = path7.dirname(fileURLToPath(import.meta.url));
+var PRESET_DIRECTORY = path6.dirname(fileURLToPath(import.meta.url));
 var PRESET_ENTRY = "base.js";
 var MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"];
 var CONFIG_ENTRY_NAMES = MODULE_EXTENSIONS.map((extension) => `eslint.config${extension}`);
@@ -10490,22 +10927,22 @@ function is_file(file) {
 function module_candidates(target3) {
   const typed = target3.replace(/\.([cm]?)js$/u, ".$1ts");
   const bare = MODULE_EXTENSIONS.map((extension) => `${target3}${extension}`);
-  const indexes = MODULE_EXTENSIONS.map((extension) => path7.join(target3, `index${extension}`));
+  const indexes = MODULE_EXTENSIONS.map((extension) => path6.join(target3, `index${extension}`));
   return [target3, typed, ...bare, ...indexes];
 }
 function resolve_module(target3) {
   return module_candidates(target3).find((candidate) => is_file(candidate));
 }
 function is_inside(relative_path) {
-  return relative_path !== "" && !relative_path.startsWith("..") && !path7.isAbsolute(relative_path);
+  return relative_path !== "" && !relative_path.startsWith("..") && !path6.isAbsolute(relative_path);
 }
 function is_local_module(target3) {
-  return path7.isAbsolute(target3) && (!target3.split(path7.sep).includes("node_modules") || is_inside(path7.relative(PRESET_DIRECTORY, target3)));
+  return path6.isAbsolute(target3) && (!target3.split(path6.sep).includes("node_modules") || is_inside(path6.relative(PRESET_DIRECTORY, target3)));
 }
 function keep_path_spelling(file, target3) {
-  const directory = path7.dirname(file);
-  const relative = path7.relative(realpathSync(directory), target3);
-  return path7.resolve(directory, relative);
+  const directory = path6.dirname(file);
+  const relative = path6.relative(realpathSync(directory), target3);
+  return path6.resolve(directory, relative);
 }
 function resolve_es_module(specifier, file) {
   const url = resolve3(specifier, pathToFileURL2(file).href);
@@ -10523,7 +10960,7 @@ function resolve_package_import(file, specifier, resolver) {
   }
 }
 function resolve_import(file, specifier) {
-  const relative = specifier.startsWith(".") ? [resolve_module(path7.resolve(path7.dirname(file), specifier))] : [];
+  const relative = specifier.startsWith(".") ? [resolve_module(path6.resolve(path6.dirname(file), specifier))] : [];
   return [
     ...relative,
     ...resolve_package_import(file, specifier, resolve_es_module),
@@ -10531,41 +10968,41 @@ function resolve_import(file, specifier) {
   ];
 }
 function list_imports(file) {
-  const source = readFileSync3(file, "utf8");
+  const source = readFileSync2(file, "utf8");
   return ts.preProcessFile(source, true, true).importedFiles.flatMap((entry) => resolve_import(file, entry.fileName)).filter((resolved) => resolved !== void 0);
 }
-function visit_module(file, reached, pending) {
+function visit_module(file, reached, pending2) {
   if (reached.has(file) || !is_file(file)) return;
   reached.add(file);
-  pending.push(...list_imports(file));
+  pending2.push(...list_imports(file));
 }
 function list_reachable_modules(entries) {
   const reached = /* @__PURE__ */ new Set();
-  const pending = [...entries];
-  while (pending.length > 0) visit_module(pending.pop(), reached, pending);
+  const pending2 = [...entries];
+  while (pending2.length > 0) visit_module(pending2.pop(), reached, pending2);
   return reached;
 }
 function list_config_entries(project_root) {
-  return CONFIG_ENTRY_NAMES.map((name) => path7.join(project_root, name)).filter(
+  return CONFIG_ENTRY_NAMES.map((name) => path6.join(project_root, name)).filter(
     (file) => is_file(file)
   );
 }
 function default_entries(directory, project_root) {
   const project_entries = project_root === void 0 ? [] : list_config_entries(project_root);
-  return [path7.join(directory, PRESET_ENTRY), ...project_entries];
+  return [path6.join(directory, PRESET_ENTRY), ...project_entries];
 }
 function compare_source_names(left, right) {
   if (left === right) return 0;
   return left < right ? -1 : 1;
 }
 function list_config_sources(directory, entries) {
-  return [...list_reachable_modules(entries)].map((file) => path7.relative(directory, file)).filter((relative_path) => is_inside(relative_path)).map((relative_path) => relative_path.split(path7.sep).join("/")).toSorted(compare_source_names);
+  return [...list_reachable_modules(entries)].map((file) => path6.relative(directory, file)).filter((relative_path) => is_inside(relative_path)).map((relative_path) => relative_path.split(path6.sep).join("/")).toSorted(compare_source_names);
 }
 function compute_config_fingerprint(directory = PRESET_DIRECTORY, entries = default_entries(directory)) {
   const digest = createHash2(HASH_ALGORITHM);
   for (const relative_path of list_config_sources(directory, entries)) {
     digest.update(`${relative_path}\0`);
-    digest.update(readFileSync3(path7.join(directory, relative_path)));
+    digest.update(readFileSync2(path6.join(directory, relative_path)));
     digest.update("\0");
   }
   return digest.digest("hex").slice(0, FINGERPRINT_LENGTH);
@@ -10582,177 +11019,13 @@ var config_fingerprint = {
   list_reachable_modules
 };
 
-// scripts/lint/lint-related-scope.ts
-import path9 from "node:path";
-
-// scripts/git/changed-file-scope.ts
-import path8 from "node:path";
-var UNREADABLE_REASON = "the changed files could not be read";
-var LISTED_FILE_LIMIT = 10;
-async function repository_root_or_cwd() {
-  try {
-    return await git_command.repository_root();
-  } catch {
-    return process.cwd();
-  }
-}
-async function read_changed_files2(root) {
-  try {
-    const relative_paths = await changed_paths.read_changed_paths(false);
-    return relative_paths.map((relative) => path8.join(root, relative));
-  } catch {
-    return void 0;
-  }
-}
-function select_files(paths, inputs) {
-  return paths.filter(
-    (file_path) => inputs.is_selectable(file_path) && inputs.is_present(file_path)
-  );
-}
-function all_scope(reason2) {
-  return { mode: "all", files: [], reason: reason2 };
-}
-function resolve_scope(paths, inputs) {
-  if (paths === void 0) return all_scope(UNREADABLE_REASON);
-  const files = select_files(paths, inputs);
-  if (files.length === 0) return all_scope(inputs.nothing_reason);
-  return { mode: "related", files, reason: `${String(files.length)} changed file(s)` };
-}
-function format_file_list(files, root) {
-  const listed = files.slice(0, LISTED_FILE_LIMIT).map((file) => `  - ${path8.relative(root, file)}`);
-  const hidden = files.length - listed.length;
-  if (hidden > 0) listed.push(`  \u2026 and ${String(hidden)} more`);
-  return listed.join("\n");
-}
-function describe_scope(scope, root, vocabulary) {
-  if (scope.mode === "all") {
-    return `${vocabulary.label}: ${scope.reason} \u2014 ${vocabulary.fallback_suffix}.`;
-  }
-  return `${vocabulary.label}: ${scope.reason} \u2014 ${vocabulary.narrowed_suffix}.
-${format_file_list(scope.files, root)}`;
-}
-var ARGV_START = 2;
-var FLAG_PREFIX = "-";
-function is_flag(argument) {
-  return argument.startsWith(FLAG_PREFIX);
-}
-function explicit_files_of(command_arguments) {
-  return command_arguments.filter((argument) => !is_flag(argument));
-}
-function flags_of(command_arguments) {
-  return command_arguments.filter((argument) => is_flag(argument));
-}
-async function resolve_command_scope(request) {
-  const explicit_files = explicit_files_of(request.command_arguments);
-  if (explicit_files.length === 0) {
-    return resolve_scope(await read_changed_files2(request.root), request.inputs);
-  }
-  return resolve_scope(
-    explicit_files.map((file) => path8.resolve(file)),
-    request.inputs
-  );
-}
-function report_unusable_arguments(command_arguments, scope, label2) {
-  const narrowed = new Set(scope.files);
-  const unusable = explicit_files_of(command_arguments).filter(
-    (file) => !narrowed.has(path8.resolve(file))
-  );
-  if (unusable.length === 0) return;
-  process.stdout.write(`${label2}: ignored \u2014 not a file this check reads: ${unusable.join(" ")}
-`);
-}
-var changed_file_scope = {
-  ARGV_START,
-  LISTED_FILE_LIMIT,
-  UNREADABLE_REASON,
-  describe_scope,
-  flags_of,
-  format_file_list,
-  is_flag,
-  read_changed_files: read_changed_files2,
-  report_unusable_arguments,
-  repository_root_or_cwd,
-  resolve_command_scope,
-  resolve_scope,
-  select_files
-};
-
-// scripts/lint/lint-related-scope.ts
-var LINTABLE_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".ts",
-  ".tsx",
-  ".mts",
-  ".cts",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs",
-  ".svelte",
-  ".vue",
-  ".md",
-  ".mdx",
-  ".json",
-  ".jsonc",
-  ".json5",
-  ".yaml",
-  ".yml",
-  ".css",
-  ".scss",
-  ".less",
-  ".html",
-  ".graphql",
-  ".gql"
-]);
-var NOTHING_LINTABLE_REASON = "no changed file is one prettier or eslint reads";
-var COMMAND_NAME = "lint:related";
-var COMMAND_LABEL = `josh ${COMMAND_NAME}`;
-var VOCABULARY = {
-  label: COMMAND_LABEL,
-  fallback_suffix: "checking the whole tree instead",
-  narrowed_suffix: "checking only them"
-};
-var PRETTIER_ARGS = ["exec", "prettier", "--check", "--ignore-unknown"];
-var ESLINT_ARGS = ["exec", "eslint"];
-var ESLINT_SCOPED_FLAGS = ["--no-warn-ignored"];
-function is_lintable(file_path) {
-  return LINTABLE_EXTENSIONS.has(path9.extname(file_path));
-}
-function scope_inputs(is_present2) {
-  return { is_present: is_present2, is_selectable: is_lintable, nothing_reason: NOTHING_LINTABLE_REASON };
-}
-function describe_scope2(scope, root) {
-  return changed_file_scope.describe_scope(scope, root, VOCABULARY);
-}
-var RELATED_CACHES = {
-  eslint_file: ESLINT_RELATED_CACHE_FILE,
-  eslint_flags: ESLINT_RELATED_CACHE_FLAGS,
-  prettier_flags: PRETTIER_RELATED_CACHE_FLAGS
-};
-function prettier_arguments(files, caches = RELATED_CACHES, directory = process.cwd()) {
-  const targets = project_checks.prettier_targets(directory, files);
-  return [...PRETTIER_ARGS, ...targets, ...caches.prettier_flags];
-}
-function eslint_arguments(files, caches = RELATED_CACHES) {
-  return [...ESLINT_ARGS, ...files, ...caches.eslint_flags, ...ESLINT_SCOPED_FLAGS];
-}
-var lint_related_scope = {
-  COMMAND_LABEL,
-  NOTHING_LINTABLE_REASON,
-  RELATED_CACHES,
-  describe_scope: describe_scope2,
-  eslint_arguments,
-  is_lintable,
-  prettier_arguments,
-  scope_inputs
-};
-
 // scripts/gate/verification-inputs.ts
 var GIT_IGNORE = ".gitignore";
 var PRETTIER_IGNORE = ".prettierignore";
 var PRETTIER_IGNORE_FILES = [GIT_IGNORE, PRETTIER_IGNORE];
 var MANIFEST = "package.json";
 var TOOLCHAIN_FILES = /* @__PURE__ */ new Set([
-  ...toolchain_inputs.PACKAGE_FILES.map((relative) => path10.basename(relative)),
+  ...toolchain_inputs.PACKAGE_FILES.map((relative) => path7.basename(relative)),
   ".editorconfig",
   ...PRETTIER_IGNORE_FILES
 ]);
@@ -10777,9 +11050,9 @@ var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
 ]);
 var MARKDOWN_EXTENSION = ".md";
 var COMMON_ENV = ["NODE_ENV"];
-var ABSENT3 = "absent";
+var ABSENT2 = "absent";
 function is_source(relative) {
-  return SOURCE_EXTENSIONS.has(path10.extname(relative));
+  return SOURCE_EXTENSIONS.has(path7.extname(relative));
 }
 async function is_lint_input(relative, is_ignored) {
   if (is_source(relative)) return true;
@@ -10790,14 +11063,14 @@ async function is_source_input(relative) {
   return is_source(relative);
 }
 async function is_metrics_input(relative) {
-  return is_source(relative) || path10.extname(relative) === MARKDOWN_EXTENSION;
+  return is_source(relative) || path7.extname(relative) === MARKDOWN_EXTENSION;
 }
 function configures_toolchain(relative) {
-  const name = path10.basename(relative);
+  const name = path7.basename(relative);
   return TOOLCHAIN_FILES.has(name) || name.startsWith(PRETTIER_CONFIG_PREFIX);
 }
 function names_any(relative, prefixes) {
-  const name = path10.basename(relative);
+  const name = path7.basename(relative);
   return configures_toolchain(relative) || prefixes.some((prefix) => name.startsWith(prefix));
 }
 function configures_compiler(relative) {
@@ -10809,7 +11082,7 @@ function configures_tests(relative) {
 function read_lint_config_modules(root) {
   const entries = config_fingerprint.list_config_entries(root);
   const modules = [...config_fingerprint.list_reachable_modules(entries)];
-  return new Set(modules.map((file) => path10.relative(root, file).split(path10.sep).join("/")));
+  return new Set(modules.map((file) => path7.relative(root, file).split(path7.sep).join("/")));
 }
 var lint_config_modules_by_root = /* @__PURE__ */ new Map();
 function lint_config_modules(root) {
@@ -10878,23 +11151,23 @@ function configures(label2, relatives, root = PROJECT_ROOT) {
 function tool_version(root, tool) {
   try {
     const manifest = JSON.parse(
-      readFileSync4(path10.join(root, "node_modules", tool, MANIFEST), "utf8")
+      readFileSync3(path7.join(root, "node_modules", tool, MANIFEST), "utf8")
     );
-    return typeof manifest === "object" && manifest !== null && "version" in manifest ? String(manifest.version) : ABSENT3;
+    return typeof manifest === "object" && manifest !== null && "version" in manifest ? String(manifest.version) : ABSENT2;
   } catch {
-    return ABSENT3;
+    return ABSENT2;
   }
 }
 function entries_of2(declaration, root, environment) {
   return [
     ...declaration.tools.map((tool) => `tool:${tool}=${tool_version(root, tool)}`),
-    ...declaration.env.map((name) => `env:${name}=${environment[name] ?? ABSENT3}`)
+    ...declaration.env.map((name) => `env:${name}=${environment[name] ?? ABSENT2}`)
   ];
 }
 function fingerprint(labels, root = PROJECT_ROOT, environment = process.env) {
-  const declarations2 = labels.flatMap((label2) => DECLARATIONS.get(label2) ?? []);
+  const declarations3 = labels.flatMap((label2) => DECLARATIONS.get(label2) ?? []);
   const entries = new Set(
-    declarations2.flatMap((declaration) => entries_of2(declaration, root, environment))
+    declarations3.flatMap((declaration) => entries_of2(declaration, root, environment))
   );
   return input_fingerprint.of_entries(entries);
 }
@@ -11000,7 +11273,7 @@ var round_schema = external_exports.object({
 function target2(root) {
   return stamp_file.stamp_path("josh-review-fix-round-", root);
 }
-function read7(root) {
+function read8(root) {
   const raw = stamp_file.read_stamp_text(target2(root)) ?? "";
   return round_schema.safeParse(json_value.parse_or_undefined(raw)).data;
 }
@@ -11012,7 +11285,7 @@ function snapshot(round) {
   }
 }
 function resume(checkout) {
-  const round = read7(checkout.root);
+  const round = read8(checkout.root);
   const stamp = round === void 0 ? void 0 : snapshot(round);
   if (stamp === void 0 || !review_attest.is_briefed_since(stamp.taken_at, checkout.root)) {
     return void 0;
@@ -11039,7 +11312,7 @@ function correspondence(previous, current2) {
     (row2) => `- rx:${JSON.stringify({ round: current2.id, previous: previous?.id, ...row2, status: review_finding_ledger.is_closing(row2.disposition) ? "resolved" : row2.status })}`
   );
 }
-function prepare(issue, findings, root) {
+function prepare2(issue, findings, root) {
   const stamp = review_stamps.briefed_stamp.read();
   if (stamp === void 0 || !review_attest.is_briefed_since(stamp.taken_at, root)) return void 0;
   return {
@@ -11053,7 +11326,7 @@ function save(round, root) {
   stamp_file.write_stamp(target2(root), round);
 }
 function lines(round, root) {
-  return round === void 0 ? [] : correspondence(read7(root), round);
+  return round === void 0 ? [] : correspondence(read8(root), round);
 }
 function record_reasons(issue, findings) {
   review_stop_log.record({
@@ -11070,8 +11343,8 @@ function record_reasons(issue, findings) {
 var review_fix_round = {
   correspondence,
   lines,
-  prepare,
-  read: read7,
+  prepare: prepare2,
+  read: read8,
   record_reasons,
   resume,
   save,
@@ -11080,32 +11353,32 @@ var review_fix_round = {
 
 // scripts/review/review-readers-scan.ts
 var HUNK_HEADER = /^@@ -\d+(?:,\d+)? \+(?<start>\d+)(?:,(?<count>\d+))? @@/u;
-var DECLARATION4 = /^(?:export\s+)?(?:async\s+)?(?:function\*?|const|let|class|type|interface|enum)\s+(?<name>\w+)/u;
+var DECLARATION5 = /^(?:export\s+)?(?:async\s+)?(?:function\*?|const|let|class|type|interface|enum)\s+(?<name>\w+)/u;
 var EXPORT_LIST = /^export\s+(?:type\s+)?\{(?<names>[^}]*)\}/gmu;
 var IDENTIFIER = /^(?:type\s+)?(?<name>\w+)/u;
 var DIRECT_EXPORT = /^export\s/u;
 var LIST_SEPARATOR3 = ",";
 var PREAMBLE = /^(?:\s*$|\s*\/[/*]|\s+\*)/u;
 var TWO = 2;
-function to_range(start2, count) {
-  return Array.from({ length: count }, (_unused, offset) => start2 + offset);
+function to_range(start2, count2) {
+  return Array.from({ length: count2 }, (_unused, offset) => start2 + offset);
 }
 function hunk_lines(header3) {
   const groups = HUNK_HEADER.exec(header3)?.groups;
   if (groups === void 0) return [];
   const start2 = Number(groups["start"]);
-  const count = groups["count"] === void 0 ? 1 : Number(groups["count"]);
-  return count === 0 ? [start2] : to_range(start2, count);
+  const count2 = groups["count"] === void 0 ? 1 : Number(groups["count"]);
+  return count2 === 0 ? [start2] : to_range(start2, count2);
 }
 function changed_lines(diff) {
   return diff.split("\n").flatMap((line) => hunk_lines(line));
 }
 function to_declaration(text2, index) {
-  const name = DECLARATION4.exec(text2)?.groups?.["name"];
+  const name = DECLARATION5.exec(text2)?.groups?.["name"];
   if (name === void 0) return void 0;
   return { name, line: index + 1, is_exported: DIRECT_EXPORT.test(text2) };
 }
-function declarations(source) {
+function declarations2(source) {
   const found = source.split("\n").map((text2, index) => to_declaration(text2, index));
   return found.filter((entry) => entry !== void 0);
 }
@@ -11141,7 +11414,7 @@ function range_end(texts, next) {
   return end;
 }
 function touched(source, lines2) {
-  const found = declarations(source);
+  const found = declarations2(source);
   const texts = source.split("\n");
   return found.filter((declaration, index) => {
     const end = range_end(texts, found[index + 1]?.line);
@@ -11169,7 +11442,7 @@ function edited(source, diff) {
   return found_targets.filter((entry) => entry.target !== void 0);
 }
 function reachable_names(source) {
-  const found = declarations(source);
+  const found = declarations2(source);
   const direct = found.filter((declaration) => declaration.is_exported).map((entry) => entry.name);
   const exported = /* @__PURE__ */ new Set([...exported_names(source), ...direct]);
   const members = [...namespaces(source, exported).values()].flat();
@@ -11178,7 +11451,7 @@ function reachable_names(source) {
 }
 var review_readers_scan = {
   changed_lines,
-  declarations,
+  declarations: declarations2,
   edited,
   exported_names,
   reachable_names
@@ -11186,8 +11459,8 @@ var review_readers_scan = {
 
 // scripts/review/review-round-one-blobs.ts
 import { existsSync as existsSync2 } from "node:fs";
-import path11 from "node:path";
-var ABSENT4 = review_tree.ABSENT_DIGEST;
+import path8 from "node:path";
+var ABSENT3 = review_tree.ABSENT_DIGEST;
 var SUCCESS_EXIT_CODE6 = 0;
 var NUL = "\0";
 var NEWLINE = "\n";
@@ -11200,16 +11473,16 @@ function repository_root() {
   return git_spawn_sync.read(["rev-parse", "--show-toplevel"]);
 }
 function hash_paths(root, paths, flags) {
-  const present = paths.filter((relative) => existsSync2(path11.join(root, relative)));
+  const present = paths.filter((relative) => existsSync2(path8.join(root, relative)));
   const output2 = present.length === 0 ? "" : git_spawn_sync.read(["hash-object", ...flags, "--", ...present], { cwd: root });
   if (output2 === void 0) return void 0;
   const hashes = output2.split(NEWLINE);
-  const hashed = new Map(present.map((relative, index) => [relative, hashes[index] ?? ABSENT4]));
-  return Object.fromEntries(paths.map((relative) => [relative, hashed.get(relative) ?? ABSENT4]));
+  const hashed = new Map(present.map((relative, index) => [relative, hashes[index] ?? ABSENT3]));
+  return Object.fromEntries(paths.map((relative) => [relative, hashed.get(relative) ?? ABSENT3]));
 }
 function parse_entry(entry) {
   const tab = entry.indexOf(TAB);
-  return [entry.slice(tab + 1), entry.slice(0, tab).split(SPACE)[OID_FIELD] ?? ABSENT4];
+  return [entry.slice(tab + 1), entry.slice(0, tab).split(SPACE)[OID_FIELD] ?? ABSENT3];
 }
 function blobs_at(commit, paths, root) {
   const result = git_spawn_sync.run(["ls-tree", "-r", "-z", commit, "--", ...paths], { cwd: root });
@@ -11219,7 +11492,7 @@ function blobs_at(commit, paths, root) {
   );
 }
 function merged_blob({ base, round_one, moved }, root) {
-  if ([base, round_one, moved].includes(ABSENT4)) return void 0;
+  if ([base, round_one, moved].includes(ABSENT3)) return void 0;
   return git_spawn_sync.read(["merge-file", "--object-id", round_one, base, moved], { cwd: root });
 }
 function carried_blob(sides, root) {
@@ -11228,11 +11501,11 @@ function carried_blob(sides, root) {
   return merged_blob(sides, root);
 }
 function sides_of(relative, readings) {
-  const base = readings.before[relative] ?? ABSENT4;
+  const base = readings.before[relative] ?? ABSENT3;
   return {
     base,
     round_one: readings.blobs[relative] ?? base,
-    moved: readings.after[relative] ?? ABSENT4
+    moved: readings.after[relative] ?? ABSENT3
   };
 }
 function carried_answer(relative, readings, root) {
@@ -11287,7 +11560,7 @@ function unmoved_between(from, to, paths, root) {
   const before = blobs_at(from, paths, root);
   const after = blobs_at(to, paths, root);
   if (before === void 0 || after === void 0) return void 0;
-  return paths.filter((relative) => (before[relative] ?? ABSENT4) === (after[relative] ?? ABSENT4));
+  return paths.filter((relative) => (before[relative] ?? ABSENT3) === (after[relative] ?? ABSENT3));
 }
 function unmoved({ from, to, paths }) {
   const root = repository_root();
@@ -11363,9 +11636,9 @@ function block2(round, paths, root) {
 var review_fix_hunks = { block: block2, resumed_block, RESUMED_HEADING };
 
 // scripts/review/review-code-tree.ts
-import { readFileSync as readFileSync5 } from "node:fs";
+import { readFileSync as readFileSync4 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import path12 from "node:path";
+import path9 from "node:path";
 
 // scripts/review/comment-ranges.ts
 var COMMENT_OPENINGS = ["//", "/*"];
@@ -11510,7 +11783,7 @@ function is_source2(relative) {
 }
 function load_typescript(root) {
   try {
-    return createRequire3(path12.join(root, PACKAGE_JSON))(TYPESCRIPT_MODULE);
+    return createRequire3(path9.join(root, PACKAGE_JSON))(TYPESCRIPT_MODULE);
   } catch {
     return void 0;
   }
@@ -11524,7 +11797,7 @@ function inert_digest(api) {
 }
 function code_digest(digest, root, relative) {
   try {
-    return digest(readFileSync5(path12.join(root, relative), "utf8"), relative);
+    return digest(readFileSync4(path9.join(root, relative), "utf8"), relative);
   } catch {
     return void 0;
   }
@@ -11549,12 +11822,12 @@ function tree_of2(root, paths, api = load_typescript(root)) {
   if (api === void 0) return {};
   return digests_of(root, paths, (text2, relative) => text_digest(api, text2, relative));
 }
-async function read8(paths, root) {
+async function read9(paths, root) {
   return tree_of2(root ?? await git_command.repository_root(), paths);
 }
-async function record3(paths, base, target3, root) {
+async function record4(paths, base, target3, root) {
   try {
-    review_stamps.round_one_code_stamp.write(await read8(paths, root), target3, base);
+    review_stamps.round_one_code_stamp.write(await read9(paths, root), target3, base);
   } catch {
     review_stamps.clear_round_one_code(target3);
   }
@@ -11572,18 +11845,18 @@ async function inert_since(base, paths, root, api) {
   if (typescript === void 0) return [];
   const digest = inert_digest(typescript);
   const tree = digests_of(checkout, paths, digest);
-  const sources = Object.keys(tree);
+  const sources2 = Object.keys(tree);
   const digests = await Promise.all(
-    sources.map(async (relative) => await base_digest(digest, base, relative))
+    sources2.map(async (relative) => await base_digest(digest, base, relative))
   );
-  return sources.filter((relative, index) => digests[index] === tree[relative]);
+  return sources2.filter((relative, index) => digests[index] === tree[relative]);
 }
 var review_code_tree = {
   comment_only,
   inert_since,
   load_typescript,
-  read: read8,
-  record: record3,
+  read: read9,
+  record: record4,
   tree_of: tree_of2
 };
 
@@ -11656,8 +11929,8 @@ var INERT_PATHS = [
 ];
 var INERT_PREFIXES = [];
 var INERT_SUFFIXES = [".code-workspace"];
-function is_inert(path15) {
-  const normalized2 = path15.trim();
+function is_inert(path12) {
+  const normalized2 = path12.trim();
   return INERT_PATHS.includes(normalized2) || INERT_PREFIXES.some((prefix) => normalized2.startsWith(prefix)) || INERT_SUFFIXES.some((suffix) => normalized2.endsWith(suffix));
 }
 function is_reduced_path(relative) {
@@ -11667,13 +11940,13 @@ function is_tiny(changed_lines2) {
   return changed_lines2 !== void 0 && changed_lines2 >= 0 && changed_lines2 <= TINY_CHANGE_LINES;
 }
 function level_for(paths, changed_lines2) {
-  const changed = paths.map((path15) => path15.trim()).filter((path15) => path15 !== "");
+  const changed = paths.map((path12) => path12.trim()).filter((path12) => path12 !== "");
   if (changed.length === 0) return DEFAULT_LEVEL;
   if (changed.every((relative) => is_reduced_path(relative))) return REDUCED_LEVEL;
   return is_tiny(changed_lines2) ? REDUCED_LEVEL : DEFAULT_LEVEL;
 }
 function deciding_paths(paths) {
-  return paths.map((path15) => path15.trim()).filter((path15) => path15 !== "" && !is_reduced_path(path15));
+  return paths.map((path12) => path12.trim()).filter((path12) => path12 !== "" && !is_reduced_path(path12));
 }
 function format_reason(paths, level) {
   if (level === REDUCED_LEVEL) {
@@ -11768,7 +12041,7 @@ function fix_delta(input2, snapshot2) {
   }
   return input2.carried_delta?.(snapshot2);
 }
-function decide3(input2) {
+function decide4(input2) {
   if (!input2.is_round_one_closed) {
     return required(CODE.OPEN_FINDING, input2.open_reason ?? OPEN_FINDING_REASON);
   }
@@ -11790,7 +12063,7 @@ function parse_json2(text2) {
 var review_round2 = {
   BASE_MOVED_REASON,
   CODE,
-  decide: decide3,
+  decide: decide4,
   EMPTY_DELTA_REASON_PREFIX,
   empty_reason,
   INERT_DELTA_REASON_PREFIX,
@@ -11904,7 +12177,7 @@ function parse_round(argv2) {
 function from_brief(brief, fallback = "1") {
   return brief.split("\n").includes(FINAL_LINE) ? "2" : fallback;
 }
-function record4(round, root) {
+function record5(round, root) {
   const pointer2 = review_attest.read_pointer(root);
   if (pointer2 === void 0) return;
   stamp_file.write_text_stamp(stamp_file.stamp_path(ROUND_PREFIX2, pointer2.nonce), String(round));
@@ -11917,7 +12190,7 @@ function current(root) {
 var review_round = {
   current,
   from_brief,
-  record: record4,
+  record: record5,
   parse_round,
   FINAL_LINE,
   FULL_CHANGE_FLAG,
@@ -11925,8 +12198,8 @@ var review_round = {
 };
 
 // scripts/review/review-untouched-readers.ts
-import { readFileSync as readFileSync6 } from "node:fs";
-import path13 from "node:path";
+import { readFileSync as readFileSync5 } from "node:fs";
+import path10 from "node:path";
 var SOURCE_FILE = /\.(?:ts|js)$/u;
 var SEARCH_PATHS = ["*.ts", "*.js", "*.svelte", ":(exclude)*.snap"];
 var WORD_FLAG = "-w";
@@ -11944,7 +12217,7 @@ async function file_edits(request, relative) {
   const diff = await git_spawn.read(["-C", root, "diff", "-U0", "--no-color", base, "--", relative]);
   if (diff.length === 0) return { relative, edits: [] };
   try {
-    const source = readFileSync6(path13.join(root, relative), "utf8");
+    const source = readFileSync5(path10.join(root, relative), "utf8");
     return { relative, edits: review_readers_scan.edited(source, diff) };
   } catch {
     return { relative, edits: [] };
@@ -11958,10 +12231,10 @@ async function readers_of(request, entry, edit) {
   const found = await git_grep_hits.search(edit.target, [WORD_FLAG], pathspecs, request.root);
   return { target: edit.target, origin: `${entry.relative}:${String(edit.line)}`, ...found };
 }
-async function read9(request) {
-  const sources = request.paths.filter((relative) => SOURCE_FILE.test(relative));
+async function read10(request) {
+  const sources2 = request.paths.filter((relative) => SOURCE_FILE.test(relative));
   const files = await Promise.all(
-    sources.map(async (relative) => await file_edits(request, relative))
+    sources2.map(async (relative) => await file_edits(request, relative))
   );
   const pairs = files.flatMap((entry) => entry.edits.map((edit) => ({ entry, edit })));
   const capped2 = pairs.slice(0, MAX_NAMES);
@@ -11999,7 +12272,7 @@ var review_untouched_readers = {
   HEADING: HEADING3,
   MAX_NAMES,
   OMITTED_TAIL,
-  read: read9,
+  read: read10,
   READ_FAILED
 };
 
@@ -12112,8 +12385,8 @@ function dropped_line(root, dropped) {
   return `Not in this change, so not a target here \u2014 the comparison offered them and \`git diff\` does not list them:
 ${format_paths2(root, dropped)}`;
 }
-function carried_line(root, base, count) {
-  return `${String(count)} further file(s) this change touches are byte-identical to round 1 and were read there, so they are deliberately out of scope. Reconcile before you report: \`git -C ${root} diff --name-only ${base}\` plus the untracked files beside it is this change, and every path in it is either a target above or one of those.`;
+function carried_line(root, base, count2) {
+  return `${String(count2)} further file(s) this change touches are byte-identical to round 1 and were read there, so they are deliberately out of scope. Reconcile before you report: \`git -C ${root} diff --name-only ${base}\` plus the untracked files beside it is this change, and every path in it is either a target above or one of those.`;
 }
 function reconciliation(root, base, scope) {
   return [
@@ -12225,7 +12498,7 @@ var review_brief = {
 };
 
 // scripts/test/test-e2e-stamp.ts
-function record5(tree, target3) {
+function record6(tree, target3) {
   try {
     review_stamps.e2e_stamp.write(tree.files, target3, tree.base);
   } catch {
@@ -12239,7 +12512,7 @@ function is_current(tree, source) {
 async function is_current_tree() {
   return is_current(await gate_tree.read_gate_tree());
 }
-var test_e2e_stamp = { is_current, is_current_tree, record: record5 };
+var test_e2e_stamp = { is_current, is_current_tree, record: record6 };
 
 // scripts/run/hold/run-hold-adopt.ts
 var ADOPTED = "adopted";
@@ -12247,9 +12520,9 @@ var NO_RECORD = "none";
 var FOREIGN2 = "foreign";
 var UNREADABLE3 = "unreadable";
 function rekey(target3, issue) {
-  const read10 = run_hold.read_hold(target3);
-  if (read10.kind === "unreadable") return UNREADABLE3;
-  const hold = run_halfrun_resume.hold_of(read10);
+  const read11 = run_hold.read_hold(target3);
+  if (read11.kind === "unreadable") return UNREADABLE3;
+  const hold = run_halfrun_resume.hold_of(read11);
   if (hold === void 0) return NO_RECORD;
   if (hold.issue !== run_hold.UNNUMBERED_ISSUE && hold.issue !== issue) return FOREIGN2;
   stamp_file.write_stamp(target3, { ...hold, issue });
@@ -12286,10 +12559,10 @@ async function stale_block(hold, issue) {
   if (is_own_unstopped(hold, issue)) return void 0;
   return await run_hold.is_tree_dirty() ? run_hold.uncommitted_message(hold) : void 0;
 }
-async function blocking_message(read10, issue) {
-  if (read10.kind === "held") return held_block(read10.hold, issue);
-  if (read10.kind === "unreadable") return run_hold.unreadable_message();
-  return read10.kind === "stale" ? await stale_block(read10.hold, issue) : void 0;
+async function blocking_message(read11, issue) {
+  if (read11.kind === "held") return held_block(read11.hold, issue);
+  if (read11.kind === "unreadable") return run_hold.unreadable_message();
+  return read11.kind === "stale" ? await stale_block(read11.hold, issue) : void 0;
 }
 var run_hold_block = { blocking_message };
 
@@ -12433,11 +12706,12 @@ var RELEASE_FLAG = "--release";
 var FORCE_FLAG = "--force";
 var FULLRUN_FLAG = "--fullrun";
 var HALFRUN_STOP_FLAG = "--halfrun-stop";
+var HALFRUN_ROUND_FLAG = "--halfrun-round";
 var PRRUN_STOP_FLAG = "--prrun-stop";
 var HUMAN_REVIEW_STOP_FLAG = "--human-review-stop";
 var ADOPT_FLAG = "--adopt";
 var MAX_CLAIM_ARGUMENTS = 2;
-var USAGE5 = "Usage: josh run:hold [<issue-number> [--fullrun | --halfrun-stop | --human-review-stop | --prrun-stop]] | josh run:hold --adopt <issue-number> | josh run:release [<issue-number> | --force]";
+var USAGE5 = "Usage: josh run:hold [<issue-number> [--fullrun | --halfrun-stop | --halfrun-round | --human-review-stop | --prrun-stop]] | josh run:hold --adopt <issue-number> | josh run:release [<issue-number> | --force]";
 var COMMAND = "run:hold";
 var HOLD_VERDICT = "hold";
 var BUSY_VERDICT = "busy";
@@ -12451,6 +12725,7 @@ var HALFRUN_STOP_KIND = "halfrun-stop";
 var HUMAN_REVIEW_STOP_KIND = "human-review-stop";
 var PRRUN_STOP_KIND = "prrun-stop";
 var ADOPT_KIND = "adopt";
+var HALFRUN_ROUND_KIND = "halfrun-round";
 var STOP_KINDS = /* @__PURE__ */ new Set([
   HALFRUN_STOP_KIND,
   HUMAN_REVIEW_STOP_KIND,
@@ -12459,6 +12734,10 @@ var STOP_KINDS = /* @__PURE__ */ new Set([
 function is_stop_request(request) {
   return STOP_KINDS.has(request.kind);
 }
+var TAKE_OVER_KINDS = /* @__PURE__ */ new Set([ADOPT_KIND, HALFRUN_ROUND_KIND]);
+function is_take_over_request(request) {
+  return TAKE_OVER_KINDS.has(request.kind);
+}
 var FORCE_RELEASE_REQUEST = { kind: FORCE_RELEASE_KIND };
 function release_request(claimant) {
   return { kind: "release", claimant };
@@ -12472,6 +12751,7 @@ function numbered_claim(issue, flag2) {
   if (flag2 === void 0) return { kind: "claim", issue };
   const stop_kind = STOP_KIND_BY_FLAG.get(flag2);
   if (stop_kind !== void 0) return { kind: stop_kind, issue };
+  if (flag2 === HALFRUN_ROUND_FLAG) return { kind: HALFRUN_ROUND_KIND, issue };
   return flag2 === FULLRUN_FLAG ? { kind: "claim", issue, is_fullrun: true } : void 0;
 }
 function parse_claim(argv2) {
@@ -12523,9 +12803,9 @@ function replace_stale(target3, request, hold) {
   run_hold.release_hold(target3);
   return take_free_tree(target3, request);
 }
-function take_tree(target3, request, read10) {
-  if (read10.kind === "held") return report_hold();
-  return read10.kind === "stale" ? replace_stale(target3, request, read10.hold) : take_free_tree(target3, request);
+function take_tree(target3, request, read11) {
+  if (read11.kind === "held") return report_hold();
+  return read11.kind === "stale" ? replace_stale(target3, request, read11.hold) : take_free_tree(target3, request);
 }
 function report_preflight(decision) {
   console.error(`${decision.reason}
@@ -12545,10 +12825,10 @@ async function claim2(target3, request, is_linked) {
     async () => await preflight_gate(request.issue, is_linked)
   );
   if (gate3 !== void 0) return gate3;
-  const read10 = run_hold.read_hold(target3);
-  const blocked = await run_hold_block.blocking_message(read10, request.issue);
+  const read11 = run_hold.read_hold(target3);
+  const blocked = await run_hold_block.blocking_message(read11, request.issue);
   if (blocked !== void 0) return report_busy(blocked);
-  const code = await run_ship_lap.timed("take_tree", async () => take_tree(target3, request, read10));
+  const code = await run_ship_lap.timed("take_tree", async () => take_tree(target3, request, read11));
   if (code === SUCCESS_EXIT_CODE7) run_maintenance.sweep();
   return code;
 }
@@ -12564,10 +12844,10 @@ function report_unreadable_record() {
   return report5(run_hold.unreadable_message(), UNKNOWN_VERDICT, FAILURE_EXIT_CODE6);
 }
 function release_record(target3, claimant) {
-  const read10 = run_hold.read_hold(target3);
-  if (read10.kind === "free") return remove_record(target3, false);
-  if (read10.kind === "unreadable") return report_unreadable_record();
-  if (!run_hold.is_own_hold(read10.hold, claimant)) return report_held2(read10.hold);
+  const read11 = run_hold.read_hold(target3);
+  if (read11.kind === "free") return remove_record(target3, false);
+  if (read11.kind === "unreadable") return report_unreadable_record();
+  if (!run_hold.is_own_hold(read11.hold, claimant)) return report_held2(read11.hold);
   return remove_record(target3, true);
 }
 async function release2(target3, claimant) {
@@ -12577,11 +12857,11 @@ async function release2(target3, claimant) {
   return code;
 }
 function force_release(target3) {
-  const read10 = run_hold.read_hold(target3);
-  if (read10.kind === "held" || read10.kind === "stale") {
-    console.error(run_hold.forced_release_message(read10.hold));
+  const read11 = run_hold.read_hold(target3);
+  if (read11.kind === "held" || read11.kind === "stale") {
+    console.error(run_hold.forced_release_message(read11.hold));
   }
-  return remove_record(target3, read10.kind !== "free");
+  return remove_record(target3, read11.kind !== "free");
 }
 function report_unknown() {
   return report5(run_hold.unknown_message(), UNKNOWN_VERDICT, FAILURE_EXIT_CODE6);
@@ -12631,9 +12911,19 @@ async function adopt4(target3, issue) {
   }
   return report5(run_hold_adopt.foreign_message(issue), BUSY_VERDICT, FAILURE_EXIT_CODE6);
 }
+async function reopen_round(target3, issue) {
+  const result = await run_halfrun_resume.reopen(target3, issue);
+  if (result === run_halfrun_resume.MARKED) return report_hold();
+  if (result === run_halfrun_resume.UNREADABLE) return report_unreadable_record();
+  return report5(run_halfrun_resume.no_stop_message(issue), BUSY_VERDICT, FAILURE_EXIT_CODE6);
+}
+async function take_over2(target3, request) {
+  const { kind, issue } = request;
+  return kind === ADOPT_KIND ? await adopt4(target3, issue) : await reopen_round(target3, issue);
+}
 async function dispatch(request, target3, is_linked) {
   if (request.kind === "claim") return await claim2(target3, request, is_linked);
-  if (request.kind === ADOPT_KIND) return await adopt4(target3, request.issue);
+  if (is_take_over_request(request)) return await take_over2(target3, request);
   if (is_stop_request(request)) return await mark_stop(target3, request);
   if (request.kind === FORCE_RELEASE_KIND) return force_release(target3);
   return await release2(target3, request.claimant);
@@ -12913,7 +13203,7 @@ var run_cut_report = {
 };
 
 // scripts/run/carry/run-carry-ended.ts
-import path14 from "node:path";
+import path11 from "node:path";
 var ENDED_PREFIX = durable_state.PREFIX.ENDED;
 var TRANSCRIPT_SUFFIX = ".jsonl";
 var ended_run_schema = external_exports.object({
@@ -12928,17 +13218,17 @@ function ended_path(git_directory) {
   return durable_state.path(ENDED_PREFIX, git_directory);
 }
 function session_of(transcript) {
-  return transcript === void 0 ? void 0 : path14.basename(transcript, TRANSCRIPT_SUFFIX);
+  return transcript === void 0 ? void 0 : path11.basename(transcript, TRANSCRIPT_SUFFIX);
 }
 function stop_of(transcript, stopped) {
   return stopped === void 0 ? {} : { stopped, session: session_of(transcript) };
 }
-function record_ended(target3, read10, now = /* @__PURE__ */ new Date(), stopped) {
-  if (read10.kind !== "carried") return;
-  const { invocation, started_at, owner_transcript } = read10.carry;
+function record_ended(target3, read11, now = /* @__PURE__ */ new Date(), stopped) {
+  if (read11.kind !== "carried") return;
+  const { invocation, started_at, owner_transcript } = read11.carry;
   const ended_at = now.toISOString();
   stamp_file.replace_stamp(target3, {
-    ...read10.carry.scheduler_provider && { scheduler_provider: read10.carry.scheduler_provider },
+    ...read11.carry.scheduler_provider && { scheduler_provider: read11.carry.scheduler_provider },
     invocation,
     started_at,
     ended_at,
@@ -12981,6 +13271,7 @@ var run_wake_schema = process_owner_schema.extend({
   started_at: external_exports.string(),
   woke: external_exports.number(),
   woke_at: external_exports.string().optional(),
+  launch_at: external_exports.string().optional(),
   // Every optional `RunWake` field must be listed: `z.object` strips undeclared ones on the round trip.
   attempts: external_exports.number().optional(),
   woke_pid: external_exports.number().optional(),
@@ -13007,7 +13298,7 @@ function decide_not_handed_off(input2) {
   if (input2.is_owner_live) return WAIT_DECISION;
   return decide_launch(input2);
 }
-function decide4(input2) {
+function decide5(input2) {
   if (input2.read.kind !== "carried") return { kind: "stop", reason: STOP_REASONS[input2.read.kind] };
   if (input2.read.carry.is_handed_off !== true) return decide_not_handed_off(input2);
   return decide_launch(input2);
@@ -13048,6 +13339,7 @@ function carried_state(existing, invocation) {
   return {
     woke: existing.woke,
     woke_at: existing.woke_at,
+    launch_at: existing.launch_at,
     attempts: existing.attempts,
     woke_pid: existing.woke_pid,
     spawned: existing.spawned,
@@ -13090,6 +13382,7 @@ function count_claim(wake) {
   return {
     ...wake,
     woke,
+    launch_at: wake.woke_at ?? wake.launch_at,
     woke_at: void 0,
     attempts: void 0,
     idle_since: void 0
@@ -13121,7 +13414,7 @@ var run_wake = {
   claim: claim3,
   count_claim,
   count_wake,
-  decide: decide4,
+  decide: decide5,
   fresh_wake,
   is_supervisor_live,
   mark_idle,
@@ -13203,11 +13496,11 @@ var DEFAULT_PORTS4 = {
   notify_stranded: real_notify_stranded
 };
 function input_at(ports, targets) {
-  const read10 = ports.read_carry(targets.carry);
-  if (read10.kind !== "carried") return void 0;
+  const read11 = ports.read_carry(targets.carry);
+  if (read11.kind !== "carried") return void 0;
   return {
-    read: read10,
-    is_owner_live: ports.is_owner_live(read10.carry),
+    read: read11,
+    is_owner_live: ports.is_owner_live(read11.carry),
     supervisor: ports.supervisor_liveness(ports.read_wake(targets.wake))
   };
 }
@@ -13245,11 +13538,11 @@ function ports_with(same_process) {
   };
 }
 function is_left_stranded(run6, ports = DEFAULT_PORTS4) {
-  const read10 = ports.read_carry(run6.carry_target);
-  if (read10.kind !== "carried") return !ports.has_ended(run6.ended_target, run6.started_at);
+  const read11 = ports.read_carry(run6.carry_target);
+  if (read11.kind !== "carried") return !ports.has_ended(run6.ended_target, run6.started_at);
   return run_stranded.is_stranded({
-    read: read10,
-    is_owner_live: run_carry.is_held_by_another(read10.carry, ports.is_owner_live),
+    read: read11,
+    is_owner_live: run_carry.is_held_by_another(read11.carry, ports.is_owner_live),
     supervisor: run_stranded.GONE
   });
 }
@@ -13353,8 +13646,8 @@ async function carried_owner_live() {
   try {
     const directory = await run_carry.repository_directory();
     if (directory === void 0) return void 0;
-    const read10 = run_carry.read_carry(run_carry.carry_path(directory));
-    return read10.kind === "carried" ? run_carry.is_owner_live(read10.carry) : void 0;
+    const read11 = run_carry.read_carry(run_carry.carry_path(directory));
+    return read11.kind === "carried" ? run_carry.is_owner_live(read11.carry) : void 0;
   } catch {
     return void 0;
   }