@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-2OEXY4GM.js

@@ -0,0 +1,252 @@
+import {
+  git_gh_issue_alias_graphql
+} from "./chunk-XAEL24EG.js";
+import {
+  review_finding_ledger
+} from "./chunk-KVURNO74.js";
+import {
+  observation_ledger_home,
+  observation_ledger_line
+} from "./chunk-QXBOECGL.js";
+import {
+  CARRIED_ROUNDS_SUFFIX,
+  LEDGER_FILE_EXTENSION,
+  OBSERVATION_LEDGER_DIRECTORY
+} from "./chunk-SV4FZR24.js";
+import {
+  git_gh_issue_read
+} from "./chunk-TFYYXETQ.js";
+import {
+  gh_author_association
+} from "./chunk-5YTEMF4O.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  git_gh_exec,
+  parse_json,
+  parse_json_array_safe
+} from "./chunk-43DU7DYZ.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/observations/observation-ledger-archive.ts
+import { existsSync, readFileSync } from "node:fs";
+import { appendFile, readdir, rm } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+var ARCHIVE_PREFIX = "archive-";
+var ARCHIVED_ROUNDS_FILE = "archived-comment-rounds.txt";
+var ISSUE_FILE_PATTERN = new RegExp(
+  String.raw`^(?<issue>\d+)(?<rounds>${CARRIED_ROUNDS_SUFFIX})?\.md$`,
+  "u"
+);
+var CLOSED_FIELDS = "state closedAt";
+var CLOSED_STATE = "CLOSED";
+var MONTH_END = 7;
+var NONE = 0;
+var ARCHIVED_LINE = "closed issues' ledger file(s) moved into the monthly archive files.";
+var ARCHIVE_FAILED_LINE = "Could not archive the closed issues' ledger files; the next flush retries:";
+var closed_schema = z.object({ state: z.string(), closedAt: z.string().nullish() });
+function issue_file_of(name) {
+  const groups = ISSUE_FILE_PATTERN.exec(name)?.groups;
+  if (groups?.["issue"] === void 0) return void 0;
+  return { name, issue: Number(groups["issue"]), is_rounds: groups["rounds"] !== void 0 };
+}
+function issue_files(names) {
+  return names.toSorted((left, right) => left.localeCompare(right)).flatMap((name) => issue_file_of(name) ?? []);
+}
+function archive_name(closed_at) {
+  return `${ARCHIVE_PREFIX}${closed_at.slice(0, MONTH_END)}${LEDGER_FILE_EXTENSION}`;
+}
+async function closed_archives(issues) {
+  const read = await git_gh_issue_alias_graphql.read_aliased(issues, CLOSED_FIELDS, closed_schema);
+  return new Map(
+    [...read.answers].flatMap(
+      ([issue, answer]) => answer.state === CLOSED_STATE && typeof answer.closedAt === "string" ? [[issue, archive_name(answer.closedAt)]] : []
+    )
+  );
+}
+function by_archive(files, archives) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const target = archives.get(file.issue);
+    if (target !== void 0) groups.set(target, [...groups.get(target) ?? [], file]);
+  }
+  return groups;
+}
+async function move(directory, target, files) {
+  const contents = await Promise.all(
+    files.map(
+      async (file) => await observation_ledger_home.read_file(path.join(directory, file.name), true)
+    )
+  );
+  await appendFile(path.join(directory, target), contents.join(""), "utf8");
+  await Promise.all(
+    files.map(async (file) => {
+      await rm(path.join(directory, file.name));
+    })
+  );
+}
+function archived_rounds_path(root) {
+  return path.join(root, OBSERVATION_LEDGER_DIRECTORY, ARCHIVED_ROUNDS_FILE);
+}
+async function record_rounds(root, files) {
+  const issues = files.filter((file) => file.is_rounds).map((file) => String(file.issue));
+  if (issues.length > NONE) {
+    await appendFile(archived_rounds_path(root), `${issues.join("\n")}
+`, "utf8");
+  }
+}
+function archived_rounds(root) {
+  const target = archived_rounds_path(root);
+  if (!existsSync(target)) return /* @__PURE__ */ new Set();
+  return new Set(readFileSync(target, "utf8").split("\n").filter(Boolean).map(Number));
+}
+async function archive(root) {
+  const directory = path.join(root, OBSERVATION_LEDGER_DIRECTORY);
+  if (!existsSync(directory)) return NONE;
+  const files = issue_files(await readdir(directory));
+  const groups = by_archive(files, await closed_archives(files.map((file) => file.issue)));
+  const moved = [...groups.values()].flat();
+  await Promise.all(
+    [...groups].map(async ([name, group]) => {
+      await move(directory, name, group);
+    })
+  );
+  await record_rounds(root, moved);
+  return moved.length;
+}
+async function archive_reported(root) {
+  try {
+    const count = await archive(root);
+    if (count > NONE) console.info(`Archived ${String(count)} ${ARCHIVED_LINE}`);
+    return count;
+  } catch (error) {
+    console.warn(`${ARCHIVE_FAILED_LINE} ${error_text.message_of(error)}`);
+    return NONE;
+  }
+}
+var observation_ledger_archive = {
+  ARCHIVE_FAILED_LINE,
+  archive,
+  archive_reported,
+  archived_rounds
+};
+
+// scripts/review/review-comment-round.ts
+import { existsSync as existsSync2 } from "node:fs";
+import path2 from "node:path";
+import { z as z2 } from "zod";
+var COMMENT_HEADING_MARK = "### ";
+var COMMENT_TITLE = "Review round recorded after the pull request opened";
+var OBSERVATION_TITLE = "Observation recorded while the pull request was open";
+var COMMENT_TITLES = [COMMENT_TITLE, OBSERVATION_TITLE];
+var COMMENT_HEADINGS = COMMENT_TITLES.map((title) => `${COMMENT_HEADING_MARK}${title}`);
+var COMMENT_NOTE = "Kept here rather than in the observation ledger: a line appended after the commit would be pushed onto the open pull request and restart its CI.";
+var CODE_FENCE = "```";
+var OBSERVATION_LINE_MARK = "- k:";
+var CARRIED_FILE_PATTERN = new RegExp(String.raw`^\d+${CARRIED_ROUNDS_SUFFIX}\.md$`, "u");
+var PER_PAGE = "100";
+var UNNAMED_REPOSITORY = "Could not name this repository from `git remote`.";
+var UNREAD_SEARCH = "Could not read the search for closed issues with a comment round.";
+var UNREAD_COMMENTS = "Could not read the comments of";
+var UNREAD_PERMISSION = "Could not read the write permission of";
+var search_item_schema = z2.object({ number: z2.number() });
+var search_schema = z2.object({ items: z2.array(search_item_schema) });
+var comment_schema = z2.object({
+  body: z2.string().nullish(),
+  author_association: z2.string().nullish(),
+  user: z2.looseObject({ login: z2.string() }).nullish()
+});
+function body_under(title, lines) {
+  const heading = `${COMMENT_HEADING_MARK}${title}`;
+  return [heading, "", COMMENT_NOTE, "", CODE_FENCE, ...lines, CODE_FENCE].join("\n");
+}
+function body_of(lines) {
+  return body_under(COMMENT_TITLE, lines);
+}
+function observation_body_of(lines) {
+  return body_under(OBSERVATION_TITLE, lines);
+}
+function is_carried_line(line) {
+  if (review_finding_ledger.is_finding_line(line)) return true;
+  return line.startsWith(OBSERVATION_LINE_MARK) && observation_ledger_line.line_reason(line) === void 0;
+}
+function is_round(comment) {
+  const body = comment.body ?? "";
+  return COMMENT_HEADINGS.some((heading) => body.startsWith(heading));
+}
+async function is_trusted_comment(comment) {
+  const login = comment.user?.login;
+  const is_trusted = await gh_author_association.trust_of({
+    login,
+    association: comment.author_association
+  });
+  if (is_trusted === void 0) throw new Error(`${UNREAD_PERMISSION} ${login ?? ""}`);
+  return is_trusted;
+}
+async function lines_of(comments) {
+  const rounds = comments.filter((comment) => is_round(comment));
+  const trusted = await Promise.all(
+    rounds.map(async (comment) => await is_trusted_comment(comment))
+  );
+  return rounds.filter((_comment, index) => trusted[index] === true).flatMap((comment) => (comment.body ?? "").split("\n")).filter((line) => is_carried_line(line));
+}
+function search_path(repo, title) {
+  const query = `repo:${repo} is:issue is:closed in:comments "${title}"`;
+  const parameters = new URLSearchParams({ q: query, sort: "updated", per_page: PER_PAGE });
+  return `search/issues?${parameters.toString()}`;
+}
+async function search(repo, title) {
+  const raw = await git_gh_exec.exec_gh_api({ path: search_path(repo, title) });
+  const page = parse_json.parse_json_object_or_undefined(raw, search_schema);
+  if (page === void 0) throw new Error(UNREAD_SEARCH);
+  return page.items.map((item) => item.number);
+}
+async function closed_issues() {
+  const repo = session_cite.session_repo();
+  if (repo === void 0) throw new Error(UNNAMED_REPOSITORY);
+  const pages = await Promise.all(COMMENT_TITLES.map(async (title) => await search(repo, title)));
+  return [...new Set(pages.flat())];
+}
+function carried_path(issue, root) {
+  return observation_ledger_home.file_path(`${String(issue)}${CARRIED_ROUNDS_SUFFIX}`, root);
+}
+function is_carried_file(file_path) {
+  return CARRIED_FILE_PATTERN.test(path2.basename(file_path));
+}
+async function issue_lines(issue) {
+  const raw = await git_gh_issue_read.issue_list_comments(String(issue));
+  if (raw === void 0) throw new Error(`${UNREAD_COMMENTS} ${session_cite.issue(issue)}`);
+  return await lines_of(parse_json_array_safe(raw, comment_schema));
+}
+async function carry_issue(issue, root) {
+  const lines = await issue_lines(issue);
+  await observation_ledger_home.append(carried_path(issue, root), lines);
+  return lines.length;
+}
+async function carry(root) {
+  const issues = await closed_issues();
+  const archived = observation_ledger_archive.archived_rounds(root);
+  const pending = issues.filter(
+    (issue) => !archived.has(issue) && !existsSync2(carried_path(issue, root))
+  );
+  const counts = await Promise.all(pending.map(async (issue) => await carry_issue(issue, root)));
+  return counts.reduce((total, count) => total + count, 0);
+}
+var review_comment_round = {
+  body_of,
+  carried_path,
+  carry,
+  is_carried_file,
+  issue_lines,
+  lines_of,
+  observation_body_of
+};
+
+export {
+  observation_ledger_archive,
+  review_comment_round
+};

