@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-DHDKG5HZ.js

@@ -1,151 +0,0 @@
-import {
-  run_wake
-} from "./chunk-QCRUPRQ2.js";
-import {
-  run_carry_ended
-} from "./chunk-KPAJBJXG.js";
-import {
-  telegram_notify
-} from "./chunk-MDKRTUE4.js";
-import {
-  run_event_stream_emit
-} from "./chunk-26JL4UU4.js";
-import {
-  run_event_stream
-} from "./chunk-KGSEWOKI.js";
-import {
-  run_carry
-} from "./chunk-DS53UUDH.js";
-import {
-  process_identity
-} from "./chunk-F2RDEF2J.js";
-
-// scripts/run/run-stranded.ts
-var RECOVERY_COMMAND = "pnpm josh run:wake --start";
-var LIVE = "live";
-var GONE = "gone";
-var UNKNOWN = "unknown";
-var STRANDED = "stranded";
-var OK = "ok";
-function supervisor_liveness(wake, same_process = process_identity.is_same_process) {
-  if (wake === void 0) return GONE;
-  const is_same = same_process(wake.pid, wake.process_start);
-  if (is_same === void 0) return UNKNOWN;
-  return is_same ? LIVE : GONE;
-}
-function had_driver(carry) {
-  return carry.is_handed_off === true || carry.owner_pid !== void 0;
-}
-function is_stranded(input) {
-  if (input.read.kind !== "carried" || input.is_owner_live || !had_driver(input.read.carry)) {
-    return false;
-  }
-  return input.supervisor === GONE;
-}
-function describe(carry) {
-  return `Run stranded \u2014 ${run_carry.describe_carry(carry)}. The owner is gone, no successor holds the budget, and no supervisor is watching.`;
-}
-function verdict_of(is_run_stranded) {
-  return is_run_stranded ? STRANDED : OK;
-}
-var run_stranded = {
-  GONE,
-  LIVE,
-  OK,
-  RECOVERY_COMMAND,
-  STRANDED,
-  UNKNOWN,
-  describe,
-  is_stranded,
-  supervisor_liveness,
-  verdict_of
-};
-
-// scripts/run/run-stranded-detect.ts
-var STRAND_RECOVERY = `Restart supervision with \`${run_stranded.RECOVERY_COMMAND}\` \u2014 it wakes a fresh successor to claim the budget; the cutting session must not resume it itself.`;
-function targets_of(directory) {
-  return { carry: run_carry.carry_path(directory), wake: run_wake.wake_path(directory) };
-}
-async function real_resolve_targets() {
-  const directory = await run_carry.repository_directory();
-  return directory === void 0 ? void 0 : targets_of(directory);
-}
-async function real_emit_stranded(text) {
-  return await run_event_stream_emit.emit_once(run_event_stream.EVENT_KIND.STRANDED, text);
-}
-async function real_notify_stranded(body) {
-  return await telegram_notify.stranded({ body, recovery: STRAND_RECOVERY });
-}
-var DEFAULT_PORTS = {
-  resolve_targets: real_resolve_targets,
-  read_carry: (target) => run_carry.read_carry(target),
-  is_owner_live: run_carry.is_owner_live,
-  has_ended: run_carry_ended.has_ended,
-  read_wake: (target) => run_wake.read_wake(target),
-  supervisor_liveness: (wake) => run_stranded.supervisor_liveness(wake),
-  emit_stranded: real_emit_stranded,
-  notify_stranded: real_notify_stranded
-};
-function input_at(ports, targets) {
-  const read = ports.read_carry(targets.carry);
-  if (read.kind !== "carried") return void 0;
-  return {
-    read,
-    is_owner_live: ports.is_owner_live(read.carry),
-    supervisor: ports.supervisor_liveness(ports.read_wake(targets.wake))
-  };
-}
-async function gather(ports) {
-  const targets = await ports.resolve_targets();
-  return targets === void 0 ? void 0 : input_at(ports, targets);
-}
-async function report(ports, input) {
-  if (input.read.kind !== "carried") return;
-  const text = run_stranded.describe(input.read.carry);
-  if (await ports.emit_stranded(text)) await ports.notify_stranded(text);
-}
-async function detect_and_report(ports = DEFAULT_PORTS) {
-  const input = await gather(ports);
-  if (input === void 0) return run_stranded.OK;
-  const is_run_stranded = run_stranded.is_stranded(input);
-  if (is_run_stranded) await report(ports, input);
-  return run_stranded.verdict_of(is_run_stranded);
-}
-async function run_stranded_check() {
-  try {
-    await detect_and_report();
-  } catch {
-  }
-}
-function is_stranded_at(directory, ports = DEFAULT_PORTS) {
-  const input = input_at(ports, targets_of(directory));
-  return input !== void 0 && run_stranded.is_stranded(input);
-}
-function ports_with(same_process) {
-  return {
-    ...DEFAULT_PORTS,
-    is_owner_live: (carry) => run_carry.is_owner_live(carry, /* @__PURE__ */ new Date(), same_process),
-    supervisor_liveness: (wake) => run_stranded.supervisor_liveness(wake, same_process)
-  };
-}
-function is_left_stranded(run, ports = DEFAULT_PORTS) {
-  const read = ports.read_carry(run.carry_target);
-  if (read.kind !== "carried") return !ports.has_ended(run.ended_target, run.started_at);
-  return run_stranded.is_stranded({
-    read,
-    is_owner_live: run_carry.is_held_by_another(read.carry, ports.is_owner_live),
-    supervisor: run_stranded.GONE
-  });
-}
-var run_stranded_detect = {
-  detect_and_report,
-  is_left_stranded,
-  is_stranded_at,
-  ports_with,
-  run_stranded_check
-};
-
-export {
-  run_stranded,
-  run_stranded_detect
-};

