@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-F4YMLVWN.js

@@ -1,183 +0,0 @@
-import {
-  run_retrospective
-} from "./chunk-IAB6LCJL.js";
-import {
-  latest_scope_cli
-} from "./chunk-BVUL57IX.js";
-import {
-  git_stash
-} from "./chunk-WROJTXWZ.js";
-import {
-  run_event_stream
-} from "./chunk-KGSEWOKI.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-
-// scripts/run/run-step.ts
-var CLOSED = "CLOSED";
-var IMPLEMENT = "implement";
-var HUMAN_REVIEW = "human-review";
-var UPDATE_DEPS = "update-deps";
-var ALREADY_DONE = "already-done";
-var KEEP_WORK = "keep-work";
-var WAIT = "wait";
-var STOP = "stop";
-var UNKNOWN = "unknown";
-var VOCABULARY = [
-  IMPLEMENT,
-  HUMAN_REVIEW,
-  UPDATE_DEPS,
-  ALREADY_DONE,
-  KEEP_WORK,
-  WAIT,
-  STOP,
-  UNKNOWN
-];
-var RETROSPECTIVE_COMMAND = "pnpm josh retrospective";
-function closed_verdict(input) {
-  return input.has_changes ? KEEP_WORK : ALREADY_DONE;
-}
-function pre_verdict(input) {
-  if (input.state === void 0) return UNKNOWN;
-  if (input.state === CLOSED) return closed_verdict(input);
-  if (input.latest_scope === latest_scope_cli.REQUIRED_SCOPE) return UPDATE_DEPS;
-  if (input.is_human_review) return HUMAN_REVIEW;
-  return IMPLEMENT;
-}
-function verdict(token) {
-  return { kind: "verdict", line: token };
-}
-function command(line) {
-  return { kind: "command", line };
-}
-function merge_command(issue_number) {
-  return command(`pnpm josh run:merge ${issue_number}`);
-}
-var KIND = run_event_stream.EVENT_KIND;
-var OFFER_BACKLOG = "pnpm josh backlog:next";
-var EVENT_ACTIONS = {
-  [KIND.PR_OPENED]: () => command("pnpm josh followup"),
-  // `ship --review` asks `review:round2 --record` itself and reuses a recorded round 1, so a run past
-  // round 1 hands the rest of the region to it rather than to the hand-run round-2 steps.
-  [KIND.REVIEW_ROUND]: () => command("pnpm josh ship --review"),
-  [KIND.MERGE]: merge_command,
-  [KIND.OUTAGE]: merge_command,
-  [KIND.PARK]: () => command(OFFER_BACKLOG),
-  // The child was released; `backlog:drive` holds the next launch until the limit resets.
-  [KIND.USAGE_LIMIT]: () => command(OFFER_BACKLOG),
-  [KIND.CUT]: (issue_number) => command(`pnpm josh run:cut --resume ${issue_number}`),
-  // A stall is undispatched ready work with a free lane, so its next step is exactly a park's: offer
-  // the backlog. The detector only reports the stall; reading it here as a dispatch is what turns the
-  // report into the action that resolves it.
-  [KIND.STALL]: () => command(OFFER_BACKLOG),
-  // The post-implementation region is with a detached ship supervisor: nothing
-  // is the agent's until the supervisor stops or the issue closes, which the terminal read answers.
-  [KIND.SHIP_LAUNCH]: () => verdict(WAIT),
-  // The supervisor stopped at a failed stage and handed control back — the next step is reading the
-  // report it stopped on, which names the stage and why.
-  [KIND.SHIP_STOP]: (issue_number) => command(`pnpm josh ship --log ${issue_number}`)
-};
-var PARENT_ONLY_EVENTS = /* @__PURE__ */ new Set([KIND.MERGE, KIND.OUTAGE, KIND.USAGE_LIMIT]);
-function stop_action(input) {
-  return run_retrospective.is_owed(input) ? command(RETROSPECTIVE_COMMAND) : verdict(STOP);
-}
-function drain_action(input) {
-  return run_retrospective.is_owed(input) ? command(RETROSPECTIVE_COMMAND) : verdict(WAIT);
-}
-var HAND_OFF_COMMAND = "pnpm josh run:carry --cut";
-function can_hand_off(input) {
-  if (input.is_lane_child || input.is_at_cut_cap) return false;
-  return input.carry_kind === "carried" && !input.has_completion_callback;
-}
-function child_launch_action(input) {
-  return can_hand_off(input) ? command(HAND_OFF_COMMAND) : verdict(WAIT);
-}
-var FULL_INPUT_ACTIONS = {
-  [KIND.STOP]: stop_action,
-  [KIND.DRAIN]: drain_action,
-  [KIND.CHILD_LAUNCH]: child_launch_action,
-  // A person's restart re-dispatched the child, so the parent's position is a launch's.
-  [KIND.RESTART]: child_launch_action
-};
-function event_action(event, issue_number, is_lane_child) {
-  if (is_lane_child && PARENT_ONLY_EVENTS.has(event)) return verdict(STOP);
-  return EVENT_ACTIONS[event]?.(issue_number) ?? verdict(UNKNOWN);
-}
-var IMPLEMENTATION_POSITIONS = /* @__PURE__ */ new Set([KIND.PLAN, KIND.RESUME]);
-function is_pre_implementation(last_event) {
-  return last_event === void 0 || IMPLEMENTATION_POSITIONS.has(last_event);
-}
-function pre_implementation_action(input) {
-  return verdict(pre_verdict(input));
-}
-function owes_merge(input) {
-  return input.is_merge_owed && input.carry_kind === "carried" && !input.is_lane_child;
-}
-function closed_action(input) {
-  if (owes_merge(input)) return merge_command(input.issue_number);
-  if (closed_verdict(input) === ALREADY_DONE) return verdict(ALREADY_DONE);
-  const message = git_stash.work_message(input.issue_number, ALREADY_DONE);
-  return {
-    kind: "decide",
-    line: `decide: ${session_cite.issue(input.issue_number)} is closed but this tree holds uncommitted work \u2014 keep it with \`pnpm josh stash:push "${message}"\` | carry it into a new issue`
-  };
-}
-function is_handed_off_parent(input) {
-  return input.is_handed_off && input.carry_kind === "carried" && !input.is_lane_child;
-}
-function carry_terminal_action(input) {
-  if (input.carry_kind === "unreadable") return verdict(UNKNOWN);
-  if (is_handed_off_parent(input)) return verdict(STOP);
-  return void 0;
-}
-function terminal_action(input) {
-  const carry_action = carry_terminal_action(input);
-  if (carry_action !== void 0) return carry_action;
-  if (input.state === void 0) return verdict(UNKNOWN);
-  if (input.state === CLOSED) return closed_action(input);
-  return void 0;
-}
-var RETROSPECTIVE_POSITIONS = /* @__PURE__ */ new Set([KIND.DRAIN, KIND.STOP]);
-function is_retrospective_position(input) {
-  return RETROSPECTIVE_POSITIONS.has(input.last_event ?? "") && run_retrospective.is_owed(input);
-}
-function driving_action(input) {
-  if (is_retrospective_position(input)) return command(RETROSPECTIVE_COMMAND);
-  return input.is_at_cut_cap ? verdict(WAIT) : command(HAND_OFF_COMMAND);
-}
-function parent_action(input) {
-  if (input.is_lane_child) return verdict(UNKNOWN);
-  const terminal = carry_terminal_action(input);
-  if (terminal !== void 0) return terminal;
-  return input.is_driving ? driving_action(input) : verdict(UNKNOWN);
-}
-function next_action(input) {
-  const terminal = terminal_action(input);
-  if (terminal !== void 0) return terminal;
-  if (is_pre_implementation(input.last_event)) return pre_implementation_action(input);
-  const event = input.last_event ?? "";
-  const full_input_action = FULL_INPUT_ACTIONS[event];
-  if (full_input_action !== void 0) return full_input_action(input);
-  return event_action(event, input.issue_number, input.is_lane_child);
-}
-var run_step = {
-  ALREADY_DONE,
-  HAND_OFF_COMMAND,
-  HUMAN_REVIEW,
-  IMPLEMENT,
-  KEEP_WORK,
-  RETROSPECTIVE_COMMAND,
-  STOP,
-  UNKNOWN,
-  UPDATE_DEPS,
-  VOCABULARY,
-  WAIT,
-  next_action,
-  parent_action,
-  pre_verdict
-};
-
-export {
-  run_step
-};