package/dist/commands/chunk-2OMIHPPE.js

@@ -0,0 +1,51 @@
+import {
+  cost_transcript
+} from "./chunk-DDZVMXZD.js";
+
+// scripts/time-runtime/time-hook-transcript.ts
+import path from "node:path";
+var { TRANSCRIPT_EXTENSION } = cost_transcript;
+var AGENT_PREFIX = "agent-";
+var AGENT_ID_PATTERN = /^[\w-]+$/u;
+function is_agent_id(value) {
+  return typeof value === "string" && AGENT_ID_PATTERN.test(value);
+}
+function fork_path(transcript_path, agent_id) {
+  const directory = path.dirname(transcript_path);
+  const session_id = path.basename(transcript_path, TRANSCRIPT_EXTENSION);
+  const file_name = `${AGENT_PREFIX}${agent_id}${TRANSCRIPT_EXTENSION}`;
+  return path.join(cost_transcript.unit_directory(directory, session_id), file_name);
+}
+function transcript_of(transcript_path, agent_id) {
+  if (!is_agent_id(agent_id) || !transcript_path.endsWith(TRANSCRIPT_EXTENSION)) {
+    return transcript_path;
+  }
+  return fork_path(transcript_path, agent_id);
+}
+var time_hook_transcript = {
+  fork_path,
+  transcript_of
+};
+
+// scripts/time-runtime/transcript-tail.ts
+import { closeSync, fstatSync, openSync, readSync } from "node:fs";
+var TAIL_BYTES = 262144;
+var FILE_START = 0;
+function read_tail(file_path, max_bytes = TAIL_BYTES) {
+  const descriptor = openSync(file_path, "r");
+  try {
+    const { size } = fstatSync(descriptor);
+    const length = Math.min(size, max_bytes);
+    const buffer = Buffer.alloc(length);
+    const read = readSync(descriptor, buffer, FILE_START, length, size - length);
+    return buffer.subarray(FILE_START, read).toString("utf8");
+  } finally {
+    closeSync(descriptor);
+  }
+}
+var transcript_tail = { TAIL_BYTES, read_tail };
+
+export {
+  time_hook_transcript,
+  transcript_tail
+};

