@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-FA7CN75F.js

@@ -0,0 +1,160 @@
+import {
+  test_related_pins
+} from "./chunk-HE5S4XRE.js";
+import {
+  direct_importers
+} from "./chunk-N4EMFHQ6.js";
+import {
+  related_scope
+} from "./chunk-KJPZPTS4.js";
+import {
+  run_ship_lap
+} from "./chunk-HRN73FQJ.js";
+import {
+  tree_verdict
+} from "./chunk-OZN4HOZT.js";
+import {
+  scoped_green
+} from "./chunk-MHF6BDQI.js";
+import {
+  test_unit_guard
+} from "./chunk-KWLNK2NJ.js";
+import {
+  verification_tail
+} from "./chunk-VCWNMRH7.js";
+import {
+  review_stamps
+} from "./chunk-S5GX3H4P.js";
+import {
+  gate_tree
+} from "./chunk-R36VZIKU.js";
+import {
+  input_fingerprint
+} from "./chunk-GA2YSPFH.js";
+
+// scripts/test/test-related-touched.ts
+import { readdirSync } from "node:fs";
+import path from "node:path";
+var TOUCHED_FLAG = "--touched";
+var TOUCHED_KIND = "touched";
+var TEST_SUFFIX = ".test.ts";
+var TOUCHED_REASON = "the diff test files, their modules' same-named tests, direct test importers and pinned tests";
+var NOTHING_TOUCHED_REASON = "no changed file reaches a touched test";
+function list_directory(directory) {
+  try {
+    return readdirSync(directory);
+  } catch {
+    return [];
+  }
+}
+function is_named_after(module_file, name) {
+  const stem = path.basename(module_file, path.extname(module_file));
+  return name.startsWith(`${stem}.`) && name.endsWith(TEST_SUFFIX);
+}
+function tests_of(root, file, list) {
+  const directory = path.dirname(file);
+  const names = list(path.join(root, directory));
+  if (file.endsWith(TEST_SUFFIX)) return names.includes(path.basename(file)) ? [file] : [];
+  if (!related_scope.is_relatable(file)) return [];
+  return names.filter((name) => is_named_after(file, name)).map((name) => path.join(directory, name));
+}
+function touched_tests(root, changed, list = list_directory) {
+  const tests = changed.flatMap((file) => tests_of(root, file, list));
+  return [.../* @__PURE__ */ new Set([...tests, ...test_related_pins.pinned_tests(changed)])];
+}
+function touched_scope(root, changed, list = list_directory) {
+  const { UNREADABLE_REASON } = related_scope;
+  if (changed === void 0) return { mode: "all", files: [], reason: UNREADABLE_REASON };
+  const files = touched_tests(root, changed, list).map((file) => path.join(root, file));
+  if (files.length === 0) return { mode: "none", files: [], reason: NOTHING_TOUCHED_REASON };
+  return { mode: "related", files, reason: TOUCHED_REASON };
+}
+async function read_scope(root, changed) {
+  if (changed === void 0) return touched_scope(root, changed);
+  const importers = await direct_importers.importers_of(
+    root,
+    changed.filter((file) => related_scope.is_relatable(file))
+  );
+  return touched_scope(root, [...changed, ...[...importers.values()].flat()]);
+}
+var test_related_touched = {
+  NOTHING_TOUCHED_REASON,
+  TOUCHED_FLAG,
+  TOUCHED_KIND,
+  TOUCHED_REASON,
+  read_scope,
+  touched_scope,
+  touched_tests
+};
+
+// scripts/test/test-related-verdict.ts
+function touched_target() {
+  return tree_verdict.record_path("test-related-touched-review");
+}
+async function record_touched(given, before, exit_code) {
+  if (given.length !== 1 || given[0] !== test_related_touched.TOUCHED_FLAG) return;
+  await scoped_green.record_if_green(review_stamps.test_related_stamp, {
+    before,
+    exit_code,
+    target: touched_target()
+  });
+}
+function target_of(given) {
+  const arguments_hash = input_fingerprint.of_entries([JSON.stringify([process.cwd(), given])]);
+  return tree_verdict.record_path(`test-related-${arguments_hash}`);
+}
+async function fresh_verdict(before, target, fresh) {
+  const exit_code = await fresh(before);
+  const tail = `${verification_tail.format_verdict("josh test:related", [])}
+`;
+  if (exit_code === 0) {
+    await tree_verdict.record({ before, exit_code, tail }, gate_tree.read_gate_tree, target);
+  }
+  return { exit_code, is_reused: false };
+}
+function preserved_blobs(before) {
+  if (before === void 0) return void 0;
+  const stamp = review_stamps.test_related_stamp.read();
+  if (stamp === void 0 || !scoped_green.is_unmoved(before, { files: stamp.files, base: stamp.base }) || !review_stamps.test_related_stamp.describes_inputs(stamp)) {
+    return void 0;
+  }
+  return stamp.blobs;
+}
+async function reused_verdict(given, before, target, kept) {
+  if (given.length === 0) {
+    const blobs = preserved_blobs(before);
+    await scoped_green.record_if_green(review_stamps.test_related_stamp, {
+      before,
+      exit_code: 0,
+      ...blobs !== void 0 && { blobs }
+    });
+  }
+  await record_touched(given, before, 0);
+  return { exit_code: tree_verdict.replay(kept, target), is_reused: true };
+}
+async function checked(given, fresh) {
+  const before = await scoped_green.read_before([]);
+  const target = target_of(given);
+  const kept = tree_verdict.read(before, target);
+  if (kept?.exit_code === 0) return await reused_verdict(given, before, target, kept);
+  const result = await fresh_verdict(before, target, fresh);
+  await record_touched(given, before, result.exit_code);
+  return result;
+}
+async function run(given, fresh) {
+  if (!test_unit_guard.is_running(process.cwd())) return await fresh(void 0);
+  const outcome = await run_ship_lap.timed(
+    "test:related",
+    async () => await checked(given, fresh),
+    {
+      note_of: (result) => ({ is_reused: result.is_reused })
+    }
+  );
+  return outcome.exit_code;
+}
+var test_related_verdict = { run, touched_target };
+
+export {
+  test_related_touched,
+  test_related_verdict
+};

