@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-MOD3FG4V.js

@@ -1,419 +0,0 @@
-import {
-  epic_decision,
-  epic_sections
-} from "./chunk-XSKB6ZUA.js";
-import {
-  epic_validate
-} from "./chunk-RFWB2KAV.js";
-import {
-  epic_fetch
-} from "./chunk-BML6MEUB.js";
-import {
-  UNORDERED_DEPENDENCIES,
-  chain_links,
-  epic_parse
-} from "./chunk-VDGNXSP3.js";
-import {
-  epic_graph
-} from "./chunk-3RIQ36LH.js";
-import {
-  DEPENDENCY_ARROW,
-  format_dependency_link,
-  format_issue_references,
-  to_issue_reference
-} from "./chunk-2ADQ5XRD.js";
-import {
-  git_gh_command
-} from "./chunk-NRULNBYI.js";
-import {
-  EPIC_LABEL,
-  has_label_name
-} from "./chunk-QQBMVC5W.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-
-// scripts/epic/epic-read.ts
-var UNKNOWN_REPO = "Could not read this repository from `git remote`, so the epic's relations cannot be keyed by repository \u2014 check `gh auth status` and that this is a checkout with an `origin` remote.";
-async function read_subject(epic_number) {
-  return epic_validate.parse_epic_subject(
-    await git_gh_command.issue_get_labels_and_body(String(epic_number))
-  );
-}
-async function read_recorded(body) {
-  const repo = await git_gh_command.repo_get_name_with_owner();
-  if (repo === void 0) return { error: UNKNOWN_REPO };
-  const tracked = epic_parse.parse_task_list_issue_numbers(body);
-  if (tracked.length === 0) return { children: [], repo };
-  const fetched = await epic_fetch.fetch_children(tracked, repo);
-  if (fetched.unreadable.length > 0) {
-    const list = epic_graph.format_references(fetched.unreadable, repo);
-    return { error: `Could not read ${list}; the epic's dependency graph is incomplete.` };
-  }
-  return { children: fetched.children, repo };
-}
-async function read_epic(epic_number) {
-  const subject = await read_subject(epic_number);
-  const unread = `Could not read issue ${session_cite.issue(epic_number)}.`;
-  if (subject === void 0) return { error: unread };
-  const recorded = await read_recorded(subject.body);
-  if ("error" in recorded) return { error: recorded.error };
-  return { subject, recorded: recorded.children, repo: recorded.repo };
-}
-var epic_read = {
-  read_subject,
-  read_epic
-};
-
-// scripts/epic/epic-chains.ts
-var AMBIGUOUS_MATCH_COUNT = 2;
-function render_chains(chains) {
-  return chains.filter((chain) => chain.length > 1).map((chain) => chain.map((number) => to_issue_reference(number)).join(DEPENDENCY_ARROW));
-}
-function links_of(chains) {
-  const links = chains.flatMap((chain) => chain_links(chain));
-  return [...new Map(links.map((link) => [format_dependency_link(link), link])).values()];
-}
-function diff_links(before, after) {
-  const before_links = links_of(before);
-  const after_links = links_of(after);
-  const before_keys = new Set(before_links.map((link) => format_dependency_link(link)));
-  const after_keys = new Set(after_links.map((link) => format_dependency_link(link)));
-  return {
-    added: after_links.filter((link) => !before_keys.has(format_dependency_link(link))),
-    removed: before_links.filter((link) => !after_keys.has(format_dependency_link(link)))
-  };
-}
-function chains_containing(chains, target) {
-  return chains.map((chain, index) => chain.includes(target) ? index : -1).filter((index) => index !== -1);
-}
-function find_repeated_reference(chains) {
-  for (const chain of chains) {
-    const repeated = chain.find((issue_number, index) => chain.indexOf(issue_number) !== index);
-    if (repeated !== void 0) return repeated;
-  }
-  return void 0;
-}
-function chain_for(additions, position) {
-  return position.kind === "before" ? [...additions, position.target] : [position.target, ...additions];
-}
-function start_chain(additions, position) {
-  return { chains: [chain_for(additions, position)] };
-}
-function add_chain(chains, additions, position) {
-  return { chains: [...chains.map((chain) => [...chain]), chain_for(additions, position)] };
-}
-function not_a_child_error(target) {
-  return {
-    error: `${to_issue_reference(target)} is not a child of this epic, so it cannot position an insertion.`
-  };
-}
-function insert_outside_chains(chains, additions, position, tracked) {
-  if (tracked.includes(position.target)) return add_chain(chains, additions, position);
-  return not_a_child_error(position.target);
-}
-function has_successor(chain, target) {
-  return chain.indexOf(target) < chain.length - 1;
-}
-function is_branching_after(chains, indices, position) {
-  if (position.kind !== "after") return false;
-  return indices.every((index) => has_successor(chains[index] ?? [], position.target));
-}
-function is_shared_before(chains, indices, position) {
-  if (position.kind !== "before") return false;
-  const predecessors = indices.map((index) => {
-    const chain = chains[index] ?? [];
-    return chain[chain.indexOf(position.target) - 1];
-  });
-  return predecessors.every((predecessor) => predecessor === predecessors[0]);
-}
-function is_single_place(chains, indices, position) {
-  return indices.length < AMBIGUOUS_MATCH_COUNT || is_shared_before(chains, indices, position);
-}
-function to_ambiguous_position_error(position) {
-  return `${to_issue_reference(position.target)} appears in more than one declared chain, so "${position.kind}" does not identify one place; edit the declaration by hand.`;
-}
-function find_position_ambiguity(chains, position) {
-  if (position?.kind !== "before" || is_single_place(chains, chains_containing(chains, position.target), position)) {
-    return void 0;
-  }
-  return to_ambiguous_position_error(position);
-}
-function splice_chain(chain, additions, position) {
-  const at = chain.indexOf(position.target) + (position.kind === "after" ? 1 : 0);
-  return [...chain.slice(0, at), ...additions, ...chain.slice(at)];
-}
-function splice_into_chains(chains, indices, additions, position) {
-  return {
-    chains: chains.map(
-      (chain, index) => indices.includes(index) ? splice_chain(chain, additions, position) : [...chain]
-    )
-  };
-}
-function insert_at_position(chains, additions, position, tracked) {
-  const indices = chains_containing(chains, position.target);
-  if (indices.length === 0) return insert_outside_chains(chains, additions, position, tracked);
-  if (is_branching_after(chains, indices, position)) return add_chain(chains, additions, position);
-  if (!is_single_place(chains, indices, position)) {
-    return { error: to_ambiguous_position_error(position) };
-  }
-  return splice_into_chains(chains, indices, additions, position);
-}
-function keep_declaration(chains) {
-  return { chains: chains.map((chain) => [...chain]) };
-}
-function start_chain_or_refuse(additions, position, tracked) {
-  if (!tracked.includes(position.target)) return not_a_child_error(position.target);
-  return start_chain(additions, position);
-}
-function apply_insertion(chains, additions, position, tracked) {
-  if (position === void 0) return keep_declaration(chains);
-  if (chains.length === 0) return start_chain_or_refuse(additions, position, tracked);
-  return insert_at_position(chains, additions, position, tracked);
-}
-function find_already_declared_addition(chains, additions) {
-  const declared = new Set(chains.flat());
-  return additions.find((addition) => declared.has(addition));
-}
-function already_declared_error(issue_number) {
-  const reference = to_issue_reference(issue_number);
-  return `${reference} is already named in the declared dependency order; inserting it again would have it block itself.`;
-}
-function find_insertion_error(chains, additions) {
-  const repeated = find_repeated_reference(chains);
-  if (repeated !== void 0) {
-    return `The declared dependency order names ${to_issue_reference(repeated)} twice; fix the declaration before inserting.`;
-  }
-  const declared = find_already_declared_addition(chains, additions);
-  return declared === void 0 ? void 0 : already_declared_error(declared);
-}
-function remove_children(chains, children) {
-  const dropped = new Set(children);
-  return chains.map((chain) => chain.filter((issue_number) => !dropped.has(issue_number))).filter((chain) => chain.length > 1);
-}
-function break_indices(chain, dropped) {
-  return chain.map((blocked, index) => {
-    const blocker = chain[index - 1];
-    return blocker !== void 0 && dropped.has(format_dependency_link({ blocker, blocked })) ? index : -1;
-  }).filter((index) => index !== -1);
-}
-function split_chain(chain, dropped) {
-  const bounds = [0, ...break_indices(chain, dropped), chain.length];
-  return bounds.slice(0, -1).map((start, index) => chain.slice(start, bounds[index + 1]));
-}
-function remove_links(chains, links) {
-  const dropped = new Set(links.map((link) => format_dependency_link(link)));
-  return chains.flatMap((chain) => split_chain(chain, dropped)).filter((chain) => chain.length > 1);
-}
-function insert_children(chains, additions, position, tracked) {
-  const error = find_insertion_error(chains, additions);
-  if (error !== void 0) return { error };
-  const outcome = apply_insertion(chains, additions, position, tracked);
-  if ("error" in outcome) return outcome;
-  const duplicated = find_repeated_reference(outcome.chains);
-  return duplicated === void 0 ? outcome : { error: already_declared_error(duplicated) };
-}
-var epic_chains = {
-  render_chains,
-  links_of,
-  diff_links,
-  find_position_ambiguity,
-  // Exported so `--order-before` / `--order-after` can pass the
-  // declaration through by the same function `--add` without a position uses. An order-only move is
-  // "leave the declaration exactly as it stood" applied to a call that *does* name a position, so a
-  // second copy of the passthrough would be the clone `CLAUDE.md` prohibits.
-  keep_declaration,
-  remove_children,
-  remove_links,
-  insert_children
-};
-
-// scripts/epic/epic-add-body.ts
-var { find_indices, is_in_range, to_body_lines } = epic_sections;
-function to_task_row(issue_number) {
-  return `- [ ] ${to_issue_reference(issue_number)}`;
-}
-function to_task_rows(placed) {
-  return placed.map((issue_number) => to_task_row(issue_number));
-}
-function append_task_rows(input, placed) {
-  const rows = find_indices(input, (line) => epic_parse.is_task_list_line(line));
-  const last = rows.at(-1);
-  if (last === void 0) return [...input.lines];
-  return [
-    ...input.lines.slice(0, last + 1),
-    ...to_task_rows(placed),
-    ...input.lines.slice(last + 1)
-  ];
-}
-function to_row_number(line) {
-  const [issue_number] = epic_parse.parse_task_list_issue_numbers(line);
-  return issue_number;
-}
-function is_placed_row(line, placed) {
-  const issue_number = to_row_number(line);
-  return issue_number !== void 0 && placed.has(issue_number);
-}
-function insert_task_rows(input, placed, position) {
-  const moved = new Set(placed);
-  const dropped = new Set(find_indices(input, (line) => is_placed_row(line, moved)));
-  const kept = input.lines.filter((_line, index) => !dropped.has(index));
-  const [at] = find_indices(to_body_lines(kept), (line) => to_row_number(line) === position.target);
-  if (at === void 0) return [...input.lines];
-  const insert_at = position.kind === "before" ? at : at + 1;
-  return [...kept.slice(0, insert_at), ...to_task_rows(placed), ...kept.slice(insert_at)];
-}
-function to_placed_lines(input) {
-  const lines = to_body_lines(input.body);
-  const { position } = input;
-  if (position === void 0) return append_task_rows(lines, input.placed);
-  return insert_task_rows(lines, input.placed, position);
-}
-var DEPENDENCIES_HEADING = /^#{1,6}[ \t]+Dependencies\b/u;
-function find_dependencies_range(input) {
-  return epic_sections.find_section_range(input, DEPENDENCIES_HEADING);
-}
-function splice_declaration(lines, input) {
-  return lines.flatMap((line, index) => {
-    if (index === input.first) return [...input.rendered];
-    if (input.dropped.has(index)) return [];
-    return [line];
-  });
-}
-function replace_declaration(lines, rendered) {
-  const input = to_body_lines(lines);
-  const range = find_dependencies_range(input);
-  if (range === void 0) return void 0;
-  const found = find_indices(input, (line) => epic_parse.is_declaration_line(line));
-  const declarations = found.filter((index) => is_in_range(index, range));
-  const [first] = declarations;
-  return first === void 0 ? [...lines.slice(0, range.end), ...rendered, ...lines.slice(range.end)] : splice_declaration(lines, { first, dropped: new Set(declarations.slice(1)), rendered });
-}
-function to_safe_declaration(line) {
-  const [rendered] = epic_chains.render_chains(epic_parse.parse_dependency_chains(line));
-  return rendered ?? UNORDERED_DEPENDENCIES;
-}
-function find_stray_declaration(lines) {
-  const input = to_body_lines(lines);
-  const range = find_dependencies_range(input);
-  if (range === void 0) return void 0;
-  const stray = find_indices(input, (line) => epic_parse.is_declaration_line(line)).find(
-    (index) => !is_in_range(index, range)
-  );
-  return stray === void 0 ? void 0 : to_safe_declaration(lines[stray] ?? "");
-}
-function to_written_lines(input) {
-  const with_rows = to_placed_lines(input);
-  const { decision } = input;
-  if (decision === void 0) return with_rows;
-  return epic_decision.append_decision(with_rows.join("\n"), decision).split("\n");
-}
-function is_declaration_unchanged(lines, rendered) {
-  const declared = epic_parse.parse_dependency_chains(lines.join("\n"));
-  return epic_chains.render_chains(declared).join("\n") === rendered.join("\n");
-}
-function to_declared_body(with_rows, rendered) {
-  const stray = find_stray_declaration(with_rows);
-  if (stray !== void 0) {
-    return {
-      error: `The body declares \`${stray}\` outside the \`Dependencies\` section, which no insertion can keep consistent; move it into that section or reword it first.`
-    };
-  }
-  if (is_declaration_unchanged(with_rows, rendered)) return { body: with_rows.join("\n") };
-  const replaced = replace_declaration(with_rows, rendered);
-  return replaced === void 0 ? { error: "Could not locate the `Dependencies` section to rewrite; nothing was written." } : { body: replaced.join("\n") };
-}
-function to_rendered_declaration(input) {
-  const rendered = epic_chains.render_chains(input.chains_after);
-  if (rendered.length > 0) return rendered;
-  return input.does_clear_declaration === true ? [UNORDERED_DEPENDENCIES] : [];
-}
-function build_body(input) {
-  const with_rows = to_written_lines(input);
-  const rendered = to_rendered_declaration(input);
-  if (rendered.length === 0) return { body: with_rows.join("\n") };
-  return to_declared_body(with_rows, rendered);
-}
-function to_link_keys(chains) {
-  return epic_chains.links_of(chains).map((link) => format_dependency_link(link)).toSorted((left, right) => left.localeCompare(right));
-}
-function has_intended_links(body, chains_after) {
-  const written = to_link_keys(epic_parse.parse_dependency_chains(body));
-  const intended = to_link_keys(chains_after);
-  return written.length === intended.length && written.every((key, index) => key === intended[index]);
-}
-function missing_rows(body, expected) {
-  const tracked = epic_parse.parse_task_list_issue_numbers(body);
-  return expected.filter((issue_number) => !tracked.includes(issue_number));
-}
-function to_placement_start(position, target, count) {
-  return position.kind === "before" ? target - count : target + 1;
-}
-function has_intended_rows(body, input) {
-  const { position, placed } = input;
-  if (position === void 0 || placed.length === 0) return true;
-  const tracked = epic_parse.parse_task_list_issue_numbers(body);
-  const target = tracked.indexOf(position.target);
-  if (target === -1) return false;
-  const start = to_placement_start(position, target, placed.length);
-  return placed.every((child, offset) => tracked[start + offset] === child);
-}
-function find_rewrite_error(body, input) {
-  const missing = missing_rows(body, input.placed);
-  if (missing.length > 0) {
-    return `The rewritten body would not track ${format_issue_references(missing)} as a task-list row.`;
-  }
-  if (!epic_parse.has_machine_readable_declaration(body)) {
-    return "The rewritten body would carry no unambiguous machine-readable `Dependencies` declaration.";
-  }
-  if (!has_intended_links(body, input.chains_after)) {
-    return "The rewritten body would declare a different dependency order than the one computed; nothing was written.";
-  }
-  if (!has_intended_rows(body, input)) {
-    return "The rewritten body would not put the placed task-list rows where the position asked; nothing was written.";
-  }
-  return void 0;
-}
-function rewrite_body(input) {
-  const built = build_body(input);
-  if ("error" in built) return built;
-  const error = find_rewrite_error(built.body, input);
-  return error === void 0 ? built : { error };
-}
-var epic_add_body = {
-  rewrite_body
-};
-
-// scripts/epic/epic-shape.ts
-function missing_declaration_error(epic_number) {
-  const check = `josh epic:check ${String(epic_number)}`;
-  return `${to_issue_reference(epic_number)} has no unambiguous machine-readable \`Dependencies\` declaration; run \`${check}\` first.`;
-}
-function promote_remedy(epic_number) {
-  const promote = `josh epic --promote ${String(epic_number)} <N...>`;
-  return `Promote it with \`${promote}\` when it is a request, a discussion or a container; create a new epic over both when it is itself one of the deliverables.`;
-}
-function find_epic_shape_error(subject) {
-  if (has_label_name(subject.labels, EPIC_LABEL)) return void 0;
-  return `${to_issue_reference(subject.epic_number)} does not carry the \`${EPIC_LABEL}\` label, so it is not an epic. ${promote_remedy(subject.epic_number)}`;
-}
-function find_subject_error(subject, tracked) {
-  const reference = to_issue_reference(subject.epic_number);
-  if (subject.body === void 0) return `Could not read the body of ${reference}.`;
-  const shape_error = find_epic_shape_error(subject);
-  if (shape_error !== void 0) return shape_error;
-  if (tracked.length === 0) {
-    return `${reference} tracks no child as a \`- [ ] #N\` row; there is nowhere to add one.`;
-  }
-  return epic_parse.has_machine_readable_declaration(subject.body) ? void 0 : missing_declaration_error(subject.epic_number);
-}
-var epic_shape = {
-  find_subject_error
-};
-
-export {
-  epic_chains,
-  epic_add_body,
-  epic_shape,
-  epic_read
-};

