@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-52CGT2IN.js

@@ -0,0 +1,119 @@
+import {
+  run_event_retry
+} from "./chunk-F7SAHNGR.js";
+import {
+  lane_yield
+} from "./chunk-SIPHEZXP.js";
+import {
+  run_event_scope
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+
+// scripts/backlog/backlog-offer-exclude.ts
+var LIST_SEPARATOR = ",";
+function exclude_of(settled, in_flight) {
+  return [.../* @__PURE__ */ new Set([...settled, ...in_flight])];
+}
+function exclude_argv(exclude) {
+  return exclude.length === 0 ? [] : ["--exclude", exclude.join(LIST_SEPARATOR)];
+}
+var backlog_offer_exclude = { exclude_argv, exclude_of };
+
+// scripts/backlog/backlog-drive-restore.ts
+var ISSUE_IN_EVENT = /#([1-9]\d*)\b/u;
+var SETTLED_KINDS = /* @__PURE__ */ new Set([
+  run_event_stream.EVENT_KIND.MERGE,
+  run_event_stream.EVENT_KIND.PARK,
+  run_event_stream.EVENT_KIND.HUMAN_REVIEW,
+  run_event_stream.EVENT_KIND.SPLIT,
+  run_event_stream.EVENT_KIND.WITHDRAW,
+  run_event_stream.EVENT_KIND.OUTAGE,
+  run_event_stream.EVENT_KIND.USAGE_LIMIT
+]);
+var DONE_KINDS = /* @__PURE__ */ new Set([
+  run_event_stream.EVENT_KIND.MERGE,
+  run_event_stream.EVENT_KIND.PARK,
+  run_event_stream.EVENT_KIND.HUMAN_REVIEW,
+  run_event_stream.EVENT_KIND.SPLIT,
+  run_event_stream.EVENT_KIND.WITHDRAW
+]);
+function issue_of(event) {
+  return ISSUE_IN_EVENT.exec(event.text)?.[1];
+}
+function update_active(active, event) {
+  const issue = issue_of(event);
+  if (issue === void 0) return;
+  if (event.kind === run_event_stream.EVENT_KIND.CHILD_LAUNCH) active.add(issue);
+  if (SETTLED_KINDS.has(event.kind)) active.delete(issue);
+}
+function active_issues(events) {
+  const active = /* @__PURE__ */ new Set();
+  for (const event of events) update_active(active, event);
+  return active;
+}
+function settled_issues(events) {
+  const settled = run_event_retry.current_attempts(events).filter((event) => DONE_KINDS.has(event.kind) && !lane_yield.is_yield(event));
+  return new Set(
+    settled.map((event) => issue_of(event)).filter((issue) => issue !== void 0).map(Number)
+  );
+}
+function issues_of_kind(events, kind) {
+  return events.filter((event) => event.kind === kind).map((event) => issue_of(event)).filter((issue) => issue !== void 0);
+}
+function withdrawn_issues(events) {
+  const named = issues_of_kind(events, run_event_stream.EVENT_KIND.WITHDRAW);
+  return named.filter(
+    (issue) => run_event_scope.is_withdrawn(events, issue) && !lane_yield.is_yielded(events, issue)
+  );
+}
+function waiting_issues(events) {
+  return [...new Set(issues_of_kind(events, run_event_stream.EVENT_KIND.SAMPLE_WAIT))];
+}
+function left_out(events, carried) {
+  const exclude = [.../* @__PURE__ */ new Set([...carried, ...withdrawn_issues(events)])];
+  return { exclude, waiting: [...waiting_issues(events)] };
+}
+function offer_exclude(events) {
+  const merged = issues_of_kind(events, run_event_stream.EVENT_KIND.MERGE);
+  const settled = [...merged, ...waiting_issues(events), ...withdrawn_issues(events)];
+  return backlog_offer_exclude.exclude_of(settled, active_issues(events));
+}
+function parked_issues(events) {
+  return new Set(
+    issues_of_kind(run_event_retry.current_attempts(events), run_event_stream.EVENT_KIND.PARK).map(
+      Number
+    )
+  );
+}
+function mentioned_issues(events) {
+  const tracked = events.filter(
+    (event) => event.kind === run_event_stream.EVENT_KIND.CHILD_LAUNCH || SETTLED_KINDS.has(event.kind)
+  );
+  return new Set(tracked.map((event) => issue_of(event)).filter((issue) => issue !== void 0));
+}
+function restore(lanes, events, merged_issues, dispatched = []) {
+  const active = active_issues(events);
+  const mentioned = mentioned_issues(events);
+  const carried = new Set(dispatched.filter((issue) => !mentioned.has(issue)));
+  return lanes.filter(
+    (issue) => (active.has(issue) || carried.has(issue)) && !merged_issues.includes(Number(issue))
+  );
+}
+var backlog_drive_restore = {
+  DONE_KINDS,
+  active_issues,
+  left_out,
+  mentioned_issues,
+  offer_exclude,
+  restore,
+  withdrawn_issues,
+  settled_issues,
+  parked_issues
+};
+
+export {
+  backlog_offer_exclude,
+  backlog_drive_restore
+};

package/dist/commands/chunk-54ZLBLLE.js

@@ -0,0 +1,74 @@
+import {
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/lane/lane-plan-wait-event.ts
+var { EVENT_KIND } = run_event_stream;
+var START = "start";
+var END = "end";
+var TEXT = /^#(?<issue>[1-9]\d*) (?<phase>start|end) (?<holder>#[1-9]\d*)$/u;
+function text_of(pair, phase) {
+  return `${issue_cite.plain_for("program", pair.issue)} ${phase} ${issue_cite.plain_for("program", pair.holder)}`;
+}
+async function timed(pair, wait) {
+  await run_event_stream_emit.emit(EVENT_KIND.PLAN_WAIT, text_of(pair, START));
+  try {
+    return await wait();
+  } finally {
+    await run_event_stream_emit.emit(EVENT_KIND.PLAN_WAIT, text_of(pair, END));
+  }
+}
+function words_of(event) {
+  if (event.kind !== EVENT_KIND.PLAN_WAIT) return [];
+  return TEXT.exec(event.text)?.slice(1) ?? [];
+}
+function mark_of(event, issue) {
+  const [lane, phase = "", holder = ""] = words_of(event);
+  if (Number(lane) !== issue) return [];
+  return [{ at_ms: Date.parse(event.at), phase, holder }];
+}
+function pair_of(start, end) {
+  if (end.phase !== END || start?.phase !== START || start.holder !== end.holder) return [];
+  return [
+    {
+      from_ms: start.at_ms,
+      to_ms: end.at_ms,
+      name: `lane:plan wait (${end.holder})`
+    }
+  ];
+}
+function spans(events, issue) {
+  const marks = events.flatMap((event) => mark_of(event, issue)).toSorted((left, right) => left.at_ms - right.at_ms);
+  return marks.flatMap((mark, index) => pair_of(marks[index - 1], mark));
+}
+function inside_of(segment, waits) {
+  return waits.map((wait) => ({
+    ...wait,
+    from_ms: Math.max(segment.from_ms, wait.from_ms),
+    to_ms: Math.min(segment.to_ms, wait.to_ms)
+  })).filter((wait) => wait.to_ms > wait.from_ms);
+}
+function carved_one(segment, waits) {
+  const parts = [];
+  let { from_ms } = segment;
+  for (const wait of inside_of(segment, waits)) {
+    if (wait.from_ms > from_ms) parts.push({ ...segment, from_ms, to_ms: wait.from_ms });
+    parts.push({ ...segment, stage: wait.name, from_ms: wait.from_ms, to_ms: wait.to_ms });
+    from_ms = wait.to_ms;
+  }
+  return from_ms < segment.to_ms ? [...parts, { ...segment, from_ms }] : parts;
+}
+function carved(segments, waits) {
+  return segments.flatMap((segment) => carved_one(segment, waits));
+}
+var lane_plan_wait_event = { carved, spans, timed };
+
+export {
+  lane_plan_wait_event
+};

package/dist/commands/chunk-56344LLX.js

@@ -0,0 +1,114 @@
+import {
+  document_section_cli
+} from "./chunk-FZ62KJXP.js";
+import {
+  run_step_section_table
+} from "./chunk-KMVJKK43.js";
+import {
+  agent_session_environment
+} from "./chunk-HHBC6QZE.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  PLATFORM_TEMP_ROOT
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/run/run-step-section-once.ts
+import { createHash } from "node:crypto";
+import { existsSync, writeFileSync } from "node:fs";
+import path from "node:path";
+var MARKER_PREFIX = "josh-section-";
+var DIGEST_LENGTH = 16;
+var TEXT_KEY_PREFIX = "text\n";
+function marker_of(key) {
+  const session = process.env[agent_session_environment.SESSION_ID_KEY];
+  if (session === void 0) return void 0;
+  const digest = createHash("sha256").update(`${session}
+${key}`).digest("hex").slice(0, DIGEST_LENGTH);
+  return path.join(PLATFORM_TEMP_ROOT, `${MARKER_PREFIX}${digest}`);
+}
+function section_key(found) {
+  return `${found.document}
+${found.heading}`;
+}
+function is_key_recorded(key) {
+  const marker = marker_of(key);
+  return marker !== void 0 && existsSync(marker);
+}
+function record_key(key) {
+  const marker = marker_of(key);
+  if (marker !== void 0) writeFileSync(marker, "");
+}
+function is_recorded(found) {
+  return is_key_recorded(section_key(found));
+}
+function record(found) {
+  record_key(section_key(found));
+}
+function is_text_recorded(text) {
+  return is_key_recorded(`${TEXT_KEY_PREFIX}${text}`);
+}
+function record_text(text) {
+  record_key(`${TEXT_KEY_PREFIX}${text}`);
+}
+function repeat_line(found) {
+  const fetch = `pnpm josh doc:section ${found.document} "${found.heading}"`;
+  return `section: ${found.document} \u2192 "${found.heading}" \u2014 printed earlier this session; after a compaction: ${fetch}`;
+}
+var run_step_section_once = { is_recorded, is_text_recorded, record, record_text, repeat_line };
+
+// scripts/run/run-step-section.ts
+var JOSH_PREFIX = "pnpm josh ";
+var COMMAND_SEPARATOR = " ";
+var SUCCESS_EXIT_CODE = 0;
+var { GOVERNING_SECTIONS, LANE_CHILD_SECTIONS } = run_step_section_table;
+function key_of(action) {
+  if (action.kind !== "command") return action.line;
+  const [subcommand = ""] = action.line.slice(JOSH_PREFIX.length).split(COMMAND_SEPARATOR);
+  return subcommand;
+}
+function section_for(key, is_lane_child) {
+  const lane_child_section = is_lane_child ? LANE_CHILD_SECTIONS.get(key) : void 0;
+  return lane_child_section ?? GOVERNING_SECTIONS.get(key);
+}
+function print_section(key, root = process.cwd(), is_lane_child = false) {
+  const found = section_for(key, is_lane_child);
+  if (found === void 0) return SUCCESS_EXIT_CODE;
+  const exit_code = document_section_cli.run([found.document, found.heading], root);
+  if (exit_code === SUCCESS_EXIT_CODE) run_step_section_once.record(found);
+  return exit_code;
+}
+function print_once(key, root = process.cwd()) {
+  const is_lane_child = lane_child_marker.is_child_of(root);
+  const found = section_for(key, is_lane_child);
+  if (found === void 0 || !run_step_section_once.is_recorded(found)) {
+    return print_section(key, root, is_lane_child);
+  }
+  console.info(run_step_section_once.repeat_line(found));
+  return SUCCESS_EXIT_CODE;
+}
+function print_for(action, is_lane_child = false, root = process.cwd()) {
+  return print_section(key_of(action), root, is_lane_child);
+}
+var { CUT, ENTRY, PARK, PAUSE, PROGRESS, RESUME, RETROSPECTIVE } = run_step_section_table;
+var run_step_section = {
+  CUT,
+  ENTRY,
+  GOVERNING_SECTIONS,
+  PARK,
+  PAUSE,
+  PROGRESS,
+  RESUME,
+  RETROSPECTIVE,
+  LANE_CHILD_SECTIONS,
+  key_of,
+  print_for,
+  print_once,
+  print_section
+};
+
+export {
+  run_step_section_once,
+  run_step_section
+};

package/dist/commands/chunk-56GR7L5L.js

@@ -0,0 +1,36 @@
+import {
+  COMMAND_MAP
+} from "./chunk-CCAVK7HN.js";
+import {
+  canonical_command
+} from "./chunk-ROJXMBXP.js";
+
+// scripts/josh/josh-read-only.ts
+var HELP_COMMANDS = /* @__PURE__ */ new Set(["help", "--help", "-h"]);
+var ALL_FLAG = "--all";
+function is_help_request(command) {
+  return command === void 0 || command === ALL_FLAG || HELP_COMMANDS.has(command);
+}
+function entry_of(name) {
+  const command = canonical_command(name);
+  return Object.hasOwn(COMMAND_MAP, command) ? COMMAND_MAP[command] : void 0;
+}
+function is_read_only_call(entry, rest) {
+  const write_flags = entry.write_flags ?? [];
+  if (rest.some((argument) => write_flags.includes(argument.split("=", 1)[0] ?? ""))) return false;
+  if (entry.is_read_only === true) return true;
+  const flags = entry.read_only_flags ?? [];
+  return rest.some((argument) => flags.includes(argument));
+}
+function refusal(args) {
+  const [command = "", ...rest] = args;
+  if (is_help_request(args[0])) return void 0;
+  const entry = entry_of(command);
+  if (entry !== void 0 && is_read_only_call(entry, rest)) return void 0;
+  return `\`josh ${command}\` is not read-only: it carries a declared write flag, or its entry is not declared read-only and it carries no read-only flag its entry declares; read its usage with \`pnpm josh help ${command}\``;
+}
+var josh_read_only = { ALL_FLAG, entry_of, is_help_request, refusal };
+
+export {
+  josh_read_only
+};

package/dist/commands/chunk-5ADJDGFT.js

@@ -0,0 +1,126 @@
+import {
+  issue_publication_state
+} from "./chunk-5RCBXYYD.js";
+import {
+  issue_auto_ok
+} from "./chunk-N5YPDLZM.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  issue_watch_diff
+} from "./chunk-44UIURBQ.js";
+import {
+  gh_author_association
+} from "./chunk-DM6I4PYD.js";
+import {
+  issue_label_schema
+} from "./chunk-34DND4BA.js";
+import {
+  AUTO_OK_LABEL,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+import {
+  read_json_listing
+} from "./chunk-NAZ753DE.js";
+import {
+  bounded_pool
+} from "./chunk-EBVS2LKX.js";
+
+// scripts/auto-ok/auto-ok-judge-read.ts
+import { z } from "zod";
+
+// scripts/auto-ok/auto-ok-judge.ts
+import { createHash } from "node:crypto";
+var MARKER_PREFIX = "<!-- josh:auto-ok-judged v=2 body=";
+var MARKER_SUFFIX = " -->";
+var MARKER_PATTERN = /<!-- josh:auto-ok-judged v=2 body=(?<digest>[\da-f]+) -->/u;
+var DIGEST_LENGTH = 16;
+var CRLF = "\r\n";
+var LF = "\n";
+function is_candidate(issue) {
+  const is_excluded = issue_publication_state.is_pending(issue.body) || !issue.is_trusted;
+  if (is_excluded || has_label_name(issue.labels, AUTO_OK_LABEL)) return false;
+  return issue_auto_ok.exclusion_of(issue.labels) === void 0;
+}
+function body_digest(body) {
+  const normalized = body.split(CRLF).join(LF);
+  return createHash("sha256").update(normalized).digest("hex").slice(0, DIGEST_LENGTH);
+}
+function digest_of(comment) {
+  if (!comment.is_trusted) return void 0;
+  return MARKER_PATTERN.exec(comment.body)?.groups?.["digest"];
+}
+function is_person_comment(comment) {
+  return comment.is_trusted === true && !comment.is_automated;
+}
+function is_judged(body, comments) {
+  const judgement = comments.findLast((comment) => digest_of(comment) !== void 0);
+  if (judgement === void 0 || digest_of(judgement) !== body_digest(body)) return false;
+  return comments.every((comment) => comment.id <= judgement.id || !is_person_comment(comment));
+}
+function comment_of(decision, body) {
+  const marker = `${MARKER_PREFIX}${body_digest(body)}${MARKER_SUFFIX}`;
+  return `${issue_auto_ok.line_of(decision)}${LF}${LF}${marker}`;
+}
+var auto_ok_judge = { comment_of, is_candidate, is_judged };
+
+// scripts/auto-ok/auto-ok-judge-read.ts
+var LISTING_LIMIT = 200;
+var COMMENT_READ_WIDTH = 4;
+var row_schema = z.looseObject({
+  number: z.number(),
+  title: z.string(),
+  body: z.string().nullish(),
+  labels: z.array(issue_label_schema),
+  updatedAt: z.string(),
+  author_association: z.string().nullish(),
+  user: z.looseObject({ login: z.string() }).nullish()
+});
+async function to_row(raw) {
+  return {
+    number: raw.number,
+    title: raw.title,
+    body: raw.body ?? "",
+    labels: raw.labels.map((label) => label.name),
+    updated_at: raw.updatedAt,
+    is_trusted: await gh_author_association.is_trusted({
+      login: raw.user?.login,
+      association: raw.author_association
+    })
+  };
+}
+async function read_candidates() {
+  const { json } = await git_gh_command.issue_list_open_for_judgement(LISTING_LIMIT);
+  if (json === void 0) return void 0;
+  const listing = read_json_listing(json, row_schema);
+  if (listing.kind !== "read") return void 0;
+  const rows = await Promise.all(listing.rows.map(async (raw) => await to_row(raw)));
+  return rows.filter((row) => auto_ok_judge.is_candidate(row));
+}
+async function owes_judgement(row, cache) {
+  if (cache.get(row.number) === row.updated_at) return false;
+  const comments = await issue_watch_diff.parse_comments(
+    await git_gh_command.issue_list_comments(String(row.number))
+  );
+  if (comments === void 0) return false;
+  if (!auto_ok_judge.is_judged(row.body, comments)) return true;
+  cache.set(row.number, row.updated_at);
+  return false;
+}
+async function owed(cache = /* @__PURE__ */ new Map()) {
+  const candidates = await read_candidates();
+  if (candidates === void 0) return void 0;
+  const owing = await bounded_pool.bounded_map(
+    candidates,
+    COMMENT_READ_WIDTH,
+    async (row) => await owes_judgement(row, cache)
+  );
+  return candidates.filter((_row, index) => owing[index] === true);
+}
+var auto_ok_judge_read = { owed };
+
+export {
+  auto_ok_judge,
+  auto_ok_judge_read
+};

package/dist/commands/chunk-5CMXAHCL.js

@@ -0,0 +1,161 @@
+import {
+  run_cut,
+  run_cut_handoff
+} from "./chunk-OTCWA4QE.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/run/cut/run-cut-report.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var CUT_VERDICT = "cut";
+var RESUME_VERDICT = "resume";
+var RESUME_IMPL_VERDICT = "resume-impl";
+var FRESH_VERDICT = "fresh";
+var UNDER_THRESHOLD_VERDICT = "under-threshold";
+var STALE_VERDICT = "stale";
+var INCOMPLETE_VERDICT = "incomplete";
+var BAD_HANDOFF_VERDICT = "bad-handoff";
+var HANDED_OFF_VERDICT = "handed-off";
+var BUSY_VERDICT = "busy";
+var NOT_A_LANE_VERDICT = "not-a-lane";
+var UNREADY_VERDICT = "unready";
+var FAILED_VERDICT = "failed";
+var ENDED_VERDICT = "ended";
+var UNREADABLE_VERDICT = "unreadable";
+var UNKNOWN_VERDICT = "unknown";
+var OVER_VERDICT = "over";
+var printed = { verdict: "" };
+function report(verdict, code) {
+  printed.verdict = verdict;
+  console.info(verdict);
+  return code;
+}
+function last_verdict() {
+  return printed.verdict;
+}
+function report_stale(cut_record) {
+  console.error(run_cut.stale_message(cut_record));
+  return report(STALE_VERDICT, FAILURE_EXIT_CODE);
+}
+function report_busy(cut_record) {
+  console.error(run_cut.busy_message(cut_record));
+  return report(BUSY_VERDICT, FAILURE_EXIT_CODE);
+}
+function report_incomplete(cut_record) {
+  console.error(run_cut.incomplete_message(cut_record));
+  return report(INCOMPLETE_VERDICT, FAILURE_EXIT_CODE);
+}
+var HANDOFF_OVERFLOW_NOTE = "--handoff <path> would grow the cut record past its byte bound";
+var HANDOFF_MISSING_NOTE = "this cut resumes into implementation and needs --handoff <path>";
+function report_bad_handoff(note) {
+  console.error(
+    `${note}. Nothing was cut; write the handoff file at ${run_cut_handoff.HANDOFF_PATH} and reissue.`
+  );
+  return report(BAD_HANDOFF_VERDICT, FAILURE_EXIT_CODE);
+}
+function report_handed_off(cut_record) {
+  console.error(run_cut.handed_off_message(cut_record));
+  return report(HANDED_OFF_VERDICT, SUCCESS_EXIT_CODE);
+}
+function report_unreadable() {
+  console.error(run_cut.unreadable_message());
+  return report(UNREADABLE_VERDICT, FAILURE_EXIT_CODE);
+}
+function report_fault(message) {
+  console.error(message);
+  return report(UNKNOWN_VERDICT, FAILURE_EXIT_CODE);
+}
+function report_unknown() {
+  return report_fault(run_cut.unknown_message());
+}
+function refuse_unready(state) {
+  console.error(
+    `Not ready to cut on ${state.branch} (dirty: ${String(state.is_dirty)}); a cut needs an uncommitted lane branch. Nothing was cut.`
+  );
+  return report(UNREADY_VERDICT, FAILURE_EXIT_CODE);
+}
+function report_under_threshold() {
+  console.error(
+    "The current context is under the shared cut threshold, so nothing was cut; a resume would cost more than the accumulation it would drop. Continue to the gate."
+  );
+  return report(UNDER_THRESHOLD_VERDICT, SUCCESS_EXIT_CODE);
+}
+function report_reviewer() {
+  console.error(
+    "This session is a ship reviewer, which its supervisor is waiting on, so nothing was cut and nothing was relaunched. Finish the review in this process and submit its findings the way your review prompt says."
+  );
+  return report(NOT_A_LANE_VERDICT, SUCCESS_EXIT_CODE);
+}
+function report_held_cut(issue) {
+  console.error(
+    `The cut is recorded for ${session_cite.issue(issue)} outside a lane, so nothing was relaunched. Keep the hold, send a \`confirmation\` Telegram whose body names the resume command \`fullrun ${issue_cite.plain_for("terminal", issue)}\`, and end the turn; the fresh session's \`pnpm josh run:cut --resume ${issue}\` answers \`resume-impl\` with the handoff.`
+  );
+  return report(CUT_VERDICT, SUCCESS_EXIT_CODE);
+}
+var RELAUNCHED_CUT_MARKER = "cut-relaunched";
+function report_relaunched_cut() {
+  console.error(RELAUNCHED_CUT_MARKER);
+  return report(CUT_VERDICT, SUCCESS_EXIT_CODE);
+}
+function report_over() {
+  console.error(
+    "This session is over the shared context-cut threshold (`pnpm josh cost --cut` answers `over`), so the implementation cut was not resumed here and its record is kept. End this conversation and type the invocation again in a fresh session."
+  );
+  return report(OVER_VERDICT, FAILURE_EXIT_CODE);
+}
+function report_missing_supervisor(issue) {
+  console.error(
+    `The OpenAI supervisor for ${session_cite.issue(issue)} is not live, so this nested process was not cut and can continue. Re-dispatch the lane to recover the supervisor.`
+  );
+  return report(FAILED_VERDICT, FAILURE_EXIT_CODE);
+}
+var run_cut_report = {
+  BAD_HANDOFF_VERDICT,
+  BUSY_VERDICT,
+  CUT_VERDICT,
+  ENDED_VERDICT,
+  FAILED_VERDICT,
+  FAILURE_EXIT_CODE,
+  FRESH_VERDICT,
+  HANDED_OFF_VERDICT,
+  HANDOFF_MISSING_NOTE,
+  HANDOFF_OVERFLOW_NOTE,
+  INCOMPLETE_VERDICT,
+  NOT_A_LANE_VERDICT,
+  OVER_VERDICT,
+  RELAUNCHED_CUT_MARKER,
+  RESUME_IMPL_VERDICT,
+  RESUME_VERDICT,
+  STALE_VERDICT,
+  SUCCESS_EXIT_CODE,
+  UNDER_THRESHOLD_VERDICT,
+  UNKNOWN_VERDICT,
+  UNREADABLE_VERDICT,
+  UNREADY_VERDICT,
+  refuse_unready,
+  last_verdict,
+  report,
+  report_bad_handoff,
+  report_busy,
+  report_fault,
+  report_handed_off,
+  report_held_cut,
+  report_incomplete,
+  report_missing_supervisor,
+  report_over,
+  report_relaunched_cut,
+  report_reviewer,
+  report_stale,
+  report_under_threshold,
+  report_unknown,
+  report_unreadable
+};
+
+export {
+  run_cut_report
+};