@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-SZG5HDNP.js

@@ -1,321 +0,0 @@
-import {
-  bash_output_cap_reader
-} from "./chunk-JFLFGLE4.js";
-import {
-  cost_tokens,
-  lane_instructions
-} from "./chunk-Y4EBUI6M.js";
-import {
-  document_section
-} from "./chunk-NDWZTWXV.js";
-import {
-  PACKAGE_DIR
-} from "./chunk-3CCGKX7Y.js";
-
-// scripts/document/entry-read-set.ts
-import { existsSync } from "node:fs";
-import path from "node:path";
-
-// scripts/document/read-set-cost.ts
-var NOTHING = 0;
-var ONE_LINE = 1;
-function cost_of(text) {
-  return { bytes: Buffer.byteLength(text, "utf8"), tokens: cost_tokens.estimate(text) };
-}
-function total(costs) {
-  const running = { bytes: NOTHING, tokens: NOTHING };
-  for (const cost of costs) {
-    running.bytes += cost.bytes;
-    running.tokens += cost.tokens;
-  }
-  return running;
-}
-function add_range(charged, found) {
-  for (let index = found.first_line; index <= found.last_line; index += ONE_LINE) charged.add(index);
-}
-function charged_lines(markdown, headings) {
-  const charged = /* @__PURE__ */ new Set();
-  for (const heading of headings) {
-    const found = document_section.section(markdown, heading);
-    if (found === void 0) return void 0;
-    add_range(charged, found);
-  }
-  return charged;
-}
-function extend_or_start(runs, index) {
-  const current = runs.at(-1);
-  if (current?.at(-1) === index - ONE_LINE) current.push(index);
-  else runs.push([index]);
-}
-function contiguous_runs(charged) {
-  const runs = [];
-  const ascending = [...charged].toSorted((left, right) => left - right);
-  for (const index of ascending) extend_or_start(runs, index);
-  return runs;
-}
-function run_text(lines, run) {
-  return run.map((index) => lines[index] ?? "").join("\n");
-}
-function scoped_file_cost(markdown, headings) {
-  const charged = charged_lines(markdown, headings);
-  if (charged === void 0) return cost_of(markdown);
-  const lines = markdown.split("\n");
-  return total(contiguous_runs(charged).map((run) => cost_of(run_text(lines, run))));
-}
-var read_set_cost = { cost_of, scoped_file_cost, total };
-
-// scripts/document/read-set-point-of-use.ts
-var POINT_OF_USE_FILES = /* @__PURE__ */ new Set([
-  "latest-gate.md",
-  "followup.md",
-  "chain-rule.md",
-  "background-commands.md",
-  "pre-gate-cut.md",
-  "progress-watcher.md",
-  "backlogrun-child.md",
-  "backlogrun-lanes.md",
-  "backlogrun-progress.md",
-  "backlogrun-park.md",
-  "backlogrun-steps.md",
-  // Read only when a delegated unit goes silent or a lane's pull request conflicts with `main` — a
-  // failure path, so a run in which nothing fails never reads it.
-  "backlogrun-recovery.md",
-  // Read only when `run:step` prints `pnpm josh retrospective` at a run's stop position — the very
-  // end of a run, never the entry. Kept out of every entry's read for the
-  // same reason the phase documents above are: no run that never drains its backlog reaches it.
-  "retrospective.md"
-]);
-var DEFERRED_DECISIONS = /* @__PURE__ */ new Set(["delegation.md", "issue-scout.md"]);
-var SPLIT_ASSESSMENT = "split-assessment.md";
-var POINT_OF_USE_BY_ENTRY = /* @__PURE__ */ new Map([
-  ["kickoff", DEFERRED_DECISIONS],
-  ["fullrun", DEFERRED_DECISIONS],
-  ["halfrun", DEFERRED_DECISIONS],
-  ["prrun", DEFERRED_DECISIONS],
-  ["backlogrun", /* @__PURE__ */ new Set([...DEFERRED_DECISIONS, "fullrun.md", SPLIT_ASSESSMENT])],
-  ["lane-child", /* @__PURE__ */ new Set([SPLIT_ASSESSMENT])]
-]);
-var NO_PER_ENTRY_FILES = /* @__PURE__ */ new Set();
-function is_point_of_use(entry, file) {
-  if (POINT_OF_USE_FILES.has(file)) return true;
-  return (POINT_OF_USE_BY_ENTRY.get(entry) ?? NO_PER_ENTRY_FILES).has(file);
-}
-function point_of_use_files(entry, cited) {
-  const reached = [...POINT_OF_USE_FILES].filter((file) => cited.has(file));
-  return [...reached, ...POINT_OF_USE_BY_ENTRY.get(entry) ?? NO_PER_ENTRY_FILES];
-}
-var read_set_point_of_use = {
-  POINT_OF_USE_FILES,
-  POINT_OF_USE_BY_ENTRY,
-  is_point_of_use,
-  point_of_use_files
-};
-
-// scripts/document/entry-read-set.ts
-var { POINT_OF_USE_FILES: POINT_OF_USE_FILES2, POINT_OF_USE_BY_ENTRY: POINT_OF_USE_BY_ENTRY2, is_point_of_use: is_point_of_use2, point_of_use_files: point_of_use_files2 } = read_set_point_of_use;
-var { cost_of: cost_of2, scoped_file_cost: scoped_file_cost2, total: total2 } = read_set_cost;
-var SKILL_DIRECTORY = path.join(".claude", "skills", "workflow-commands");
-var SKILL_FILE = "SKILL.md";
-var LANE_CHILD = "lane-child";
-var TABLE_SECTION = "1. Which file to read";
-var NOTHING2 = 0;
-var HEADING_JOINER = '" + "';
-var SUBSECTION_PREFIX = "### ";
-var TABLE_ROW = /^\|(?<entry>[^|]+)\|(?<files>[^|]+)\|\s*$/u;
-var MARKDOWN_NAME = /`(?<name>[\w.-]+\.md)`/gu;
-var ENTRY_KEYWORD = /`(?<keyword>[a-z]+)/u;
-var SECTION_REFERENCE = /`(?<file>[\w.-]+\.md)` *→ *"(?<heading>[^"]+)"/gu;
-var WHITESPACE_RUN = /\s+/gu;
-function document_path(root, name) {
-  const in_project = path.join(root, SKILL_DIRECTORY, name);
-  const in_package = path.join(PACKAGE_DIR, SKILL_DIRECTORY, name);
-  const project_manifest = path.join(root, "package.json");
-  if (root !== "" && existsSync(project_manifest) && existsSync(in_package)) return in_package;
-  return existsSync(in_project) ? in_project : in_package;
-}
-function read_document(root, name) {
-  return document_section.read_optional(document_path(root, name)) ?? "";
-}
-function unique(names) {
-  return [...new Set(names)];
-}
-function all_matches(text, pattern) {
-  const scanner = new RegExp(pattern.source, pattern.flags);
-  const found = [];
-  let match = scanner.exec(text);
-  while (match !== null) {
-    found.push(match);
-    match = scanner.exec(text);
-  }
-  return found;
-}
-function group_of(match, name) {
-  return match.groups?.[name] ?? "";
-}
-function names_in(text) {
-  return all_matches(text, MARKDOWN_NAME).map((match) => group_of(match, "name"));
-}
-function columns_of(line) {
-  const groups = TABLE_ROW.exec(line)?.groups;
-  if (groups === void 0) return void 0;
-  const { entry = "", files = "" } = groups;
-  return { entry, files };
-}
-function to_row(line) {
-  const columns = columns_of(line);
-  if (columns === void 0) return void 0;
-  const { keyword } = ENTRY_KEYWORD.exec(columns.entry)?.groups ?? {};
-  return keyword === void 0 ? void 0 : { keyword, files: names_in(columns.files) };
-}
-function push_row(rows, line) {
-  const row = to_row(line);
-  if (row !== void 0 && row.files.length > NOTHING2) rows.set(row.keyword, row.files);
-}
-function table_rows(root) {
-  const rows = /* @__PURE__ */ new Map();
-  const found = document_section.section(read_document(root, SKILL_FILE), TABLE_SECTION);
-  const lines = (found?.text ?? "").split("\n");
-  for (const line of lines) {
-    if (line.startsWith(SUBSECTION_PREFIX)) break;
-    push_row(rows, line);
-  }
-  return rows;
-}
-function files_for(root, entry) {
-  if (entry === LANE_CHILD) return [path.basename(lane_instructions.WORKFLOW_ENTRY)];
-  const declared = table_rows(root).get(entry) ?? [];
-  return unique([SKILL_FILE, ...declared]).filter((file) => !is_point_of_use2(entry, file));
-}
-function fold(text) {
-  return text.replaceAll(WHITESPACE_RUN, " ").trim();
-}
-function is_sibling_document(root, name) {
-  return document_section.read_optional(document_path(root, name)) !== void 0;
-}
-function is_counted(root, entry, reference, files) {
-  if (is_point_of_use2(entry, reference.file)) return false;
-  return !files.includes(reference.file) && is_sibling_document(root, reference.file);
-}
-function to_reference(match) {
-  return { file: group_of(match, "file"), heading: fold(group_of(match, "heading")) };
-}
-function references_from(root, entry, text, files) {
-  return all_matches(text, SECTION_REFERENCE).map((match) => to_reference(match)).filter((reference) => is_counted(root, entry, reference, files));
-}
-function sort_key(reference) {
-  return `${reference.file} ${reference.heading}`;
-}
-function dedupe(references) {
-  const seen = /* @__PURE__ */ new Map();
-  for (const reference of references) seen.set(sort_key(reference), reference);
-  return [...seen].map(([, reference]) => reference);
-}
-function sections_for(root, entry, files) {
-  const found = files.filter((file) => file !== SKILL_FILE).flatMap((file) => references_from(root, entry, read_document(root, file), files));
-  return dedupe(found).toSorted((left, right) => sort_key(left).localeCompare(sort_key(right)));
-}
-function read_set(root, entry) {
-  const files = files_for(root, entry);
-  return { entry, files, sections: sections_for(root, entry, files) };
-}
-function section_cost(root, reference) {
-  const found = document_section.section(read_document(root, reference.file), reference.heading);
-  return {
-    ...reference,
-    // **An unresolvable reference is charged at the whole file.** Reporting it at zero would let a
-    // broken pointer read as a saving, which is the one direction this measurement must not move.
-    cost: cost_of2(found?.text ?? read_document(root, reference.file)),
-    is_resolved: found !== void 0
-  };
-}
-function referenced_cost(root, sections) {
-  const files = unique(sections.map((reference) => reference.file));
-  return total2(files.map((file) => cost_of2(read_document(root, file))));
-}
-function headings_for(sections, file) {
-  return sections.filter((reference) => reference.file === file).map((one) => one.heading);
-}
-function scoped_cost(root, sections) {
-  const files = unique(sections.map((reference) => reference.file));
-  return total2(
-    files.map((file) => scoped_file_cost2(read_document(root, file), headings_for(sections, file)))
-  );
-}
-function file_costs(root, names) {
-  return names.map((file) => ({ file, cost: cost_of2(read_document(root, file)) }));
-}
-function point_of_use_cost(root, file, references) {
-  const markdown = read_document(root, file);
-  const headings = unique(references.filter((one) => one.file === file).map((one) => one.heading));
-  if (headings.length === NOTHING2) {
-    return { file, heading: "", cost: cost_of2(markdown), is_resolved: true };
-  }
-  return {
-    file,
-    heading: headings.join(HEADING_JOINER),
-    cost: scoped_file_cost2(markdown, headings),
-    is_resolved: headings.every(
-      (heading) => document_section.section(markdown, heading) !== void 0
-    )
-  };
-}
-function path_texts(root, entry, table_text) {
-  const manifests = files_for(root, entry).filter((file) => file !== SKILL_FILE);
-  const rows = table_text.split("\n").filter((line) => line.startsWith("|") && line.includes(`\`${entry}\``));
-  return [...manifests.map((file) => read_document(root, file)), ...rows];
-}
-function point_of_use_references(root, entry, table_text) {
-  const manifests = files_for(root, entry).filter((file) => file !== SKILL_FILE);
-  const texts = [table_text, ...manifests.map((file) => read_document(root, file))];
-  return texts.flatMap(
-    (text) => all_matches(text, SECTION_REFERENCE).map((match) => to_reference(match))
-  );
-}
-function entry_table_text(root) {
-  return document_section.section(read_document(root, SKILL_FILE), TABLE_SECTION)?.text ?? "";
-}
-function point_of_use_costs(root, entry, also) {
-  const table_text = entry === LANE_CHILD ? "" : entry_table_text(root);
-  const references = point_of_use_references(root, entry, table_text);
-  const named = path_texts(root, entry, table_text).flatMap((text) => names_in(text));
-  const cited = /* @__PURE__ */ new Set([...also, ...named]);
-  return point_of_use_files2(entry, cited).map((file) => point_of_use_cost(root, file, references));
-}
-function costed(root, entry, also = /* @__PURE__ */ new Set()) {
-  const { files, sections } = read_set(root, entry);
-  const own_costs = file_costs(root, files);
-  const section_costs = sections.map((reference) => section_cost(root, reference));
-  const own = total2(own_costs.map((row) => row.cost));
-  return {
-    entry,
-    files: own_costs,
-    sections: section_costs,
-    point_of_use: point_of_use_costs(root, entry, also),
-    bash_output_cap: bash_output_cap_reader.bash_output_cap(root),
-    whole: total2([own, referenced_cost(root, sections)]),
-    scoped: total2([own, scoped_cost(root, sections)])
-  };
-}
-function entries(root) {
-  return [...table_rows(root)].map(([keyword]) => keyword);
-}
-var entry_read_set = {
-  HARNESS_DEFAULT_CAP_CHARS: bash_output_cap_reader.HARNESS_DEFAULT_CAP_CHARS,
-  POINT_OF_USE_BY_ENTRY: POINT_OF_USE_BY_ENTRY2,
-  POINT_OF_USE_FILES: POINT_OF_USE_FILES2,
-  SECTION_REFERENCE,
-  SKILL_DIRECTORY,
-  SKILL_FILE,
-  TABLE_SECTION,
-  bash_output_cap: bash_output_cap_reader.bash_output_cap,
-  cost_of: cost_of2,
-  costed,
-  document_path,
-  entries,
-  read_set,
-  total: total2
-};
-
-export {
-  entry_read_set
-};