package/dist/commands/chunk-2ONSHOAY.js

@@ -0,0 +1,46 @@
+import {
+  git_command,
+  git_diff_reads
+} from "./chunk-IXZZSST7.js";
+import {
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+import {
+  UNTRACKED_FILES_FLAG
+} from "./chunk-B5GXZK3E.js";
+
+// scripts/run/cut/run-cut-ready.ts
+function is_ready(tree) {
+  return tree.branch !== tree.default_branch && tree.is_dirty;
+}
+async function is_lane_branch(state) {
+  const default_branch = await git_command.get_default_branch();
+  return is_ready({ branch: state.branch, default_branch, is_dirty: state.is_dirty });
+}
+var STATUS_ARGUMENTS = ["status", "--porcelain=v2", "--branch", UNTRACKED_FILES_FLAG];
+var HEADER_PREFIX = "#";
+var BRANCH_HEADER = "# branch.head ";
+function tree_of(status, default_branch) {
+  const lines = status.split("\n").filter((line) => line !== "");
+  const header = lines.find((line) => line.startsWith(BRANCH_HEADER));
+  if (header === void 0) return void 0;
+  const branch = header.slice(BRANCH_HEADER.length);
+  const is_dirty = lines.some((line) => !line.startsWith(HEADER_PREFIX));
+  return { branch, default_branch, is_dirty };
+}
+function read_tree_sync(cwd) {
+  const options = git_spawn_sync.located(cwd);
+  const status = git_spawn_sync.read(STATUS_ARGUMENTS, options);
+  if (status === void 0) return void 0;
+  const reference = git_spawn_sync.read(git_diff_reads.DEFAULT_BRANCH_ARGUMENTS, options);
+  return tree_of(status, git_diff_reads.default_branch_of(reference));
+}
+function is_ready_sync(read = read_tree_sync) {
+  const tree = read();
+  return tree === void 0 || is_ready(tree);
+}
+var run_cut_ready = { is_lane_branch, is_ready, is_ready_sync, read_tree_sync, tree_of };
+
+export {
+  run_cut_ready
+};

package/dist/commands/chunk-2SA3W4JF.js

@@ -0,0 +1,41 @@
+import {
+  release_history,
+  release_plan
+} from "./chunk-RGRLLF2J.js";
+import {
+  version_targets
+} from "./chunk-LPSULLNK.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/followup/git-followup-pending.ts
+var MERGE_PENDING_NOTE = "\u2014 this run's merge is not counted; it lands next";
+async function read_tip(options) {
+  if (options.tip !== void 0) return options.tip;
+  const default_branch = await git_command.get_default_branch();
+  await git_command.fetch_branch(default_branch);
+  return `origin/${default_branch}`;
+}
+async function read_pending(options) {
+  try {
+    const current_version = version_targets.read_workspace_version(options.cwd ?? process.cwd());
+    if (current_version === void 0) return void 0;
+    const tip = await read_tip(options);
+    const plan = await release_history.read_release_plan(current_version, options.reader, tip);
+    return plan?.pending;
+  } catch {
+    return void 0;
+  }
+}
+async function pending_release_line(options) {
+  const pending = await read_pending(options);
+  if (pending === void 0) return void 0;
+  const line = release_plan.format_pending_line(pending);
+  return options.is_merge_pending ? `${line} ${MERGE_PENDING_NOTE}` : line;
+}
+var git_followup_pending = { MERGE_PENDING_NOTE, pending_release_line, read_pending };
+
+export {
+  git_followup_pending
+};

package/dist/commands/chunk-2VY7CJ2R.js

@@ -0,0 +1,212 @@
+import {
+  declared_growth,
+  split_assess
+} from "./chunk-ZGEUWHFF.js";
+import {
+  lane_stage_budget
+} from "./chunk-AXXEMVRJ.js";
+import {
+  lane_implement_rate
+} from "./chunk-KP2BVAS5.js";
+import {
+  markdown_section
+} from "./chunk-JZK33TA5.js";
+import {
+  issue_body_keys
+} from "./chunk-KXK2A2HB.js";
+import {
+  SPLIT_ROUTE_LABEL
+} from "./chunk-QQBMVC5W.js";
+
+// scripts/issue/size-estimate.ts
+import { z } from "zod";
+var BACKGROUND_HEADING = issue_body_keys.heading("background");
+var EPIC_HEADING = "## Split rationale";
+var PREFIX = issue_body_keys.prefix("size");
+var HEADING_PREFIX = "## ";
+var { REASON_PREFIX } = split_assess;
+var DECLARATION = `${PREFIX} ${issue_body_keys.size_value("<N>", "<M>")}`;
+var MISSING = `missing size estimate: declare \`${DECLARATION}\` under ${BACKGROUND_HEADING}`;
+var EXAMPLE = `${PREFIX} ${issue_body_keys.size_value("3", "60")}`;
+var MALFORMED = `\`${PREFIX}\` must be written ${DECLARATION}
+${EXAMPLE}`;
+var estimate_schema = z.object({ files: z.coerce.number(), lines: z.coerce.number() });
+var IMPLEMENT_BUDGET = lane_stage_budget.BUDGET_MINUTES.implement;
+var BAR_BUDGETS = 2;
+var BAR_MINUTES = BAR_BUDGETS * IMPLEMENT_BUDGET;
+function declared(body, prefix) {
+  const background = markdown_section.section_lines(body, BACKGROUND_HEADING).join("\n");
+  const line = markdown_section.unfenced_lines(background).map((text) => text.trim()).find((text) => text.startsWith(prefix));
+  return line?.slice(prefix.length).trim();
+}
+function is_estimate_line(text) {
+  const trimmed = text.trim();
+  return trimmed.startsWith(PREFIX) && issue_body_keys.size_counts(trimmed.slice(PREFIX.length).trim()) !== void 0;
+}
+function stated_line(record) {
+  return markdown_section.unfenced_lines(record).find((text) => is_estimate_line(text))?.trim();
+}
+function declared_index(visible) {
+  const start = visible.findIndex((text) => text.trim() === BACKGROUND_HEADING) + 1;
+  if (start === 0) return -1;
+  const section = visible.slice(start);
+  const end = section.findIndex((text) => text.trimStart().startsWith(HEADING_PREFIX));
+  const bounded = end === -1 ? section : section.slice(0, end);
+  const at = bounded.findIndex((text) => text.trimStart().startsWith(PREFIX));
+  return at === -1 ? -1 : start + at;
+}
+function restated(body, line) {
+  const lines = [...markdown_section.lines_of(body)];
+  const at = declared_index(markdown_section.unfenced_lines(body));
+  const current = lines[at];
+  if (current === void 0) return body;
+  lines[at] = `${current.slice(0, current.length - current.trimStart().length)}${line}`;
+  return lines.join("\n");
+}
+function is_epic(body) {
+  return markdown_section.has_line(body, EPIC_HEADING);
+}
+function grown(count, axis, growth) {
+  return count * declared_growth.factor(growth, axis);
+}
+function guide_for(rate) {
+  return split_assess.guide_for(IMPLEMENT_BUDGET, rate);
+}
+function parse(body, rate, growth) {
+  const read = estimate_schema.safeParse(issue_body_keys.size_counts(declared(body, PREFIX) ?? ""));
+  if (!read.success) return void 0;
+  const { files, lines } = read.data;
+  return {
+    files,
+    lines,
+    verdict: split_assess.verdict_for(
+      grown(files, "files", growth),
+      grown(lines, "lines", growth),
+      guide_for(rate)
+    )
+  };
+}
+function growth_text(growth) {
+  return growth?.files === void 0 && growth?.lines === void 0 ? `\xD7 ${String(declared_growth.factor(growth, "files"))}` : `(${declared_growth.text(growth)})`;
+}
+function projected(estimate, growth) {
+  const declared_counts = `${String(estimate.files)} file(s) / ${String(estimate.lines)} line(s)`;
+  const grown_counts = `${String(grown(estimate.files, "files", growth))} file(s) / ${String(grown(estimate.lines, "lines", growth))} line(s)`;
+  return `size estimate ${declared_counts} ${growth_text(growth)} = ${grown_counts}`;
+}
+function problems(body) {
+  if (is_epic(body)) return [];
+  if (declared(body, PREFIX) === void 0) return [MISSING];
+  return parse(body) === void 0 ? [MALFORMED] : [];
+}
+function is_reasoned(body) {
+  return (declared(body, REASON_PREFIX) ?? "") !== "";
+}
+function is_excused(body, route) {
+  return route === SPLIT_ROUTE_LABEL || is_reasoned(body);
+}
+function exceeded(estimate, rate, growth) {
+  if (estimate.verdict === split_assess.SINGLE_VERDICT) return projected(estimate, growth);
+  const guide = guide_for(rate);
+  return `${projected(estimate, growth)} exceeds the guide (more than ${String(guide.files)} files or ${String(guide.lines)} lines)`;
+}
+function refusal(estimate, rate, growth) {
+  return `${exceeded(estimate, rate, growth)} \u2014 file it split (\`--route split\`) or declare \`${REASON_PREFIX} <\u7406\u7531>\`; split-assessment.md \u2192 "${split_assess.QUESTION_SECTION}"`;
+}
+function guide_exceeded(body, rate, growth) {
+  const estimate = parse(body, rate, growth);
+  return estimate?.verdict === split_assess.SPLIT_VERDICT ? estimate : void 0;
+}
+function over_guide(body, route, rate, growth) {
+  return is_excused(body, route) ? void 0 : guide_exceeded(body, rate, growth);
+}
+function split_over_guide(body, route, rate, growth) {
+  return route === SPLIT_ROUTE_LABEL ? guide_exceeded(body, rate, growth) : void 0;
+}
+function over_cap(body, route, rate, growth) {
+  const estimate = parse(body, rate, growth);
+  if (estimate === void 0 || is_excused(body, route)) return void 0;
+  return split_assess.is_over_cap(
+    grown(estimate.files, "files", growth),
+    grown(estimate.lines, "lines", growth),
+    guide_for(rate)
+  ) ? estimate : void 0;
+}
+function route_of(labels) {
+  return labels.includes(SPLIT_ROUTE_LABEL) ? SPLIT_ROUTE_LABEL : void 0;
+}
+function capped(estimate, rate, growth) {
+  const { cap } = guide_for(rate);
+  return `${projected(estimate, growth)} exceeds the cap (more than ${String(cap.files)} files or ${String(cap.lines)} lines) with no \`${REASON_PREFIX}\``;
+}
+function cap_refusal(estimate, rate, growth) {
+  return `${capped(estimate, rate, growth)} \u2014 with separately-mergeable parts, file an ordered epic of \`--route split\` children (the mechanical changes first, the child that switches the setting on last); one deliverable, declare \`${REASON_PREFIX} <\u7406\u7531>\`; split-assessment.md \u2192 "${split_assess.QUESTION_SECTION}"`;
+}
+function projected_minutes(estimate, rate, growth) {
+  return lane_implement_rate.minutes_for(grown(estimate.lines, "lines", growth), rate);
+}
+function declared_lines_bar(rate, growth) {
+  const lines = lane_implement_rate.lines_for(BAR_MINUTES, rate);
+  return lines === void 0 ? void 0 : Math.floor(lines / declared_growth.factor(growth, "lines"));
+}
+function unreasoned(body, rate, growth) {
+  return is_reasoned(body) ? void 0 : parse(body, rate, growth);
+}
+function bar_overrun(body, rate, growth) {
+  const estimate = unreasoned(body, rate, growth);
+  if (estimate === void 0 || rate === void 0) return void 0;
+  const bar = declared_lines_bar(rate, growth);
+  return bar !== void 0 && estimate.lines > bar ? { estimate, rate, bar } : void 0;
+}
+function overrun_text(overrun, growth) {
+  const { estimate, rate, bar } = overrun;
+  const minutes = Math.round(projected_minutes(estimate, rate, growth));
+  const measured = `${rate.median.toFixed(1)} implement min / 100 lines over ${String(rate.lanes)} lane(s)`;
+  const limit = `the ${String(BAR_MINUTES)}-minute size bar (${String(BAR_BUDGETS)} \xD7 the ${String(IMPLEMENT_BUDGET)}-minute implement budget: at most ${String(bar)} declared line(s))`;
+  return `${exceeded(estimate, rate, growth)} and projects ${String(minutes)} implement minute(s) at ${measured}, over ${limit}`;
+}
+function over_budget(body, rate, growth) {
+  return bar_overrun(body, rate, growth)?.estimate;
+}
+function budget_note(body, rate, growth) {
+  const overrun = bar_overrun(body, rate, growth);
+  return overrun === void 0 ? void 0 : overrun_text(overrun, growth);
+}
+function budget_problem(body, rate, growth) {
+  const note = budget_note(body, rate, growth);
+  return note === void 0 ? void 0 : `${note} \u2014 split it into children each within the bar or declare \`${REASON_PREFIX} <\u7406\u7531>\`; split-assessment.md \u2192 "${split_assess.QUESTION_SECTION}"`;
+}
+function guide_problem(body, route, rate, growth) {
+  const over = over_cap(body, route, rate, growth);
+  if (over !== void 0) return cap_refusal(over, rate, growth);
+  const estimate = over_guide(body, route, rate, growth);
+  const guide_refusal = estimate === void 0 ? void 0 : refusal(estimate, rate, growth);
+  return budget_problem(body, rate, growth) ?? guide_refusal;
+}
+function declared_files(body) {
+  return parse(body)?.files;
+}
+var size_estimate = {
+  budget_note,
+  capped,
+  declared,
+  declared_files,
+  declared_lines_bar,
+  declared_size: parse,
+  exceeded,
+  guide_problem,
+  is_epic,
+  over_budget,
+  over_cap,
+  over_guide,
+  problems,
+  projected_minutes,
+  restated,
+  route_of,
+  split_over_guide,
+  stated_line
+};
+
+export {
+  size_estimate
+};

package/dist/commands/chunk-2WRDAQPJ.js

@@ -0,0 +1,74 @@
+import {
+  issue_read
+} from "./chunk-3F3RNIG2.js";
+import {
+  git_gh_issue_read
+} from "./chunk-TFYYXETQ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/issue/issue-outcome.ts
+import { z } from "zod";
+var SUMMARY_LIMIT = 80;
+var summary_schema = z.string().min(1).max(SUMMARY_LIMIT).regex(/^[\u{20}-\u{7E}]+$/u).refine((value) => value === value.trim());
+var MARKER = /^<!-- josh:outcome (?<json>[^\n]+) -->$/gmu;
+var COMMENT_URL = /^https:\/\/github\.com\/[^/]+\/[^/]+\/issues\/\d+#issuecomment-\d+$(?![\s\S])/u;
+var url_schema = z.string().regex(COMMENT_URL);
+var outcome_schema = z.object({ summary: summary_schema, url: url_schema.optional() });
+function body_of(note) {
+  if (note.summary === void 0 && note.url === void 0) return note.body;
+  const outcome = outcome_schema.parse({ summary: note.summary, url: note.url });
+  return `${note.body}
+
+<!-- josh:outcome ${JSON.stringify(outcome)} -->`;
+}
+function evidence_of(comment, url) {
+  if (comment.html_url === void 0 || !COMMENT_URL.test(url)) return false;
+  return url.split("#", 1)[0] === comment.html_url.split("#", 1)[0];
+}
+function record_of(body) {
+  const json = [...body.matchAll(MARKER)].at(-1)?.groups?.["json"];
+  return json_value.parse_with(json ?? "", outcome_schema);
+}
+function cited_outcome(record, comment) {
+  const url = record.url ?? comment.html_url;
+  return url === void 0 || !evidence_of(comment, url) ? void 0 : { summary: record.summary, url };
+}
+function outcome_of(comment) {
+  if (comment.is_trusted !== true) return void 0;
+  const record = record_of(comment.body);
+  return record === void 0 ? void 0 : cited_outcome(record, comment);
+}
+function from_comments(comments, candidates = comments) {
+  const outcomes = candidates.flatMap((comment) => {
+    const outcome = outcome_of(comment);
+    const evidence = comments.find((entry) => entry.html_url === outcome?.url);
+    return outcome === void 0 || evidence?.is_trusted !== true ? [] : [outcome];
+  });
+  return outcomes.at(-1);
+}
+async function read(issue) {
+  try {
+    const json = await git_gh_issue_read.issue_list_comments(
+      String(issue),
+      void 0,
+      void 0,
+      git_gh_issue_read.read_comments_conditionally
+    );
+    const comments = json === void 0 ? void 0 : await issue_read.parse_comments(json);
+    return comments === void 0 ? void 0 : from_comments(comments);
+  } catch {
+    return void 0;
+  }
+}
+async function recorded(issue, is_merged) {
+  if (is_merged) return {};
+  const outcome = await read(issue);
+  return outcome === void 0 ? {} : { outcome };
+}
+var issue_outcome = { body_of, from_comments, read, recorded, summary_schema, url_schema };
+
+export {
+  issue_outcome
+};