@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-NDBX7LSS.js

@@ -1,32 +0,0 @@
-import {
-  time_transcript_line
-} from "./chunk-OJ65BZBV.js";
-import {
-  cost_blocks,
-  time_shell
-} from "./chunk-LHKXJD6L.js";
-
-// scripts/rules/tail-commands.ts
-function is_bash_use(block) {
-  return block.type === cost_blocks.TOOL_USE_TYPE && block.name === cost_blocks.BASH_TOOL;
-}
-function bash_commands_of(line) {
-  const parsed = time_transcript_line.parse_line(line);
-  if (parsed === void 0) return [];
-  return parsed.blocks.filter((block) => is_bash_use(block)).map((block) => time_shell.bash_command(block.input));
-}
-function prior_bash_commands(tail) {
-  return tail.split("\n").flatMap((line) => bash_commands_of(line));
-}
-function answered(text, is_call, token) {
-  const blocks = time_transcript_line.parse_text(text).flatMap((line) => line.blocks);
-  const call_ids = new Set(
-    blocks.filter((block) => is_call(time_shell.bash_command(block.input))).map((block) => block.id)
-  );
-  return blocks.some((block) => call_ids.has(block.result_id) && block.token_lines.includes(token));
-}
-var tail_commands = { answered, is_bash_use, prior_bash_commands };
-
-export {
-  tail_commands
-};

package/dist/commands/chunk-NEGJ77RV.js

