@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-ZEH2B3DF.js

@@ -0,0 +1,239 @@
+import {
+  run_cut_decline
+} from "./chunk-NFKWFOFM.js";
+import {
+  run_cut_ready
+} from "./chunk-2ONSHOAY.js";
+import {
+  cost_cli,
+  cost_verdict
+} from "./chunk-JEYITIWB.js";
+import {
+  shell_segments
+} from "./chunk-CVJHQOI3.js";
+import {
+  run_cut,
+  run_cut_handoff
+} from "./chunk-TFDVTU6O.js";
+import {
+  agent_session_role
+} from "./chunk-DURHGVRC.js";
+import {
+  agent_provider
+} from "./chunk-DDZVMXZD.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 {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/rules/implementation-cut.ts
+import path from "node:path";
+
+// scripts/rules/edit-tool.ts
+var EDIT = "Edit";
+var WRITE = "Write";
+var EDIT_TOOLS = /* @__PURE__ */ new Set([EDIT, WRITE]);
+function is_edit_tool(name) {
+  return EDIT_TOOLS.has(name);
+}
+function string_field(input, key) {
+  const value = input[key];
+  return typeof value === "string" ? value : "";
+}
+var edit_tool = {
+  EDIT,
+  WRITE,
+  is_edit_tool,
+  string_field
+};
+
+// scripts/rules/implementation-cut-verdict.ts
+import { z } from "zod";
+var VERDICT_CACHE_PREFIX = "josh-impl-cut-verdict-";
+var VERDICT_REUSE_MS = 5e3;
+var VERDICT_VALUES = [
+  "over",
+  "under",
+  "unmeasurable"
+];
+var cache_schema = z.object({ read_at_ms: z.number(), verdict: z.enum(VERDICT_VALUES) });
+function cache_path(directory) {
+  return stamp_file.stamp_path(VERDICT_CACHE_PREFIX, directory);
+}
+function cached_verdict(target, now_ms) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return void 0;
+  const cached = json_value.parse_with(raw, cache_schema);
+  if (cached === void 0) return void 0;
+  return now_ms - cached.read_at_ms < VERDICT_REUSE_MS ? cached.verdict : void 0;
+}
+function reused_verdict(read, directory, now_ms = Date.now()) {
+  const target = cache_path(directory);
+  const cached = cached_verdict(target, now_ms);
+  if (cached !== void 0) return cached;
+  const value = read();
+  stamp_file.replace_stamp(target, { read_at_ms: now_ms, verdict: value });
+  return value;
+}
+var implementation_cut_verdict = {
+  VERDICT_REUSE_MS,
+  cache_path,
+  reused_verdict
+};
+
+// scripts/rules/implementation-cut.ts
+var { is_edit_tool: is_edit_tool2 } = edit_tool;
+var CUT_COMMANDS = /* @__PURE__ */ new Set(["run:cut"]);
+var IMPL_FLAG = /(?:^|\s)--impl(?:[=\s]|$)/u;
+var RESUME_FLAG = /(?:^|\s)--resume(?:[=\s]|$)/u;
+function calls_cut_with(command, flag) {
+  return shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, CUT_COMMANDS) && flag.test(segment));
+}
+function takes_the_impl_cut(command) {
+  return calls_cut_with(command, IMPL_FLAG);
+}
+function resumes_a_cut(command) {
+  return calls_cut_with(command, RESUME_FLAG);
+}
+function can_cut_sync(issue, cwd) {
+  const directory = run_cut.worktree_git_directory_sync(cwd);
+  if (run_cut_decline.is_declined_sync(issue, directory)) return false;
+  return run_cut_ready.is_ready_sync(() => run_cut_ready.read_tree_sync(cwd));
+}
+function is_named(value) {
+  return value !== void 0 && value !== "";
+}
+function environment_for(transcript, source) {
+  if (agent_provider.resolve_provider(source).kind === "rejected" || is_named(source[agent_provider.CODEX_SESSION_KEY]) || is_named(source[agent_session_environment.SESSION_ID_KEY])) {
+    return source;
+  }
+  return {
+    ...source,
+    [agent_session_environment.SESSION_ID_KEY]: path.basename(transcript, ".jsonl")
+  };
+}
+function session_verdict(transcript, directory, source) {
+  return implementation_cut_verdict.reused_verdict(
+    () => cost_cli.session_verdict(directory, environment_for(transcript, source)),
+    transcript
+  );
+}
+function current_state(context, transcript) {
+  const { cwd, env } = context;
+  return {
+    directory: cwd,
+    source: env,
+    // The cut record and the run hold of the call's own work tree.
+    carried: (now) => run_cut.carried_cut_sync(now, run_cut.worktree_git_directory_sync(cwd)),
+    held_issue: () => run_cut.held_issue_sync(run_cut.worktree_git_directory_sync(cwd)),
+    // **Read through the short reuse window**. The row now fires per
+    // threshold crossing rather than once per run, so this predicate is a candidate on every edit;
+    // the window collapses one turn's burst of edits to a single whole-transcript price.
+    verdict: () => transcript === void 0 ? implementation_cut_verdict.reused_verdict(() => cost_cli.session_verdict(cwd, env), cwd) : session_verdict(transcript, cwd, env),
+    can_cut: (issue) => can_cut_sync(issue, cwd)
+  };
+}
+function lane_child_issue(state) {
+  if (!lane_child_marker.is_child_of(state.directory, state.source)) return void 0;
+  return lane_paths.lane_issue_of(state.directory, { ...state.source });
+}
+function held_run_issue(state) {
+  if (lane_paths.lane_issue_of(state.directory, { ...state.source }) !== void 0) return void 0;
+  return state.held_issue();
+}
+function implementing_run_issue(state) {
+  if (agent_session_role.is_reviewer(state.source)) return void 0;
+  return lane_child_issue(state) ?? held_run_issue(state);
+}
+function uncut_run_issue(state) {
+  const issue = implementing_run_issue(state);
+  if (issue === void 0) return void 0;
+  return state.carried()?.issue === issue ? void 0 : issue;
+}
+function file_path_of(call) {
+  if (!json_value.is_record(call.input)) return "";
+  const value = call.input["file_path"];
+  return typeof value === "string" ? value : "";
+}
+function is_handoff_write(call, directory, issue) {
+  const handoff = path.resolve(directory, run_cut_handoff.handoff_path_of(issue));
+  return path.resolve(directory, file_path_of(call)) === handoff;
+}
+function refusable_issue(call, state) {
+  const issue = uncut_run_issue(state);
+  if (issue === void 0) return void 0;
+  return is_handoff_write(call, state.directory, issue) ? void 0 : issue;
+}
+function warrants_the_cut(state) {
+  return state.verdict() === cost_verdict.OVER_VERDICT;
+}
+function is_over_threshold_edit(call, state) {
+  if (!is_edit_tool2(call.name)) return false;
+  const issue = refusable_issue(call, state);
+  if (issue === void 0) return false;
+  return warrants_the_cut(state) && state.can_cut(issue);
+}
+var THRESHOLD_TEXT = "`pnpm josh cost --cut`";
+var IMPLEMENTATION_CUT_REASON = `\u26D4 implementation-phase cut: refused on every edit over ${THRESHOLD_TEXT}. Write \`${run_cut_handoff.HANDOFF_PATH}\`: ${run_cut_handoff.HANDOFF_FORMAT}, run \`pnpm josh run:cut --impl <N> --handoff <path>\`; \`cut\`: end the turn immediately, no Telegram is owed; else reissue the edit (\`.claude/skills/workflow-commands/pre-gate-cut.md\`).`;
+var REISSUE_WINDOW_MS = 9e4;
+function is_reissued_refusal(now_ms, delivered_at_ms) {
+  return now_ms - delivered_at_ms < REISSUE_WINDOW_MS;
+}
+function decide(_call, run, _can_record, delivered_at_ms) {
+  return !is_reissued_refusal(run.now_ms, delivered_at_ms);
+}
+function decide_for_session(call, run, can_record, delivered_at_ms) {
+  return decide(call, run, can_record, delivered_at_ms) && is_over_threshold_edit(call, current_state(run.context, run.transcript));
+}
+function is_refusable_edit(call, state) {
+  return is_edit_tool2(call.name) && refusable_issue(call, state) !== void 0;
+}
+function is_refusable_edit_in(call, context) {
+  return is_refusable_edit(call, current_state(context));
+}
+var ROW = {
+  id: "implementation-cut",
+  is_trigger: is_refusable_edit_in,
+  reason: IMPLEMENTATION_CUT_REASON,
+  decide: decide_for_session,
+  // The opening the reason carried before it was cut to the action and the next command.
+  former_reasons: [
+    "\u26D4 implementation-phase cut: this checkout is a lane dispatched",
+    "\u26D4 implementation-phase cut: this run's context crossed the"
+  ],
+  about: {
+    title: "The implementation-phase cut",
+    topic: '`.claude/skills/workflow-commands/pre-gate-cut.md` \u2192 "It is a guard, fired at the edit that crosses the threshold"',
+    fires: "an `Edit` / `Write` by an uncut lane child whose recent context is over the `pnpm josh cost --cut` threshold; it hands over `pnpm josh run:cut --impl <N> --handoff <path>`. At each threshold crossing",
+    quiet: "not a lane child, a non-editing tool, the run's own handoff file, already cut, or under the threshold"
+  }
+};
+var implementation_cut = {
+  IMPLEMENTATION_CUT_REASON,
+  REISSUE_WINDOW_MS,
+  ROW,
+  decide,
+  is_over_threshold_edit,
+  is_reissued_refusal,
+  resumes_a_cut,
+  session_verdict,
+  takes_the_impl_cut,
+  uncut_run_issue
+};
+
+export {
+  edit_tool,
+  implementation_cut_verdict,
+  implementation_cut
+};

