@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-XXPDFJRI.js

@@ -0,0 +1,48 @@
+import {
+  issue_number_shape,
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+
+// scripts/lane/lane-child-mark-keys.ts
+var KEY = "JOSH_LANE_CHILD";
+var OVERRUN_KEY = "JOSH_LANE_OVERRUN";
+var MARK_KEYS = [KEY, OVERRUN_KEY];
+var lane_child_mark_keys = { KEY, MARK_KEYS, OVERRUN_KEY };
+
+// scripts/lane/lane-child-marker.ts
+var { KEY: KEY2, OVERRUN_KEY: OVERRUN_KEY2 } = lane_child_mark_keys;
+var CACHE_TTL_KEY = "CLAUDE_CODE_PROMPT_CACHE_TTL";
+var CACHE_TTL = "5m";
+var OVERRUN_VALUE = "1";
+function environment_for(issue) {
+  issue_number_shape.require_issue_number(issue);
+  return { [KEY2]: issue, [CACHE_TTL_KEY]: CACHE_TTL };
+}
+function marked_issue(source = process.env) {
+  const value = source[KEY2];
+  if (value === void 0) return void 0;
+  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(value) ? value : void 0;
+}
+function overrun_environment_for(issue) {
+  return { ...environment_for(issue), [OVERRUN_KEY2]: OVERRUN_VALUE };
+}
+function is_overrun(source = process.env) {
+  return source[OVERRUN_KEY2] === OVERRUN_VALUE && marked_issue(source) !== void 0;
+}
+function is_child_of(directory, source = process.env) {
+  const marked = marked_issue(source);
+  return marked !== void 0 && marked === lane_paths.lane_issue_of(directory, { ...source });
+}
+var lane_child_marker = {
+  KEY: KEY2,
+  OVERRUN_KEY: OVERRUN_KEY2,
+  env_for: environment_for,
+  overrun_env_for: overrun_environment_for,
+  is_child_of,
+  is_overrun,
+  marked_issue
+};
+
+export {
+  lane_child_marker
+};

package/dist/commands/chunk-Y6OGDG5I.js

@@ -0,0 +1,49 @@
+import {
+  split_assess
+} from "./chunk-ZGEUWHFF.js";
+
+// scripts/lane/lane-plan-estimate.ts
+import { readFile } from "node:fs/promises";
+import { z } from "zod";
+var FLAG = "--estimate";
+var FLAG_WIDTH = 2;
+var change_schema = z.object({
+  path: z.string().trim().min(1),
+  changed_lines: z.number().int().nonnegative()
+});
+var schema = z.object({
+  changes: z.array(change_schema),
+  added: z.array(z.string()).default([])
+});
+function split(tokens) {
+  const at = tokens.indexOf(FLAG);
+  if (at === -1) return { tokens: [...tokens] };
+  if (tokens.lastIndexOf(FLAG) !== at) throw new Error("duplicate --estimate");
+  const file = tokens[at + 1];
+  if (file === void 0 || file.startsWith("--")) throw new Error("--estimate needs a JSON file");
+  return { tokens: [...tokens.slice(0, at), ...tokens.slice(at + FLAG_WIDTH)], file };
+}
+async function read(file) {
+  const scope = schema.parse(JSON.parse(await readFile(file, "utf8")));
+  const paths = scope.changes.map((change) => change.path);
+  if (new Set(paths).size !== paths.length) throw new Error("duplicate estimate path");
+  if (scope.added.some((path) => !paths.includes(path))) {
+    throw new Error("added path needs an estimate");
+  }
+  return scope;
+}
+async function attach(plan, file) {
+  if (file === void 0) return plan;
+  const scope = await read(file);
+  const paths = scope.changes.map((change) => change.path);
+  if (plan.paths.some((path) => !paths.includes(path))) {
+    throw new Error("planned path needs an estimate");
+  }
+  const size = split_assess.measure(scope.changes, void 0, new Set(scope.added));
+  return { ...plan, paths, estimated_size: { files: size.files, lines: size.lines } };
+}
+var lane_plan_estimate = { attach, read, split };
+
+export {
+  lane_plan_estimate
+};

package/dist/commands/chunk-YEAE46TS.js

@@ -0,0 +1,98 @@
+import {
+  REPOSITORY_SEGMENT_SOURCE
+} from "./chunk-VDGNXSP3.js";
+import {
+  git_gh_issue_rest
+} from "./chunk-TFYYXETQ.js";
+import {
+  author_fields_schema,
+  blocked_by_schema
+} from "./chunk-34DND4BA.js";
+import {
+  parse_json_object_or_undefined
+} from "./chunk-43DU7DYZ.js";
+
+// scripts/epic/epic-issue.ts
+import { z } from "zod";
+var label_schema = z.object({ name: z.string() });
+var CLOSED = "CLOSED";
+var OPEN = "OPEN";
+var UNKNOWN_STATE = "UNKNOWN";
+var PULL_REQUEST_SEGMENT = "/pull/";
+var epic_issue_schema = z.object({
+  number: z.number(),
+  title: z.string().default(""),
+  body: z.union([z.string(), z.null().transform(() => "")]).default(""),
+  state: z.string().default(UNKNOWN_STATE),
+  // The issue endpoint answers for a pull request as readily as for an issue, and nothing in the
+  // other fields separates them — an open PR reports `state: OPEN`, a merged one `MERGED`. The URL
+  // is what says which it is: `/pull/<n>` against `/issues/<n>`.
+  url: z.string().default(""),
+  labels: z.array(label_schema).default([]),
+  blockedBy: blocked_by_schema,
+  // Who filed the issue, for `backlog:next`'s author-trust check (joshuafolkken/kit#4633).
+  ...author_fields_schema
+});
+function parse_epic_issue(raw) {
+  if (raw === void 0) return void 0;
+  try {
+    return parse_json_object_or_undefined(raw, epic_issue_schema);
+  } catch {
+    return void 0;
+  }
+}
+function blocker_references_of(issue, fallback_repo = "") {
+  return (issue.blockedBy?.nodes ?? []).map(
+    (blocker) => git_gh_issue_rest.reference_of_blocker(blocker, fallback_repo)
+  );
+}
+function label_names(issue) {
+  return issue.labels.map((label) => label.name);
+}
+function normalize_state(state) {
+  return state.toUpperCase() === CLOSED ? CLOSED : "OPEN";
+}
+function is_open(state) {
+  return state.toUpperCase() === OPEN;
+}
+function is_pull_request(issue) {
+  return issue.url.includes(PULL_REQUEST_SEGMENT);
+}
+function parse_epic_number(raw = "") {
+  if (raw.includes("/")) return void 0;
+  const parsed = Number(raw.replace("#", ""));
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+var QUALIFIED_REFERENCE = new RegExp(
+  String.raw`^(${REPOSITORY_SEGMENT_SOURCE}\/${REPOSITORY_SEGMENT_SOURCE})#(\d+)$`,
+  "u"
+);
+var QUALIFIED_REPO_GROUP = 1;
+var QUALIFIED_NUMBER_GROUP = 2;
+function to_qualified_reference(match) {
+  const repo = match[QUALIFIED_REPO_GROUP];
+  if (repo === void 0) return void 0;
+  const number = Number(match[QUALIFIED_NUMBER_GROUP]);
+  return Number.isSafeInteger(number) && number > 0 ? { repo, number } : void 0;
+}
+function parse_epic_reference(raw = "") {
+  const match = QUALIFIED_REFERENCE.exec(raw.trim());
+  if (match !== null) return to_qualified_reference(match);
+  const number = parse_epic_number(raw);
+  return number === void 0 ? void 0 : { number };
+}
+var epic_issue = {
+  CLOSED,
+  blocker_references_of,
+  parse_epic_issue,
+  label_names,
+  normalize_state,
+  is_open,
+  is_pull_request,
+  parse_epic_number,
+  parse_epic_reference
+};
+
+export {
+  epic_issue
+};

package/dist/commands/chunk-YEQFAEVW.js

@@ -0,0 +1,112 @@
+import {
+  animation_helpers,
+  create_git_operation_config
+} from "./chunk-GO3GH7FG.js";
+import {
+  BranchMismatchError
+} from "./chunk-QSBYULSS.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/git/git-branch.ts
+async function current() {
+  const config = {
+    error_message: "Failed to get current branch"
+  };
+  return await animation_helpers.execute_with_animation(
+    "Getting current branch...",
+    git_command.branch,
+    config
+  );
+}
+async function create(branch_name) {
+  const config = create_git_operation_config("Failed to create branch");
+  await animation_helpers.execute_with_animation(
+    `Creating branch: ${branch_name}...`,
+    async () => {
+      await git_command.checkout_b(branch_name);
+      return `Branch created: ${branch_name}`;
+    },
+    config
+  );
+}
+async function switch_to(branch_name) {
+  const config = create_git_operation_config("Failed to switch branch");
+  await animation_helpers.execute_with_animation(
+    `Switching to branch: ${branch_name}...`,
+    async () => {
+      await git_command.checkout(branch_name);
+      return `Switched to branch: ${branch_name}`;
+    },
+    config
+  );
+}
+async function exists(branch_name) {
+  const config = {
+    error_message: "Failed to check branch existence",
+    result_formatter: (is_exists) => is_exists ? "Exists" : "Not found"
+  };
+  return await animation_helpers.execute_with_animation(
+    "Checking if branch exists...",
+    async () => {
+      return await git_command.branch_exists(branch_name);
+    },
+    config
+  );
+}
+async function pull_latest() {
+  const config = create_git_operation_config("Failed to pull latest from remote");
+  await animation_helpers.execute_with_animation(
+    "Pulling latest from remote...",
+    async () => {
+      await git_command.pull_fast_forward();
+      return "Pulled latest from remote";
+    },
+    config
+  );
+}
+var ISSUE_PREFIX_PATTERN = /^(\d+)-/u;
+function has_same_issue_prefix(branch_a, branch_b) {
+  const prefix_a = ISSUE_PREFIX_PATTERN.exec(branch_a)?.[0];
+  const prefix_b = ISSUE_PREFIX_PATTERN.exec(branch_b)?.[0];
+  return prefix_a !== void 0 && prefix_a === prefix_b;
+}
+function issue_from_branch(branch) {
+  const digits = ISSUE_PREFIX_PATTERN.exec(branch)?.[1];
+  return digits === void 0 ? void 0 : Number(digits);
+}
+function is_mismatch(current_branch, target_branch_name, default_branch) {
+  if (current_branch === default_branch || current_branch === target_branch_name) return false;
+  return !has_same_issue_prefix(current_branch, target_branch_name);
+}
+async function handle_default_branch(target_branch_name) {
+  await pull_latest();
+  const is_branch_exists = await exists(target_branch_name);
+  await (is_branch_exists ? switch_to : create)(target_branch_name);
+}
+async function check_and_create_branch(current_branch, target_branch_name) {
+  const default_branch = await git_command.get_default_branch();
+  if (current_branch === default_branch) {
+    await handle_default_branch(target_branch_name);
+    return target_branch_name;
+  }
+  if (is_mismatch(current_branch, target_branch_name, default_branch)) {
+    throw new BranchMismatchError({ current_branch, target_branch_name });
+  }
+  return current_branch;
+}
+var git_branch = {
+  current,
+  check_and_create_branch,
+  is_mismatch,
+  // Exported so a lane's branch name can be checked against the real matcher rather than against a
+  // second copy of the pattern. A copy is what let `lane/<N>` ship: nothing
+  // asserted that the name `lane:open` writes is one this function accepts.
+  has_same_issue_prefix,
+  issue_from_branch
+};
+
+export {
+  git_branch
+};

package/dist/commands/chunk-YJZAD4Z5.js

@@ -0,0 +1,103 @@
+import {
+  markdown_section
+} from "./chunk-JZK33TA5.js";
+
+// scripts/lane/lane-early-push-count.ts
+var MULTI_SLOT_EARLY_PUSH = "multi-slot-early-push";
+var PUSHED = "pushed";
+var MULTI_SLOT_MINIMUM = 2;
+function multi_slot_pushed(entries) {
+  return entries.filter(
+    (entry) => entry.kind === "early-push" && entry.result === PUSHED && (entry.slots ?? 0) >= MULTI_SLOT_MINIMUM
+  ).length;
+}
+var lane_early_push_count = { MULTI_SLOT_EARLY_PUSH, multi_slot_pushed };
+
+// scripts/issue/issue-observation-gate.ts
+var PREFIX = "<!-- josh:observation-wait";
+var DECLARATION = /^<!-- josh:observation-wait:v1 (?<url>https:\/\/github\.com\/(?<repo>[\w.-]+\/[\w.-]+)\/issues\/[1-9]\d*#issuecomment-(?<comment>[1-9]\d*)) (?<keys>[\w-]+(?:,[\w-]+)*) -->$/u;
+var LEDGER = / ledger:(?<metric>[\w-]+)>=(?<minimum>[1-9]\d*)(?= -->$)/u;
+var METRICS = /* @__PURE__ */ new Set([lane_early_push_count.MULTI_SLOT_EARLY_PUSH]);
+var EVIDENCE_HEADING = "## Observation evidence";
+var TASK = /^- \[(?<checked>[ xX])\] (?<key>[\w-]+): (?<description>.+)$/u;
+var EVIDENCE = /\[evidence\]\(https:\/\/github\.com\/[\w./#?=&%-]+\)$/u;
+var records = /* @__PURE__ */ new Map();
+var samples = /* @__PURE__ */ new Map();
+function is_evidenced(task) {
+  return task?.["checked"]?.toLowerCase() === "x" && EVIDENCE.test(task["description"] ?? "");
+}
+function declarations(body = "") {
+  return markdown_section.unfenced_lines(body).filter((line) => line.trimStart().startsWith(PREFIX));
+}
+function ledger_of(line) {
+  const groups = LEDGER.exec(line)?.groups;
+  if (groups === void 0) return void 0;
+  return { metric: String(groups["metric"]), minimum: Number(groups["minimum"]) };
+}
+function is_known(ledger) {
+  return ledger === void 0 || METRICS.has(ledger.metric);
+}
+function source_of(line) {
+  const trimmed = line.trim();
+  const ledger = ledger_of(trimmed);
+  if (!is_known(ledger)) return void 0;
+  const groups = DECLARATION.exec(trimmed.replace(LEDGER, ""))?.groups;
+  if (groups === void 0) return void 0;
+  return {
+    url: String(groups["url"]),
+    repo: String(groups["repo"]),
+    comment: String(groups["comment"]),
+    keys: String(groups["keys"]).split(","),
+    ledger
+  };
+}
+function is_sampled(ledger) {
+  if (ledger === void 0) return false;
+  return (samples.get(ledger.metric) ?? 0) >= ledger.minimum;
+}
+function sources(bodies) {
+  return bodies.flatMap((body) => declarations(body).flatMap((line) => source_of(line) ?? []));
+}
+function pending(source, body) {
+  const lines = markdown_section.section_lines(body, EVIDENCE_HEADING).join("\n");
+  const tasks = markdown_section.unfenced_lines(lines).map((line) => TASK.exec(line)?.groups);
+  return source.keys.filter((key) => {
+    const matches = tasks.filter((task2) => task2?.["key"] === key);
+    const [task] = matches;
+    return matches.length !== 1 || !is_evidenced(task);
+  });
+}
+function wait_for(line) {
+  const source = source_of(line);
+  if (source === void 0) {
+    return {
+      reason: "unknown observation condition; record a v1 evidence comment and required keys"
+    };
+  }
+  if (is_sampled(source.ledger)) return void 0;
+  const body = records.get(source.url);
+  if (body === void 0) {
+    return { reason: `observation evidence unread: ${source.keys.join(", ")}`, url: source.url };
+  }
+  const missing = pending(source, body);
+  return missing.length === 0 ? void 0 : { reason: `observation evidence required: ${missing.join(", ")}`, url: source.url };
+}
+function wait_of(body) {
+  return declarations(body).map((line) => wait_for(line)).find((wait) => wait !== void 0);
+}
+function record(url, body) {
+  records.set(url, body);
+}
+function record_sample(metric, count) {
+  samples.set(metric, count);
+}
+function reset() {
+  records.clear();
+  samples.clear();
+}
+var issue_observation_gate = { sources, wait_of, record, record_sample, reset };
+
+export {
+  lane_early_push_count,
+  issue_observation_gate
+};

package/dist/commands/chunk-YMAEYY5R.js

@@ -0,0 +1,278 @@
+import {
+  run_ship_preflight
+} from "./chunk-BE6F4YK2.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
+};