@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-HDVSZ6CZ.js

@@ -0,0 +1,292 @@
+import {
+  agent_session_role
+} from "./chunk-DURHGVRC.js";
+import {
+  agent_profile_schema
+} from "./chunk-F7B4ESZE.js";
+import {
+  agent_safe_text
+} from "./chunk-3LZXX5GL.js";
+import {
+  run_carry_session,
+  run_headless_keys
+} from "./chunk-DS53UUDH.js";
+import {
+  agent_session_environment
+} from "./chunk-HHBC6QZE.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  PLATFORM_TEMP_ROOT,
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/agent/agent-headless.ts
+var KEY = "JOSH_AGENT_HEADLESS";
+var VALUE = "1";
+function environment() {
+  return { [KEY]: VALUE };
+}
+function is_headless(source = process.env) {
+  return source[KEY] === VALUE;
+}
+var agent_headless = { KEY, environment, is_headless };
+
+// scripts/run/detached-launch.ts
+import { spawn } from "node:child_process";
+import { closeSync, constants, openSync, writeSync as writeSync2 } from "node:fs";
+
+// scripts/agent/agent-launch-environment.ts
+var OPENAI_PROVIDER = "openai";
+function build(profile, environment2 = {}) {
+  if (profile === void 0) return { ...environment2, [agent_session_role.KEY]: void 0 };
+  const marked = {
+    ...agent_headless.environment(),
+    ...environment2,
+    ...agent_session_role.env_for(profile.role)
+  };
+  return profile.provider === OPENAI_PROVIDER ? { TMPDIR: PLATFORM_TEMP_ROOT, ...marked } : marked;
+}
+var agent_launch_environment = { build };
+
+// scripts/agent/codex-launch-identity.ts
+var CONFIG_FLAG = "-c";
+var SHELL_SET = "shell_environment_policy.set.";
+function identity_environment(request) {
+  return {
+    [lane_paths.LANE_ROOT_KEY]: process.env[lane_paths.LANE_ROOT_KEY],
+    ...request.env
+  };
+}
+function identity_arguments(request) {
+  const source = identity_environment(request);
+  if (!lane_child_marker.is_child_of(request.cwd, source)) return [];
+  return [lane_child_marker.KEY, lane_paths.LANE_ROOT_KEY].flatMap(
+    (key) => source[key] === void 0 ? [] : [CONFIG_FLAG, `${SHELL_SET}${key}=${JSON.stringify(source[key])}`]
+  );
+}
+function is_codex_worker(request) {
+  const { argv, profile } = request;
+  return profile?.provider === "openai" && profile.role === agent_profile_schema.WORKER && argv.command === "codex" && argv.ends_with_prompt === true;
+}
+function scheduler_arguments(request) {
+  if (request.profile?.role !== agent_profile_schema.SCHEDULER) return [];
+  const keys = [run_carry_session.KEY, ...run_headless_keys.MARK_KEYS];
+  return keys.flatMap(
+    (key) => request.env?.[key] === void 0 ? [] : [CONFIG_FLAG, `${SHELL_SET}${key}=${JSON.stringify(request.env[key])}`]
+  );
+}
+function is_codex(request) {
+  return request.profile?.provider === "openai" && request.argv.command === "codex";
+}
+function arguments_for(request) {
+  const { argv } = request;
+  if (!is_codex(request) || argv.ends_with_prompt !== true) return argv.args;
+  const identity = is_codex_worker(request) ? identity_arguments(request) : scheduler_arguments(request);
+  return [...argv.args.slice(0, -1), ...identity, ...argv.args.slice(-1)];
+}
+var codex_launch_identity = { arguments_for };
+
+// scripts/run/launch-priority.ts
+import { setPriority } from "node:os";
+var LANE_NICENESS = 10;
+function lower(pid, set_priority = setPriority) {
+  if (pid === void 0) return;
+  try {
+    set_priority(pid, LANE_NICENESS);
+  } catch {
+  }
+}
+var launch_priority = {
+  LANE_NICENESS,
+  lower
+};
+
+// scripts/run/attached-log.ts
+import { writeSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { z } from "zod";
+var EVENT_SCHEMA = z.looseObject({ type: z.string(), timestamp: z.string().optional() });
+function stamped_line(line, timestamp) {
+  const event = EVENT_SCHEMA.safeParse(json_value.parse_or_undefined(line)).data;
+  if (event === void 0) return line;
+  return JSON.stringify({ ...event, timestamp: event.timestamp ?? timestamp });
+}
+function record(child, log, on_error) {
+  if (child.stdout === null) return;
+  const lines = createInterface({ input: child.stdout });
+  lines.on("line", (line) => {
+    if (log === void 0) return;
+    try {
+      writeSync(log, `${stamped_line(line, (/* @__PURE__ */ new Date()).toISOString())}
+`);
+    } catch (error) {
+      on_error(`the session log could not be written: ${String(error)}`);
+    }
+  });
+}
+var attached_log = { record, stamped_line };
+
+// scripts/run/detached-launch.ts
+var NO_PID_NOTE = "the process started without a pid";
+var UNSAFE_NOTE = "the wake command or its arguments are empty, over length, or contain characters that are not safe to execute";
+var { is_safe_prompt, is_safe_value } = agent_safe_text;
+var LAST = -1;
+function is_safe_element(argv, value, index) {
+  const is_prompt = argv.ends_with_prompt === true && index === argv.args.length + LAST;
+  return is_prompt ? is_safe_prompt(value) : is_safe_value(value);
+}
+function is_safe_argv(argv) {
+  return is_safe_value(argv.command) && argv.args.every((value, index) => is_safe_element(argv, value, index));
+}
+function note_of(error) {
+  return error instanceof Error ? error.message : JSON.stringify(error);
+}
+function launched(pid) {
+  return { kind: "launched", pid };
+}
+var LOG_FLAGS = constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW;
+var LOG_MODE = 384;
+function profile_suffix(profile) {
+  return profile === void 0 ? "" : ` \xB7 ${agent_profile_schema.describe(profile)}`;
+}
+function log_header(argv, profile) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString();
+  return `
+=== ${stamp} \xB7 started by process ${String(process.pid)} \xB7 ${argv.command}${profile_suffix(profile)} ===
+`;
+}
+function opened_log(log_path, on_error) {
+  const descriptor = openSync(log_path, LOG_FLAGS, LOG_MODE);
+  if (!stamp_file.is_own_regular_file(log_path)) {
+    closeSync(descriptor);
+    on_error(`${log_path} is not this account's own file, so nothing is kept there`);
+    return void 0;
+  }
+  return descriptor;
+}
+function stamped(descriptor, argv, profile, on_error) {
+  if (descriptor === void 0) return;
+  try {
+    writeSync2(descriptor, log_header(argv, profile));
+  } catch (error) {
+    on_error(`the session log could not be written: ${note_of(error)}`);
+  }
+}
+function open_log(log_path, on_error) {
+  if (log_path === void 0) return void 0;
+  try {
+    return opened_log(log_path, on_error);
+  } catch (error) {
+    on_error(`the session log at ${log_path} could not be opened: ${note_of(error)}`);
+    return void 0;
+  }
+}
+function ensure_log(log_path, on_error) {
+  const descriptor = open_log(log_path, on_error);
+  if (descriptor !== void 0) closeSync(descriptor);
+}
+function spawn_options(cwd, log, environment2 = {}, is_detached = true) {
+  const output = log ?? "ignore";
+  return {
+    cwd,
+    detached: is_detached,
+    stdio: ["ignore", is_detached ? output : "pipe", output],
+    env: { ...process.env, ...agent_session_environment.removed_environment(), ...environment2 }
+  };
+}
+function notify_spawn(pid, on_spawn, on_error) {
+  if (pid === void 0) return;
+  try {
+    on_spawn(pid);
+  } catch (error) {
+    on_error(`the child state could not be recorded: ${note_of(error)}`);
+  }
+}
+async function attached_spawn(request, log, on_error, on_spawn) {
+  return await new Promise((resolve) => {
+    const environment2 = agent_launch_environment.build(request.profile, request.env);
+    const child = spawn(
+      request.argv.command,
+      [...request.argv.args],
+      spawn_options(request.cwd, log, environment2, false)
+    );
+    child.once("error", (error) => {
+      on_error(note_of(error));
+      resolve({ kind: "failed", note: note_of(error) });
+    });
+    attached_log.record(child, log, on_error);
+    child.once("close", (exit_code) => {
+      resolve({ kind: "completed", pid: child.pid ?? 0, exit_code });
+    });
+    launch_priority.lower(child.pid);
+    notify_spawn(child.pid, on_spawn, on_error);
+  });
+}
+function ignore_spawn(_pid) {
+}
+function spawned(request, log, on_error) {
+  const { command, args } = request.argv;
+  const environment2 = agent_launch_environment.build(request.profile, request.env);
+  const child = spawn(command, [...args], spawn_options(request.cwd, log, environment2));
+  child.on("error", (error) => {
+    on_error(note_of(error));
+  });
+  child.unref();
+  launch_priority.lower(child.pid);
+  return child.pid === void 0 ? { kind: "failed", note: NO_PID_NOTE } : launched(child.pid);
+}
+function prepared_request(request) {
+  return {
+    ...request,
+    argv: { ...request.argv, args: codex_launch_identity.arguments_for(request) }
+  };
+}
+function launch(input, on_error) {
+  const request = prepared_request(input);
+  if (!is_safe_argv(request.argv)) return { kind: "failed", note: UNSAFE_NOTE };
+  const log = open_log(request.log_path, on_error);
+  try {
+    stamped(log, request.argv, request.profile, on_error);
+    return spawned(request, log, on_error);
+  } catch (error) {
+    return { kind: "failed", note: note_of(error) };
+  } finally {
+    if (log !== void 0) closeSync(log);
+  }
+}
+async function launch_attached(input, on_error, on_spawn = ignore_spawn) {
+  const request = prepared_request(input);
+  if (!is_safe_argv(request.argv)) return { kind: "failed", note: UNSAFE_NOTE };
+  const log = open_log(request.log_path, on_error);
+  try {
+    stamped(log, request.argv, request.profile, on_error);
+    return await attached_spawn(request, log, on_error, on_spawn);
+  } catch (error) {
+    return { kind: "failed", note: note_of(error) };
+  } finally {
+    if (log !== void 0) closeSync(log);
+  }
+}
+var detached_launch = {
+  UNSAFE_NOTE,
+  ensure_log,
+  is_safe_argv,
+  is_safe_value,
+  launch,
+  launch_attached,
+  log_header,
+  note_of
+};
+
+export {
+  agent_headless,
+  detached_launch
+};