package/dist/commands/chunk-ZGANVZCA.js

@@ -0,0 +1,92 @@
+import {
+  run_ship_body_draft
+} from "./chunk-NVMV7BYX.js";
+import {
+  cli_body
+} from "./chunk-7IZJ5MG2.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+
+// scripts/run/ship/run-ship-args.ts
+var FIRST = 0;
+var NUMBER_GROUP = 1;
+var EXTRA_CITE_START = 1;
+var TRAILING_ISSUE_PATTERN = /#([1-9]\d*)\s*$/u;
+var NOTIFY_OPTIONS = ["notify-message", "notify-message-file"];
+var { BODY_FILE_OPTION, body_arguments } = run_ship_body_draft;
+var UNPINNED_OK_OPTION = "unpinned-ok";
+var OPTIONS = {
+  [NOTIFY_OPTIONS[0]]: { type: "string" },
+  [NOTIFY_OPTIONS[1]]: { type: "string" },
+  [BODY_FILE_OPTION]: { type: "string" },
+  review: { type: "boolean" },
+  // Hand the region to a detached supervisor (`run-ship-detach.ts`), print the
+  // report a stopped supervisor left, and carry follow-up citations as options so the supervisor's
+  // command line still ends with its title.
+  detach: { type: "boolean" },
+  log: { type: "string" },
+  cite: { type: "string", multiple: true },
+  // Forwarded to round 1's `run:review`, the only way past a change no test can pin under `--review`.
+  [UNPINNED_OK_OPTION]: { type: "string" }
+};
+function notify_arguments(values) {
+  return NOTIFY_OPTIONS.flatMap((option) => {
+    const value = values[option];
+    return value === void 0 ? [] : [`--${option}`, value];
+  });
+}
+function issue_number(title) {
+  return TRAILING_ISSUE_PATTERN.exec(title)?.[NUMBER_GROUP];
+}
+function unpinned_arguments(reason) {
+  return reason === void 0 ? [] : [`--${UNPINNED_OK_OPTION}`, reason];
+}
+function is_stray_unpinned_ok(values) {
+  const reason = values[UNPINNED_OK_OPTION];
+  if (reason === void 0) return false;
+  return values.review !== true || reason.trim() === "";
+}
+function is_refused_option(values) {
+  return is_stray_unpinned_ok(values) || values[BODY_FILE_OPTION] === cli_body.STDIN_PATH;
+}
+function ship_args(title, rest, values) {
+  const number = issue_number(title);
+  const cites = [...rest, ...values.cite ?? []];
+  if (number === void 0 || cites.some((token) => !issue_number_shape.is_issue_number(token))) {
+    return void 0;
+  }
+  return {
+    title,
+    number,
+    notify: notify_arguments(values),
+    body: body_arguments(values[BODY_FILE_OPTION]),
+    body_path: values[BODY_FILE_OPTION],
+    cites,
+    is_review: values.review === true,
+    is_detach: values.detach === true,
+    unpinned_ok: unpinned_arguments(values[UNPINNED_OK_OPTION])
+  };
+}
+function log_command(number, positionals) {
+  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(number) && positionals.length === 0 ? { kind: "log", number } : void 0;
+}
+function command_of(values, positionals) {
+  if (values.log !== void 0) return log_command(values.log, positionals);
+  if (is_refused_option(values)) return void 0;
+  const title = positionals[FIRST];
+  const args = title === void 0 ? void 0 : ship_args(title, positionals.slice(EXTRA_CITE_START), values);
+  return args === void 0 ? void 0 : { kind: "ship", args };
+}
+function parse(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  return parsed === void 0 ? void 0 : command_of(parsed.values, parsed.positionals);
+}
+var run_ship_args = { parse };
+
+export {
+  run_ship_args
+};

