@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-ZMWL7LZM.js

@@ -0,0 +1,210 @@
+import {
+  time_bundle_call,
+  time_bundles,
+  time_spans
+} from "./chunk-NXWVWI4U.js";
+import {
+  time_transcript_line
+} from "./chunk-ZW6DLYS4.js";
+import {
+  time_shell
+} from "./chunk-LHKXJD6L.js";
+
+// scripts/time-runtime/time-command-key.ts
+var UNNAMED_KEY = "";
+function command_key(span) {
+  if (span.label === time_spans.UNKNOWN_TOOL) return UNNAMED_KEY;
+  return span.josh_command === "" ? span.label : span.josh_command;
+}
+var time_command_key = { UNNAMED_KEY, command_key };
+
+// scripts/time-runtime/time-call-identity.ts
+var IDENTITY_SEPARATOR = "\0";
+function identity_of(call) {
+  return [
+    time_command_key.command_key(call),
+    call.check_key,
+    [...call.targets].toSorted((left, right) => left.localeCompare(right)).join(",")
+  ].join(IDENTITY_SEPARATOR);
+}
+var time_call_identity = { identity_of };
+
+// scripts/time-runtime/time-search-call.ts
+var SEARCH_COMMANDS = ["fd", "find", "grep", "rg"];
+var SEARCH_LABELS = new Set(
+  SEARCH_COMMANDS.map((command) => time_shell.bash_label(command))
+);
+var CHAIN_COMMANDS = [...SEARCH_COMMANDS, "sed"];
+var CHAIN_LABELS = new Set(
+  CHAIN_COMMANDS.map((command) => time_shell.bash_label(command))
+);
+function is_read_only_search(call) {
+  return SEARCH_LABELS.has(call.label) && call.is_bundleable && !call.may_write;
+}
+function is_search_chain_call(call) {
+  return CHAIN_LABELS.has(call.label) && call.is_bundleable && !call.is_writing;
+}
+var time_search_call = {
+  is_read_only_search,
+  is_search_chain_call
+};
+
+// scripts/time-runtime/time-batch-guard.ts
+var CONSECUTIVE_LIMIT = 3;
+var REFIRE_EVERY = CONSECUTIVE_LIMIT;
+var ONE_TURN = 1;
+var NONE = 0;
+var NOTICE_REFIRE_EVERY = ONE_TURN;
+var NAMED_CANDIDATE_COUNT = 3;
+var SEQUENCE_BEFORE_LIMIT = CONSECUTIVE_LIMIT - ONE_TURN;
+var RULE_POINTER = "`prompts/collaboration-workflow/turn-batching.md`";
+var STREAK = `${String(CONSECUTIVE_LIMIT)} single-call turns in a row`;
+var REASON = `\u26D4 batching: ${STREAK}. Reissue this with the calls that do not need its result \u2014 the test is whether a call's input needs another call's result, not what kind of call it is (edits are covered exactly as reads); it never authorizes weakening a verification gate or a review. Nothing to pair? Reissue it unchanged. ${RULE_POINTER}`;
+var NOTICE = `\u{1F4A1} batching: ${STREAK}; the Write proceeds. Issue the writes that do not need its result in one turn, never by weakening a gate or a review. ${RULE_POINTER}`;
+var LANE_NOTICE = `\u{1F4A1} batching: ${STREAK}; the call proceeds. Pair independent calls. ${RULE_POINTER}`;
+var WHOLE_FILE_WRITE_TOOL = "Write";
+var EDIT_TOOL = "Edit";
+function is_guarded_call(call) {
+  if (call.name === WHOLE_FILE_WRITE_TOOL) return false;
+  return time_bundle_call.call_facts(call.name, call.input).is_bundleable;
+}
+function is_notice_call(call) {
+  return call.name === WHOLE_FILE_WRITE_TOOL;
+}
+function is_read_only_call(call) {
+  const facts = time_bundle_call.call_facts(call.name, call.input);
+  return facts.is_bundleable && !facts.may_write;
+}
+function depends_on_sequence(sequence, facts) {
+  return sequence.some((span) => time_bundles.shares_target(span.targets, facts.targets));
+}
+function sequence_started_ms(sequence) {
+  return sequence[0]?.ended_ms ?? NONE;
+}
+function turns_since(sequence, last_fired_ms) {
+  return sequence.filter((span) => span.ended_ms > last_fired_ms).length;
+}
+function is_sequence_at_limit(sequence, facts, last_fired_ms, refire_every) {
+  if (sequence.length < SEQUENCE_BEFORE_LIMIT || depends_on_sequence(sequence, facts)) return false;
+  if (last_fired_ms < sequence_started_ms(sequence)) return true;
+  return turns_since(sequence, last_fired_ms) >= refire_every;
+}
+function is_at_limit(spans, call, last_fired_ms, refire_every) {
+  return is_sequence_at_limit(
+    time_bundles.open_sequence(spans),
+    time_bundle_call.call_facts(call.name, call.input),
+    last_fired_ms,
+    refire_every
+  );
+}
+var GUARD_LABEL = time_transcript_line.guard_from_refusal(REASON);
+function is_reissued_refusal(spans, call) {
+  const identity = time_call_identity.identity_of(
+    time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID)
+  );
+  return spans.some(
+    (span) => span.refusal_guard === GUARD_LABEL && time_call_identity.identity_of(span) === identity
+  );
+}
+function refusable_spans(text, call) {
+  if (!is_guarded_call(call)) return [];
+  const { spans } = time_spans.parse_timeline(text);
+  return is_reissued_refusal(spans, call) ? [] : spans;
+}
+function should_block(text, call, refused_at_ms, refire_every = REFIRE_EVERY) {
+  return is_at_limit(refusable_spans(text, call), call, refused_at_ms, refire_every);
+}
+function as_tool_call(call) {
+  return time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID);
+}
+function is_search_chain_call2(call) {
+  return is_guarded_call(call) && time_search_call.is_search_chain_call(as_tool_call(call));
+}
+function is_search_chain(spans, call) {
+  const recent = time_bundles.open_sequence(spans).slice(-SEQUENCE_BEFORE_LIMIT);
+  return [...recent, as_tool_call(call)].every(
+    (turn) => time_search_call.is_search_chain_call(turn)
+  );
+}
+function should_block_search_chain(text, call, refused_at_ms) {
+  const spans = refusable_spans(text, call);
+  return is_search_chain(spans, call) && is_at_limit(spans, call, refused_at_ms, REFIRE_EVERY);
+}
+function should_notify(text, call, notified_at_ms) {
+  if (!is_notice_call(call)) return false;
+  const { spans } = time_spans.parse_timeline(text);
+  return is_at_limit(spans, call, notified_at_ms, NOTICE_REFIRE_EVERY);
+}
+function describe_span(span) {
+  const target = span.targets[0] ?? "";
+  if (target === "" || span.label.includes(target)) return span.label;
+  return `${span.label} ${target}`;
+}
+var FOLD_MINIMUM = 2;
+function read_targets(sequence) {
+  const paths = sequence.filter((span) => span.is_bundleable && !span.is_writing).map((span) => span.targets[0] ?? "").filter((path) => path !== "" && time_bundle_call.has_extension(path));
+  return [...new Set(paths)];
+}
+function read_fold_directive(sequence) {
+  const paths = read_targets(sequence);
+  if (paths.length < FOLD_MINIMUM) return "";
+  return ` Fold them into one call: \`pnpm josh read:files ${paths.join(" ")}\`.`;
+}
+function write_targets(sequence) {
+  const paths = sequence.filter((span) => span.label === EDIT_TOOL).map((span) => span.targets[0] ?? "").filter((path) => path !== "" && time_bundle_call.has_extension(path));
+  return [...new Set(paths)];
+}
+function write_fold_directive(sequence) {
+  const paths = write_targets(sequence);
+  if (paths.length < FOLD_MINIMUM) return "";
+  return ` Fold them into one \`pnpm josh edit:files\` call with a plan over: ${paths.join(" ")}.`;
+}
+function name_candidates(calls) {
+  if (calls.length === NONE) return "";
+  const named = calls.map((call) => describe_span(call)).join(", ");
+  const folds = `${read_fold_directive(calls)}${write_fold_directive(calls)}`;
+  return ` Just issued one per turn, so at least these could have shared a turn: ${named}.${folds}`;
+}
+function recent_candidates(tail) {
+  return name_candidates(
+    time_bundles.open_sequence(time_spans.parse_timeline(tail).spans).slice(-NAMED_CANDIDATE_COUNT)
+  );
+}
+function pairing_candidates(tail, call) {
+  const sequence = time_bundles.open_sequence(time_spans.parse_timeline(tail).spans);
+  if (call === void 0 || sequence.length === NONE) {
+    return name_candidates(sequence.slice(-NAMED_CANDIDATE_COUNT));
+  }
+  const facts = time_bundle_call.call_facts(call.name, call.input);
+  if (!facts.is_bundleable || depends_on_sequence(sequence, facts)) return "";
+  const current = time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID);
+  return name_candidates([...sequence.slice(ONE_TURN - NAMED_CANDIDATE_COUNT), current]);
+}
+var STAMP_PREFIX = "josh-batch-guard-";
+var NOTICE_STAMP_PREFIX = "josh-batch-guard-notice-";
+var time_batch_guard = {
+  CONSECUTIVE_LIMIT,
+  GUARD_LABEL,
+  LANE_NOTICE,
+  NOTICE,
+  NOTICE_REFIRE_EVERY,
+  NOTICE_STAMP_PREFIX,
+  REASON,
+  REFIRE_EVERY,
+  SEQUENCE_BEFORE_LIMIT,
+  STAMP_PREFIX,
+  is_guarded_call,
+  is_notice_call,
+  is_read_only_call,
+  is_search_chain_call: is_search_chain_call2,
+  pairing_candidates,
+  recent_candidates,
+  should_block,
+  should_block_search_chain,
+  should_notify
+};
+
+export {
+  time_search_call,
+  time_batch_guard
+};