package/dist/commands/chunk-F57LACNC.js

@@ -1,84 +0,0 @@
-import {
-  review_brief
-} from "./chunk-EVVQJJFV.js";
-import {
-  review_stamps
-} from "./chunk-S5GX3H4P.js";
-import {
-  file_map_stamp
-} from "./chunk-M32UPB2D.js";
-
-// scripts/gate/gate-skip.ts
-var FORCE_FLAG = "--force";
-var NO_BASE = "the merge base could not be read";
-var NO_CHANGE = "no file differs from the merge base";
-var INPUTS_MOVED = "a checked tool or environment variable changed since the green gate";
-var BASE_MOVED = "the merge base moved since the green gate";
-function base_moved(recorded, base) {
-  return `${BASE_MOVED} (${recorded ?? "none"} \u2192 ${base})`;
-}
-function stamp_miss(stamp, base) {
-  if (stamp.base !== base) return base_moved(stamp.base, base);
-  return review_stamps.gate_stamp.describes_inputs(stamp) ? void 0 : INPUTS_MOVED;
-}
-var NO_MATCHING_RECORD = "no green gate record matches the changed files";
-function record_miss(recorded, tree) {
-  if (recorded === void 0) return NO_MATCHING_RECORD;
-  const changed = String(Object.keys(tree).length);
-  const covered = String(Object.keys(recorded.files).length);
-  const differing = String(file_map_stamp.changed_since(recorded, tree).length);
-  return `${NO_MATCHING_RECORD} (${changed} changed, record covers ${covered}, ${differing} differ)`;
-}
-function gate_reuse(tree, base, source) {
-  if (base === void 0) return { miss: NO_BASE };
-  if (Object.keys(tree).length === 0) return { miss: NO_CHANGE };
-  const recorded = review_stamps.gate_stamp.read(source);
-  const stamp = review_brief.matching_stamp(recorded, tree);
-  if (stamp === void 0) return { miss: record_miss(recorded, tree) };
-  const miss = stamp_miss(stamp, base);
-  return miss === void 0 ? { stamp } : { miss };
-}
-var MISS_KINDS = [
-  [NO_BASE, "no-base"],
-  [NO_CHANGE, "no-change"],
-  [`${NO_MATCHING_RECORD} (`, "record-differs"],
-  [NO_MATCHING_RECORD, "no-record"],
-  [BASE_MOVED, "base-moved"],
-  [INPUTS_MOVED, "inputs-moved"]
-];
-var OTHER_MISS = "other";
-function miss_kind(miss) {
-  return MISS_KINDS.find(([prefix]) => miss.startsWith(prefix))?.[1] ?? OTHER_MISS;
-}
-function stamp_of(reuse) {
-  return "stamp" in reuse ? reuse.stamp : void 0;
-}
-function reusable_green_gate(tree, base, source) {
-  return stamp_of(gate_reuse(tree, base, source));
-}
-function format_reuse_notice(notice) {
-  return `\u2714 this tree is already green \u2014 ${notice.subject} passed on it at ${notice.taken_at} (\`pnpm josh gate\`)${notice.carried_clause}.
-  Reusing that result; nothing was re-run. \`${notice.force_hint}\` runs ${notice.rerun_object} anyway.`;
-}
-function format_skip(taken_at) {
-  return format_reuse_notice({
-    subject: "lint, the type check, the spell check and the unit tests all",
-    carried_clause: "",
-    taken_at,
-    force_hint: `pnpm josh gate ${FORCE_FLAG}`,
-    rerun_object: "the four checks"
-  });
-}
-var gate_skip = {
-  FORCE_FLAG,
-  format_reuse_notice,
-  format_skip,
-  gate_reuse,
-  miss_kind,
-  reusable_green_gate,
-  stamp_of
-};
-
-export {
-  gate_skip
-};