package/dist/commands/chunk-T25S4QHL.js

@@ -1,52 +0,0 @@
-import {
-  git_spawn
-} from "./chunk-CJKPF5DJ.js";
-import {
-  get_exit_code
-} from "./chunk-VJE3RJAX.js";
-
-// scripts/git/git-grep-hits.ts
-var GREP_LINE = /^(?<path>[^:]+):(?<line>\d+):(?<text>.*)$/u;
-var MAX_EXCERPT_LENGTH = 80;
-var ELLIPSIS = "\u2026";
-var GREP_NO_MATCH_EXIT = 1;
-function shorten(text) {
-  const trimmed = text.trim();
-  if (trimmed.length <= MAX_EXCERPT_LENGTH) return trimmed;
-  return `${trimmed.slice(0, MAX_EXCERPT_LENGTH)}${ELLIPSIS}`;
-}
-function to_hit(output_line) {
-  const groups = GREP_LINE.exec(output_line)?.groups;
-  if (groups === void 0) return void 0;
-  const { path, line, text } = groups;
-  return { path, line, excerpt: shorten(text) };
-}
-function parse(stdout) {
-  const hits = stdout.split("\n").map((line) => to_hit(line));
-  return hits.filter((hit) => hit !== void 0);
-}
-async function search(target, flags, pathspecs, root) {
-  const location = root === void 0 ? [] : ["-C", root];
-  const grep_arguments = [
-    ...location,
-    "grep",
-    "-n",
-    "-I",
-    "-F",
-    ...flags,
-    "-e",
-    target,
-    "--",
-    ...pathspecs
-  ];
-  try {
-    return { hits: parse(await git_spawn.read(grep_arguments)), has_failed: false };
-  } catch (error) {
-    return { hits: [], has_failed: get_exit_code(error) !== GREP_NO_MATCH_EXIT };
-  }
-}
-var git_grep_hits = { parse, search };
-
-export {
-  git_grep_hits
-};