package/dist/commands/chunk-FDASVHZD.js

@@ -0,0 +1,241 @@
+import {
+  review_stamps
+} from "./chunk-S5GX3H4P.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PACKAGE_JSON
+} from "./chunk-WB4T3VY2.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/review/review-code-tree.ts
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+// scripts/review/comment-ranges.ts
+var COMMENT_OPENINGS = ["//", "/*"];
+var MARK = "\uE000";
+var LINE_BREAK = "\n";
+var SEPARATOR = " ";
+var RAW_BLOCK = /<(?<tag>script|style)\b[^>]*>(?<body>[\s\S]*?)<\/\k<tag>>/gu;
+var SCRIPT_TAG = "script";
+var MARKUP_COMMENT = /<!--[\s\S]*?-->/gu;
+var VIRTUAL_FILE_NAME = "fix-delta.ts";
+var DIRECTIVE_MARKERS = [
+  "///",
+  "@ts-",
+  "eslint",
+  "jshint",
+  "global ",
+  "globals ",
+  "prettier-ignore",
+  "svelte-ignore",
+  "cspell",
+  "v8 ignore",
+  "c8 ignore",
+  "istanbul ignore",
+  "__PURE__",
+  "__NO_SIDE_EFFECTS__",
+  "@vite-ignore",
+  "webpack",
+  "@jsx",
+  "@vitest-environment"
+];
+var JSDOC_TYPE_TAG = /@(?:type|typedef|param|returns?|template|satisfies|import|callback|overload|enum|this)\b/u;
+var JSDOC_TYPE_EXPRESSION = /@\w+\s*\{/u;
+function is_directive(text, range) {
+  const comment = text.slice(range[0], range[1]);
+  if (JSDOC_TYPE_TAG.test(comment) || JSDOC_TYPE_EXPRESSION.test(comment)) return true;
+  return DIRECTIVE_MARKERS.some((marker) => comment.includes(marker));
+}
+function is_comment(text, range) {
+  return COMMENT_OPENINGS.some((opening) => text.startsWith(opening, range[0]));
+}
+function trivia_at(api, text, position) {
+  const found = [
+    ...api.getLeadingCommentRanges(text, position) ?? [],
+    ...api.getTrailingCommentRanges(text, position) ?? []
+  ];
+  return found.map((range) => [range.pos, range.end]);
+}
+function collect(api, node, source, into) {
+  if (api.isJSDoc(node)) return;
+  into.push(...trivia_at(api, source.text, node.pos));
+  for (const child of node.getChildren(source)) collect(api, child, source, into);
+}
+function script_ranges(api, text) {
+  const source = api.createSourceFile(VIRTUAL_FILE_NAME, text, api.ScriptTarget.Latest, false);
+  const diagnostics = source.parseDiagnostics;
+  if (diagnostics === void 0 || diagnostics.length > 0) return void 0;
+  const ranges = [];
+  collect(api, source, source, ranges);
+  return ranges.filter((range) => is_comment(text, range));
+}
+function shifted(ranges, offset) {
+  return ranges.map((range) => [range[0] + offset, range[1] + offset]);
+}
+function is_inside(blocks, index) {
+  return blocks.some((block) => index >= block[0] && index < block[1]);
+}
+function markup_ranges(text, blocks) {
+  return [...text.matchAll(MARKUP_COMMENT)].filter((match) => !is_inside(blocks, match.index)).map((match) => [match.index, match.index + match[0].length]);
+}
+function block_ranges(api, match) {
+  if (match.groups?.["tag"] !== SCRIPT_TAG) return [];
+  const body = match.groups["body"] ?? "";
+  const ranges = script_ranges(api, body);
+  return ranges && shifted(ranges, match.index + match[0].indexOf(body));
+}
+function svelte_ranges(api, text) {
+  const matches = [...text.matchAll(RAW_BLOCK)];
+  const scripts = matches.map((match) => block_ranges(api, match));
+  if (scripts.includes(void 0)) return void 0;
+  const blocks = matches.map((match) => [match.index, match.index + match[0].length]);
+  return [...scripts.flatMap((ranges) => ranges ?? []), ...markup_ranges(text, blocks)];
+}
+function mark_for(text, start, end) {
+  return text.slice(start, end).includes(LINE_BREAK) ? `${MARK}${LINE_BREAK}${MARK}` : MARK;
+}
+function marked(text, ranges) {
+  const ordered = ranges.toSorted((left, right) => left[0] - right[0]);
+  let result = "";
+  let cursor = 0;
+  for (const [start, end] of ordered) {
+    if (start < cursor) continue;
+    result += `${text.slice(cursor, start)}${mark_for(text, start, end)}`;
+    cursor = end;
+  }
+  return `${result}${text.slice(cursor)}`;
+}
+function normalized_line(line) {
+  if (!line.includes(MARK)) return [line];
+  const indentation = line.slice(0, line.length - line.trimStart().length);
+  const words = line.split(MARK).map((part) => part.trim()).filter((part) => part !== "");
+  return words.length === 0 ? [] : [`${indentation}${words.join(SEPARATOR)}`];
+}
+function without(text, ranges) {
+  return marked(text, ranges).split(LINE_BREAK).flatMap((line) => normalized_line(line)).join(LINE_BREAK);
+}
+function strip(api, text, is_svelte2) {
+  const ranges = is_svelte2 ? svelte_ranges(api, text) : script_ranges(api, text);
+  return ranges && without(
+    text,
+    ranges.filter((range) => !is_directive(text, range))
+  );
+}
+var comment_ranges = { strip };
+
+// scripts/review/import-specifiers.ts
+var VIRTUAL_FILE_NAME2 = "import-delta.ts";
+var SVELTE_EXTENSION = ".svelte";
+var EMPTY_SPECIFIER = "''";
+function specifier_ranges(api, text) {
+  const source = api.createSourceFile(VIRTUAL_FILE_NAME2, text, api.ScriptTarget.Latest, true);
+  return source.statements.filter((statement) => api.isImportDeclaration(statement)).filter((statement) => statement.importClause !== void 0).map((statement) => [statement.moduleSpecifier.getStart(source), statement.moduleSpecifier.end]);
+}
+function blank(api, text, relative) {
+  if (relative.endsWith(SVELTE_EXTENSION)) return text;
+  const ranges = specifier_ranges(api, text);
+  const starts = [0, ...ranges.map(([, end]) => end)];
+  return starts.map((start, index) => text.slice(start, ranges[index]?.[0] ?? text.length)).join(EMPTY_SPECIFIER);
+}
+var import_specifiers = { blank };
+
+// scripts/review/review-code-tree.ts
+var SCRIPT_EXTENSIONS = [".ts", ".js"];
+var SVELTE_EXTENSION2 = ".svelte";
+var EXCLUDED_PREFIX = ".claude/";
+var TYPESCRIPT_MODULE = "typescript";
+function is_svelte(relative) {
+  return relative.endsWith(SVELTE_EXTENSION2);
+}
+function is_source(relative) {
+  if (relative.startsWith(EXCLUDED_PREFIX)) return false;
+  return is_svelte(relative) || SCRIPT_EXTENSIONS.some((extension) => relative.endsWith(extension));
+}
+function load_typescript(root) {
+  try {
+    return createRequire(path.join(root, PACKAGE_JSON))(TYPESCRIPT_MODULE);
+  } catch {
+    return void 0;
+  }
+}
+function text_digest(api, text, relative) {
+  const code = comment_ranges.strip(api, text, is_svelte(relative));
+  return code === void 0 ? void 0 : stamp_file.digest(code);
+}
+function inert_digest(api) {
+  return (text, relative) => text_digest(api, import_specifiers.blank(api, text, relative), relative);
+}
+function code_digest(digest, root, relative) {
+  try {
+    return digest(readFileSync(path.join(root, relative), "utf8"), relative);
+  } catch {
+    return void 0;
+  }
+}
+async function base_digest(digest, base, relative) {
+  try {
+    const text = await git_command.show_file(`${base}:${relative}`);
+    return digest(`${text}
+`, relative);
+  } catch {
+    return void 0;
+  }
+}
+function digests_of(root, paths, digest) {
+  const entries = paths.filter((relative) => is_source(relative)).flatMap((relative) => {
+    const value = code_digest(digest, root, relative);
+    return value === void 0 ? [] : [[relative, value]];
+  });
+  return Object.fromEntries(entries);
+}
+function tree_of(root, paths, api = load_typescript(root)) {
+  if (api === void 0) return {};
+  return digests_of(root, paths, (text, relative) => text_digest(api, text, relative));
+}
+async function read(paths, root) {
+  return tree_of(root ?? await git_command.repository_root(), paths);
+}
+async function record(paths, base, target, root) {
+  try {
+    review_stamps.round_one_code_stamp.write(await read(paths, root), target, base);
+  } catch {
+    review_stamps.clear_round_one_code(target);
+  }
+}
+function comment_only(snapshot, tree, base, unmoved = []) {
+  if (snapshot === void 0 || base === void 0) return [];
+  const is_same_base = snapshot.base === base;
+  return Object.keys(snapshot.files).filter(
+    (relative) => snapshot.files[relative] === tree[relative] && (is_same_base || unmoved.includes(relative))
+  );
+}
+async function inert_since(base, paths, root, api) {
+  const checkout = root ?? await git_command.repository_root();
+  const typescript = api ?? load_typescript(checkout);
+  if (typescript === void 0) return [];
+  const digest = inert_digest(typescript);
+  const tree = digests_of(checkout, paths, digest);
+  const sources = Object.keys(tree);
+  const digests = await Promise.all(
+    sources.map(async (relative) => await base_digest(digest, base, relative))
+  );
+  return sources.filter((relative, index) => digests[index] === tree[relative]);
+}
+var review_code_tree = {
+  comment_only,
+  inert_since,
+  load_typescript,
+  read,
+  record,
+  tree_of
+};
+
+export {
+  review_code_tree
+};

package/dist/commands/chunk-FEYZ575X.js

@@ -0,0 +1,278 @@
+import {
+  run_ship_preflight
+} from "./chunk-OHN3QARP.js";
+import {
+  run_investigation_record
+} from "./chunk-JT5ICRFF.js";
+import {
+  issue_read_cli
+} from "./chunk-3EW5LTN3.js";
+import {
+  issue_state_cli
+} from "./chunk-E4PFCTXN.js";
+import {
+  acceptance_map
+} from "./chunk-5PCK53WP.js";
+import {
+  run_prep_locate
+} from "./chunk-XRQMVAB4.js";
+import {
+  issue_read
+} from "./chunk-3F3RNIG2.js";
+import {
+  markdown_section
+} from "./chunk-JZK33TA5.js";
+import {
+  latest_scope_cli
+} from "./chunk-BVUL57IX.js";
+import {
+  git_stash
+} from "./chunk-WROJTXWZ.js";
+import {
+  issue_body_keys
+} from "./chunk-KXK2A2HB.js";
+import {
+  delegation_policy
+} from "./chunk-6I2JM5UX.js";
+import {
+  issue_state
+} from "./chunk-WXXLJQBO.js";
+import {
+  git_gh_issue_read
+} from "./chunk-TFYYXETQ.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+
+// scripts/run/run-prep.ts
+var SUMMARY_PREFIX = "prep #";
+var STATE_LABEL = "state: ";
+var HUMAN_REVIEW_LABEL = "human_review: ";
+var LATEST_LABEL = "latest: ";
+var FIELD_SEPARATOR = " \xB7 ";
+var SUMMARY_DASH = " \u2014 ";
+var UNKNOWN = "?";
+var YES = "yes";
+var NO = "no";
+var CONTENT_HEADER = "=== issue ===";
+var STATE_HEADER = "=== state ===";
+var LATEST_HEADER = "=== dependency update ===";
+var LOCATIONS_HEADER = "=== code locations ===";
+var INVESTIGATION_HEADER = "=== investigation ===";
+var INVESTIGATION_BODY = `Delegate before the first read \u2014 the guard refuses at ${delegation_policy.INVESTIGATION_LIMIT}. ${delegation_policy.INVESTIGATION_STEP} Brief it with the code locations above; read in the main line only the files this run will edit.`;
+var INVESTIGATION_PLANNED_BODY = "Skip the investigator \u2014 the plan is recorded (`run:planned` or a plan comment): the recorded plan in the issue (body or plan comment) is the investigation; read in the main line only the files this run will edit.";
+var INVESTIGATION_SAVED_LEAD = "Skip the investigator \u2014 its conclusion is saved below; read in the main line only the files this run will edit, where main moved since re-read only the cited files its diff touches, and delegate only what it does not answer:";
+var INVESTIGATION_SAVE_STEP = "Save the investigator's conclusion (its `file:line` citations) with the Write tool to";
+var SHIP_HEADER = "=== ship preconditions ===";
+var SHIP_MET = "met \u2014 nothing `josh ship` refuses on as the tree stands";
+var SHIP_UNMET = "unmet \u2014 `josh ship` will refuse until these are fixed; fix them before the gate:";
+var SECTION_SEPARATOR = "\n\n";
+var LATEST_JOINER = " \u2014 ";
+function human_review_value(state) {
+  if (state === void 0) return UNKNOWN;
+  return state.is_human_review ? YES : NO;
+}
+function summary(parts) {
+  const state_value = parts.state === void 0 ? UNKNOWN : parts.state.state;
+  const fields = [
+    `${STATE_LABEL}${state_value}`,
+    `${HUMAN_REVIEW_LABEL}${human_review_value(parts.state)}`,
+    `${LATEST_LABEL}${parts.latest_scope}`
+  ];
+  return `${SUMMARY_PREFIX}${parts.issue_number}${SUMMARY_DASH}${fields.join(FIELD_SEPARATOR)}`;
+}
+function state_body(parts) {
+  return parts.state === void 0 ? parts.state_failure : issue_state.format_issue_state(parts.state);
+}
+function section(header, body) {
+  return `${header}
+${body}`;
+}
+function ship_body(problems) {
+  if (problems.length === 0) return SHIP_MET;
+  return [SHIP_UNMET, ...problems.map((problem) => `  - ${problem}`)].join("\n");
+}
+function save_step(record) {
+  return record === void 0 ? "" : ` ${INVESTIGATION_SAVE_STEP} \`${record.path}\`.`;
+}
+function investigation_body(parts) {
+  const findings = parts.investigation?.findings;
+  if (findings !== void 0) return `${INVESTIGATION_SAVED_LEAD}
+${findings}`;
+  if (parts.is_planned === true) return INVESTIGATION_PLANNED_BODY;
+  return `${INVESTIGATION_BODY}${save_step(parts.investigation)}`;
+}
+function format_report(parts) {
+  return [
+    summary(parts),
+    section(CONTENT_HEADER, parts.content_body),
+    section(STATE_HEADER, state_body(parts)),
+    section(LATEST_HEADER, `${parts.latest_scope}${LATEST_JOINER}${parts.latest_reason}`),
+    section(LOCATIONS_HEADER, parts.locations),
+    section(INVESTIGATION_HEADER, investigation_body(parts)),
+    section(SHIP_HEADER, ship_body(parts.ship_problems))
+  ].join(SECTION_SEPARATOR);
+}
+var run_prep = {
+  CONTENT_HEADER,
+  INVESTIGATION_HEADER,
+  INVESTIGATION_PLANNED_BODY,
+  INVESTIGATION_SAVED_LEAD,
+  INVESTIGATION_SAVE_STEP,
+  LATEST_HEADER,
+  LOCATIONS_HEADER,
+  SHIP_HEADER,
+  SHIP_UNMET,
+  STATE_HEADER,
+  SUMMARY_PREFIX,
+  format_report,
+  ship_body,
+  summary
+};
+
+// scripts/run/run-prep-summary.ts
+var NOW_HEADING = issue_body_keys.heading("symptom");
+var CHANGE_HEADING = issue_body_keys.heading("expected");
+var TEST_LINE = "  - test:";
+function is_blank(line) {
+  return line.trim() === "";
+}
+function section_text(body, heading) {
+  const lines = markdown_section.section_lines(body, heading);
+  const start = lines.findIndex((line) => !is_blank(line));
+  if (start === -1) return [];
+  return lines.slice(start, lines.findLastIndex((line) => !is_blank(line)) + 1);
+}
+function check_lines(body) {
+  return acceptance_map.criteria_of(body).flatMap((criterion) => [`- ${criterion.text}`, TEST_LINE]);
+}
+function trust_lines(is_body_trusted) {
+  return is_body_trusted === true ? [] : [issue_read.UNTRUSTED_BODY_HEADING, ""];
+}
+function format_summary(body, is_body_trusted) {
+  return [
+    ...trust_lines(is_body_trusted),
+    "## Now",
+    ...section_text(body, NOW_HEADING),
+    "",
+    "## Change",
+    ...section_text(body, CHANGE_HEADING),
+    "",
+    "## Check",
+    ...check_lines(body)
+  ].join("\n");
+}
+var run_prep_summary = { format_summary };
+
+// scripts/run/run-prep-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var USAGE = "Usage: josh run:prep <issue-number> [--summary]";
+var SUMMARY_FLAG = "--summary";
+var LANE_SKIP_SCOPE = "not asked";
+var LANE_SKIP_REASON = "a dispatched lane child does not run josh latest \u2014 the parent does, once per session";
+function parse_number(argv) {
+  const [first] = argv;
+  if (first === void 0 || argv.length !== 1 || !issue_number_shape.ISSUE_NUMBER_PATTERN.test(first)) {
+    return void 0;
+  }
+  return first;
+}
+function failure_note(issue_number, kind) {
+  return `(issue ${session_cite.issue(issue_number)} not bundled: ${kind})`;
+}
+function latest_decision() {
+  if (lane_child_marker.is_child_of(process.cwd())) {
+    return { scope: LANE_SKIP_SCOPE, reason: LANE_SKIP_REASON };
+  }
+  return latest_scope_cli.scope_decision();
+}
+async function lane_has_changes() {
+  if (!lane_child_marker.is_child_of(process.cwd())) return false;
+  try {
+    return await git_stash.has_stashable_changes(process.cwd());
+  } catch (error) {
+    error_text.trace_swallowed("run_prep_cli.lane_has_changes", error);
+    return false;
+  }
+}
+async function gather(issue_number) {
+  const [content, state, has_changes, ship_problems, investigation] = await Promise.all([
+    issue_read_cli.read_block(issue_number),
+    issue_state_cli.read_issue(issue_number),
+    lane_has_changes(),
+    run_ship_preflight.ahead(issue_number),
+    run_investigation_record.load(issue_number)
+  ]);
+  const locations = await run_prep_locate.locate(content.kind === "ok" ? content.block : "");
+  const latest = latest_decision();
+  return { content, state, latest, has_changes, locations, ship_problems, investigation };
+}
+function content_body(issue_number, content) {
+  return content.kind === "ok" ? content.block : failure_note(issue_number, content.kind);
+}
+function to_parts(issue_number, reads) {
+  const state = reads.state.kind === "state" ? reads.state.state : void 0;
+  const state_failure = state === void 0 ? failure_note(issue_number, reads.state.kind) : "";
+  return {
+    issue_number,
+    content_body: content_body(issue_number, reads.content),
+    state,
+    state_failure,
+    latest_scope: reads.latest.scope,
+    latest_reason: reads.latest.reason,
+    has_changes: reads.has_changes,
+    locations: reads.locations,
+    ship_problems: reads.ship_problems,
+    investigation: reads.investigation
+  };
+}
+function exit_code(reads) {
+  const is_complete = reads.content.kind === "ok" && reads.state.kind === "state";
+  return is_complete ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE;
+}
+async function read_summary(issue_number) {
+  const [body, block] = await Promise.all([
+    git_gh_issue_read.issue_get_body(issue_number),
+    issue_read_cli.read_block(issue_number)
+  ]);
+  if (body === void 0) return void 0;
+  const is_trusted = block.kind === "ok" ? block.trust.is_body_trusted : void 0;
+  return { body, text: session_cite.text(run_prep_summary.format_summary(body, is_trusted)) };
+}
+async function print_summary(issue_number) {
+  const summary2 = await read_summary(issue_number);
+  if (summary2 === void 0) {
+    console.error(failure_note(issue_number, "unreadable"));
+    return FAILURE_EXIT_CODE;
+  }
+  console.info(summary2.text);
+  return SUCCESS_EXIT_CODE;
+}
+async function run(argv) {
+  const issue_number = parse_number(argv.filter((argument) => argument !== SUMMARY_FLAG));
+  if (issue_number === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  if (argv.includes(SUMMARY_FLAG)) return await print_summary(issue_number);
+  const reads = await gather(issue_number);
+  const report = run_prep.format_report(to_parts(issue_number, reads));
+  console.info(session_cite.text(report));
+  return exit_code(reads);
+}
+var run_prep_cli = { failure_note, gather, parse_number, read_summary, run, to_parts };
+
+export {
+  run_prep,
+  run_prep_cli
+};