package/dist/commands/chunk-HE3GOMR7.js

@@ -0,0 +1,88 @@
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/git/main-merge-guard.ts
+var STATUS_CODE_LENGTH = 2;
+var STATUS_PREFIX_LENGTH = STATUS_CODE_LENGTH + 1;
+var RENAME_SEPARATOR = " -> ";
+var UNMERGED_CODES = /* @__PURE__ */ new Set(["DD", "AU", "UD", "UA", "DU", "AA", "UU"]);
+var UNSTAGED_INDEX_CODES = /* @__PURE__ */ new Set([" ", "?", "!"]);
+var DIRECTORY_SUFFIX = "/";
+var COMMIT_COMMAND = "`pnpm josh git -y`";
+var LANE_COMMIT_COMMAND = '`pnpm josh git -y --skip-push --skip-pr "<title> #<N>"`';
+var PROCEDURE_POINTER = '`.claude/skills/workflow-commands/chain-rule.md` \u2192 "origin/main is merged in before the gate"';
+var MERGE_RERUN = "`pnpm josh main:merge`";
+function status_lines(status) {
+  return status.split("\n").filter((line) => line.length > STATUS_PREFIX_LENGTH);
+}
+function line_paths(line) {
+  return line.slice(STATUS_PREFIX_LENGTH).split(RENAME_SEPARATOR);
+}
+function unmerged_paths(status) {
+  return status_lines(status).filter((line) => UNMERGED_CODES.has(line.slice(0, STATUS_CODE_LENGTH))).flatMap((line) => line_paths(line));
+}
+function staged_paths(status) {
+  return status_lines(status).filter((line) => !UNSTAGED_INDEX_CODES.has(line.charAt(0))).flatMap((line) => line_paths(line));
+}
+function covers(uncommitted, incoming) {
+  if (uncommitted.endsWith(DIRECTORY_SUFFIX)) return incoming.startsWith(uncommitted);
+  return uncommitted === incoming;
+}
+function overlapping_paths(status, incoming) {
+  const uncommitted = status_lines(status).flatMap((line) => line_paths(line));
+  return uncommitted.filter((path) => incoming.some((changed) => covers(path, changed)));
+}
+function commit_command(is_lane_child = lane_child_marker.is_child_of(process.cwd())) {
+  return is_lane_child ? LANE_COMMIT_COMMAND : COMMIT_COMMAND;
+}
+function unresolved_message(prefix, paths, rerun, commit = commit_command()) {
+  return `${prefix}: the index still holds unresolved paths (${paths.join(", ")}). Remove the conflict markers, then finish through ${commit} \u2014 it stages and commits them, so no \`git add\` permission is needed, and inside a lane this is Tier A. Rerun ${rerun} after it (${PROCEDURE_POINTER}).`;
+}
+function staged_message(paths, commit) {
+  return `main:merge: the index holds staged changes (${paths.join(", ")}), which git refuses to merge over. Commit them first through ${commit}, then rerun \`pnpm josh main:merge\` (${PROCEDURE_POINTER}).`;
+}
+function overlap_message(default_branch, paths, commit) {
+  return `main:merge: uncommitted changes touch files origin/${default_branch} also changed (${paths.join(", ")}). Commit the work first through ${commit}, then rerun \`pnpm josh main:merge\`. Never stash around the merge \u2014 a stash reapplied over it leaves the conflict half-recorded in the index (${PROCEDURE_POINTER}).`;
+}
+function conflict_hint(commit = commit_command()) {
+  return `main:merge: finish a conflicted merge by removing the conflict markers, then ${commit} records the merge commit \u2014 no \`git add\` permission is needed (${PROCEDURE_POINTER}).`;
+}
+function merge_refusal(status, incoming, default_branch, commit) {
+  if (incoming.length === 0) return void 0;
+  const staged = staged_paths(status);
+  if (staged.length > 0) return staged_message(staged, commit);
+  const overlap = overlapping_paths(status, incoming);
+  return overlap.length > 0 ? overlap_message(default_branch, overlap, commit) : void 0;
+}
+function refusal(status, incoming, default_branch, commit = commit_command()) {
+  const unmerged = unmerged_paths(status);
+  if (unmerged.length > 0) return unresolved_message("main:merge", unmerged, MERGE_RERUN, commit);
+  return merge_refusal(status, incoming, default_branch, commit);
+}
+async function incoming_paths(default_branch) {
+  const output = await git_spawn.read([
+    "diff",
+    "--name-only",
+    "--no-renames",
+    `HEAD...origin/${default_branch}`
+  ]);
+  return output.split("\n").filter((line) => line !== "");
+}
+var main_merge_guard = {
+  commit_command,
+  conflict_hint,
+  incoming_paths,
+  overlapping_paths,
+  refusal,
+  staged_paths,
+  unmerged_paths,
+  unresolved_message
+};
+
+export {
+  main_merge_guard
+};