package/dist/commands/chunk-MRAEJLXL.js

@@ -1,83 +0,0 @@
-import {
-  split_assess
-} from "./chunk-ZGEUWHFF.js";
-import {
-  lane_ledger
-} from "./chunk-2O64H5UJ.js";
-import {
-  SPLIT_ROUTE_LABEL
-} from "./chunk-QQBMVC5W.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  lane_ledger_write
-} from "./chunk-KIS7JFNP.js";
-import {
-  lane_child_marker
-} from "./chunk-XXPDFJRI.js";
-
-// scripts/split/split-resolution.ts
-var NOTICE_SECTION = `split-assessment.md \u2192 "${split_assess.NOTICE_SECTION}"`;
-function is_split_clear({ route, found_during }) {
-  const marked = lane_child_marker.marked_issue();
-  const finder = found_during ?? marked;
-  if (route !== SPLIT_ROUTE_LABEL || finder === void 0 || finder !== marked) return true;
-  console.error(
-    `refused: ${session_cite.issue(finder)} is a dispatched lane, which is never split \u2014 finish it; file an independent new requirement without \`--route split\` (${NOTICE_SECTION}).`
-  );
-  return false;
-}
-function is_notice(entry) {
-  return entry.kind === lane_ledger.KIND.SPLIT_NOTICE;
-}
-function is_split_child(entry) {
-  return entry.kind === lane_ledger.KIND.SPLIT_FILED;
-}
-function notices(entries) {
-  return entries.filter((entry) => is_notice(entry));
-}
-function split_issues(entries) {
-  return new Set(entries.filter((entry) => is_split_child(entry)).map((entry) => entry.issue));
-}
-async function record_child({ route, found_during, child }) {
-  if (route !== SPLIT_ROUTE_LABEL || found_during === void 0) return;
-  try {
-    await lane_ledger_write.record_split_filed({ issue: Number(found_during), child });
-  } catch (error) {
-    throw new Error(
-      `Created ${child}, but split-child evidence could not be recorded. Do not create another child. Recover with \`pnpm josh split:recover ${found_during} ${child}\`.`,
-      { cause: error }
-    );
-  }
-}
-async function record_fold({ origin, target }) {
-  try {
-    await lane_ledger_write.record_split_filed({
-      issue: Number(origin),
-      child: issue_cite.plain_for("program", target)
-    });
-  } catch (error) {
-    throw new Error(
-      `Folded into ${session_cite.issue(target)}, but split-child evidence for ${session_cite.issue(origin)} could not be recorded: ${error_text.message_of(error)}`,
-      { cause: error }
-    );
-  }
-}
-var split_resolution = {
-  is_split_clear,
-  notices,
-  record_child,
-  record_fold,
-  split_issues
-};
-
-export {
-  split_resolution
-};