package/dist/commands/chunk-DHJRFBKO.js

@@ -1,223 +0,0 @@
-import {
-  agent_event
-} from "./chunk-LULJUD6P.js";
-import {
-  issue_state
-} from "./chunk-WXXLJQBO.js";
-import {
-  git_gh_issue_read
-} from "./chunk-TFYYXETQ.js";
-import {
-  run_hold
-} from "./chunk-F5N2QIFD.js";
-import {
-  lane_state
-} from "./chunk-7EAYFMDN.js";
-import {
-  has_parked_label
-} from "./chunk-QQBMVC5W.js";
-import {
-  issue_number_shape
-} from "./chunk-G75GWNNY.js";
-import {
-  PLATFORM_TEMP_ROOT
-} from "./chunk-VLN6TSPJ.js";
-import {
-  MS_PER_MINUTE,
-  MS_PER_SECOND
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/run/run-liveness.ts
-import { readFileSync, realpathSync, statSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
-import path from "node:path";
-import { setTimeout as sleep } from "node:timers/promises";
-var ALIVE_VERDICT = "alive";
-var PAUSED_VERDICT = "paused";
-var SETTLED_VERDICT = "settled";
-var STOPPED_VERDICT = "stopped";
-var UNDETERMINED_VERDICT = "undetermined";
-var PROCESS_ALIVE = "alive";
-var PROCESS_NONE = "none";
-var PROCESS_UNKNOWN = "unknown";
-var DEFAULT_SILENT_MINUTES = 30;
-var DEFAULT_GAP_SECONDS = 5;
-var OPEN_STATE = "OPEN";
-var STATE_FIELDS = "state,labels";
-var REASONS = {
-  [ALIVE_VERDICT]: "The unit is still working: its output moved, or a process of the child is alive.",
-  [PAUSED_VERDICT]: "The lane state record says the lane is paused: its child is suspended, not working, and nothing moves until someone resumes it.",
-  [SETTLED_VERDICT]: "The child is closed, parked with `needs-decision` or `run:stalled`, or marked `already-done`, so there is nothing here to recover.",
-  [STOPPED_VERDICT]: "The output has been frozen past the silent window and no process of the child is alive in that checkout.",
-  [UNDETERMINED_VERDICT]: "A trace could not be read, so this says nothing about the unit. A trace that could not be read answers `undetermined`, never `stopped`."
-};
-var ALIVE_ADVICE = "Keep waiting on `pnpm josh lane:await`; do not touch the child.";
-var PAUSED_ADVICE = "Do not wait on it and do not recover it: tell the person the lane is paused; `pnpm josh lane:resume <N>` resumes it once they ask.";
-var SETTLED_ADVICE = "Read the child with `pnpm josh issue:state <N>` and take the branch its state says.";
-var STOPPED_CLEAN_ADVICE = "The unit ended \u2014 classify how before booking it. Run `pnpm josh run:merge <N> --output <path>` (add `--epic <E> --repo <owner/repo>` for a named epic): it reads the child's exit record without waiting for the unit to return, re-dispatches a child that could not reach the API (counting the outage; a run of them trips the environment guard, which holds launches), and parks an abandoned child with `run:stalled` against the consecutive-failure guard. The checkout is clean, so there is nothing to stash.";
-var STOPPED_DIRTY_ADVICE = "Classify how the unit ended with `pnpm josh run:merge <N> --output <path> --stash` (add `--epic <E> --repo <owner/repo>` for a named epic): `--stash` first stashes the half-finished work and records its `stash:pop` line on the Issue, then it re-dispatches an API-outage child (counting the outage; a run of them trips the environment guard, which holds launches) and parks an abandoned child with `run:stalled` against the consecutive-failure guard, without waiting for the unit to return.";
-var UNDETERMINED_ADVICE = "Read the trace that failed and ask again. Where the process trace was given as `unknown`, leave `--process` out so the command reads it. Two of these in a row is a fault in the check itself rather than a slow unit: stop polling and report it.";
-function is_output_moving(traces) {
-  return traces.is_output_frozen === false;
-}
-function is_agent_state_finished(state) {
-  return state?.result === "completed" || state?.result === "failed";
-}
-function is_agent_finished(traces) {
-  return is_agent_state_finished(traces.agent_state);
-}
-function recorded_verdict(state) {
-  if (state === "paused") return PAUSED_VERDICT;
-  return state === "ended" ? SETTLED_VERDICT : void 0;
-}
-function definitive_verdict(traces) {
-  if (traces.is_child_settled === true) return SETTLED_VERDICT;
-  const recorded = recorded_verdict(traces.lane_state);
-  if (recorded !== void 0) return recorded;
-  if (is_agent_finished(traces)) return STOPPED_VERDICT;
-  if (is_output_moving(traces)) return ALIVE_VERDICT;
-  return void 0;
-}
-function is_check_running(traces) {
-  return traces.process_trace === PROCESS_ALIVE;
-}
-function has_unreadable_trace(traces) {
-  return traces.is_child_settled === void 0 || traces.is_output_frozen === void 0 || traces.process_trace === PROCESS_UNKNOWN;
-}
-function to_verdict(traces) {
-  const definitive = definitive_verdict(traces);
-  if (definitive !== void 0) return definitive;
-  if (has_unreadable_trace(traces)) return UNDETERMINED_VERDICT;
-  return is_check_running(traces) ? ALIVE_VERDICT : STOPPED_VERDICT;
-}
-var ADVICE = {
-  [ALIVE_VERDICT]: ALIVE_ADVICE,
-  [PAUSED_VERDICT]: PAUSED_ADVICE,
-  [SETTLED_VERDICT]: SETTLED_ADVICE,
-  [UNDETERMINED_VERDICT]: UNDETERMINED_ADVICE
-};
-function to_advice(verdict, has_work_to_stash) {
-  if (verdict !== STOPPED_VERDICT) return ADVICE[verdict];
-  return has_work_to_stash ? STOPPED_DIRTY_ADVICE : STOPPED_CLEAN_ADVICE;
-}
-function decide(traces) {
-  const verdict = to_verdict(traces);
-  const has_work_to_stash = verdict === STOPPED_VERDICT && traces.is_tree_dirty;
-  return {
-    advice: to_advice(verdict, has_work_to_stash),
-    has_work_to_stash,
-    reason: traces.agent_state?.reason ?? REASONS[verdict],
-    verdict
-  };
-}
-function to_resolved_root(root) {
-  try {
-    return realpathSync(root);
-  } catch {
-    return root;
-  }
-}
-var ALLOWED_ROOTS = [
-  ...new Set(
-    [homedir(), tmpdir(), PLATFORM_TEMP_ROOT].flatMap((root) => [root, to_resolved_root(root)])
-  )
-];
-function is_within(candidate, root) {
-  const relative = path.relative(root, candidate);
-  return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
-}
-function to_safe_path(output_path) {
-  const normalized = path.normalize(output_path);
-  if (!path.isAbsolute(normalized)) return void 0;
-  return ALLOWED_ROOTS.some((root) => is_within(normalized, root)) ? normalized : void 0;
-}
-function sample_output(output_path) {
-  const safe_path = to_safe_path(output_path);
-  if (safe_path === void 0) return void 0;
-  const stats = statSync(safe_path, { throwIfNoEntry: false });
-  if (!stats?.isFile()) return void 0;
-  return { mtime_ms: stats.mtimeMs, size: stats.size };
-}
-function read_agent_state(output_path) {
-  const safe_path = to_safe_path(output_path);
-  if (safe_path === void 0) return void 0;
-  try {
-    const state = agent_event.read(readFileSync(safe_path, "utf8"));
-    return state.provider === void 0 ? void 0 : state;
-  } catch {
-    return void 0;
-  }
-}
-function describe_agent_state(output_path) {
-  const state = read_agent_state(output_path);
-  return state === void 0 ? void 0 : `agent: ${state.provider ?? "unknown"} ${agent_event.describe(state)}`;
-}
-async function read_output_frozen(request) {
-  const first = sample_output(request.output_path);
-  if (first === void 0) return void 0;
-  if (request.now_ms - first.mtime_ms < request.silent_window_ms) return false;
-  await sleep(request.gap_ms);
-  const second = sample_output(request.output_path);
-  if (second === void 0) return void 0;
-  return second.mtime_ms === first.mtime_ms && second.size === first.size;
-}
-function carries_settled_label(labels) {
-  return has_parked_label(labels);
-}
-async function read_child_settled(issue, repo) {
-  const json = await git_gh_issue_read.issue_view_json(issue, STATE_FIELDS, repo);
-  if (json === void 0) return void 0;
-  const state = issue_state.parse_issue_state(json);
-  if (state === void 0) return void 0;
-  return state.state !== OPEN_STATE || carries_settled_label(state.labels);
-}
-function freshness_of(request) {
-  return {
-    gap_ms: request.gap_ms ?? DEFAULT_GAP_SECONDS * MS_PER_SECOND,
-    now_ms: Date.now(),
-    output_path: request.output_path,
-    silent_window_ms: request.silent_window_ms ?? DEFAULT_SILENT_MINUTES * MS_PER_MINUTE
-  };
-}
-async function read_traces(request) {
-  const [is_initial_child_settled, is_output_frozen, is_tree_dirty, record] = await Promise.all([
-    read_child_settled(request.issue, request.repo),
-    read_output_frozen(freshness_of(request)),
-    run_hold.is_tree_dirty(),
-    lane_state.read_state(request.issue)
-  ]);
-  const agent_state = read_agent_state(request.output_path);
-  const is_latest_child_settled = is_agent_state_finished(agent_state) ? await read_child_settled(request.issue, request.repo) : void 0;
-  const is_child_settled = is_latest_child_settled ?? is_initial_child_settled;
-  return {
-    agent_state,
-    is_child_settled,
-    is_output_frozen,
-    is_tree_dirty,
-    lane_state: record?.state,
-    process_trace: request.process_trace
-  };
-}
-async function check(request) {
-  issue_number_shape.require_issue_number(request.issue);
-  return decide(await read_traces(request));
-}
-var run_liveness = {
-  check,
-  decide,
-  describe_agent_state,
-  read_agent_state,
-  read_child_settled,
-  read_output_frozen,
-  sample_output,
-  to_safe_path
-};
-
-export {
-  UNDETERMINED_VERDICT,
-  PROCESS_ALIVE,
-  PROCESS_NONE,
-  PROCESS_UNKNOWN,
-  DEFAULT_SILENT_MINUTES,
-  run_liveness
-};

package/dist/commands/chunk-DKO5VTEH.js

@@ -1,65 +0,0 @@
-import {
-  observation_ledger_home
-} from "./chunk-QXBOECGL.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/hooks/hook-ledger-read.ts
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { z } from "zod";
-var LEDGER_EXTENSION = ".jsonl";
-var HOURS_PER_DAY = 24;
-var MS_PER_HOUR = 36e5;
-var MS_PER_DAY = HOURS_PER_DAY * MS_PER_HOUR;
-var KEY_SEPARATOR = "	";
-var line_schema = z.object({
-  at: z.string(),
-  hook: z.string(),
-  rule: z.string(),
-  tool: z.string(),
-  session: z.string(),
-  command: z.string()
-});
-function period_start(period_days, now) {
-  return now.getTime() - period_days * MS_PER_DAY;
-}
-function day_files(directory, period_days, now) {
-  const count = Math.ceil(period_days) + 1;
-  const days = Array.from(
-    { length: count },
-    (_, index) => observation_ledger_home.ledger_date(new Date(now.getTime() - (count - 1 - index) * MS_PER_DAY))
-  );
-  return days.map((day) => path.join(directory, `${day}${LEDGER_EXTENSION}`));
-}
-async function read_text(file) {
-  try {
-    return await readFile(file, "utf8");
-  } catch {
-    return "";
-  }
-}
-function lines_of(text) {
-  return text.split("\n").map((line) => json_value.parse_with(line, line_schema)).filter((line) => line !== void 0);
-}
-async function read_lines(directory, period_days, now) {
-  const files = day_files(directory, period_days, now);
-  const texts = await Promise.all(files.map(async (file) => await read_text(file)));
-  const start = period_start(period_days, now);
-  return texts.flatMap((text) => lines_of(text)).filter((line) => Date.parse(line.at) >= start);
-}
-function group(lines) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const line of lines) {
-    const key = `${line.hook}${KEY_SEPARATOR}${line.rule}`;
-    const found = groups.get(key) ?? { hook: line.hook, rule: line.rule, lines: [] };
-    groups.set(key, { ...found, lines: [...found.lines, line] });
-  }
-  return [...groups.values()].toSorted((left, right) => right.lines.length - left.lines.length);
-}
-var hook_ledger_read = { group, period_start, read_lines };
-
-export {
-  hook_ledger_read
-};

