@joshuafolkken/kit 1.3101.0 → 1.3125.0

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

@@ -1,85 +0,0 @@
-import {
-  git_gh_etag_read
-} from "./chunk-IPS7EBE5.js";
-import {
-  IN_PROGRESS_LABEL
-} from "./chunk-QQBMVC5W.js";
-import {
-  git_gh_api_path
-} from "./chunk-RDRN56E4.js";
-import {
-  MS_PER_MINUTE
-} from "./chunk-WPAQUMHC.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/epic/epic-label-age.ts
-import { z } from "zod";
-var STALE_MINUTES = 90;
-var TIMELINE_PAGE = 100;
-var LABELED_EVENT = "labeled";
-var UNPARSED_TIMELINE_MESSAGE = "timeline did not parse";
-var label_schema = z.object({ name: z.string() });
-var timeline_schema = z.array(
-  z.object({
-    event: z.string().nullish(),
-    created_at: z.string().nullish(),
-    label: label_schema.nullish()
-  })
-);
-function parse_events(raw) {
-  const events = json_value.parse_array(raw);
-  if (events === void 0) throw new Error(UNPARSED_TIMELINE_MESSAGE);
-  return events;
-}
-async function read_timeline(path) {
-  return parse_events(await git_gh_etag_read.read_listing(path, TIMELINE_PAGE));
-}
-function is_in_progress_labeling(event) {
-  return event.event === LABELED_EVENT && event.label?.name.toLowerCase() === IN_PROGRESS_LABEL;
-}
-async function read_labeled_at(issue, repo) {
-  try {
-    const path = `${git_gh_api_path.issue_api_path(String(issue), repo)}/timeline?per_page=${String(TIMELINE_PAGE)}`;
-    const events = timeline_schema.parse(await read_timeline(path));
-    const at = events.findLast((event) => is_in_progress_labeling(event))?.created_at;
-    return typeof at === "string" ? { kind: "at", at } : { kind: "absent" };
-  } catch {
-    return { kind: "unread" };
-  }
-}
-function minutes_since(at, now) {
-  return Math.floor((now.getTime() - Date.parse(at)) / MS_PER_MINUTE);
-}
-function is_stale(labeled_at, now) {
-  if (labeled_at.kind === "unread") return false;
-  if (labeled_at.kind === "absent") return true;
-  return minutes_since(labeled_at.at, now) > STALE_MINUTES;
-}
-function age_text(labeled_at, now) {
-  if (labeled_at.kind === "unread") return "label age unread";
-  if (labeled_at.kind === "absent") return `${IN_PROGRESS_LABEL} older than the timeline \u2014 stale`;
-  const stale = is_stale(labeled_at, now) ? " \u2014 stale" : "";
-  return `${IN_PROGRESS_LABEL} for ${String(minutes_since(labeled_at.at, now))} min${stale}`;
-}
-async function read_ages(issues, repo, now) {
-  const ages = await Promise.all(
-    issues.map(async (issue) => {
-      const labeled_at = await read_labeled_at(issue, repo);
-      return [issue, age_text(labeled_at, now)];
-    })
-  );
-  return new Map(ages);
-}
-var epic_label_age = {
-  STALE_MINUTES,
-  read_labeled_at,
-  is_stale,
-  age_text,
-  read_ages
-};
-
-export {
-  epic_label_age
-};

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