package/dist/commands/chunk-F5N2QIFD.js

@@ -1,213 +0,0 @@
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  agent_session_environment
-} from "./chunk-HHBC6QZE.js";
-import {
-  process_identity
-} from "./chunk-F2RDEF2J.js";
-import {
-  stamp_file
-} from "./chunk-VLN6TSPJ.js";
-import {
-  git_command
-} from "./chunk-IXZZSST7.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/josh/stamp-record.ts
-var NONE_READ = { kind: "none" };
-var UNREADABLE_READ = { kind: "unreadable" };
-function is_older_than(iso, max_age_ms, now) {
-  const at = Date.parse(iso);
-  if (Number.isNaN(at)) return true;
-  return now.getTime() - at > max_age_ms;
-}
-function classify(raw, spec, now) {
-  if (raw === void 0) return NONE_READ;
-  const record = spec.parse(raw);
-  if (record === void 0) return UNREADABLE_READ;
-  const is_expired2 = is_older_than(spec.timestamp_of(record), spec.max_age_ms, now);
-  return { kind: is_expired2 ? "expired" : "carried", record };
-}
-var stamp_record = { classify, is_older_than };
-
-// scripts/run/hold/run-hold.ts
-import { z } from "zod";
-var HOLD_PREFIX = "josh-run-hold-";
-var UNNUMBERED_ISSUE = "new";
-var HOLD_MAX_AGE_HOURS = 8;
-var MILLISECONDS_PER_HOUR = 36e5;
-var HOLD_MAX_AGE_MS = HOLD_MAX_AGE_HOURS * MILLISECONDS_PER_HOUR;
-var RELEASE_COMMAND = "pnpm josh run:release";
-var FORCE_RELEASE_COMMAND = `${RELEASE_COMMAND} --force`;
-var NOT_IDLE = 'that is not "nothing is running here"';
-var FREE_READ = { kind: "free" };
-var UNREADABLE_READ2 = { kind: "unreadable" };
-function hold_path(git_directory) {
-  return stamp_file.stamp_path(HOLD_PREFIX, git_directory);
-}
-async function worktree_directory() {
-  const directories = await git_command.git_directories();
-  return directories[0];
-}
-async function is_linked_worktree() {
-  const directories = await git_command.git_directories();
-  return directories[0] !== void 0 && directories[0] !== directories[1];
-}
-var run_hold_schema = z.object({
-  issue: z.string(),
-  taken_at: z.string(),
-  pid: z.number(),
-  is_fullrun: z.boolean().optional(),
-  is_halfrun_stop: z.boolean().optional(),
-  prrun_stop_head: z.string().optional(),
-  owner_pid: z.number().optional(),
-  owner_start: z.string().optional(),
-  notified_at: z.string().optional()
-});
-function parse_hold(raw) {
-  return json_value.parse_with(raw, run_hold_schema);
-}
-function is_expired(hold, now) {
-  return stamp_record.is_older_than(hold.taken_at, HOLD_MAX_AGE_MS, now);
-}
-function is_stop_marked(hold) {
-  return hold.is_halfrun_stop === true || hold.prrun_stop_head !== void 0;
-}
-function is_owner_gone(hold) {
-  if (is_stop_marked(hold) || hold.owner_pid === void 0) return false;
-  return process_identity.is_same_process(hold.owner_pid, hold.owner_start) === false;
-}
-function is_stale(hold, now) {
-  return is_expired(hold, now) || is_owner_gone(hold);
-}
-function classify2(raw, now) {
-  if (raw === void 0) return FREE_READ;
-  const hold = parse_hold(raw);
-  if (hold === void 0) return UNREADABLE_READ2;
-  return { kind: is_stale(hold, now) ? "stale" : "held", hold };
-}
-function read_hold(target, now = /* @__PURE__ */ new Date()) {
-  return classify2(stamp_file.read_stamp_text(target), now);
-}
-function session_owner(environment = process.env) {
-  const pid = agent_session_environment.session_pid(environment);
-  if (pid === void 0) return {};
-  return { owner_pid: pid, owner_start: process_identity.read_start(pid) };
-}
-function build_hold(issue, now, is_fullrun) {
-  return { issue, taken_at: now.toISOString(), pid: process.pid, is_fullrun, ...session_owner() };
-}
-function write_hold(target, issue, now = /* @__PURE__ */ new Date()) {
-  const hold = build_hold(issue, now);
-  stamp_file.write_stamp(target, hold);
-  return hold;
-}
-function create_hold(target, issue, now = /* @__PURE__ */ new Date(), is_fullrun) {
-  return stamp_file.create_stamp(target, build_hold(issue, now, is_fullrun));
-}
-var HALFRUN_STOP_FIELDS = { is_halfrun_stop: true };
-function create_stop_hold(target, issue, mark, now = /* @__PURE__ */ new Date()) {
-  return stamp_file.create_stamp(target, { ...build_hold(issue, now), ...mark });
-}
-function create_halfrun_stop_hold(target, issue, now = /* @__PURE__ */ new Date()) {
-  return create_stop_hold(target, issue, HALFRUN_STOP_FIELDS, now);
-}
-async function is_tree_dirty(directory) {
-  try {
-    const status = await git_command.status(directory);
-    return status.trim() !== "";
-  } catch (error) {
-    error_text.trace_swallowed("run_hold.is_tree_dirty", error);
-    return true;
-  }
-}
-function release_hold(target) {
-  stamp_file.remove_stamp(target);
-}
-function describe_holder(hold) {
-  const holder = hold.issue === UNNUMBERED_ISSUE ? "an unnumbered run" : session_cite.issue(hold.issue);
-  return `${holder}, recorded ${hold.taken_at} (pid ${String(hold.owner_pid ?? hold.pid)})`;
-}
-function own_release_command(issue) {
-  return issue === UNNUMBERED_ISSUE ? RELEASE_COMMAND : `${RELEASE_COMMAND} ${issue}`;
-}
-function is_own_hold(hold, claimant) {
-  return hold.issue === claimant;
-}
-function is_reentry(hold, claimant) {
-  return claimant !== UNNUMBERED_ISSUE && is_own_hold(hold, claimant);
-}
-function held_message(hold) {
-  return `This working tree is already held by ${describe_holder(hold)}. One run at a time per working tree: a second run here commits its files onto the other run's branch. If that record is stale, run \`${FORCE_RELEASE_COMMAND}\` in this working tree \u2014 it removes a record this run did not write, so be sure the run that did has ended \u2014 and ask again.`;
-}
-function foreign_release_message(hold) {
-  return `This working tree is held by ${describe_holder(hold)}, and this release did not claim it \u2014 nothing was removed. Release it as that run with \`${own_release_command(hold.issue)}\`, or, once you are sure it has ended, remove the record with \`${FORCE_RELEASE_COMMAND}\`.`;
-}
-function forced_release_message(hold) {
-  return `Forced: removed the run record held by ${describe_holder(hold)}.`;
-}
-function unreadable_message() {
-  return `This working tree's run record could not be read \u2014 ${NOT_IDLE}. Run \`${FORCE_RELEASE_COMMAND}\` in this working tree to clear it, then ask again.`;
-}
-function stale_reason(hold) {
-  return is_owner_gone(hold) ? "the session that wrote it has ended" : `older than ${String(HOLD_MAX_AGE_HOURS)} hours`;
-}
-function stale_message(hold) {
-  return `Replaced a stale run record held by ${describe_holder(hold)}: ${stale_reason(hold)}, so the run that wrote it has ended without releasing it.`;
-}
-function uncommitted_message(hold) {
-  return `This working tree still has uncommitted changes, and its run record \u2014 held by ${describe_holder(hold)} \u2014 has expired or outlived its session. That is a run which stopped for a person rather than one that finished, so the tree is not free: commit or stash the work, or run \`${own_release_command(hold.issue)}\` once you are done with it, then ask again.`;
-}
-function race_message(read, target) {
-  if (read.kind === "held") return held_message(read.hold);
-  return `A record already exists at ${target} and this run did not write it \u2014 ${NOT_IDLE}. Either another run claimed the tree at the same moment, or the record belongs to another account. Run \`${FORCE_RELEASE_COMMAND}\`, and remove that file by hand if it is still there.`;
-}
-function unknown_message() {
-  return `Could not read this working tree's git directory \u2014 ${NOT_IDLE}. Run this from inside the checkout the run will edit.`;
-}
-var run_hold = {
-  is_stop_marked,
-  FORCE_RELEASE_COMMAND,
-  HOLD_MAX_AGE_HOURS,
-  HOLD_MAX_AGE_MS,
-  RELEASE_COMMAND,
-  UNNUMBERED_ISSUE,
-  classify: classify2,
-  create_halfrun_stop_hold,
-  create_stop_hold,
-  HALFRUN_STOP_FIELDS,
-  create_hold,
-  describe_holder,
-  foreign_release_message,
-  forced_release_message,
-  held_message,
-  hold_path,
-  is_linked_worktree,
-  is_own_hold,
-  is_reentry,
-  is_tree_dirty,
-  own_release_command,
-  race_message,
-  read_hold,
-  release_hold,
-  session_owner,
-  stale_message,
-  stale_reason,
-  uncommitted_message,
-  unknown_message,
-  unreadable_message,
-  worktree_directory,
-  write_hold
-};
-
-export {
-  stamp_record,
-  run_hold
-};