package/dist/commands/chunk-DLHH3MLS.js

@@ -1,85 +0,0 @@
-import {
-  changed_file_scope
-} from "./chunk-QX2EMUXV.js";
-import {
-  project_checks
-} from "./chunk-RO4QEZJO.js";
-import {
-  ESLINT_RELATED_CACHE_FILE,
-  ESLINT_RELATED_CACHE_FLAGS,
-  PRETTIER_RELATED_CACHE_FLAGS
-} from "./chunk-TBIX5FRN.js";
-
-// scripts/lint/lint-related-scope.ts
-import path from "node:path";
-var LINTABLE_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".ts",
-  ".tsx",
-  ".mts",
-  ".cts",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs",
-  ".svelte",
-  ".vue",
-  ".md",
-  ".mdx",
-  ".json",
-  ".jsonc",
-  ".json5",
-  ".yaml",
-  ".yml",
-  ".css",
-  ".scss",
-  ".less",
-  ".html",
-  ".graphql",
-  ".gql"
-]);
-var NOTHING_LINTABLE_REASON = "no changed file is one prettier or eslint reads";
-var COMMAND_NAME = "lint:related";
-var COMMAND_LABEL = `josh ${COMMAND_NAME}`;
-var VOCABULARY = {
-  label: COMMAND_LABEL,
-  fallback_suffix: "checking the whole tree instead",
-  narrowed_suffix: "checking only them"
-};
-var PRETTIER_ARGS = ["exec", "prettier", "--check", "--ignore-unknown"];
-var ESLINT_ARGS = ["exec", "eslint"];
-var ESLINT_SCOPED_FLAGS = ["--no-warn-ignored"];
-function is_lintable(file_path) {
-  return LINTABLE_EXTENSIONS.has(path.extname(file_path));
-}
-function scope_inputs(is_present) {
-  return { is_present, is_selectable: is_lintable, nothing_reason: NOTHING_LINTABLE_REASON };
-}
-function describe_scope(scope, root) {
-  return changed_file_scope.describe_scope(scope, root, VOCABULARY);
-}
-var RELATED_CACHES = {
-  eslint_file: ESLINT_RELATED_CACHE_FILE,
-  eslint_flags: ESLINT_RELATED_CACHE_FLAGS,
-  prettier_flags: PRETTIER_RELATED_CACHE_FLAGS
-};
-function prettier_arguments(files, caches = RELATED_CACHES, directory = process.cwd()) {
-  const targets = project_checks.prettier_targets(directory, files);
-  return [...PRETTIER_ARGS, ...targets, ...caches.prettier_flags];
-}
-function eslint_arguments(files, caches = RELATED_CACHES) {
-  return [...ESLINT_ARGS, ...files, ...caches.eslint_flags, ...ESLINT_SCOPED_FLAGS];
-}
-var lint_related_scope = {
-  COMMAND_LABEL,
-  NOTHING_LINTABLE_REASON,
-  RELATED_CACHES,
-  describe_scope,
-  eslint_arguments,
-  is_lintable,
-  prettier_arguments,
-  scope_inputs
-};
-
-export {
-  lint_related_scope
-};