@@ -1,245 +0,0 @@
-import {
-  unit_worker_share
-} from "./chunk-B73IIRMS.js";
-import {
-  josh_verdict
-} from "./chunk-JTU5A4JI.js";
-import {
-  gate_labels
-} from "./chunk-WQ6FS544.js";
-import {
-  core_weights
-} from "./chunk-ENFPR7J2.js";
-
-// scripts/gate/gate-plan.ts
-import { availableParallelism } from "node:os";
-
-// scripts/gate/gate-checks.ts
-var {
-  BEHAVIOR_LABEL,
-  EXPORTS_LABEL,
-  KEEP_WHOLE_SUITE_FLAG,
-  LINT_LABEL,
-  LOCKFILE_LABEL,
-  METRICS_LABEL,
-  SPELL_CHECK_LABEL,
-  SPELL_CHECK_TARGET,
-  TYPE_CHECK_LABEL,
-  TYPE_CHECK_TARGET,
-  UNIT_LABEL,
-  UNIT_TARGET
-} = gate_labels;
-var STATIC_CHECKS = [
-  // **The lint reads the branch's changed files, not the whole tree** (joshuafolkken/kit#4085), and
-  // falls back to the whole tree in CI and on a changed configuration (`lint-gate-scope.ts`).
-  {
-    label: LINT_LABEL,
-    target: "lint",
-    args: ["--changed"],
-    reserved_cores: core_weights.CORE_WEIGHTS.lint,
-    memory_mb: core_weights.MEMORY_MB.lint
-  },
-  {
-    label: TYPE_CHECK_LABEL,
-    target: TYPE_CHECK_TARGET,
-    reserved_cores: core_weights.CORE_WEIGHTS.type_check,
-    memory_mb: core_weights.MEMORY_MB.type_check
-  },
-  {
-    label: SPELL_CHECK_LABEL,
-    target: SPELL_CHECK_TARGET,
-    reserved_cores: core_weights.CORE_WEIGHTS.spell_check,
-    memory_mb: core_weights.MEMORY_MB.spell_check
-  },
-  { label: BEHAVIOR_LABEL, target: BEHAVIOR_LABEL, reserved_cores: 0 },
-  // **The unused-member check builds one TypeScript program, as the type check does**, and reserves
-  // what the type check reserves: measured warm at 5.5s of wall for 9.0s of CPU, 1.6 cores rounded up.
-  {
-    label: EXPORTS_LABEL,
-    target: "exports:unused",
-    reserved_cores: core_weights.CORE_WEIGHTS.type_check,
-    is_whole_tree: true
-  },
-  // **The metrics ratchet is kit's own**: it holds kit's repository-wide
-  // totals to the merge-base's. It is the whole-tree eslint scan with only `max-lines` enabled, so it
-  // reserves that scan's weight. It times no startup here: beside the unit suite that reads the load, not josh.
-  {
-    label: METRICS_LABEL,
-    target: METRICS_LABEL,
-    args: ["--no-startup"],
-    reserved_cores: core_weights.CORE_WEIGHTS.eslint_scan,
-    memory_mb: core_weights.MEMORY_MB.metrics,
-    is_kit_only: true,
-    is_whole_tree: true
-  },
-  // The lockfile policy check is network-bound and usually instant: it verifies only when the
-  // lockfile or `pnpm-workspace.yaml` moved from the merge-base (joshuafolkken/kit#4090), so it
-  // reserves no core. Kit's own until a consumer's private-registry entries are known to verify.
-  { label: LOCKFILE_LABEL, target: "lockfile:policy", reserved_cores: 0, is_kit_only: true }
-];
-var GATE_CHECKS = [
-  ...STATIC_CHECKS,
-  { label: UNIT_LABEL, target: UNIT_TARGET, args: [KEEP_WHOLE_SUITE_FLAG], reserved_cores: 0 }
-];
-function select_gate_checks(is_unit_included, is_kit_repository = true, is_whole_tree_included = !is_unit_included) {
-  const checks = is_unit_included ? GATE_CHECKS : STATIC_CHECKS;
-  return checks.filter(
-    (check) => (is_kit_repository || check.is_kit_only !== true) && (is_whole_tree_included || check.is_whole_tree !== true)
-  );
-}
-var LANE_GATE_CHECKS = select_gate_checks(true, true, false);
-function selected_checks(selection) {
-  const { is_unit_included = true, is_kit_repository = true, is_whole_tree_included } = selection;
-  return select_gate_checks(is_unit_included, is_kit_repository, is_whole_tree_included);
-}
-function whole_tree_labels(is_kit_repository = true) {
-  return select_gate_checks(false, is_kit_repository, true).filter((check) => check.is_whole_tree === true).map((check) => check.label);
-}
-function has_unit_check(checks) {
-  return checks.some((check) => check.label === UNIT_LABEL);
-}
-var gate_checks = {
-  GATE_CHECKS,
-  LANE_GATE_CHECKS,
-  STATIC_CHECKS,
-  has_unit_check,
-  select_gate_checks,
-  selected_checks,
-  whole_tree_labels
-};
-
-// scripts/gate/gate-plan.ts
-var { GATE_CHECKS: GATE_CHECKS2, LANE_GATE_CHECKS: LANE_GATE_CHECKS2, STATIC_CHECKS: STATIC_CHECKS2, has_unit_check: has_unit_check2, select_gate_checks: select_gate_checks2 } = gate_checks;
-var { selected_checks: selected_checks2, whole_tree_labels: whole_tree_labels2 } = gate_checks;
-var { UNIT_LABEL: UNIT_LABEL2 } = gate_labels;
-var RESERVED_CORES = select_gate_checks2(false, true, false).reduce(
-  (total, check) => total + check.reserved_cores,
-  0
-);
-var MEASURED_CORES = 11;
-var MIN_CONCURRENCY = 1;
-var MIN_SHARED_CORES = 1;
-function lightest_first(items, reserved_cores_of) {
-  return items.toSorted((left, right) => reserved_cores_of(left) - reserved_cores_of(right));
-}
-function shared_cores(available_cores, concurrent_runs) {
-  const runs = Number.isFinite(concurrent_runs) ? Math.max(unit_worker_share.SOLO_RUNS, concurrent_runs) : unit_worker_share.SOLO_RUNS;
-  return Math.max(MIN_SHARED_CORES, Math.floor(available_cores / runs));
-}
-function resolve_concurrency(available_cores, concurrent_runs = unit_worker_share.SOLO_RUNS, checks = LANE_GATE_CHECKS2) {
-  const share = shared_cores(available_cores, concurrent_runs);
-  const ordered = lightest_first(checks, (check) => check.reserved_cores);
-  let admitted = 0;
-  let reserved = 0;
-  for (const check of ordered) {
-    reserved += check.reserved_cores;
-    if (reserved > share) break;
-    admitted += 1;
-  }
-  return Math.max(MIN_CONCURRENCY, admitted);
-}
-function resolve_unit_worker_cap(available_cores, concurrent_runs = unit_worker_share.SOLO_RUNS) {
-  const share = unit_worker_share.resolve_unit_workers(available_cores, concurrent_runs);
-  if (share !== void 0) return share;
-  if (available_cores < MEASURED_CORES) return void 0;
-  return available_cores - RESERVED_CORES;
-}
-function solo_unit_weight(available_cores) {
-  return Math.max(0, available_cores - RESERVED_CORES);
-}
-function check_weight(check, plan, available_cores) {
-  if (check.label !== UNIT_LABEL2) return check.reserved_cores;
-  return plan.unit_worker_cap ?? solo_unit_weight(available_cores);
-}
-function unit_memory(workers) {
-  return workers * core_weights.MEMORY_MB.unit_worker;
-}
-function check_memory(check, plan, available_cores) {
-  if (check.label !== UNIT_LABEL2) return check.memory_mb ?? 0;
-  return unit_memory(check_weight(check, plan, available_cores));
-}
-function direct_solo_workers(available_cores) {
-  const vitest_default = available_cores - unit_worker_share.MAIN_PROCESS_CORES;
-  const floor = Math.min(vitest_default, solo_unit_weight(MEASURED_CORES));
-  return Math.max(solo_unit_weight(available_cores), floor);
-}
-function direct_unit_weight(available_cores = availableParallelism(), live_runs = unit_worker_share.live_run_count(), live_lanes = unit_worker_share.live_lane_count()) {
-  const workers = unit_worker_share.current_share(available_cores, live_runs, void 0, live_lanes) ?? direct_solo_workers(available_cores);
-  return Math.max(unit_worker_share.MIN_WORKERS, workers) + unit_worker_share.MAIN_PROCESS_CORES;
-}
-var FILES_PER_WORKER = 285;
-function scoped_unit_weight(files, available_cores = availableParallelism(), live_runs = unit_worker_share.live_run_count(), live_lanes = unit_worker_share.live_lane_count()) {
-  const { MAIN_PROCESS_CORES, MIN_WORKERS } = unit_worker_share;
-  const share = direct_unit_weight(available_cores, live_runs, live_lanes) - MAIN_PROCESS_CORES;
-  const wanted = Math.max(MIN_WORKERS, Math.ceil(files / FILES_PER_WORKER));
-  return Math.min(wanted, share) + MAIN_PROCESS_CORES;
-}
-function direct_unit_memory() {
-  return unit_memory(direct_unit_weight());
-}
-var DIRECT_UNIT_CLAIM = {
-  core_weight: direct_unit_weight,
-  memory_mb: direct_unit_memory,
-  is_unit_claim: true
-};
-function unit_cap_for(checks, available_cores, concurrent_runs) {
-  if (!has_unit_check2(checks)) return void 0;
-  return resolve_unit_worker_cap(available_cores, concurrent_runs);
-}
-function plan_of(concurrency, unit_worker_cap, checks = LANE_GATE_CHECKS2) {
-  return { checks, concurrency, unit_worker_cap };
-}
-function resolve_gate_plan(available_cores = availableParallelism(), concurrent_runs = unit_worker_share.SOLO_RUNS, selection = {}) {
-  const checks = selected_checks2(selection);
-  return {
-    checks,
-    concurrency: resolve_concurrency(available_cores, concurrent_runs, checks),
-    unit_worker_cap: unit_cap_for(checks, available_cores, concurrent_runs)
-  };
-}
-function format_machine(available_cores, concurrent_runs) {
-  const cores = `${String(available_cores)} cores`;
-  if (concurrent_runs <= unit_worker_share.SOLO_RUNS) return cores;
-  return `${cores}, ${String(concurrent_runs)} unit runs or lanes`;
-}
-function format_unit_cap(plan) {
-  if (!has_unit_check2(plan.checks)) return `${UNIT_LABEL2} elsewhere`;
-  if (plan.unit_worker_cap === void 0) return `${UNIT_LABEL2} unrestricted`;
-  return `${UNIT_LABEL2} at ${String(plan.unit_worker_cap)} workers`;
-}
-function format_gate_plan(plan, available_cores = availableParallelism(), concurrent_runs = unit_worker_share.SOLO_RUNS) {
-  const cap = format_unit_cap(plan);
-  const count = `${String(plan.concurrency)} of ${String(plan.checks.length)}`;
-  const width = `${count}${josh_verdict.GATE_OPENING_MARK}`;
-  const machine = format_machine(available_cores, concurrent_runs);
-  return `${josh_verdict.GATE_OPENING_PREFIX}${width}, ${cap} (${machine})`;
-}
-var gate_plan = {
-  DIRECT_UNIT_CLAIM,
-  FILES_PER_WORKER,
-  GATE_CHECKS: GATE_CHECKS2,
-  LANE_GATE_CHECKS: LANE_GATE_CHECKS2,
-  MEASURED_CORES,
-  RESERVED_CORES,
-  STATIC_CHECKS: STATIC_CHECKS2,
-  check_memory,
-  check_weight,
-  direct_unit_weight,
-  format_gate_plan,
-  format_machine,
-  has_unit_check: has_unit_check2,
-  lightest_first,
-  plan_of,
-  resolve_concurrency,
-  resolve_gate_plan,
-  resolve_unit_worker_cap,
-  scoped_unit_weight,
-  select_gate_checks: select_gate_checks2,
-  unit_memory,
-  whole_tree_labels: whole_tree_labels2
-};
-
-export {
-  gate_checks,
-  gate_plan
-};

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

