@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-KWLNK2NJ.js

@@ -0,0 +1,391 @@
+import {
+  vitest_failure_summary
+} from "./chunk-GDP7QXYE.js";
+import {
+  test_read_map,
+  test_read_trace
+} from "./chunk-B2PJEV3S.js";
+import {
+  input_fingerprint
+} from "./chunk-GA2YSPFH.js";
+import {
+  changed_file_scope
+} from "./chunk-QX2EMUXV.js";
+import {
+  project_checks
+} from "./chunk-RO4QEZJO.js";
+import {
+  SKIP_MARKER
+} from "./chunk-IW6NWCSN.js";
+import {
+  core_admission,
+  core_budget,
+  held_mark
+} from "./chunk-ZCHZU6NX.js";
+import {
+  machine_capacity
+} from "./chunk-XDR2BRDL.js";
+import {
+  unit_worker_share
+} from "./chunk-B73IIRMS.js";
+import {
+  PROJECT_ENVIRONMENT_KEYS
+} from "./chunk-IGD6QJPH.js";
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+import {
+  core_weights
+} from "./chunk-ENFPR7J2.js";
+import {
+  direct_launch
+} from "./chunk-SVV4U5AR.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/test/test-unit-guard.ts
+import { existsSync, globSync } from "node:fs";
+import { availableParallelism as availableParallelism2 } from "node:os";
+import path2 from "node:path";
+
+// scripts/gate/free-cores.ts
+import { availableParallelism } from "node:os";
+function running_claims(directory) {
+  const own = held_mark.held_reservation();
+  return core_budget.live_reservations(directory).filter((entry) => entry.key !== own);
+}
+function free_of(reading, options) {
+  if (reading.busy_cores === void 0) return void 0;
+  const ledger = core_admission.ledger_load(running_claims(options.directory), Date.now());
+  return machine_capacity.machine_budget(
+    options.available_cores ?? availableParallelism(),
+    reading,
+    ledger
+  ).cores;
+}
+function workers_in_memory(available_mb) {
+  if (available_mb === void 0) return void 0;
+  return available_mb / core_weights.MEMORY_MB.unit_worker;
+}
+async function read(options = {}) {
+  const reading = await (options.read_machine ?? machine_capacity.read_machine)();
+  return {
+    cores: free_of(reading, options),
+    memory_workers: workers_in_memory(reading.available_mb)
+  };
+}
+var free_cores = { read };
+
+// scripts/test/test-unit-guard.ts
+import { execa as execa2 } from "execa";
+
+// scripts/test/project-test-script.ts
+import { execa } from "execa";
+var PNPM = "pnpm";
+var SCRIPT_NAME = "test";
+var FAIL_EXIT_CODE = 1;
+var INIT_PLACEHOLDER = 'echo "Error: no test specified" && exit 1';
+var REENTRY_KEY = "JOSH_PROJECT_TEST_SCRIPT";
+var REENTRY_VALUE = "1";
+var EMPTY_COMMANDS = /* @__PURE__ */ new Set(["", INIT_PLACEHOLDER]);
+function field_of(value, key) {
+  return json_value.is_record(value) ? value[key] : void 0;
+}
+function declared_script(project_directory) {
+  const manifest = project_checks.read_manifest(project_directory);
+  const script = field_of(field_of(manifest, "scripts"), SCRIPT_NAME);
+  if (typeof script !== "string") return void 0;
+  const command = script.trim();
+  return EMPTY_COMMANDS.has(command) ? void 0 : command;
+}
+function state(project_directory, environment = process.env) {
+  if (declared_script(project_directory) === void 0) return "absent";
+  return environment[REENTRY_KEY] === REENTRY_VALUE ? "reentrant" : "declared";
+}
+async function run(project_directory, command_label) {
+  console.info(
+    `josh ${command_label}: vitest is not installed \u2014 running the project's own test script (${PNPM} run ${SCRIPT_NAME}).`
+  );
+  const result = await execa(PNPM, ["run", SCRIPT_NAME], {
+    cwd: project_checks.project_root(project_directory),
+    env: { [REENTRY_KEY]: REENTRY_VALUE },
+    stdio: "inherit",
+    reject: false
+  });
+  return result.exitCode ?? FAIL_EXIT_CODE;
+}
+var project_test_script = { INIT_PLACEHOLDER, REENTRY_KEY, declared_script, state, run };
+
+// scripts/test/test-read-recording.ts
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+var RUN_SUBCOMMAND = "run";
+var WORKER_FLAG_PREFIX = "--maxWorkers";
+var RECORD_DIRECTORY_PREFIX = "josh-test-reads-";
+function is_recordable(vitest_arguments) {
+  const [subcommand, ...flags] = vitest_arguments;
+  return subcommand === RUN_SUBCOMMAND && flags.every((flag) => flag.startsWith(WORKER_FLAG_PREFIX));
+}
+async function commit_directories(commit) {
+  const output = await git_spawn.read(["ls-tree", "-r", "-d", "--name-only", "-z", commit]);
+  return output.split("\0").filter((listed) => listed.length > 0);
+}
+async function own_change() {
+  try {
+    return await changed_paths.read_changed_paths(false);
+  } catch {
+    return [];
+  }
+}
+async function tree_snapshot(root) {
+  const commit = await git_command.head_commit();
+  const dirty = input_fingerprint.of_files(root, await changed_paths.read_changed_since(commit));
+  const change = await own_change();
+  return { commit, dirty, change, directories: await commit_directories(commit) };
+}
+function save_map(root, directory, snapshot) {
+  try {
+    const readers = test_read_map.merge_records(test_read_map.collect_records(directory));
+    test_read_map.write_map(root, { version: test_read_map.MAP_VERSION, ...snapshot, readers });
+  } catch {
+  }
+}
+async function with_read_recording(root, vitest_arguments, run2) {
+  if (!is_recordable(vitest_arguments)) return await run2({});
+  const directory = mkdtempSync(path.join(tmpdir(), RECORD_DIRECTORY_PREFIX));
+  try {
+    const [tree] = await Promise.allSettled([tree_snapshot(root)]);
+    const exit_code = await run2({
+      [test_read_trace.RECORD_DIRECTORY_KEY]: directory,
+      [test_read_trace.ROOT_KEY]: root
+    });
+    if (exit_code === 0 && tree.status === "fulfilled") save_map(root, directory, tree.value);
+    return exit_code;
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+}
+var test_read_recording = { is_recordable, with_read_recording };
+
+// scripts/test/unit-update-arguments.ts
+var UPDATE_VALUES = {
+  all: true,
+  new: true,
+  none: true,
+  true: true,
+  false: true
+};
+var UPDATE_FLAGS = /* @__PURE__ */ new Set(["-u", "--update"]);
+var OPTION_PREFIX = "-";
+var NOT_FOUND = -1;
+function is_filter_word(value) {
+  if (value === void 0 || value.startsWith(OPTION_PREFIX)) return false;
+  return !Object.hasOwn(UPDATE_VALUES, value);
+}
+function filter_words(vitest_arguments) {
+  const next_option = vitest_arguments.findIndex((argument) => argument.startsWith(OPTION_PREFIX));
+  return next_option === NOT_FOUND ? vitest_arguments : vitest_arguments.slice(0, next_option);
+}
+function filter_flag(vitest_arguments) {
+  const delimiter = vitest_arguments.indexOf("--");
+  const options = delimiter === NOT_FOUND ? vitest_arguments : vitest_arguments.slice(0, delimiter);
+  return options.findIndex(
+    (argument, index) => UPDATE_FLAGS.has(argument) && is_filter_word(options[index + 1])
+  );
+}
+function reorder(vitest_arguments) {
+  const flag_index = filter_flag(vitest_arguments);
+  const value = flag_index === NOT_FOUND ? void 0 : vitest_arguments[flag_index + 1];
+  if (!is_filter_word(value)) return { arguments: vitest_arguments };
+  const filters = filter_words(vitest_arguments.slice(flag_index + 1));
+  const ordered = vitest_arguments.toSpliced(flag_index + 1, filters.length);
+  return {
+    arguments: reorder(ordered.toSpliced(flag_index, 0, ...filters)).arguments,
+    filter: value
+  };
+}
+function notice(filter) {
+  return `moved "${filter}" in front of the update flag \u2014 vitest reads the word after it as the update type, not a file filter.`;
+}
+var unit_update_arguments = {
+  notice,
+  reorder
+};
+
+// scripts/test/test-unit-guard.ts
+var FAIL_EXIT_CODE2 = 1;
+var VITEST_PACKAGE = path2.join("node_modules", "vitest");
+var UNIT_GLOB = "**/*.{test,spec}.{ts,js}";
+var NODE_MODULES = "node_modules";
+var SKIP_ACTION = "skip-missing-package";
+var SKIP_NO_TESTS_ACTION = "skip-no-tests";
+var SKIP_NO_SCRIPT_ACTION = "skip-no-test-script";
+var SKIP_REENTRANT_ACTION = "skip-reentrant";
+var RUN_SCRIPT_ACTION = "run-project-script";
+var FAIL_ACTION = "fail-no-tests";
+var VITEST_SUBJECT = "vitest unit tests";
+var UNIT_SUBJECT = "unit tests";
+var SKIP_NOTICES = {
+  [SKIP_ACTION]: { reason: "vitest is not installed", subject: VITEST_SUBJECT },
+  [SKIP_NO_TESTS_ACTION]: {
+    reason: "no unit test files were found in this basic project",
+    subject: VITEST_SUBJECT
+  },
+  [SKIP_NO_SCRIPT_ACTION]: {
+    reason: "vitest is not installed and package.json declares no test script",
+    subject: UNIT_SUBJECT
+  },
+  [SKIP_REENTRANT_ACTION]: {
+    reason: "the project's test script called back into this check",
+    subject: UNIT_SUBJECT
+  }
+};
+var FAIL_REASON = "vitest is installed but no *.{test,spec}.{ts,js} test file was found \u2014 refusing to report a unit check that ran nothing";
+var BASIC_MISSING_PACKAGE_ACTIONS = {
+  declared: RUN_SCRIPT_ACTION,
+  absent: SKIP_NO_SCRIPT_ACTION,
+  reentrant: SKIP_REENTRANT_ACTION
+};
+function resolve_installed_action(has_tests, is_basic) {
+  if (has_tests) return "run";
+  return is_basic ? SKIP_NO_TESTS_ACTION : FAIL_ACTION;
+}
+function resolve_guard_action(is_installed, has_tests, is_basic = false, script_state = "absent") {
+  if (is_installed) return resolve_installed_action(has_tests, is_basic);
+  return is_basic ? BASIC_MISSING_PACKAGE_ACTIONS[script_state] : SKIP_ACTION;
+}
+function is_vitest_installed(project_directory) {
+  return existsSync(path2.join(project_directory, VITEST_PACKAGE));
+}
+function is_in_node_modules(entry) {
+  return entry.split(/[/\\]/u).includes(NODE_MODULES);
+}
+function has_unit_tests(project_directory) {
+  const matches = globSync(UNIT_GLOB, {
+    cwd: project_directory,
+    exclude: is_in_node_modules
+  });
+  return matches.length > 0;
+}
+function guard_action(project_directory) {
+  return resolve_guard_action(
+    is_vitest_installed(project_directory),
+    has_unit_tests(project_directory),
+    project_checks.is_basic(project_directory),
+    project_test_script.state(project_directory)
+  );
+}
+function is_skip_action(action) {
+  return Object.hasOwn(SKIP_NOTICES, action);
+}
+function is_skipping(project_directory) {
+  return is_skip_action(guard_action(project_directory));
+}
+function is_running(project_directory) {
+  const action = guard_action(project_directory);
+  return action === "run" || action === RUN_SCRIPT_ACTION;
+}
+function isolated_unit_environment(environment = process.env) {
+  const isolated = { ...environment };
+  for (const key of PROJECT_ENVIRONMENT_KEYS) Reflect.deleteProperty(isolated, key);
+  return isolated;
+}
+async function vitest_share(vitest_arguments) {
+  if (unit_worker_share.has_worker_flag(vitest_arguments)) return void 0;
+  const available_cores = availableParallelism2();
+  const free = await free_cores.read({ available_cores });
+  const share = unit_worker_share.current_share(
+    available_cores,
+    unit_worker_share.live_run_count(),
+    free,
+    unit_worker_share.live_lane_count()
+  );
+  return unit_worker_share.cap_to_claim(share, core_budget.held_unit_claim());
+}
+async function execute_vitest(vitest_arguments, recording, directory) {
+  const launch = direct_launch(directory, ["exec", "vitest", ...vitest_arguments]);
+  const result = await execa2(launch.file, [...launch.args], {
+    cwd: directory,
+    env: { ...isolated_unit_environment(), ...recording },
+    extendEnv: false,
+    stdin: "inherit",
+    stdout: ["inherit", "pipe"],
+    stderr: ["inherit", "pipe"],
+    all: true,
+    reject: false
+  });
+  const exit_code = result.exitCode ?? FAIL_EXIT_CODE2;
+  vitest_failure_summary.report(vitest_arguments, result.all, exit_code);
+  return exit_code;
+}
+async function run_vitest(vitest_arguments, directory = process.cwd()) {
+  return await unit_worker_share.with_run_marker(async () => {
+    const sized = [
+      ...vitest_arguments,
+      ...unit_worker_share.worker_arguments(vitest_arguments, await vitest_share(vitest_arguments))
+    ];
+    const root = await changed_file_scope.repository_root_or_cwd();
+    return await test_read_recording.with_read_recording(
+      root,
+      sized,
+      async (recording) => await execute_vitest(sized, recording, directory)
+    );
+  });
+}
+async function run_vitest_in(directory, vitest_arguments) {
+  return await run_vitest(vitest_arguments, directory);
+}
+var UNIT_COMMAND_LABEL = "test:unit";
+function report_no_run(action, command_label) {
+  if (action === FAIL_ACTION) {
+    console.error(`josh ${command_label}: ${FAIL_REASON}.`);
+    return FAIL_EXIT_CODE2;
+  }
+  const { reason, subject } = SKIP_NOTICES[action];
+  console.info(`josh ${command_label}: ${reason} ${SKIP_MARKER} ${subject}.`);
+  return 0;
+}
+async function run_guarded_vitest(project_directory, vitest_arguments, command_label = UNIT_COMMAND_LABEL, announcement) {
+  const action = guard_action(project_directory);
+  if (action === RUN_SCRIPT_ACTION) {
+    return await project_test_script.run(project_directory, command_label);
+  }
+  if (action !== "run") return report_no_run(action, command_label);
+  if (announcement !== void 0) process.stdout.write(`${announcement}
+`);
+  return await run_vitest(vitest_arguments);
+}
+async function run_guarded_unit(project_directory, extra_arguments) {
+  const { arguments: ordered, filter } = unit_update_arguments.reorder(extra_arguments);
+  if (filter !== void 0) {
+    console.info(`josh ${UNIT_COMMAND_LABEL}: ${unit_update_arguments.notice(filter)}`);
+  }
+  return await run_guarded_vitest(project_directory, ["run", ...ordered]);
+}
+var test_unit_guard = {
+  SKIP_MARKER,
+  guard_action,
+  is_skipping,
+  is_running,
+  resolve_guard_action,
+  is_vitest_installed,
+  has_unit_tests,
+  isolated_unit_environment,
+  run_guarded_unit,
+  run_guarded_vitest,
+  run_vitest_in,
+  vitest_share
+};
+
+export {
+  free_cores,
+  test_unit_guard
+};

package/dist/commands/chunk-L2CLCNXW.js

@@ -0,0 +1,144 @@
+import {
+  run_wake
+} from "./chunk-QCRUPRQ2.js";
+import {
+  import_graph
+} from "./chunk-4IDINPBE.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  MS_PER_MINUTE,
+  MS_PER_SECOND
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/run/wake/run-wake-code.ts
+function is_changed(loaded, current, is_suspected) {
+  if (current === void 0) return false;
+  if (loaded === void 0) return is_suspected;
+  return loaded !== current;
+}
+function consume(state, read, current) {
+  if (current === void 0) {
+    state.is_suspect = read.is_suspect;
+    return;
+  }
+  state.head = read.head;
+  state.is_suspect = false;
+}
+async function is_stale(state, source, is_suspected) {
+  const head = await source.head();
+  const is_suspect = is_suspected() || state.is_suspect;
+  if (!is_suspect && head === state.head) return false;
+  const current = await source.closure();
+  consume(state, { head, is_suspect }, current);
+  return is_changed(state.loaded, current, is_suspect);
+}
+async function watch(source, is_suspected = () => false) {
+  const state = {
+    head: await source.head(),
+    loaded: await source.closure(),
+    is_suspect: false
+  };
+  return async () => await is_stale(state, source, is_suspected);
+}
+async function read_head() {
+  try {
+    return await git_command.head_commit();
+  } catch (error) {
+    error_text.trace_swallowed("run_wake_code.read_head", error);
+    return void 0;
+  }
+}
+async function read_closure(root, entry) {
+  try {
+    const graph = await import_graph.create(root);
+    return graph?.closure_hash(entry);
+  } catch (error) {
+    error_text.trace_swallowed("run_wake_code.read_closure", error);
+    return void 0;
+  }
+}
+function source_of(root, entry) {
+  return { head: read_head, closure: async () => await read_closure(root, entry) };
+}
+var run_wake_code = { source_of, watch };
+
+// scripts/backlog/backlog-dispatch-bound.ts
+var DISPATCH_BOUND_SECONDS = 60;
+var DISPATCH_BOUND_MS = DISPATCH_BOUND_SECONDS * MS_PER_SECOND;
+var DRIVER_START_SECONDS = 25;
+var DRIVER_START_MS = DRIVER_START_SECONDS * MS_PER_SECOND;
+var NOTICE_MS = DISPATCH_BOUND_MS - DRIVER_START_MS;
+var backlog_dispatch_bound = { DISPATCH_BOUND_MS, DRIVER_START_MS, NOTICE_MS };
+
+// scripts/run/wake/run-wake-window.ts
+var WINDOW_MINUTES = 5;
+var WINDOW_MS = WINDOW_MINUTES * MS_PER_MINUTE;
+var PASS_INTERVAL_MS = backlog_dispatch_bound.NOTICE_MS;
+var run_wake_window = { WINDOW_MINUTES, WINDOW_MS, PASS_INTERVAL_MS };
+
+// scripts/run/wake/run-wake-stop.ts
+function signal(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    console.error(
+      `Process ${String(pid)} could not be signalled; the record is removed regardless.`
+    );
+  }
+}
+function signal_supervisor(wake) {
+  if (run_wake.is_supervisor_live(wake)) signal(wake.pid);
+}
+function stop(wake_target) {
+  const wake = run_wake.read_wake(wake_target);
+  if (wake === void 0) return void 0;
+  run_wake.remove_wake(wake_target);
+  signal_supervisor(wake);
+  return wake;
+}
+var run_wake_stop = { signal, stop };
+
+// scripts/run/wake/run-wake-takeover.ts
+var TAKEOVER_INTERVAL_MS = MS_PER_SECOND;
+var TAKEOVER_WAIT_MS = backlog_dispatch_bound.NOTICE_MS;
+var TAKEOVER_ATTEMPTS = TAKEOVER_WAIT_MS / TAKEOVER_INTERVAL_MS;
+function ports_of(wake_target) {
+  return {
+    holder_pid: () => run_wake.read_wake(wake_target)?.pid,
+    is_alive: process_identity.is_live_pid,
+    stop: run_wake_stop.signal
+  };
+}
+function result_of(pid, ports) {
+  if (ports.holder_pid() === pid) return "taken";
+  return ports.is_alive(pid) ? "unclaimed" : "died";
+}
+async function await_takeover(pid, ports, attempts = TAKEOVER_ATTEMPTS) {
+  await poll.poll_until(async () => result_of(pid, ports) !== "unclaimed", {
+    attempts,
+    interval_ms: TAKEOVER_INTERVAL_MS,
+    ...ports.sleeper && { sleeper: ports.sleeper }
+  });
+  const result = result_of(pid, ports);
+  if (result === "unclaimed") ports.stop(pid);
+  return result;
+}
+var run_wake_takeover = { TAKEOVER_WAIT_MS, await_takeover, ports_of };
+
+export {
+  run_wake_code,
+  run_wake_window,
+  run_wake_stop,
+  run_wake_takeover
+};