package/dist/commands/chunk-MRW2WYJS.js

@@ -1,68 +0,0 @@
-import {
-  plan_consumers_section
-} from "./chunk-SRG6PKVS.js";
-import {
-  backlog_overlap,
-  lane_plan
-} from "./chunk-MDGPJOLK.js";
-import {
-  issue_read
-} from "./chunk-3F3RNIG2.js";
-import {
-  markdown_section
-} from "./chunk-JZK33TA5.js";
-import {
-  git_gh_issue_read
-} from "./chunk-TFYYXETQ.js";
-import {
-  PLANNED_LABEL,
-  has_any_label
-} from "./chunk-QQBMVC5W.js";
-import {
-  bounded_pool
-} from "./chunk-EBVS2LKX.js";
-
-// scripts/backlog/backlog-plan-comment.ts
-var PLANNED = /* @__PURE__ */ new Set([PLANNED_LABEL]);
-var READ_CONCURRENCY = 8;
-function is_plan(comment) {
-  return comment.is_trusted === true && markdown_section.has_line(comment.body, plan_consumers_section.HEADING);
-}
-function plan_body(comment) {
-  return comment === void 0 ? void 0 : plan_consumers_section.without(comment.body);
-}
-function plan_of(comments) {
-  return plan_body(comments.findLast((comment) => is_plan(comment)));
-}
-async function read_plan_comment(issue) {
-  const json = await git_gh_issue_read.issue_list_comments(String(issue));
-  const comments = await issue_read.parse_comments(json);
-  return comments?.findLast((comment) => is_plan(comment));
-}
-async function read_plan(issue) {
-  return plan_body(await read_plan_comment(issue));
-}
-async function plan_paths(issue) {
-  return [...backlog_overlap.declared_paths(await read_plan(issue) ?? "")];
-}
-async function with_plan(issue) {
-  if (!has_any_label(issue.labels, PLANNED)) return issue;
-  const comment = await read_plan_comment(issue.number);
-  const plan = plan_body(comment);
-  if (plan === void 0 || backlog_overlap.declared_paths(plan).size === 0) return issue;
-  return { ...issue, body: plan, commented_at: comment?.created_at };
-}
-function commented_of(planned) {
-  const dated = planned.filter((issue) => issue.commented_at !== void 0);
-  return new Map(dated.map((issue) => [issue.number, issue.commented_at ?? ""]));
-}
-async function declared_of(issues, directory) {
-  const planned = await bounded_pool.bounded_map(issues, READ_CONCURRENCY, with_plan);
-  const declared = backlog_overlap.declared_of(planned);
-  return lane_plan.with_plans(declared, directory, commented_of(planned));
-}
-var backlog_plan_comment = { declared_of, plan_of, plan_paths, read_plan };
-
-export {
-  backlog_plan_comment
-};

