@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-FZ62KJXP.js

@@ -0,0 +1,75 @@
+import {
+  capped_output
+} from "./chunk-7HP3FQGQ.js";
+import {
+  entry_read_set
+} from "./chunk-45RCSJGE.js";
+import {
+  document_section
+} from "./chunk-NDWZTWXV.js";
+import {
+  find_package_directory
+} from "./chunk-LR22UK5W.js";
+
+// scripts/document/document-section-cli.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../scripts/document/document-section-cli.ts", __josh_meta.url).href;
+var __josh_source_filename = __josh_file_path(__josh_source_url);
+var __josh_source_dirname = __josh_dirname(__josh_source_filename);
+var FAILURE_EXIT_CODE = 1;
+var FILE_ARGUMENT = 0;
+var HEADING_ARGUMENT = 1;
+var NO_CANDIDATE = 0;
+var USAGE = 'Usage: josh doc:section <file.md> "<heading>"';
+var PACKAGE_DIRECTORY = find_package_directory(path.dirname(fileURLToPath(__josh_source_url)));
+function candidates_under(directory, name) {
+  return [path.resolve(directory, name), entry_read_set.document_path(directory, name)];
+}
+function resolve_document(name, root = process.cwd(), package_directory = PACKAGE_DIRECTORY) {
+  const named = path.resolve(root, name);
+  const candidates = [...candidates_under(root, name), ...candidates_under(package_directory, name)];
+  return candidates.find((candidate) => existsSync(candidate)) ?? named;
+}
+function report_missing(markdown, heading) {
+  const near = document_section.candidates(markdown, heading);
+  const listed = near.length > NO_CANDIDATE ? near : document_section.titles(markdown);
+  console.error(`No single section matches ${JSON.stringify(heading)}. Headings it could mean:`);
+  for (const title of listed) console.error(`  ${title}`);
+  return FAILURE_EXIT_CODE;
+}
+function print_section(markdown, heading, root) {
+  const found = document_section.section(markdown, heading);
+  if (found === void 0) return report_missing(markdown, heading);
+  capped_output.capped_print(found.text, heading, root);
+  return 0;
+}
+function read_named(name, root) {
+  const file_path = resolve_document(name, root);
+  const markdown = document_section.read_optional(file_path);
+  if (markdown === void 0) console.error(`Cannot read ${file_path}`);
+  return markdown;
+}
+function section_text(name, heading, root = process.cwd()) {
+  const markdown = document_section.read_optional(resolve_document(name, root));
+  return markdown === void 0 ? void 0 : document_section.section(markdown, heading)?.text;
+}
+function run(argv, root = process.cwd()) {
+  const name = argv[FILE_ARGUMENT];
+  const heading = argv[HEADING_ARGUMENT];
+  if (name === void 0 || heading === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  const markdown = read_named(name, root);
+  return markdown === void 0 ? FAILURE_EXIT_CODE : print_section(markdown, heading, root);
+}
+var document_section_cli = { FAILURE_EXIT_CODE, USAGE, resolve_document, run, section_text };
+
+export {
+  document_section_cli
+};

package/dist/commands/chunk-FZNYKSQS.js

@@ -0,0 +1,335 @@
+import {
+  run_ship_review,
+  run_ship_stop_cause
+} from "./chunk-ILQU26IF.js";
+import {
+  lane_relaunch
+} from "./chunk-TSS2RKBC.js";
+import {
+  api_auth
+} from "./chunk-NUR4FQHM.js";
+import {
+  lane_parked
+} from "./chunk-AFGEGGIF.js";
+import {
+  review_round
+} from "./chunk-5ZWU2B7T.js";
+import {
+  review_attest
+} from "./chunk-37RULO76.js";
+import {
+  agent_argv
+} from "./chunk-IV6ETHVB.js";
+import {
+  review_prompt_level
+} from "./chunk-E33LSO2W.js";
+import {
+  agent_role_profile
+} from "./chunk-O5JGV7NA.js";
+import {
+  core_priority
+} from "./chunk-TWI7UTVE.js";
+import {
+  detached_launch
+} from "./chunk-MOAPWO34.js";
+import {
+  agent_profile_schema
+} from "./chunk-F7B4ESZE.js";
+import {
+  lane_child_invocation,
+  run_ship_stop_context
+} from "./chunk-VFW6XZH7.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  distributed_paths
+} from "./chunk-3MQTOUXT.js";
+import {
+  parse_json
+} from "./chunk-NAZ753DE.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/review/review-pair.ts
+var PAIRED_ENV = "JOSH_REVIEWER_PAIRED";
+var ENABLED_VALUE = "1";
+var BRIEF_PREFIX = "josh-review-paired-brief-";
+var FINDINGS_PREFIX = "josh-review-paired-findings-";
+var LOG_PREFIX = "josh-review-paired-log-";
+var PAIRED_PROFILE = agent_role_profile.VERIFICATION_PROFILES.anthropic;
+function is_enabled(environment = process.env) {
+  return environment[PAIRED_ENV] === ENABLED_VALUE;
+}
+function paths(directory = PROJECT_ROOT) {
+  return {
+    brief: stamp_file.stamp_path(BRIEF_PREFIX, directory, ".md"),
+    findings: stamp_file.stamp_path(FINDINGS_PREFIX, directory, ".txt"),
+    log: stamp_file.stamp_path(LOG_PREFIX, directory, ".log")
+  };
+}
+function paired_brief(text, findings) {
+  const [level = "", ...rest] = text.split("\n");
+  return [
+    level,
+    "",
+    "## Paired comparison run \u2014 recorded only, never gating",
+    "",
+    `This overrides every attest and submit step below and your agent definition: never run \`review:attest\` or \`review:submit\`. Write your findings to ${findings}, one per line as \`<category>:<severity>:<file>[:<line>] \u2014 <sentence>\`, or the single line \`none\`.`,
+    "",
+    ...rest
+  ].join("\n");
+}
+function paired_opening(brief) {
+  return [
+    `${review_prompt_level.opening(brief)}Review this checkout as a paired /code-review, recorded only: read the review brief at ${brief}`,
+    "and follow its first section over everything else \u2014 never run review:attest or review:submit.",
+    "Review it yourself in this session and never launch a second reviewer."
+  ].join(" ");
+}
+function launch_note(brief) {
+  const opening = paired_opening(brief);
+  return [
+    `paired brief: ${brief}`,
+    `paired model: ${PAIRED_PROFILE.model} \xB7 effort ${PAIRED_PROFILE.effort}`,
+    `paired prompt: ${opening}`,
+    "Paired comparison on: launch a third `reviewer` beside round 1 with the paired model and prompt; when both return, run `pnpm josh review:pair --issue <N> --opus-agent <id> --sonnet-agent <id>` before `review:record`. Its result never gates."
+  ].join("\n");
+}
+function offer(text, environment = process.env, directory = PROJECT_ROOT) {
+  const { brief, findings } = paths(directory);
+  stamp_file.remove_stamp(findings);
+  if (!is_enabled(environment) || review_round.from_brief(text) === "2") {
+    stamp_file.remove_stamp(brief);
+    return void 0;
+  }
+  stamp_file.write_text_stamp(brief, `${paired_brief(text, findings)}
+`);
+  return launch_note(brief);
+}
+function is_offered(directory = PROJECT_ROOT) {
+  return stamp_file.read_stamp_text(paths(directory).brief) !== void 0;
+}
+var review_pair = {
+  PAIRED_ENV,
+  PAIRED_PROFILE,
+  is_enabled,
+  is_offered,
+  offer,
+  opening: paired_opening,
+  paths
+};
+
+// scripts/lane/lane-session-action.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+
+// scripts/review/review-pair-session.ts
+import { z } from "zod";
+var PAIR_COMMAND = "review:pair";
+var OBJECT_OPENING = "{";
+var record_schema = z.looseObject({});
+var init_schema = z.object({
+  type: z.literal("system"),
+  subtype: z.literal("init"),
+  session_id: z.string().min(1)
+});
+function note(text) {
+  process.stderr.write(`paired reviewer: ${text}
+`);
+}
+function session_in(line) {
+  if (!line.startsWith(OBJECT_OPENING)) return void 0;
+  const record = parse_json.parse_json_object_or_undefined(line, record_schema);
+  return init_schema.safeParse(record).data?.session_id;
+}
+function session_of(log_path) {
+  const lines = stamp_file.read_stamp_text(log_path)?.split("\n") ?? [];
+  return lines.map((line) => session_in(line.trim())).findLast((id) => id !== void 0);
+}
+async function run(directory, environment) {
+  const { brief, log } = review_pair.paths(directory);
+  const opening = review_pair.opening(brief);
+  const built = agent_argv.with_profile_in(opening, review_pair.PAIRED_PROFILE, directory);
+  if (built.kind === "rejected") {
+    note(`not started \u2014 ${built.note}`);
+    return;
+  }
+  stamp_file.remove_stamp(log);
+  const request = {
+    argv: built.argv,
+    cwd: directory,
+    log_path: log,
+    profile: built.profile,
+    env: environment
+  };
+  const result = await detached_launch.launch_attached(request, note);
+  if (result.kind === "failed") note(`not started \u2014 ${result.note}`);
+}
+async function launch(directory, environment) {
+  if (!review_pair.is_offered(directory)) return;
+  try {
+    await run(directory, environment);
+  } catch (error) {
+    note(`failed \u2014 ${error_text.message_of(error)}`);
+  }
+}
+function pair_argv(issue, code_log, directory) {
+  if (!review_pair.is_offered(directory)) return void 0;
+  const opus = session_of(code_log);
+  const sonnet = session_of(review_pair.paths(directory).log);
+  if (opus === void 0 || sonnet === void 0) return void 0;
+  return [PAIR_COMMAND, "--issue", issue, "--opus-agent", opus, "--sonnet-agent", sonnet];
+}
+var review_pair_session = { launch, pair_argv, session_of };
+
+// scripts/lane/lane-session-action.ts
+import { z as z2 } from "zod";
+var BRIEF_PREFIX2 = "josh-ship-review-brief-";
+var FINDINGS_PREFIX2 = "josh-ship-review-findings-";
+var LOG_PREFIX2 = "josh-ship-review-log-";
+var SUBMIT_SCRIPT = "scripts/review/review-submit-cli.ts";
+var ANTHROPIC_PROVIDER = "anthropic";
+var stop_schema = z2.object({
+  stage: z2.enum(run_ship_stage.STAGE),
+  title: z2.string(),
+  flags: z2.array(z2.string()).readonly(),
+  is_review: z2.boolean(),
+  unpinned_ok: z2.array(z2.string()).readonly().exactOptional(),
+  conflicts: z2.array(z2.string()).readonly().default([]),
+  cause: z2.enum(run_ship_stop_cause.CAUSE).exactOptional(),
+  is_review_stale: z2.boolean().exactOptional(),
+  context: run_ship_stop_context.stop_context_schema.exactOptional()
+}).strict();
+var slots_schema = z2.array(z2.enum(review_attest.REVIEW_SLOTS)).readonly();
+var action_schema = z2.discriminatedUnion("kind", [
+  z2.object({
+    kind: z2.literal("review"),
+    round: z2.enum(["1", "2"]),
+    slots: slots_schema.exactOptional()
+  }).strict(),
+  z2.object({ kind: z2.literal("relaunch"), stop: stop_schema }).strict()
+]);
+var request_schema = z2.object({ session: z2.uuid(), nonce: z2.uuid(), action: action_schema }).strict();
+var SUCCESS = { is_success: true };
+function failure(reason) {
+  return { is_success: false, reason };
+}
+function review_paths(directory, slot = review_attest.REVIEW_SLOT.CODE) {
+  const prefix = slot === review_attest.REVIEW_SLOT.CODE ? "" : "interaction-";
+  return {
+    brief: stamp_file.stamp_path(`${BRIEF_PREFIX2}${prefix}`, directory, ".md"),
+    findings: stamp_file.stamp_path(`${FINDINGS_PREFIX2}${prefix}`, directory, ".txt"),
+    log: stamp_file.stamp_path(`${LOG_PREFIX2}${prefix}`, directory, ".log")
+  };
+}
+function provider_of(lane) {
+  return lane.profile?.provider ?? ANTHROPIC_PROVIDER;
+}
+function action_slots(action) {
+  return action.slots ?? [review_attest.REVIEW_SLOT.CODE];
+}
+function has_submit(directory) {
+  return [SUBMIT_SCRIPT, `${distributed_paths.KIT_PACKAGE_PATH_PREFIX}${SUBMIT_SCRIPT}`].some(
+    (script) => existsSync(path.join(directory, script))
+  );
+}
+function review_prompt(lane, action, slot) {
+  const { brief, findings } = review_paths(lane.directory, slot);
+  const round_prompt = action.round === "1" ? run_ship_review.reviewer_prompt : run_ship_review.verification_prompt;
+  const prompt_of = run_ship_review.slot_prompt(round_prompt, slot, action_slots(action));
+  const tail = lane_child_invocation.review_invocation(lane.issue);
+  const findings_path = has_submit(lane.directory) ? void 0 : findings;
+  return `${prompt_of(brief, slot, lane.issue, findings_path)} This is ${tail}`;
+}
+function exited_answer(exit_code, log_path) {
+  const exited = `the reviewer exited with code ${String(exit_code)}`;
+  if (!api_auth.is_auth_failed_transcript(stamp_file.read_stamp_text(log_path))) {
+    return failure(exited);
+  }
+  return failure(`${api_auth.AUTH_FAILURE_NOTE}: ${exited}`);
+}
+function reviewer_answer(result, log_path) {
+  if (result.kind === "failed") return failure(`the reviewer could not start: ${result.note}`);
+  return result.exit_code === 0 ? SUCCESS : exited_answer(result.exit_code, log_path);
+}
+function reviewer_environment(lane) {
+  return { ...lane_child_marker.env_for(lane.issue), ...core_priority.PRIORITY_ENVIRONMENT };
+}
+async function launch_review(lane, action, slot) {
+  const target = review_paths(lane.directory, slot);
+  const prompt = review_prompt(lane, action, slot);
+  const built = agent_argv.review_in(prompt, Number(action.round), lane.directory);
+  if (built.kind === "rejected") return failure(`the reviewer profile was rejected: ${built.note}`);
+  if (built.profile.provider !== provider_of(lane)) {
+    return failure(`the reviewer resolved to ${built.profile.provider}, not the lane's provider`);
+  }
+  console.error(agent_profile_schema.describe_review(Number(action.round), built.profile));
+  const result = await detached_launch.launch_attached(
+    {
+      argv: built.argv,
+      cwd: lane.directory,
+      log_path: target.log,
+      profile: built.profile,
+      env: reviewer_environment(lane)
+    },
+    console.error
+  );
+  return reviewer_answer(result, target.log);
+}
+async function launch_pair(lane, action) {
+  if (action.round !== "1" || !action_slots(action).includes(review_attest.REVIEW_SLOT.CODE)) return;
+  await review_pair_session.launch(lane.directory, reviewer_environment(lane));
+}
+async function launch_reviews(lane, action) {
+  const [answers] = await Promise.all([
+    Promise.all(action_slots(action).map(async (slot) => await launch_review(lane, action, slot))),
+    launch_pair(lane, action)
+  ]);
+  return answers.find((reply) => !reply.is_success) ?? SUCCESS;
+}
+async function relaunch(lane, stop) {
+  if (lane_relaunch.is_openai_lane(lane)) {
+    return failure("an OpenAI lane is relaunched by its own supervisor");
+  }
+  const invocation = lane_child_invocation.ship_stop_invocation(lane.issue, stop);
+  const phase = agent_profile_schema.IMPLEMENTATION_PHASE;
+  const result = await lane_relaunch.relaunch(lane, invocation, phase, console.error);
+  return result.kind === "launched" ? SUCCESS : failure(`the relaunch did not start: ${result.note}`);
+}
+async function perform(lane, action) {
+  if (await lane_parked.is_parked(lane.issue)) return failure("the issue is parked");
+  if (action.kind === "relaunch") return await relaunch(lane, action.stop);
+  return await launch_reviews(lane, action);
+}
+async function answer(lane, action) {
+  try {
+    return await perform(lane, action);
+  } catch (error) {
+    return failure(`the broker failed: ${error_text.message_of(error)}`);
+  }
+}
+var lane_session_action = {
+  SUCCESS,
+  action_schema,
+  answer,
+  failure,
+  request_schema,
+  review_paths
+};
+
+export {
+  review_pair,
+  review_pair_session,
+  lane_session_action
+};