@@ -1,173 +0,0 @@
-import {
-  repository_labels
-} from "./chunk-FOKCRIAN.js";
-import {
-  github_issue_url
-} from "./chunk-S4X5PJV7.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  MAX_SCANNED,
-  git_gh_issue_list
-} from "./chunk-HXDTA5VU.js";
-import {
-  git_gh_issue_write
-} from "./chunk-RN2YDNLF.js";
-import {
-  RELEASE_LABEL
-} from "./chunk-QQBMVC5W.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  issue_number_shape
-} from "./chunk-66NX6EXR.js";
-import {
-  cli_flags
-} from "./chunk-2FE3C4PH.js";
-import {
-  git_gh_exec
-} from "./chunk-XDF25GSU.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/issue/issue-release.ts
-function is_listing_row(value) {
-  if (typeof value !== "object" || value === null) return false;
-  return Number.isSafeInteger(Reflect.get(value, "number"));
-}
-function open_release_of(json) {
-  const rows = (json_value.parse_array(json) ?? []).filter((row) => is_listing_row(row));
-  return rows.length === 0 ? void 0 : Math.min(...rows.map((row) => row.number));
-}
-function title_of(repo) {
-  return `Release ${repo} (next version)`;
-}
-function body_of(repo) {
-  return [
-    `Tracks the next release of ${repo}.`,
-    "",
-    "Every Issue this one is blocked by changes something a consumer can use only once it is published. Once they have merged, a person runs `pnpm josh release` in the primary checkout.",
-    "",
-    "`pnpm josh release` closes this Issue once that release is published: the next blocker files a new one, so an open release Issue names only unreleased work.",
-    "",
-    "Every Issue this one blocks needs the published version (`pnpm josh issue:release <N> --wait`); closing this Issue hands each of them back to the backlog.",
-    "",
-    "`auto-ok` is never applied to this Issue by a run; a person may apply it.",
-    ""
-  ].join("\n");
-}
-var RELEASE_LABELS = [RELEASE_LABEL];
-var issue_release = { RELEASE_LABELS, open_release_of, title_of, body_of };
-
-// scripts/issue/issue-release-cli.ts
-var SUCCESS_EXIT_CODE = 0;
-var FAILURE_EXIT_CODE = 1;
-var USAGE = "Usage: josh issue:release <issue-number> [--wait]";
-var NONE = "none";
-var UNKNOWN_REPO_MESSAGE = "Could not read this repository from `git remote` \u2014 check `gh auth status`.";
-var OPTIONS = { wait: { type: "boolean" } };
-async function find_open(target) {
-  const outcome = await git_gh_issue_list.issue_list({
-    json_fields: "number",
-    limit: MAX_SCANNED,
-    label: RELEASE_LABEL,
-    repo: target
-  });
-  if (outcome.json === void 0) return void 0;
-  return issue_release.open_release_of(outcome.json) ?? NONE;
-}
-async function file_release(target) {
-  repository_labels.ensure_labels(target);
-  const request = git_gh_issue_write.issue_create_request({
-    title: issue_release.title_of(target),
-    body: issue_release.body_of(target),
-    labels: issue_release.RELEASE_LABELS,
-    repo: target
-  });
-  try {
-    const url = await git_gh_exec.exec_gh_api(request);
-    const issue_number = Number(github_issue_url.parse(url)?.issue_number) || void 0;
-    if (issue_number === void 0) console.error(`\u2716 the release number is unreadable: ${url}`);
-    return issue_number;
-  } catch (error) {
-    console.error(`\u2716 the release Issue could not be filed: ${error_text.message_of(error)}`);
-    return void 0;
-  }
-}
-async function release_of(target) {
-  const open = await find_open(target);
-  if (open === void 0) {
-    console.error(`\u2716 the open ${RELEASE_LABEL} Issues of ${target} could not be listed`);
-    return void 0;
-  }
-  if (open !== NONE) return { issue_number: open, is_filed: false };
-  const filed = await file_release(target);
-  return filed === void 0 ? void 0 : { issue_number: filed, is_filed: true };
-}
-function release_label_of(release, target) {
-  const how = release.is_filed ? "filed" : "open";
-  return `${session_cite.issue(release.issue_number, void 0, target)} (${how})`;
-}
-function linked_line(release, request, target) {
-  const release_label = release_label_of(release, target);
-  const issue_label = session_cite.issue(request.issue_number, void 0, target);
-  return request.is_wait ? `release: ${issue_label} waits on ${release_label}` : `release: ${release_label} is blocked by ${issue_label}`;
-}
-function unlinked_line(edge, target) {
-  const blocker = session_cite.issue(edge.blocker, void 0, target);
-  return `\u2716 ${blocker} could not be recorded as a blocker of ${session_cite.issue(edge.blocked, void 0, target)}`;
-}
-function edge_of(release, request) {
-  return request.is_wait ? { blocked: request.issue_number, blocker: release.issue_number } : { blocked: release.issue_number, blocker: request.issue_number };
-}
-async function record(request, target) {
-  const release = await release_of(target);
-  if (release === void 0) return false;
-  const edge = edge_of(release, request);
-  const is_linked = await git_gh_issue_write.issue_add_blocked_by(
-    String(edge.blocked),
-    String(edge.blocker)
-  );
-  if (is_linked) console.info(linked_line(release, request, target));
-  else console.error(unlinked_line(edge, target));
-  return is_linked;
-}
-async function link(issue_number, target) {
-  return await record({ issue_number, is_wait: false }, target);
-}
-function issue_number_of(positionals) {
-  const [issue_number, ...rest] = positionals;
-  const is_single = rest.length === 0 && issue_number !== void 0;
-  return is_single && issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue_number) ? Number(issue_number) : void 0;
-}
-function request_of(argv) {
-  const parsed = cli_flags.arguments_of(argv, OPTIONS);
-  const issue_number = issue_number_of(parsed?.positionals ?? []);
-  if (parsed === void 0 || issue_number === void 0) return void 0;
-  return { issue_number, is_wait: parsed.values.wait === true };
-}
-async function run(argv) {
-  const request = request_of(argv);
-  if (request === void 0) {
-    console.error(USAGE);
-    return FAILURE_EXIT_CODE;
-  }
-  const current = await git_gh_command.repo_get_name_with_owner();
-  if (current === void 0) {
-    console.error(UNKNOWN_REPO_MESSAGE);
-    return FAILURE_EXIT_CODE;
-  }
-  return await record(request, current) ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE;
-}
-var issue_release_cli = { find_open, link, run };
-
-export {
-  NONE,
-  issue_release_cli
-};