package/dist/commands/chunk-L7MDU6D7.js

@@ -0,0 +1,155 @@
+import {
+  agent_diagnostics,
+  claude_agent_argv
+} from "./chunk-6OHJBQDE.js";
+import {
+  review_prompt_level
+} from "./chunk-E33LSO2W.js";
+import {
+  agent_worker_profile
+} from "./chunk-LL6G34MF.js";
+import {
+  agent_phase_profile,
+  agent_role_profile
+} from "./chunk-O5JGV7NA.js";
+import {
+  agent_session_role
+} from "./chunk-DURHGVRC.js";
+import {
+  agent_profile_schema
+} from "./chunk-F7B4ESZE.js";
+
+// scripts/agent/agent-ship-cap.ts
+function has_phase_model(profile, phase) {
+  return agent_phase_profile.phase_model(profile.role, profile.provider, phase, {}) !== void 0;
+}
+function weaker(profile, resolved) {
+  const { worker, settings } = resolved;
+  const rank = settings.profiles.findIndex((entry) => entry.agent.model === profile.model);
+  const limit = settings.profiles.findIndex((entry) => entry.name === worker.name);
+  return rank <= limit ? profile : { ...profile, model: worker.agent.model };
+}
+function capped_by(profile, result) {
+  if (result.kind === "unset") return { kind: "profile", profile };
+  return result.kind === "rejected" ? result : { kind: "profile", profile: weaker(profile, result) };
+}
+async function capped(resolved, phase, worker) {
+  if (resolved.kind === "rejected" || !has_phase_model(resolved.profile, phase)) return resolved;
+  return capped_by(resolved.profile, await worker());
+}
+var agent_ship_cap = { capped };
+
+// scripts/agent/codex-agent-argv.ts
+import path from "node:path";
+var AGENT_COMMAND = "codex";
+var AGENT_FLAGS = ["exec"];
+var MODEL_FLAG = "--model";
+var CONFIG_FLAG = "-c";
+var JSON_FLAG = "--json";
+var SQLITE_CACHE_PATH = ["node_modules", ".cache", "josh", "openai"];
+var EPHEMERAL_FLAG = "--ephemeral";
+var PERMISSION_ARGUMENTS = [
+  CONFIG_FLAG,
+  'default_permissions=":danger-full-access"',
+  CONFIG_FLAG,
+  'approval_policy="never"'
+];
+function effort_config(profile) {
+  return `model_reasoning_effort="${profile.effort}"`;
+}
+function role_config(profile) {
+  return `shell_environment_policy.set.${agent_session_role.KEY}=${JSON.stringify(profile.role)}`;
+}
+function sqlite_config(cwd) {
+  return `sqlite_home=${JSON.stringify(path.resolve(cwd, ...SQLITE_CACHE_PATH))}`;
+}
+function persistence_arguments(profile) {
+  return profile.role === agent_profile_schema.WORKER ? [] : [EPHEMERAL_FLAG];
+}
+function lane_arguments(cwd, profile) {
+  if (cwd === void 0) return [];
+  return [CONFIG_FLAG, sqlite_config(cwd), ...persistence_arguments(profile)];
+}
+function build(invocation, profile, cwd) {
+  return {
+    command: AGENT_COMMAND,
+    args: [
+      ...AGENT_FLAGS,
+      MODEL_FLAG,
+      profile.model,
+      CONFIG_FLAG,
+      effort_config(profile),
+      CONFIG_FLAG,
+      role_config(profile),
+      ...PERMISSION_ARGUMENTS,
+      ...lane_arguments(cwd, profile),
+      JSON_FLAG,
+      invocation
+    ],
+    ends_with_prompt: true
+  };
+}
+var codex_agent_argv = { build };
+
+// scripts/agent/agent-argv.ts
+function build2(invocation, profile, cwd, session_id) {
+  return profile.provider === "openai" ? codex_agent_argv.build(invocation, profile, cwd) : claude_agent_argv.build(invocation, profile, session_id, cwd);
+}
+function build_resume(invocation, profile, session_id, cwd) {
+  return profile.provider === "openai" ? codex_agent_argv.build(invocation, profile, cwd) : claude_agent_argv.build_resume(invocation, profile, session_id, cwd);
+}
+function with_profile_in(invocation, profile, cwd, session_id) {
+  const diagnostic = agent_diagnostics.check(profile);
+  if (diagnostic.kind === "rejected") return diagnostic;
+  return { kind: "argv", argv: build2(invocation, profile, cwd, session_id), profile };
+}
+function with_resume_in(invocation, profile, session_id, cwd) {
+  const diagnostic = agent_diagnostics.check(profile);
+  if (diagnostic.kind === "rejected") return diagnostic;
+  return { kind: "argv", argv: build_resume(invocation, profile, session_id, cwd), profile };
+}
+function with_profile(invocation, profile) {
+  const diagnostic = agent_diagnostics.check(profile);
+  if (diagnostic.kind === "rejected") return diagnostic;
+  return { kind: "argv", argv: build2(invocation, profile), profile };
+}
+function resolve(invocation, role, environment = process.env) {
+  const resolved = agent_role_profile.resolve(role, environment);
+  return resolved.kind === "rejected" ? resolved : with_profile(invocation, resolved.profile);
+}
+function profiled_in(invocation, resolved, cwd) {
+  return resolved.kind === "rejected" ? resolved : with_profile_in(invocation, resolved.profile, cwd);
+}
+async function resume_argv(invocation, profile, phase, site) {
+  const resolved = profile === void 0 ? agent_role_profile.resolve(agent_role_profile.WORKER, process.env, phase) : agent_role_profile.with_phase(profile, phase);
+  const capped2 = await agent_ship_cap.capped(
+    resolved,
+    phase,
+    async () => await agent_worker_profile.resolve(site.cwd, site.labels)
+  );
+  return profiled_in(invocation, capped2, site.cwd);
+}
+function resolve_in(invocation, role, cwd, environment = process.env) {
+  return profiled_in(invocation, agent_role_profile.resolve(role, environment), cwd);
+}
+function review_in(invocation, round, cwd, environment = process.env) {
+  const is_reduced = review_prompt_level.level_of(invocation) === "low";
+  return profiled_in(
+    invocation,
+    agent_role_profile.resolve_review(round, environment, is_reduced),
+    cwd
+  );
+}
+var agent_argv = {
+  resolve,
+  resolve_in,
+  review_in,
+  resume_argv,
+  with_profile,
+  with_profile_in,
+  with_resume_in
+};
+
+export {
+  agent_argv
+};