@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-2TUA6V4F.js

@@ -0,0 +1,191 @@
+import {
+  issue_merged
+} from "./chunk-ORFXTHXU.js";
+import {
+  issue_outcome
+} from "./chunk-F546BPG3.js";
+import {
+  git_gh_issue_alias_graphql
+} from "./chunk-B762PNT6.js";
+import {
+  PAGE,
+  git_gh_issue_read
+} from "./chunk-U6SMBYTN.js";
+import {
+  git_gh_etag_read
+} from "./chunk-V6WWW6HX.js";
+import {
+  issue_label_schema
+} from "./chunk-34DND4BA.js";
+import {
+  ALREADY_DONE_LABEL,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+import {
+  parse_json_object_or_undefined
+} from "./chunk-NAZ753DE.js";
+import {
+  bounded_pool
+} from "./chunk-EBVS2LKX.js";
+
+// scripts/run/board/run-board-closed.ts
+import { z as z2 } from "zod";
+
+// scripts/run/board/run-board-closed-graphql.ts
+import { z } from "zod";
+var TIMELINE_TYPES = [
+  "CLOSED_EVENT",
+  "REOPENED_EVENT",
+  "CROSS_REFERENCED_EVENT",
+  "LABELED_EVENT",
+  "UNLABELED_EVENT"
+].join(", ");
+var CLOSED_FIELDS = `title state stateReason closedAt
+	labels(${PAGE}) { nodes { name } }
+	timelineItems(${PAGE}, itemTypes: [${TIMELINE_TYPES}]) {
+		pageInfo { hasNextPage }
+		nodes {
+			type: __typename
+			... on ClosedEvent { stateReason }
+			... on LabeledEvent { label { name } }
+			... on UnlabeledEvent { label { name } }
+			... on CrossReferencedEvent { source { ... on PullRequest { mergedAt } } }
+		}
+	}`;
+var REST_EVENTS = {
+  ClosedEvent: "closed",
+  ReopenedEvent: "reopened",
+  CrossReferencedEvent: "cross-referenced",
+  LabeledEvent: "labeled",
+  UnlabeledEvent: "unlabeled"
+};
+var label_schema = z.object({ name: z.string() });
+var page_info_schema = z.object({ hasNextPage: z.boolean() });
+var event_node_schema = z.object({
+  type: z.string(),
+  stateReason: z.string().nullish(),
+  label: label_schema.nullish(),
+  source: z.object({ mergedAt: z.string().nullish() }).nullish()
+});
+var timeline_schema = z.object({
+  pageInfo: page_info_schema,
+  nodes: z.array(event_node_schema)
+});
+var closed_fields_schema = z.object({
+  title: z.string(),
+  state: z.string(),
+  stateReason: z.string().nullish(),
+  closedAt: z.string().nullish(),
+  labels: z.object({ nodes: z.array(label_schema) }),
+  timelineItems: timeline_schema
+});
+function reason_of(reason) {
+  return reason?.toLowerCase();
+}
+function to_rest_event(node) {
+  return {
+    event: REST_EVENTS[node.type] ?? "",
+    state_reason: reason_of(node.stateReason),
+    label: node.label ?? void 0,
+    source: { issue: { pull_request: { merged_at: node.source?.mergedAt ?? void 0 } } }
+  };
+}
+function is_merged_of(issue) {
+  if (issue.timelineItems.pageInfo.hasNextPage) return void 0;
+  const events = issue.timelineItems.nodes.map((node) => to_rest_event(node));
+  const rows = issue_merged.page_rows(JSON.stringify(events));
+  return rows === void 0 ? void 0 : issue_merged.is_merged_close(rows);
+}
+function to_source(issue) {
+  const view = {
+    title: issue.title,
+    state: issue.state,
+    stateReason: reason_of(issue.stateReason),
+    closedAt: issue.closedAt ?? void 0,
+    labels: issue.labels.nodes
+  };
+  return { json: JSON.stringify(view), is_merged: is_merged_of(issue) };
+}
+async function read_sources(issues) {
+  const read = await git_gh_issue_alias_graphql.read_aliased(
+    issues,
+    CLOSED_FIELDS,
+    closed_fields_schema
+  );
+  return new Map([...read.answers].map(([issue, fields]) => [issue, to_source(fields)]));
+}
+var run_board_closed_graphql = { read_sources };
+
+// scripts/run/board/run-board-closed.ts
+var CLOSED_FIELDS2 = "title,state,stateReason,closedAt,labels";
+var CLOSED_STATE = "CLOSED";
+var NOT_PLANNED_REASON = "not_planned";
+var STILL_OPEN = "open";
+var READ_CONCURRENCY = 4;
+var closed_schema = z2.looseObject({
+  title: z2.string(),
+  state: z2.string(),
+  stateReason: z2.string().nullish(),
+  closedAt: z2.string().nullish(),
+  labels: z2.array(issue_label_schema).default([])
+});
+function closed_ms_of(view) {
+  const closed_ms = Date.parse(view.closedAt ?? "");
+  return Number.isNaN(closed_ms) ? void 0 : closed_ms;
+}
+async function read_view(issue, source) {
+  const json = source?.json ?? await git_gh_issue_read.issue_view_json(
+    String(issue),
+    CLOSED_FIELDS2,
+    void 0,
+    git_gh_etag_read.read
+  );
+  return json === void 0 ? void 0 : parse_json_object_or_undefined(json, closed_schema);
+}
+async function read_merged(issue, source) {
+  return source?.is_merged ?? await issue_merged.read_merge_state(String(issue));
+}
+async function read_closed(issue, source) {
+  const view = await read_view(issue, source);
+  if (view === void 0) return void 0;
+  if (view.state !== CLOSED_STATE) return STILL_OPEN;
+  const is_merged = await read_merged(issue, source);
+  if (is_merged === void 0) return void 0;
+  const labels = view.labels.map((label) => label.name);
+  const is_not_planned = view.stateReason === NOT_PLANNED_REASON;
+  return {
+    title: view.title,
+    labels,
+    closed_ms: closed_ms_of(view),
+    is_merged,
+    is_not_planned,
+    ...await issue_outcome.recorded(issue, is_merged)
+  };
+}
+async function read_all(issues, read = read_closed) {
+  const sources = await run_board_closed_graphql.read_sources(issues);
+  const answers = await bounded_pool.bounded_map(issues, READ_CONCURRENCY, async (issue) => ({
+    issue,
+    answer: await read(issue, sources.get(issue))
+  }));
+  const closed = new Map(
+    answers.flatMap(
+      ({ issue, answer }) => typeof answer === "object" ? [[issue, answer]] : []
+    )
+  );
+  return { closed, is_whole: answers.every(({ answer }) => answer !== void 0) };
+}
+function state_of(closed) {
+  if (closed.is_merged) return "merged";
+  if (closed.is_not_planned) return "withdrawn";
+  return has_label_name(closed.labels, ALREADY_DONE_LABEL) ? "already_done" : "done";
+}
+function is_reopened(issue, closed, listing) {
+  if (listing.open_numbers?.has(issue) !== true) return false;
+  return closed.closed_ms === void 0 || (listing.read_ms ?? -Infinity) > closed.closed_ms;
+}
+var run_board_closed = { STILL_OPEN, is_reopened, read_all, read_closed, state_of };
+
+export {
+  run_board_closed
+};

package/dist/commands/chunk-2UXSF5YF.js

@@ -0,0 +1,49 @@
+import {
+  delivered_rules
+} from "./chunk-UC5ZOPKX.js";
+
+// scripts/rules/stop-rule-rows.ts
+var STOP_GUARD = "pnpm josh stop:guard";
+var ROWS = [
+  {
+    id: "stop-notify",
+    about: {
+      title: "Stop notification",
+      topic: '`rule-delivery.md` \u2192 "stop-notify"',
+      entry: STOP_GUARD,
+      fires: "a stop with the work tree held and no `confirmation` notify that turn. Sends the notify itself; blocks only when the send fails",
+      quiet: "no hold, a `confirmation` notify on the tail, or a pre-gate cut taken"
+    }
+  },
+  {
+    id: "hold-release",
+    about: {
+      title: "Hold release",
+      topic: "`.claude/skills/workflow-commands/working-tree-hold.md`",
+      entry: STOP_GUARD,
+      fires: "a stop on a clean tree with the `run:hold` record still in place. Releases the hold itself; blocks only when that fails",
+      quiet: "a dirty tree (a `halfrun` stop before the commit, a `needs-human-review` stop) or already released"
+    }
+  },
+  {
+    id: "filing-offer",
+    about: {
+      title: "Offer to file",
+      topic: "`.claude/skills/workflow-commands/observation-filing.md`",
+      entry: STOP_GUARD,
+      fires: "an unattended run (a kit-launched headless session, a lane child, a `backlogrun` parent) whose last reply offers to file without filing. Blocks the stop",
+      quiet: "an interactive session, already filed, inside a fence or quote, a named third-party `owner/repo`, or an unknown owner"
+    }
+  }
+];
+var stop_rule_rows = { ROWS };
+
+// scripts/rules/guard-rule-rows.ts
+function rows() {
+  return [...delivered_rules.MEASURED_RULES, ...stop_rule_rows.ROWS];
+}
+var guard_rule_rows = { rows };
+
+export {
+  guard_rule_rows
+};

package/dist/commands/chunk-2ZDVX64H.js

@@ -0,0 +1,66 @@
+import {
+  telegram_test
+} from "./chunk-HLQVLQEB.js";
+import {
+  git_gh_repo
+} from "./chunk-QRY55H5U.js";
+import {
+  run_stage
+} from "./chunk-UWLLZQJB.js";
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/issue/issue-plan-notify.ts
+var CHANGE_HEADING = /^#{2,3}\s+変更\s*$/u;
+var ANY_HEADING = /^#{1,6}\s/u;
+var TOP_LEVEL_ITEM = /^(?:[-*+]|\d+\.)\s+(?<text>\S.*)$/u;
+var SUMMARY_ITEMS = 3;
+var KICKOFF = "kickoff";
+function section_body(section) {
+  const lines = markdown_section.written_fence_free_lines(section.join("\n"));
+  const end = lines.findIndex((line) => ANY_HEADING.test(line.trim()));
+  return end === -1 ? lines : lines.slice(0, end);
+}
+function summary_of(plan) {
+  const section = markdown_section.written_section_lines_matching(
+    plan,
+    (line) => CHANGE_HEADING.test(line.trim())
+  );
+  const lines = section.length === 0 ? markdown_section.written_fence_free_lines(plan) : section_body(section);
+  const items = lines.map((line) => TOP_LEVEL_ITEM.exec(line)?.groups?.["text"]);
+  return items.filter((item) => item !== void 0).slice(0, SUMMARY_ITEMS);
+}
+function body_of(notice) {
+  const items = summary_of(notice.plan).map((item) => `- ${item}`);
+  return [...items, run_stage.next_line(KICKOFF, notice.issue_number)].join("\n");
+}
+async function slug_of(repo) {
+  return repo ?? await git_gh_repo.repo_get_name_with_owner();
+}
+async function values_of(message) {
+  const slug = await slug_of(message.repo);
+  const url = slug === void 0 ? {} : { "issue-url": issue_cite.issue_url(slug, message.issue_number) };
+  const title = message.title === void 0 ? {} : { "issue-title": message.title };
+  return { "task-type": "planning", body: message.body, ...url, ...title };
+}
+async function send_planning(message) {
+  try {
+    await telegram_test.send_values(await values_of(message));
+  } catch (error) {
+    console.error(
+      `\u26A0\uFE0F  ${message.command} could not send the planning notification: ${String(error)}`
+    );
+  }
+}
+async function send(notice) {
+  await send_planning({ ...notice, body: body_of(notice), command: "issue:plan" });
+}
+var issue_plan_notify = { summary_of, send, send_planning, slug_of };
+
+export {
+  issue_plan_notify
+};

package/dist/commands/chunk-33N7SBIU.js

@@ -0,0 +1,18 @@
+import {
+  hook_decision
+} from "./chunk-HXAVYXUS.js";
+
+// scripts/run/run-retrospective.ts
+var RETROSPECTIVE_ENV_KEY = "JOSH_RETROSPECTIVE";
+function is_enabled() {
+  return hook_decision.is_switch_opt_in(RETROSPECTIVE_ENV_KEY);
+}
+function is_owed(facts) {
+  if (!facts.is_retrospective_enabled) return false;
+  return !facts.is_lane_child && !facts.is_retrospective_done && !facts.is_consumer;
+}
+var run_retrospective = { is_enabled, is_owed };
+
+export {
+  run_retrospective
+};

package/dist/commands/chunk-373P5MM2.js

@@ -0,0 +1,353 @@
+import {
+  repository_lock
+} from "./chunk-GC73YEU7.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  durable_state
+} from "./chunk-JSJS3OT7.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/event/run-event-stream.ts
+import { z } from "zod";
+var EVENT_PREFIX = durable_state.PREFIX.EVENTS;
+var EVENT_SUFFIX = ".jsonl";
+var EVENT_CAP = 15e3;
+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",
+  HUMAN_REVIEW: "human-review",
+  SPLIT: "split",
+  OUTAGE: "outage",
+  // A Claude usage limit stopped a lane child (joshuafolkken/kit#4745). Its text names the reset time,
+  // which `backlog:drive` reads to hold launches until then; it counts against no streak, so it is not an
+  // `OUTAGE`.
+  USAGE_LIMIT: "usage-limit",
+  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",
+  // A person withdrew a lane child — stopped it and left its issue open for the next run (`lane:withdraw`).
+  // It is written before the stop, so `run:merge` settles the child as withdrawn whatever GitHub says
+  // by the time the parent collects it, and counts it as neither a merge, a failure nor an outage.
+  WITHDRAW: "withdraw",
+  // 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",
+  // The relaunch meant to answer a `SHIP_STOP` started nothing — the broker refused it, or the direct
+  // spawn failed (joshuafolkken/kit#4765). `run:merge` reads it, not the transcript's mtime, to tell the
+  // stop went unanswered, and a re-dispatch cap's park names its reason. A trace: the stop stays the
+  // position `run:step` answers.
+  RELAUNCH_FAILED: "relaunch-failed",
+  // 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. The backlog driver writes its own
+  // `collect` / `launch` steps on a child as this kind too, which no reader draws as a phase
+  // (`backlog-drive-trace.ts`). A trace, like `SHIP_STAGE`: it says where the child's work is, not where
+  // the run is.
+  LANE_PHASE: "lane-phase",
+  // The fullrun step `run:step` or `run:entry` computed for an issue: `#<N> step <n>/<total> <name>`,
+  // written once per change of step (`run-event-step.ts`), so `run:board` draws it (joshuafolkken/kit#6598).
+  // A trace: it says which step the issue's run reached, not where the run is.
+  STEP: "step",
+  // 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",
+  // `backlog:drive` reached a watch with no child running and nothing to dispatch — the point a person's
+  // hand is wanted. Emitted once per idle episode (`emit_once_since_with`, reset by `CHILD_LAUNCH`), it
+  // is the dedup marker for the one idle Telegram. A trace: a drain's retrospective is read off the
+  // position beneath it, so the marker must not stand over it.
+  IDLE_NOTICE: "idle-notice",
+  // A person paused or resumed a lane child (`lane:pause` / `lane:resume`), so who halted a lane and
+  // when is on the stream rather than only in a shell history (joshuafolkken/kit#4268). A trace: it
+  // says what a lane's processes were told, not where the run is.
+  LANE_STATE: "lane-state",
+  // `backlog:drive` found nothing of the run in flight and only paused lanes left, paused past the
+  // silent window (joshuafolkken/kit#4270). Emitted once per pause episode (`emit_once_since_with`,
+  // reset by `LANE_STATE`), it is the dedup marker for the one paused-lane Telegram. A trace.
+  PAUSED_NOTICE: "paused-notice",
+  // `backlog:drive` ran a due issue's measurement declaration itself, found it within its bound and
+  // closed the issue through `issue:measured` — no lane was launched for it (joshuafolkken/kit#4621).
+  // `run:board` draws it merged. A trace: the parent's position is the drive's, not this close.
+  MEASURED: "measured",
+  // `backlog:drive` ran a due issue's measurement declaration and found no sample to read yet, so the
+  // issue waits without a lane (joshuafolkken/kit#6503). A trace: `offer_exclude` keeps it out of the
+  // run's offers, the way the drive's own `waiting` list does.
+  SAMPLE_WAIT: "sample-wait",
+  // The host slept while `backlog:drive` sampled its load (joshuafolkken/kit#5032): the sampler's timer
+  // ran late by more than a few intervals. `at` is the wake and `elapsed_ms` how long the sleep
+  // lasted; every lane's net time takes it out (`lane-sleep.ts`). A trace.
+  SLEEP: "sleep",
+  // A lane's `lane:plan` blocking on a holder of its files (joshuafolkken/kit#6140): `#<N> start #<M>`
+  // as one ask begins to wait, `#<N> end #<M>` as it ends, so `lane:breakdown` counts
+  // the wait under its own row rather than the stage it fell in (`lane-plan-wait-event.ts`). A trace.
+  PLAN_WAIT: "plan-wait",
+  // GitHub's REST core rate limit read around one `backlog:drive` offer cycle (joshuafolkken/kit#6558):
+  // JSON text with the cycle's `used_delta`, `remaining` and `reset`, or `is_missing` when a read failed
+  // (`backlog-drive-rate.ts`). A trace written every cycle, so the bound rolls it off with the heartbeats.
+  RATE_LIMIT: "rate-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.STEP,
+  EVENT_KIND.ADD,
+  EVENT_KIND.LANE_LIMIT,
+  EVENT_KIND.SETUP,
+  EVENT_KIND.PR_CHECKS,
+  EVENT_KIND.IDLE_NOTICE,
+  EVENT_KIND.LANE_STATE,
+  EVENT_KIND.PAUSED_NOTICE,
+  EVENT_KIND.MEASURED,
+  EVENT_KIND.SAMPLE_WAIT,
+  EVENT_KIND.RELAUNCH_FAILED,
+  EVENT_KIND.SLEEP,
+  EVENT_KIND.PLAN_WAIT,
+  EVENT_KIND.RATE_LIMIT
+]);
+var DISPOSABLE_KINDS = /* @__PURE__ */ new Set([
+  EVENT_KIND.SHIP_STAGE,
+  EVENT_KIND.HEARTBEAT,
+  EVENT_KIND.SETUP,
+  EVENT_KIND.PR_CHECKS,
+  EVENT_KIND.RATE_LIMIT
+]);
+var event_schema = z.object({
+  pos: z.number(),
+  at: z.string(),
+  kind: z.string(),
+  text: z.string(),
+  // The child's time on a lane, recorded once by the writer of an ending (joshuafolkken/kit#4481), so a
+  // reader never has to find its launch again. An event written before it has none. A `sleep` event
+  // carries the sleep's length here.
+  elapsed_ms: z.number().optional(),
+  // The ship stop a park was taken at — its stage and `Cause` class (joshuafolkken/kit#6864) — so a
+  // reader re-dispatching the park reads them without parsing text. Free strings: an event a later
+  // version wrote with a new class still parses. A park written before it, or no ship's, has none —
+  // as does one a lane on older code rewrote, since its schema drops the key, so none is a normal read.
+  stop: z.object({ stage: z.string(), cause: z.string() }).optional()
+});
+function is_event_kind(value) {
+  return EVENT_KINDS.includes(value);
+}
+function target_of(repository) {
+  return durable_state.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 lines_of(raw) {
+  return raw.split(LINE_SEPARATOR).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => parse_line(line)).filter(is_present);
+}
+function events_of_text(raw) {
+  return lines_of(raw).filter((event) => is_event_kind(event.kind));
+}
+function read_lines(target, is_required = false) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0 && is_required) throw new Error("Could not read the run event stream.");
+  if (raw === void 0) return [];
+  return lines_of(raw);
+}
+function read_events(target, is_required = false) {
+  return read_lines(target, is_required).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_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_SEPARATOR)[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_event(target, event) {
+  if (!is_event_kind(event.kind)) return { appended: false, position: FIRST_POSITION };
+  const lock = `${target}${LOCK_SUFFIX}`;
+  const position = repository_lock.with_lock_sync(
+    () => append_held(target, event),
+    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 append(target, kind, text, at) {
+  return append_event(target, { at, kind, text });
+}
+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 since(events, reset_kind) {
+  const reset_at = events.findLastIndex((event) => event.kind === reset_kind);
+  return events.slice(reset_at + POSITION_INCREMENT);
+}
+function has_since(events, kind, reset_kind) {
+  return since(events, reset_kind).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,
+  append_event,
+  events_of_text,
+  format_event,
+  has_since,
+  is_stage_start,
+  read_events,
+  read_from,
+  read_last,
+  since,
+  target_of
+};
+
+export {
+  run_event_stream
+};