@joshuafolkken/kit 1.3099.0 → 1.3125.0

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

@@ -0,0 +1,119 @@
+import {
+  baseline_measure
+} from "./chunk-RH4LJ4D6.js";
+import {
+  reproduction_measure
+} from "./chunk-C2WXQPF3.js";
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.js";
+
+// scripts/rules/firing-point.ts
+var HOOK_DELIVERABLE_TOOLS = [
+  "Bash",
+  "Edit",
+  "Read",
+  "Write",
+  "AskUserQuestion",
+  "Agent",
+  "Task",
+  "Glob",
+  "Grep",
+  "WebFetch",
+  "Stop"
+];
+var KNOWN_UNDELIVERABLE_TOOLS = ["WebSearch", "TodoWrite", "NotebookEdit"];
+function includes_name(names, name) {
+  return names.includes(name.trim());
+}
+function classify(name) {
+  if (includes_name(HOOK_DELIVERABLE_TOOLS, name)) return "delivered";
+  if (includes_name(KNOWN_UNDELIVERABLE_TOOLS, name)) return "not-delivered";
+  return "unknown";
+}
+var firing_point = {
+  HOOK_DELIVERABLE_TOOLS,
+  KNOWN_UNDELIVERABLE_TOOLS,
+  classify
+};
+
+// scripts/issue/behavior-change-lint.ts
+var DECLARATION_LINE = issue_body_keys.line("kind", "behavior_change");
+var FIRING_POINT_HEADING = issue_body_keys.heading("trigger");
+var BASELINE_HEADING = issue_body_keys.heading("baseline");
+var REPRODUCTION_HEADING = issue_body_keys.heading("reproduction");
+var REQUIRED_HEADINGS = [
+  FIRING_POINT_HEADING,
+  BASELINE_HEADING,
+  REPRODUCTION_HEADING
+];
+var PLACEHOLDER_PREFIX = "<";
+var BACKTICKED = /`([^`]+)`/u;
+var WHITESPACE = /\s+/u;
+var BULLET_MARKER = /^[-*]\s+/u;
+function is_target(body) {
+  return markdown_section.has_line(body, DECLARATION_LINE);
+}
+function missing_headings(body) {
+  return REQUIRED_HEADINGS.filter((heading) => !markdown_section.has_line(body, heading));
+}
+function is_content(line) {
+  return line.length > 0 && !line.startsWith(PLACEHOLDER_PREFIX);
+}
+function first_content_line(lines) {
+  return lines.map((line) => line.trim()).find((line) => is_content(line));
+}
+function firing_point_name(body) {
+  const line = first_content_line(markdown_section.section_lines(body, FIRING_POINT_HEADING));
+  if (line === void 0) return void 0;
+  return BACKTICKED.exec(line)?.[1] ?? line.replace(BULLET_MARKER, "").split(WHITESPACE, 1)[0];
+}
+function firing_point_problem(body) {
+  const name = firing_point_name(body);
+  if (name === void 0) return void 0;
+  if (firing_point.classify(name) === "not-delivered") {
+    return `firing point \`${name}\` is a real tool call, but no hook can deliver a rule on it`;
+  }
+  if (firing_point.classify(name) === "unknown") {
+    return `firing point \`${name}\` is not on the delivery table (not a recognized tool call)`;
+  }
+  return void 0;
+}
+function baseline_problem(body) {
+  if (!markdown_section.has_line(body, BASELINE_HEADING) || baseline_measure.has_command_value(body)) {
+    return void 0;
+  }
+  return "baseline must be written as `command \u2192 value`, not prose (it has to be re-runnable)";
+}
+function reproduction_problem(body) {
+  if (!markdown_section.has_line(body, REPRODUCTION_HEADING) || reproduction_measure.has_command_output(body)) {
+    return void 0;
+  }
+  return 'reproduction must be a command and its actual output (a fenced block), not prose ("\u78BA\u8A8D\u3057\u305F" is not re-runnable)';
+}
+function heading_problems(body) {
+  return missing_headings(body).map((heading) => `missing heading: ${heading}`);
+}
+function problems(body) {
+  if (!is_target(body)) return [];
+  return [
+    ...heading_problems(body),
+    firing_point_problem(body),
+    baseline_problem(body),
+    reproduction_problem(body)
+  ].filter((problem) => problem !== void 0);
+}
+var behavior_change_lint = {
+  is_target,
+  firing_point_name,
+  problems,
+  REQUIRED_HEADINGS,
+  DECLARATION_LINE
+};
+
+export {
+  behavior_change_lint
+};

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