package/dist/commands/chunk-ZNFVJETO.js

@@ -0,0 +1,263 @@
+import {
+  git_gh_pr_read
+} from "./chunk-3PGB2RKZ.js";
+import {
+  git_stash
+} from "./chunk-5KEESWMC.js";
+import {
+  lane_registry
+} from "./chunk-KXZR7UAE.js";
+import {
+  run_hold
+} from "./chunk-NQ4D2XZY.js";
+import {
+  shell_quote
+} from "./chunk-W2IA2LV3.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/run-preflight.ts
+import { z } from "zod";
+var CLEAN_VERDICT = "clean";
+var RECLAIM_VERDICT = "reclaim";
+var RESUME_VERDICT = "resume";
+var PARK_VERDICT = "park";
+var NO_PR = "none";
+var OPEN_PR = "open";
+var MERGED_PR = "merged";
+var CLOSED_PR = "closed";
+var NO_CHILD_WORK = { branch_name: void 0, pr_state: NO_PR };
+var pr_info_schema = z.object({ state: z.string().optional() });
+var GH_PR_STATES = /* @__PURE__ */ new Map([
+  ["CLOSED", CLOSED_PR],
+  ["MERGED", MERGED_PR],
+  ["OPEN", OPEN_PR]
+]);
+var CLEAN_REASON = "Nothing was left behind: the tree is clean, HEAD is on the default branch, and this issue has no pull request and no branch holding work.";
+var CLEAN_ADVICE = "Start the child.";
+var RESUME_ADVICE = "Reuse the branch and run the whole verification gate from the start \u2014 refactor, `pnpm josh gate`, `/code-review` \u2014 never only the part the interrupted run had not reached. Nobody verified what it already committed.";
+var PARK_ADVICE = "Park the child: add `needs-decision` and comment what was found. Do not delete the branch, do not reopen the pull request, and do not commit on top of it.";
+var STASH_LABEL_PREFIX = "run:hold reclaimed before #";
+var { require_issue_number } = issue_number_shape;
+var UNREADABLE_PR_MESSAGE = "The pull request could not be read for branch ";
+var RESUME_IN_PLACE_REASON = "HEAD is on this issue\u2019s own branch over a clean tree, so the run resumes there.";
+var ISSUE_BRANCH_SEPARATOR = "-";
+function is_issue_branch(branch, issue) {
+  return branch.startsWith(`${issue}${ISSUE_BRANCH_SEPARATOR}`);
+}
+function is_off_default(tree) {
+  return tree.branch !== tree.default_branch;
+}
+function needs_reclaim(tree, issue) {
+  return tree.is_dirty || is_off_default(tree) && !is_issue_branch(tree.branch, issue);
+}
+function is_pr_decided(state) {
+  return state === MERGED_PR || state === CLOSED_PR;
+}
+function has_leftover_work(child) {
+  return child.branch_name !== void 0 || child.pr_state === OPEN_PR;
+}
+function is_resuming_in_place(tree, child) {
+  return is_off_default(tree) && (child.branch_name ?? tree.branch) === tree.branch;
+}
+function to_verdict(tree, child, issue) {
+  if (needs_reclaim(tree, issue)) return RECLAIM_VERDICT;
+  if (is_pr_decided(child.pr_state)) return PARK_VERDICT;
+  if (is_resuming_in_place(tree, child)) return CLEAN_VERDICT;
+  return has_leftover_work(child) ? RESUME_VERDICT : CLEAN_VERDICT;
+}
+function reclaim_reason(tree) {
+  const findings = [
+    tree.is_dirty ? "uncommitted changes" : void 0,
+    tree.branch === tree.default_branch ? void 0 : `HEAD on ${tree.branch}`
+  ].filter((entry) => entry !== void 0);
+  return `An earlier run left ${findings.join(" and ")} in this working tree.`;
+}
+function park_reason(state) {
+  return `The pull request for this issue is ${state}, so whether any work is still owed is a person's call.`;
+}
+function resume_reason(child) {
+  const branch_part = child.branch_name === void 0 ? "" : ` on branch ${child.branch_name}`;
+  const pr_part = child.pr_state === OPEN_PR ? ", and its pull request is still open" : "";
+  return `An earlier run left a partial implementation${branch_part}${pr_part}.`;
+}
+function to_reason(verdict, tree, child) {
+  if (verdict === RECLAIM_VERDICT) return reclaim_reason(tree);
+  if (verdict === PARK_VERDICT) return park_reason(child.pr_state);
+  if (verdict === RESUME_VERDICT) return resume_reason(child);
+  return is_off_default(tree) ? RESUME_IN_PLACE_REASON : CLEAN_REASON;
+}
+function reclaim_steps(tree, issue) {
+  if (!tree.is_dirty) return [];
+  return [
+    `pnpm josh stash:push "${STASH_LABEL_PREFIX}${issue}"`,
+    `Record the stash on ${session_cite.issue(issue)} \u2014 the comment is what gets it popped; nothing pops it for you.`
+  ];
+}
+function reclaim_advice(tree, issue) {
+  return [
+    ...reclaim_steps(tree, issue),
+    "pnpm josh ms",
+    "Then ask this command again: it is re-askable, and the clean tree gets its own answer."
+  ].join("\n");
+}
+function resume_steps(child) {
+  if (child.lane_directory !== void 0) {
+    return [
+      `cd ${shell_quote.word(child.lane_directory)}`,
+      "Resume in that lane worktree, where the branch is checked out; keep its directory."
+    ];
+  }
+  if (child.branch_name === void 0) return [];
+  return [
+    `git switch ${shell_quote.word(child.branch_name)}`,
+    "Then ask this command again: it takes the hold there."
+  ];
+}
+function resume_advice(child) {
+  return [...resume_steps(child), RESUME_ADVICE].join("\n");
+}
+function to_advice(verdict, issue, tree, child) {
+  if (verdict === RECLAIM_VERDICT) return reclaim_advice(tree, issue);
+  if (verdict === RESUME_VERDICT) return resume_advice(child);
+  if (verdict === PARK_VERDICT) return PARK_ADVICE;
+  return is_off_default(tree) ? RESUME_ADVICE : CLEAN_ADVICE;
+}
+function decide(tree, child, issue) {
+  const verdict = to_verdict(tree, child, issue);
+  return {
+    advice: to_advice(verdict, issue, tree, child),
+    reason: to_reason(verdict, tree, child),
+    verdict
+  };
+}
+function read_pr_field(raw) {
+  return json_value.parse_with(raw, pr_info_schema)?.state;
+}
+function to_pr_state(raw) {
+  const state = read_pr_field(raw);
+  return (state === void 0 ? void 0 : GH_PR_STATES.get(state)) ?? NO_PR;
+}
+async function has_stashable_work() {
+  try {
+    return await git_stash.has_stashable_changes();
+  } catch (error) {
+    error_text.trace_swallowed("run_preflight.has_stashable_work", error);
+    return true;
+  }
+}
+async function read_tree_state() {
+  const [is_dirty, current, default_branch] = await Promise.all([
+    has_stashable_work(),
+    git_command.branch(),
+    git_command.get_default_branch()
+  ]);
+  return { branch: current, default_branch, is_dirty };
+}
+async function read_pr_state(branch_name) {
+  if (!await git_gh_pr_read.pr_exists(branch_name)) return NO_PR;
+  const raw = await git_gh_pr_read.pr_view(branch_name);
+  if (raw === "") throw new Error(`${UNREADABLE_PR_MESSAGE}${branch_name}`);
+  return to_pr_state(raw);
+}
+function is_pr_open(state) {
+  return state === OPEN_PR;
+}
+async function read_pr_of_branch(branch_name, lane) {
+  const pr_state = await read_pr_state(branch_name);
+  const is_lane_branch = lane?.branch === branch_name && !lane.is_stranded;
+  return is_lane_branch ? { branch_name, lane_directory: lane.directory, pr_state } : { branch_name, pr_state };
+}
+function pick_child_state(reads) {
+  const decided = reads.find((read) => is_pr_decided(read.pr_state));
+  const open = reads.find((read) => is_pr_open(read.pr_state));
+  return decided ?? open ?? reads[0] ?? NO_CHILD_WORK;
+}
+var ISSUE_BRANCH_SUFFIX = "-*";
+var ANY_REMOTE_PREFIX = "*/";
+var REMOTE_SEPARATOR = "/";
+var NOT_FOUND_INDEX = -1;
+function to_head_branch(name) {
+  const separator_index = name.indexOf(REMOTE_SEPARATOR);
+  return separator_index === NOT_FOUND_INDEX ? name : name.slice(separator_index + 1);
+}
+function group_by_head(pairs) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const [name, reference] of pairs) groups.set(name, [...groups.get(name) ?? [], reference]);
+  return groups;
+}
+async function read_branch_candidates(issue) {
+  const pattern = `${issue}${ISSUE_BRANCH_SUFFIX}`;
+  const [local, remote] = await Promise.all([
+    git_command.branch_names(pattern),
+    git_command.branch_names_remote(`${ANY_REMOTE_PREFIX}${pattern}`)
+  ]);
+  return group_by_head([
+    ...local.map((name) => [name, name]),
+    ...remote.map((reference) => [to_head_branch(reference), reference])
+  ]);
+}
+async function has_commits_beyond(base, references) {
+  const counts = await Promise.all(
+    references.map(async (reference) => await git_command.commit_count_beyond(base, reference))
+  );
+  return counts.some((count) => count > 0);
+}
+async function is_held_dirty(name, lane) {
+  if (lane?.branch !== name || lane.is_stranded) return false;
+  return await run_hold.is_tree_dirty(lane.directory);
+}
+async function read_candidate(name, references, context) {
+  const state = await read_pr_of_branch(name, context.lane);
+  if (state.pr_state !== NO_PR || await has_commits_beyond(context.base, references)) return state;
+  return await is_held_dirty(name, context.lane) ? state : void 0;
+}
+async function read_child_state(issue) {
+  const candidates = await read_branch_candidates(issue);
+  if (candidates.size === 0) return NO_CHILD_WORK;
+  const [base, lane] = await Promise.all([
+    git_command.default_branch_reference(),
+    lane_registry.find_open_lane(issue)
+  ]);
+  const reads = await Promise.all(
+    [...candidates].map(
+      async ([name, references]) => await read_candidate(name, references, { base, lane })
+    )
+  );
+  return pick_child_state(reads.filter((read) => read !== void 0));
+}
+async function check(issue) {
+  require_issue_number(issue);
+  const tree = await read_tree_state();
+  if (needs_reclaim(tree, issue)) return decide(tree, NO_CHILD_WORK, issue);
+  return decide(tree, await read_child_state(issue), issue);
+}
+var run_preflight = {
+  CLEAN_VERDICT,
+  RESUME_ADVICE,
+  MERGED_PR,
+  STASH_LABEL_PREFIX,
+  check,
+  decide,
+  is_issue_branch,
+  read_child_state,
+  read_pr_state,
+  to_pr_state
+};
+
+export {
+  run_preflight
+};