package/dist/commands/chunk-NEGRE5VW.js

@@ -1,101 +0,0 @@
-import {
-  test_related_pins
-} from "./chunk-HE5S4XRE.js";
-import {
-  direct_importers
-} from "./chunk-LAR76BFA.js";
-import {
-  test_pinned_logic
-} from "./chunk-Y27PTXXI.js";
-import {
-  test_pinned_reach
-} from "./chunk-GUR54ELE.js";
-import {
-  related_scope
-} from "./chunk-CFHRNTE5.js";
-import {
-  test_declared_logic
-} from "./chunk-7HCPRVMB.js";
-
-// scripts/test/test-related-cap.ts
-import { existsSync } from "node:fs";
-import path from "node:path";
-var NO_CAP = { importers: /* @__PURE__ */ new Map(), over_cap: [] };
-function reach_sum(counts) {
-  return counts.reduce((sum, reached) => sum + reached.count, 0);
-}
-function over_cap_of(counts, max_tests = test_pinned_logic.MAX_TEST_FILES) {
-  const widest = counts.toSorted((first, second) => second.count - first.count);
-  const fits = widest.findIndex((_, index) => reach_sum(widest.slice(index)) <= max_tests);
-  const narrowed = fits === -1 ? widest : widest.slice(0, fits);
-  return narrowed.map((reached) => reached.file);
-}
-function candidates_of(root, files, narrowed) {
-  return files.filter(
-    (file) => related_scope.is_relatable(file) && !test_declared_logic.is_test_file(file) && !narrowed.has(file) && existsSync(path.join(root, file))
-  );
-}
-async function relative_counts(root, files, read_counts) {
-  if (files.length === 0) return [];
-  const counts = await read_counts(files.map((file) => path.join(root, file)));
-  return (counts ?? []).map((reached) => ({ ...reached, file: path.relative(root, reached.file) }));
-}
-async function read_over_cap(root, files, read_counts) {
-  return over_cap_of(await relative_counts(root, files, read_counts));
-}
-async function direct_of(root, over_cap) {
-  const importers = await direct_importers.importers_of(root, over_cap);
-  const narrowed = [...importers].filter(([, tests]) => tests.length > 0);
-  return narrowed.map(([file, tests]) => [file, test_related_pins.with_pins(file, tests)]);
-}
-async function split_of(root, files) {
-  const every_test = await direct_importers.every_test_importers(root, files);
-  return [every_test, candidates_of(root, files, every_test)];
-}
-async function capped_importers(root, files, is_whole, read_counts = test_pinned_reach.reached_test_counts) {
-  if (is_whole) return NO_CAP;
-  const [every_test, candidates] = await split_of(root, files);
-  const over_cap = await read_over_cap(root, candidates, read_counts);
-  const capped = await direct_of(root, over_cap);
-  return { importers: new Map([...every_test, ...capped]), over_cap: capped.map(([file]) => file) };
-}
-async function hubs_of(root, files, read_counts = test_pinned_reach.reached_test_counts) {
-  const [, candidates] = await split_of(root, files);
-  const counts = await relative_counts(root, candidates, read_counts);
-  return counts.flatMap((reached) => over_cap_of([reached]));
-}
-function capped_test_count(capped) {
-  const tests = capped.over_cap.flatMap((file) => capped.importers.get(file) ?? []);
-  return new Set(tests).size;
-}
-function hub_of(over_cap, own) {
-  return over_cap.find((file) => own.includes(file));
-}
-function over_cap_line(capped, own) {
-  const { over_cap } = capped;
-  if (over_cap.length === 0) return void 0;
-  const { COMMAND_LABEL } = related_scope;
-  const cap = String(test_pinned_logic.MAX_TEST_FILES);
-  const ran = String(capped_test_count(capped));
-  const hub = hub_of(over_cap, own);
-  const hub_part = hub === void 0 ? "" : `, hub ${hub}`;
-  return `${COMMAND_LABEL}: ${String(over_cap.length)} over cap (${cap} test files)${hub_part} \u2014 ${ran} test files run, the rest unchecked: ${over_cap.join(", ")}`;
-}
-function report_over_cap(capped, own) {
-  const line = over_cap_line(capped, own);
-  if (line !== void 0) process.stdout.write(`${line}
-`);
-}
-var test_related_cap = {
-  NO_CAP,
-  capped_importers,
-  hub_of,
-  hubs_of,
-  over_cap_line,
-  over_cap_of,
-  report_over_cap
-};
-
-export {
-  test_related_cap
-};