@@ -0,0 +1,117 @@
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.js";
+
+// scripts/issue/measure-declaration.ts
+import { z } from "zod";
+var BACKGROUND_HEADING = issue_body_keys.heading("background");
+var PREFIX = issue_body_keys.prefix("measure_declaration");
+var PREMISE_PREFIX = issue_body_keys.prefix("premise");
+var ABSENT_PREFIX = issue_body_keys.prefix("measure_absent");
+var ABSENT = `${ABSENT_PREFIX} <\u7406\u7531>`;
+var SHAPE = "`<command>` <=|<|>=|> <number>";
+var DECLARATION = `${PREFIX} ${SHAPE}`;
+var VALUE_PATTERN = /^`(?<command>[^`\s][^`]*)`\s*(?<operator><=|>=|<|>)\s*(?<threshold>-?\d+(?:\.\d+)?)$/u;
+var NUMBER_PATTERN = /^-?\d+(?:\.\d+)?$/u;
+var EXAMPLE_VALUE = "`pnpm josh lane:net 5168` <= 40";
+var EXAMPLE = `${PREFIX} ${EXAMPLE_VALUE}`;
+var PLACEHOLDER_PATTERN = /<[^\s<>./][^<>./]*>/u;
+var declaration_schema = z.object({
+  command: z.string().trim(),
+  operator: z.enum(["<=", "<", ">=", ">"]),
+  threshold: z.coerce.number()
+});
+var COMPARE = {
+  "<=": (value, threshold) => value <= threshold,
+  "<": (value, threshold) => value < threshold,
+  ">=": (value, threshold) => value >= threshold,
+  ">": (value, threshold) => value > threshold
+};
+function background_values(body, prefix) {
+  const background = markdown_section.section_lines(body, BACKGROUND_HEADING).join("\n");
+  return markdown_section.unfenced_lines(background).map((text) => text.trim()).filter((text) => text.startsWith(prefix)).map((text) => text.slice(prefix.length).trim());
+}
+function background_value(body, prefix) {
+  return background_values(body, prefix)[0];
+}
+function declared_value(body) {
+  return background_value(body, PREFIX);
+}
+function is_stated(body) {
+  if (declared_value(body) !== void 0) return true;
+  return (background_value(body, ABSENT_PREFIX) ?? "").length > 0;
+}
+function shaped(value) {
+  const read = declaration_schema.safeParse(VALUE_PATTERN.exec(value)?.groups);
+  return read.success ? read.data : void 0;
+}
+function placeholder_of(declaration) {
+  return PLACEHOLDER_PATTERN.exec(declaration.command)?.[0];
+}
+function placeholder_problem(placeholder, prefix) {
+  return `\`${prefix}\` runs its command as written: replace the placeholder \`${placeholder}\` with the value it stands for
+${prefix} ${EXAMPLE_VALUE}`;
+}
+function malformed_problem(prefix) {
+  return `\`${prefix}\` must be written ${prefix} ${SHAPE}
+${prefix} ${EXAMPLE_VALUE}`;
+}
+function value_problems(value, prefix) {
+  const declaration = shaped(value);
+  if (declaration === void 0) return [malformed_problem(prefix)];
+  const placeholder = placeholder_of(declaration);
+  return placeholder === void 0 ? [] : [placeholder_problem(placeholder, prefix)];
+}
+function parsed(value) {
+  const declaration = shaped(value);
+  return declaration === void 0 || placeholder_of(declaration) !== void 0 ? void 0 : declaration;
+}
+function parse(body) {
+  const value = declared_value(body);
+  return value === void 0 ? void 0 : parsed(value);
+}
+function premises(body) {
+  return background_values(body, PREMISE_PREFIX).flatMap((value) => parsed(value) ?? []);
+}
+function problems(body) {
+  const value = declared_value(body);
+  const declared = value === void 0 ? [] : value_problems(value, PREFIX);
+  const premised = background_values(body, PREMISE_PREFIX).flatMap(
+    (premise) => value_problems(premise, PREMISE_PREFIX)
+  );
+  return [...declared, ...premised];
+}
+function value_of(output) {
+  const last = output.split("\n").map((line) => line.trim()).findLast((line) => line.length > 0);
+  return last !== void 0 && NUMBER_PATTERN.test(last) ? Number(last) : void 0;
+}
+function judge(declaration, output) {
+  const value = value_of(output);
+  if (value === void 0) return { kind: "unreadable" };
+  const is_pass = COMPARE[declaration.operator](value, declaration.threshold);
+  return { kind: is_pass ? "pass" : "fail", value };
+}
+function format(declaration) {
+  return `\`${declaration.command}\` ${declaration.operator} ${String(declaration.threshold)}`;
+}
+var measure_declaration = {
+  ABSENT,
+  DECLARATION,
+  EXAMPLE,
+  PREFIX,
+  PREMISE_PREFIX,
+  background_value,
+  format,
+  is_stated,
+  judge,
+  parse,
+  premises,
+  problems
+};
+
+export {
+  measure_declaration
+};

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

@@ -0,0 +1,426 @@
+import {
+  review_round_reuse,
+  run_ship_probe
+} from "./chunk-VD4ELMDA.js";
+import {
+  review_reviewed_tree
+} from "./chunk-JKPYLZ6T.js";
+import {
+  review_record
+} from "./chunk-NASUAXRJ.js";
+import {
+  review_comment_carry
+} from "./chunk-QDUWBRQC.js";
+import {
+  review_comment_round
+} from "./chunk-5SOU366I.js";
+import {
+  review_record_pinned
+} from "./chunk-UN6BPKQ5.js";
+import {
+  review_finding_text,
+  review_fix_round,
+  review_round
+} from "./chunk-5ZWU2B7T.js";
+import {
+  review_interaction
+} from "./chunk-TGCIRQG5.js";
+import {
+  review_finding_ledger
+} from "./chunk-KVURNO74.js";
+import {
+  review_attest,
+  review_checkout
+} from "./chunk-37RULO76.js";
+import {
+  observation_ledger_home
+} from "./chunk-N5FT5LYP.js";
+import {
+  review_stamps
+} from "./chunk-PMC2N6JK.js";
+import {
+  file_map_stamp
+} from "./chunk-M32UPB2D.js";
+import {
+  git_gh_issue_write
+} from "./chunk-C3Y42PHX.js";
+import {
+  run_ship_detach
+} from "./chunk-Z7C2O5JC.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/review/review-lane-handover.ts
+var SHIP_STEP = 'pnpm josh ship --detach --review "<title> #<N>"';
+var NEXT_STEP_LINE = `Next: hand over to \`${SHIP_STEP}\` \u2014 round 2 is the ship's; never reopen \`run:review\` (chain-rule.md step 0).`;
+var SHIP_REVIEWS_LINE = `Files moved since \u2014 a widened \`lane:plan\`'s included \u2014 are the ship's: hand over to \`${SHIP_STEP}\`, whose round 2 reads them, or whose own round 1 reviews again where it does not reuse this one; never reopen \`run:review\` (chain-rule.md step 0).`;
+var UNANSWERED_CAUSE = "git could not answer the reuse question";
+async function answer_here(issue) {
+  try {
+    return await review_round_reuse.answer_here(issue);
+  } catch (error) {
+    error_text.trace_swallowed("review_lane_handover.answer_here", error);
+    return { reuse: review_round_reuse.REUSE.AGAIN, cause: UNANSWERED_CAUSE };
+  }
+}
+async function is_reused_here(issue) {
+  const answer = await answer_here(issue);
+  return answer.reuse !== review_round_reuse.REUSE.AGAIN;
+}
+function is_lane_child_of(issue) {
+  if (lane_child_marker.marked_issue() !== String(issue)) return false;
+  return lane_child_marker.is_child_of(PROJECT_ROOT);
+}
+async function is_handed_over(issue) {
+  if (!is_lane_child_of(issue)) return false;
+  return await is_reused_here(issue);
+}
+async function is_round_attested(issue) {
+  const verdict = await review_record.check(issue);
+  if (verdict.status !== "ok") return false;
+  const checkout = await review_checkout.read_checkout();
+  return review_attest.is_attested_on(checkout, checkout.root);
+}
+async function is_reopen_refused(issue) {
+  if (!is_lane_child_of(issue)) return false;
+  return await is_round_attested(issue);
+}
+function refusal(issue) {
+  return `\u26D4 run:review: round 1 of ${session_cite.issue(issue)} is recorded and attested, and this is a dispatched lane child (\`${lane_child_marker.KEY}\`), so no brief is minted. ${SHIP_REVIEWS_LINE}`;
+}
+var review_lane_handover = {
+  NEXT_STEP_LINE,
+  SHIP_REVIEWS_LINE,
+  answer_here,
+  is_handed_over,
+  is_reopen_refused,
+  refusal
+};
+
+// scripts/review/review-final-record.ts
+function stamp(issue, root = PROJECT_ROOT) {
+  return file_map_stamp.create(
+    `josh-ship-final-review-${issue}-`,
+    root,
+    () => review_attest.read_pointer(root)?.nonce ?? ""
+  );
+}
+function is_attested_final(root) {
+  const pointer = review_attest.read_pointer(root);
+  if (pointer === void 0 || review_round.current(root) !== "2") return false;
+  const expected = review_attest.read_expectation(pointer.nonce);
+  return expected !== void 0 && review_attest.is_attested_on(expected, root);
+}
+function record(issue, findings, root) {
+  const completion = stamp(String(issue), root);
+  const tree = review_stamps.briefed_stamp.read();
+  completion.remove();
+  if (tree === void 0 || !is_attested_final(root) || !review_attest.is_briefed_since(tree.taken_at, root) || findings.some((finding) => finding.severity !== "low")) {
+    return;
+  }
+  completion.write(tree.files, void 0, tree.base);
+  completion.complete();
+}
+var review_final_record = { record, stamp };
+
+// scripts/review/review-record-interaction.ts
+var NOT_REQUIRED_LINE = "No interaction review is due: the change touches no run tooling, changes only comments in it, or this checkout keeps no ledger.";
+var DUE_HEAD = "Interaction review now due";
+function due_line(issue) {
+  return `${DUE_HEAD}: this round\u2019s change touches the run tooling and no interaction pass is recorded. Before \`josh ship\`, record it with \`pnpm josh review:record --from-slot --interaction --issue ${String(issue)} [<n>=<disposition> ...]\` \u2014 if no interaction reviewer ran beside this round, first open its brief with \`pnpm josh review:brief --interaction\` and run that \`reviewer\` \u2014 so a finding is fixed in this lane rather than stopping the ship.`;
+}
+async function report_due(issue, root) {
+  try {
+    if (await review_interaction.status(issue, root) === "missing") console.info(due_line(issue));
+  } catch (error) {
+    error_text.trace_swallowed("review_record_interaction.report_due", error);
+  }
+}
+var review_record_interaction = {
+  due_line,
+  NOT_REQUIRED_LINE,
+  report_due
+};
+
+// scripts/review/review-record-code-round.ts
+var HIGH_SEVERITY = "high";
+function unsettled_files(findings) {
+  return findings.filter((finding) => finding.severity === HIGH_SEVERITY).map((finding) => finding.file);
+}
+async function report_handover(issue) {
+  const is_handed_over2 = await review_lane_handover.is_handed_over(issue);
+  if (is_handed_over2) console.info(review_lane_handover.NEXT_STEP_LINE);
+  return is_handed_over2;
+}
+function is_restarted_here(is_handed_over2) {
+  return is_handed_over2 && !run_ship_detach.is_supervised();
+}
+async function follow(issue, root, findings) {
+  await review_reviewed_tree.record(unsettled_files(findings));
+  const is_handed_over2 = await report_handover(issue);
+  await review_record_interaction.report_due(issue, root);
+  if (!is_restarted_here(is_handed_over2)) return;
+  await review_record_pinned.read_skipped_join(root);
+  await review_record_pinned.restart_if_moved(root);
+}
+var review_record_code_round = { follow };
+
+// scripts/review/review-record-comment.ts
+var FAILURE_EXIT_CODE = 1;
+var AFTER_PUSH_LINE = "The branch is pushed and the tree is clean, so this round is recorded on the issue, not in the ledger \u2014 a ledger line would need a push of its own and restart CI.";
+async function post(issue, lines) {
+  try {
+    const url = await git_gh_issue_write.issue_comment(
+      String(issue),
+      review_comment_round.body_of(lines)
+    );
+    console.info(`Recorded ${String(lines.length)} review-finding line(s) in ${url.trim()}.`);
+    return 0;
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return FAILURE_EXIT_CODE;
+  }
+}
+async function is_after_push() {
+  return await run_ship_probe.is_pushed_clean();
+}
+async function post_after_push(round) {
+  console.info(AFTER_PUSH_LINE);
+  const code = await post(round.issue, round.lines);
+  if (code === 0) await review_record_code_round.follow(round.issue, round.root, round.findings);
+  return code;
+}
+var review_record_comment = { is_after_push, post, post_after_push };
+
+// scripts/review/review-record-cli.ts
+var FAILURE_EXIT_CODE2 = 1;
+var USAGE = "Usage: josh review:record --issue <N> [--comment | --interaction] [[<disposition> ]<category>:<severity>:<file>[ \u2014 <reason>] ...] | josh review:record --check [--interaction] --issue <N>";
+var FILE_HINT = "  <file>: the cited path, optionally with :line";
+var DISPOSITION_HINT = "  <disposition>: optional \u2014 fixed | false-positive | filed:#<M> | deferred:#<M>; josh review:round2 skips only when every High/Medium is fixed or false-positive";
+var REASON_HINT = "  <reason>: optional, one sentence on what was wrong, kept for the lane\u2019s next review and fix \u2014 pass each finding with its reason as one single-quoted argument";
+var CHECK_USAGE = "Usage: josh review:record --check [--interaction] --issue <N>";
+var RECORDED_LINE = "Recorded: the review round for this issue is in the ledger.";
+var REUSED_LINE = "Reused: josh ship takes this round as its round 1 \u2014 the files this round covers hold still since the record. A default branch the ship\u2019s sync merges in moves them only where it changed a file this round covers, and the ship then reviews round 1 again itself.";
+var DELTA_LINE = "Reused, delta to round 2: josh ship takes this round as its round 1 and does not review it again \u2014 every moved path a round executes is one round 2 reads after the commit, or the ship\u2019s own round 1 stopped on it.";
+function review_again_line(cause = "the reuse question gave no reason", is_refused = false) {
+  const next = is_refused ? review_lane_handover.SHIP_REVIEWS_LINE : "Run `pnpm josh run:review` and the round-1 `/code-review` here (chain-rule.md step 0).";
+  return `Not reused: josh ship reviews round 1 again \u2014 ${cause}. ${next}`;
+}
+function reuse_line(answer, is_refused) {
+  if (answer.reuse === "again") return review_again_line(answer.cause, is_refused);
+  const line = answer.reuse === "delta" ? DELTA_LINE : REUSED_LINE;
+  return answer.note === void 0 ? line : `${line} \u2014 ${answer.note}`;
+}
+var NOT_REQUIRED_LINE2 = "No review-finding ledger is kept in this checkout, so there is nothing to check.";
+var OPTIONS = {
+  issue: { type: "string" },
+  check: { type: "boolean" },
+  comment: { type: "boolean" },
+  interaction: { type: "boolean" }
+};
+function to_finding(category, severity, file) {
+  if (!review_finding_ledger.is_category(category) || !review_finding_ledger.is_severity(severity)) {
+    return void 0;
+  }
+  return review_finding_ledger.is_valid_file(file) ? { category, severity, file } : void 0;
+}
+function parse_finding(spec) {
+  const first = spec.indexOf(":");
+  const second = spec.indexOf(":", first + 1);
+  if (first === -1 || second === -1) return void 0;
+  return to_finding(spec.slice(0, first), spec.slice(first + 1, second), spec.slice(second + 1));
+}
+function parse_positional(positional) {
+  const { spec: marked, description } = review_finding_text.split_description(positional);
+  const { disposition, spec } = review_finding_ledger.split_disposition(marked);
+  const finding = parse_finding(spec);
+  if (finding === void 0) return void 0;
+  return { finding: disposition === void 0 ? finding : { ...finding, disposition }, description };
+}
+function parse_findings(positionals) {
+  const findings = [];
+  for (const positional of positionals) {
+    const parsed = parse_positional(positional);
+    if (parsed === void 0) return void 0;
+    findings.push({ ...parsed.finding, description: parsed.description });
+  }
+  return findings;
+}
+function parse_argv(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  if (parsed === void 0) return void 0;
+  return {
+    check: parsed.values.check === true,
+    comment: parsed.values.comment === true,
+    interaction: parsed.values.interaction === true,
+    issue: parsed.values.issue,
+    positionals: parsed.positionals
+  };
+}
+function to_request(parsed) {
+  const { issue } = parsed;
+  if (issue === void 0 || !issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue)) return void 0;
+  const findings = parse_findings(parsed.positionals);
+  return findings === void 0 ? void 0 : { issue: Number(issue), findings };
+}
+function accepted_values(placeholder, values) {
+  return `  ${placeholder}: ${values.join(" | ")}`;
+}
+function usage_text() {
+  return [
+    USAGE,
+    accepted_values("<category>", review_finding_ledger.CATEGORIES),
+    accepted_values("<severity>", review_finding_ledger.SEVERITIES),
+    FILE_HINT,
+    DISPOSITION_HINT,
+    REASON_HINT
+  ].join("\n");
+}
+function build_lines(request, date, kind = "code") {
+  if (request.findings.length === 0) {
+    return [review_finding_ledger.zero_round_line(date, request.issue, kind)];
+  }
+  return request.findings.map(
+    (finding) => review_finding_ledger.finding_line(finding, date, request.issue, kind)
+  );
+}
+function confirmation(count, ledger_path) {
+  return `Recorded ${String(count)} review-finding line(s) in ${ledger_path}.`;
+}
+async function code_recorded(issue) {
+  const answer = await review_lane_handover.answer_here(issue);
+  const is_refused = await review_lane_handover.is_reopen_refused(issue);
+  return [RECORDED_LINE, reuse_line(answer, is_refused)].join("\n");
+}
+async function interaction_recorded() {
+  return RECORDED_LINE;
+}
+async function code_status(issue, root) {
+  const verdict = await review_record.check(issue, root);
+  return verdict.status;
+}
+var CHECK_MODES = {
+  code: {
+    status: code_status,
+    recorded: code_recorded,
+    refusal: review_record.refusal_message,
+    not_required: NOT_REQUIRED_LINE2
+  },
+  interaction: {
+    status: review_interaction.status,
+    recorded: interaction_recorded,
+    refusal: review_interaction.refusal_message,
+    not_required: review_record_interaction.NOT_REQUIRED_LINE
+  }
+};
+function kind_of(parsed) {
+  return parsed.interaction ? "interaction" : "code";
+}
+async function report_check(issue, mode, root) {
+  const status = await mode.status(issue, root);
+  if (status === "missing") {
+    console.error(mode.refusal(issue));
+    return FAILURE_EXIT_CODE2;
+  }
+  console.info(status === "ok" ? await mode.recorded(issue) : mode.not_required);
+  return 0;
+}
+async function run_check(parsed, root) {
+  const { issue } = parsed;
+  if (issue === void 0 || !issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue)) {
+    console.error(CHECK_USAGE);
+    return FAILURE_EXIT_CODE2;
+  }
+  return await report_check(Number(issue), CHECK_MODES[kind_of(parsed)], root);
+}
+function ledger_lines({ issue, lines, kind, date }) {
+  if (kind === "interaction") return lines;
+  return [review_finding_ledger.round_line(date, issue), ...lines];
+}
+async function append_round(round) {
+  const { issue, lines, root } = round;
+  const ledger_path = observation_ledger_home.issue_path(issue, root);
+  await observation_ledger_home.append(ledger_path, ledger_lines(round));
+  console.info(confirmation(lines.length, ledger_path));
+  await review_comment_carry.carry_from_record(root);
+  return 0;
+}
+async function write_round(parsed, request, now, root) {
+  const kind = kind_of(parsed);
+  const date = observation_ledger_home.ledger_date(now);
+  const lines = [
+    ...build_lines(request, date, kind),
+    ...review_fix_round.lines(request.round, root)
+  ];
+  const { issue, findings } = request;
+  if (parsed.comment) {
+    return { code: await review_record_comment.post(issue, lines), is_ledger: false };
+  }
+  if (kind === "code" && await review_record_comment.is_after_push()) {
+    const code = await review_record_comment.post_after_push({ issue, lines, root, findings });
+    return { code, is_ledger: false };
+  }
+  return { code: await append_round({ issue, lines, root, kind, date }), is_ledger: true };
+}
+function finish_record(request, is_interaction, root) {
+  if (!is_interaction) review_final_record.record(request.issue, request.findings, root);
+  review_fix_round.record_reasons(request.issue, request.findings);
+  if (request.round !== void 0) review_fix_round.save(request.round, root);
+}
+async function record_prepared(parsed, request, now, root) {
+  request.round = parsed.interaction ? void 0 : review_fix_round.prepare(request.issue, request.findings, root);
+  const { code, is_ledger } = await write_round(parsed, request, now, root);
+  if (code !== 0) return code;
+  finish_record(request, parsed.interaction, root);
+  if (is_ledger && !parsed.interaction) {
+    await review_record_code_round.follow(request.issue, root, request.findings);
+  }
+  return 0;
+}
+async function run_record(parsed, now, root) {
+  const request = parsed.comment && parsed.interaction ? void 0 : to_request(parsed);
+  if (request === void 0) {
+    console.error(usage_text());
+    return FAILURE_EXIT_CODE2;
+  }
+  return await record_prepared(parsed, request, now, root);
+}
+async function run(argv, now, root = observation_ledger_home.ledger_root()) {
+  const parsed = parse_argv(argv);
+  if (parsed === void 0) {
+    console.error(usage_text());
+    return FAILURE_EXIT_CODE2;
+  }
+  if (parsed.check) return await run_check(parsed, root);
+  return await run_record(parsed, now, root);
+}
+var review_record_cli = {
+  accepted_values,
+  build_lines,
+  parse_finding,
+  parse_positional,
+  run,
+  usage_text
+};
+
+export {
+  review_final_record,
+  review_lane_handover,
+  review_record_cli
+};