@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-ON4IKRGS.js

@@ -0,0 +1,469 @@
+import {
+  review_stop_log
+} from "./chunk-GGWXF7RJ.js";
+import {
+  agent_safe_text
+} from "./chunk-3LZXX5GL.js";
+import {
+  shell_quote
+} from "./chunk-W2IA2LV3.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  git_common_directory
+} from "./chunk-JPMAW2VZ.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+import {
+  PROBE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-reap.ts
+import { execFileSync } from "node:child_process";
+
+// scripts/run/ship/run-ship-next.ts
+var { STAGE } = run_ship_stage;
+var COMMAND = {
+  LOG: "pnpm josh ship --log",
+  DETACH: "pnpm josh ship --detach",
+  DETACH_REVIEW: "pnpm josh ship --detach --review"
+};
+function resume_of(args) {
+  const cites = args.cites.flatMap((cite) => ["--cite", cite]);
+  return {
+    title: args.title,
+    flags: [...args.notify, ...args.body, ...cites],
+    is_review: args.is_review,
+    unpinned_ok: args.unpinned_ok
+  };
+}
+function ship_command(command, resume, review_flags = []) {
+  const words = [...review_flags, ...resume.flags, resume.title].map(
+    (token) => shell_quote.word(token)
+  );
+  return [command, ...words].join(" ");
+}
+function review_command(resume) {
+  return ship_command(COMMAND.DETACH_REVIEW, resume, resume.unpinned_ok);
+}
+function detach_again(resume) {
+  return `leave the fix uncommitted and run \`${ship_command(COMMAND.DETACH, resume)}\`.`;
+}
+function detach_as_started(resume) {
+  const command = resume.is_review ? review_command(resume) : ship_command(COMMAND.DETACH, resume);
+  return `leave the fix uncommitted and run \`${command}\`.`;
+}
+var AFTER_FIX = {
+  [STAGE.PREFLIGHT]: detach_as_started,
+  [STAGE.REVIEW]: detach_as_started,
+  [STAGE.GATE]: detach_as_started,
+  [STAGE.SYNC]: detach_as_started,
+  [STAGE.COMMIT]: detach_as_started,
+  [STAGE.ROUND_TWO]: detach_again,
+  [STAGE.FOLLOWUP]: detach_again,
+  [STAGE.REPORT]: detach_again
+};
+function detach_review_again(resume) {
+  return `leave the fix uncommitted and run \`${review_command(resume)}\` \u2014 the review read the issue before its update, so the supervisor reviews round 1 again.`;
+}
+function after_fix(stage, resume) {
+  return resume.is_review_stale === true ? detach_review_again(resume) : AFTER_FIX[stage](resume);
+}
+function conflict_step(conflicts) {
+  return `Resolve the conflict with origin/main in ${conflicts.join(", ")} (the merge is left in progress: remove the conflict markers in those files), then`;
+}
+function fix_step(issue, stage, is_excerpted) {
+  if (is_excerpted) return `Fix the ${stage} failure shown in the output below`;
+  return `Read the stopped report with \`${COMMAND.LOG} ${issue}\`, fix the ${stage} failure`;
+}
+function next_step(issue, stage, resume, is_excerpted = false) {
+  const conflicts = resume.conflicts ?? [];
+  if (conflicts.length > 0) return `${conflict_step(conflicts)} ${after_fix(stage, resume)}`;
+  return `${fix_step(issue, stage, is_excerpted)}, then ${after_fix(stage, resume)}`;
+}
+var run_ship_next = { COMMAND, next_step, resume_of };
+
+// scripts/run/ship/run-ship-stop-context.ts
+import { stripVTControlCharacters } from "node:util";
+
+// scripts/review/review-prior-findings.ts
+var PRIOR_LIMIT = 5;
+var ENTRY_LENGTH_LIMIT = 400;
+var LINE_SUFFIX = /:\d.*$/u;
+var KEY_SEPARATOR = " \u2014 ";
+var LINE_BREAKS = /[\n\r]+/gu;
+function file_of(location) {
+  return location.replace(LINE_SUFFIX, "");
+}
+function key_of(finding) {
+  return `${finding.location}${KEY_SEPARATOR}${finding.sentence}`;
+}
+function entry_text(line) {
+  const disposition = line.fixed === true ? "fixed in place" : "stopped";
+  const text = `${key_of(line)} (${line.kind}, ${disposition} in the ${line.stage} stage)`;
+  return agent_safe_text.printable(text.replaceAll(LINE_BREAKS, " ")).slice(0, ENTRY_LENGTH_LIMIT);
+}
+function latest(issue, is_kept, log_path) {
+  return review_stop_log.read(log_path).filter((line) => String(line.issue) === issue && is_kept(line)).slice(-PRIOR_LIMIT).map((line) => entry_text(line));
+}
+function on_files(issue, current, log_path) {
+  const files = new Set(current.map((finding) => file_of(finding.location)));
+  const own = new Set(current.map((finding) => key_of(finding)));
+  return latest(
+    issue,
+    (line) => files.has(file_of(line.location)) && !own.has(key_of(line)),
+    log_path
+  );
+}
+function fix_lines(entries) {
+  if (entries === void 0 || entries.length === 0) return [];
+  return [
+    "Earlier review findings on the same files in this lane \u2014 confirm the fix still meets each before shipping again:",
+    ...entries.map((entry) => `- ${entry}`)
+  ];
+}
+function prompt_clauses(issue, log_path) {
+  const entries = latest(issue, () => true, log_path);
+  if (entries.length === 0) return [];
+  return [
+    `Earlier review rounds in this lane recorded these findings: ${entries.join("; ")}.`,
+    "Check that the change still meets each of them, and report a change that breaks one as a finding."
+  ];
+}
+var review_prior_findings = {
+  ENTRY_LENGTH_LIMIT,
+  PRIOR_LIMIT,
+  fix_lines,
+  latest,
+  on_files,
+  prompt_clauses
+};
+
+// scripts/run/ship/run-ship-stop-context.ts
+import { z } from "zod";
+var EXCERPT_LINE_LIMIT = 40;
+var EXCERPT_LINE_WIDTH = 240;
+var CHANGED_PATH_LIMIT = 30;
+var OUTPUT_PREFIX = "josh-ship-stop-";
+var OUTPUT_SUFFIX = ".log";
+var KEY_SEPARATOR2 = "-";
+var LINE_BREAK = "\n";
+var CARRIAGE_RETURN = "\r";
+var omitted_schema = z.object({ path: z.string().optional(), last_line: z.number().int() }).strict();
+var stop_context_schema = z.object({
+  excerpt: z.array(z.string()).readonly(),
+  omitted: omitted_schema.optional(),
+  changed: z.array(z.string()).readonly().optional(),
+  more_changed: z.number().int(),
+  prior: z.array(z.string()).readonly().optional()
+}).strict();
+function shown_frame(line) {
+  return line.trimEnd().split(CARRIAGE_RETURN).at(-1) ?? "";
+}
+function output_lines(output) {
+  return stripVTControlCharacters(output).trimEnd().split(LINE_BREAK).map((line) => agent_safe_text.printable(shown_frame(line)));
+}
+async function keep_full_output(issue, output) {
+  const repository = await git_common_directory.read_repository();
+  if (repository === void 0) return void 0;
+  const target = stamp_file.stamp_path(
+    `${OUTPUT_PREFIX}${issue}${KEY_SEPARATOR2}`,
+    repository,
+    OUTPUT_SUFFIX
+  );
+  try {
+    return stamp_file.replace_text_stamp(target, output);
+  } catch {
+    return void 0;
+  }
+}
+async function omitted_range(issue, lines) {
+  const path2 = await keep_full_output(issue, lines.join(LINE_BREAK));
+  const last_line = lines.length - EXCERPT_LINE_LIMIT;
+  return path2 === void 0 ? { last_line } : { path: path2, last_line };
+}
+function clipped(lines) {
+  return lines.map((line) => line.slice(0, EXCERPT_LINE_WIDTH));
+}
+async function excerpt_of(issue, output) {
+  const lines = output.trim() === "" ? [] : output_lines(output);
+  if (lines.length <= EXCERPT_LINE_LIMIT) return { excerpt: clipped(lines) };
+  return {
+    excerpt: clipped(lines.slice(-EXCERPT_LINE_LIMIT)),
+    omitted: await omitted_range(issue, lines)
+  };
+}
+async function read_paths() {
+  try {
+    return await changed_paths.read_changed_paths(false);
+  } catch {
+    return void 0;
+  }
+}
+async function changed_of() {
+  const paths = await read_paths();
+  if (paths === void 0) return { more_changed: 0 };
+  return {
+    changed: paths.slice(0, CHANGED_PATH_LIMIT),
+    more_changed: Math.max(0, paths.length - CHANGED_PATH_LIMIT)
+  };
+}
+async function build(issue, output, findings = []) {
+  const prior = review_prior_findings.on_files(issue, findings);
+  return {
+    ...await excerpt_of(issue, output),
+    ...await changed_of(),
+    ...prior.length > 0 && { prior }
+  };
+}
+function has_excerpt(context) {
+  return context !== void 0 && context.excerpt.length > 0;
+}
+function excerpt_heading(issue, omitted, shown) {
+  if (omitted === void 0) return "The failed stage output:";
+  const source = omitted.path ?? `the stopped report (\`${run_ship_next.COMMAND.LOG} ${issue}\`)`;
+  const range = `lines 1-${String(omitted.last_line)} are in ${source}`;
+  return `The failed stage output (its last ${String(shown)} lines; ${range}):`;
+}
+function with_dropped(omitted, dropped) {
+  if (dropped === 0) return omitted;
+  return { ...omitted, last_line: (omitted?.last_line ?? 0) + dropped };
+}
+function excerpt_block(issue, context, changed, dropped) {
+  const shown = context.excerpt.slice(dropped);
+  const heading = excerpt_heading(issue, with_dropped(context.omitted, dropped), shown.length);
+  return [heading, ...shown, changed].join(LINE_BREAK);
+}
+function changed_text(context) {
+  if (context.changed === void 0) return "The changed files could not be read from git.";
+  if (context.changed.length === 0) return "No files changed against the default branch.";
+  const more = context.more_changed > 0 ? ` (and ${String(context.more_changed)} more)` : "";
+  return `Changed files on the branch: ${context.changed.join(", ")}${more}.`;
+}
+function trailer_text(context) {
+  return [changed_text(context), ...review_prior_findings.fix_lines(context.prior)].join(LINE_BREAK);
+}
+function fitted_block(issue, context, budget) {
+  const changed = trailer_text(context);
+  if (!has_excerpt(context)) return changed;
+  let dropped = 0;
+  let block = excerpt_block(issue, context, changed, dropped);
+  while (block.length > budget && dropped < context.excerpt.length - 1) {
+    dropped += 1;
+    block = excerpt_block(issue, context, changed, dropped);
+  }
+  return block;
+}
+function has_prior(context) {
+  return context.prior !== void 0 && context.prior.length > 0;
+}
+function describe(issue, context, budget = agent_safe_text.MAX_VALUE_LENGTH) {
+  let fitted = context;
+  let block = fitted_block(issue, fitted, budget);
+  while (block.length > budget && has_prior(fitted)) {
+    fitted = { ...fitted, prior: fitted.prior?.slice(1) };
+    block = fitted_block(issue, fitted, budget);
+  }
+  return block;
+}
+var run_ship_stop_context = {
+  CHANGED_PATH_LIMIT,
+  EXCERPT_LINE_LIMIT,
+  build,
+  describe,
+  has_excerpt,
+  stop_context_schema
+};
+
+// scripts/lane/lane-child-invocation.ts
+var CHILD_INVOCATION = "fullrun";
+var LINE_BREAK2 = "\n";
+var REVIEW_INVOCATION = "the reviewer of lane";
+var RESUME_GUIDE = ".claude/skills/workflow-commands/pre-gate-cut.md";
+var SHIP_PROCESS = String.raw`(josh(\.[jt]s)? ship|run-ship-cli\.ts)`;
+function child_invocation(issue) {
+  issue_number_shape.require_issue_number(issue);
+  return `${CHILD_INVOCATION} ${issue_cite.plain_for("program", issue)}`;
+}
+function process_pattern(issue) {
+  issue_number_shape.require_issue_number(issue);
+  return `(${CHILD_INVOCATION}|${REVIEW_INVOCATION}|${SHIP_PROCESS} .*) ${issue_cite.plain_for("program", issue)}$`;
+}
+function ship_pattern(issue) {
+  issue_number_shape.require_issue_number(issue);
+  return `${SHIP_PROCESS} .* ${issue_cite.plain_for("program", issue)}$`;
+}
+function review_invocation(issue) {
+  issue_number_shape.require_issue_number(issue);
+  return `${REVIEW_INVOCATION} ${issue_cite.plain_for("program", issue)}`;
+}
+function resume_invocation(issue) {
+  const preamble = `Resuming the lane child for issue ${issue_cite.plain_for("program", issue)} \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Run \`pnpm josh run:entry ${issue}\` once before anything else; it checks the carried cut and completes the entry on \`fresh\`. Follow its resume verdict in ${RESUME_GUIDE}: \`resume\` goes to the gate, \`resume-impl\` continues implementation. Continue this`;
+  return `${preamble} ${child_invocation(issue)}`;
+}
+function outage_resume_invocation(issue) {
+  const preamble = `Resuming the lane child for issue ${issue_cite.plain_for("program", issue)} after an API disconnection \u2014 your session was restored with its full context, so do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Continue the run from where it stopped: run \`pnpm josh run:step ${issue}\` to find the next action, redoing only the last step if it did not complete.`;
+  return `${preamble} ${child_invocation(issue)}`;
+}
+function known_stop_lines(issue, stop, frame) {
+  const { context } = stop;
+  const is_excerpted = run_ship_stop_context.has_excerpt(context);
+  const next = run_ship_next.next_step(issue, stop.stage, stop, is_excerpted);
+  if (context === void 0) return [next];
+  const fixed = [...frame, next].join(LINE_BREAK2).length + LINE_BREAK2.length;
+  const budget = agent_safe_text.MAX_VALUE_LENGTH - fixed;
+  return [next, run_ship_stop_context.describe(issue, context, budget)];
+}
+function ship_stop_invocation(issue, stop) {
+  const opening = `Resuming the lane child for issue ${issue_cite.plain_for("program", issue)} after its detached ship supervisor stopped at a failed stage \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md).`;
+  const closing = `Do not re-plan or re-implement what is already on the branch. ${child_invocation(issue)}`;
+  const middle = stop === void 0 ? [
+    `Run \`pnpm josh run:step ${issue}\` and read the stopped report it names, fix what stopped the ship, then hand the region back per chain-rule.md.`
+  ] : known_stop_lines(issue, stop, [opening, closing]);
+  return [opening, ...middle, closing].join(LINE_BREAK2);
+}
+function ship_stop_note(issue, stop) {
+  return known_stop_lines(issue, stop, []).join(LINE_BREAK2);
+}
+var lane_child_invocation = {
+  child_invocation,
+  outage_resume_invocation,
+  process_pattern,
+  resume_invocation,
+  review_invocation,
+  ship_pattern,
+  ship_stop_invocation,
+  ship_stop_note
+};
+
+// scripts/lane/process-tools.ts
+import path from "node:path";
+var NOT_FOUND_CODE = "ENOENT";
+var PACKAGE_HINT = "install the package that provides it (procps on Debian/Ubuntu: `apt-get install procps`)";
+function is_not_found(error) {
+  return error instanceof Error && "code" in error && error.code === NOT_FOUND_CODE;
+}
+function missing_notice(command) {
+  return `\`${path.basename(command)}\` is not installed \u2014 kit's lane commands read processes with ps and pgrep; ${PACKAGE_HINT}`;
+}
+function throw_if_missing(command, error) {
+  if (is_not_found(error)) throw new Error(missing_notice(command), { cause: error });
+}
+var process_tools = { missing_notice, throw_if_missing };
+
+// scripts/lane/lane-reap.ts
+var PGREP_COMMAND = "pgrep";
+var MATCH_FULL_COMMAND_LINE = "-f";
+var CHILDREN_OF_FLAG = "-P";
+var PS_COMMAND = "/bin/ps";
+var PARENT_FORMAT = ["-o", "ppid=", "-p"];
+var TERMINATE_SIGNAL = "SIGTERM";
+var CONTINUE_SIGNAL = "SIGCONT";
+var LOWEST_CHILD_PID = 2;
+function parse_pids(printed) {
+  return printed.split("\n").map((line) => Number(line.trim())).filter((pid) => Number.isSafeInteger(pid) && pid >= LOWEST_CHILD_PID);
+}
+function run_probe(command, args) {
+  try {
+    return execFileSync(command, [...args], {
+      encoding: "utf8",
+      timeout: PROBE_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch (error) {
+    process_tools.throw_if_missing(command, error);
+    return "";
+  }
+}
+function parent_of(pid) {
+  return parse_pids(run_probe(PS_COMMAND, [...PARENT_FORMAT, String(pid)]))[0];
+}
+function send(pid, name) {
+  try {
+    process.kill(pid, name);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function terminate(pid) {
+  if (!send(pid, TERMINATE_SIGNAL)) return false;
+  send(pid, CONTINUE_SIGNAL);
+  return true;
+}
+var SYSTEM_PROBES = {
+  matching: (pattern) => parse_pids(run_probe(PGREP_COMMAND, [MATCH_FULL_COMMAND_LINE, pattern])),
+  children_of: (pid) => parse_pids(run_probe(PGREP_COMMAND, [CHILDREN_OF_FLAG, String(pid)])),
+  parent_of,
+  terminate
+};
+function ancestry_of(pid, probes = SYSTEM_PROBES) {
+  const ancestry = /* @__PURE__ */ new Set([pid]);
+  let current = probes.parent_of(pid);
+  while (current !== void 0 && !ancestry.has(current)) {
+    ancestry.add(current);
+    current = probes.parent_of(current);
+  }
+  return ancestry;
+}
+function own_ancestry(probes = SYSTEM_PROBES) {
+  return ancestry_of(process.pid, probes);
+}
+function tree_of(roots, probes) {
+  const tree = [];
+  const pending = [...roots];
+  let next = pending.shift();
+  while (next !== void 0) {
+    if (!tree.includes(next)) {
+      tree.push(next);
+      pending.push(...probes.children_of(next));
+    }
+    next = pending.shift();
+  }
+  return tree;
+}
+function roots_of(issue, own, probes) {
+  const pattern = lane_child_invocation.process_pattern(issue);
+  return probes.matching(pattern).filter((pid) => !own.has(pid));
+}
+function lane_tree(issue, probes = SYSTEM_PROBES) {
+  const own = own_ancestry(probes);
+  return tree_of(roots_of(issue, own, probes), probes).filter((pid) => !own.has(pid));
+}
+function reap_child(lane, probes = SYSTEM_PROBES) {
+  return lane_tree(lane.issue, probes).filter((pid) => probes.terminate(pid));
+}
+function is_child_running(issue, probes = SYSTEM_PROBES) {
+  return roots_of(issue, own_ancestry(probes), probes).length > 0;
+}
+var lane_reap = {
+  ancestry_of,
+  is_child_running,
+  lane_tree,
+  own_ancestry,
+  parse_pids,
+  PS_COMMAND,
+  reap_child,
+  run_probe,
+  SYSTEM_PROBES
+};
+
+export {
+  run_ship_next,
+  review_prior_findings,
+  run_ship_stop_context,
+  lane_child_invocation,
+  process_tools,
+  lane_reap
+};

package/dist/commands/chunk-OT74RSQO.js

@@ -0,0 +1,82 @@
+import {
+  run_board_closed
+} from "./chunk-DVCMQMRN.js";
+import {
+  lane_withdraw
+} from "./chunk-P43GWYR6.js";
+import {
+  lane_registry
+} from "./chunk-NEOCCN6D.js";
+import {
+  run_event_scope,
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/lane/lane-withdraw-closed.ts
+var SWEEP_REASON = "its issue was closed as not planned while the lane was still open";
+function is_not_planned(read) {
+  return read !== void 0 && read.is_not_planned && !read.is_merged;
+}
+async function closed_lanes() {
+  const listed = await lane_registry.list_lanes();
+  const lanes = listed.filter((lane) => !lane.is_stranded);
+  const { closed } = await run_board_closed.read_all(lanes.map((lane) => Number(lane.issue)));
+  return lanes.filter((lane) => is_not_planned(closed.get(Number(lane.issue))));
+}
+async function has_unpushed(branch) {
+  try {
+    return await git_command.commit_count_unpushed(branch) > 0;
+  } catch (error) {
+    error_text.trace_swallowed("lane_withdraw_closed.has_unpushed", error);
+    return true;
+  }
+}
+function kept_note(issue, by) {
+  const settled = by === "yield" ? "gave its lane back" : "is closed without a merge";
+  return `${session_cite.issue(issue)} ${settled}, but its branch has commits on no remote, so its lane is kept \u2014 run \`pnpm josh lane:withdraw ${issue}\` by hand.`;
+}
+async function withdraw_lane(lane, reason, by) {
+  if (await has_unpushed(lane.branch)) return { note: kept_note(lane.issue, by), is_retry: false };
+  const outcome = await lane_withdraw.withdraw(lane.issue, reason, by);
+  return {
+    note: lane_withdraw.describe(outcome, lane.issue),
+    is_retry: outcome.kind === "unreadable"
+  };
+}
+async function sweep_lane(lane, events) {
+  if (run_event_scope.is_withdrawn(events, lane.issue)) return void 0;
+  const { note } = await withdraw_lane(lane, SWEEP_REASON, "supervisor");
+  return note;
+}
+async function try_sweep_lane(lane, events) {
+  try {
+    return await sweep_lane(lane, events);
+  } catch (error) {
+    error_text.trace_swallowed("lane_withdraw_closed.sweep_lane", error);
+    return `${session_cite.issue(lane.issue)} could not be withdrawn (${error_text.message_of(error)}); the next pass tries again.`;
+  }
+}
+async function withdraw_closed() {
+  const lanes = await closed_lanes();
+  const events = await run_event_stream_emit.current_events();
+  const notes = [];
+  for (const lane of lanes) {
+    const note = await try_sweep_lane(lane, events);
+    if (note !== void 0) notes.push(note);
+  }
+  return notes;
+}
+var lane_withdraw_closed = { SWEEP_REASON, withdraw_closed, withdraw_lane };
+
+export {
+  lane_withdraw_closed
+};

package/dist/commands/chunk-OVCVINYW.js

@@ -0,0 +1,143 @@
+import {
+  backlogrun_parent_read_set,
+  lane_child_read_set
+} from "./chunk-KPMAJP6D.js";
+import {
+  document_byte_budget
+} from "./chunk-M3ZDYCUF.js";
+import {
+  entry_read_set
+} from "./chunk-LNQOL2CL.js";
+import {
+  PACKAGE_DIR
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/document/entry-read-budget.ts
+import { statSync } from "node:fs";
+import path from "node:path";
+
+// scripts/document/document-reachability.ts
+var RESIDENT_BASE = ["CLAUDE.md"];
+var WORKFLOW_DIRECTORY = ".claude/skills/workflow-commands";
+function workflow_path(name) {
+  return `${WORKFLOW_DIRECTORY}/${name}`;
+}
+function names_of(set) {
+  return [...set.files, ...set.sections.map((reference) => reference.file)];
+}
+function entry_read_names(root) {
+  const names = [...entry_read_set.entries(root), lane_child_read_set.LANE_CHILD].flatMap(
+    (entry) => names_of(entry_read_set.read_set(root, entry))
+  );
+  return new Set(names);
+}
+function resident_documents(root) {
+  return /* @__PURE__ */ new Set([
+    ...RESIDENT_BASE,
+    ...[...entry_read_names(root)].map((name) => workflow_path(name))
+  ]);
+}
+function point_of_use_documents() {
+  const per_entry = [...entry_read_set.POINT_OF_USE_BY_ENTRY.values()].flatMap((files) => [
+    ...files
+  ]);
+  return new Set(
+    [...entry_read_set.POINT_OF_USE_FILES, ...per_entry].map((name) => workflow_path(name))
+  );
+}
+function label_of(relative_path, resident, point_of_use) {
+  if (resident.has(relative_path)) return "resident";
+  return point_of_use.has(relative_path) ? "point-of-use" : "unreached";
+}
+function classify(corpus, root = process.cwd()) {
+  const resident = resident_documents(root);
+  const point_of_use = point_of_use_documents();
+  return new Map(corpus.map((one) => [one, label_of(one, resident, point_of_use)]));
+}
+function documents_labelled(label, corpus, root = process.cwd()) {
+  return [...classify(corpus, root)].filter(([, value]) => value === label).map(([one]) => one).toSorted((left, right) => left.localeCompare(right));
+}
+function covered_documents(root = process.cwd()) {
+  return [.../* @__PURE__ */ new Set([...resident_documents(root), ...point_of_use_documents()])].toSorted(
+    (left, right) => left.localeCompare(right)
+  );
+}
+function unreached_documents(corpus, root = process.cwd()) {
+  return documents_labelled("unreached", corpus, root);
+}
+var document_reachability = {
+  RESIDENT_BASE,
+  classify,
+  covered_documents,
+  documents_labelled,
+  unreached_documents
+};
+
+// scripts/document/entry-read-budget.ts
+var { block_ceiling } = document_byte_budget;
+var { LANE_CHILD } = lane_child_read_set;
+var { BACKLOGRUN } = backlogrun_parent_read_set;
+var NOTHING = 0;
+var RECHECK_COMMAND = "pnpm josh bytes";
+var ENTRY_READ_BUDGET = [
+  { entry: "kickoff", bytes: 36864 },
+  // joshuafolkken/kit#6094 trimmed restated prose from SKILL.md and entry-sequence.md, lowering
+  // `fullrun`, `halfrun`, `prrun` and `backlogrun` by a block each.
+  { entry: "fullrun", bytes: 49152 },
+  { entry: "halfrun", bytes: 45056 },
+  { entry: "prrun", bytes: 49152 },
+  // joshuafolkken/kit#5843 removed the duplicated backlogrun procedures, lowering the read by a block;
+  // joshuafolkken/kit#5920 moved the loop's section pointers into the driver hand-off, by another;
+  // joshuafolkken/kit#5946 moved the lane child's step 0 out of the chain section, by another
+  // (and lowered `prrun` and the lane child by one block each).
+  { entry: "backlogrun", bytes: 69632 },
+  // joshuafolkken/kit#5953 charged pre-gate-cut.md at the two sections run:cut prints, not whole;
+  // joshuafolkken/kit#5958 dropped the seam's pointer to the cut, lowering it by a block.
+  { entry: LANE_CHILD, bytes: 24576 }
+];
+function byte_size(root, relative_path) {
+  return statSync(path.join(root, relative_path)).size;
+}
+function entry_cost(root, entry) {
+  if (entry === LANE_CHILD) return lane_child_read_set.costed(root);
+  if (entry === BACKLOGRUN) return backlogrun_parent_read_set.costed(root);
+  return entry_read_set.costed(root, entry);
+}
+function total_read_bytes(cost) {
+  return entry_read_set.total([cost.scoped, ...cost.point_of_use.map((one) => one.cost)]).bytes;
+}
+function resident_base_bytes() {
+  return document_reachability.RESIDENT_BASE.reduce(
+    (sum, one) => sum + byte_size(PACKAGE_DIR, one),
+    NOTHING
+  );
+}
+function entry_total_bytes(root, entry) {
+  return total_read_bytes(entry_cost(root, entry)) + resident_base_bytes();
+}
+function recorded_bytes_for(entry) {
+  return ENTRY_READ_BUDGET.find((one) => one.entry === entry)?.bytes;
+}
+function over_budget_message(entry, current_bytes, recorded_bytes) {
+  const next = block_ceiling(current_bytes).toString();
+  const raise_hint = `raise its recorded size to ${next} in scripts/document/entry-read-budget.ts so the reason shows in the PR diff`;
+  return `entry ${entry} reads ${current_bytes.toString()} bytes, over its ${recorded_bytes.toString()}-byte ceiling. Trim what it reads, or ${raise_hint}. Recheck with \`${RECHECK_COMMAND}\`.`;
+}
+function stale_budget_message(entry, recorded_bytes, current_bytes) {
+  const next = block_ceiling(current_bytes).toString();
+  const lower_hint = `lower its recorded size to ${next} in scripts/document/entry-read-budget.ts so the ratchet holds the reduction`;
+  return `entry ${entry} records ${recorded_bytes.toString()} bytes but reads ${current_bytes.toString()}, more than a block above actual. ${lower_hint}.`;
+}
+var entry_read_budget = {
+  ENTRY_READ_BUDGET,
+  RECHECK_COMMAND,
+  entry_total_bytes,
+  over_budget_message,
+  recorded_bytes_for,
+  stale_budget_message
+};
+
+export {
+  document_reachability,
+  entry_read_budget
+};