@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-45RCSJGE.js

@@ -0,0 +1,321 @@
+import {
+  bash_output_cap_reader
+} from "./chunk-JFLFGLE4.js";
+import {
+  cost_tokens,
+  lane_instructions
+} from "./chunk-SCCUBRDO.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-4DNAAFF4.js

@@ -0,0 +1,159 @@
+import {
+  session_language
+} from "./chunk-OKYFQJW3.js";
+
+// scripts/issue/issue-body-keys.ts
+var KEYS = {
+  kind: { ja: "\u7A2E\u5225", en: "Type" },
+  purpose: { ja: "\u76EE\u7684", en: "Purpose" },
+  compatibility: { ja: "\u4E92\u63DB\u6027", en: "Compatibility" },
+  release: { ja: "\u30EA\u30EA\u30FC\u30B9\u5206\u985E", en: "Release classification" },
+  judgement: { ja: "\u4EBA\u306E\u5224\u65AD", en: "Human judgement" },
+  decision_rule: { ja: "\u5224\u5B9A\u898F\u5247", en: "Decision rule" },
+  close_condition: { ja: "\u4E2D\u6B62\u6761\u4EF6", en: "Close condition" },
+  priority: { ja: "\u512A\u5148\u5EA6", en: "Priority" },
+  security: { ja: "\u30BB\u30AD\u30E5\u30EA\u30C6\u30A3", en: "Security" },
+  cause_park: { ja: "\u539F\u56E0\u306E park", en: "Cause park" },
+  cause_lane: { ja: "\u539F\u56E0\u306E\u30EC\u30FC\u30F3", en: "Cause lane" },
+  cause_loss: { ja: "\u539F\u56E0\u306E\u640D\u5931", en: "Cause loss" },
+  order: { ja: "\u5B9F\u65BD\u9806", en: "Order" },
+  origin: { ja: "\u539F\u56E0", en: "Cause" },
+  size: { ja: "\u898F\u6A21\u898B\u7A4D\u3082\u308A", en: "Size estimate" },
+  no_split_reason: { ja: "\u5206\u5272\u3057\u306A\u3044\u7406\u7531", en: "No-split reason" },
+  no_lines: { ja: "\u884C\u3092\u5897\u3084\u3055\u306A\u3044", en: "No added lines" },
+  refactor_first: { ja: "\u5148\u884C\u30EA\u30D5\u30A1\u30AF\u30BF", en: "Refactor first" },
+  enforcement: { ja: "\u5F37\u5236", en: "Enforcement" },
+  measurement: { ja: "\u8A08\u6E2C", en: "Measurement" },
+  measure_declaration: { ja: "\u8A08\u6E2C\u5BA3\u8A00", en: "Measure declaration" },
+  premise: { ja: "\u524D\u63D0", en: "Premise" },
+  measure_absent: { ja: "\u8A08\u6E2C\u5BA3\u8A00\u306A\u3057", en: "No measure declaration" },
+  sample_gate: { ja: "\u5B9F\u65BD\u53EF\u80FD\u6761\u4EF6", en: "Sample gate" },
+  not_before: { ja: "\u5B9F\u65BD\u53EF\u80FD\u65E5", en: "Not before" },
+  source: { ja: "\u51FA\u3069\u3053\u308D", en: "Source" },
+  constraint_source: { ja: "\u51FA\u6240", en: "Constraint source" },
+  constraint_reference: { ja: "\u53C2\u7167", en: "Constraint reference" },
+  constraint_instruction: { ja: "\u6307\u793A", en: "Constraint instruction" }
+};
+var VALUES = {
+  bug: { ja: "\u4E0D\u5177\u5408", en: "defect" },
+  non_bug: { ja: "\u975E\u4E0D\u5177\u5408", en: "non-defect" },
+  behavior_change: { ja: "\u632F\u308B\u821E\u3044\u5909\u66F4", en: "behavior change" },
+  feature: { ja: "\u6A5F\u80FD\u8FFD\u52A0", en: "feature" },
+  improvement: { ja: "\u6A5F\u80FD\u6539\u5584", en: "improvement" },
+  time_saving: { ja: "\u6642\u9593\u77ED\u7E2E", en: "time saving" },
+  bug_fix: { ja: "\u4E0D\u5177\u5408\u4FEE\u6B63", en: "bug fix" },
+  breaking: { ja: "\u7834\u58CA\u7684\u5909\u66F4", en: "breaking change" },
+  not_needed: { ja: "\u4E0D\u8981", en: "not needed" },
+  needed: { ja: "\u8981", en: "needed" },
+  normal: { ja: "\u901A\u5E38", en: "normal" },
+  high: { ja: "\u9AD8", en: "high" },
+  critical: { ja: "\u7DCA\u6025", en: "critical" },
+  last: { ja: "\u6700\u5F8C", en: "last" },
+  unknown: { ja: "\u4E0D\u660E", en: "unknown" },
+  none: { ja: "\u306A\u3057", en: "none" }
+};
+var HEADINGS = {
+  summary: { ja: "\u6982\u8981", en: "Summary" },
+  background: { ja: "\u80CC\u666F", en: "Background" },
+  symptom: { ja: "\u73FE\u8C61", en: "Symptom" },
+  expected: { ja: "\u671F\u5F85\u7D50\u679C", en: "Expected result" },
+  criteria: { ja: "\u53D7\u3051\u5165\u308C\u6761\u4EF6", en: "Acceptance criteria" },
+  trigger: { ja: "\u767A\u706B\u70B9", en: "Trigger" },
+  baseline: { ja: "\u30D9\u30FC\u30B9\u30E9\u30A4\u30F3", en: "Baseline" },
+  reproduction: { ja: "\u518D\u73FE", en: "Reproduction" },
+  expected_effect: { ja: "\u671F\u5F85\u52B9\u679C", en: "Expected effect" },
+  auto_execution_constraint: { ja: "\u81EA\u52D5\u5B9F\u884C\u306E\u5236\u7D04", en: "Automatic execution constraint" }
+};
+var SIZE_VALUES = {
+  ja: "\u7D04 <files> \u30D5\u30A1\u30A4\u30EB / <lines> \u884C\uFF08\u30C6\u30B9\u30C8\u9664\u304F\uFF09",
+  en: "about <files> files / <lines> lines (excluding tests)"
+};
+var SIZE_PATTERNS = [
+  /^約\s*(?<files>\d+)\s*ファイル\s*\/\s*(?<lines>\d+)\s*行\s*[（(]テスト除く[）)]$/u,
+  /^about\s*(?<files>\d+)\s*files?\s*\/\s*(?<lines>\d+)\s*lines?\s*\(excluding tests\)$/iu
+];
+var COLUMNS = ["ja", "en"];
+var HEADING_PREFIX = "## ";
+var BULLET = "- ";
+var KEY_END = ":";
+var VALUE_END = /^(?:$|[^\p{L}\p{N}-])/u;
+var VALUE_TEXTS = Object.values(VALUES).flatMap((row) => COLUMNS.map((at) => ({ row, text: row[at] }))).toSorted((left, right) => right.text.length - left.text.length);
+function column() {
+  return session_language.is_japanese(session_language.resolve_session_lang().lang) ? "ja" : "en";
+}
+function text_of(row) {
+  return row[column()];
+}
+function key(name) {
+  return text_of(KEYS[name]);
+}
+function value(name) {
+  return text_of(VALUES[name]);
+}
+function prefix(name) {
+  return `- ${key(name)}:`;
+}
+function line(name, value_name) {
+  return `${prefix(name)} ${value(value_name)}`;
+}
+function prefix_variants(name) {
+  return COLUMNS.map((at) => `- ${KEYS[name][at]}:`);
+}
+function line_variants(name, value_name) {
+  return COLUMNS.map((at) => `- ${KEYS[name][at]}: ${VALUES[value_name][at]}`);
+}
+function heading(name) {
+  return `## ${text_of(HEADINGS[name])}`;
+}
+function size_value(files, lines) {
+  return text_of(SIZE_VALUES).replace("<files>", () => files).replace("<lines>", () => lines);
+}
+function size_counts(text) {
+  return SIZE_PATTERNS.map((pattern) => pattern.exec(text)?.groups).find(Boolean);
+}
+function row_named(rows, text) {
+  return Object.values(rows).find((row) => COLUMNS.some((at) => row[at] === text));
+}
+function indent_of(raw) {
+  return raw.slice(0, raw.length - raw.trimStart().length);
+}
+function canonical_value(rest) {
+  const trimmed = rest.trimStart();
+  const found = VALUE_TEXTS.find(
+    ({ text }) => trimmed.startsWith(text) && VALUE_END.test(trimmed.slice(text.length))
+  );
+  if (found === void 0) return rest;
+  return `${indent_of(rest)}${text_of(found.row)}${trimmed.slice(found.text.length)}`;
+}
+function canonical_declaration(raw) {
+  const text = raw.trimStart();
+  const end = text.indexOf(KEY_END);
+  const row = end !== -1 && text.startsWith(BULLET) ? row_named(KEYS, text.slice(BULLET.length, end)) : void 0;
+  return row === void 0 ? void 0 : `${indent_of(raw)}${BULLET}${text_of(row)}${KEY_END}${canonical_value(text.slice(end + 1))}`;
+}
+function canonical_heading(raw) {
+  const text = raw.trim();
+  const row = text.startsWith(HEADING_PREFIX) ? row_named(HEADINGS, text.slice(HEADING_PREFIX.length)) : void 0;
+  return row === void 0 ? void 0 : `${indent_of(raw)}${HEADING_PREFIX}${text_of(row)}`;
+}
+function canonical_line(raw) {
+  return canonical_heading(raw) ?? canonical_declaration(raw) ?? raw;
+}
+var TABLES = { keys: KEYS, values: VALUES, headings: HEADINGS };
+var issue_body_keys = {
+  canonical_line,
+  column,
+  heading,
+  line,
+  line_variants,
+  prefix,
+  prefix_variants,
+  size_counts,
+  size_value,
+  TABLES,
+  value
+};
+
+export {
+  issue_body_keys
+};

