@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-7K5ITPHR.js

@@ -0,0 +1,338 @@
+import {
+  split_resolution
+} from "./chunk-MRAEJLXL.js";
+import {
+  auto_ok_cli
+} from "./chunk-RFIOZTXY.js";
+import {
+  size_estimate
+} from "./chunk-2VY7CJ2R.js";
+import {
+  lane_implement_rate_read
+} from "./chunk-PJYTUUTH.js";
+import {
+  declared_growth,
+  split_assess
+} from "./chunk-ZGEUWHFF.js";
+import {
+  lane_stage_budget
+} from "./chunk-AXXEMVRJ.js";
+import {
+  lane_implement_rate,
+  lane_size_stats
+} from "./chunk-KP2BVAS5.js";
+import {
+  run_ship_planned
+} from "./chunk-PKXTISWR.js";
+import {
+  backlog_overlap,
+  lane_plan,
+  lane_plan_approval
+} from "./chunk-MDGPJOLK.js";
+import {
+  test_related_cap
+} from "./chunk-HQZ65PJE.js";
+import {
+  test_pinned_logic
+} from "./chunk-RAQ3E6OT.js";
+import {
+  lane_stats
+} from "./chunk-2XLR7R6E.js";
+import {
+  lane_ledger
+} from "./chunk-2O64H5UJ.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  issue_body_keys
+} from "./chunk-KXK2A2HB.js";
+import {
+  IN_PROGRESS_LABEL,
+  has_any_label
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  change_base
+} from "./chunk-LBVYFW3I.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/lane/lane-plan-size.ts
+function declared_of(issue, issues) {
+  const body = issues.find((candidate) => candidate.number === issue)?.body;
+  const size = body === void 0 ? void 0 : size_estimate.declared_size(body);
+  return size === void 0 || size.files === 0 ? void 0 : size;
+}
+function declares(issue, issues) {
+  return declared_of(issue, issues) !== void 0;
+}
+function ratios_of(signals) {
+  return { files: signals.files_ratio, lines: signals.lines_ratio };
+}
+function guide_of(signals) {
+  return split_assess.guide_for(
+    lane_stage_budget.BUDGET_MINUTES.implement,
+    signals.implement_rate,
+    ratios_of(signals)
+  );
+}
+function ordered(counted, recorded) {
+  const held = new Set(recorded);
+  return [...counted.filter((file) => held.has(file)), ...counted.filter((file) => !held.has(file))];
+}
+function units_of(files, signals) {
+  const base = signals.base_files ?? new Set(files);
+  return split_assess.units_of(files, new Set(files.filter((file) => !base.has(file))));
+}
+function files_approved(plan, declared, recorded, measured) {
+  const approval = plan.size_approval ?? recorded?.size_approval;
+  return approval !== void 0 && lane_plan_approval.allows(approval, plan, { reason: "files", declared, measured });
+}
+function is_counted(file) {
+  return split_assess.is_deliverable({ path: file, changed_lines: 0 });
+}
+function files_over(plan, declared, recorded, signals) {
+  const limit = declared * declared_growth.factor(ratios_of(signals), "files");
+  const counted = plan.paths.filter((file) => is_counted(file));
+  const units = units_of(ordered(counted, recorded?.paths ?? []), signals);
+  if (units.length <= limit || files_approved(plan, declared, recorded, units.length)) {
+    return void 0;
+  }
+  const tests = plan.paths.filter((file) => test_declared_logic.is_test_file(file));
+  const kept = counted.filter((file) => units.slice(0, limit).flat().includes(file));
+  const split_off = counted.filter((file) => units.slice(limit).flat().includes(file));
+  return { reason: "files", declared, limit, kept, split_off, tests };
+}
+function earlier_cleared(recorded, signals) {
+  if (recorded?.cleared_paths !== void 0) return recorded.cleared_paths;
+  return recorded?.cleared === true ? signals.committed_files : [];
+}
+function unplanned_hunks(signals, plan, recorded) {
+  const listed = plan.paths.filter((path) => !path.endsWith("/"));
+  const planned = [...listed, ...recorded?.paths ?? [], ...earlier_cleared(recorded, signals)];
+  return run_ship_planned.unplanned_of(planned, signals.hunk_files).length;
+}
+function hunks_over(declared, hunks, signals) {
+  const limit = declared * declared_growth.factor(ratios_of(signals), "files");
+  return hunks > limit ? { reason: "hunks", declared, limit, measured: hunks } : void 0;
+}
+function lines_limit(signals) {
+  const growth = ratios_of(signals);
+  const bar = size_estimate.declared_lines_bar(signals.implement_rate, growth);
+  return bar ?? Math.floor(guide_of(signals).lines / declared_growth.factor(growth, "lines"));
+}
+function lines_over(declared, signals) {
+  const limit = lines_limit(signals);
+  if (declared <= limit) return void 0;
+  const measured = Math.round(declared * declared_growth.factor(ratios_of(signals), "lines"));
+  return { reason: "lines", declared, limit, measured };
+}
+function unapproved(over, plan, approval) {
+  if (over === void 0 || approval === void 0) return over;
+  if (over.reason !== "lines") return over;
+  const is_within = lane_plan_approval.allows(approval, plan, { ...over, reason: over.reason });
+  return is_within ? void 0 : over;
+}
+function planned_lines(declared, signals, plan, recorded) {
+  const approval = plan.size_approval ?? recorded?.size_approval;
+  if (approval === void 0 && lane_plan.is_sized(recorded)) return void 0;
+  return unapproved(lines_over(declared, signals), plan, approval);
+}
+function measure_over(declared, signals, plan, recorded) {
+  if (signals.split_filed) return void 0;
+  const estimated = Math.max(declared.lines, plan.estimated_size?.lines ?? 0);
+  return hunks_over(declared.files, unplanned_hunks(signals, plan, recorded), signals) ?? planned_lines(estimated, signals, plan, recorded);
+}
+function is_waived(plan, over) {
+  return over !== void 0 && (plan.single === true || plan.sized === true);
+}
+function hub_over(signals) {
+  const hubs = signals.hubs ?? [];
+  return hubs.length === 0 ? void 0 : { reason: "hub", limit: test_pinned_logic.MAX_TEST_FILES, hubs };
+}
+function first_over(plan, declared, recorded, signals) {
+  const files = files_over(plan, declared.files, recorded, signals);
+  if (files !== void 0 && !is_waived(plan, files)) return files;
+  return hub_over(signals) ?? measure_over(declared, signals, plan, recorded) ?? files;
+}
+function oversize(plan, issues, recorded, signals) {
+  const declared = declared_of(plan.issue, issues);
+  if (declared === void 0) return void 0;
+  const over = first_over(plan, declared, recorded, signals);
+  return over === void 0 ? void 0 : { ...over, guide: guide_of(signals) };
+}
+function bar_tail() {
+  return `A \`${split_assess.REASON_PREFIX}\` comment does not pass this bar \u2014 split-assessment.md \u2192 "${split_assess.QUESTION_SECTION}".`;
+}
+var SIZE_PREFIX = issue_body_keys.prefix("size");
+function files_text(issue, over) {
+  const planned = [...over.kept, ...over.split_off];
+  const counted = split_assess.units_of(planned, /* @__PURE__ */ new Set()).length;
+  const bar = `${String(counted)} files (tests and generated artifacts excluded), over ${String(over.limit)} \u2014 ${String(over.limit / over.declared)} times the ${String(over.declared)} its \`${SIZE_PREFIX}\` declares`;
+  const replan = ["pnpm josh lane:plan", String(issue), ...over.kept, ...over.tests].join(" ");
+  return `split (files): ${session_cite.issue(issue)}'s plan holds ${bar}, so it is not recorded. Keep in this Issue: ${over.kept.join(", ")}. Split off: ${over.split_off.join(", ")} \u2014 file them as a follow-up Issue with \`pnpm josh issue:file "<title>" --body-file <body.md> --route split\`, revert any edit to them here, run \`${replan}\`, and ship this Issue on the kept files. One deliverable with no separately-mergeable part instead \u2192 run this \`lane:plan\` again with \`--single\`. ${bar_tail()}`;
+}
+function waiver_text(issue, over) {
+  return `size warning (${over.reason}): ${session_cite.issue(issue)}'s plan is past its ${String(over.limit)} bar, recorded and noted on the ledger \u2014 a warning, not a stop; finish this Issue, never split it \u2014 an overrun at the merge is recorded as a pre-split miss (split-assessment.md \u2192 "${split_assess.NOTICE_SECTION}").`;
+}
+function measure_bar(over) {
+  if (over.reason === "hunks") {
+    return `change holds ${String(over.measured)} hunks outside the plan's files (tests excluded), over ${String(over.limit)} \u2014 ${String(over.limit / over.declared)} times the ${String(over.declared)} files its \`${SIZE_PREFIX}\` declares`;
+  }
+  return `\`${SIZE_PREFIX}\` declares ${String(over.declared)} lines, about ${String(over.measured)} at the lines lanes ran over their declaration \u2014 over the ${String(over.limit)} declared lines the size bar allows`;
+}
+function measure_text(issue, over) {
+  return `split (${over.reason}): ${session_cite.issue(issue)}'s ${measure_bar(over)}, so the plan is not recorded. Carve a separately-mergeable part off as a follow-up Issue with \`pnpm josh issue:file "<title>" --body-file <body.md> --route split\`, revert any edit to it here, and run \`pnpm josh lane:plan ${String(issue)} <paths>\` again on what stays. ${bar_tail()}`;
+}
+function hub_text(issue, over) {
+  return `split (hub): ${session_cite.issue(issue)}'s plan edits ${over.hubs.join(", ")}, whose \`test:related\` reach passes the ${String(over.limit)}-test-file cap, so the plan is not recorded. Carve the hub edit off as a follow-up Issue with \`pnpm josh issue:file "<title>" --body-file <body.md> --route split\`, revert any edit to it here, and run \`pnpm josh lane:plan ${String(issue)} <paths>\` again on what stays. The hub edit is the one deliverable instead \u2192 run this \`lane:plan\` again with \`--single\`. ${bar_tail()}`;
+}
+function over_text(issue, over) {
+  if (over.reason === "files") return files_text(issue, over);
+  return over.reason === "hub" ? hub_text(issue, over) : measure_text(issue, over);
+}
+function refusal_text(issue, over) {
+  const text = over_text(issue, over);
+  const guide = over.guide ?? split_assess.guide_for(lane_stage_budget.BUDGET_MINUTES.implement);
+  return `${text} ${split_assess.policy_text(guide)}`;
+}
+var lane_plan_size = { declares, is_waived, oversize, refusal_text, waiver_text };
+
+// scripts/lane/lane-plan-signals.ts
+var RATIO_PERIOD_DAYS = lane_implement_rate_read.PERIOD_DAYS;
+var NAME_ONLY = "--name-only";
+var DIFF_ARGUMENTS = [
+  "diff",
+  "-U0",
+  "--no-color",
+  "--no-ext-diff",
+  "--diff-filter=M",
+  "--src-prefix=a/",
+  "--dst-prefix=b/"
+];
+function hunk_files(diff) {
+  return test_pinned_logic.parse_hunks(diff).map((hunk) => hunk.file);
+}
+var NO_PROBE = { hunk_files: [], committed_files: [] };
+async function read_or_empty(arguments_) {
+  try {
+    return await git_spawn.read(arguments_);
+  } catch {
+    return "";
+  }
+}
+function names_of(output) {
+  return output.split("\n").filter((name) => name !== "");
+}
+async function base_files_of(base) {
+  try {
+    return new Set(names_of(await git_spawn.read(["ls-tree", "-r", NAME_ONLY, base])));
+  } catch {
+    return void 0;
+  }
+}
+async function probe_of(base) {
+  const [diff, committed, base_files] = await Promise.all([
+    read_or_empty([...DIFF_ARGUMENTS, base]),
+    read_or_empty(["diff", NAME_ONLY, `${base}...HEAD`]),
+    base_files_of(base)
+  ]);
+  return { hunk_files: hunk_files(diff), committed_files: names_of(committed), base_files };
+}
+async function tree_of() {
+  const base = await change_base.resolved_through_merge();
+  return base === void 0 ? NO_PROBE : await probe_of(base);
+}
+async function entries_of() {
+  const ledger = await lane_ledger.target();
+  return ledger === void 0 ? [] : lane_ledger.read_entries(ledger);
+}
+function signals_from(issue, tree, entries, now_ms) {
+  const window = lane_stats.window_of(RATIO_PERIOD_DAYS, now_ms);
+  const ratios = lane_size_stats.ratios(entries, window);
+  return {
+    ...tree,
+    files_ratio: ratios.files,
+    lines_ratio: ratios.lines,
+    implement_rate: lane_implement_rate.rate(entries, window),
+    split_filed: split_resolution.split_issues(entries).has(issue)
+  };
+}
+async function hubs_of(paths) {
+  return paths.length === 0 ? [] : await test_related_cap.hubs_of(process.cwd(), paths);
+}
+async function signals_of(issue, paths = []) {
+  const [tree, entries, hubs] = await Promise.all([tree_of(), entries_of(), hubs_of(paths)]);
+  return { ...signals_from(issue, tree, entries, Date.now()), hubs };
+}
+var lane_plan_signals = { hunk_files, signals_from, signals_of };
+
+// scripts/lane/lane-plan-probe.ts
+var RUNNING = /* @__PURE__ */ new Set([IN_PROGRESS_LABEL]);
+var UNREAD = "unread";
+var OVERSIZE = "oversize";
+async function opted_in() {
+  const read = await auto_ok_cli.fetch_opted_in();
+  return read.kind === "read" ? read.issues : void 0;
+}
+function running_of(issues) {
+  return issues.filter((issue) => has_any_label(issue.labels, RUNNING));
+}
+function clash_among(plan, issues, directory) {
+  const declared = lane_plan.with_plans(backlog_overlap.declared_of(issues), directory);
+  return lane_plan.clash_of(plan, declared, directory);
+}
+function overlap_text(issue, clash) {
+  const holder = session_cite.issue(clash.holder);
+  return `${session_cite.issue(issue)}'s planned \`${clash.path}\` overlaps \`${clash.claimed}\`, which ${holder} declares or plans`;
+}
+function probe(plan, issues, directory) {
+  return issues === void 0 ? UNREAD : clash_among(plan, running_of(issues), directory);
+}
+function is_unread(found) {
+  return found === UNREAD;
+}
+function record_cleared(plan, directory) {
+  lane_plan.record(
+    { ...plan, cleared: true, yielded: void 0, waits_until: void 0 },
+    directory
+  );
+}
+async function oversize_of(plan, issues, directory) {
+  if (issues === void 0 || !lane_plan_size.declares(plan.issue, issues)) return void 0;
+  const signals = await lane_plan_signals.signals_of(plan.issue, plan.paths);
+  return lane_plan_size.oversize(plan, issues, lane_plan.read(plan.issue, directory), signals);
+}
+function is_oversize(found) {
+  return found === OVERSIZE;
+}
+async function extend(plan, directory) {
+  const issues = await opted_in();
+  const over = await oversize_of(plan, issues, directory);
+  if (over !== void 0 && !lane_plan_size.is_waived(plan, over)) return OVERSIZE;
+  const found = probe(plan, issues, directory);
+  if (found === void 0) record_cleared(plan, directory);
+  return found;
+}
+var lane_plan_probe = {
+  clash_among,
+  extend,
+  is_oversize,
+  is_unread,
+  opted_in,
+  overlap_text,
+  oversize_of,
+  probe,
+  record_cleared,
+  running_of
+};
+
+export {
+  lane_plan_signals,
+  lane_plan_size,
+  lane_plan_probe
+};

