@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-A6T2N7VC.js

@@ -1,159 +0,0 @@
-import {
-  repo_setting
-} from "./chunk-JJRKTWLK.js";
-
-// scripts/repo/auto-merge-setting-logic.ts
-var SETTING_LABEL = "Repository auto-merge";
-var ALLOW_AUTO_MERGE_FIELD = "allow_auto_merge";
-var ORIGIN_ISSUE = "joshuafolkken/kit#834";
-var WORKFLOW_PATH = ".github/workflows/dependabot-auto-merge.yml";
-function enable_command(repo) {
-  return `gh api -X PATCH repos/${repo_setting.command_target(repo)} -f ${ALLOW_AUTO_MERGE_FIELD}=true`;
-}
-function classify_auto_merge(exit_code, stdout) {
-  return repo_setting.classify_boolean_setting(
-    repo_setting.parse_payload(exit_code, stdout),
-    ALLOW_AUTO_MERGE_FIELD
-  );
-}
-function format_disabled_detail(repo) {
-  return [
-    `    off, so ${WORKFLOW_PATH} fails with`,
-    "    `Auto-merge is not allowed for this repository` and Dependabot pull requests stay open.",
-    `    Enable: ${enable_command(repo)}`,
-    `    ${ORIGIN_ISSUE} distributes the workflow; kit never changes this setting.`
-  ];
-}
-function format_unreadable_detail(repo) {
-  if (repo === void 0) {
-    return [
-      "    The repository could not be identified \u2014 `gh` is missing, unauthenticated, or this is",
-      "    not a GitHub remote."
-    ];
-  }
-  return [
-    "    No admin access, or the request failed (offline, timed out, or an unexpected response).",
-    "    Check Settings \u2192 General \u2192 Pull Requests \u2192 Allow auto-merge on the repository's page."
-  ];
-}
-function format_auto_merge_report(status, repo) {
-  const target = repo_setting.report_target(repo);
-  if (status === "enabled") return [`  \u2714 ${SETTING_LABEL}: enabled (${target})`];
-  if (status === "unreadable") {
-    return [
-      `  \u26A0 ${SETTING_LABEL}: could not be read (${target}) \u2014 not checked, not necessarily off`,
-      ...format_unreadable_detail(repo)
-    ];
-  }
-  return [`  \u26A0 ${SETTING_LABEL}: disabled (${target})`, ...format_disabled_detail(repo)];
-}
-var auto_merge_setting_logic = {
-  SETTING_LABEL,
-  classify_auto_merge,
-  format_auto_merge_report
-};
-
-// scripts/repo/auto-merge-setting.ts
-function read_auto_merge(repo) {
-  const { exit_code, stdout } = repo_setting.query_repo_api(`repos/${repo}`);
-  return auto_merge_setting_logic.classify_auto_merge(exit_code, stdout);
-}
-function report_auto_merge_section(repo) {
-  const status = repo === void 0 ? "unreadable" : read_auto_merge(repo);
-  repo_setting.print_section(auto_merge_setting_logic.format_auto_merge_report(status, repo));
-  return status;
-}
-var auto_merge_setting = {
-  GH_TIMEOUT_MS: repo_setting.GH_TIMEOUT_MS,
-  read_auto_merge,
-  report_auto_merge_section
-};
-
-// scripts/security/security-updates-logic.ts
-var SETTING_LABEL2 = "Dependabot security updates";
-var ENABLED_FIELD = "enabled";
-var PAUSED_FIELD = "paused";
-var ORIGIN_ISSUE2 = "joshuafolkken/kit#803";
-function enable_command2(repo) {
-  return `gh api -X PUT repos/${repo_setting.command_target(repo)}/automated-security-fixes`;
-}
-function classify_active(paused) {
-  if (paused === void 0) return "enabled";
-  if (typeof paused !== "boolean") return "unreadable";
-  return paused ? "paused" : "enabled";
-}
-function classify_security_updates(exit_code, stdout) {
-  const payload = repo_setting.parse_payload(exit_code, stdout);
-  const status = repo_setting.classify_boolean_setting(payload, ENABLED_FIELD);
-  if (status !== "enabled") return status;
-  return classify_active(repo_setting.read_field(payload, PAUSED_FIELD));
-}
-function is_exposed(status) {
-  return status === "disabled" || status === "paused";
-}
-function format_exposed_detail(status, repo) {
-  const remediation = status === "paused" ? [
-    "    enabled but paused, so no advisory pull request is opened.",
-    "    Resume it from the repository's Security \u2192 Dependabot page; re-running the enable",
-    "    API does not clear a pause."
-  ] : [
-    "    off, so npm advisories open no pull request at all.",
-    `    Enable: ${enable_command2(repo)}`
-  ];
-  return [
-    ...remediation,
-    `    ${ORIGIN_ISSUE2} disabled npm version updates, so this is the only remaining npm path.`
-  ];
-}
-function format_unreadable_detail2(repo) {
-  if (repo === void 0) {
-    return [
-      "    The repository could not be identified \u2014 `gh` is missing, unauthenticated, or this is",
-      "    not a GitHub remote."
-    ];
-  }
-  return [
-    "    No admin access, Dependabot not enabled for the repository, or the request failed",
-    "    (offline, timed out, or an unexpected response).",
-    "    Check the repository's Security \u2192 Dependabot page."
-  ];
-}
-function format_security_updates_report(status, repo) {
-  const target = repo_setting.report_target(repo);
-  if (status === "enabled") return [`  \u2714 ${SETTING_LABEL2}: enabled (${target})`];
-  if (!is_exposed(status)) {
-    return [
-      `  \u26A0 ${SETTING_LABEL2}: could not be read (${target}) \u2014 not checked, not necessarily off`,
-      ...format_unreadable_detail2(repo)
-    ];
-  }
-  return [`  \u26A0 ${SETTING_LABEL2}: ${status} (${target})`, ...format_exposed_detail(status, repo)];
-}
-var security_updates_logic = {
-  enable_command: enable_command2,
-  classify_security_updates,
-  is_exposed,
-  format_security_updates_report
-};
-
-// scripts/security/security-updates.ts
-var SECURITY_FIXES_PATH = "automated-security-fixes";
-function read_security_updates(repo) {
-  const { exit_code, stdout } = repo_setting.query_repo_api(`repos/${repo}/${SECURITY_FIXES_PATH}`);
-  return security_updates_logic.classify_security_updates(exit_code, stdout);
-}
-function report_security_updates_section(repo) {
-  const status = repo === void 0 ? "unreadable" : read_security_updates(repo);
-  repo_setting.print_section(security_updates_logic.format_security_updates_report(status, repo));
-  return status;
-}
-var security_updates = {
-  GH_TIMEOUT_MS: repo_setting.GH_TIMEOUT_MS,
-  read_security_updates,
-  report_security_updates_section
-};
-
-export {
-  auto_merge_setting,
-  security_updates
-};