package/dist/commands/chunk-4E5WBWG7.js

@@ -0,0 +1,70 @@
+import {
+  lane_ledger_write
+} from "./chunk-V56NLG7I.js";
+import {
+  git_common_directory
+} from "./chunk-MT6TRLFD.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/review/review-stop-log.ts
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+var LOG_FILE = "review-stops.jsonl";
+var LINE_SEPARATOR = "\n";
+var stop_line_schema = z.object({
+  at: z.string(),
+  issue: z.number(),
+  stage: z.string(),
+  kind: z.string(),
+  location: z.string(),
+  sentence: z.string(),
+  fixed: z.boolean().optional()
+});
+function target() {
+  if (process.env["VITEST"] !== void 0) return void 0;
+  const common = git_common_directory.repository();
+  return common === void 0 ? void 0 : path.join(common, git_common_directory.STATE_DIRECTORY, LOG_FILE);
+}
+function write(destination, stop) {
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const mark = stop.is_fixed === true ? { fixed: true } : {};
+  mkdirSync(path.dirname(destination), { recursive: true });
+  for (const finding of stop.findings) {
+    lane_ledger_write.append(destination, {
+      at,
+      issue: stop.issue,
+      stage: stop.stage,
+      ...finding,
+      ...mark
+    });
+  }
+}
+function record(stop, log_path = target()) {
+  if (log_path === void 0 || stop.findings.length === 0) return;
+  try {
+    write(log_path, stop);
+  } catch {
+  }
+}
+function parse_line(line) {
+  return stop_line_schema.safeParse(json_value.parse_or_undefined(line)).data;
+}
+function is_present(line) {
+  return line !== void 0;
+}
+function read(log_path = target()) {
+  const raw = log_path === void 0 ? void 0 : stamp_file.read_stamp_text(log_path);
+  if (raw === void 0) return [];
+  return raw.split(LINE_SEPARATOR).map((line) => parse_line(line.trim())).filter(is_present);
+}
+var review_stop_log = { read, record, target };
+
+export {
+  review_stop_log
+};