package/dist/commands/chunk-FZYFGHRY.js

@@ -0,0 +1,72 @@
+import {
+  npm_registry,
+  release_age
+} from "./chunk-5GI5GLC4.js";
+import {
+  git_gh_exec
+} from "./chunk-NAZ753DE.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/version/version-remote.ts
+var TIMES_PAGE_SIZE = 100;
+var TIMES_JQ = "[.[] | {(.name): .created_at}] | add";
+function require_endpoint(versions_endpoint, package_name) {
+  if (versions_endpoint !== void 0 && versions_endpoint.trim() !== "") return versions_endpoint;
+  throw new Error(
+    `Could not derive a versions endpoint for ${package_name}; check its version-command config.`
+  );
+}
+function read_github_name(endpoint, package_name) {
+  try {
+    return git_gh_exec.exec_gh_api_sync({ path: endpoint, jq_filter: ".[0].name" }).trim();
+  } catch (error) {
+    const detail = error_text.message_of(error);
+    throw new Error(
+      `Failed to fetch latest version for ${package_name} via ${endpoint}: ${detail}`,
+      {
+        cause: error
+      }
+    );
+  }
+}
+function read_github_latest(endpoint, package_name) {
+  const name = read_github_name(endpoint, package_name);
+  const version = npm_registry.valid_version(name);
+  if (version !== void 0) return version;
+  throw new Error(
+    `Refused latest version for ${package_name} via ${endpoint}: ${JSON.stringify(name)} is not a semver version`
+  );
+}
+function fetch_latest_version(versions_endpoint, package_name) {
+  const endpoint = require_endpoint(versions_endpoint, package_name);
+  return npm_registry.read_latest(package_name) ?? read_github_latest(endpoint, package_name);
+}
+function with_page_size(endpoint, page_size) {
+  const separator = endpoint.indexOf("?");
+  const path_part = separator === -1 ? endpoint : endpoint.slice(0, separator);
+  const query = new URLSearchParams(separator === -1 ? "" : endpoint.slice(separator + 1));
+  query.set("per_page", String(page_size));
+  return `${path_part}?${query.toString()}`;
+}
+function read_github_release_times(versions_endpoint) {
+  const endpoint = with_page_size(versions_endpoint, TIMES_PAGE_SIZE);
+  const stdout = git_gh_exec.read_gh_api_sync({ path: endpoint, jq_filter: TIMES_JQ });
+  if (stdout === void 0) return void 0;
+  const parsed = release_age.release_times_schema.safeParse(json_value.parse_or_undefined(stdout));
+  return parsed.success ? parsed.data : void 0;
+}
+function fetch_release_times(versions_endpoint, package_name) {
+  if (versions_endpoint === void 0 || versions_endpoint.trim() === "") return void 0;
+  return npm_registry.read_release_times(package_name) ?? read_github_release_times(versions_endpoint);
+}
+
+export {
+  fetch_latest_version,
+  with_page_size,
+  fetch_release_times
+};