package/dist/commands/chunk-HEFUC4ZW.js

@@ -0,0 +1,65 @@
+import {
+  gate_tree
+} from "./chunk-R36VZIKU.js";
+import {
+  project_checks
+} from "./chunk-RO4QEZJO.js";
+import {
+  release_approval_prune
+} from "./chunk-QSJCZATC.js";
+import {
+  buffered_process
+} from "./chunk-JZHY7D6D.js";
+
+// scripts/gate/metrics-totals.ts
+var METRICS_TOTALS_COMMAND = ["josh", "metrics", "--totals-only"];
+var METRICS_RERECORD_COMMAND = [...METRICS_TOTALS_COMMAND, "--rerecord"];
+var NOTICE_HEADING = "\u26A0 josh metrics --totals-only did not pass \u2014 settle it before `josh run:review`, whose open stops on it (a total the branch approval names is re-recorded there):";
+var REVIEW_REFUSAL_HEADING = "run:review refused: josh metrics --totals-only did not pass \u2014 record the reason the totals grew (or bring them back down), then run run:review again:";
+async function growth_notice(directory) {
+  if (!project_checks.is_kit_repository(directory)) return void 0;
+  const result = await buffered_process.run_buffered_process(METRICS_TOTALS_COMMAND, {
+    cwd: directory
+  });
+  if (!buffered_process.is_process_failed(result)) return void 0;
+  return `${NOTICE_HEADING}
+${result.output.trim()}`;
+}
+async function totals_check(directory) {
+  if (!project_checks.is_kit_repository(directory)) return void 0;
+  return await buffered_process.run_buffered_process(METRICS_RERECORD_COMMAND, { cwd: directory });
+}
+async function totals_refusal(directory) {
+  const result = await totals_check(directory);
+  if (result === void 0 || !buffered_process.is_process_failed(result)) return void 0;
+  return `${REVIEW_REFUSAL_HEADING}
+${result.output.trim()}`;
+}
+function carries_approval(files) {
+  return Object.keys(files).some((file) => release_approval_prune.is_approval(file));
+}
+async function rerecord(directory, files) {
+  if (!project_checks.is_kit_repository(directory) || !carries_approval(files)) return false;
+  await buffered_process.run_buffered_process(METRICS_RERECORD_COMMAND, { cwd: directory });
+  return true;
+}
+var metrics_totals = {
+  METRICS_RERECORD_COMMAND,
+  METRICS_TOTALS_COMMAND,
+  NOTICE_HEADING,
+  REVIEW_REFUSAL_HEADING,
+  growth_notice,
+  rerecord,
+  // Finish the existing approval writer before fixing the tree any verification will read.
+  async rerecorded_tree(read = gate_tree.read_gate_tree, directory = process.cwd()) {
+    const tree = await read();
+    const is_rerecorded = await metrics_totals.rerecord(directory, tree.files);
+    return is_rerecorded ? await read() : tree;
+  },
+  totals_check,
+  totals_refusal
+};
+
+export {
+  metrics_totals
+};