package/dist/commands/chunk-4MRBLCDB.js

@@ -0,0 +1,96 @@
+// scripts/test/whole-suite-files.ts
+import path from "node:path";
+
+// scripts/test/unit-setup-files.ts
+var STATE_GUARD = ["./tools/test/test-state-guard.ts"];
+var STDOUT_GUARD = ["./tools/test/test-stdout-guard.ts"];
+var TELEGRAM_GUARD = ["./tools/test/test-telegram-guard.ts"];
+var MACHINE_GUARD = ["./tools/test/test-machine-guard.ts"];
+var NETWORK_GUARD = ["./tools/test/test-network-guard.ts"];
+var WORKER_GUARDS = [...STDOUT_GUARD, ...TELEGRAM_GUARD, ...MACHINE_GUARD];
+var READ_RECORDER = ["./tools/test/test-read-recorder.ts"];
+var UNIT_FILE_REPORTER = "./vitest.reporter.config.ts";
+var unit_setup_files = {
+  MACHINE_GUARD,
+  NETWORK_GUARD,
+  READ_RECORDER,
+  STATE_GUARD,
+  STDOUT_GUARD,
+  UNIT_FILE_REPORTER,
+  TELEGRAM_GUARD,
+  WORKER_GUARDS
+};
+
+// scripts/test/whole-suite-files.ts
+var SETUP_FILES = [
+  ...unit_setup_files.NETWORK_GUARD,
+  ...unit_setup_files.STATE_GUARD,
+  ...unit_setup_files.WORKER_GUARDS,
+  ...unit_setup_files.READ_RECORDER
+];
+var ROOT_FILES = [
+  "package.json",
+  "pnpm-lock.yaml",
+  "pnpm-workspace.yaml",
+  "tsconfig.json",
+  "vitest.config.ts",
+  "vitest.harness.config.ts",
+  // What the read recorder runs in every worker, which no test imports through the setup file.
+  "tools/test/test-read-capture.ts",
+  "scripts/test/test-read-trace.ts"
+];
+var IMPORTED_BY_EVERY_TEST = [
+  "scripts/agent/agent-headless.ts",
+  "scripts/git/constants.ts",
+  "scripts/git/git-location-environment.ts",
+  "scripts/init/init-paths.ts",
+  "scripts/josh/agent-session-environment.ts",
+  "scripts/josh/platform-temporary.ts",
+  "scripts/josh/process-identity.ts",
+  "scripts/josh/process-owner.ts",
+  "scripts/josh/stamp-file.ts",
+  "scripts/lane/lane-child-mark-keys.ts",
+  "scripts/lib/atomic-write.ts",
+  "scripts/lib/json-value.ts",
+  "scripts/lib/read-file.ts",
+  "scripts/lib/timeouts.ts",
+  "scripts/run/run-headless-keys.ts",
+  "scripts/test/unit-durations.ts",
+  "scripts/test/unit-run-marker.ts",
+  "scripts/test/unit-setup-files.ts",
+  "scripts/test/vitest-cache-directory.ts",
+  "scripts/test/vitest-cli-excludes.ts",
+  "tools/test/duration-sequencer.ts",
+  "tools/test/duration-shard.ts",
+  "tools/test/pure-files.ts",
+  "tools/test/test-module-elapsed.ts",
+  "tools/test/test-repository-guard.ts",
+  "tools/test/unit-duration-record.ts",
+  "tools/test/unit-guard-environment.ts",
+  "tools/test/unit-projects.ts",
+  "tools/test/vitest-config-workers.ts",
+  "tools/test/vitest-include-globs.ts"
+];
+var WHOLE_SUITE_FILES = new Set(
+  [...ROOT_FILES, ...IMPORTED_BY_EVERY_TEST, ...SETUP_FILES].map((file) => path.normalize(file))
+);
+var EVERY_TEST_IMPORTS = new Set(
+  IMPORTED_BY_EVERY_TEST.map((file) => path.normalize(file))
+);
+var UNIT_RUNTIME_PACKAGES = [
+  "vitest",
+  "vite",
+  "vite-node",
+  "typescript",
+  "@vitest/"
+];
+function is_unit_runtime_package(name) {
+  return UNIT_RUNTIME_PACKAGES.some(
+    (entry) => entry.endsWith(path.posix.sep) ? name.startsWith(entry) : name === entry
+  );
+}
+var whole_suite_files = { EVERY_TEST_IMPORTS, WHOLE_SUITE_FILES, is_unit_runtime_package };
+
+export {
+  whole_suite_files
+};