@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-LAUKNN57.js

@@ -0,0 +1,530 @@
+import {
+  lane_yield
+} from "./chunk-SIPHEZXP.js";
+import {
+  lane_stage_stats
+} from "./chunk-3TN76RWK.js";
+import {
+  run_ship_planned
+} from "./chunk-QGTLTPXT.js";
+import {
+  type_check_step
+} from "./chunk-RMDLFLPE.js";
+import {
+  check_reuse
+} from "./chunk-RKCENL5P.js";
+import {
+  structural_checks
+} from "./chunk-ULL3OIAG.js";
+import {
+  metrics_totals
+} from "./chunk-JM3EJYA3.js";
+import {
+  gate_tree
+} from "./chunk-3OSUM6DM.js";
+import {
+  lane_sleep,
+  lane_stats
+} from "./chunk-WYAY6CQI.js";
+import {
+  lane_ledger
+} from "./chunk-I2RBOH4F.js";
+import {
+  lane_spans
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  gate_labels
+} from "./chunk-WQ6FS544.js";
+import {
+  lane_ledger_write
+} from "./chunk-V56NLG7I.js";
+import {
+  buffered_process
+} from "./chunk-JZHY7D6D.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/run/ship/run-ship-pre-detach.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var SECTION_SEPARATOR = "\n\n";
+var PASSED = "pre-detach checks passed";
+var UNPINNED = "unpinned";
+var { METRICS_RERECORD_COMMAND } = metrics_totals;
+var STATIC_CHECKS = [
+  { list: ["josh", "exports:unused"], label: gate_labels.EXPORTS_LABEL },
+  { list: ["josh", "cspell:dot"] }
+];
+var GUARD_TEST_TARGETS = [
+  "scripts/document",
+  "scripts/claude",
+  "scripts/rules",
+  "scripts/josh/josh-command-map.test.ts",
+  ...structural_checks.STRUCTURAL_GUARD_TARGETS,
+  "tools/test/pure-files.test.ts"
+];
+var { GUARD_TEST_COMMAND, failure_prefix, failure_section } = structural_checks;
+function present_targets(directory) {
+  return GUARD_TEST_TARGETS.filter((target) => existsSync(path.join(directory, target)));
+}
+function guard_tests(directory) {
+  const targets = present_targets(directory);
+  return targets.length === 0 ? [] : [{ list: [...GUARD_TEST_COMMAND, ...targets] }];
+}
+async function metrics_runs(directory) {
+  const started = performance.now();
+  const result = await metrics_totals.totals_check(directory);
+  if (result === void 0) return [];
+  return [
+    { check: { list: METRICS_RERECORD_COMMAND }, result, elapsed_ms: performance.now() - started }
+  ];
+}
+async function command_lists(directory) {
+  const type_check = await type_check_step.resolve_type_check_args(directory);
+  return [
+    { list: type_check, label: gate_labels.TYPE_CHECK_LABEL },
+    ...STATIC_CHECKS,
+    ...guard_tests(directory)
+  ];
+}
+async function run_in(directory, check) {
+  const started = performance.now();
+  const result = await buffered_process.run_buffered_process(check.list, { cwd: directory });
+  return { check, result, elapsed_ms: performance.now() - started };
+}
+function is_gate_run(run) {
+  return run.check.label !== void 0;
+}
+function gate_results(runs) {
+  return runs.filter((run) => is_gate_run(run)).map(({ check, result, elapsed_ms }) => {
+    return { ...result, label: check.label, command: check.list.join(" "), elapsed_ms };
+  });
+}
+function verdict(runs) {
+  const failed = runs.filter(({ result }) => buffered_process.is_process_failed(result));
+  if (failed.length === 0) return { code: SUCCESS_EXIT_CODE, out: PASSED };
+  return {
+    code: FAILURE_EXIT_CODE,
+    out: failed.map(({ check, result }) => failure_section(check.list, result)).join(SECTION_SEPARATOR)
+  };
+}
+async function not_asked() {
+  return { code: SUCCESS_EXIT_CODE, out: PASSED };
+}
+function joined(result, pinned) {
+  if (pinned.code === SUCCESS_EXIT_CODE) return result;
+  if (result.code === SUCCESS_EXIT_CODE) return pinned;
+  return { code: FAILURE_EXIT_CODE, out: [result.out, pinned.out].join(SECTION_SEPARATOR) };
+}
+function red_kinds(result, pinned) {
+  return [
+    ...result.code === SUCCESS_EXIT_CODE ? [] : [lane_ledger_write.PRE_DETACH_STAGE],
+    ...pinned.code === SUCCESS_EXIT_CODE ? [] : [UNPINNED]
+  ];
+}
+function with_pinned(result, pinned) {
+  const preconditions = red_kinds(result, pinned);
+  const { code, out } = joined(result, pinned);
+  const { unpinned } = pinned;
+  if (preconditions.length === 0) return { code, out };
+  return { code, out, preconditions, ...unpinned !== void 0 && { unpinned } };
+}
+async function checks(directory = process.cwd(), records = check_reuse.DEFAULT_RECORDS, pinned = not_asked) {
+  const metrics = await metrics_runs(directory);
+  const [lists, tree] = await Promise.all([command_lists(directory), gate_tree.read_gate_tree()]);
+  const [runs, pinned_result] = await Promise.all([
+    Promise.all(lists.map(async (check) => await run_in(directory, check))),
+    pinned()
+  ]);
+  await check_reuse.record_green_checks(gate_results(runs), tree, records);
+  return with_pinned(verdict([...runs, ...metrics]), pinned_result);
+}
+var run_ship_pre_detach = {
+  GUARD_TEST_TARGETS,
+  METRICS_RERECORD_COMMAND,
+  PASSED,
+  STATIC_CHECKS,
+  UNPINNED,
+  checks,
+  failure_prefix,
+  with_pinned
+};
+
+// scripts/lane/lane-stop-stats.ts
+var COLUMNS = [
+  "stop",
+  "wait median (min)",
+  "wait max (min)",
+  "wait total (min)",
+  "runs",
+  "not resumed",
+  "causes"
+];
+var { STAGE } = run_ship_stage;
+var { is_dispatch, is_number, is_stage } = lane_stage_stats;
+var REASONS = [
+  STAGE.PREFLIGHT,
+  STAGE.REVIEW,
+  STAGE.SYNC,
+  run_ship_stage.CONFLICT,
+  STAGE.GATE,
+  STAGE.COMMIT,
+  STAGE.ROUND_TWO,
+  STAGE.FOLLOWUP,
+  STAGE.REPORT
+];
+var EVENT_ISSUE = /#([1-9]\d*)\b/u;
+var UNRECORDED_CAUSE = "unrecorded";
+var NO_CAUSES = "-";
+var NOTICED = " (noticed)";
+function is_stop(entry) {
+  return entry.kind === lane_ledger.KIND.STOP;
+}
+function issue_of(event) {
+  return Number(EVENT_ISSUE.exec(event.text)?.[1]);
+}
+function events_of(events, kind) {
+  return events.filter((event) => event.kind === kind).map((event) => ({ issue: issue_of(event), at_ms: Date.parse(event.at) }));
+}
+function parks_of(events) {
+  return events_of(events, run_event_stream.EVENT_KIND.PARK);
+}
+function dispatches_of(entries) {
+  return entries.filter((entry) => is_dispatch(entry)).map((entry) => ({ issue: entry.issue, at_ms: Date.parse(entry.at) }));
+}
+function ends_of(entries, parks) {
+  const resumes = entries.filter((entry) => is_stage(entry)).map((stage) => ({ issue: stage.issue, at_ms: lane_stage_stats.started_ms(stage) }));
+  return [...resumes, ...dispatches_of(entries), ...parks];
+}
+function wait_ms(stop, ends) {
+  const later = ends.filter((end) => end.issue === stop.issue && end.at_ms >= stop.at_ms).map((end) => end.at_ms - stop.at_ms);
+  return later.length === 0 ? void 0 : Math.min(...later);
+}
+function instant_of(stop) {
+  return { issue: stop.issue, at_ms: Date.parse(stop.at) };
+}
+function notices_of(entries) {
+  return entries.filter((entry) => entry.kind === lane_ledger.KIND.UNPLANNED_NOTICE).map((entry) => ({ issue: entry.issue, at_ms: Date.parse(entry.at) }));
+}
+function noticed(cause, stop, notices) {
+  if (cause !== run_ship_planned.PRECONDITION) return cause;
+  const is_noticed = notices.some(
+    (notice) => notice.issue === stop.issue && notice.at_ms <= stop.at_ms
+  );
+  return is_noticed ? `${cause}${NOTICED}` : cause;
+}
+function with_path(kind, stop) {
+  if (kind !== run_ship_pre_detach.UNPINNED || stop.unpinned === void 0) return kind;
+  return `${kind}:${stop.unpinned.path}`;
+}
+function causes_of(stop, notices) {
+  const { preconditions = [], findings = [] } = stop;
+  const kinds = [...preconditions.map((kind) => with_path(kind, stop)), ...findings];
+  if (kinds.length === 0) return [stop.cause ?? UNRECORDED_CAUSE];
+  return kinds.map((kind) => noticed(kind, instant_of(stop), notices));
+}
+function waits_of(entries, ends, notices) {
+  return entries.filter(is_stop).map((stop) => ({
+    stop,
+    reason: stop.reason,
+    causes: causes_of(stop, notices),
+    wait_ms: wait_ms(instant_of(stop), ends)
+  }));
+}
+function total(values) {
+  return values.length === 0 ? void 0 : values.reduce((sum, value) => sum + value, 0);
+}
+function causes_cell(waits2) {
+  const all = waits2.flatMap((wait) => wait.causes);
+  const counted = [...new Set(all)].map((cause) => ({
+    cause,
+    count: all.filter((each) => each === cause).length
+  }));
+  const ranked = counted.toSorted((left, right) => right.count - left.count);
+  return ranked.length === 0 ? NO_CAUSES : ranked.map(({ cause, count }) => `${cause} ${String(count)}`).join(", ");
+}
+function reason_row(reason, waits2) {
+  const of_reason = waits2.filter((wait) => wait.reason === reason);
+  const ended = of_reason.map((wait) => wait.wait_ms).filter((value) => is_number(value));
+  return lane_stats.to_row([
+    reason,
+    lane_stage_stats.cell(lane_stats.median(ended)),
+    lane_stage_stats.cell(lane_stats.peak(ended)),
+    lane_stage_stats.cell(total(ended)),
+    String(ended.length),
+    String(of_reason.length - ended.length),
+    causes_cell(of_reason)
+  ]);
+}
+function waits_in(entries, window, events = []) {
+  const ends = ends_of(entries, parks_of(events));
+  return waits_of(lane_stats.in_window(entries, window), ends, notices_of(entries));
+}
+function table(entries, window, events = []) {
+  const waits2 = waits_in(entries, window, events);
+  return [
+    lane_stats.to_row(COLUMNS),
+    lane_stats.to_row(COLUMNS.map(() => "---")),
+    ...REASONS.map((reason) => reason_row(reason, waits2))
+  ].join("\n");
+}
+var lane_stop_stats = {
+  REASONS,
+  dispatches_of,
+  ends_of,
+  events_of,
+  issue_of,
+  table,
+  total,
+  wait_ms,
+  waits_in
+};
+
+// scripts/lane/lane-stage-events.ts
+var { EVENT_KIND } = run_event_stream;
+var { PHASE, STAGE: STAGE2 } = run_ship_stage;
+var SHIP_STAGES = /* @__PURE__ */ new Set([
+  ...Object.values(STAGE2),
+  lane_ledger.PRE_DETACH_STAGE
+]);
+function is_ship(entry, issue) {
+  return entry.kind === lane_ledger.KIND.STAGE && entry.issue === issue && SHIP_STAGES.has(entry.stage);
+}
+function event_at(at_ms, issue, words) {
+  return {
+    pos: 0,
+    at: new Date(at_ms).toISOString(),
+    kind: EVENT_KIND.SHIP_STAGE,
+    text: `${issue_cite.plain_for("program", issue)} ${words}`
+  };
+}
+function interval_events(entry, issue) {
+  const end_ms = Date.parse(entry.at);
+  if (!Number.isFinite(end_ms) || entry.elapsed_ms <= 0) return [];
+  return [
+    event_at(end_ms - entry.elapsed_ms, issue, `${entry.stage} ${PHASE.START}`),
+    event_at(end_ms, issue, `${entry.stage} ${PHASE.DONE}`)
+  ];
+}
+function is_lane_ship(event, issue) {
+  return event.kind === EVENT_KIND.SHIP_STAGE && lane_stop_stats.issue_of(event) === issue;
+}
+function change(active, event) {
+  if (event.kind === EVENT_KIND.STOP) {
+    active.clear();
+    return;
+  }
+  const { stage, phase } = run_ship_stage.words_of(event.text);
+  if (phase === PHASE.SKIPPED) return;
+  if (phase === PHASE.START) active.set(stage, event);
+  else active.delete(stage);
+}
+function exclusive(events, issue) {
+  const active = /* @__PURE__ */ new Map();
+  return events.map((event) => {
+    change(active, event);
+    const latest = [...active.values()].at(-1);
+    if (latest === void 0) return event;
+    const { stage } = run_ship_stage.words_of(latest.text);
+    return event_at(Date.parse(event.at), issue, `${stage} ${PHASE.START}`);
+  });
+}
+function stop_events(entries, issue) {
+  return entries.flatMap(
+    (entry) => entry.kind === lane_ledger.KIND.STOP && entry.issue === issue ? { ...event_at(Date.parse(entry.at), issue, entry.reason), kind: EVENT_KIND.STOP } : []
+  );
+}
+function of(entries, events, issue) {
+  const restored = entries.filter((entry) => is_ship(entry, issue)).flatMap((entry) => interval_events(entry, issue));
+  const ship = [
+    ...events.filter((event) => is_lane_ship(event, issue)),
+    ...restored,
+    ...stop_events(entries, issue)
+  ].toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at));
+  return [
+    ...events.filter((event) => !is_lane_ship(event, issue)),
+    ...exclusive(ship, issue)
+  ].toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at));
+}
+var lane_stage_events = { of };
+
+// scripts/lane/lane-net-time.ts
+var { EVENT_KIND: EVENT_KIND2 } = run_event_stream;
+var { PHASE: PHASE2, STAGE: STAGE3 } = run_ship_stage;
+function entries_of(entries, issue) {
+  return entries.filter((entry) => "issue" in entry && entry.issue === issue);
+}
+function span_of(entries, issue) {
+  const of_issue = entries_of(entries, issue).toSorted(
+    (left, right) => Date.parse(left.at) - Date.parse(right.at)
+  );
+  const from = of_issue.find((entry) => lane_stage_stats.is_dispatch(entry));
+  const to = of_issue.findLast((entry) => lane_stage_stats.is_merge(entry));
+  if (from === void 0 || to === void 0) return void 0;
+  const span = { from_ms: Date.parse(from.at), to_ms: Date.parse(to.at) };
+  return span.to_ms < span.from_ms ? void 0 : span;
+}
+function holds_of(events) {
+  return [
+    ...lane_stop_stats.events_of(events, EVENT_KIND2.PARK),
+    ...lane_stop_stats.events_of(events, EVENT_KIND2.OUTAGE),
+    ...lane_stop_stats.events_of(events, EVENT_KIND2.USAGE_LIMIT)
+  ];
+}
+function held_ms(hold, ends, to_ms) {
+  const left_ms = to_ms - hold.at_ms;
+  return Math.min(lane_stop_stats.wait_ms(hold, ends) ?? left_ms, left_ms);
+}
+function hold_waits(entries, events, issue, span) {
+  const holds = holds_of(events);
+  const inside = holds.filter(
+    (hold) => hold.issue === issue && hold.at_ms >= span.from_ms && hold.at_ms < span.to_ms
+  );
+  return inside.map((hold) => {
+    const ends = lane_stop_stats.ends_of(
+      entries,
+      holds.filter((other) => other.at_ms > hold.at_ms)
+    );
+    return { from_ms: hold.at_ms, to_ms: hold.at_ms + held_ms(hold, ends, span.to_ms) };
+  });
+}
+function joined2(spans) {
+  const sorted = spans.toSorted((left, right) => left.from_ms - right.from_ms);
+  const kept = [];
+  for (const next of sorted) {
+    const last = kept.at(-1);
+    if (last === void 0 || next.from_ms > last.to_ms) kept.push({ ...next });
+    else last.to_ms = Math.max(last.to_ms, next.to_ms);
+  }
+  return kept;
+}
+function slept(events, span) {
+  const cut = lane_sleep.spans(events).map((sleep) => ({
+    from_ms: Math.max(sleep.from_ms, span.from_ms),
+    to_ms: Math.min(sleep.to_ms, span.to_ms)
+  }));
+  return joined2(cut.filter((sleep) => sleep.to_ms > sleep.from_ms));
+}
+function yield_spans(entries, events) {
+  const yields = lane_stop_stats.events_of(
+    events.filter((event) => lane_yield.is_yield_note(event)),
+    EVENT_KIND2.NOTE
+  );
+  return lane_spans.issue_spans({
+    starts: yields,
+    bounds: yields,
+    ends: lane_stop_stats.dispatches_of(entries)
+  });
+}
+function run_start_ms(dispatches, split) {
+  const start = dispatches.findLast(
+    (entry) => entry.issue === split.issue && entry.at_ms <= split.at_ms
+  );
+  return start?.at_ms ?? split.at_ms;
+}
+function split_spans(entries, events) {
+  const splits = lane_stop_stats.events_of(events, EVENT_KIND2.SPLIT);
+  const dispatches = lane_stop_stats.dispatches_of(entries);
+  const spans = lane_spans.issue_spans({ starts: splits, bounds: splits, ends: dispatches });
+  return splits.map((split, index) => ({
+    from_ms: run_start_ms(dispatches, split),
+    end_ms: spans[index]?.end_ms
+  })).filter((wait) => wait.end_ms !== void 0);
+}
+function cut_inside(spans, span) {
+  const inside = spans.filter((wait) => wait.from_ms >= span.from_ms && wait.from_ms < span.to_ms);
+  return inside.map((wait) => ({
+    from_ms: wait.from_ms,
+    to_ms: Math.min(wait.end_ms ?? span.to_ms, span.to_ms)
+  }));
+}
+function events_of_issue(events, issue) {
+  return events.filter((event) => lane_stop_stats.issue_of(event) === issue);
+}
+function yielded(entries, events, issue, span) {
+  return cut_inside(yield_spans(entries, events_of_issue(events, issue)), span);
+}
+function split_waits(entries, events, issue, span) {
+  return cut_inside(split_spans(entries, events_of_issue(events, issue)), span);
+}
+function waiting(entries, events, issue, span) {
+  return joined2([
+    ...hold_waits(entries, events, issue, span),
+    ...yielded(entries, events, issue, span),
+    ...slept(events, span)
+  ]);
+}
+function waits(entries, events, issue, span) {
+  return joined2([
+    ...waiting(entries, events, issue, span),
+    ...split_waits(entries, events, issue, span)
+  ]);
+}
+function is_followup_start(event) {
+  const { stage, phase } = run_ship_stage.words_of(event.text);
+  return stage === STAGE3.FOLLOWUP && phase === PHASE2.START;
+}
+function followed(events, issue, span) {
+  const lines = events.filter((event) => event.kind === EVENT_KIND2.SHIP_STAGE).filter((event) => lane_stop_stats.issue_of(event) === issue).map((event) => ({ event, at_ms: Date.parse(event.at) })).filter((line) => line.at_ms >= span.from_ms && line.at_ms < span.to_ms).toSorted((left, right) => left.at_ms - right.at_ms);
+  return lines.map((line, index) => ({ line, to_ms: lines[index + 1]?.at_ms ?? span.to_ms })).filter(({ line }) => is_followup_start(line.event)).map(({ line, to_ms }) => ({ from_ms: line.at_ms, to_ms }));
+}
+function automatic_waits(entries, events, issue, span) {
+  const stages = lane_stage_events.of(entries, events, issue);
+  return joined2([...waiting(entries, events, issue, span), ...followed(stages, issue, span)]);
+}
+function outside(entries, events, issue, span) {
+  return joined2([
+    ...automatic_waits(entries, events, issue, span),
+    ...split_waits(entries, events, issue, span)
+  ]);
+}
+function net_ms(entries, events, issue) {
+  const span = span_of(entries, issue);
+  if (span === void 0) return void 0;
+  return outside(entries, events, issue, span).reduce(
+    (left, wait) => left - (wait.to_ms - wait.from_ms),
+    span.to_ms - span.from_ms
+  );
+}
+function net_minutes(entries, events, issue) {
+  const net = net_ms(entries, events, issue);
+  return net === void 0 ? void 0 : Math.ceil(net / MS_PER_MINUTE);
+}
+function missing_reason(entries, issue) {
+  const of_issue = entries_of(entries, issue);
+  if (of_issue.every((entry) => !lane_stage_stats.is_dispatch(entry))) return "no dispatch";
+  if (of_issue.every((entry) => !lane_stage_stats.is_merge(entry))) return "no merge";
+  return "cause unknown";
+}
+var lane_net_time = {
+  automatic_waits,
+  hold_waits,
+  missing_reason,
+  net_minutes,
+  net_ms,
+  outside,
+  slept,
+  span_of,
+  waits,
+  yield_spans,
+  yielded
+};
+
+export {
+  run_ship_pre_detach,
+  lane_stop_stats,
+  lane_stage_events,
+  lane_net_time
+};

package/dist/commands/chunk-LDYDRXOY.js

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