@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-BUZAYEBD.js

@@ -0,0 +1,319 @@
+import {
+  defect_origin_line
+} from "./chunk-HQSWPRUF.js";
+import {
+  behavior_change_lint
+} from "./chunk-COGKULQH.js";
+import {
+  issue_not_before
+} from "./chunk-PCZROH3R.js";
+import {
+  issue_auto_ok
+} from "./chunk-QGATHT4S.js";
+import {
+  measure_declaration
+} from "./chunk-34JJYCIY.js";
+import {
+  size_estimate
+} from "./chunk-2VY7CJ2R.js";
+import {
+  expected_effect_lint
+} from "./chunk-XZQWEVR3.js";
+import {
+  issue_priority
+} from "./chunk-XI2ABCRX.js";
+import {
+  cli_body
+} from "./chunk-7IZJ5MG2.js";
+import {
+  issue_bug_label
+} from "./chunk-SVTS7ACS.js";
+import {
+  pr_classification
+} from "./chunk-RS5HBJY6.js";
+import {
+  markdown_section
+} from "./chunk-JZK33TA5.js";
+import {
+  issue_body_keys
+} from "./chunk-KXK2A2HB.js";
+import {
+  BREAKING_CHANGE_LABEL,
+  BUG_LABEL,
+  ENHANCEMENT_LABEL,
+  OTHER_CHANGE_LABEL,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  package_path
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/issue/aggregation-split.ts
+var CRITERIA_HEADING = issue_body_keys.heading("criteria");
+var BACKGROUND_HEADING = issue_body_keys.heading("background");
+var CRITERION_PREFIX = "- [";
+var RECORDING_WORDS = ["Issue", "\u30B3\u30E1\u30F3\u30C8", "\u8A18\u9332"];
+var SUBJECT_WORDS = ["\u96C6\u8A08", "\u8A08\u6E2C", "before", "\u5909\u66F4\u524D\u5F8C"];
+var ISSUE_REFERENCE = /#\d+/u;
+var IMPLEMENTATION_FILES = 3;
+var REFUSAL = `an acceptance criterion records an aggregation or a measurement as an Issue comment beside an implementation of ${String(IMPLEMENTATION_FILES)}+ files \u2014 file it as a prior Issue (\`--route split\`) and cite its comment under ${BACKGROUND_HEADING} in this one; issue-template.md \u2192 "\`${BACKGROUND_HEADING}\` \u76F4\u4E0B\u306E\u5BA3\u8A00\u3068\u5206\u985E\u30E9\u30D9\u30EB"`;
+function is_aggregation_criterion(line) {
+  const text = line.trim();
+  if (!text.startsWith(CRITERION_PREFIX) || ISSUE_REFERENCE.test(text)) return false;
+  return SUBJECT_WORDS.some((word) => text.includes(word)) && RECORDING_WORDS.every((word) => text.includes(word));
+}
+function has_aggregation_criterion(body) {
+  const criteria = markdown_section.section_lines(body, CRITERIA_HEADING).join("\n");
+  return markdown_section.unfenced_lines(criteria).some((line) => is_aggregation_criterion(line));
+}
+function declares_implementation(body) {
+  return (size_estimate.declared_files(body) ?? 0) >= IMPLEMENTATION_FILES;
+}
+function problems(body) {
+  return has_aggregation_criterion(body) && declares_implementation(body) ? [REFUSAL] : [];
+}
+var aggregation_split = { IMPLEMENTATION_FILES, problems };
+
+// scripts/issue/enforcement-lint.ts
+var ENFORCEMENT_PREFIX = issue_body_keys.prefix("enforcement");
+var MEASUREMENT_PREFIX = issue_body_keys.prefix("measurement");
+var BACKGROUND_HEADING2 = issue_body_keys.heading("background");
+var NONE_VALUE = issue_body_keys.value("none");
+var PLACEHOLDER_PREFIX = "<";
+function is_unnamed(value) {
+  return value === "" || value === NONE_VALUE || value.startsWith(PLACEHOLDER_PREFIX);
+}
+function declaration_problem(body, prefix, guide) {
+  const value = measure_declaration.background_value(body, prefix);
+  if (value === void 0) {
+    return `missing declaration under ${BACKGROUND_HEADING2}:\`${prefix} ${guide}\``;
+  }
+  return is_unnamed(value) ? `\`${prefix}\` must name ${guide}, not \`${value}\`` : void 0;
+}
+function problems2(body) {
+  if (!behavior_change_lint.is_target(body)) return [];
+  return [
+    declaration_problem(
+      body,
+      ENFORCEMENT_PREFIX,
+      "<the hook, lint or gate that stops it> or \u8A08\u6E2C\u306E\u307F"
+    ),
+    declaration_problem(body, MEASUREMENT_PREFIX, "<the number a violation shows in (command)>")
+  ].filter((problem) => problem !== void 0);
+}
+var enforcement_lint = { problems: problems2 };
+
+// scripts/issue/figure-source-lint.ts
+var BACKGROUND_HEADING3 = issue_body_keys.heading("background");
+var EFFECT_HEADING = issue_body_keys.heading("expected_effect");
+var PREDICTION = "\u4E88\u6E2C";
+var COMMAND = /`[^`\s]+\s[^`]*`/u;
+var WARNING = `number with no source (add the command that measured it in backticks, or write ${PREDICTION}): `;
+var NOT_A_FIGURE = /#\d+|\d{4}-\d{2}-\d{2}|^\d+\.\s/gu;
+var DIGIT = /\d/u;
+var DECLARATIONS = [
+  "size",
+  "cause_lane",
+  "cause_loss",
+  "priority",
+  "sample_gate",
+  "not_before",
+  "measure_absent",
+  "measurement",
+  "decision_rule"
+].map((key) => issue_body_keys.prefix(key));
+function text_lines(body, heading) {
+  const section2 = markdown_section.section_lines(body, heading).join("\n");
+  return markdown_section.unfenced_lines(section2).map((line) => line.trim());
+}
+function has_no_source(line) {
+  if (COMMAND.test(line) || line.includes(PREDICTION)) return false;
+  return DIGIT.test(line.replaceAll(NOT_A_FIGURE, ""));
+}
+function warnings(body) {
+  const background = text_lines(body, BACKGROUND_HEADING3).filter(
+    (line) => DECLARATIONS.every((prefix) => !line.startsWith(prefix))
+  );
+  return [...background, ...text_lines(body, EFFECT_HEADING)].filter((line) => has_no_source(line)).map((line) => `${WARNING}${line}`);
+}
+var figure_source_lint = { warnings };
+
+// scripts/issue/issue-classification.ts
+var BACKGROUND_HEADING4 = issue_body_keys.heading("background");
+var FEATURE_DECLARATIONS = [
+  issue_body_keys.line("purpose", "feature"),
+  issue_body_keys.line("purpose", "improvement"),
+  issue_body_keys.line("purpose", "time_saving")
+];
+var BREAKING_DECLARATION = issue_body_keys.line("compatibility", "breaking");
+var NON_BUG_DECLARATION = issue_body_keys.line("kind", "non_bug");
+var NON_BUG_LINE = new RegExp(
+  String.raw`^ {0,3}(?:${issue_body_keys.line_variants("kind", "non_bug").join("|")})[ \t]*$`,
+  "mu"
+);
+var CLASSIFICATION_LABELS = [BUG_LABEL, ENHANCEMENT_LABEL, BREAKING_CHANGE_LABEL];
+var CONFLICT = "bug and enhancement declarations cannot be combined";
+var MISSING_BUG_CLASSIFICATION = "missing bug classification";
+var CONFLICTING_BUG_CLASSIFICATIONS = "conflicting bug classifications";
+function required_labels(body) {
+  const labels = [];
+  const background = markdown_section.section_lines(body, BACKGROUND_HEADING4).join("\n");
+  if (issue_bug_label.is_bug_fix(body)) labels.push(BUG_LABEL);
+  if (FEATURE_DECLARATIONS.some((line) => markdown_section.has_unfenced_line(background, line))) {
+    labels.push(ENHANCEMENT_LABEL);
+  }
+  if (markdown_section.has_unfenced_line(background, BREAKING_DECLARATION)) {
+    labels.push(BREAKING_CHANGE_LABEL);
+  }
+  return labels;
+}
+function labels_for(body, existing) {
+  const missing = required_labels(body).filter((label) => !has_label_name(existing, label));
+  return [...existing, ...missing];
+}
+function bug_classification_problem(body) {
+  const background = markdown_section.section_lines(body, BACKGROUND_HEADING4).join("\n");
+  const has_bug = issue_bug_label.is_bug_fix(body);
+  const has_non_bug = markdown_section.has_unfenced_line(background, NON_BUG_DECLARATION);
+  if (!has_bug && !has_non_bug) return MISSING_BUG_CLASSIFICATION;
+  if (has_bug && has_non_bug) return CONFLICTING_BUG_CLASSIFICATIONS;
+  return void 0;
+}
+function label_conflict(body) {
+  const labels = required_labels(body);
+  return labels.includes(BUG_LABEL) && labels.includes(ENHANCEMENT_LABEL) ? CONFLICT : void 0;
+}
+function selection_problem(body, labels) {
+  try {
+    pr_classification.select_classification(labels, body);
+    return void 0;
+  } catch (error) {
+    return error_text.message_of(error);
+  }
+}
+function with_release_classification(body, labels = required_labels(body)) {
+  const line = pr_classification.declaration(OTHER_CHANGE_LABEL);
+  const amended = body.replace(NON_BUG_LINE, (non_bug) => `${non_bug}
+${line}`);
+  if (selection_problem(body, labels) === void 0) return body;
+  return selection_problem(amended, labels) === void 0 ? amended : body;
+}
+function release_problem(body, labels) {
+  if (bug_classification_problem(body) !== void 0 || label_conflict(body) !== void 0) {
+    return void 0;
+  }
+  return selection_problem(with_release_classification(body, labels), labels);
+}
+function problems3(body, labels = required_labels(body)) {
+  const found = [
+    bug_classification_problem(body),
+    label_conflict(body),
+    release_problem(body, labels),
+    defect_origin_line.problem(body),
+    defect_origin_line.reproduction_problem(body)
+  ];
+  return found.filter((problem) => problem !== void 0);
+}
+var issue_classification = {
+  CLASSIFICATION_LABELS,
+  labels_for,
+  problems: problems3,
+  required_labels,
+  with_release_classification
+};
+
+// scripts/issue/issue-lint.ts
+var REQUIRED_HEADINGS = ["background", "symptom", "expected", "criteria"].map((name) => issue_body_keys.heading(name));
+function missing_headings(body) {
+  return REQUIRED_HEADINGS.filter((heading) => !markdown_section.has_line(body, heading));
+}
+var issue_lint = {
+  missing_headings,
+  REQUIRED_HEADINGS
+};
+
+// scripts/issue/issue-template-section.ts
+import { existsSync, readFileSync } from "node:fs";
+var TEMPLATE_PATHS = {
+  ja: "prompts/collaboration-workflow/issue-template.md",
+  en: "prompts/collaboration-workflow/issue-template.en.md"
+};
+var TEMPLATE_FENCE = "````";
+function template_lines(document) {
+  const lines = markdown_section.lines_of(document);
+  const start = lines.findIndex((line) => line.startsWith(TEMPLATE_FENCE));
+  const end = lines.findIndex((line, index) => index > start && line.trim() === TEMPLATE_FENCE);
+  if (start === -1 || end === -1) return [];
+  return lines.slice(start + 1, end);
+}
+function section_of(document, heading) {
+  const template = template_lines(document).join("\n");
+  if (!markdown_section.has_line(template, heading)) return void 0;
+  return [heading, ...markdown_section.section_lines(template, heading)].join("\n").trimEnd();
+}
+function section(heading) {
+  const template_path = package_path(TEMPLATE_PATHS[issue_body_keys.column()]);
+  if (!existsSync(template_path)) return void 0;
+  return section_of(readFileSync(template_path, "utf8"), heading);
+}
+var issue_template_section = { section, section_of };
+
+// scripts/issue/issue-lint-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var OK_MESSAGE = "ok";
+var NO_LABELS = "none";
+var USAGE = "Usage: josh issue:lint <path-to-issue-body>";
+var MISSING_HEADING_PREFIX = "missing heading: ";
+function with_template(problem) {
+  if (!problem.startsWith(MISSING_HEADING_PREFIX)) return problem;
+  const template = issue_template_section.section(problem.slice(MISSING_HEADING_PREFIX.length));
+  return template === void 0 ? problem : `${problem}
+${template}`;
+}
+function problems4(body, labels) {
+  const missing = issue_lint.missing_headings(body).map((heading) => `${MISSING_HEADING_PREFIX}${heading}`);
+  return [
+    ...missing,
+    ...behavior_change_lint.problems(body),
+    ...enforcement_lint.problems(body),
+    ...expected_effect_lint.problems(body),
+    ...issue_classification.problems(body, labels),
+    ...issue_not_before.problems(body),
+    ...measure_declaration.problems(body),
+    ...size_estimate.problems(body),
+    ...aggregation_split.problems(body),
+    issue_auto_ok.decision_problem(body),
+    issue_priority.order_problem(body)
+  ].filter((problem) => problem !== void 0).map((problem) => with_template(problem));
+}
+function warn(body) {
+  for (const warning of figure_source_lint.warnings(body)) console.warn(`\u26A0 ${warning}`);
+}
+function report(found, body) {
+  warn(body);
+  if (found.length === 0) {
+    console.info(OK_MESSAGE);
+    console.info(`labels: ${issue_classification.required_labels(body).join(", ") || NO_LABELS}`);
+    return SUCCESS_EXIT_CODE;
+  }
+  console.error(found.map((problem) => `\u2716 ${problem}`).join("\n"));
+  return FAILURE_EXIT_CODE;
+}
+async function run(body_path) {
+  if (body_path === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  const body = cli_body.read_file_or_stdin(body_path);
+  return report(problems4(body), body);
+}
+var issue_lint_cli = { problems: problems4, run, warn };
+
+export {
+  issue_classification,
+  issue_lint_cli
+};

package/dist/commands/chunk-BVUL57IX.js

@@ -0,0 +1,139 @@
+import {
+  latest_lane_guard
+} from "./chunk-33TAOZUE.js";
+import {
+  overrides_diff_report
+} from "./chunk-V5OUZFWK.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/version/latest-stamp.ts
+var STAMP_PREFIX = "josh-latest-stamp-";
+var DEFAULT_MAX_AGE_HOURS = 12;
+var MAX_AGE_ENV_VAR = "JOSH_LATEST_MAX_AGE_HOURS";
+var MS_PER_HOUR = 36e5;
+function stamp_path() {
+  return stamp_file.stamp_path(STAMP_PREFIX, PROJECT_ROOT);
+}
+function read_max_age_hours(environment = process.env) {
+  const raw = Number(environment[MAX_AGE_ENV_VAR]);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_MAX_AGE_HOURS;
+}
+function parse_stamp(raw) {
+  const { ran_at } = JSON.parse(raw);
+  if (typeof ran_at !== "string" || Number.isNaN(Date.parse(ran_at))) return void 0;
+  return { ran_at };
+}
+function read_stamp(source = stamp_path()) {
+  const raw = stamp_file.read_stamp_text(source);
+  if (raw === void 0) return void 0;
+  try {
+    return parse_stamp(raw);
+  } catch {
+    return void 0;
+  }
+}
+function write_stamp(target = stamp_path()) {
+  const stamp = { ran_at: (/* @__PURE__ */ new Date()).toISOString() };
+  return stamp_file.write_stamp(target, stamp);
+}
+function hours_since(stamp, now = /* @__PURE__ */ new Date()) {
+  return (now.getTime() - Date.parse(stamp.ran_at)) / MS_PER_HOUR;
+}
+function is_fresh(stamp, now = /* @__PURE__ */ new Date(), max_age_hours) {
+  return Math.abs(hours_since(stamp, now)) < (max_age_hours ?? read_max_age_hours());
+}
+var latest_stamp = {
+  DEFAULT_MAX_AGE_HOURS,
+  hours_since,
+  is_fresh,
+  MAX_AGE_ENV_VAR,
+  read_max_age_hours,
+  read_stamp,
+  stamp_path,
+  write_stamp
+};
+
+// scripts/version/latest-scope-cli.ts
+var USAGE = "Usage: josh latest:scope [--record] [--json]";
+var JSON_KEY = "scope";
+var JSON_FLAG = "--json";
+var RECORD_FLAG = "--record";
+var KNOWN_FLAGS = /* @__PURE__ */ new Set([JSON_FLAG, RECORD_FLAG]);
+var REQUIRED_SCOPE = "required";
+var SKIPPED_SCOPE = "skip";
+var FAILURE_EXIT_CODE = 1;
+var NO_STAMP_REASON = "no record of a `josh latest` run in this checkout \u2014 update rather than assume the dependencies are current";
+var HOURS_PRECISION = 1;
+var PIN_CHECK_RANGE = "HEAD";
+var OVERRIDES_MOVED_EXIT_CODE = 3;
+function format_hours(hours) {
+  return hours.toFixed(HOURS_PRECISION);
+}
+function describe_stamp(stamp, max_age_hours, is_fresh2) {
+  const age = format_hours(latest_stamp.hours_since(stamp));
+  const window = format_hours(max_age_hours);
+  if (is_fresh2) return `last run ${age}h ago, inside the ${window}h window \u2014 nothing to update`;
+  return `last run ${age}h ago, past the ${window}h window \u2014 update before implementing`;
+}
+function decide() {
+  const stamp = latest_stamp.read_stamp();
+  if (stamp === void 0) return { scope: REQUIRED_SCOPE, reason: NO_STAMP_REASON };
+  const max_age_hours = latest_stamp.read_max_age_hours();
+  const is_fresh2 = latest_stamp.is_fresh(stamp, /* @__PURE__ */ new Date(), max_age_hours);
+  return {
+    scope: is_fresh2 ? SKIPPED_SCOPE : REQUIRED_SCOPE,
+    reason: describe_stamp(stamp, max_age_hours, is_fresh2)
+  };
+}
+function scope_decision() {
+  if (latest_lane_guard.is_lane()) {
+    return { scope: SKIPPED_SCOPE, reason: latest_lane_guard.LANE_SCOPE_REASON };
+  }
+  return decide();
+}
+function print_decision(decision, is_json) {
+  if (is_json) {
+    console.info(JSON.stringify({ [JSON_KEY]: decision.scope, reason: decision.reason }));
+    return;
+  }
+  console.info(decision.scope);
+  console.error(decision.reason);
+}
+function record() {
+  try {
+    console.error(`recorded this josh latest run at ${latest_stamp.write_stamp()}`);
+  } catch (error) {
+    console.error(`could not record this josh latest run: ${String(error)}`);
+  }
+  return overrides_diff_report.judge_overrides(PIN_CHECK_RANGE) ? 0 : OVERRIDES_MOVED_EXIT_CODE;
+}
+function run(argv) {
+  if (argv.some((argument) => !KNOWN_FLAGS.has(argument))) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  if (argv.includes(RECORD_FLAG)) return record();
+  print_decision(scope_decision(), argv.includes(JSON_FLAG));
+  return 0;
+}
+var latest_scope_cli = {
+  decide,
+  JSON_KEY,
+  NO_STAMP_REASON,
+  OVERRIDES_MOVED_EXIT_CODE,
+  RECORD_FLAG,
+  REQUIRED_SCOPE,
+  run,
+  scope_decision,
+  SKIPPED_SCOPE,
+  USAGE
+};
+
+export {
+  latest_scope_cli
+};

package/dist/commands/chunk-C7FGDZWP.js

@@ -0,0 +1,224 @@
+import {
+  test_pinned_logic
+} from "./chunk-RAQ3E6OT.js";
+import {
+  review_readers_scan
+} from "./chunk-W6MVQEMO.js";
+import {
+  git_grep_hits
+} from "./chunk-LU5EOGFQ.js";
+import {
+  COMMAND_MAP
+} from "./chunk-CCHJZEF5.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/review/prose-stale-scan.ts
+var CODE_FILE = /\.(?:ts|js)$/u;
+var TEST_FILE = /\.test\.(?:ts|js)$/u;
+var IDENTIFIER_SHAPE = /[_\d]|[a-z][A-Z]/u;
+var REGEXP_SPECIAL = /[$()*+.?[\\\]^{|}]/gu;
+var BACKTICK = "`";
+var SPAN_PARITY = 2;
+var MARKDOWN_EXTENSION = ".md";
+var MARKDOWN_FILE = /\.md$/u;
+var COMMAND = /\bjosh\s+(?<command>[a-z][\w-]*:[\w:-]+)/gu;
+var UPPER_CASE = /^[A-Z][A-Z\d_]*[A-Z\d]$/u;
+var HEADING = /^#{1,6} (?<text>.+)$/u;
+var TOKEN = /[\w-]+(?::[\w-]+)*/gu;
+var COMMENT_LINE = /^\s*(?:\/[/*]|\*|#)/u;
+var OK_LINE = "ok";
+var FOUND_EXIT = 1;
+var FAILED_EXIT = 2;
+function to_terms(kind, words) {
+  return words.map((word) => ({ kind, word }));
+}
+function declared_names(source, is_deleted) {
+  if (is_deleted) return review_readers_scan.reachable_names(source);
+  return review_readers_scan.declarations(source).map((entry) => entry.name);
+}
+function code_terms(source, is_deleted) {
+  const declared = declared_names(source, is_deleted);
+  const listed = [...review_readers_scan.exported_names(source)];
+  const constants = declared.filter((name) => UPPER_CASE.test(name));
+  const names = [...declared.filter((name) => !UPPER_CASE.test(name)), ...listed];
+  return [...to_terms("name", names), ...to_terms("constant", constants)];
+}
+function command_terms(lines) {
+  const commands = lines.flatMap(
+    (line) => [...line.matchAll(COMMAND)].map((match) => match.groups?.["command"] ?? "")
+  );
+  return to_terms("command", commands);
+}
+function headings(lines) {
+  const texts = lines.map((line) => HEADING.exec(line)?.groups?.["text"]?.trim());
+  return texts.filter((text) => text !== void 0 && text !== "");
+}
+function declared_in(lines) {
+  return review_readers_scan.declarations(lines.join("\n")).map((entry) => entry.name);
+}
+function renamed_terms(hunk) {
+  const before = declared_in(hunk.old_lines);
+  const after = declared_in(hunk.new_lines ?? []);
+  const gone = before.filter((name) => !after.includes(name));
+  const fresh = after.filter((name) => !before.includes(name));
+  return gone.flatMap((word, index) => {
+    const renamed_to = fresh[index];
+    if (renamed_to === void 0) return [];
+    return [{ kind: UPPER_CASE.test(word) ? "constant" : "name", word, renamed_to }];
+  });
+}
+function hunk_terms(hunk, deleted) {
+  const lines = hunk.old_lines;
+  const is_code = CODE_FILE.test(hunk.file) && !TEST_FILE.test(hunk.file);
+  const source = lines.join("\n");
+  const code = is_code ? [...code_terms(source, deleted.has(hunk.file)), ...renamed_terms(hunk)] : [];
+  const titled = hunk.file.endsWith(MARKDOWN_EXTENSION) ? to_terms("heading", headings(lines)) : [];
+  return [...code, ...command_terms(lines), ...titled];
+}
+function added_lines(hunks, extension) {
+  return hunks.filter((hunk) => extension.test(hunk.file)).flatMap((hunk) => hunk.new_lines ?? []);
+}
+function kept_of(hunks, registered) {
+  const added = hunks.flatMap((hunk) => hunk.new_lines ?? []);
+  const titles = headings(added_lines(hunks, MARKDOWN_FILE));
+  const declared = declared_in(added_lines(hunks, CODE_FILE));
+  const tokens = added.flatMap((line) => [...line.matchAll(TOKEN)].map((match) => match[0]));
+  return {
+    tokens: new Set(tokens),
+    titles: new Set(titles),
+    declared: new Set(declared),
+    registered
+  };
+}
+function is_removed(term, kept) {
+  if (term.renamed_to !== void 0) return !kept.declared.has(term.word);
+  if (term.kind === "heading") return !kept.titles.has(term.word);
+  if (term.kind === "command" && kept.registered.has(term.word)) return false;
+  return !kept.tokens.has(term.word);
+}
+var EMPTY_TREE = { surviving: /* @__PURE__ */ new Set(), deleted: /* @__PURE__ */ new Set() };
+function stale_terms(hunks, registered, tree = EMPTY_TREE) {
+  const { surviving, deleted } = tree;
+  const kept = kept_of(hunks, registered);
+  const terms = hunks.flatMap((hunk) => hunk_terms(hunk, deleted));
+  const unique = new Map(terms.map((term) => [term.word, term]));
+  return [...unique.values()].filter((term) => !surviving.has(term.word) && is_removed(term, kept));
+}
+function pattern(term) {
+  if (term.kind === "heading") return { target: `"${term.word}"`, flags: [] };
+  return { target: term.word, flags: ["-w"] };
+}
+function is_prose(hit) {
+  return hit.path.endsWith(MARKDOWN_EXTENSION) || COMMENT_LINE.test(hit.excerpt);
+}
+function code_spans(excerpt) {
+  return excerpt.split(BACKTICK).filter((_span, index) => index % SPAN_PARITY === 1);
+}
+function code_shape(word) {
+  const shapes = [
+    String.raw`\.${word}(?![\w$])`,
+    String.raw`(?<![\w$])${word}\(`,
+    String.raw`\{\s*(?:[\w$]+\s*,\s*)*${word}\s*[,}]`,
+    String.raw`\bimport\s+${word}\s+from\b`
+  ];
+  return new RegExp(shapes.join("|"), "u");
+}
+function is_code_use(term, excerpt) {
+  if (term.kind !== "name" || IDENTIFIER_SHAPE.test(term.word)) return true;
+  const word = term.word.replaceAll(REGEXP_SPECIAL, String.raw`\$&`);
+  const whole = new RegExp(String.raw`(?<![\w$])${word}(?![\w$])`, "u");
+  return code_spans(excerpt).some((span) => whole.test(span)) || code_shape(word).test(excerpt);
+}
+function reference_lines(reference) {
+  const { kind, word, renamed_to } = reference.term;
+  const label = renamed_to === void 0 ? word : `${word} (renamed to ${renamed_to})`;
+  if (reference.has_failed) return [`search failed: ${kind} ${label}`];
+  return reference.hits.filter((hit) => is_prose(hit) && is_code_use(reference.term, hit.excerpt)).map((hit) => `${hit.path}:${hit.line} ${kind} ${label}`);
+}
+function exit_code_of(references2, lines) {
+  if (references2.some((reference) => reference.has_failed)) return FAILED_EXIT;
+  return lines.length > 0 ? FOUND_EXIT : 0;
+}
+function report(references2) {
+  const lines = references2.flatMap((reference) => reference_lines(reference));
+  return {
+    text: lines.length > 0 ? lines.join("\n") : OK_LINE,
+    exit_code: exit_code_of(references2, lines)
+  };
+}
+var prose_stale_scan = { CODE_FILE, FAILED_EXIT, pattern, report, stale_terms };
+
+// scripts/review/prose-stale-read.ts
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+var SEARCH_PATHS = ["*.md", "prompts", "docs", ".claude", "scripts", ":(exclude)CHANGELOG.md"];
+var CODE_PATHSPECS = ["*.ts", "*.js", ":(exclude)*.test.ts", ":(exclude)*.test.js"];
+async function read_hunks(root, base) {
+  const diff = await git_spawn.read([
+    "-C",
+    root,
+    "diff",
+    "-U0",
+    "--no-color",
+    "--no-ext-diff",
+    "--src-prefix=a/",
+    "--dst-prefix=b/",
+    base
+  ]);
+  return test_pinned_logic.all_hunks(diff);
+}
+async function reference_of(term, root) {
+  const { target, flags } = prose_stale_scan.pattern(term);
+  const { hits, has_failed } = await git_grep_hits.search(target, flags, SEARCH_PATHS, root);
+  return { term, hits, has_failed };
+}
+async function declared_in2(root, files) {
+  const sources = await Promise.all(
+    files.map(async (file) => await readFile(path.join(root, file), "utf8"))
+  );
+  return sources.flatMap(
+    (source) => review_readers_scan.declarations(source).map(({ name }) => name)
+  );
+}
+async function files_writing(root, names) {
+  const results = await Promise.all(
+    names.map(async (name) => await git_grep_hits.search(name, ["-w"], CODE_PATHSPECS, root))
+  );
+  const files = new Set(results.flatMap(({ hits }) => hits.map((hit) => hit.path)));
+  return [...files].filter((file) => existsSync(path.join(root, file)));
+}
+async function declared_elsewhere(root, hunks, deleted) {
+  const gone = hunks.filter((hunk) => deleted.includes(hunk.file));
+  const names = [
+    ...new Set(
+      gone.flatMap((hunk) => review_readers_scan.reachable_names(hunk.old_lines.join("\n")))
+    )
+  ];
+  const declared = new Set(await declared_in2(root, await files_writing(root, names)));
+  return names.filter((name) => declared.has(name));
+}
+async function tree_of(root, hunks) {
+  const files = [...new Set(hunks.map((hunk) => hunk.file))].filter(
+    (file) => prose_stale_scan.CODE_FILE.test(file)
+  );
+  const present = files.filter((file) => existsSync(path.join(root, file)));
+  const names = await declared_in2(root, present);
+  const deleted = files.filter((file) => !present.includes(file));
+  const elsewhere = await declared_elsewhere(root, hunks, deleted);
+  return { surviving: /* @__PURE__ */ new Set([...names, ...elsewhere]), deleted: new Set(deleted) };
+}
+async function references(root, hunks) {
+  const registered = new Set(Object.keys(COMMAND_MAP));
+  const tree = await tree_of(root, hunks);
+  const terms = prose_stale_scan.stale_terms(hunks, registered, tree);
+  return await Promise.all(terms.map(async (term) => await reference_of(term, root)));
+}
+var prose_stale_read = { read_hunks, references };
+
+export {
+  prose_stale_scan,
+  prose_stale_read
+};