package/dist/commands/chunk-NFPD2P3V.js

@@ -1,53 +0,0 @@
-import {
-  observation_ledger
-} from "./chunk-SV4FZR24.js";
-import {
-  input_fingerprint
-} from "./chunk-MGF64OHV.js";
-import {
-  changed_paths
-} from "./chunk-V5FD7DVV.js";
-import {
-  change_base
-} from "./chunk-36LOGVJ7.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-
-// scripts/review/review-tree.ts
-var ABSENT_DIGEST = input_fingerprint.ABSENT;
-function tree_of(root, paths) {
-  return input_fingerprint.of_files(
-    root,
-    paths.filter((relative) => !observation_ledger.is_ledger_path(relative))
-  );
-}
-async function read_changed_tree(paths, root) {
-  return tree_of(
-    root ?? await git_command.repository_root(),
-    paths ?? await changed_paths.read_changed_paths(false)
-  );
-}
-var review_tree = { ABSENT_DIGEST, read_changed_tree, tree_of };
-
-// scripts/gate/gate-tree.ts
-async function read_changed_files() {
-  try {
-    return await review_tree.read_changed_tree();
-  } catch {
-    return {};
-  }
-}
-async function read_base() {
-  return await change_base.resolved_through_merge();
-}
-async function read_gate_tree() {
-  const [files, base] = await Promise.all([read_changed_files(), read_base()]);
-  return { files, base };
-}
-var gate_tree = { read_gate_tree };
-
-export {
-  review_tree,
-  gate_tree
-};

package/dist/commands/chunk-NHIW7JE6.js

@@ -1,335 +0,0 @@
-import {
-  run_ship_review,
-  run_ship_stop_cause
-} from "./chunk-MRORPFSO.js";
-import {
-  lane_relaunch
-} from "./chunk-AC26ZUG5.js";
-import {
-  api_auth
-} from "./chunk-NUR4FQHM.js";
-import {
-  lane_parked
-} from "./chunk-FWU3H4TX.js";
-import {
-  review_round
-} from "./chunk-EKLU6QR7.js";
-import {
-  review_attest
-} from "./chunk-KIILCKQR.js";
-import {
-  agent_argv
-} from "./chunk-NU7W6QGT.js";
-import {
-  review_prompt_level
-} from "./chunk-E33LSO2W.js";
-import {
-  agent_role_profile
-} from "./chunk-6UCWAFQY.js";
-import {
-  core_priority
-} from "./chunk-TCBUX52E.js";
-import {
-  detached_launch
-} from "./chunk-C2SEDMZ3.js";
-import {
-  lane_child_marker
-} from "./chunk-QAHFPCFR.js";
-import {
-  distributed_paths
-} from "./chunk-66TGK5XL.js";
-import {
-  agent_profile_schema
-} from "./chunk-EZSO25UZ.js";
-import {
-  lane_child_invocation,
-  run_ship_stop_context
-} from "./chunk-EW4NPUMQ.js";
-import {
-  run_ship_stage
-} from "./chunk-OHNP3QL2.js";
-import {
-  parse_json
-} from "./chunk-XDF25GSU.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.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
-};