@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-KGSEWOKI.js

@@ -0,0 +1,353 @@
+import {
+  repository_lock
+} from "./chunk-NUCFIYZL.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  durable_state
+} from "./chunk-DS53UUDH.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
+};

package/dist/commands/chunk-KHGDZQRG.js

@@ -0,0 +1,271 @@
+import {
+  test_related
+} from "./chunk-RDUFVQVJ.js";
+import {
+  test_unit_guard
+} from "./chunk-KWLNK2NJ.js";
+import {
+  gate_log,
+  verification_tail
+} from "./chunk-VCWNMRH7.js";
+import {
+  moved_paths
+} from "./chunk-PBAEJ5PT.js";
+import {
+  review_tree
+} from "./chunk-R36VZIKU.js";
+import {
+  file_map_stamp
+} from "./chunk-M32UPB2D.js";
+import {
+  verification_inputs
+} from "./chunk-MHXIJKGP.js";
+import {
+  NOTHING_TO_CHECK_MARKER,
+  NOT_USED_MARKER
+} from "./chunk-IW6NWCSN.js";
+import {
+  josh_verdict
+} from "./chunk-JTU5A4JI.js";
+import {
+  status_icons
+} from "./chunk-65E4OZJ7.js";
+import {
+  gate_labels
+} from "./chunk-WQ6FS544.js";
+import {
+  GATE_COMMAND
+} from "./chunk-TBIX5FRN.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  buffered_process
+} from "./chunk-JZHY7D6D.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  MS_PER_SECOND
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/gate/gate-report.ts
+var { FAIL_ICON, PASS_ICON, WARN_ICON } = status_icons;
+function is_gate_step_failed(result) {
+  return buffered_process.is_process_failed(result);
+}
+function is_skip_notice(result) {
+  return result.output.includes(test_unit_guard.SKIP_MARKER);
+}
+var WARNING_MARKERS = ["warning", "Warning", "\u26A0"];
+function has_warnings(result) {
+  return WARNING_MARKERS.some((marker) => result.output.includes(marker));
+}
+var SAFE_CHAIN_BANNER = "safe-chain is not available";
+var PNPM_SCRIPT_HEADER = "$ ";
+var LINT_FILE_PREFIX = "  - ";
+function checker_lines(result) {
+  return result.output.split("\n").filter((line) => !line.includes(SAFE_CHAIN_BANNER) && !line.startsWith(PNPM_SCRIPT_HEADER));
+}
+function has_checker_warning(result) {
+  if (!gate_labels.WARNING_CHECKER_LABELS.includes(result.label)) return false;
+  return checker_lines(result).filter((line) => result.label !== gate_labels.LINT_LABEL || !line.startsWith(LINT_FILE_PREFIX)).some((line) => WARNING_MARKERS.some((marker) => line.includes(marker)));
+}
+function is_unverified_skip(result) {
+  return checker_lines(result).some(
+    (line) => line.includes(test_unit_guard.SKIP_MARKER) && !line.includes(NOT_USED_MARKER)
+  );
+}
+function has_nothing_to_say(result) {
+  return !is_unverified_skip(result) && !has_checker_warning(result);
+}
+var IDLE_MARKERS = [test_unit_guard.SKIP_MARKER, NOTHING_TO_CHECK_MARKER];
+function is_idle_line(line) {
+  return IDLE_MARKERS.some((marker) => line.includes(marker));
+}
+function is_tool_line(line) {
+  return line.trim() !== "";
+}
+function is_idle(result) {
+  const lines = checker_lines(result).filter((line) => is_tool_line(line));
+  return lines.length > 0 && lines.every((line) => is_idle_line(line));
+}
+function should_print_body(result, is_verbose) {
+  if (is_verbose || is_gate_step_failed(result)) return true;
+  return is_skip_notice(result) || has_warnings(result);
+}
+var SECONDS_DECIMALS = 1;
+function format_seconds(elapsed_ms) {
+  return `${(elapsed_ms / MS_PER_SECOND).toFixed(SECONDS_DECIMALS)}s`;
+}
+function gate_step_header(result) {
+  const icon = is_gate_step_failed(result) ? FAIL_ICON : PASS_ICON;
+  const timing = result.reused_at === void 0 ? format_seconds(result.elapsed_ms) : `reused \u2014 inputs unchanged since it passed at ${result.reused_at}`;
+  return `${icon} ${result.label} (pnpm ${result.command}) ${timing}`;
+}
+function print_gate_step(result, is_verbose) {
+  process.stdout.write(`
+${gate_step_header(result)}
+`);
+  if (should_print_body(result, is_verbose) && result.output) {
+    process.stdout.write(`${result.output}
+`);
+  }
+}
+function format_failure_actions(failed) {
+  if (failed.length === 0) return "";
+  const lines = failed.map(
+    (result) => verification_tail.format_rerun(result.label, `pnpm ${result.command}`)
+  );
+  return `${GATE_COMMAND} \u2014 next:
+${lines.join("\n")}
+`;
+}
+function format_budget_notes(results) {
+  const lines = results.flatMap(
+    (result) => result.budget_note === void 0 ? [] : `  ${WARN_ICON} ${result.label} \u2014 ${result.budget_note}`
+  );
+  return lines.length === 0 ? "" : `${lines.join("\n")}
+`;
+}
+function format_green_verdict(results, total) {
+  const has_skip = results.some((result) => is_skip_notice(result));
+  const skipped = has_skip ? results.filter((result) => is_idle(result)).length : 0;
+  const ran = results.length - skipped;
+  if (ran === 0) return josh_verdict.format_gate_unverified(skipped, total);
+  return josh_verdict.format_gate_passed({ ran, skipped }, total);
+}
+function print_gate_summary(results, report, log_path) {
+  const failed = results.filter((result) => is_gate_step_failed(result));
+  const total = format_seconds(report.elapsed_ms);
+  const verdict = failed.length === 0 ? format_green_verdict(results, total) : josh_verdict.format_gate_failed(failed.map((result) => result.label).join(", "), total);
+  const failures = `${format_budget_notes(results)}${format_failure_actions(failed)}`;
+  process.stdout.write(
+    `
+${verification_tail.format_tail({ failures, log: { path: log_path }, verdict })}`
+  );
+}
+function report_gate_steps(results, report) {
+  for (const result of results) print_gate_step(result, report.is_verbose);
+  const entries = results.map((result) => ({
+    header: gate_step_header(result),
+    output: result.output
+  }));
+  const written_log = gate_log.write_gate_log(entries, report.log_path);
+  print_gate_summary(results, report, written_log);
+  return results.filter((result) => is_gate_step_failed(result)).map((result) => result.label);
+}
+var gate_report = {
+  format_budget_notes,
+  format_failure_actions,
+  has_checker_warning,
+  has_nothing_to_say,
+  is_gate_step_failed,
+  report_gate_steps
+};
+
+// scripts/gate/check-inputs.ts
+import path from "node:path";
+function prettier_ignored(root) {
+  const ignore_path = verification_inputs.PRETTIER_IGNORE_FILES.map((name) => path.join(root, name));
+  return async function is_ignored(relative) {
+    try {
+      const prettier = await import("prettier");
+      const info = await prettier.getFileInfo(path.join(root, relative), {
+        ignorePath: ignore_path
+      });
+      return info.ignored;
+    } catch {
+      return false;
+    }
+  };
+}
+async function reads_any(declaration, paths, is_ignored, root) {
+  if (declaration.reads === "recorded") return await test_related.reaches_tests(root, paths);
+  const { is_input } = declaration;
+  if (is_input === void 0) return true;
+  const answers = await Promise.all(
+    paths.map(async (relative) => await is_input(relative, is_ignored))
+  );
+  return answers.includes(true);
+}
+async function touches_inputs(label, paths, is_ignored, root = PROJECT_ROOT) {
+  const declaration = verification_inputs.declaration_of(label);
+  if (declaration === void 0 || verification_inputs.configures(label, paths, root)) return true;
+  return await reads_any(declaration, paths, is_ignored, root);
+}
+var check_inputs = { prettier_ignored, touches_inputs };
+
+// scripts/gate/check-reuse.ts
+var CHECK_PREFIX = "josh-gate-check-";
+function declared_inputs(label) {
+  if (!verification_inputs.is_declared(label)) return void 0;
+  return {
+    fingerprint: () => verification_inputs.fingerprint([label]),
+    touches: async (moved, context) => await check_inputs.touches_inputs(label, moved, context.is_ignored, context.root)
+  };
+}
+function check_stamp(inputs) {
+  return file_map_stamp.create(CHECK_PREFIX, PROJECT_ROOT, inputs.fingerprint);
+}
+function default_records(label) {
+  return stamp_file.stamp_path(`${CHECK_PREFIX}${label}-`, PROJECT_ROOT);
+}
+async function is_stamp_reusable(inputs, stamp, context) {
+  const moved = await moved_paths.moved_since(stamp, context.tree);
+  if (moved === void 0 || !check_stamp(inputs).describes_inputs(stamp)) return false;
+  return !await inputs.touches(moved, context);
+}
+async function reused_at(label, inputs, context) {
+  if (inputs === void 0) return void 0;
+  const stamp = check_stamp(inputs).read(context.records(label));
+  if (stamp === void 0) return void 0;
+  return await is_stamp_reusable(inputs, stamp, context) ? stamp.taken_at : void 0;
+}
+async function read_root() {
+  try {
+    return await git_command.repository_root();
+  } catch {
+    return void 0;
+  }
+}
+async function reusable_checks(labels, tree, records = default_records, inputs_of = declared_inputs) {
+  const root = await read_root();
+  if (root === void 0) return /* @__PURE__ */ new Map();
+  const context = { tree, records, root, is_ignored: check_inputs.prettier_ignored(root) };
+  const answers = await Promise.all(
+    labels.map(
+      async (label) => [label, await reused_at(label, inputs_of(label), context)]
+    )
+  );
+  return new Map(answers.flatMap(([label, at]) => at === void 0 ? [] : [[label, at]]));
+}
+function recordable_inputs(result, inputs_of) {
+  const is_quiet_pass = !gate_report.is_gate_step_failed(result) && gate_report.has_nothing_to_say(result);
+  return is_quiet_pass ? inputs_of(result.label) : void 0;
+}
+function write_records(results, tree, records, inputs_of) {
+  for (const result of results) {
+    const inputs = recordable_inputs(result, inputs_of);
+    if (inputs !== void 0) {
+      check_stamp(inputs).write(tree.files, records(result.label), tree.base);
+    }
+  }
+}
+async function record_green_checks(results, tree, records = default_records, inputs_of = declared_inputs) {
+  try {
+    const after = await review_tree.read_changed_tree();
+    if (JSON.stringify(after) !== JSON.stringify(tree.files)) return;
+    write_records(results, { files: after, base: tree.base }, records, inputs_of);
+  } catch {
+  }
+}
+var check_reuse = { DEFAULT_RECORDS: default_records, record_green_checks, reusable_checks };
+
+export {
+  gate_report,
+  check_reuse
+};