package/dist/commands/chunk-AAUDI7WJ.js

@@ -1,250 +0,0 @@
-import {
-  issue_bug_label
-} from "./chunk-SVTS7ACS.js";
-import {
-  observation_ledger
-} from "./chunk-SV4FZR24.js";
-import {
-  base_tree
-} from "./chunk-DXJQHJQ4.js";
-import {
-  test_declared_logic
-} from "./chunk-7HCPRVMB.js";
-import {
-  changed_paths
-} from "./chunk-V5FD7DVV.js";
-import {
-  change_base
-} from "./chunk-36LOGVJ7.js";
-import {
-  git_location_environment
-} from "./chunk-B77ZMVHS.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/test/test-red.ts
-import { existsSync } from "node:fs";
-import { readFile, realpath, rm, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { execa } from "execa";
-
-// scripts/test/test-red-logic.ts
-import node_path from "node:path";
-import { z } from "zod";
-var { BUG_DECLARATION_LINE } = issue_bug_label;
-var UNIT_TEST_SUFFIX = ".test.ts";
-function is_bug_fix(body) {
-  return issue_bug_label.is_bug_fix(body);
-}
-function unit_test_files(paths) {
-  return paths.map((path2) => path2.trim()).filter((path2) => test_declared_logic.is_test_file(path2) && path2.endsWith(UNIT_TEST_SUFFIX));
-}
-function is_test_only(paths) {
-  const counted = paths.filter((path2) => !observation_ledger.is_ledger_path(path2));
-  return counted.length > 0 && counted.every((path2) => test_declared_logic.is_test_file(path2));
-}
-var REPORT_SCHEMA = z.object({ testResults: z.array(z.unknown()) });
-function ran_file_count(report) {
-  return json_value.parse_with(report, REPORT_SCHEMA)?.testResults.length ?? 0;
-}
-var RESULT_SCHEMA = z.object({ name: z.string(), status: z.string() });
-var RESULTS_SCHEMA = z.object({ testResults: z.array(RESULT_SCHEMA) });
-var FAILED_STATUS = "failed";
-var PARENT_PREFIX = "..";
-function is_inside(name) {
-  return !name.startsWith(PARENT_PREFIX) && !node_path.isAbsolute(name);
-}
-function relative_in(roots, file) {
-  const relatives = roots.map((root) => node_path.relative(root, file));
-  return relatives.filter((name) => is_inside(name)).slice(0, 1);
-}
-function failed_files(report, roots) {
-  const results = json_value.parse_with(report, RESULTS_SCHEMA)?.testResults ?? [];
-  return results.filter((result) => result.status === FAILED_STATUS).flatMap((result) => relative_in(roots, result.name));
-}
-var QUEUED_EVENT = "queued";
-var END_EVENT = "end";
-function progress_reporter(progress) {
-  const target = JSON.stringify(progress);
-  return [
-    "import { appendFileSync } from 'node:fs'",
-    "export default class {",
-    `	onTestModuleQueued(module) { appendFileSync(${target}, \`${QUEUED_EVENT} \${module.moduleId}\\n\`) }`,
-    `	onTestModuleEnd(module) { appendFileSync(${target}, \`${END_EVENT} \${module.moduleId}\\n\`) }`,
-    "}",
-    ""
-  ].join("\n");
-}
-function files_of(lines, event) {
-  const prefix = `${event} `;
-  return lines.filter((line) => line.startsWith(prefix)).map((line) => line.slice(prefix.length));
-}
-function unfinished_files(progress, roots) {
-  const lines = progress.split("\n");
-  const ended = new Set(files_of(lines, END_EVENT));
-  const running = files_of(lines, QUEUED_EVENT).filter((file) => !ended.has(file));
-  return [...new Set(running)].flatMap((file) => relative_in(roots, file));
-}
-function verdict_for(test_count, is_failed) {
-  if (test_count === 0) return is_failed ? "stopped" : "no-test";
-  return is_failed ? "red" : "green";
-}
-function is_refused(body, verdict) {
-  return verdict === "green" && is_bug_fix(body);
-}
-var test_red_logic = {
-  BUG_DECLARATION_LINE,
-  failed_files,
-  is_bug_fix,
-  is_refused,
-  is_test_only,
-  progress_reporter,
-  ran_file_count,
-  unfinished_files,
-  unit_test_files,
-  verdict_for
-};
-
-// scripts/test/vitest-cache-directory.ts
-var CACHE_DIRECTORY_KEY = "JOSH_VITEST_CACHE_DIR";
-function config_cache_directory(environment = process.env) {
-  const directory = environment[CACHE_DIRECTORY_KEY] ?? "";
-  return directory === "" ? void 0 : directory;
-}
-var vitest_cache_directory = { CACHE_DIRECTORY_KEY, config_cache_directory };
-
-// scripts/test/test-red.ts
-var TREE_PREFIX = "josh-test-red-";
-var REPORT_NAME = "report.json";
-var PROGRESS_NAME = "progress.log";
-var REPORTER_NAME = "progress-reporter.mjs";
-var PROBE_TIMEOUT_MS = 3e5;
-var KILL_SIGNAL = "SIGKILL";
-var CACHE_NAME = "vite-cache";
-var VITEST_BIN = path.join(base_tree.NODE_MODULES, ".bin", "vitest");
-var USAGE = "Usage: josh test:red \u2014 prints red / green / no-test / stopped / test-only for the changed tests on the merge-base";
-function changed_tests(paths) {
-  return test_red_logic.unit_test_files(paths).filter((file) => existsSync(file));
-}
-function reporter_arguments(report) {
-  return ["--reporter=json", `--outputFile=${report}`];
-}
-async function read_report(report) {
-  return existsSync(report) ? await readFile(report, "utf8") : "";
-}
-async function prepare_outputs(parent, outputs) {
-  const reporter = path.join(parent, REPORTER_NAME);
-  await Promise.all(
-    outputs.map(async (output) => {
-      await rm(output, { force: true });
-    })
-  );
-  await writeFile(reporter, test_red_logic.progress_reporter(path.join(parent, PROGRESS_NAME)));
-  return reporter;
-}
-var live_groups = /* @__PURE__ */ new Set();
-function kill_group(pid) {
-  if (pid === void 0) return;
-  try {
-    process.kill(-pid, KILL_SIGNAL);
-  } catch {
-  }
-}
-function stop_live_probes() {
-  for (const pid of live_groups) kill_group(pid);
-}
-process.on("exit", stop_live_probes);
-function spawn_vitest({ parent, tree }, vitest_args) {
-  return execa(path.join(tree, VITEST_BIN), vitest_args, {
-    cwd: tree,
-    detached: true,
-    env: {
-      ...git_location_environment.location_free_environment(),
-      [vitest_cache_directory.CACHE_DIRECTORY_KEY]: path.join(parent, CACHE_NAME)
-    },
-    extendEnv: true,
-    reject: false
-  });
-}
-async function vitest_in(base, vitest_args, timeout_ms) {
-  const state = { timed_out: false };
-  const subprocess = spawn_vitest(base, vitest_args);
-  live_groups.add(subprocess.pid);
-  const timer = setTimeout(() => {
-    state.timed_out = true;
-    kill_group(subprocess.pid);
-  }, timeout_ms);
-  const result = await subprocess;
-  clearTimeout(timer);
-  live_groups.delete(subprocess.pid);
-  return {
-    is_failed: result.exitCode !== 0,
-    timed_out: state.timed_out && result.signal === KILL_SIGNAL
-  };
-}
-async function timeout_error(progress, roots, timeout_ms) {
-  const running = test_red_logic.unfinished_files(await read_report(progress), roots);
-  const names = running.length > 0 ? running.join(", ") : "no test file had been queued";
-  return new Error(
-    `vitest probe passed its ${String(timeout_ms)} ms timeout, still running: ${names}`
-  );
-}
-async function probe_in(base, selection, timeout_ms = PROBE_TIMEOUT_MS) {
-  const report = path.join(base.parent, REPORT_NAME);
-  const progress = path.join(base.parent, PROGRESS_NAME);
-  const reporter = await prepare_outputs(base.parent, [report, progress]);
-  const vitest_args = [
-    ...selection,
-    "--passWithNoTests",
-    ...reporter_arguments(report),
-    `--reporter=${reporter}`
-  ];
-  const outcome = await vitest_in(base, vitest_args, timeout_ms);
-  const roots = [base.tree, await realpath(base.tree)];
-  if (outcome.timed_out) throw await timeout_error(progress, roots, timeout_ms);
-  const text = await read_report(report);
-  const ran = test_red_logic.ran_file_count(text);
-  return {
-    verdict: test_red_logic.verdict_for(ran, outcome.is_failed),
-    failed: test_red_logic.failed_files(text, roots),
-    ran
-  };
-}
-async function verdict_on(base, files) {
-  return await base_tree.with_tree(TREE_PREFIX, base, async (pre_fix) => {
-    await base_tree.copy_in(pre_fix.tree, files);
-    const probe = await probe_in(pre_fix, ["run", ...files]);
-    return probe.verdict;
-  });
-}
-async function run() {
-  const base = await change_base.resolved_through_merge();
-  const paths = await changed_paths.read_changed_paths(false);
-  const files = changed_tests(paths);
-  if (base === void 0 || files.length === 0) return { verdict: "no-test", files };
-  if (test_red_logic.is_test_only(paths)) return { verdict: "test-only", files };
-  return { verdict: await verdict_on(base, files), files };
-}
-async function main(argv) {
-  if (argv.length > 0) {
-    process.stderr.write(`${USAGE}
-`);
-    return argv.includes("--help") ? 0 : 1;
-  }
-  const { verdict, files } = await run();
-  process.stdout.write(`${verdict}
-`);
-  if (files.length > 0) process.stderr.write(`${files.join("\n")}
-`);
-  return 0;
-}
-function has_runner() {
-  return existsSync(VITEST_BIN);
-}
-var test_red = { has_runner, main, probe_in, run, stop_live_probes };
-
-export {
-  test_red_logic,
-  test_red
-};

package/dist/commands/chunk-AC26ZUG5.js

@@ -1,259 +0,0 @@
-import {
-  lane_seed_policy
-} from "./chunk-6NGNMIMT.js";
-import {
-  agent_argv
-} from "./chunk-NU7W6QGT.js";
-import {
-  git_gh_issue_write
-} from "./chunk-RN2YDNLF.js";
-import {
-  lane_registry,
-  lane_seat_ownership
-} from "./chunk-452HWOJ7.js";
-import {
-  lane_environment
-} from "./chunk-5ZTQX7OS.js";
-import {
-  run_ship_detach
-} from "./chunk-G4E4M2P4.js";
-import {
-  detached_launch
-} from "./chunk-C2SEDMZ3.js";
-import {
-  lane_child_marker
-} from "./chunk-QAHFPCFR.js";
-import {
-  lane_child_invocation
-} from "./chunk-EW4NPUMQ.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  durable_state
-} from "./chunk-MPGJ4ONJ.js";
-import {
-  lane_paths
-} from "./chunk-YIA6FC3K.js";
-import {
-  ENV_FILE_NAME,
-  LANE_SEAT_KEY,
-  PORT_SEED_KEY
-} from "./chunk-IGD6QJPH.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  file_reader
-} from "./chunk-ZNX2LJCQ.js";
-
-// scripts/lane/lane-dispatch-log.ts
-var LOG_PREFIX = durable_state.PREFIX.LANE_DISPATCH;
-var LOG_SUFFIX = ".log";
-function default_log_path(lane) {
-  return durable_state.path(`${LOG_PREFIX}${lane.issue}-`, lane.directory, LOG_SUFFIX);
-}
-var lane_dispatch_log = { default_log_path };
-
-// scripts/lane/lane-seat.ts
-import { existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
-import path from "node:path";
-var SEAT_LOCK_PREFIX = "seat-";
-function lock_path(root, name) {
-  return path.join(root, lane_paths.SEAT_LOCK_DIR, name);
-}
-function release_lock(lock) {
-  rmSync(lock, { recursive: true, force: true });
-}
-function release(reservation) {
-  release_lock(reservation.lock);
-  release_lock(reservation.issue_lock);
-}
-function open_in_flight_count(root) {
-  try {
-    return readdirSync(path.join(root, lane_paths.SEAT_LOCK_DIR)).filter(
-      (entry) => entry.startsWith(SEAT_LOCK_PREFIX)
-    ).length;
-  } catch {
-    return 0;
-  }
-}
-function claim(lock) {
-  mkdirSync(path.dirname(lock), { recursive: true });
-  try {
-    mkdirSync(lock);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function unreadable_description(lane) {
-  return `${session_cite.issue(lane.issue)} (${lane.directory}): ${lane.seat_problem ?? "unreadable .env"}`;
-}
-function guard_readable(lanes) {
-  const unknown = lanes.filter((lane) => lane.seat_problem !== void 0);
-  if (unknown.length === 0) return;
-  throw new Error(
-    `Cannot read lane port ownership: ${unknown.map((lane) => unreadable_description(lane)).join(", ")}`
-  );
-}
-function report_quarantined(root, lanes) {
-  const unknown = lane_registry.unreadable_lanes(lanes).filter((lane) => !existsSync(lock_path(root, `lane-${lane.issue}`)));
-  for (const lane of unknown) {
-    console.error(
-      `Quarantined lane ${unreadable_description(lane)}; checking candidate ports before allocation.`
-    );
-  }
-}
-function candidates(lanes, issue) {
-  const own = lane_registry.find_lane(lanes, issue);
-  if (own?.seat_owned === true && own.seat !== void 0) return [own.seat];
-  return lane_seed_policy.free_seats(lane_registry.used_seats(lanes));
-}
-async function ports_available(seat, lane) {
-  const root = lane?.directory ?? await lane_registry.main_repository_root();
-  const content = file_reader.read_file_or_empty(path.join(root, ENV_FILE_NAME));
-  const ports = lane_environment.read_lane_ports(lane_environment.lane_file_content(content, seat));
-  const reading = await lane_seat_ownership.snapshot();
-  if (reading === void 0) throw new Error(lane_seat_ownership.UNREADABLE);
-  return !lane_seat_ownership.ports_held(
-    { development_port: ports.development, preview_port: ports.preview },
-    reading.ports
-  );
-}
-async function available(issue, seat) {
-  const lanes = await lane_registry.list_lanes();
-  guard_readable(lanes);
-  if (lane_registry.used_seats(lanes.filter((lane) => lane.issue !== issue)).includes(seat)) {
-    return false;
-  }
-  if (lane_registry.find_lane(lanes, issue)?.seat_owned === true) return true;
-  return await ports_available(seat, lane_registry.find_lane(lanes, issue));
-}
-async function try_seat(root, issue, seat) {
-  const lock = lock_path(root, `${SEAT_LOCK_PREFIX}${String(seat)}`);
-  if (!claim(lock)) return void 0;
-  let is_held = false;
-  try {
-    is_held = await available(issue, seat);
-    return is_held ? lock : void 0;
-  } finally {
-    if (!is_held) release_lock(lock);
-  }
-}
-async function first_available(root, issue, seats) {
-  const [seat, ...rest] = seats;
-  if (seat === void 0) return void 0;
-  const lock = await try_seat(root, issue, seat);
-  return lock === void 0 ? await first_available(root, issue, rest) : { seat, lock };
-}
-async function reserve_locked(root, issue, issue_lock) {
-  const lanes = await lane_registry.list_lanes();
-  guard_readable(lanes);
-  const selected = await first_available(root, issue, candidates(lanes, issue));
-  return selected === void 0 ? void 0 : { ...selected, issue_lock };
-}
-async function reserve(root, issue) {
-  const issue_lock = lock_path(root, `lane-${issue}`);
-  if (!claim(issue_lock)) throw new Error(`Lane ${issue} is already acquiring a port seat.`);
-  try {
-    const reservation = await reserve_locked(root, issue, issue_lock);
-    if (reservation !== void 0) return reservation;
-  } catch (error) {
-    release_lock(issue_lock);
-    throw error;
-  }
-  release_lock(issue_lock);
-  return void 0;
-}
-var lane_seat = { guard_readable, open_in_flight_count, release, report_quarantined, reserve };
-
-// scripts/lane/lane-seat-start.ts
-function update(lane, seat) {
-  const content = lane_registry.read_environment(lane.directory);
-  if (content === void 0) throw new Error(`Cannot read lane environment: ${lane.directory}`);
-  const updated = lane_environment.lane_file_content(content, seat);
-  const ports = lane_environment.read_lane_ports(updated);
-  lane_registry.write_environment(lane.directory, updated);
-  return {
-    ...lane,
-    seat,
-    development_port: ports.development,
-    preview_port: ports.preview,
-    seat_held: true
-  };
-}
-async function start(lane, launch2) {
-  const root = lane_paths.lane_root(await lane_registry.main_repository_root());
-  const reservation = await lane_seat.reserve(root, lane.issue);
-  if (reservation === void 0) throw new Error("No free port seat is available for this lane.");
-  try {
-    return await launch2(update(lane, reservation.seat));
-  } finally {
-    lane_seat.release(reservation);
-  }
-}
-function environment(lane) {
-  if (lane.seat === void 0) {
-    throw new Error("Cannot launch a lane without an allocated port seat.");
-  }
-  const content = lane_registry.read_environment(lane.directory);
-  if (content === void 0) throw new Error(`Cannot read lane environment: ${lane.directory}`);
-  return {
-    [LANE_SEAT_KEY]: String(lane.seat),
-    [PORT_SEED_KEY]: String(lane_environment.read_root_seed(content))
-  };
-}
-var lane_seat_start = { environment, start };
-
-// scripts/lane/lane-relaunch.ts
-var { SUPERVISED_KEY } = run_ship_detach;
-var OPENAI_PROVIDER = "openai";
-function launch(lane, built, on_note) {
-  return detached_launch.launch(
-    {
-      argv: built.argv,
-      cwd: lane.directory,
-      log_path: lane_dispatch_log.default_log_path(lane),
-      profile: built.profile,
-      // The relaunch keeps the mark, so the resumed child is still a dispatched child to every rule
-      // that reads it; the inherited environment cannot be relied on here,
-      // since the parent-session strip runs on the way in. **The ship supervisor's mark is dropped**:
-      // a detached supervisor is what relaunches after a stopped stage, and an
-      // agent that inherited its mark would read its own in-turn `josh ship` failure as a supervisor's —
-      // relaunching a second child into the lane beside itself.
-      env: {
-        ...lane_child_marker.env_for(lane.issue),
-        ...lane_seat_start.environment(lane),
-        [SUPERVISED_KEY]: void 0
-      }
-    },
-    on_note
-  );
-}
-async function relaunch(lane, invocation, phase, on_note) {
-  try {
-    const built = await agent_argv.resume_argv(invocation, lane.profile, phase, {
-      cwd: lane.directory,
-      labels: async () => await git_gh_issue_write.read_label_names(lane.issue)
-    });
-    if (built.kind === "rejected") return built;
-    return await lane_seat_start.start(lane, async (seated) => launch(seated, built, on_note));
-  } catch (error) {
-    return { kind: "failed", note: error_text.message_of(error) };
-  }
-}
-function is_openai_lane(lane) {
-  return lane.profile?.provider === OPENAI_PROVIDER;
-}
-async function resume(lane, phase, on_note) {
-  return await relaunch(lane, lane_child_invocation.resume_invocation(lane.issue), phase, on_note);
-}
-var lane_relaunch = { is_openai_lane, relaunch, resume };
-
-export {
-  lane_dispatch_log,
-  lane_seat,
-  lane_seat_start,
-  lane_relaunch
-};