package/dist/commands/chunk-FA7CN75F.js

@@ -1,160 +0,0 @@
-import {
-  test_related_pins
-} from "./chunk-HE5S4XRE.js";
-import {
-  direct_importers
-} from "./chunk-N4EMFHQ6.js";
-import {
-  related_scope
-} from "./chunk-KJPZPTS4.js";
-import {
-  run_ship_lap
-} from "./chunk-HRN73FQJ.js";
-import {
-  tree_verdict
-} from "./chunk-OZN4HOZT.js";
-import {
-  scoped_green
-} from "./chunk-MHF6BDQI.js";
-import {
-  test_unit_guard
-} from "./chunk-KWLNK2NJ.js";
-import {
-  verification_tail
-} from "./chunk-VCWNMRH7.js";
-import {
-  review_stamps
-} from "./chunk-S5GX3H4P.js";
-import {
-  gate_tree
-} from "./chunk-R36VZIKU.js";
-import {
-  input_fingerprint
-} from "./chunk-GA2YSPFH.js";
-
-// scripts/test/test-related-touched.ts
-import { readdirSync } from "node:fs";
-import path from "node:path";
-var TOUCHED_FLAG = "--touched";
-var TOUCHED_KIND = "touched";
-var TEST_SUFFIX = ".test.ts";
-var TOUCHED_REASON = "the diff test files, their modules' same-named tests, direct test importers and pinned tests";
-var NOTHING_TOUCHED_REASON = "no changed file reaches a touched test";
-function list_directory(directory) {
-  try {
-    return readdirSync(directory);
-  } catch {
-    return [];
-  }
-}
-function is_named_after(module_file, name) {
-  const stem = path.basename(module_file, path.extname(module_file));
-  return name.startsWith(`${stem}.`) && name.endsWith(TEST_SUFFIX);
-}
-function tests_of(root, file, list) {
-  const directory = path.dirname(file);
-  const names = list(path.join(root, directory));
-  if (file.endsWith(TEST_SUFFIX)) return names.includes(path.basename(file)) ? [file] : [];
-  if (!related_scope.is_relatable(file)) return [];
-  return names.filter((name) => is_named_after(file, name)).map((name) => path.join(directory, name));
-}
-function touched_tests(root, changed, list = list_directory) {
-  const tests = changed.flatMap((file) => tests_of(root, file, list));
-  return [.../* @__PURE__ */ new Set([...tests, ...test_related_pins.pinned_tests(changed)])];
-}
-function touched_scope(root, changed, list = list_directory) {
-  const { UNREADABLE_REASON } = related_scope;
-  if (changed === void 0) return { mode: "all", files: [], reason: UNREADABLE_REASON };
-  const files = touched_tests(root, changed, list).map((file) => path.join(root, file));
-  if (files.length === 0) return { mode: "none", files: [], reason: NOTHING_TOUCHED_REASON };
-  return { mode: "related", files, reason: TOUCHED_REASON };
-}
-async function read_scope(root, changed) {
-  if (changed === void 0) return touched_scope(root, changed);
-  const importers = await direct_importers.importers_of(
-    root,
-    changed.filter((file) => related_scope.is_relatable(file))
-  );
-  return touched_scope(root, [...changed, ...[...importers.values()].flat()]);
-}
-var test_related_touched = {
-  NOTHING_TOUCHED_REASON,
-  TOUCHED_FLAG,
-  TOUCHED_KIND,
-  TOUCHED_REASON,
-  read_scope,
-  touched_scope,
-  touched_tests
-};
-
-// scripts/test/test-related-verdict.ts
-function touched_target() {
-  return tree_verdict.record_path("test-related-touched-review");
-}
-async function record_touched(given, before, exit_code) {
-  if (given.length !== 1 || given[0] !== test_related_touched.TOUCHED_FLAG) return;
-  await scoped_green.record_if_green(review_stamps.test_related_stamp, {
-    before,
-    exit_code,
-    target: touched_target()
-  });
-}
-function target_of(given) {
-  const arguments_hash = input_fingerprint.of_entries([JSON.stringify([process.cwd(), given])]);
-  return tree_verdict.record_path(`test-related-${arguments_hash}`);
-}
-async function fresh_verdict(before, target, fresh) {
-  const exit_code = await fresh(before);
-  const tail = `${verification_tail.format_verdict("josh test:related", [])}
-`;
-  if (exit_code === 0) {
-    await tree_verdict.record({ before, exit_code, tail }, gate_tree.read_gate_tree, target);
-  }
-  return { exit_code, is_reused: false };
-}
-function preserved_blobs(before) {
-  if (before === void 0) return void 0;
-  const stamp = review_stamps.test_related_stamp.read();
-  if (stamp === void 0 || !scoped_green.is_unmoved(before, { files: stamp.files, base: stamp.base }) || !review_stamps.test_related_stamp.describes_inputs(stamp)) {
-    return void 0;
-  }
-  return stamp.blobs;
-}
-async function reused_verdict(given, before, target, kept) {
-  if (given.length === 0) {
-    const blobs = preserved_blobs(before);
-    await scoped_green.record_if_green(review_stamps.test_related_stamp, {
-      before,
-      exit_code: 0,
-      ...blobs !== void 0 && { blobs }
-    });
-  }
-  await record_touched(given, before, 0);
-  return { exit_code: tree_verdict.replay(kept, target), is_reused: true };
-}
-async function checked(given, fresh) {
-  const before = await scoped_green.read_before([]);
-  const target = target_of(given);
-  const kept = tree_verdict.read(before, target);
-  if (kept?.exit_code === 0) return await reused_verdict(given, before, target, kept);
-  const result = await fresh_verdict(before, target, fresh);
-  await record_touched(given, before, result.exit_code);
-  return result;
-}
-async function run(given, fresh) {
-  if (!test_unit_guard.is_running(process.cwd())) return await fresh(void 0);
-  const outcome = await run_ship_lap.timed(
-    "test:related",
-    async () => await checked(given, fresh),
-    {
-      note_of: (result) => ({ is_reused: result.is_reused })
-    }
-  );
-  return outcome.exit_code;
-}
-var test_related_verdict = { run, touched_target };
-
-export {
-  test_related_touched,
-  test_related_verdict
-};