package/dist/commands/chunk-N2XH7QBY.js

@@ -1,103 +0,0 @@
-import {
-  run_cut
-} from "./chunk-TFDVTU6O.js";
-import {
-  RUN_STALLED_LABEL
-} from "./chunk-QQBMVC5W.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-
-// scripts/run/park/run-stalled.ts
-var SESSION_UNFINISHED = {
-  short: "session unfinished",
-  why: "the child\u2019s session ended with its issue still open and unfinished."
-};
-var CUT_NOT_RELAUNCHED = {
-  short: "cut not relaunched",
-  why: "its lane held a declared cut, but no successor could be relaunched from it (or it already was once)."
-};
-var STALE_HANDOFF = {
-  short: "stale hand-off",
-  why: "the child stopped at `resume: handed-off` because an old hand-off cut record was already adopted."
-};
-var RESUME_COMMAND = "fullrun";
-var CAUSE_LEAD = `${RUN_STALLED_LABEL}: `;
-function resume_of(child, is_backlog_live = false) {
-  return is_backlog_live ? `pnpm josh run:add ${String(child)} --retry` : `${RESUME_COMMAND} ${issue_cite.plain_for("program", child)}`;
-}
-function recovery_of(cause) {
-  if (cause === STALE_HANDOFF.why) {
-    return `repair the stale hand-off cut record with \`${run_cut.END_COMMAND}\` (retry alone does not clear it)`;
-  }
-  return /cut.*(?:handed-off|already handed off)/iu.test(cause) ? `clear the handed-off cut with \`${run_cut.END_COMMAND}\`` : "fix the cause";
-}
-function next_step(child, cause = "") {
-  const recovery = recovery_of(cause);
-  return `${recovery}, then use \`${resume_of(child, true)}\` in the live backlogrun or resume it with \`${resume_of(child, false)}\``;
-}
-var ESCALATION_REQUESTED = {
-  short: "escalation requested",
-  why: "the worker declared that its Issue needs a stronger josh.worker profile."
-};
-var CARRYING_CLASSES = [SESSION_UNFINISHED, ESCALATION_REQUESTED];
-function lead_of(cause) {
-  return `${cause.short}: `;
-}
-function carrying(cause, message) {
-  const first = message.split(/\r?\n/u, 1)[0]?.trim() ?? "";
-  return first === "" ? cause : { short: `${lead_of(cause)}${first}`, why: first };
-}
-function session_unfinished(message) {
-  return carrying(SESSION_UNFINISHED, message);
-}
-function escalation_requested(reason) {
-  return carrying(ESCALATION_REQUESTED, reason);
-}
-function class_of(cause) {
-  const carried = CARRYING_CLASSES.find((known) => cause.startsWith(lead_of(known)));
-  return carried?.short ?? cause;
-}
-function park_event(child, cause) {
-  return `${issue_cite.plain_for("program", child)} parked (${CAUSE_LEAD}${cause})`;
-}
-function cause_of(reason) {
-  if (reason === RUN_STALLED_LABEL) return "";
-  return reason.startsWith(CAUSE_LEAD) ? reason.slice(CAUSE_LEAD.length) : void 0;
-}
-function cause_in(text) {
-  const lead = ` parked (${CAUSE_LEAD}`;
-  const start = text.indexOf(lead);
-  return start === -1 || !text.endsWith(")") ? void 0 : text.slice(start + lead.length, -1);
-}
-function stop_of(event) {
-  return event.stop;
-}
-function row_text(child, cause = "", is_backlog_live = false) {
-  const resume = `\u2192 resume: ${resume_of(child, is_backlog_live)}`;
-  return cause === "" ? resume : `${resume} (${cause})`;
-}
-function waiting_text(waits) {
-  return `waiting on ${waits.map((wait) => wait.includes("#") ? wait : issue_cite.plain_for("program", wait)).join(", ")}`;
-}
-var run_stalled = {
-  CUT_NOT_RELAUNCHED,
-  ESCALATION_REQUESTED,
-  SESSION_UNFINISHED,
-  STALE_HANDOFF,
-  cause_in,
-  cause_of,
-  class_of,
-  escalation_requested,
-  next_step,
-  park_event,
-  resume_of,
-  row_text,
-  session_unfinished,
-  stop_of,
-  waiting_text
-};
-
-export {
-  run_stalled
-};