package/dist/commands/chunk-DOYNK72G.js

@@ -1,81 +0,0 @@
-import {
-  git_gh_command
-} from "./chunk-NRULNBYI.js";
-import {
-  RUN_LANE_LABEL,
-  RUN_SOLO_LABEL
-} from "./chunk-QQBMVC5W.js";
-import {
-  cli_flags
-} from "./chunk-2FE3C4PH.js";
-
-// scripts/backlog/backlog-triage-decision.ts
-var OPTIONS = {
-  defect: { type: "string" },
-  verification: { type: "string" },
-  "every-run": { type: "string" }
-};
-var ANSWERS = /* @__PURE__ */ new Set(["yes", "no", "unknown"]);
-var USAGE = "Usage: josh backlog:triage --decide --defect yes|no|unknown --verification yes|no|unknown --every-run yes|no|unknown";
-function decide(answers) {
-  if (answers.includes("no")) return RUN_LANE_LABEL;
-  if (answers.includes("unknown")) return "judge";
-  return RUN_SOLO_LABEL;
-}
-function is_answer(answer) {
-  return answer !== void 0 && ANSWERS.has(answer);
-}
-function answers_of(argv) {
-  const values = cli_flags.values_of(argv, OPTIONS);
-  const answers = [values?.defect, values?.verification, values?.["every-run"]];
-  return answers.every(is_answer) ? answers : void 0;
-}
-function run(argv) {
-  const answers = answers_of(argv);
-  if (answers === void 0) {
-    console.error(USAGE);
-    return 1;
-  }
-  console.info(decide(answers));
-  return 0;
-}
-var backlog_triage_decision = { OPTIONS, decide, is_answer, run };
-
-// scripts/issue/issue-run-verdict.ts
-var RUN_LABEL_OPTIONS = {
-  ...backlog_triage_decision.OPTIONS,
-  lane: { type: "boolean" },
-  solo: { type: "boolean" }
-};
-function solo_label_of(flags) {
-  const answers = [flags.defect, flags.verification, flags["every-run"]];
-  const verdict = answers.every((answer) => backlog_triage_decision.is_answer(answer)) ? backlog_triage_decision.decide(answers) : "judge";
-  if (verdict === RUN_SOLO_LABEL) return verdict;
-  console.error(
-    `--solo refused: ${verdict}; answer --defect, --verification and --every-run with yes`
-  );
-  return void 0;
-}
-function run_label_of(flags) {
-  if (flags.lane === flags.solo) return void 0;
-  return flags.lane === true ? RUN_LANE_LABEL : solo_label_of(flags);
-}
-async function apply_labels(issue, labels) {
-  for (const label of labels) {
-    const write = await git_gh_command.issue_apply_label(issue, label);
-    if (!write.is_applied) return `could not apply \`${label}\`: ${write.reason}`;
-  }
-  return void 0;
-}
-function comment_with_answers(body, flags) {
-  if (flags.solo !== true) return body;
-  return `${body}
-
-solo-run answers: defect ${String(flags.defect)} \xB7 verification ${String(flags.verification)} \xB7 every-run ${String(flags["every-run"])}`;
-}
-var issue_run_verdict = { RUN_LABEL_OPTIONS, run_label_of, apply_labels, comment_with_answers };
-
-export {
-  backlog_triage_decision,
-  issue_run_verdict
-};