@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-B545ENGY.js

@@ -0,0 +1,214 @@
+import {
+  lane_vacant
+} from "./chunk-YOZTZMAT.js";
+import {
+  lane_dispatch_dependency
+} from "./chunk-NDQIJBRQ.js";
+import {
+  josh_command
+} from "./chunk-47J4KOZP.js";
+import {
+  run_event_setup
+} from "./chunk-OKN63ZH5.js";
+import {
+  core_budget,
+  core_wait
+} from "./chunk-ZCHZU6NX.js";
+import {
+  lane_registry
+} from "./chunk-NEOCCN6D.js";
+import {
+  run_startup
+} from "./chunk-RV7EQIE4.js";
+import {
+  issue_number_shape,
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  INSTALL_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-launch-cli.ts
+import { execa } from "execa";
+
+// scripts/lane/lane-launch-admission.ts
+var LANE_MEMORY_MB = 470;
+function checkout_of(issue) {
+  const cwd = process.cwd();
+  const root = core_wait.where_of(cwd).lanes_root ?? lane_paths.lane_root(cwd);
+  return lane_paths.lane_directory(root, issue);
+}
+function options_of(issue) {
+  return {
+    memory_mb: LANE_MEMORY_MB,
+    is_strict_admission: true,
+    is_memory_pending: true,
+    command: "lane:launch",
+    checkout: checkout_of(issue)
+  };
+}
+async function run_reserved(context, run2, handle) {
+  let is_retained = false;
+  try {
+    const outcome = await run2(context);
+    if (outcome.kind === "launched") {
+      core_budget.transfer(handle, Number(outcome.pid));
+      is_retained = true;
+    }
+    return outcome;
+  } finally {
+    if (!is_retained) core_budget.release(handle);
+  }
+}
+async function launch(context, run2) {
+  const handle = await core_budget.reserve(0, options_of(context.issue));
+  return await run_reserved(context, run2, handle);
+}
+var lane_launch_admission = { launch, options_of, run_reserved };
+
+// scripts/lane/lane-launch-pending.ts
+var pending = /* @__PURE__ */ new Map();
+function keep(issues) {
+  for (const [issue, claim] of pending) {
+    if (issues.includes(issue)) continue;
+    core_budget.release(claim);
+    pending.delete(issue);
+  }
+}
+function claim_for(issue) {
+  const claim = pending.get(issue) ?? core_budget.claim(0, lane_launch_admission.options_of(issue));
+  pending.set(issue, claim);
+  return claim;
+}
+async function launch2(context, run2) {
+  const handle = await core_budget.poll_claim(claim_for(context.issue));
+  if (handle === void 0) return { kind: "waiting" };
+  pending.delete(context.issue);
+  return await lane_launch_admission.run_reserved(context, run2, handle);
+}
+var lane_launch_pending = { keep, launch: launch2 };
+
+// scripts/lane/lane-launch-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var should_forward_stderr = true;
+var PNPM = "pnpm";
+var USAGE = "Usage: josh lane:launch <issue-number> [--stash <message>]";
+var OPTIONS = { stash: { type: "string" } };
+var PREPARED = { code: SUCCESS_EXIT_CODE, out: "" };
+function read_context(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  if (parsed === void 0) return void 0;
+  const [issue, ...rest] = parsed.positionals;
+  if (issue === void 0 || rest.length > 0 || !issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue)) {
+    return void 0;
+  }
+  return { issue, stash: parsed.values.stash };
+}
+function failure_detail(result) {
+  const detail = (result.err ?? "").trim() || result.out.trim();
+  return detail === "" ? void 0 : detail;
+}
+function refused(kind, result) {
+  const detail = failure_detail(result);
+  return detail === void 0 ? { kind } : { kind, detail };
+}
+async function install(directory) {
+  const result = await execa(PNPM, ["--dir", directory, "install", "--frozen-lockfile"], {
+    reject: false,
+    timeout: INSTALL_TIMEOUT_MS
+  });
+  const installed = {
+    code: result.exitCode ?? FAILURE_EXIT_CODE,
+    out: result.stdout,
+    err: result.stderr
+  };
+  if (installed.code !== SUCCESS_EXIT_CODE) console.error(failure_detail(installed) ?? "");
+  return installed;
+}
+async function prepare(context, directory) {
+  const { issue, stash } = context;
+  if (stash === void 0) return PREPARED;
+  const popped = await josh_command.josh_run(
+    ["stash:pop", stash, "--dir", directory],
+    should_forward_stderr
+  );
+  if (popped.code !== SUCCESS_EXIT_CODE) return popped;
+  await run_event_setup.emit(run_event_setup.installing(issue));
+  return await run_startup.phase("dependency reinstall", async () => await install(directory), {
+    edge_of: (value) => value.code === SUCCESS_EXIT_CODE ? "done" : "failed"
+  });
+}
+async function close_if_vacant(lane) {
+  if (lane === void 0 || !await lane_vacant.is_vacant(lane)) return;
+  await josh_command.josh_run(["lane:close", lane.issue], should_forward_stderr);
+}
+async function lane_directory(issue) {
+  const kept = await lane_registry.find_open_lane(issue);
+  if (kept?.output !== void 0) return { code: SUCCESS_EXIT_CODE, out: kept.directory };
+  await close_if_vacant(kept);
+  return await josh_command.josh_run(["lane:open", issue], should_forward_stderr);
+}
+function dispatch_edge(value) {
+  if (value.code === lane_dispatch_dependency.WAIT_EXIT_CODE) return "waiting";
+  return value.code === SUCCESS_EXIT_CODE ? "done" : "failed";
+}
+async function dispatch(context) {
+  await run_event_setup.emit(run_event_setup.dispatching(context.issue));
+  const dispatched = await run_startup.phase(
+    "worker dispatch",
+    async () => await josh_command.josh_run(["lane:dispatch", context.issue], should_forward_stderr),
+    { edge_of: dispatch_edge }
+  );
+  if (dispatched.code === lane_dispatch_dependency.WAIT_EXIT_CODE) {
+    await close_if_vacant(await lane_registry.find_open_lane(context.issue));
+    return { kind: "waiting" };
+  }
+  if (dispatched.code !== SUCCESS_EXIT_CODE) return refused("failed", dispatched);
+  return { kind: "launched", pid: dispatched.out };
+}
+async function launch_admitted(context) {
+  const opened = await run_startup.phase(
+    "lane creation",
+    async () => await lane_directory(context.issue),
+    { edge_of: (value) => value.code === SUCCESS_EXIT_CODE ? "done" : "failed" }
+  );
+  if (opened.code !== SUCCESS_EXIT_CODE) return refused("unopened", opened);
+  const prepared = await prepare(context, opened.out);
+  if (prepared.code !== SUCCESS_EXIT_CODE) return refused("failed", prepared);
+  return await dispatch(context);
+}
+async function launch_lane(context) {
+  return await lane_launch_admission.launch(context, launch_admitted);
+}
+async function launch_ready_lane(context) {
+  return await lane_launch_pending.launch(context, launch_admitted);
+}
+async function launch3(context) {
+  const outcome = await launch_lane(context);
+  if (outcome.kind !== "launched") return FAILURE_EXIT_CODE;
+  console.info(outcome.pid);
+  return SUCCESS_EXIT_CODE;
+}
+async function run(argv) {
+  const context = read_context(argv);
+  if (context === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  return await launch3(context);
+}
+var lane_launch_cli = {
+  keep_pending: lane_launch_pending.keep,
+  launch_lane,
+  launch_ready_lane,
+  read_context,
+  run
+};
+
+export {
+  lane_launch_cli
+};

package/dist/commands/chunk-B5HP6T4L.js

@@ -0,0 +1,170 @@
+import {
+  git_utilities
+} from "./chunk-B5GXZK3E.js";
+import {
+  GIT_TIMEOUT_MS,
+  MS_PER_SECOND,
+  PROBE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/git/git-spawn.ts
+import { execa as execa3 } from "execa";
+
+// scripts/git/git-execa-error.ts
+function get_exit_code(error) {
+  if (typeof error !== "object" || error === null || !("exitCode" in error)) return void 0;
+  const { exitCode: exit_code } = error;
+  return typeof exit_code === "number" ? exit_code : void 0;
+}
+function has_timed_out(error) {
+  if (typeof error !== "object" || error === null || !("timedOut" in error)) return false;
+  return error.timedOut === true;
+}
+var TIMEOUT_EXIT_CODE = "timeout";
+function create_spawn_error(command, exit_code) {
+  const exit_code_string = exit_code === void 0 ? "unknown" : String(exit_code);
+  const error_message = `git ${command} exited with code ${exit_code_string}`;
+  return new Error(error_message, { cause: { exit_code: exit_code_string } });
+}
+
+// scripts/git/git-push-transport.ts
+import { execa as execa2 } from "execa";
+
+// scripts/git/git-ssh-keepalive.ts
+import { execa } from "execa";
+var SSH_KEEPALIVE_OPTIONS = "-o ServerAliveInterval=15 -o ServerAliveCountMax=3";
+var SSH_COMMAND_VARIABLE = "GIT_SSH_COMMAND";
+var SSH_LEGACY_VARIABLE = "GIT_SSH";
+var KEEPALIVE_SSH_COMMAND = `ssh ${SSH_KEEPALIVE_OPTIONS}`;
+var SSH_COMMAND_CONFIG_KEY = "core.sshCommand";
+var CONFIG_PROBE_ARGUMENTS = ["config", "--get", SSH_COMMAND_CONFIG_KEY];
+var PROBE_OPTIONS = { timeout: PROBE_TIMEOUT_MS };
+function to_environment_value(name) {
+  return process.env[name]?.trim() ?? "";
+}
+function to_configured_ssh_command() {
+  const from_command = to_environment_value(SSH_COMMAND_VARIABLE);
+  return from_command === "" ? to_environment_value(SSH_LEGACY_VARIABLE) : from_command;
+}
+async function has_configured_ssh_command() {
+  if (to_configured_ssh_command() !== "") return true;
+  try {
+    const git_command_bin = git_utilities.get_git_command_for_spawn();
+    const { stdout } = await execa(git_command_bin, CONFIG_PROBE_ARGUMENTS, PROBE_OPTIONS);
+    return stdout.trim() !== "";
+  } catch (error) {
+    return has_timed_out(error);
+  }
+}
+async function to_environment() {
+  const should_keep_alive = !await has_configured_ssh_command();
+  return should_keep_alive ? { [SSH_COMMAND_VARIABLE]: KEEPALIVE_SSH_COMMAND } : {};
+}
+var git_ssh_keepalive = {
+  to_environment
+};
+
+// scripts/git/git-push-transport.ts
+var PUSH_TIMEOUT_SECONDS = 120;
+var PUSH_TIMEOUT_MS = PUSH_TIMEOUT_SECONDS * MS_PER_SECOND;
+var PUSH_TIMEOUT_LABEL = `${String(PUSH_TIMEOUT_SECONDS)}s`;
+var PUSH_TIMEOUT_MESSAGE = "git push timed out";
+var PUSH_SUBCOMMAND = "push";
+async function to_push_options() {
+  return {
+    stdio: "inherit",
+    timeout: PUSH_TIMEOUT_MS,
+    env: await git_ssh_keepalive.to_environment()
+  };
+}
+async function did_push_time_out(arguments_list) {
+  const git_command_bin = git_utilities.get_git_command_for_spawn();
+  const options = await to_push_options();
+  try {
+    await execa2(git_command_bin, [PUSH_SUBCOMMAND, ...arguments_list], options);
+    return false;
+  } catch (error) {
+    if (has_timed_out(error)) return true;
+    throw create_spawn_error(PUSH_SUBCOMMAND, get_exit_code(error));
+  }
+}
+function to_manual_command(arguments_list) {
+  return ["git", PUSH_SUBCOMMAND, ...arguments_list].join(" ");
+}
+function to_retry_notice(arguments_list) {
+  return `${PUSH_TIMEOUT_MESSAGE} after ${PUSH_TIMEOUT_LABEL} \u2014 retrying once: ${to_manual_command(arguments_list)}`;
+}
+function create_timeout_error(arguments_list) {
+  const message = `${PUSH_TIMEOUT_MESSAGE} twice (${PUSH_TIMEOUT_LABEL} each). Re-run it by hand: ${to_manual_command(arguments_list)}`;
+  return new Error(message, { cause: { exit_code: TIMEOUT_EXIT_CODE } });
+}
+async function push(arguments_list) {
+  if (!await did_push_time_out(arguments_list)) return;
+  console.warn(to_retry_notice(arguments_list));
+  if (!await did_push_time_out(arguments_list)) return;
+  throw create_timeout_error(arguments_list);
+}
+var git_push_transport = {
+  push
+};
+
+// scripts/git/git-spawn.ts
+async function read(arguments_, timeout_ms = GIT_TIMEOUT_MS) {
+  const git_cmd = git_utilities.get_git_command_for_spawn();
+  const { stdout } = await execa3(git_cmd, arguments_, { timeout: timeout_ms });
+  return stdout.trimEnd();
+}
+var REMOTE_TIMEOUT_MS = PUSH_TIMEOUT_MS;
+function to_budget_error(command, error, timeout_ms) {
+  if (!has_timed_out(error)) return create_spawn_error(command, get_exit_code(error));
+  const seconds = String(Math.round(timeout_ms / MS_PER_SECOND));
+  return new Error(`git ${command} timed out after ${seconds}s`, {
+    cause: { exit_code: TIMEOUT_EXIT_CODE }
+  });
+}
+async function spawn_remote(arguments_, options) {
+  const git_cmd = git_utilities.get_git_command_for_spawn();
+  try {
+    const { stdout } = await execa3(git_cmd, arguments_, options);
+    return typeof stdout === "string" ? stdout.trimEnd() : "";
+  } catch (error) {
+    throw to_budget_error(arguments_[0] ?? "", error, options.timeout);
+  }
+}
+async function read_remote(arguments_, timeout_ms = REMOTE_TIMEOUT_MS) {
+  return await spawn_remote(arguments_, {
+    timeout: timeout_ms,
+    env: await git_ssh_keepalive.to_environment()
+  });
+}
+async function with_output_remote(command, arguments_list) {
+  await spawn_remote([command, ...arguments_list], {
+    stdio: "inherit",
+    timeout: REMOTE_TIMEOUT_MS,
+    env: await git_ssh_keepalive.to_environment()
+  });
+}
+async function with_output(command, arguments_list, options = {}) {
+  const { config_options = [], timeout_ms = GIT_TIMEOUT_MS } = options;
+  const git_command_bin = git_utilities.get_git_command_for_spawn();
+  const spawn_arguments = [...config_options, command, ...arguments_list];
+  try {
+    await execa3(git_command_bin, spawn_arguments, { stdio: "inherit", timeout: timeout_ms });
+  } catch (error) {
+    throw to_budget_error(command, error, timeout_ms);
+  }
+}
+var git_spawn = {
+  read,
+  read_remote,
+  with_output,
+  with_output_remote
+};
+
+export {
+  get_exit_code,
+  has_timed_out,
+  create_spawn_error,
+  git_push_transport,
+  git_spawn
+};

package/dist/commands/chunk-B73IIRMS.js

@@ -0,0 +1,207 @@
+import {
+  lane_state_record
+} from "./chunk-UUH3DE77.js";
+import {
+  git_directory
+} from "./chunk-3NWAGIA6.js";
+import {
+  process_owner_schema
+} from "./chunk-HLUS2M3D.js";
+import {
+  issue_number_shape,
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  durable_state_root
+} from "./chunk-5VQCL33M.js";
+import {
+  PLATFORM_TEMP_ROOT,
+  platform_temporary,
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/test/unit-worker-share.ts
+import { availableParallelism } from "node:os";
+
+// scripts/test/unit-lane-count.ts
+import { readdirSync } from "node:fs";
+import path from "node:path";
+function is_idle_lane(lanes_root, issue, environment) {
+  const common = git_directory.resolve_git_directory(path.join(lanes_root, issue));
+  if (common === void 0) return false;
+  const override = environment[platform_temporary.TEMP_ROOT_KEY];
+  const state_root = durable_state_root.state_root(override, () => common);
+  return lane_state_record.is_idle(state_root, common, issue);
+}
+function own_lane(checkout, environment) {
+  return lane_paths.lane_issue_of(lane_paths.checkout_of(path.resolve(checkout)), environment);
+}
+function live_lane_count(checkout = process.cwd(), environment = process.env) {
+  try {
+    const lanes_root = lane_paths.lanes_root_of(checkout, environment);
+    const own = own_lane(checkout, environment);
+    const issues = readdirSync(lanes_root).filter(
+      (name) => issue_number_shape.ISSUE_NUMBER_PATTERN.test(name)
+    );
+    return issues.filter((issue) => issue === own || !is_idle_lane(lanes_root, issue, environment)).length;
+  } catch {
+    return 0;
+  }
+}
+var unit_lane_count = { live_lane_count };
+
+// scripts/test/unit-run-marker.ts
+import { readdirSync as readdirSync2 } from "node:fs";
+import path2 from "node:path";
+var RUN_PREFIX = "josh-unit-running-";
+var MIN_WORKERS = 1;
+var SOLO_RUNS = 1;
+function marker_path(pid = process.pid) {
+  return stamp_file.stamp_path(RUN_PREFIX, String(pid));
+}
+function is_running(marker) {
+  return process_identity.is_same_process(marker.pid, marker.process_start) !== false;
+}
+function read_marker(source) {
+  const raw = stamp_file.read_stamp_text(source);
+  if (raw === void 0) return void 0;
+  const parsed = process_owner_schema.safeParse(json_value.parse_or_undefined(raw));
+  return parsed.success ? parsed.data : void 0;
+}
+function marker_files(directory = PLATFORM_TEMP_ROOT) {
+  try {
+    return readdirSync2(directory).filter((name) => name.startsWith(RUN_PREFIX));
+  } catch {
+    return [];
+  }
+}
+function sweep_marker(source) {
+  try {
+    stamp_file.remove_stamp(source);
+  } catch {
+  }
+}
+function is_marker_live(source) {
+  const marker = read_marker(source);
+  if (marker === void 0) return false;
+  if (is_running(marker)) return true;
+  sweep_marker(source);
+  return false;
+}
+function live_run_count(directory = PLATFORM_TEMP_ROOT) {
+  return marker_files(directory).filter((name) => is_marker_live(path2.join(directory, name))).length;
+}
+var NESTED_KEY = "JOSH_UNIT_RUN_MARKED";
+var NESTED_VALUE = "1";
+function is_nested_run() {
+  return process.env[NESTED_KEY] === NESTED_VALUE;
+}
+function resolve_unit_workers(available_cores, runs) {
+  if (runs <= SOLO_RUNS) return void 0;
+  return Math.max(MIN_WORKERS, Math.floor(available_cores / runs));
+}
+function sharing_runs(runs, lanes) {
+  return Math.max(runs, lanes);
+}
+function mark_run_started(target) {
+  try {
+    stamp_file.write_stamp(target, process_identity.own_fields());
+  } catch {
+  }
+}
+var unit_run_marker = {
+  MIN_WORKERS,
+  NESTED_KEY,
+  NESTED_VALUE,
+  RUN_PREFIX,
+  SOLO_RUNS,
+  is_nested_run,
+  live_run_count,
+  mark_run_started,
+  marker_path,
+  read_marker,
+  resolve_unit_workers,
+  sharing_runs
+};
+
+// scripts/test/unit-worker-share.ts
+var { MIN_WORKERS: MIN_WORKERS2, NESTED_KEY: NESTED_KEY2, NESTED_VALUE: NESTED_VALUE2, SOLO_RUNS: SOLO_RUNS2 } = unit_run_marker;
+var {
+  is_nested_run: is_nested_run2,
+  live_run_count: live_run_count2,
+  mark_run_started: mark_run_started2,
+  marker_path: marker_path2,
+  resolve_unit_workers: resolve_unit_workers2,
+  sharing_runs: sharing_runs2
+} = unit_run_marker;
+var WORKER_FLAG = "--maxWorkers";
+var WORKER_FLAGS = [WORKER_FLAG, "--max-workers"];
+var MAIN_PROCESS_CORES = 1;
+function cap_to_free(workers, free_cores, available_cores) {
+  if (free_cores === void 0 || free_cores >= (workers ?? available_cores)) return workers;
+  return Math.max(MIN_WORKERS2, Math.floor(free_cores));
+}
+var UNREAD_CAPACITY = { cores: void 0, memory_workers: void 0 };
+function cap_to_capacity(workers, free, available_cores) {
+  const core_capped = cap_to_free(workers, free.cores, available_cores);
+  return cap_to_free(core_capped, free.memory_workers, available_cores);
+}
+function cap_to_claim(share, claim) {
+  if (claim === void 0) return share;
+  const bound = Math.max(MIN_WORKERS2, (claim.granted ?? claim.weight) - MAIN_PROCESS_CORES);
+  return Math.min(share ?? bound, bound);
+}
+function own_run() {
+  return is_nested_run2() ? 0 : SOLO_RUNS2;
+}
+function current_share(available_cores = availableParallelism(), live_runs = live_run_count2(), free = UNREAD_CAPACITY, live_lanes = SOLO_RUNS2) {
+  const share = resolve_unit_workers2(
+    available_cores,
+    sharing_runs2(live_runs + own_run(), live_lanes)
+  );
+  return cap_to_capacity(share, free, available_cores);
+}
+function is_worker_flag(argument) {
+  return WORKER_FLAGS.some((flag) => argument === flag || argument.startsWith(`${flag}=`));
+}
+function has_worker_flag(vitest_arguments) {
+  return vitest_arguments.some((argument) => is_worker_flag(argument));
+}
+function worker_arguments(vitest_arguments, share) {
+  if (share === void 0 || has_worker_flag(vitest_arguments)) return [];
+  return [`${WORKER_FLAG}=${String(share)}`];
+}
+async function with_run_marker(run) {
+  if (is_nested_run2()) return await run();
+  const target = marker_path2();
+  mark_run_started2(target);
+  process.env[NESTED_KEY2] = NESTED_VALUE2;
+  try {
+    return await run();
+  } finally {
+    process.env[NESTED_KEY2] = "";
+    stamp_file.remove_stamp(target);
+  }
+}
+var unit_worker_share = {
+  ...unit_run_marker,
+  ...unit_lane_count,
+  MAIN_PROCESS_CORES,
+  cap_to_capacity,
+  cap_to_claim,
+  cap_to_free,
+  current_share,
+  has_worker_flag,
+  with_run_marker,
+  worker_arguments
+};
+
+export {
+  unit_worker_share
+};

package/dist/commands/chunk-BBLEC4YQ.js

@@ -0,0 +1,109 @@
+import {
+  review_round2
+} from "./chunk-T6JUDQMW.js";
+import {
+  review_finding_ledger
+} from "./chunk-KVURNO74.js";
+import {
+  review_code_tree
+} from "./chunk-FDASVHZD.js";
+import {
+  review_attest
+} from "./chunk-URZ4RDC4.js";
+import {
+  observation_ledger_home
+} from "./chunk-QXBOECGL.js";
+import {
+  project_checks
+} from "./chunk-RO4QEZJO.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+import {
+  change_base
+} from "./chunk-LBVYFW3I.js";
+
+// scripts/review/review-interaction.ts
+var TARGET_DIRECTORIES = ["scripts/run/", "scripts/lane/", "scripts/backlog/", "scripts/hooks/"];
+var NOT_DUE_LINE = "Interaction review not due: this is not the kit repository, or the change touches none of scripts/run/, scripts/lane/, scripts/backlog/ or scripts/hooks/.";
+var QUESTIONS = [
+  "1. Every state, command, label, file or process this change adds or gives a new meaning to \u2014 who else reads or writes it? Search the repository outside the diff for each. Where the plan has a `### \u5F71\u97FF\u3092\u53D7\u3051\u308B\u65E2\u5B58\u306E\u5229\u7528\u8005` section, check it names them all.",
+  "2. Does each of those readers and writers still behave correctly when the new state or value reaches it (for example, a paused lane counted as running)?",
+  "3. Does the change add heavy or synchronous work to a path called repeatedly \u2014 every second, every Bash call, every edit?"
+];
+var ROLE_LINES = [
+  "## Interaction review",
+  "This pass is not a second `/code-review`: do not hunt for bugs inside the diff \u2014 the round before it did. Your role is to find three existing features this change breaks. Check only these three:",
+  ...QUESTIONS,
+  "Report each break with the reader's `file:line` and the change's, rated by the rubric's severities; it is disposed of by `prompts/review.md` \u2192 \"Interaction review\"."
+];
+var INERT_LINE_PREFIX = "Interaction review not due: every run-tooling path this change touches leaves what executes unchanged (round 2\u2019s inert reading \u2014 in these directories, an edit to comments or import specifiers only)";
+var NOT_REQUIRED = "not-required";
+function due_paths(paths, checkout = process.cwd()) {
+  if (!project_checks.is_kit_repository(checkout)) return [];
+  return paths.filter((file) => TARGET_DIRECTORIES.some((directory) => file.startsWith(directory)));
+}
+function brief_block(targets) {
+  const listed = targets.map((file) => `- ${file}`);
+  return [...ROLE_LINES, "Changed in the run tooling:", ...listed].join("\n");
+}
+async function inert_line(due) {
+  const base = await change_base.resolved_through_merge();
+  if (base === void 0) return void 0;
+  const inert = await review_code_tree.inert_since(base, due);
+  const is_inert = due.every((relative) => review_round2.is_unexecuted(relative, inert));
+  return is_inert ? `${INERT_LINE_PREFIX}: ${due.join(", ")}` : void 0;
+}
+async function unrecorded_reading(due) {
+  const line = await inert_line(due);
+  return line === void 0 ? { status: "missing" } : { status: NOT_REQUIRED, inert_line: line };
+}
+async function reading_of(issue, paths, root = observation_ledger_home.ledger_root()) {
+  const due = due_paths(paths);
+  const content = due.length > 0 ? await observation_ledger_home.read(root) : void 0;
+  if (content === void 0) return { status: NOT_REQUIRED };
+  if (review_finding_ledger.has_issue_record(content, issue, "interaction")) return { status: "ok" };
+  return await unrecorded_reading(due);
+}
+async function status_of(issue, paths, root) {
+  const answer = await reading_of(issue, paths, root);
+  return answer.status;
+}
+async function reading(issue, root) {
+  return await reading_of(issue, await changed_paths.read_changed_paths(false), root);
+}
+async function status(issue, root) {
+  const answer = await reading(issue, root);
+  return answer.status;
+}
+function round_one_slots(answer) {
+  const { CODE, INTERACTION } = review_attest.REVIEW_SLOT;
+  return answer === "missing" ? [CODE, INTERACTION] : [CODE];
+}
+var MISSING_REASON = "This change touches the run tooling, and no interaction review is recorded for its issue \u2014 the pass that looks for the existing features a change breaks, which `/code-review` does not (joshuafolkken/kit#4276).";
+var REMEDY = "Run it from `pnpm josh review:brief --interaction`, whose reviewer writes its findings with `pnpm josh review:submit --interaction`; record them with `pnpm josh review:record --from-slot --interaction --issue <N> [<n>=<disposition> ...]` and reissue the merge.";
+function refusal_message(issue) {
+  return [MISSING_REASON, `Issue: ${session_cite.issue(issue)}`, REMEDY].join("\n");
+}
+async function refusal(issue, root) {
+  return await status(issue, root) === "missing" ? refusal_message(issue) : void 0;
+}
+var review_interaction = {
+  brief_block,
+  due_paths,
+  NOT_DUE_LINE,
+  QUESTIONS,
+  reading,
+  refusal,
+  refusal_message,
+  round_one_slots,
+  status,
+  status_of
+};
+
+export {
+  review_interaction
+};