package/dist/commands/chunk-ZQEKIMBV.js

@@ -0,0 +1,82 @@
+import {
+  plan_consumers_section
+} from "./chunk-SB3R6E3R.js";
+import {
+  git_grep_hits
+} from "./chunk-EWBEYTVS.js";
+
+// scripts/issue/plan-consumers.ts
+var PATHSPECS = [":(exclude).josh"];
+var KINDS = [
+  ["code", "code"],
+  ["config", "config and workflows"],
+  ["prompt", "prompts and skills"],
+  ["doc", "docs"],
+  ["test", "tests"]
+];
+var TEST_PATH = /(?:\.test\.ts|\.e2e\.ts|\.snap)$/u;
+var CODE_PATH = /\.(?:ts|js|mjs|cjs|svelte|sh)$/u;
+var PROMPT_ROOTS = ["prompts/", ".claude/"];
+var MAX_HITS_PER_KIND = 20;
+var MAX_DRAFT_FILES = 8;
+var INDENT = "  ";
+var HIT_INDENT = `${INDENT}${INDENT}`;
+var HIT_SEPARATOR = "  ";
+var NO_REFERENCE = " \u2014 no reference in the tracked tree";
+var SEARCH_FAILED = " \u2014 git grep failed; not searched";
+var DRAFT_ACTION = "<\u76F4\u3059 | \u5F71\u97FF\u306A\u3057 | \u5225 Issue>";
+var DRAFT_NO_REFERENCE = "no existing reference";
+function markdown_kind(path) {
+  return PROMPT_ROOTS.some((root) => path.startsWith(root)) ? "prompt" : "doc";
+}
+function kind_of(path) {
+  if (TEST_PATH.test(path)) return "test";
+  if (CODE_PATH.test(path)) return "code";
+  return path.endsWith(".md") ? markdown_kind(path) : "config";
+}
+function more_line(count) {
+  return count > MAX_HITS_PER_KIND ? [`${HIT_INDENT}\u2026 +${String(count - MAX_HITS_PER_KIND)} more`] : [];
+}
+function format_kind(hits, kind, label) {
+  const of_kind = hits.filter((hit) => kind_of(hit.path) === kind);
+  if (of_kind.length === 0) return [];
+  const lines = of_kind.slice(0, MAX_HITS_PER_KIND).map((hit) => `${HIT_INDENT}${hit.path}:${hit.line}${HIT_SEPARATOR}${hit.excerpt}`);
+  return [`${INDENT}${label}`, ...lines, ...more_line(of_kind.length)];
+}
+function format_consumers(consumers) {
+  if (consumers.has_failed) return `${consumers.identifier}${SEARCH_FAILED}`;
+  if (consumers.hits.length === 0) return `${consumers.identifier}${NO_REFERENCE}`;
+  const kinds = KINDS.flatMap(([kind, label]) => format_kind(consumers.hits, kind, label));
+  return [consumers.identifier, ...kinds].join("\n");
+}
+function kind_rank(path) {
+  return KINDS.findIndex(([kind]) => kind === kind_of(path));
+}
+function draft_files(hits) {
+  const paths = [...new Set(hits.map((hit) => hit.path))].filter((path) => kind_of(path) !== "test").toSorted((left, right) => kind_rank(left) - kind_rank(right));
+  const shown = paths.slice(0, MAX_DRAFT_FILES).map((path) => `\`${path}\``);
+  const rest = paths.length - shown.length;
+  return rest > 0 ? [...shown, `+${String(rest)} more`] : shown;
+}
+function draft_entry(consumers) {
+  const files = draft_files(consumers.hits);
+  if (files.length === 0) return `- \`${consumers.identifier}\`: ${DRAFT_NO_REFERENCE}`;
+  return `- \`${consumers.identifier}\`: ${files.join(", ")} \u2014 ${DRAFT_ACTION}`;
+}
+function format_draft(all) {
+  const entries = all.map((consumers) => draft_entry(consumers));
+  return ["draft:", plan_consumers_section.HEADING, "", ...entries].join("\n");
+}
+async function find(identifier) {
+  return { identifier, ...await git_grep_hits.search(identifier, [], PATHSPECS) };
+}
+async function report(identifiers) {
+  const all = await Promise.all(identifiers.map(async (identifier) => await find(identifier)));
+  const sections = [...all.map((consumers) => format_consumers(consumers)), format_draft(all)];
+  return { text: sections.join("\n\n"), has_failed: all.some((consumers) => consumers.has_failed) };
+}
+var plan_consumers = { kind_of, report };
+
+export {
+  plan_consumers
+};