@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-B545ENGY.js

@@ -1,214 +0,0 @@
-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

@@ -1,170 +0,0 @@
-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

@@ -1,207 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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
-};