@@ -1,335 +0,0 @@
-import {
-  run_ship_review,
-  run_ship_stop_cause
-} from "./chunk-7HYYHCTN.js";
-import {
-  lane_relaunch
-} from "./chunk-ZV6BZZJ2.js";
-import {
-  api_auth
-} from "./chunk-NUR4FQHM.js";
-import {
-  lane_parked
-} from "./chunk-BLRXHK2V.js";
-import {
-  review_round
-} from "./chunk-EVVQJJFV.js";
-import {
-  review_attest
-} from "./chunk-URZ4RDC4.js";
-import {
-  agent_argv
-} from "./chunk-L7MDU6D7.js";
-import {
-  review_prompt_level
-} from "./chunk-E33LSO2W.js";
-import {
-  agent_role_profile
-} from "./chunk-O5JGV7NA.js";
-import {
-  core_priority
-} from "./chunk-ZCHZU6NX.js";
-import {
-  detached_launch
-} from "./chunk-HDVSZ6CZ.js";
-import {
-  agent_profile_schema
-} from "./chunk-F7B4ESZE.js";
-import {
-  lane_child_invocation,
-  run_ship_stop_context
-} from "./chunk-ON4IKRGS.js";
-import {
-  run_ship_stage
-} from "./chunk-PUQA7F6Y.js";
-import {
-  distributed_paths
-} from "./chunk-3MQTOUXT.js";
-import {
-  parse_json
-} from "./chunk-43DU7DYZ.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  lane_child_marker
-} from "./chunk-XXPDFJRI.js";
-import {
-  stamp_file
-} from "./chunk-VLN6TSPJ.js";
-import {
-  PROJECT_ROOT
-} from "./chunk-3CCGKX7Y.js";
-
-// scripts/review/review-pair.ts
-var PAIRED_ENV = "JOSH_REVIEWER_PAIRED";
-var ENABLED_VALUE = "1";
-var BRIEF_PREFIX = "josh-review-paired-brief-";
-var FINDINGS_PREFIX = "josh-review-paired-findings-";
-var LOG_PREFIX = "josh-review-paired-log-";
-var PAIRED_PROFILE = agent_role_profile.VERIFICATION_PROFILES.anthropic;
-function is_enabled(environment = process.env) {
-  return environment[PAIRED_ENV] === ENABLED_VALUE;
-}
-function paths(directory = PROJECT_ROOT) {
-  return {
-    brief: stamp_file.stamp_path(BRIEF_PREFIX, directory, ".md"),
-    findings: stamp_file.stamp_path(FINDINGS_PREFIX, directory, ".txt"),
-    log: stamp_file.stamp_path(LOG_PREFIX, directory, ".log")
-  };
-}
-function paired_brief(text, findings) {
-  const [level = "", ...rest] = text.split("\n");
-  return [
-    level,
-    "",
-    "## Paired comparison run \u2014 recorded only, never gating",
-    "",
-    `This overrides every attest and submit step below and your agent definition: never run \`review:attest\` or \`review:submit\`. Write your findings to ${findings}, one per line as \`<category>:<severity>:<file>[:<line>] \u2014 <sentence>\`, or the single line \`none\`.`,
-    "",
-    ...rest
-  ].join("\n");
-}
-function paired_opening(brief) {
-  return [
-    `${review_prompt_level.opening(brief)}Review this checkout as a paired /code-review, recorded only: read the review brief at ${brief}`,
-    "and follow its first section over everything else \u2014 never run review:attest or review:submit.",
-    "Review it yourself in this session and never launch a second reviewer."
-  ].join(" ");
-}
-function launch_note(brief) {
-  const opening = paired_opening(brief);
-  return [
-    `paired brief: ${brief}`,
-    `paired model: ${PAIRED_PROFILE.model} \xB7 effort ${PAIRED_PROFILE.effort}`,
-    `paired prompt: ${opening}`,
-    "Paired comparison on: launch a third `reviewer` beside round 1 with the paired model and prompt; when both return, run `pnpm josh review:pair --issue <N> --opus-agent <id> --sonnet-agent <id>` before `review:record`. Its result never gates."
-  ].join("\n");
-}
-function offer(text, environment = process.env, directory = PROJECT_ROOT) {
-  const { brief, findings } = paths(directory);
-  stamp_file.remove_stamp(findings);
-  if (!is_enabled(environment) || review_round.from_brief(text) === "2") {
-    stamp_file.remove_stamp(brief);
-    return void 0;
-  }
-  stamp_file.write_text_stamp(brief, `${paired_brief(text, findings)}
-`);
-  return launch_note(brief);
-}
-function is_offered(directory = PROJECT_ROOT) {
-  return stamp_file.read_stamp_text(paths(directory).brief) !== void 0;
-}
-var review_pair = {
-  PAIRED_ENV,
-  PAIRED_PROFILE,
-  is_enabled,
-  is_offered,
-  offer,
-  opening: paired_opening,
-  paths
-};
-
-// scripts/lane/lane-session-action.ts
-import { existsSync } from "node:fs";
-import path from "node:path";
-
-// scripts/review/review-pair-session.ts
-import { z } from "zod";
-var PAIR_COMMAND = "review:pair";
-var OBJECT_OPENING = "{";
-var record_schema = z.looseObject({});
-var init_schema = z.object({
-  type: z.literal("system"),
-  subtype: z.literal("init"),
-  session_id: z.string().min(1)
-});
-function note(text) {
-  process.stderr.write(`paired reviewer: ${text}
-`);
-}
-function session_in(line) {
-  if (!line.startsWith(OBJECT_OPENING)) return void 0;
-  const record = parse_json.parse_json_object_or_undefined(line, record_schema);
-  return init_schema.safeParse(record).data?.session_id;
-}
-function session_of(log_path) {
-  const lines = stamp_file.read_stamp_text(log_path)?.split("\n") ?? [];
-  return lines.map((line) => session_in(line.trim())).findLast((id) => id !== void 0);
-}
-async function run(directory, environment) {
-  const { brief, log } = review_pair.paths(directory);
-  const opening = review_pair.opening(brief);
-  const built = agent_argv.with_profile_in(opening, review_pair.PAIRED_PROFILE, directory);
-  if (built.kind === "rejected") {
-    note(`not started \u2014 ${built.note}`);
-    return;
-  }
-  stamp_file.remove_stamp(log);
-  const request = {
-    argv: built.argv,
-    cwd: directory,
-    log_path: log,
-    profile: built.profile,
-    env: environment
-  };
-  const result = await detached_launch.launch_attached(request, note);
-  if (result.kind === "failed") note(`not started \u2014 ${result.note}`);
-}
-async function launch(directory, environment) {
-  if (!review_pair.is_offered(directory)) return;
-  try {
-    await run(directory, environment);
-  } catch (error) {
-    note(`failed \u2014 ${error_text.message_of(error)}`);
-  }
-}
-function pair_argv(issue, code_log, directory) {
-  if (!review_pair.is_offered(directory)) return void 0;
-  const opus = session_of(code_log);
-  const sonnet = session_of(review_pair.paths(directory).log);
-  if (opus === void 0 || sonnet === void 0) return void 0;
-  return [PAIR_COMMAND, "--issue", issue, "--opus-agent", opus, "--sonnet-agent", sonnet];
-}
-var review_pair_session = { launch, pair_argv, session_of };
-
-// scripts/lane/lane-session-action.ts
-import { z as z2 } from "zod";
-var BRIEF_PREFIX2 = "josh-ship-review-brief-";
-var FINDINGS_PREFIX2 = "josh-ship-review-findings-";
-var LOG_PREFIX2 = "josh-ship-review-log-";
-var SUBMIT_SCRIPT = "scripts/review/review-submit-cli.ts";
-var ANTHROPIC_PROVIDER = "anthropic";
-var stop_schema = z2.object({
-  stage: z2.enum(run_ship_stage.STAGE),
-  title: z2.string(),
-  flags: z2.array(z2.string()).readonly(),
-  is_review: z2.boolean(),
-  unpinned_ok: z2.array(z2.string()).readonly().exactOptional(),
-  conflicts: z2.array(z2.string()).readonly().default([]),
-  cause: z2.enum(run_ship_stop_cause.CAUSE).exactOptional(),
-  is_review_stale: z2.boolean().exactOptional(),
-  context: run_ship_stop_context.stop_context_schema.exactOptional()
-}).strict();
-var slots_schema = z2.array(z2.enum(review_attest.REVIEW_SLOTS)).readonly();
-var action_schema = z2.discriminatedUnion("kind", [
-  z2.object({
-    kind: z2.literal("review"),
-    round: z2.enum(["1", "2"]),
-    slots: slots_schema.exactOptional()
-  }).strict(),
-  z2.object({ kind: z2.literal("relaunch"), stop: stop_schema }).strict()
-]);
-var request_schema = z2.object({ session: z2.uuid(), nonce: z2.uuid(), action: action_schema }).strict();
-var SUCCESS = { is_success: true };
-function failure(reason) {
-  return { is_success: false, reason };
-}
-function review_paths(directory, slot = review_attest.REVIEW_SLOT.CODE) {
-  const prefix = slot === review_attest.REVIEW_SLOT.CODE ? "" : "interaction-";
-  return {
-    brief: stamp_file.stamp_path(`${BRIEF_PREFIX2}${prefix}`, directory, ".md"),
-    findings: stamp_file.stamp_path(`${FINDINGS_PREFIX2}${prefix}`, directory, ".txt"),
-    log: stamp_file.stamp_path(`${LOG_PREFIX2}${prefix}`, directory, ".log")
-  };
-}
-function provider_of(lane) {
-  return lane.profile?.provider ?? ANTHROPIC_PROVIDER;
-}
-function action_slots(action) {
-  return action.slots ?? [review_attest.REVIEW_SLOT.CODE];
-}
-function has_submit(directory) {
-  return [SUBMIT_SCRIPT, `${distributed_paths.KIT_PACKAGE_PATH_PREFIX}${SUBMIT_SCRIPT}`].some(
-    (script) => existsSync(path.join(directory, script))
-  );
-}
-function review_prompt(lane, action, slot) {
-  const { brief, findings } = review_paths(lane.directory, slot);
-  const round_prompt = action.round === "1" ? run_ship_review.reviewer_prompt : run_ship_review.verification_prompt;
-  const prompt_of = run_ship_review.slot_prompt(round_prompt, slot, action_slots(action));
-  const tail = lane_child_invocation.review_invocation(lane.issue);
-  const findings_path = has_submit(lane.directory) ? void 0 : findings;
-  return `${prompt_of(brief, slot, lane.issue, findings_path)} This is ${tail}`;
-}
-function exited_answer(exit_code, log_path) {
-  const exited = `the reviewer exited with code ${String(exit_code)}`;
-  if (!api_auth.is_auth_failed_transcript(stamp_file.read_stamp_text(log_path))) {
-    return failure(exited);
-  }
-  return failure(`${api_auth.AUTH_FAILURE_NOTE}: ${exited}`);
-}
-function reviewer_answer(result, log_path) {
-  if (result.kind === "failed") return failure(`the reviewer could not start: ${result.note}`);
-  return result.exit_code === 0 ? SUCCESS : exited_answer(result.exit_code, log_path);
-}
-function reviewer_environment(lane) {
-  return { ...lane_child_marker.env_for(lane.issue), ...core_priority.PRIORITY_ENVIRONMENT };
-}
-async function launch_review(lane, action, slot) {
-  const target = review_paths(lane.directory, slot);
-  const prompt = review_prompt(lane, action, slot);
-  const built = agent_argv.review_in(prompt, Number(action.round), lane.directory);
-  if (built.kind === "rejected") return failure(`the reviewer profile was rejected: ${built.note}`);
-  if (built.profile.provider !== provider_of(lane)) {
-    return failure(`the reviewer resolved to ${built.profile.provider}, not the lane's provider`);
-  }
-  console.error(agent_profile_schema.describe_review(Number(action.round), built.profile));
-  const result = await detached_launch.launch_attached(
-    {
-      argv: built.argv,
-      cwd: lane.directory,
-      log_path: target.log,
-      profile: built.profile,
-      env: reviewer_environment(lane)
-    },
-    console.error
-  );
-  return reviewer_answer(result, target.log);
-}
-async function launch_pair(lane, action) {
-  if (action.round !== "1" || !action_slots(action).includes(review_attest.REVIEW_SLOT.CODE)) return;
-  await review_pair_session.launch(lane.directory, reviewer_environment(lane));
-}
-async function launch_reviews(lane, action) {
-  const [answers] = await Promise.all([
-    Promise.all(action_slots(action).map(async (slot) => await launch_review(lane, action, slot))),
-    launch_pair(lane, action)
-  ]);
-  return answers.find((reply) => !reply.is_success) ?? SUCCESS;
-}
-async function relaunch(lane, stop) {
-  if (lane_relaunch.is_openai_lane(lane)) {
-    return failure("an OpenAI lane is relaunched by its own supervisor");
-  }
-  const invocation = lane_child_invocation.ship_stop_invocation(lane.issue, stop);
-  const phase = agent_profile_schema.IMPLEMENTATION_PHASE;
-  const result = await lane_relaunch.relaunch(lane, invocation, phase, console.error);
-  return result.kind === "launched" ? SUCCESS : failure(`the relaunch did not start: ${result.note}`);
-}
-async function perform(lane, action) {
-  if (await lane_parked.is_parked(lane.issue)) return failure("the issue is parked");
-  if (action.kind === "relaunch") return await relaunch(lane, action.stop);
-  return await launch_reviews(lane, action);
-}
-async function answer(lane, action) {
-  try {
-    return await perform(lane, action);
-  } catch (error) {
-    return failure(`the broker failed: ${error_text.message_of(error)}`);
-  }
-}
-var lane_session_action = {
-  SUCCESS,
-  action_schema,
-  answer,
-  failure,
-  request_schema,
-  review_paths
-};
-
-export {
-  review_pair,
-  review_pair_session,
-  lane_session_action
-};