package/dist/commands/chunk-ZGEUWHFF.js

@@ -0,0 +1,297 @@
+import {
+  lane_implement_rate
+} from "./chunk-KP2BVAS5.js";
+import {
+  run_record_path
+} from "./chunk-WL5JHB3I.js";
+import {
+  hook_launch
+} from "./chunk-OF4BY4N7.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  issue_body_keys
+} from "./chunk-KXK2A2HB.js";
+
+// scripts/agent/codex-hooks.ts
+var CODEX_EDIT_TOOL = "apply_patch|functions.apply_patch";
+var CODEX_SHELL_TOOLS = "exec_command|functions.exec_command|exec|functions.exec";
+var TOOL_EVENTS = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUse"]);
+var UNMATCHED_EVENTS = /* @__PURE__ */ new Set(["UserPromptSubmit"]);
+var JSON_INDENT = "	";
+var CLAUDE_SETTINGS_FILE = ".claude/settings.json";
+var CODEX_HOOKS_FILE = ".codex/hooks.json";
+var GENERATED_SOURCES = /* @__PURE__ */ new Map([
+  [CODEX_HOOKS_FILE, CLAUDE_SETTINGS_FILE]
+]);
+function adapter_command(mode) {
+  return hook_launch.hook_launch_command(`codex-hook-adapter ${mode}`, hook_launch.CODEX_ROOT);
+}
+var ADAPTED_COMMANDS = /* @__PURE__ */ new Map([
+  [hook_launch.hook_launch_command("pretool-guard"), adapter_command("pretool")],
+  [hook_launch.hook_launch_command("format-edited"), adapter_command("posttool")]
+]);
+function codex_handler(handler) {
+  const command = ADAPTED_COMMANDS.get(handler.command) ?? hook_launch.codex_command(handler.command);
+  return { ...handler, command };
+}
+function codex_matcher(event, matcher) {
+  if (UNMATCHED_EVENTS.has(event)) return void 0;
+  if (matcher !== void 0 && TOOL_EVENTS.has(event)) {
+    return `${matcher}|${CODEX_EDIT_TOOL}|${CODEX_SHELL_TOOLS}`;
+  }
+  return matcher;
+}
+function codex_group(event, group) {
+  const matcher = codex_matcher(event, group.matcher);
+  const hooks = group.hooks.map((handler) => codex_handler(handler));
+  return matcher === void 0 ? { hooks } : { matcher, hooks };
+}
+function codex_hook_config(claude) {
+  const events = Object.entries(claude.hooks).map(([event, groups]) => [
+    event,
+    groups.map((group) => codex_group(event, group))
+  ]);
+  return { hooks: Object.fromEntries(events) };
+}
+function codex_hooks_text(claude_settings_text) {
+  const claude = JSON.parse(claude_settings_text);
+  return `${JSON.stringify(codex_hook_config(claude), void 0, JSON_INDENT)}
+`;
+}
+var codex_hooks = {
+  adapter_command,
+  codex_hook_config,
+  codex_hooks_text,
+  CLAUDE_SETTINGS_FILE,
+  CODEX_HOOKS_FILE,
+  GENERATED_SOURCES
+};
+
+// scripts/git/git-path-quoting.ts
+var OCTAL_RADIX = 8;
+var OCTAL_WIDTH = 3;
+var SPACE_CODE = 32;
+var DELETE_CODE = 127;
+var ESCAPES = /* @__PURE__ */ new Map([
+  ["\x07", "a"],
+  ["\b", "b"],
+  ["	", "t"],
+  ["\n", "n"],
+  ["\v", "v"],
+  ["\f", "f"],
+  ["\r", "r"],
+  ['"', '"'],
+  ["\\", "\\"]
+]);
+function escape_character(character) {
+  const short = ESCAPES.get(character);
+  if (short !== void 0) return `\\${short}`;
+  const code = character.codePointAt(0) ?? 0;
+  return code === DELETE_CODE || code < SPACE_CODE ? `\\${code.toString(OCTAL_RADIX).padStart(OCTAL_WIDTH, "0")}` : character;
+}
+function quote(file) {
+  const escaped = Array.from(file, (character) => escape_character(character)).join("");
+  return escaped === file ? file : `"${escaped}"`;
+}
+function unescape_character(escaped) {
+  return [...ESCAPES].find((entry) => entry[1] === escaped)?.[0] ?? String.fromCodePoint(Number.parseInt(escaped, OCTAL_RADIX));
+}
+function unquote(file) {
+  if (!file.startsWith('"') || !file.endsWith('"')) return file;
+  return file.slice(1, -1).replaceAll(
+    /\\([0-7]{3}|a|b|f|n|r|t|v|["\\])/gu,
+    (_match, escaped) => unescape_character(escaped)
+  );
+}
+var git_path_quoting = { quote, unquote };
+
+// scripts/split/declared-growth.ts
+var FALLBACK = 2;
+function factor(ratios, axis) {
+  return ratios?.[axis] ?? FALLBACK;
+}
+function axis_text(ratios, axis) {
+  const source = ratios?.[axis] === void 0 ? "fallback" : "measured";
+  return `${axis} \xD7 ${String(factor(ratios, axis))} (${source})`;
+}
+function text(ratios) {
+  return `growth ${axis_text(ratios, "files")} / ${axis_text(ratios, "lines")}`;
+}
+var declared_growth = { FALLBACK, factor, text };
+
+// scripts/split/split-assess.ts
+var FILE_GUIDE = 8;
+var LINE_GUIDE = 200;
+var CAP_FACTOR = 1.5;
+var FILE_CAP = FILE_GUIDE * CAP_FACTOR;
+var LINE_CAP = LINE_GUIDE * CAP_FACTOR;
+var DEFAULT_GUIDE = {
+  files: FILE_GUIDE,
+  lines: LINE_GUIDE,
+  cap: { files: FILE_CAP, lines: LINE_CAP }
+};
+function guide_for(minutes, measured, growth) {
+  const lines = lane_implement_rate.lines_for(minutes, measured);
+  const correction = growth === void 0 ? {} : { growth };
+  if (lines === void 0 || lines <= LINE_GUIDE) return { ...DEFAULT_GUIDE, ...correction };
+  const files = lines * FILE_GUIDE / LINE_GUIDE;
+  return {
+    files,
+    lines,
+    cap: { files: files * CAP_FACTOR, lines: lines * CAP_FACTOR },
+    ...correction
+  };
+}
+var DECLARED_GROWTH_FACTOR = declared_growth.FALLBACK;
+var SPLIT_VERDICT = "split";
+var SINGLE_VERDICT = "single";
+var SCRIPTS_DIRECTORY = "scripts/";
+var TYPESCRIPT = ".ts";
+var BINARY_MARKER = "-";
+var NUMSTAT_FIELDS = 3;
+function parse_count(field) {
+  if (field === void 0 || field === BINARY_MARKER) return 0;
+  const value = Number(field);
+  return Number.isNaN(value) ? 0 : value;
+}
+function parse_row(row) {
+  const fields = row.split("	");
+  if (fields.length < NUMSTAT_FIELDS) return void 0;
+  const [added, deleted, ...path_parts] = fields;
+  return { path: path_parts.join("	"), changed_lines: parse_count(added) + parse_count(deleted) };
+}
+function parse_numstat(raw) {
+  return raw.split("\n").map((line) => line.trim()).filter((line) => line !== "").map((row) => parse_row(row)).filter((change) => change !== void 0);
+}
+function is_deliverable(change) {
+  const file = git_path_quoting.unquote(change.path);
+  return !test_declared_logic.is_test_file(file) && !run_record_path.is_run_record(file);
+}
+function is_scripts_module(file) {
+  return file.startsWith(SCRIPTS_DIRECTORY) && file.endsWith(TYPESCRIPT);
+}
+function directory_of(file) {
+  return file.slice(0, file.lastIndexOf("/") + 1);
+}
+function partners_of(files, added) {
+  const modules = files.filter((file) => is_scripts_module(file));
+  const partners = /* @__PURE__ */ new Map();
+  const new_modules = modules.filter((file) => added.has(file));
+  for (const module of new_modules) {
+    const importer = modules.find(
+      (file) => !added.has(file) && !partners.has(file) && directory_of(file) === directory_of(module)
+    );
+    if (importer !== void 0) partners.set(module, importer).set(importer, module);
+  }
+  return partners;
+}
+function units_of(files, added) {
+  const artifacts = codex_hooks.GENERATED_SOURCES;
+  const sources = files.filter((file) => !files.includes(artifacts.get(file) ?? ""));
+  const partners = partners_of(sources, added);
+  return sources.flatMap((file) => {
+    const partner = partners.get(file);
+    const unit = partner === void 0 ? [file] : [file, partner];
+    const generated = files.filter((path) => unit.includes(artifacts.get(path) ?? ""));
+    return partner !== void 0 && sources.indexOf(partner) < sources.indexOf(file) ? [] : [[...unit, ...generated]];
+  });
+}
+function verdict_for(files, lines, guide = DEFAULT_GUIDE) {
+  return files > guide.files || lines > guide.lines ? SPLIT_VERDICT : SINGLE_VERDICT;
+}
+function is_over_cap(files, lines, guide = DEFAULT_GUIDE) {
+  return files > guide.cap.files || lines > guide.cap.lines;
+}
+function measure(changes, guide, added = /* @__PURE__ */ new Set()) {
+  const runtime = changes.filter((change) => is_deliverable(change));
+  const lines = runtime.reduce((total, change) => total + change.changed_lines, 0);
+  const paths = runtime.map((change) => git_path_quoting.unquote(change.path));
+  const files = units_of(paths, added).length;
+  return {
+    files,
+    lines,
+    verdict: verdict_for(files, lines, guide),
+    ...guide !== void 0 && { guide }
+  };
+}
+function assess(raw, guide, added) {
+  return measure(parse_numstat(raw), guide, added);
+}
+var SPLIT_TAIL = "over the guide \u2014 the size condition for a split is met (separability is a separate judgement)";
+var SINGLE_TAIL = "under the guide on both axes \u2014 one Issue, however separable";
+function counted(measurement) {
+  return `${String(measurement.files)} changed file(s), ${String(measurement.lines)} changed line(s), tests excluded`;
+}
+function guide_text(guide) {
+  return `guide ${String(guide.files)} files / ${String(guide.lines)} lines`;
+}
+function policy_text(guide) {
+  const source = guide.lines > LINE_GUIDE ? "measured" : "fallback";
+  return `${guide_text(guide)} (${source}); ${declared_growth.text(guide.growth)}`;
+}
+function reason(measurement, guide = measurement.guide ?? DEFAULT_GUIDE) {
+  const tail = measurement.verdict === SPLIT_VERDICT ? SPLIT_TAIL : SINGLE_TAIL;
+  return `${counted(measurement)} (${policy_text(guide)}) \u2014 ${tail}`;
+}
+function grown_bar(declared, guide) {
+  const grown_files = declared.files * declared_growth.factor(guide.growth, "files");
+  const grown_lines = declared.lines * declared_growth.factor(guide.growth, "lines");
+  const files = Math.min(grown_files, guide.files);
+  const lines = Math.min(grown_lines, guide.lines);
+  const capped = files < grown_files || lines < grown_lines ? ", capped at the guide" : "";
+  const declaration = `declared ${String(declared.files)} files / ${String(declared.lines)} lines`;
+  return {
+    files,
+    lines,
+    text: `${declaration}; ${declared_growth.text(guide.growth)}${capped} = ${String(files)} files / ${String(lines)} lines`
+  };
+}
+function is_sized(declared) {
+  return declared !== void 0 && declared.files > 0 && declared.lines > 0;
+}
+function notice_bar(declared, guide) {
+  const guide_bar = { files: guide.files, lines: guide.lines, text: guide_text(guide) };
+  if (!is_sized(declared)) return guide_bar;
+  const bar = grown_bar(declared, guide);
+  return bar.files === guide.files && bar.lines === guide.lines ? guide_bar : bar;
+}
+var NOTICE_SECTION = "Over the guide before the gate";
+var QUESTION_SECTION = "The question";
+var REASON_PREFIX = issue_body_keys.prefix("no_split_reason");
+var NOTICE_ACTION = `go on to the end; a started Issue is never split, and the merge records the overrun as a pre-split miss \u2014 split-assessment.md \u2192 "${NOTICE_SECTION}"`;
+function notice(measurement, declared, guide = measurement.guide ?? DEFAULT_GUIDE) {
+  const bar = notice_bar(declared, guide);
+  if (measurement.files <= bar.files && measurement.lines <= bar.lines) return void 0;
+  return `split notice: ${counted(measurement)} (${bar.text}; ${policy_text(guide)}) \u2014 over the bar, a warning, not a stop: ${NOTICE_ACTION}`;
+}
+var split_assess = {
+  DECLARED_GROWTH_FACTOR,
+  FILE_CAP,
+  FILE_GUIDE,
+  LINE_CAP,
+  LINE_GUIDE,
+  NOTICE_SECTION,
+  QUESTION_SECTION,
+  REASON_PREFIX,
+  SPLIT_VERDICT,
+  SINGLE_VERDICT,
+  assess,
+  guide_for,
+  is_deliverable,
+  is_over_cap,
+  notice,
+  measure,
+  parse_numstat,
+  policy_text,
+  reason,
+  units_of,
+  verdict_for
+};
+
+export {
+  declared_growth,
+  git_path_quoting,
+  split_assess
+};