@joshuafolkken/kit 1.1383.0 → 1.1387.0

package/dist/hooks/{chunk-6AC4C2IO.js → chunk-GNDJ7NJ7.js}

@@ -6,9 +6,9 @@ import {
   lane_child_invocation,
   repo_discovery,
   repo_origin,
-  repository_lock,
-  run_ship_stage
-} from "./chunk-2X2ART5G.js";
+  run_event_stream,
+  run_event_stream_emit
+} from "./chunk-U32VSRNG.js";
 import {
   error_text
 } from "./chunk-CDY4NFQG.js";
@@ -30,10 +30,10 @@ import {
   time_density_hook,
   time_shell,
   time_transcript_line
-} from "./chunk-TT742SIO.js";
+} from "./chunk-SL4GQ2XP.js";
 import {
   lane_child_marker
-} from "./chunk-Y5R47QHU.js";
+} from "./chunk-J3KSS7II.js";
 import {
   agent_session_environment,
   backlog_budget,
@@ -41,9 +41,8 @@ import {
   git_command,
   has_timed_out,
   json_value,
-  process_identity,
-  run_carry
-} from "./chunk-4MGHBTOM.js";
+  process_identity
+} from "./chunk-2YSW3CXH.js";
 import {
   COMMAND_TIMEOUT_MS,
   stamp_file
@@ -1061,406 +1060,7 @@ var lane_background = {
 // scripts/run/ship/run-ship-detach.ts
 import { randomUUID } from "node:crypto";
 import { setTimeout as sleep } from "node:timers/promises";
-
-// scripts/run/event/run-event-stream.ts
 import { z as z4 } from "zod";
-var EVENT_PREFIX = "josh-run-events-";
-var EVENT_SUFFIX = ".jsonl";
-var EVENT_CAP = 500;
-var FIRST_POSITION = 0;
-var POSITION_INCREMENT = 1;
-var LINE_SEPARATOR = "\n";
-var WORD_SEPARATOR = " ";
-var STAGE_PHASE_INDEX = 2;
-var LOCK_SUFFIX = ".lock";
-var LOCK_WAIT_MS = 5e3;
-var EVENT_KIND = {
-  PLAN: "plan",
-  CHILD_LAUNCH: "child-launch",
-  MERGE: "merge",
-  PARK: "park",
-  SPLIT: "split",
-  OUTAGE: "outage",
-  CUT: "cut",
-  // A fresh session adopted an implementation cut — `run:cut --resume` answered `resume-impl`. The
-  // resume clears the cut record, so without this the `cut` would stay the newest position and
-  // `run:step` would keep answering the resume command it had just run.
-  RESUME: "resume",
-  // The backlog emptied while nothing of the run's own was in flight — the drain. It marks the position
-  // at which the end-of-run retrospective is owed, *before* the idle watch opens, so `run:step` fires
-  // the retrospective at the drain rather than after the watch runs its course. It is not itself a
-  // stop: the run watches on once the retrospective has run, and the real `STOP` follows when the watch
-  // expires.
-  DRAIN: "drain",
-  STOP: "stop",
-  PR_OPENED: "pr-opened",
-  REVIEW_ROUND: "review-round",
-  // The end-of-run retrospective's result, recorded when the run marks the retrospective done. A
-  // retrospective that files zero improvements and one that never ran look
-  // the same from outside — no new Issue either way — so the result is put on the stream the report is
-  // generated from: the issues filed (or that none were), and the candidates dropped with why. It is
-  // emitted from the `run:carry --retrospective` close, so marking the retrospective done and recording
-  // what it found are one action rather than two the run could do only one of.
-  RETROSPECTIVE: "retrospective",
-  // Ready backlog work is sitting undispatched while a lane is free and nothing has dispatched for a
-  // while. Emitted once per stall episode by the stop-time detector, it is both the dedup marker —
-  // `emit_once_since` refuses a second until a `CHILD_LAUNCH` intervenes — and the line a terminal
-  // reader following the stream sees. `run:step` reads it as `backlog:next`, so a run that
-  // stalled is pointed straight at dispatching the work rather than left waiting.
-  STALL: "stall",
-  // The run's own driver is gone: the cut handed the budget off, the owner has died, and no supervisor
-  // is watching. Emitted once per strand episode by the stop-time detector,
-  // exactly as `STALL` is — the newest-event dedup keeps a run polled every stop from notifying more
-  // than once, and a terminal reader following the stream sees the line. The strand is the step before
-  // the stall: a stalled run still has a driver that could dispatch, a stranded one has none.
-  STRANDED: "stranded",
-  // One `josh ship` stage starting, succeeding or failing. It is a trace of the
-  // composite's progress rather than a position the run is at — the positions a ship leaves behind are
-  // the closed issue its `followup` merges, or a detached supervisor's `SHIP_LAUNCH` / `SHIP_STOP` below
-  // — so it is one of the `TRACE_KINDS` the last-event read skips.
-  SHIP_STAGE: "ship-stage",
-  // One progress watcher line — the `at … / next …` heartbeat `run:progress` prints. Printed only to
-  // the watcher's own output, a headless successor's heartbeat would be buried in its log after a cut;
-  // on the stream it reaches the attached session's relay. It says
-  // the run is alive rather than where it is, so it is a trace kind like `SHIP_STAGE`.
-  HEARTBEAT: "heartbeat",
-  // The post-implementation region handed to a detached `josh ship --detach` supervisor. Unlike a stage
-  // trace it is a position: the agent has ended and the
-  // supervisor carries the run, so `run:step` answers `wait` until it stops or the issue closes.
-  SHIP_LAUNCH: "ship-launch",
-  // The supervisor stopped at a failed stage — a red gate, a High/Medium review, a failed push, red CI
-  // The position that hands control back: `run:step` prints the command that
-  // shows the stopped report, so the agent fixes it and relaunches rather than rebuilding the context.
-  SHIP_STOP: "ship-stop",
-  // An Issue the run filed on its way, written by `issue:file`, so a run started from the command line
-  // still surfaces what it found — `run:board`'s findings section reads it.
-  FILED: "filed",
-  // A one-line observation short of an Issue, written with `run:event --append note` and shown in the
-  // same section.
-  NOTE: "note",
-  // A lane child reached a phase no other event marks — its first implementation edit, written by the
-  // PreToolUse hook — so `run:board` draws how far the child has got. A trace,
-  // like `SHIP_STAGE`: it says where the child's work is, not where the run is.
-  LANE_PHASE: "lane-phase",
-  // An issue `run:add` put into the live run. The parent's `--wait` watcher
-  // ends on it, so the issue takes the next free lane without waiting out the arrival probe's minute. A
-  // trace: it says what the run was handed, not where the run is.
-  ADD: "add",
-  // `josh lane:limit` raised a live run's lane limit. The `--wait` watcher's
-  // arrival probe reads it as a wake: the lanes a raise frees are new room for a pool its baseline
-  // already holds. A trace: it says the run gained room, not where the run is.
-  LANE_LIMIT: "lane-limit"
-};
-var EVENT_KINDS = Object.values(EVENT_KIND);
-var TRACE_KINDS = /* @__PURE__ */ new Set([
-  EVENT_KIND.SHIP_STAGE,
-  EVENT_KIND.HEARTBEAT,
-  EVENT_KIND.FILED,
-  EVENT_KIND.NOTE,
-  EVENT_KIND.LANE_PHASE,
-  EVENT_KIND.ADD,
-  EVENT_KIND.LANE_LIMIT
-]);
-var DISPOSABLE_KINDS = /* @__PURE__ */ new Set([EVENT_KIND.SHIP_STAGE, EVENT_KIND.HEARTBEAT]);
-var event_schema = z4.object({
-  pos: z4.number(),
-  at: z4.string(),
-  kind: z4.string(),
-  text: z4.string()
-});
-function is_event_kind(value) {
-  return EVENT_KINDS.includes(value);
-}
-function target_of(repository) {
-  return stamp_file.stamp_path(EVENT_PREFIX, repository, EVENT_SUFFIX);
-}
-function is_present(event) {
-  return event !== void 0;
-}
-function parse_line(line) {
-  return event_schema.safeParse(json_value.parse_or_undefined(line)).data;
-}
-function read_lines(target) {
-  const raw = stamp_file.read_stamp_text(target);
-  if (raw === void 0) return [];
-  return raw.split(LINE_SEPARATOR).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => parse_line(line)).filter(is_present);
-}
-function read_events(target) {
-  return read_lines(target).filter((event) => is_event_kind(event.kind));
-}
-function last_position(events) {
-  return events[events.length - POSITION_INCREMENT]?.pos ?? FIRST_POSITION;
-}
-function issue_of(event) {
-  return event.text.split(WORD_SEPARATOR)[FIRST_POSITION] ?? "";
-}
-function newest_stages(events) {
-  const newest = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    if (event.kind === EVENT_KIND.SHIP_STAGE) newest.set(issue_of(event), event);
-  }
-  return new Set(newest.values());
-}
-function is_stage_start(event) {
-  if (event.kind !== EVENT_KIND.SHIP_STAGE) return false;
-  return event.text.split(WORD_SEPARATOR)[STAGE_PHASE_INDEX] === run_ship_stage.PHASE.START;
-}
-function droppable(events) {
-  const kept = newest_stages(events);
-  const disposable = events.filter((event) => DISPOSABLE_KINDS.has(event.kind) && !kept.has(event));
-  return [
-    ...disposable.filter((event) => !is_stage_start(event)),
-    ...disposable.filter((event) => is_stage_start(event))
-  ];
-}
-function bounded(events) {
-  const excess = events.length - EVENT_CAP;
-  if (excess <= 0) return events;
-  const dropped = new Set(droppable(events).slice(0, excess));
-  return events.filter((event) => !dropped.has(event)).slice(-EVENT_CAP);
-}
-function serialize(events) {
-  return `${events.map((event) => JSON.stringify(event)).join(LINE_SEPARATOR)}${LINE_SEPARATOR}`;
-}
-function append_held(target, event) {
-  const position = last_position(read_lines(target)) + POSITION_INCREMENT;
-  const events = bounded([...read_events(target), { pos: position, ...event }]);
-  stamp_file.replace_text_stamp(target, serialize(events));
-  return position;
-}
-function append(target, kind, text2, at) {
-  if (!is_event_kind(kind)) return { appended: false, position: FIRST_POSITION };
-  const lock = `${target}${LOCK_SUFFIX}`;
-  const position = repository_lock.with_lock_sync(
-    () => append_held(target, { at, kind, text: text2 }),
-    lock,
-    LOCK_WAIT_MS
-  );
-  if (position === void 0) {
-    const message = `run event stream: gave up waiting for the lock at ${lock}`;
-    process.stderr.write(`${message}
-`);
-    throw new Error(message);
-  }
-  return { appended: true, position };
-}
-function read_from(target, position) {
-  const events = read_events(target);
-  return {
-    events: events.filter((event) => event.pos > position),
-    next_position: last_position(events)
-  };
-}
-function read_last(target) {
-  return read_events(target).findLast((event) => !TRACE_KINDS.has(event.kind));
-}
-function has_since(events, kind, reset_kind) {
-  const reset_at = events.findLastIndex((event) => event.kind === reset_kind);
-  return events.slice(reset_at + POSITION_INCREMENT).some((event) => event.kind === kind);
-}
-var FIELD_SEPARATOR = " \xB7 ";
-function format_event(event) {
-  return [event.at, event.kind, event.text].join(FIELD_SEPARATOR);
-}
-var run_event_stream = {
-  EVENT_CAP,
-  EVENT_KIND,
-  EVENT_KINDS,
-  TRACE_KINDS,
-  append,
-  format_event,
-  has_since,
-  is_stage_start,
-  read_events,
-  read_from,
-  read_last,
-  target_of
-};
-
-// scripts/run/event/run-event-scope.ts
-var SINCE_SCOPE = "since";
-var UNKNOWN_SCOPE = "unknown";
-var UNKNOWN_EVENT_SCOPE = { kind: UNKNOWN_SCOPE };
-function moment_of(at) {
-  const parsed = Date.parse(at);
-  return Number.isNaN(parsed) ? void 0 : parsed;
-}
-function is_within(event, floor) {
-  const at = moment_of(event.at);
-  return at !== void 0 && at >= floor;
-}
-function scoped_events(events, scope) {
-  if (scope.kind === UNKNOWN_SCOPE) return void 0;
-  const floor = moment_of(scope.started_at);
-  if (floor === void 0) return void 0;
-  return events.filter((event) => is_within(event, floor));
-}
-function scope_of(read) {
-  if (read.kind !== "carried") return UNKNOWN_EVENT_SCOPE;
-  return { kind: SINCE_SCOPE, started_at: read.carry.started_at };
-}
-function last_scoped_event(events, scope) {
-  return scoped_events(events, scope)?.findLast(
-    (event) => !run_event_stream.TRACE_KINDS.has(event.kind)
-  );
-}
-var SHIP_POSITION_KINDS = /* @__PURE__ */ new Set([
-  run_event_stream.EVENT_KIND.SHIP_LAUNCH,
-  run_event_stream.EVENT_KIND.SHIP_STOP
-]);
-var KIND = run_event_stream.EVENT_KIND;
-var BATCH_RECORD_KINDS = /* @__PURE__ */ new Set([
-  KIND.CHILD_LAUNCH,
-  KIND.PARK,
-  KIND.SPLIT,
-  KIND.RETROSPECTIVE,
-  KIND.STRANDED
-]);
-var ISSUE_REFERENCE = /#(\d+)/u;
-function is_foreign_ship_event(event, issue2) {
-  return SHIP_POSITION_KINDS.has(event.kind) && !event.text.startsWith(`${issue_cite.plain(issue2)} `);
-}
-function is_own_ship_event(event, issue2) {
-  return SHIP_POSITION_KINDS.has(event.kind) && !is_foreign_ship_event(event, issue2);
-}
-function issue_named(event) {
-  return ISSUE_REFERENCE.exec(event.text)?.[1];
-}
-function names_issue(event, issue2) {
-  return issue_named(event) === issue2;
-}
-function is_lane_position(event, issue2) {
-  return !BATCH_RECORD_KINDS.has(event.kind) && names_issue(event, issue2);
-}
-function since_own_launch(events, issue2) {
-  const launch2 = events.findLastIndex(
-    (event) => event.kind === KIND.CHILD_LAUNCH && names_issue(event, issue2)
-  );
-  return events.slice(launch2 + 1);
-}
-function is_foreign_event(event, issue2, is_lane_child) {
-  if (is_lane_child) return !is_lane_position(event, issue2);
-  return is_foreign_ship_event(event, issue2);
-}
-function last_issue_event(events, scope, issue2, is_lane_child) {
-  const attempt = is_lane_child ? since_own_launch(events, issue2) : events;
-  const own = attempt.filter((event) => !is_foreign_event(event, issue2, is_lane_child));
-  if (scope.kind === SINCE_SCOPE) return last_scoped_event(own, scope);
-  return own.findLast((event) => is_own_ship_event(event, issue2));
-}
-var LAUNCH_OR_SETTLE_KINDS = /* @__PURE__ */ new Set([
-  KIND.CHILD_LAUNCH,
-  KIND.MERGE,
-  KIND.PARK,
-  KIND.SPLIT
-]);
-function is_merge_owed(events, scope, issue2) {
-  const newest = (scoped_events(events, scope) ?? []).findLast(
-    (event) => LAUNCH_OR_SETTLE_KINDS.has(event.kind) && names_issue(event, issue2)
-  );
-  return newest?.kind === KIND.CHILD_LAUNCH;
-}
-var run_event_scope = {
-  UNKNOWN_EVENT_SCOPE,
-  is_merge_owed,
-  issue_named,
-  last_issue_event,
-  last_scoped_event,
-  moment_of,
-  scope_of,
-  scoped_events,
-  since_own_launch
-};
-
-// scripts/run/event/run-event-stream-emit.ts
-function now_iso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-async function stream_target() {
-  const repository = await run_carry.repository_directory();
-  return repository === void 0 ? void 0 : run_event_stream.target_of(repository);
-}
-async function emit(kind, text2) {
-  try {
-    const target = await stream_target();
-    if (target === void 0) return;
-    run_event_stream.append(target, kind, text2, now_iso());
-  } catch {
-  }
-}
-async function emit_once(kind, text2) {
-  try {
-    const target = await stream_target();
-    if (target === void 0 || run_event_stream.read_last(target)?.kind === kind) return false;
-    return run_event_stream.append(target, kind, text2, now_iso()).appended;
-  } catch (error) {
-    error_text.trace_swallowed("run_event_stream_emit.emit_once", error);
-    return false;
-  }
-}
-function invocation_events(repository, target) {
-  const events = run_event_stream.read_events(target);
-  const scope = run_event_scope.scope_of(run_carry.read_carry(run_carry.carry_path(repository)));
-  return run_event_scope.scoped_events(events, scope) ?? events;
-}
-async function emit_once_since(kind, text2, reset_kind) {
-  try {
-    const repository = await run_carry.repository_directory();
-    if (repository === void 0) return false;
-    const target = run_event_stream.target_of(repository);
-    if (run_event_stream.has_since(invocation_events(repository, target), kind, reset_kind)) {
-      return false;
-    }
-    return run_event_stream.append(target, kind, text2, now_iso()).appended;
-  } catch (error) {
-    error_text.trace_swallowed("run_event_stream_emit.emit_once_since", error);
-    return false;
-  }
-}
-async function emit_heartbeat(line) {
-  await emit(run_event_stream.EVENT_KIND.HEARTBEAT, line);
-}
-async function current_events() {
-  try {
-    const repository = await run_carry.repository_directory();
-    if (repository === void 0) return [];
-    const read = run_carry.read_carry(run_carry.carry_path(repository));
-    const scope = run_event_scope.scope_of(read);
-    const events = run_event_stream.read_events(run_event_stream.target_of(repository));
-    return run_event_scope.scoped_events(events, scope) ?? [];
-  } catch {
-    return [];
-  }
-}
-async function invocation_or_all_events() {
-  try {
-    const repository = await run_carry.repository_directory();
-    return repository === void 0 ? [] : invocation_events(repository, run_event_stream.target_of(repository));
-  } catch {
-    return [];
-  }
-}
-async function all_events() {
-  try {
-    const target = await stream_target();
-    return target === void 0 ? [] : run_event_stream.read_events(target);
-  } catch {
-    return [];
-  }
-}
-var run_event_stream_emit = {
-  all_events,
-  current_events,
-  emit,
-  emit_heartbeat,
-  emit_once,
-  emit_once_since,
-  invocation_or_all_events,
-  stream_target
-};
-
-// scripts/run/ship/run-ship-detach.ts
-import { z as z5 } from "zod";
 var LOG_PREFIX = "josh-ship-log-";
 var PID_PREFIX = "josh-ship-pid-";
 var BODY_PREFIX = "josh-ship-notify-";
