@joshuafolkken/kit 1.1383.0 → 1.1435.0

package/dist/hooks/{chunk-2X2ART5G.js → chunk-YW452ZAX.js}

@@ -1,6 +1,9 @@
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
 import {
   lane_child_marker
-} from "./chunk-Y5R47QHU.js";
+} from "./chunk-4BHUPFKF.js";
 import {
   ENV_FILE_NAME,
   GIT_LOCATION_VARIABLES,
@@ -20,14 +23,14 @@ import {
   process_identity,
   process_owner_schema,
   run_carry
-} from "./chunk-4MGHBTOM.js";
+} from "./chunk-3LE6VLSR.js";
 import {
   INSTALL_TIMEOUT_MS,
   PLATFORM_TEMP_ROOT,
   PROBE_TIMEOUT_MS,
   SUITE_TIMEOUT_MS,
   stamp_file
-} from "./chunk-NEC4AT4Z.js";
+} from "./chunk-DGT54IH5.js";
 
 // scripts/agent/agent-headless.ts
 var KEY = "JOSH_AGENT_HEADLESS";
@@ -40,6 +43,16 @@ function is_headless(source = process.env) {
 }
 var agent_headless = { KEY, environment, is_headless };
 
+// scripts/josh/session-language.ts
+var ENV_KEY = "JOSH_SESSION_LANG";
+var DEFAULT_SESSION_LANG = "ja";
+function resolve_session_lang() {
+  const value = process.env[ENV_KEY]?.trim();
+  if (value) return { lang: value, is_default: false };
+  return { lang: DEFAULT_SESSION_LANG, is_default: true };
+}
+var session_language = { DEFAULT_SESSION_LANG, ENV_KEY, resolve_session_lang };
+
 // scripts/lane/lane-reap.ts
 import { execFileSync } from "node:child_process";
 
@@ -213,6 +226,7 @@ function stop_reason(stage, conflicts = []) {
   return conflicts.length > 0 ? CONFLICT : stage;
 }
 var run_ship_stage = {
+  CONFLICT,
   PHASE,
   STAGE,
   clear,
@@ -316,6 +330,21 @@ var lane_child_invocation = {
   ship_stop_invocation
 };
 
+// scripts/lane/process-tools.ts
+import path from "node:path";
+var NOT_FOUND_CODE = "ENOENT";
+var PACKAGE_HINT = "install the package that provides it (procps on Debian/Ubuntu: `apt-get install procps`)";
+function is_not_found(error) {
+  return error instanceof Error && "code" in error && error.code === NOT_FOUND_CODE;
+}
+function missing_notice(command) {
+  return `\`${path.basename(command)}\` is not installed \u2014 kit's lane commands read processes with ps and pgrep; ${PACKAGE_HINT}`;
+}
+function throw_if_missing(command, error) {
+  if (is_not_found(error)) throw new Error(missing_notice(command), { cause: error });
+}
+var process_tools = { missing_notice, throw_if_missing };
+
 // scripts/lane/lane-reap.ts
 var PGREP_COMMAND = "pgrep";
 var MATCH_FULL_COMMAND_LINE = "-f";
@@ -334,7 +363,8 @@ function run_probe(command, args) {
       timeout: PROBE_TIMEOUT_MS,
       stdio: ["ignore", "pipe", "ignore"]
     });
-  } catch {
+  } catch (error) {
+    process_tools.throw_if_missing(command, error);
     return "";
   }
 }
@@ -380,14 +410,20 @@ function tree_of(roots, probes) {
   }
   return tree;
 }
+function roots_of(issue, own2, probes) {
+  const pattern = lane_child_invocation.process_pattern(issue);
+  return probes.matching(pattern).filter((pid) => !own2.has(pid));
+}
 function reap_child(issue, probes = SYSTEM_PROBES) {
   const own2 = own_ancestry(probes);
-  const pattern = lane_child_invocation.process_pattern(issue);
-  const roots = probes.matching(pattern).filter((pid) => !own2.has(pid));
-  const doomed = tree_of(roots, probes).filter((pid) => !own2.has(pid));
+  const doomed = tree_of(roots_of(issue, own2, probes), probes).filter((pid) => !own2.has(pid));
   return doomed.filter((pid) => probes.terminate(pid));
 }