package/dist/commands/chunk-G4UVY3TO.js

@@ -0,0 +1,90 @@
+import {
+  lane_plan_signals
+} from "./chunk-NV6Y4U37.js";
+import {
+  lane_ledger_archive
+} from "./chunk-2TI22UNK.js";
+import {
+  lane_stage_stats
+} from "./chunk-3TN76RWK.js";
+import {
+  lane_stats
+} from "./chunk-WYAY6CQI.js";
+import {
+  lane_ledger
+} from "./chunk-I2RBOH4F.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-plan-wait.ts
+var WAIT_CAP_MINUTES = 30;
+var WAIT_CAP_MS = WAIT_CAP_MINUTES * MS_PER_MINUTE;
+var MEDIAN_PERIOD_DAYS = 3;
+var ASK_MINUTES = 9;
+var ASK_MS = ASK_MINUTES * MS_PER_MINUTE;
+function deadline_of(facts) {
+  const { own_at_ms, holder_at_ms, now_ms } = facts;
+  if (!facts.has_commits || own_at_ms >= holder_at_ms) return void 0;
+  const remaining = facts.median_ms - (now_ms - holder_at_ms);
+  const bound = Math.min(now_ms - own_at_ms, WAIT_CAP_MS);
+  return remaining <= bound ? now_ms + bound : void 0;
+}
+function dispatched_at(entries, issue) {
+  const starts = entries.filter((entry) => lane_stage_stats.is_dispatch(entry) && entry.issue === issue).map((entry) => Date.parse(entry.at));
+  return lane_stats.peak(starts);
+}
+function median_ms(entries, now_ms) {
+  const period = lane_stats.in_window(entries, lane_stats.window_of(MEDIAN_PERIOD_DAYS, now_ms));
+  const minutes = lane_stats.median(lane_stats.merge_minutes(entries, period));
+  return minutes === void 0 ? void 0 : minutes * MS_PER_MINUTE;
+}
+function facts_from(entries, pair, has_commits, now_ms) {
+  const own_at_ms = dispatched_at(entries, pair.issue);
+  const holder_at_ms = dispatched_at(entries, pair.holder);
+  const median = median_ms(entries, now_ms);
+  if (own_at_ms === void 0 || holder_at_ms === void 0 || median === void 0) {
+    return void 0;
+  }
+  return { own_at_ms, holder_at_ms, has_commits, median_ms: median, now_ms };
+}
+async function entries_of() {
+  const ledger = await lane_ledger.target();
+  return ledger === void 0 ? [] : lane_ledger_archive.history_at(ledger);
+}
+async function deadline(issue, holder, now_ms) {
+  const [entries, signals] = await Promise.all([entries_of(), lane_plan_signals.signals_of(issue)]);
+  const facts = facts_from(entries, { issue, holder }, signals.committed_files.length > 0, now_ms);
+  return facts === void 0 ? void 0 : deadline_of(facts);
+}
+async function hold(until_ms, is_free, sleeper = poll.sleep) {
+  const ask_end_ms = Date.now() + ASK_MS;
+  return await poll.wait_for(
+    async () => {
+      if (Date.now() >= until_ms) return "expired";
+      if (await is_free()) return "free";
+      return Date.now() + MS_PER_MINUTE > ask_end_ms ? "again" : void 0;
+    },
+    { interval_ms: MS_PER_MINUTE, sleeper }
+  );
+}
+var lane_plan_wait = { deadline, deadline_of, facts_from, hold };
+
+// scripts/lane/lane-plan-wait-until.ts
+async function until(plan, holder) {
+  const now_ms = Date.now();
+  if (plan.waits_until !== void 0) {
+    return Date.parse(plan.waits_until) > now_ms ? plan.waits_until : void 0;
+  }
+  const deadline2 = await lane_plan_wait.deadline(plan.issue, holder, now_ms);
+  return deadline2 === void 0 ? void 0 : new Date(deadline2).toISOString();
+}
+var lane_plan_wait_until = { until };
+
+export {
+  lane_plan_wait,
+  lane_plan_wait_until
+};

package/dist/commands/chunk-G6H2TOAA.js

@@ -0,0 +1,18 @@
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+
+// scripts/release/release-approval-prune.ts
+var APPROVAL_DIRECTORY = ".josh/metrics-accepted";
+var APPROVAL_PREFIX = `${APPROVAL_DIRECTORY}/`;
+async function prune() {
+  await git_spawn.read(["rm", "-r", "-q", "--ignore-unmatch", "--", APPROVAL_DIRECTORY]);
+}
+function is_approval(file) {
+  return file.startsWith(APPROVAL_PREFIX);
+}
+var release_approval_prune = { APPROVAL_DIRECTORY, is_approval, prune };
+
+export {
+  release_approval_prune
+};