package/dist/commands/chunk-7OEBSPPU.js

@@ -0,0 +1,321 @@
+import {
+  backlog_hold_codes
+} from "./chunk-MXPCEZL5.js";
+import {
+  backlog_next_shared
+} from "./chunk-A3LCN4KA.js";
+import {
+  backlog_wait_cause
+} from "./chunk-N2ZF6T4E.js";
+import {
+  lane_room
+} from "./chunk-AUTD5FV2.js";
+import {
+  lane_capacity
+} from "./chunk-WR73HTRG.js";
+import {
+  epic_triage
+} from "./chunk-VQRT32JB.js";
+import {
+  backlog_drive_restore,
+  backlog_offer_exclude
+} from "./chunk-SQZZHK6X.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  lane_ledger
+} from "./chunk-2O64H5UJ.js";
+import {
+  run_headless
+} from "./chunk-Q4ULMZAS.js";
+import {
+  lane_registry
+} from "./chunk-NEOCCN6D.js";
+import {
+  run_event_scope,
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  run_invocation
+} from "./chunk-DS53UUDH.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/backlog/backlog-hold-text.ts
+var {
+  DRAINED_REASON,
+  DRIVERLESS_PREFIX,
+  HAND_BACK_PREFIX,
+  MEMORY_REASON,
+  OFFER_PREFIX,
+  REASON_SEPARATOR,
+  USAGE_LIMIT_REASON
+} = backlog_hold_codes;
+var NOT_FOUND = -1;
+var AWAIT_TRIAGE = "open issues await your triage";
+var HAND_BACK_TEXT = /* @__PURE__ */ new Map([
+  ["judge", AWAIT_TRIAGE],
+  ["triage", "a parked issue awaits your triage"],
+  ["merge", "the driver paused after a merge; the session restarts it"],
+  ["launch", "a lane launch failed; the session restarts the driver"],
+  ["offer", "the backlog offer failed; the session restarts the driver"],
+  ["window", "the run's time window closed; the session restarts the driver"],
+  [DRAINED_REASON, "the backlog had nothing to start; the session restarts the driver"]
+]);
+var PERSON_HAND_BACKS = /* @__PURE__ */ new Set(["judge", "triage"]);
+var OFFER_TEXT = /* @__PURE__ */ new Map([
+  ["solo", "a run:solo issue must finish first"],
+  ["blocked", "every queued issue is blocked"],
+  ["exhausted", "the backlog has nothing left to start"],
+  ["untriaged", AWAIT_TRIAGE],
+  ["parked", "parked issues await your decision"],
+  ["unreadable", "the backlog could not be read"]
+]);
+var CAUSE_TEXT = {
+  chain: "other issues",
+  gate: "a start condition",
+  lane: "a running lane"
+};
+var CAUSE_JOINER = " or ";
+var MEMORY_TEXT = "memory pressure is high; lanes resume when it eases";
+var USAGE_LIMIT_TEXT = "the usage limit is reached; lanes resume when it resets";
+var DRIVERLESS_TEXT = "no driver is running";
+function rest_after(code, prefix) {
+  const head = `${prefix}${REASON_SEPARATOR}`;
+  return code.startsWith(head) ? code.slice(head.length) : void 0;
+}
+function hand_back_text(reason) {
+  return HAND_BACK_TEXT.get(reason) ?? `the driver paused (${reason}); the session restarts it`;
+}
+function cause_text(detail) {
+  const causes = backlog_wait_cause.causes_of_tag(detail);
+  if (causes === void 0) return void 0;
+  return `queued issues wait on ${causes.map((cause) => CAUSE_TEXT[cause]).join(CAUSE_JOINER)}`;
+}
+function offer_text(rest) {
+  const index = rest.indexOf(REASON_SEPARATOR);
+  const detail = index === NOT_FOUND ? "" : rest.slice(index + REASON_SEPARATOR.length);
+  return OFFER_TEXT.get(detail) ?? cause_text(detail) ?? `the backlog is waiting (${rest})`;
+}
+function prefixed_text(code) {
+  const hand_back = rest_after(code, HAND_BACK_PREFIX);
+  if (hand_back !== void 0) return hand_back_text(hand_back);
+  const offer = rest_after(code, OFFER_PREFIX);
+  return offer === void 0 ? void 0 : offer_text(offer);
+}
+function whole_text(code) {
+  if (code === MEMORY_REASON) return MEMORY_TEXT;
+  return code === USAGE_LIMIT_REASON ? USAGE_LIMIT_TEXT : void 0;
+}
+function text_of(code) {
+  if (code.startsWith(DRIVERLESS_PREFIX)) {
+    return `${DRIVERLESS_TEXT}; ${text_of(code.slice(DRIVERLESS_PREFIX.length))}`;
+  }
+  return prefixed_text(code) ?? whole_text(code) ?? code;
+}
+function is_driver_restart(code) {
+  const own = code.startsWith(DRIVERLESS_PREFIX) ? code.slice(DRIVERLESS_PREFIX.length) : code;
+  const reason = rest_after(own, HAND_BACK_PREFIX);
+  return reason !== void 0 && !PERSON_HAND_BACKS.has(reason);
+}
+var backlog_hold_text = { is_driver_restart, text_of };
+
+// scripts/backlog/backlog-stalled.ts
+var STALL_THRESHOLD_MINUTES = 10;
+var STALL_THRESHOLD_MS = STALL_THRESHOLD_MINUTES * MS_PER_MINUTE;
+var NONE = 0;
+var STALLED = "stalled";
+var OK = "ok";
+var UNREADABLE = "unreadable";
+function is_stalled(reading, threshold_ms) {
+  return reading.ready_count > NONE && reading.free_lanes > NONE && reading.waiting_ms > threshold_ms;
+}
+function assess(reading, threshold_ms) {
+  if (reading === void 0) return UNREADABLE;
+  if (is_stalled(reading, threshold_ms)) return STALLED;
+  return OK;
+}
+function dispatch_reference_iso(events) {
+  const last_launch = events.findLast(
+    (event) => event.kind === run_event_stream.EVENT_KIND.CHILD_LAUNCH
+  );
+  return last_launch?.at ?? events[0]?.at;
+}
+function dispatch_reference_ms(events) {
+  const iso = dispatch_reference_iso(events);
+  const at = iso === void 0 ? NaN : Date.parse(iso);
+  return Number.isNaN(at) ? void 0 : at;
+}
+function dispatch_age_ms(events, now_ms) {
+  const at = dispatch_reference_ms(events);
+  return at === void 0 ? void 0 : now_ms - at;
+}
+function open_offerable_ms(entries, reference_ms) {
+  const newest = entries.findLast(
+    (entry) => entry.kind === lane_ledger.KIND.OFFERABLE && Date.parse(entry.at) >= reference_ms
+  );
+  if (newest?.kind !== lane_ledger.KIND.OFFERABLE || !newest.is_offerable) return void 0;
+  return Date.parse(newest.at);
+}
+function open_hold(entries) {
+  const { HELD, RELEASED, DISPATCH } = lane_ledger.KIND;
+  const hold_kinds = /* @__PURE__ */ new Set([HELD, RELEASED, DISPATCH]);
+  const newest = entries.findLast((entry) => hold_kinds.has(entry.kind));
+  return newest?.kind === lane_ledger.KIND.HELD ? newest.reason : void 0;
+}
+function describe(reading) {
+  const minutes = Math.floor(reading.waiting_ms / MS_PER_MINUTE);
+  const held = reading.hold === void 0 ? "" : ` (${backlog_hold_text.text_of(reading.hold)})`;
+  return `${String(reading.ready_count)} ready, ${String(reading.free_lanes)} free lane(s), ${String(minutes)}m waiting with both${held}`;
+}
+function ready_tokens(out) {
+  return out.split("\n").map((token) => token.trim()).filter((token) => issue_number_shape.is_issue_number(token));
+}
+function count_ready_tokens(out) {
+  return ready_tokens(out).length;
+}
+function needs_triage(out) {
+  return out.split("\n").some((token) => token.trim() === epic_triage.TRIAGE_VERDICT);
+}
+var backlog_stalled = {
+  STALLED,
+  OK,
+  UNREADABLE,
+  STALL_THRESHOLD_MS,
+  assess,
+  count_ready_tokens,
+  describe,
+  dispatch_age_ms,
+  needs_triage,
+  open_hold,
+  open_offerable_ms,
+  ready_tokens
+};
+
+// scripts/backlog/backlog-ready.ts
+var NO_FREE = 0;
+var NONE2 = 0;
+var lane_room2 = lane_room.read;
+async function lane_use(lanes) {
+  const room = await lane_room2(lanes);
+  return room.use;
+}
+function free_of(limit, use) {
+  return lane_capacity.free_lanes(limit, use.occupied, use.seated);
+}
+async function count_in(room) {
+  const limit = await lane_capacity.lane_limit();
+  if (limit.kind !== "limit") return void 0;
+  return { limit: limit.limit, free: free_of(limit.limit, room.use) };
+}
+async function free_lanes_beside(lanes) {
+  const count = await count_in(await lane_room2(lanes));
+  return count?.free;
+}
+async function free_under(limit) {
+  return free_of(limit, await lane_use());
+}
+async function free_lane_count() {
+  return await free_lanes_beside(await lane_registry.list_lanes()) ?? NO_FREE;
+}
+async function drive_limit() {
+  const limit = await lane_capacity.lane_limit();
+  if (limit.kind !== "limit") throw new Error(limit.problem);
+  return limit.limit;
+}
+async function drive_free_lane_count() {
+  return await free_under(await drive_limit());
+}
+async function drive_limit_room() {
+  const limit = await drive_limit();
+  const use = await lane_use();
+  return lane_capacity.limit_room(limit, use.occupied);
+}
+function drains_pool(carry) {
+  return carry === void 0 || !run_invocation.has_only(carry.invocation);
+}
+async function stream_exclude(carry) {
+  const target = await run_event_stream_emit.stream_target();
+  if (target === void 0 || carry === void 0) return [];
+  const scope = run_event_scope.scope_of({ kind: "carried", carry });
+  const events = run_event_scope.scoped_events(run_event_stream.read_events(target), scope) ?? [];
+  return backlog_drive_restore.offer_exclude(events);
+}
+async function read_backlog_next(timeout_ms) {
+  const carry = await run_headless.current_carry();
+  if (!drains_pool(carry)) return void 0;
+  const argv = ["backlog:next", ...backlog_offer_exclude.exclude_argv(await stream_exclude(carry))];
+  return await backlog_next_shared.read(argv, timeout_ms === void 0, timeout_ms);
+}
+async function ready_issues() {
+  const result = await read_backlog_next();
+  return result === void 0 ? [] : backlog_stalled.ready_tokens(result.out);
+}
+var DEFAULT_PORTS = { free_lane_count, ready_issues };
+async function read_ready(ports = DEFAULT_PORTS) {
+  const free_lanes = await ports.free_lane_count();
+  if (free_lanes <= NO_FREE) return { issues: [], free_lanes };
+  return { issues: await ports.ready_issues(), free_lanes };
+}
+function ready_line(reading, slug) {
+  if (reading.issues.length === NONE2 || reading.free_lanes <= NO_FREE) return void 0;
+  const cite = issue_cite.citer(slug, /* @__PURE__ */ new Map());
+  const issues = reading.issues.map((issue) => cite(issue)).join(" ");
+  return `ready ${issues} \xB7 free lanes ${String(reading.free_lanes)}`;
+}
+async function parent_ready_line(ports, is_parent, read_repo) {
+  if (!await is_parent()) return void 0;
+  const reading = await read_ready(ports);
+  return reading.issues.length === NONE2 ? void 0 : ready_line(reading, await read_repo());
+}
+function print_line(line) {
+  if (line !== void 0) console.info(line);
+}
+async function print_ready_line(ports = DEFAULT_PORTS, is_parent = run_headless.is_backlog_parent, read_repo = git_gh_command.repo_get_name_with_owner) {
+  try {
+    print_line(await parent_ready_line(ports, is_parent, read_repo));
+  } catch {
+  }
+}
+var OFFER_HINT = "\u21BB backlogrun parent: a child just entered an epic \u2014 run `pnpm josh backlog:offer` next, so a runnable filing is dispatched now rather than on the next wake.";
+async function print_offer_hint(is_parent = run_headless.is_backlog_parent) {
+  try {
+    if (await is_parent()) console.info(OFFER_HINT);
+  } catch {
+  }
+}
+var backlog_ready = {
+  DEFAULT_PORTS,
+  OFFER_HINT,
+  read_backlog_next,
+  print_offer_hint,
+  free_lane_count,
+  free_lanes_beside,
+  count_in,
+  lane_room: lane_room2,
+  lane_use,
+  drive_free_lane_count,
+  drive_limit_room,
+  drains_pool,
+  print_ready_line,
+  read_ready,
+  ready_issues,
+  ready_line
+};
+
+export {
+  backlog_hold_text,
+  backlog_stalled,
+  backlog_ready
+};