+function is_child_running(issue, probes = SYSTEM_PROBES) {
+  return roots_of(issue, own_ancestry(probes), probes).length > 0;
+}
 var lane_reap = {
+  is_child_running,
   own_ancestry,
   parse_pids,
   reap_child
@@ -395,11 +431,11 @@ var lane_reap = {
 
 // scripts/lane/lane-registry.ts
 import { existsSync as existsSync2 } from "node:fs";
-import path2 from "node:path";
+import path3 from "node:path";
 
 // scripts/discovery/repo-discovery.ts
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import path from "node:path";
+import path2 from "node:path";
 
 // scripts/discovery/repo-origin.ts
 var GITHUB_HOST = "github.com";
@@ -546,10 +582,10 @@ var GITDIR_PREFIX = "gitdir:";
 var COMMON_DIRECTORY_FILE = "commondir";
 var OVERRIDE_ENV_KEY = "JOSH_REPO_PATHS";
 function resolve_common_directory(git_directory) {
-  const pointer = path.join(git_directory, COMMON_DIRECTORY_FILE);
+  const pointer = path2.join(git_directory, COMMON_DIRECTORY_FILE);
   if (!existsSync(pointer)) return git_directory;
   try {
-    return path.resolve(git_directory, readFileSync(pointer, "utf8").trim());
+    return path2.resolve(git_directory, readFileSync(pointer, "utf8").trim());
   } catch {
     return git_directory;
   }
@@ -557,10 +593,10 @@ function resolve_common_directory(git_directory) {
 function follow_git_file(repository_path, git_file) {
   const pointer = readFileSync(git_file, "utf8").trim();
   if (!pointer.startsWith(GITDIR_PREFIX)) return void 0;
-  return path.resolve(repository_path, pointer.slice(GITDIR_PREFIX.length).trim());
+  return path2.resolve(repository_path, pointer.slice(GITDIR_PREFIX.length).trim());
 }
 function resolve_git_directory(repository_path) {
-  const candidate = path.join(repository_path, GIT_DIRECTORY);
+  const candidate = path2.join(repository_path, GIT_DIRECTORY);
   if (!existsSync(candidate)) return void 0;
   try {
     if (statSync(candidate).isDirectory()) return candidate;
@@ -574,7 +610,7 @@ function read_config(repository_path) {
   const git_directory = resolve_git_directory(repository_path);
   if (git_directory === void 0) return void 0;
   try {
-    return readFileSync(path.join(git_directory, GIT_CONFIG), "utf8");
+    return readFileSync(path2.join(git_directory, GIT_CONFIG), "utf8");
   } catch {
     return void 0;
   }
@@ -589,7 +625,7 @@ function read_remote_urls(repository_path) {
 }
 function sibling_directories(parent) {
   try {
-    return readdirSync(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path.join(parent, entry.name)).toSorted((left, right) => left.localeCompare(right));
+    return readdirSync(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path2.join(parent, entry.name)).toSorted((left, right) => left.localeCompare(right));
   } catch {
     return [];
   }
@@ -608,15 +644,15 @@ function resolve_current_owner(repository_path) {
 function main_worktree(repository_path) {
   const git_directory = resolve_git_directory(repository_path);
   if (git_directory === void 0) return repository_path;
-  if (path.basename(git_directory) !== GIT_DIRECTORY) return repository_path;
-  return path.dirname(git_directory);
+  if (path2.basename(git_directory) !== GIT_DIRECTORY) return repository_path;
+  return path2.dirname(git_directory);
 }
 function discover_repositories(repository_path, environment3 = process.env) {
   const main = main_worktree(repository_path);
   const current_owner = resolve_current_owner(main);
   if (current_owner === void 0) return /* @__PURE__ */ new Map();
   return repo_map_logic.build_repository_map(
-    scan_siblings(path.dirname(main)),
+    scan_siblings(path2.dirname(main)),
     current_owner,
     environment3[OVERRIDE_ENV_KEY]
   );
@@ -1182,7 +1218,7 @@ function held_seat(content) {
   return seat_from_content(content) ?? EMPTY_SEAT;
 }
 function read_environment(directory) {
-  return file_reader.read_if_readable(path2.join(directory, ENV_FILE_NAME));
+  return file_reader.read_if_readable(path3.join(directory, ENV_FILE_NAME));
 }
 function branch_issue(branch) {
   if (!branch?.endsWith(lane_paths.LANE_BRANCH_SUFFIX)) return void 0;
@@ -1245,6 +1281,9 @@ async function has_lanes_in_flight() {
   const lanes = await list_lanes();
   return lanes.some((lane) => !lane.is_stranded);
 }
+function live_count(lanes) {
+  return lanes.filter((lane) => !lane.is_stranded).length;
+}
 function used_seats(lanes) {
   return lanes.map((lane) => lane.seat).filter((seat) => seat !== void 0);
 }
@@ -1262,6 +1301,7 @@ var lane_registry = {
   find_open_lane,
   has_lanes_in_flight,
   list_lanes,
+  live_count,
   main_repository_root,
   parse_block,
   read_environment,
@@ -1323,17 +1363,446 @@ var run_headless = {
   is_backlog_parent,
   is_cut_capped,
   is_headless: is_headless2,
+  is_headless_parent,
   is_owned_here,
   must_keep_waiting
 };
 
+// scripts/run/event/run-event-stream.ts
+import { z as z3 } 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_SEPARATOR2 = " ";
+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",
+  // A person stopped a running lane child and re-dispatched its issue in a fresh session
+  // (`lane:restart`). It follows the fresh dispatch's `CHILD_LAUNCH`, so it is a launch to the parent and
+  // the board, and — like that launch — a batch record a lane child never reads as its own position.
+  RESTART: "restart",
+  // 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 — or by the `run:wake`
+  // supervisor as it fails, leaves that state behind and has warned of it —
+  // 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",
+  // One stage of the run's start — the session starting, the plan, the hand-off to the supervisor, a
+  // lane opening (`run-event-setup.ts`). `run:board` draws it while the run stands at it, so the
+  // minutes before one read as work rather than as a run that has stopped. A trace: it says the run is
+  // getting ready, not where the run is.
+  SETUP: "setup",
+  // A child's pull request checks as `josh followup` last polled them — the CI counts and CodeRabbit's
+  // state (`run-event-checks.ts`), written only when they change, so `run:board` draws a child waiting
+  // in followup without asking GitHub (joshuafolkken/kit#3770). A trace: it says how the checks stand,
+  // not where the run is.
+  PR_CHECKS: "pr-checks"
+};
+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,
+  EVENT_KIND.SETUP,
+  EVENT_KIND.PR_CHECKS
+]);
+var DISPOSABLE_KINDS = /* @__PURE__ */ new Set([
+  EVENT_KIND.SHIP_STAGE,
+  EVENT_KIND.HEARTBEAT,
+  EVENT_KIND.SETUP,
+  EVENT_KIND.PR_CHECKS
+]);
+var event_schema = z3.object({
+  pos: z3.number(),
+  at: z3.string(),
+  kind: z3.string(),
+  text: z3.string()
+});
+function is_event_kind(value) {
+  return EVENT_KINDS.includes(value);
+}
+function target_of(repository2) {
+  return stamp_file.stamp_path(EVENT_PREFIX, repository2, 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_SEPARATOR2)[FIRST_POSITION] ?? "";
+}
+function newest_by_issue(events, kind) {
+  const newest = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.kind === kind) 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_SEPARATOR2)[STAGE_PHASE_INDEX] === run_ship_stage.PHASE.START;
+}
+function drawn_lines(events) {
+  const setup = events.findLast((event) => event.kind === EVENT_KIND.SETUP);
+  return /* @__PURE__ */ new Set([
+    ...newest_by_issue(events, EVENT_KIND.SHIP_STAGE),
+    ...newest_by_issue(events, EVENT_KIND.PR_CHECKS),
+    ...setup === void 0 ? [] : [setup]
+  ]);
+}
+function droppable(events) {
+  const kept = drawn_lines(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, text, 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 }),
+    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.RESTART,
+  KIND.PARK,
+  KIND.SPLIT,
+  KIND.RETROSPECTIVE,
+  KIND.STRANDED
+]);
+var ISSUE_REFERENCE = /#(\d+)/u;
+function is_foreign_ship_event(event, issue) {
+  return SHIP_POSITION_KINDS.has(event.kind) && !event.text.startsWith(`${issue_cite.plain(issue)} `);
+}
+function is_own_ship_event(event, issue) {
+  return SHIP_POSITION_KINDS.has(event.kind) && !is_foreign_ship_event(event, issue);
+}
+function issue_named(event) {
+  return ISSUE_REFERENCE.exec(event.text)?.[1];
+}
+function names_issue(event, issue) {
+  return issue_named(event) === issue;
+}
+function is_lane_position(event, issue) {
+  return !BATCH_RECORD_KINDS.has(event.kind) && names_issue(event, issue);
+}
+function since_own_launch(events, issue) {
+  const launch2 = events.findLastIndex(
+    (event) => event.kind === KIND.CHILD_LAUNCH && names_issue(event, issue)
+  );
+  return events.slice(launch2 + 1);
+}
+function is_foreign_event(event, issue, is_lane_child) {
+  if (is_lane_child) return !is_lane_position(event, issue);
+  return is_foreign_ship_event(event, issue);
+}
+function last_issue_event(events, scope, issue, is_lane_child) {
+  const attempt = is_lane_child ? since_own_launch(events, issue) : events;
+  const own2 = attempt.filter((event) => !is_foreign_event(event, issue, is_lane_child));
+  if (scope.kind === SINCE_SCOPE) return last_scoped_event(own2, scope);
+  return own2.findLast((event) => is_own_ship_event(event, issue));
+}
+var LAUNCH_OR_SETTLE_KINDS = /* @__PURE__ */ new Set([
+  KIND.CHILD_LAUNCH,
+  KIND.MERGE,
+  KIND.PARK,
+  KIND.SPLIT
+]);
+function is_merge_owed(events, scope, issue) {
+  const newest = (scoped_events(events, scope) ?? []).findLast(
+    (event) => LAUNCH_OR_SETTLE_KINDS.has(event.kind) && names_issue(event, issue)
+  );
+  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 repository2 = await run_carry.repository_directory();
+  return repository2 === void 0 ? void 0 : run_event_stream.target_of(repository2);
+}
+async function emit(kind, text) {
+  try {
+    const target = await stream_target();
+    if (target === void 0) return;
+    run_event_stream.append(target, kind, text, now_iso());
+  } catch {
+  }
+}
+async function emit_once(kind, text) {
+  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, text, now_iso()).appended;
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.emit_once", error);
+    return false;
+  }
+}
+function invocation_events(repository2, target) {
+  const events = run_event_stream.read_events(target);
+  const scope = run_event_scope.scope_of(run_carry.read_carry(run_carry.carry_path(repository2)));
+  return run_event_scope.scoped_events(events, scope) ?? events;
+}
+async function emit_once_since(kind, text, reset_kind) {
+  try {
+    const repository2 = await run_carry.repository_directory();
+    if (repository2 === void 0) return false;
+    const target = run_event_stream.target_of(repository2);
+    if (run_event_stream.has_since(invocation_events(repository2, target), kind, reset_kind)) {
+      return false;
+    }
+    return run_event_stream.append(target, kind, text, 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 repository2 = await run_carry.repository_directory();
+    if (repository2 === void 0) return [];
+    const read = run_carry.read_carry(run_carry.carry_path(repository2));
+    const scope = run_event_scope.scope_of(read);
+    const events = run_event_stream.read_events(run_event_stream.target_of(repository2));
+    return run_event_scope.scoped_events(events, scope) ?? [];
+  } catch {
+    return [];
+  }
+}
+async function invocation_or_all_events() {
+  try {
+    const repository2 = await run_carry.repository_directory();
+    return repository2 === void 0 ? [] : invocation_events(repository2, run_event_stream.target_of(repository2));
+  } 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/detached-launch.ts
 import { spawn } from "node:child_process";
 import { closeSync, constants, openSync, writeSync } from "node:fs";
 
 // scripts/agent/agent-launch-environment.ts
 import { existsSync as existsSync3, lstatSync, mkdirSync, readlinkSync, symlinkSync, unlinkSync } from "node:fs";
-import path4 from "node:path";
+import path5 from "node:path";
 
 // scripts/gh/gh-cli-token.ts
 import { execaSync } from "execa";
@@ -1361,9 +1830,9 @@ var agent_session_role = { KEY: KEY2, env_for: environment_for, is_reviewer };
 
 // scripts/agent/codex-home-source.ts
 import os from "node:os";
-import path3 from "node:path";
+import path4 from "node:path";
 function default_home() {
-  return path3.join(os.homedir(), ".codex");
+  return path4.join(os.homedir(), ".codex");
 }
 var codex_home_source = { default_home };
 
@@ -1385,13 +1854,13 @@ function remove_old_home_link(source, target) {
   return false;
 }
 function link_home_file(source_home, target_home, name) {
-  const source = path4.join(source_home, name);
-  const target = path4.join(target_home, name);
+  const source = path5.join(source_home, name);
+  const target = path5.join(target_home, name);
   if (!remove_old_home_link(source, target) && existsSync3(source)) symlinkSync(source, target);
 }
 function reviewer_home(cwd, environment3) {
   const source = environment3["CODEX_HOME"] ?? process.env["CODEX_HOME"] ?? codex_home_source.default_home();
-  const target = path4.resolve(cwd, ...REVIEWER_HOME);
+  const target = path5.resolve(cwd, ...REVIEWER_HOME);
   mkdirSync(target, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
   for (const name of HOME_FILES) link_home_file(source, target, name);
   return target;
@@ -1545,17 +2014,19 @@ var detached_launch = {
 };
 
 export {
+  repo_origin,
+  repo_discovery,
   issue_cite,
   git_common_directory,
-  repository_lock,
-  run_ship_stage,
+  run_event_stream,
+  run_event_scope,
+  run_event_stream_emit,
   agent_role_profile,
   agent_session_role,
   lane_child_invocation,
-  repo_origin,
-  repo_discovery,
   agent_headless,
   detached_launch,
+  session_language,
   lane_registry,
   run_headless
 };