@@ -1481,14 +1081,14 @@ var RESULT_PREFIX = "josh-ship-result-";
 var RECORD_POLL_MS = 25;
 var RECORD_WAIT_ATTEMPTS = 200;
 var CLAIM_WINDOW_MS = 12e4;
-var ship_record_schema = z5.object({
-  pid: z5.number().int().positive().optional(),
-  process_start: z5.string().optional(),
-  launched_at: z5.number().optional(),
-  launcher_pid: z5.number().int().positive().optional(),
-  launcher_start: z5.string().optional(),
-  launch_id: z5.string(),
-  result: z5.enum(["success", "failed"]).optional()
+var ship_record_schema = z4.object({
+  pid: z4.number().int().positive().optional(),
+  process_start: z4.string().optional(),
+  launched_at: z4.number().optional(),
+  launcher_pid: z4.number().int().positive().optional(),
+  launcher_start: z4.string().optional(),
+  launch_id: z4.string(),
+  result: z4.enum(["success", "failed"]).optional()
 });
 var LAUNCH_MARK = " \xB7 started by process ";
 var HEADER_START = "\n";
@@ -2021,8 +1621,8 @@ var parse_json = {
 };
 
 // scripts/gh/git-gh-failure.ts
-import { z as z6 } from "zod";
-var error_document_schema = z6.object({ status: z6.union([z6.string(), z6.number()]).optional() }).catch({});
+import { z as z5 } from "zod";
+var error_document_schema = z5.object({ status: z5.union([z5.string(), z5.number()]).optional() }).catch({});
 var GH_FAILURE_FIELD = "gh_failure";
 function has_gh_failure(error) {
   return error instanceof Error && Object.hasOwn(error, GH_FAILURE_FIELD);
@@ -2225,7 +1825,7 @@ var git_gh_helpers = {
 };
 
 // scripts/gh/git-gh-issue-rest.ts
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 
 // scripts/gh/git-gh-rest-state.ts
 var MERGED_STATE = "MERGED";
@@ -2234,11 +1834,11 @@ function to_gh_state(state) {
 }
 
 // scripts/gh/git-gh-issue-rest.ts
-var rest_issue_schema = z7.looseObject({
-  number: z7.number(),
-  issue_dependencies_summary: z7.looseObject({ total_blocked_by: z7.number().optional() }).nullish(),
+var rest_issue_schema = z6.looseObject({
+  number: z6.number(),
+  issue_dependencies_summary: z6.looseObject({ total_blocked_by: z6.number().optional() }).nullish(),
   // Present only on a pull request, which this endpoint serves as readily as an issue.
-  pull_request: z7.looseObject({ merged_at: z7.string().nullish() }).nullish()
+  pull_request: z6.looseObject({ merged_at: z6.string().nullish() }).nullish()
 });
 var REPOSITORY_URL = /\/repos\/([\w.-]+\/[\w.-]+)$/u;
 var REPOSITORY_URL_GROUP = 1;
@@ -2246,7 +1846,7 @@ var BLOCKED_BY_FIELD = "blockedBy";
 var BLOCKED_BY_COUNT_FIELD = "blocked_by_count";
 var STATE_FIELD = "state";
 var BODY_FIELD = "body";
-var FIELD_SEPARATOR2 = ",";
+var FIELD_SEPARATOR = ",";
 var EMPTY_BODY = "";
 var REST_FIELD_NAMES = /* @__PURE__ */ new Map([
   ["url", "html_url"],
@@ -2260,7 +1860,7 @@ function rest_field_name(field) {
   return REST_FIELD_NAMES.get(field) ?? field;
 }
 function split_fields(fields) {
-  return fields.split(FIELD_SEPARATOR2).map((field) => field.trim()).filter((field) => field.length > 0);
+  return fields.split(FIELD_SEPARATOR).map((field) => field.trim()).filter((field) => field.length > 0);
 }
 function to_issue_state(rest, value) {
   if (typeof rest.pull_request?.merged_at === "string") return MERGED_STATE;
@@ -2808,18 +2408,18 @@ var git_gh_issue = {
 // scripts/ci/pr-classification.ts
 import { readFileSync as readFileSync2 } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { z as z8 } from "zod";
+import { z as z7 } from "zod";
 var CLASSIFICATION_SET = new Set(RELEASE_CLASSIFICATION_NAMES);
 var ISSUE_BUG_LABEL = "bug";
 var DECLARATION_PREFIX = "- \u30EA\u30EA\u30FC\u30B9\u5206\u985E: ";
 var DECLARATION = new RegExp(`^${DECLARATION_PREFIX}(.+)$`, "gmu");
 var LEGACY_LABELS = /* @__PURE__ */ new Set(["semver-major", "semver-minor"]);
-var LABEL = z8.object({ name: z8.string() });
-var USER = z8.object({ login: z8.string() });
-var PULL_REQUEST = z8.object({ number: z8.number(), user: USER });
-var EVENT = z8.object({
+var LABEL = z7.object({ name: z7.string() });
+var USER = z7.object({ login: z7.string() });
+var PULL_REQUEST = z7.object({ number: z7.number(), user: USER });
+var EVENT = z7.object({
   pull_request: PULL_REQUEST,
-  repository: z8.object({ full_name: z8.string() })
+  repository: z7.object({ full_name: z7.string() })
 });
 function classification_error(labels, author) {
   const legacy = labels.filter((label) => LEGACY_LABELS.has(label.toLowerCase()));
@@ -2842,7 +2442,7 @@ function release_candidates(candidates) {
   return candidates.filter((candidate) => candidate !== ENHANCEMENT_LABEL);
 }
 function issue_candidates(issue_json) {
-  const issue2 = z8.object({ labels: z8.array(LABEL), body: z8.string().nullable() }).parse(JSON.parse(issue_json));
+  const issue2 = z7.object({ labels: z7.array(LABEL), body: z7.string().nullable() }).parse(JSON.parse(issue_json));
   const names = issue2.labels.map((label) => label.name.toLowerCase());
   const declared = [...(issue2.body ?? "").matchAll(DECLARATION)].map((match) => match[1] ?? "");
   const candidates = [...release_candidates([...names, ...declared].filter(is_classification))];
@@ -2917,30 +2517,30 @@ async function poll_until(is_done, options) {
 var poll = { poll_until, sleep: sleep2 };
 
 // scripts/gh/git-gh-pr.ts
-import { z as z12 } from "zod";
+import { z as z11 } from "zod";
 
 // scripts/gh/git-gh-pr-rest.ts
-import { z as z9 } from "zod";
-var rest_repo_schema = z9.looseObject({ full_name: z9.string().optional() }).nullish();
-var rest_pull_side_schema = z9.looseObject({ repo: rest_repo_schema });
-var rest_pull_schema = z9.looseObject({
-  number: z9.number(),
-  html_url: z9.string().optional(),
-  body: z9.string().nullish(),
-  state: z9.string().optional(),
-  merged: z9.boolean().nullish(),
-  merged_at: z9.string().nullish(),
-  mergeable: z9.boolean().nullish(),
-  mergeable_state: z9.string().optional(),
+import { z as z8 } from "zod";
+var rest_repo_schema = z8.looseObject({ full_name: z8.string().optional() }).nullish();
+var rest_pull_side_schema = z8.looseObject({ repo: rest_repo_schema });
+var rest_pull_schema = z8.looseObject({
+  number: z8.number(),
+  html_url: z8.string().optional(),
+  body: z8.string().nullish(),
+  state: z8.string().optional(),
+  merged: z8.boolean().nullish(),
+  merged_at: z8.string().nullish(),
+  mergeable: z8.boolean().nullish(),
+  mergeable_state: z8.string().optional(),
   // `sha` is the head commit, which is what both halves of the merge-gate rollup are keyed by —
   // REST hangs the check runs and the status contexts off the commit rather than off the pull
   // request.
-  head: z9.looseObject({ ref: z9.string().optional(), sha: z9.string().optional(), repo: rest_repo_schema }).nullish(),
+  head: z8.looseObject({ ref: z8.string().optional(), sha: z8.string().optional(), repo: rest_repo_schema }).nullish(),
   base: rest_pull_side_schema.nullish(),
   // `node_id` is what the GraphQL auto-merge mutation addresses a pull request by, and `auto_merge`
   // is `null` until auto-merge is enabled — both read by `git-gh-pr-auto-merge.ts`.
-  node_id: z9.string().optional(),
-  auto_merge: z9.looseObject({}).nullish()
+  node_id: z8.string().optional(),
+  auto_merge: z8.looseObject({}).nullish()
 });
 var NOT_A_PULL_MESSAGE = "gh api answered something other than a pull request object";
 var NOT_A_PULL_LISTING_MESSAGE = "gh api answered something other than a pull request listing";
@@ -3159,14 +2759,14 @@ var git_gh_pr_read = {
 };
 
 // scripts/gh/git-gh-pr-review.ts
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 var REVIEW_APPROVED = "APPROVED";
 var REVIEW_CHANGES_REQUESTED = "CHANGES_REQUESTED";
 var REVIEW_NONE = "";
 var STATE_CHANGING_REVIEWS = /* @__PURE__ */ new Set([REVIEW_APPROVED, REVIEW_CHANGES_REQUESTED]);
-var rest_review_schema = z10.looseObject({
-  state: z10.string().optional(),
-  user: z10.looseObject({ login: z10.string().optional() }).nullish()
+var rest_review_schema = z9.looseObject({
+  state: z9.string().optional(),
+  user: z9.looseObject({ login: z9.string().optional() }).nullish()
 });
 var NOT_A_REVIEW_LISTING = "gh api answered something other than a review listing";
 function parse_rest_reviews(reviews_json) {
@@ -3199,18 +2799,18 @@ function to_review_decision(reviews_json) {
 var git_gh_pr_review = { to_review_decision };
 
 // scripts/gh/git-gh-pr-rollup.ts
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 var STATUS_CONTEXT_TYPE_NAME = "StatusContext";
 var TYPE_NAME_KEY = "__typename";
-var rollup_element_schema = z11.looseObject({});
-var check_runs_page_schema = z11.looseObject({
+var rollup_element_schema = z10.looseObject({});
+var check_runs_page_schema = z10.looseObject({
   // Required, not optional: GitHub always names the key, and accepting a page without one would
   // answer an empty rollup — which `git-pr-followup.ts` reports as "this branch has no checks".
-  check_runs: z11.array(rollup_element_schema)
+  check_runs: z10.array(rollup_element_schema)
 });
-var id_holder_schema = z11.object({ id: z11.number() });
-var status_page_schema = z11.looseObject({
-  statuses: z11.array(rollup_element_schema)
+var id_holder_schema = z10.object({ id: z10.number() });
+var status_page_schema = z10.looseObject({
+  statuses: z10.array(rollup_element_schema)
 });
 var NOT_A_CHECK_RUNS_LISTING = "gh api answered something other than a check run listing";
 var NOT_A_STATUS_LISTING = "gh api answered something other than a commit status listing";
@@ -3344,7 +2944,7 @@ var MERGE_READ_BACK_ATTEMPTS = 3;
 var MERGE_READ_BACK_INTERVAL_MS = 1e3;
 var PR_NUMBER_PATTERN = /\/pull\/([1-9]\d*)$/u;
 var LABELS_SEGMENT2 = "/labels";
-var PR_LABELS = z12.array(z12.object({ name: z12.string() }));
+var PR_LABELS = z11.array(z11.object({ name: z11.string() }));
 async function add_pr_classification(number, label) {
   await git_gh_exec.exec_gh_api({
     path: `${git_gh_api_path.issue_api_path(number)}${LABELS_SEGMENT2}`,
@@ -3693,9 +3293,6 @@ var git_gh_command = {
 
 export {
   bounded_pool,
-  run_event_stream,
-  run_event_scope,
-  run_event_stream_emit,
   shell_segments,
   bash_triggers,
   tail_commands,

package/dist/hooks/{chunk-LOJTBU5V.js → chunk-IYVOLN6A.js}

@@ -1,12 +1,12 @@
 import {
   investigation_reads
-} from "./chunk-7VSZ2N4B.js";
+} from "./chunk-WNFJLBXI.js";
 import {
   lane_guard_policy
-} from "./chunk-KC6LUZZ2.js";
+} from "./chunk-EAQEGME7.js";
 import {
   hook_decision
-} from "./chunk-LC56R53A.js";
+} from "./chunk-EBSHN25W.js";
 
 // scripts/delegation/investigation-guard.ts
 import { text } from "node:stream/consumers";