package/dist/commands/chunk-HHS3LYLV.js

@@ -0,0 +1,30 @@
+import {
+  review_brief
+} from "./chunk-EVVQJJFV.js";
+import {
+  review_stamps
+} from "./chunk-S5GX3H4P.js";
+import {
+  gate_tree
+} from "./chunk-R36VZIKU.js";
+
+// scripts/test/test-e2e-stamp.ts
+function record(tree, target) {
+  try {
+    review_stamps.e2e_stamp.write(tree.files, target, tree.base);
+  } catch {
+  }
+}
+function is_current(tree, source) {
+  if (tree.base === void 0) return false;
+  const stamp = review_brief.matching_stamp(review_stamps.e2e_stamp.read(source), tree.files);
+  return stamp?.base === tree.base;
+}
+async function is_current_tree() {
+  return is_current(await gate_tree.read_gate_tree());
+}
+var test_e2e_stamp = { is_current, is_current_tree, record };
+
+export {
+  test_e2e_stamp
+};

package/dist/commands/chunk-HQZ65PJE.js

@@ -0,0 +1,167 @@
+import {
+  test_related_pins
+} from "./chunk-HE5S4XRE.js";
+import {
+  direct_importers
+} from "./chunk-N4EMFHQ6.js";
+import {
+  test_pinned_logic
+} from "./chunk-RAQ3E6OT.js";
+import {
+  test_pinned_reach
+} from "./chunk-6FN37DER.js";
+import {
+  related_scope
+} from "./chunk-KJPZPTS4.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  change_base
+} from "./chunk-LBVYFW3I.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/test/test-related-cap.ts
+import { existsSync } from "node:fs";
+import path2 from "node:path";
+
+// scripts/test/test-related-imports.ts
+import { readFileSync } from "node:fs";
+import path from "node:path";
+function is_loading(typescript, node, source) {
+  if (!typescript.isCallExpression(node)) return false;
+  return node.expression.kind === typescript.SyntaxKind.ImportKeyword || node.expression.getText(source) === "require";
+}
+function signature(typescript, file, content) {
+  const source = typescript.createSourceFile(file, content, typescript.ScriptTarget.Latest);
+  const declarations = [];
+  function visit(node) {
+    if (typescript.isImportDeclaration(node) || typescript.isExportDeclaration(node) || is_loading(typescript, node, source)) {
+      declarations.push(node.getText(source));
+    }
+    typescript.forEachChild(node, visit);
+  }
+  visit(source);
+  return JSON.stringify(declarations);
+}
+async function is_stable(root, file, comparison) {
+  if (path.extname(file) === ".svelte") return false;
+  try {
+    const before = await git_spawn.read(["-C", root, "show", `${comparison.base}:${file}`]);
+    const current = readFileSync(path.join(root, file), "utf8");
+    return signature(comparison.typescript, file, before) === signature(comparison.typescript, file, current);
+  } catch {
+    return false;
+  }
+}
+async function compare(root, files) {
+  try {
+    const base = await change_base.resolved_through_merge();
+    if (base === void 0) return files.map(() => false);
+    const { default: typescript } = await import("typescript");
+    return await Promise.all(
+      files.map(async (file) => await is_stable(root, file, { base, typescript }))
+    );
+  } catch {
+    return files.map(() => false);
+  }
+}
+async function stable_files(root, files) {
+  if (files.length === 0) return [];
+  const stable = await compare(root, files);
+  const retained = files.filter((_file, index) => stable[index] !== true);
+  if (retained.length > 0) {
+    process.stdout.write(
+      `josh test:related: keeping full reach (imports changed or unknown): ${retained.join(", ")}
+`
+    );
+  }
+  return files.filter((_file, index) => stable[index] === true);
+}
+var test_related_imports = { stable_files };
+
+// scripts/test/test-related-cap.ts
+var NO_CAP = { importers: /* @__PURE__ */ new Map(), over_cap: [] };
+function reach_sum(counts) {
+  return counts.reduce((sum, reached) => sum + reached.count, 0);
+}
+function over_cap_of(counts, max_tests = test_pinned_logic.MAX_TEST_FILES) {
+  const widest = counts.toSorted((first, second) => second.count - first.count);
+  const fits = widest.findIndex((_, index) => reach_sum(widest.slice(index)) <= max_tests);
+  const narrowed = fits === -1 ? widest : widest.slice(0, fits);
+  return narrowed.map((reached) => reached.file);
+}
+function candidates_of(root, files, narrowed) {
+  return files.filter(
+    (file) => related_scope.is_relatable(file) && !test_declared_logic.is_test_file(file) && !narrowed.has(file) && existsSync(path2.join(root, file))
+  );
+}
+async function relative_counts(root, files, read_counts) {
+  if (files.length === 0) return [];
+  const counts = await read_counts(files.map((file) => path2.join(root, file)));
+  return (counts ?? []).map((reached) => ({ ...reached, file: path2.relative(root, reached.file) }));
+}
+async function read_over_cap(root, files, read_counts) {
+  return over_cap_of(await relative_counts(root, files, read_counts));
+}
+async function direct_of(root, over_cap) {
+  const stable = await test_related_imports.stable_files(root, over_cap);
+  const importers = await direct_importers.importers_of(root, stable);
+  const narrowed = [...importers].filter(([, tests]) => tests.length > 0);
+  return narrowed.map(([file, tests]) => [file, test_related_pins.with_pins(file, tests)]);
+}
+async function split_of(root, files) {
+  const shared = direct_importers.every_test_imports_of(files);
+  const stable = await test_related_imports.stable_files(root, shared);
+  const every_test = await direct_importers.every_test_importers(root, stable);
+  return [every_test, candidates_of(root, files, every_test)];
+}
+async function capped_importers(root, files, is_whole, read_counts = test_pinned_reach.reached_test_counts) {
+  if (is_whole) return NO_CAP;
+  const [every_test, candidates] = await split_of(root, files);
+  const over_cap = await read_over_cap(root, candidates, read_counts);
+  const capped = await direct_of(root, over_cap);
+  return { importers: new Map([...every_test, ...capped]), over_cap: capped.map(([file]) => file) };
+}
+async function hubs_of(root, files, read_counts = test_pinned_reach.reached_test_counts) {
+  const [, candidates] = await split_of(root, files);
+  const counts = await relative_counts(root, candidates, read_counts);
+  return counts.flatMap((reached) => over_cap_of([reached]));
+}
+function capped_test_count(capped) {
+  const tests = capped.over_cap.flatMap((file) => capped.importers.get(file) ?? []);
+  return new Set(tests).size;
+}
+function hub_of(over_cap, own) {
+  return over_cap.find((file) => own.includes(file));
+}
+function over_cap_line(capped, own) {
+  const { over_cap } = capped;
+  if (over_cap.length === 0) return void 0;
+  const { COMMAND_LABEL } = related_scope;
+  const cap = String(test_pinned_logic.MAX_TEST_FILES);
+  const ran = String(capped_test_count(capped));
+  const hub = hub_of(over_cap, own);
+  const hub_part = hub === void 0 ? "" : `, hub ${hub}`;
+  return `${COMMAND_LABEL}: ${String(over_cap.length)} over cap (${cap} test files)${hub_part} \u2014 ${ran} test files run, the rest unchecked: ${over_cap.join(", ")}`;
+}
+function report_over_cap(capped, own) {
+  const line = over_cap_line(capped, own);
+  if (line !== void 0) process.stdout.write(`${line}
+`);
+}
+var test_related_cap = {
+  NO_CAP,
+  capped_importers,
+  hub_of,
+  hubs_of,
+  over_cap_line,
+  over_cap_of,
+  report_over_cap
+};
+
+export {
+  test_related_cap
+};