package/dist/commands/chunk-T4F33UKZ.js

@@ -1,114 +0,0 @@
-import {
-  git_followup_label
-} from "./chunk-6RUWU2SB.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  run_ship_lap
-} from "./chunk-PE7B7242.js";
-import {
-  resolve_tsx_runner
-} from "./chunk-CBAKBWSZ.js";
-import {
-  detached_launch
-} from "./chunk-C2SEDMZ3.js";
-import {
-  IN_PROGRESS_LABEL,
-  NEEDS_HUMAN_MERGE_LABEL
-} from "./chunk-QQBMVC5W.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  package_path
-} from "./chunk-3CCGKX7Y.js";
-import {
-  MS_PER_MINUTE
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/run/run-maintenance.ts
-import { execa } from "execa";
-var LABEL_SCRIPT = "scripts/run/run-label-main.ts";
-var SWEEP_SCRIPT = "scripts/run/tidy/run-tidy-main.ts";
-var HOLD_PARENT = "run:entry \u203A run:hold";
-function argv(script, args) {
-  const runner = resolve_tsx_runner();
-  return {
-    command: runner.executable,
-    args: [...runner.leading_arguments, package_path(script), ...args]
-  };
-}
-function background(script, args, prefix) {
-  const log_path = stamp_file.stamp_path(prefix, process.cwd(), ".log");
-  const result = detached_launch.launch(
-    {
-      argv: argv(script, args),
-      cwd: process.cwd(),
-      log_path,
-      env: run_ship_lap.environment(HOLD_PARENT)
-    },
-    console.warn
-  );
-  const state = result.kind === "failed" ? result.note : `pid ${String(result.pid)}`;
-  console.warn(`run maintenance: ${result.kind} (${state}) \u2014 ${log_path}`);
-}
-async function label(issue) {
-  const command = argv(LABEL_SCRIPT, [issue]);
-  const result = await execa(command.command, command.args, {
-    reject: false,
-    timeout: MS_PER_MINUTE
-  });
-  if (result.exitCode === 0) return true;
-  console.warn(
-    `run label: ${result.timedOut ? "60s timeout" : "failed"}; retry queued for ${session_cite.issue(issue)}`
-  );
-  background(LABEL_SCRIPT, [issue, "--retry"], `josh-run-label-retry-${issue}-`);
-  return false;
-}
-function sweep() {
-  background(SWEEP_SCRIPT, [], "josh-run-sweep-");
-}
-var run_maintenance = { label, sweep };
-
-// scripts/run/run-label.ts
-var MARK_RECOVERY = "gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=in-progress'";
-var UNMARK_RECOVERY = "gh api -X DELETE repos/{owner}/{repo}/issues/<N>/labels/in-progress";
-var PARK_RECOVERY = "gh api -X DELETE repos/{owner}/{repo}/issues/<N>/labels/needs-human-merge";
-function warn(action, issue, recovery, label2 = IN_PROGRESS_LABEL) {
-  console.warn(
-    `\u26A0 could not ${action} \`${label2}\` on ${session_cite.issue(issue)} \u2014 run by hand: ${recovery}`
-  );
-}
-async function mark(issue) {
-  const is_marked = await run_maintenance.label(issue);
-  if (!is_marked) warn("apply", issue, MARK_RECOVERY);
-  return is_marked;
-}
-async function unmark(issue) {
-  try {
-    await git_followup_label.strip_in_progress(issue);
-    return true;
-  } catch {
-    warn("remove", issue, UNMARK_RECOVERY);
-    return false;
-  }
-}
-async function claim(issue) {
-  const is_cleared = await git_gh_command.issue_clear_label(issue, NEEDS_HUMAN_MERGE_LABEL);
-  if (!is_cleared) warn("remove", issue, PARK_RECOVERY, NEEDS_HUMAN_MERGE_LABEL);
-  return await git_gh_command.issue_apply_label(issue, IN_PROGRESS_LABEL);
-}
-var run_label = {
-  claim,
-  mark,
-  unmark
-};
-
-export {
-  run_maintenance,
-  run_label
-};

package/dist/commands/chunk-T4UYEHWG.js

@@ -1,50 +0,0 @@
-import {
-  issue_number_shape
-} from "./chunk-66NX6EXR.js";
-
-// scripts/run/handoff/run-handoff-args.ts
-var BRIEF_FLAG = "--brief-file";
-var BACKLOG_KEYWORD = "backlogrun";
-var NOT_FOUND = -1;
-var FLAG_AND_VALUE = 2;
-var RETROSPECTIVE_KEYWORD = "retrospective";
-var TYPED_KEYWORDS = ["kickoff", "fullrun", "halfrun", "prrun"];
-var WORKFLOW_KEYWORDS = [...TYPED_KEYWORDS, RETROSPECTIVE_KEYWORD];
-var KEYWORDS = [...TYPED_KEYWORDS, BACKLOG_KEYWORD];
-var WORKFLOW_KEYWORD_TOKENS = WORKFLOW_KEYWORDS;
-function is_workflow_keyword(token) {
-  return WORKFLOW_KEYWORD_TOKENS.includes(token);
-}
-function refused(note) {
-  return { kind: "refused", note };
-}
-function workflow_of(keyword, rest) {
-  const at = rest.indexOf(BRIEF_FLAG);
-  const brief_file = at === NOT_FOUND ? void 0 : rest[at + 1];
-  if (brief_file === void 0 || brief_file.startsWith("-")) {
-    return refused(`${keyword} needs ${BRIEF_FLAG} <path>`);
-  }
-  const entry = [...rest.slice(0, at), ...rest.slice(at + FLAG_AND_VALUE)];
-  if (entry.includes(BRIEF_FLAG)) return refused(`${BRIEF_FLAG} is given more than once`);
-  const line = [keyword, ...entry.map((token) => issue_number_shape.issue_token(token))].join(" ");
-  return { kind: "workflow", keyword, line, brief_file };
-}
-function retrospective_of(rest) {
-  if (rest.length > 0) return refused(`${RETROSPECTIVE_KEYWORD} takes no other argument`);
-  const keyword = RETROSPECTIVE_KEYWORD;
-  return { kind: "workflow", keyword, line: keyword, brief_file: void 0 };
-}
-function parse(argv) {
-  const [keyword, ...rest] = argv;
-  if (keyword === BACKLOG_KEYWORD) return { kind: "backlogrun", rest };
-  if (keyword === RETROSPECTIVE_KEYWORD) return retrospective_of(rest);
-  if (!is_workflow_keyword(keyword)) {
-    return refused(`expected one of ${WORKFLOW_KEYWORDS.join(", ")}, ${BACKLOG_KEYWORD}`);
-  }
-  return workflow_of(keyword, rest);
-}
-var run_handoff_args = { BACKLOG_KEYWORD, KEYWORDS, RETROSPECTIVE_KEYWORD, parse };
-
-export {
-  run_handoff_args
-};

package/dist/commands/chunk-TAEGXID2.js

@@ -1,58 +0,0 @@
-import {
-  git_issue
-} from "./chunk-HI5WPM6C.js";
-import {
-  lane_plan
-} from "./chunk-B7ZNIEDV.js";
-import {
-  git_branch
-} from "./chunk-Q5Q2QYVU.js";
-import {
-  test_declared_logic
-} from "./chunk-7HCPRVMB.js";
-import {
-  changed_paths
-} from "./chunk-V5FD7DVV.js";
-
-// scripts/run/ship/run-ship-planned.ts
-import path from "node:path";
-var PRECONDITION = "unplanned";
-var SEPARATOR = "/";
-var NON_CODE_PREFIXES = ["docs/", ".josh/"];
-var CODE_EXTENSIONS = /* @__PURE__ */ new Set([".cjs", ".js", ".mjs", ".sh", ".svelte", ".ts"]);
-function is_planned(claims, file) {
-  return claims.some(
-    (claim) => claim.endsWith(SEPARATOR) ? file.startsWith(claim) : claim === file
-  );
-}
-function is_code(file) {
-  return CODE_EXTENSIONS.has(path.extname(file)) && NON_CODE_PREFIXES.every((prefix) => !file.startsWith(prefix));
-}
-function unplanned_of(claims, changed) {
-  return test_declared_logic.runtime_files(changed).filter((file) => is_code(file) && !is_planned(claims, file));
-}
-function problem_text(issue, claims, files) {
-  const replan = ["pnpm josh lane:plan", issue, ...claims, ...files].join(" ");
-  return `unplanned: ${files.join(", ")} \u2014 the lane's lane:plan record does not list these code files. In scope: run \`${replan}\` and comment the reason on the Issue in one line, then re-detach; if it answers \`yield\` or \`split\`, follow what it prints instead. Out of scope: revert the change and file it with \`pnpm josh issue:file\`.`;
-}
-function held_claims(plan) {
-  return plan?.yielded === true ? void 0 : plan?.paths;
-}
-async function unplanned() {
-  const issue = git_issue.branch_number(await git_branch.current());
-  if (issue === void 0) return void 0;
-  const claims = held_claims(lane_plan.read(Number(issue), process.cwd()));
-  if (claims === void 0) return void 0;
-  const files = unplanned_of(claims, await changed_paths.read_changed_paths(false));
-  if (files.length === 0) return void 0;
-  return { issue: Number(issue), files, text: problem_text(issue, claims, files) };
-}
-async function problems() {
-  const found = await unplanned();
-  return found === void 0 ? [] : [found.text];
-}
-var run_ship_planned = { PRECONDITION, problems, unplanned, unplanned_of };
-
-export {
-  run_ship_planned
-};