@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-UKBBWMLE.js

@@ -1,1189 +0,0 @@
-import {
-  run_wake_code,
-  run_wake_stop,
-  run_wake_takeover,
-  run_wake_window
-} from "./chunk-HG2NZQD5.js";
-import {
-  run_wake_handoff
-} from "./chunk-EBI2BAKQ.js";
-import {
-  lane_withdraw_closed
-} from "./chunk-TP6L4W3W.js";
-import {
-  lane_close
-} from "./chunk-ZZFFSQF4.js";
-import {
-  backlog_drive_args
-} from "./chunk-JHN6RCE6.js";
-import {
-  lane_session_broker
-} from "./chunk-L7DAL54N.js";
-import {
-  ts_entry_loader
-} from "./chunk-VHRNXWVP.js";
-import {
-  lane_relaunch
-} from "./chunk-AC26ZUG5.js";
-import {
-  document_section_cli
-} from "./chunk-ZSOR4ISJ.js";
-import {
-  run_stranded_detect
-} from "./chunk-G5KSL2Q2.js";
-import {
-  run_wake
-} from "./chunk-6Q3XUCLM.js";
-import {
-  run_carry_ended
-} from "./chunk-ZVAIIHBE.js";
-import {
-  epic_triage
-} from "./chunk-VQRT32JB.js";
-import {
-  josh_command
-} from "./chunk-2VRITY55.js";
-import {
-  telegram_notify
-} from "./chunk-WJ4NEDNI.js";
-import {
-  run_step_section_table
-} from "./chunk-JIGBNCDR.js";
-import {
-  gh_spawn
-} from "./chunk-3PEXBHRN.js";
-import {
-  backlogrun_launch
-} from "./chunk-2EZTYLO4.js";
-import {
-  agent_argv
-} from "./chunk-NU7W6QGT.js";
-import {
-  claude_agent_argv
-} from "./chunk-DEZF7QZZ.js";
-import {
-  run_event_setup
-} from "./chunk-I2KCGKJI.js";
-import {
-  run_headless
-} from "./chunk-7C7FOKJK.js";
-import {
-  agent_role_profile
-} from "./chunk-6UCWAFQY.js";
-import {
-  lane_registry
-} from "./chunk-452HWOJ7.js";
-import {
-  run_liveness
-} from "./chunk-3AEDZZNL.js";
-import {
-  detached_launch
-} from "./chunk-C2SEDMZ3.js";
-import {
-  run_event_stream_emit
-} from "./chunk-OKZWEVR4.js";
-import {
-  run_event_stream
-} from "./chunk-NSAVEXVR.js";
-import {
-  agent_safe_text
-} from "./chunk-3LZXX5GL.js";
-import {
-  issue_citation
-} from "./chunk-22DVQCP6.js";
-import {
-  run_carry,
-  run_invocation
-} from "./chunk-MPGJ4ONJ.js";
-import {
-  cli_flags
-} from "./chunk-2FE3C4PH.js";
-import {
-  poll
-} from "./chunk-SBGTCT2C.js";
-import {
-  process_identity
-} from "./chunk-AKK56GNX.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  MS_PER_SECOND
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/run/wake/run-wake-cli.ts
-import { dirname as __josh_dirname } from "node:path";
-import { fileURLToPath as __josh_file_path } from "node:url";
-import { fileURLToPath } from "node:url";
-
-// scripts/run/wake/run-wake-await.ts
-function is_live_carry(read, ports) {
-  if (read.kind !== "carried") return false;
-  return ports.is_owner_live(read.carry) || ports.is_launched_record(read.carry);
-}
-function is_launched_record(carry, git_directory) {
-  const launch = backlogrun_launch.pending_launch(git_directory);
-  if (launch === void 0 || carry.is_handed_off !== true) return false;
-  return carry.invocation === launch.invocation && Date.parse(carry.started_at) === Date.parse(launch.started_at);
-}
-function supervised_invocation(ports) {
-  const read = ports.read_carry();
-  if (read.kind !== "carried") return ports.pending_invocation();
-  if (ports.is_owner_live(read.carry)) return read.carry.invocation;
-  return ports.pending_invocation() ?? read.carry.invocation;
-}
-async function await_carry(ports, interval_ms) {
-  const read = ports.read_carry();
-  if (is_live_carry(read, ports)) return read;
-  if (ports.pending_invocation() === void 0) return ports.read_carry();
-  await ports.sleep(interval_ms);
-  return await await_carry(ports, interval_ms);
-}
-function ports_of(context) {
-  return {
-    read_carry: () => run_carry.read_carry(context.carry_target),
-    pending_invocation: () => backlogrun_launch.pending_launch(context.git_directory)?.invocation,
-    is_owner_live: (carry) => run_carry.is_owner_live(carry),
-    is_launched_record: (carry) => is_launched_record(carry, context.git_directory),
-    sleep: poll.sleep
-  };
-}
-function supervised_carry(read, invocation, ports) {
-  if (read.kind !== "carried") return void 0;
-  if (read.carry.invocation === invocation || ports.is_owner_live(read.carry)) return read.carry;
-  return void 0;
-}
-function held_for(target, wake, carry, profile) {
-  if (carry.invocation === wake.invocation) return { kind: "claimed", wake, carry };
-  const supervised2 = run_wake.fresh_wake(carry.invocation, /* @__PURE__ */ new Date(), profile);
-  run_wake.update_wake(target, supervised2);
-  return { kind: "claimed", wake: supervised2, carry };
-}
-async function claim_run(context, profile, interval_ms, ports = ports_of(context)) {
-  const invocation = supervised_invocation(ports);
-  if (invocation === void 0) return { kind: "refused", carry_kind: ports.read_carry().kind };
-  const wake = run_wake.claim(context.wake_target, invocation, /* @__PURE__ */ new Date(), profile);
-  if (wake === void 0) return { kind: "running" };
-  const read = await await_carry(ports, interval_ms);
-  const carry = supervised_carry(read, invocation, ports);
-  if (carry !== void 0) return held_for(context.wake_target, wake, carry, profile);
-  run_wake.tidy_own_wake(context.wake_target);
-  return { kind: "refused", carry_kind: read.kind };
-}
-var run_wake_await = { await_carry, claim_run, supervised_invocation };
-
-// scripts/run/wake/run-wake-describe.ts
-import path from "node:path";
-
-// scripts/run/wake/run-wake-caffeinate.ts
-import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-var CAFFEINATE_PATH = "/usr/bin/caffeinate";
-var CAFFEINATE_FLAGS = ["-i", "-s", "-w"];
-function argv(pid) {
-  return [...CAFFEINATE_FLAGS, String(pid)];
-}
-function keep_awake(pid, is_present = existsSync, spawner = spawn) {
-  if (!is_present(CAFFEINATE_PATH)) return;
-  const child = spawner(CAFFEINATE_PATH, argv(pid), { detached: true, stdio: "ignore" });
-  child.on("error", () => {
-  });
-  child.unref();
-}
-var run_wake_caffeinate = {
-  CAFFEINATE_PATH,
-  argv,
-  keep_awake
-};
-
-// scripts/run/wake/run-wake-session.ts
-var WAKE_COMMAND = claude_agent_argv.AGENT_COMMAND;
-var WAKE_FLAGS = claude_agent_argv.AGENT_FLAGS;
-var LOOP_FLAG = "--loop";
-var INTERVAL_FLAG = "--interval";
-var SUPERVISOR_SESSION = "run-wake-supervisor";
-function scheduler_profile() {
-  const resolved = agent_role_profile.resolve(agent_role_profile.SCHEDULER);
-  agent_role_profile.warn_of_default();
-  if (resolved.kind === "profile") return resolved.profile;
-  console.error(resolved.note);
-  return void 0;
-}
-function chosen_profile(provider) {
-  const environment = backlogrun_launch.chosen_environment(provider);
-  return agent_role_profile.resolve(agent_role_profile.SCHEDULER, environment);
-}
-function supervisor_environment(profile) {
-  return profile.provider === "openai" ? { CODEX_THREAD_ID: SUPERVISOR_SESSION } : { CLAUDE_CODE_CHILD_SESSION: SUPERVISOR_SESSION, CODEX_THREAD_ID: void 0 };
-}
-function safe_invocation(invocation) {
-  if (!detached_launch.is_safe_value(invocation)) return void 0;
-  const rebuilt = run_invocation.rebuild(invocation);
-  return rebuilt === invocation ? rebuilt : void 0;
-}
-function profiled_argv(invocation, profile, cwd, session_id) {
-  return cwd === void 0 ? agent_argv.with_profile(invocation, profile) : agent_argv.with_profile_in(invocation, profile, cwd, session_id);
-}
-function resolved_argv(invocation, cwd) {
-  return cwd === void 0 ? agent_argv.resolve(invocation, agent_role_profile.SCHEDULER) : agent_argv.resolve_in(invocation, agent_role_profile.SCHEDULER, cwd);
-}
-function handoff_prompt(matched, material) {
-  return `${matched}
-Driver handoff: ${agent_safe_text.printable(material)}`.slice(
-    0,
-    agent_safe_text.MAX_PROMPT_LENGTH
-  );
-}
-function wake_argv(invocation, profile, cwd, session) {
-  const matched = safe_invocation(invocation);
-  if (matched === void 0) return void 0;
-  const prompt = typeof session === "object" ? handoff_prompt(matched, session.material) : matched;
-  const session_id = typeof session === "object" ? session.id : session;
-  return profile === void 0 ? resolved_argv(prompt, cwd) : profiled_argv(prompt, profile, cwd, session_id);
-}
-function supervisor_argv(script_path, interval) {
-  const chosen = interval === void 0 ? [] : [INTERVAL_FLAG, interval];
-  return {
-    command: process.execPath,
-    args: [...ts_entry_loader.loader_argv(process.execArgv), script_path, LOOP_FLAG, ...chosen]
-  };
-}
-var run_wake_session = {
-  INTERVAL_FLAG,
-  LOOP_FLAG,
-  WAKE_COMMAND,
-  WAKE_FLAGS,
-  ensure_log: detached_launch.ensure_log,
-  is_safe_argv: detached_launch.is_safe_argv,
-  keep_awake: run_wake_caffeinate.keep_awake,
-  launch: detached_launch.launch,
-  chosen_profile,
-  scheduler_profile,
-  supervisor_argv,
-  supervisor_environment,
-  wake_argv
-};
-
-// scripts/run/wake/run-wake-describe.ts
-var UNKNOWN_CUTS = "an unreadable number of";
-var REPO_LOOKUP_TIMEOUT_MS = 1e4;
-var STOP_COMMAND = "pnpm josh backlogrun --stop";
-var UNREADABLE_TIME = "an unreadable time";
-function carry_cuts(read) {
-  if (read.kind === "carried") return String(read.carry.cuts);
-  return UNKNOWN_CUTS;
-}
-function outstanding_line(wake) {
-  if (wake.attempts === void 0) return void 0;
-  return `${String(wake.attempts)} launch(es) outstanding for the current cut, none claimed yet`;
-}
-function wait_input(wake, read, now) {
-  return {
-    read,
-    woke_at: wake.woke_at,
-    attempts: wake.attempts ?? 0,
-    is_owner_live: read.kind === "carried" && run_carry.is_owner_live(read.carry, now),
-    has_work: wake.idle_since === void 0 ? void 0 : false,
-    idle_since: wake.idle_since,
-    now
-  };
-}
-function deadline(marked_at, limit_ms) {
-  const marked = Date.parse(marked_at ?? "");
-  return Number.isNaN(marked) ? UNREADABLE_TIME : new Date(marked + limit_ms).toISOString();
-}
-function owner_wait(wake, carry) {
-  if (carry.owner_pid === wake.pid) {
-    return "waiting: the driver holds the carry record and is running";
-  }
-  return `waiting: process ${String(carry.owner_pid)} holds the carry record; the driver starts at its next cut or once it exits`;
-}
-var WAIT_LINES = {
-  pending: (wake) => `waiting: the woken session has until ${deadline(wake.woke_at, run_wake.WAKE_GRACE_MS)} to begin work on the carry record`,
-  idle: (wake) => `waiting: no runnable work; the driver starts anyway at ${deadline(wake.idle_since, run_wake.IDLE_CEILING_MS)}`
-};
-function wait_line(wake, read, now) {
-  const { kind } = run_wake.decide(wait_input(wake, read, now));
-  if (kind === "wait" && read.kind === "carried") return owner_wait(wake, read.carry);
-  return WAIT_LINES[kind]?.(wake);
-}
-function stream_lines(context) {
-  const event = run_event_stream.read_last(context.event_target);
-  const progress = event === void 0 ? [] : [`progress: ${run_event_stream.format_event(event)}`];
-  const follow = `watch: \`pnpm josh run:board\` in a pane of its own (recover with \`tail -F ${context.event_target}\`)`;
-  return [...progress, follow];
-}
-function describe_wake(wake, context, now = /* @__PURE__ */ new Date()) {
-  const live = run_wake.is_supervisor_live(wake) ? "running" : "not running";
-  const read = run_carry.read_carry(context.carry_target);
-  return [
-    `invocation: ${wake.invocation}`,
-    `profile: ${wake.profile === void 0 ? "unrecorded" : agent_role_profile.describe(wake.profile)}`,
-    `supervisor: process ${String(wake.pid)} (${live}), watching since ${wake.started_at}`,
-    `woke ${String(wake.woke)} session(s) across ${carry_cuts(read)} cut(s)`,
-    outstanding_line(wake),
-    wait_line(wake, read, now),
-    run_liveness.describe_agent_state(context.log_target),
-    `output: ${context.log_target}`,
-    // How progress is seen without asking after the cut: the run's stream, followed from here.
-    // `--list` is that reader's one-shot last-event form.
-    ...stream_lines(context),
-    `stop it with \`${STOP_COMMAND}\``
-  ].filter((line) => line !== void 0).join("\n");
-}
-function cite_description(description, repo) {
-  return repo === void 0 ? description : issue_citation.linkify(description, repo);
-}
-function describe_wake_cited(wake, context) {
-  const repo = gh_spawn.get_repo_name_with_owner_within(REPO_LOOKUP_TIMEOUT_MS);
-  return cite_description(describe_wake(wake, context), repo);
-}
-function context_of(directory, note) {
-  const log_target = run_wake.wake_log_path(directory);
-  run_wake_session.ensure_log(log_target, note);
-  return {
-    carry_target: run_carry.carry_path(directory),
-    ended_target: run_carry_ended.ended_path(directory),
-    wake_target: run_wake.wake_path(directory),
-    log_target,
-    event_target: run_event_stream.target_of(directory),
-    git_directory: directory,
-    worktree: path.dirname(directory)
-  };
-}
-var run_wake_describe = {
-  STOP_COMMAND,
-  cite_description,
-  context_of,
-  describe_wake,
-  describe_wake_cited
-};
-
-// scripts/run/wake/run-wake-loop.ts
-var STOPPED_REASON = "stopped";
-var FAILED_REASON = "failed";
-var RELOAD_REASON = "reload";
-var NO_ATTEMPTS = 0;
-var STOPPED_BY_PERSON = { reason: STOPPED_REASON, note: void 0 };
-var CODE_CHANGED = { reason: RELOAD_REASON, note: void 0 };
-function stopped(reason, note) {
-  return { kind: "stop", stop: { reason, note } };
-}
-function wake_failure_note(wake) {
-  const attempts = String(wake.attempts ?? NO_ATTEMPTS);
-  const last = wake.woke_pid === void 0 ? "none" : `process ${String(wake.woke_pid)}`;
-  return `woke a session for "${wake.invocation}" ${attempts} time(s) and none of them claimed the carry record; the last one was ${last}, which may still be running`;
-}
-function beside_step(wake, material, ports) {
-  const result = ports.wake_beside(wake.invocation, ports.new_session_id(), material);
-  return result.kind === "failed" ? stopped(FAILED_REASON, result.note) : { kind: "continue", wake };
-}
-function handoff_step(wake, material, ports) {
-  const session_id = ports.new_session_id();
-  ports.hand_off(session_id);
-  const result = ports.wake(wake.invocation, session_id, material);
-  if (result.kind === "failed") return stopped(FAILED_REASON, result.note);
-  return { kind: "continue", wake: run_wake.count_wake(wake, ports.now(), result.pid, session_id) };
-}
-async function wake_step(wake, ports) {
-  const driven = await ports.drive();
-  if (driven.kind === "finished") return stopped("ended");
-  if (driven.kind === "failed") return stopped(FAILED_REASON, driven.note);
-  if (driven.kind === "released") return { kind: "continue", wake };
-  return driven.kind === "triage" ? beside_step(wake, driven.material, ports) : handoff_step(wake, driven.material, ports);
-}
-function continue_step(wake, decision, ports) {
-  if (decision.kind === "wait") return { kind: "continue", wake: run_wake.count_claim(wake) };
-  if (decision.kind === "idle") {
-    return { kind: "continue", wake: run_wake.mark_idle(wake, ports.now()) };
-  }
-  return { kind: "continue", wake };
-}
-async function step(wake, decision, ports) {
-  if (decision.kind === "stop") return stopped(decision.reason);
-  if (decision.kind === "failed") return stopped(FAILED_REASON, wake_failure_note(wake));
-  if (decision.kind === "wake") return await wake_step(wake, ports);
-  return continue_step(wake, decision, ports);
-}
-function decision_input(wake, ports) {
-  const read = ports.read_carry();
-  return {
-    read,
-    woke_at: wake.woke_at,
-    attempts: wake.attempts ?? NO_ATTEMPTS,
-    is_owner_live: ports.is_owner_live(read),
-    has_work: void 0,
-    idle_since: wake.idle_since,
-    now: ports.now()
-  };
-}
-async function decide_pass(wake, ports) {
-  const input = decision_input(wake, ports);
-  const decision = run_wake.decide(input);
-  if (decision.kind !== "wake") return decision;
-  return run_wake.decide({ ...input, has_work: await ports.has_work(input.read) });
-}
-async function retry_closes(ports) {
-  try {
-    await ports.retry_closes();
-  } catch (error) {
-    error_text.trace_swallowed("run_wake_loop.retry_closes", error);
-  }
-}
-async function run_pass(target, wake, ports) {
-  const decision = await decide_pass(wake, ports);
-  if (decision.kind !== "stop" && await ports.is_code_stale()) return CODE_CHANGED;
-  await retry_closes(ports);
-  const outcome = await step(wake, decision, ports);
-  if (outcome.kind === "stop") return outcome.stop;
-  return run_wake.update_wake(target, outcome.wake) ? void 0 : STOPPED_BY_PERSON;
-}
-function without_release_gap(ports) {
-  let is_released = false;
-  return {
-    ...ports,
-    drive: async () => {
-      const result = await ports.drive();
-      is_released = result.kind === "released" || result.kind === "triage";
-      return result;
-    },
-    sleep: async (milliseconds) => {
-      const duration = is_released ? 0 : milliseconds;
-      is_released = false;
-      await ports.sleep(duration);
-    }
-  };
-}
-async function run_loop(target, ports, interval_ms) {
-  const continuous = without_release_gap(ports);
-  return await poll.wait_for(
-    async () => {
-      const wake = run_wake.read_own_wake(target);
-      return wake === void 0 ? STOPPED_BY_PERSON : await run_pass(target, wake, continuous);
-    },
-    { interval_ms, sleeper: continuous.sleep }
-  );
-}
-var run_wake_loop = {
-  FAILED_REASON,
-  RELOAD_REASON,
-  run_loop
-};
-
-// scripts/run/wake/run-wake-finish.ts
-var SUCCESS_EXIT_CODE = 0;
-var FAILURE_EXIT_CODE = 1;
-var WARNING_TITLE = "run:wake supervisor";
-var WARNING_RECOVERY = `Check the wake command, then restart with \`pnpm josh run:wake --start\`.`;
-var STOP_BODIES = {
-  ended: void 0,
-  stopped: void 0,
-  reload: void 0,
-  failed: "The supervisor could not continue the run and has stopped.",
-  unreadable: "The carry record could not be read, so the supervisor stopped rather than guess at it."
-};
-function log_hint(context) {
-  return `The output of every session this supervisor started is in ${context.log_target}.`;
-}
-function warning_body(stop, body, context) {
-  return [body, log_hint(context), stop.note].filter(Boolean).join("\n");
-}
-async function warn_of_stop(stop, body, context) {
-  return await telegram_notify.warn({
-    issue_title: WARNING_TITLE,
-    body: warning_body(stop, body, context),
-    recovery: WARNING_RECOVERY
-  });
-}
-function is_strand_told(stop, watched, is_warned) {
-  if (!is_warned || stop.reason !== run_wake_loop.FAILED_REASON) return false;
-  return run_stranded_detect.is_left_stranded(watched);
-}
-async function record_failure(stop, watched, is_warned) {
-  if (!is_strand_told(stop, watched, is_warned)) return;
-  const [cause = ""] = (stop.note ?? "").split("\n", 1);
-  await run_event_stream_emit.emit(
-    run_event_stream.EVENT_KIND.STRANDED,
-    `The supervisor failed and stopped watching the run \u2014 ${cause}`
-  );
-}
-function exit_code_of(reason) {
-  return reason === run_wake_loop.FAILED_REASON ? FAILURE_EXIT_CODE : SUCCESS_EXIT_CODE;
-}
-function stop_body(reason) {
-  return STOP_BODIES[reason];
-}
-async function warn_and_record(stop, body, context, started_at) {
-  console.error(stop.note ?? body);
-  const is_warned = await warn_of_stop(stop, body, context);
-  await record_failure(stop, { ...context, started_at }, is_warned);
-}
-async function finish(stop, context, started_at) {
-  const body = stop_body(stop.reason);
-  if (body !== void 0) await warn_and_record(stop, body, context, started_at);
-  console.info(stop.reason);
-  return exit_code_of(stop.reason);
-}
-var run_wake_finish = {
-  finish,
-  record_failure,
-  stop_body,
-  warning_body
-};
-
-// scripts/run/wake/run-wake-ports.ts
-import { randomUUID } from "node:crypto";
-
-// scripts/run/run-step-section-driver.ts
-var { DRIVER_SECTIONS, LOOP } = run_step_section_table;
-function carried_text(found, root) {
-  return document_section_cli.section_text(found.document, found.heading, root) ?? `\`${found.document}\` \u2192 "${found.heading}"`;
-}
-function driver_sections(verdict, root = process.cwd()) {
-  const found = DRIVER_SECTIONS.find(([prefix]) => verdict.startsWith(prefix));
-  return (found?.[1] ?? [LOOP]).map((section) => carried_text(section, root)).join("\n");
-}
-var run_step_section_driver = { driver_sections };
-
-// scripts/run/wake/run-wake-resume.ts
-var RESUME_PREFIX = "resume: ";
-var OWNER_FLAG = "--owner";
-var DROPPED_FLAGS = /* @__PURE__ */ new Set([OWNER_FLAG, "--active"]);
-var SUFFIX = ".resume";
-var SUCCESS = 0;
-function resume_of(out) {
-  return out.split("\n").find((line) => line.startsWith(RESUME_PREFIX));
-}
-function is_dropped(flags, index) {
-  return [flags[index], flags[index - 1]].some(
-    (flag) => flag !== void 0 && DROPPED_FLAGS.has(flag)
-  );
-}
-function state_flags(line) {
-  const flags = line.slice(RESUME_PREFIX.length).split(" ");
-  if (!flags.includes(OWNER_FLAG) || backlog_drive_args.parse(flags) === void 0) return void 0;
-  return flags.filter((_flag, index) => !is_dropped(flags, index));
-}
-function is_valid(line) {
-  return state_flags(line) !== void 0;
-}
-function resumed_args(base, line) {
-  const state = line === void 0 ? void 0 : state_flags(line);
-  return state === void 0 ? void 0 : [...base, ...state];
-}
-function key_of(carry) {
-  return `${carry.started_at} ${carry.invocation}`;
-}
-function resume_path(target) {
-  return `${target}${SUFFIX}`;
-}
-function stored(target, carry) {
-  const [key, line] = stamp_file.read_stamp_text(resume_path(target))?.split("\n") ?? [];
-  return key === key_of(carry) ? line : void 0;
-}
-function remember(target, carry, result) {
-  if (result.code !== SUCCESS) return;
-  const line = resume_of(result.out);
-  const source = resume_path(target);
-  if (line === void 0) stamp_file.remove_stamp(source);
-  else stamp_file.replace_text_stamp(source, `${key_of(carry)}
-${line}`);
-}
-function name_beside(target, carry, pid) {
-  const line = stored(target, carry);
-  if (line === void 0) return;
-  const flags = backlog_drive_args.beside_flags(pid, process_identity.read_start(pid));
-  stamp_file.replace_text_stamp(resume_path(target), `${key_of(carry)}
-${line} ${flags.join(" ")}`);
-}
-var run_wake_resume = { is_valid, name_beside, remember, resume_of, resumed_args, stored };
-
-// scripts/run/wake/run-wake-driver.ts
-var SUCCESS2 = 0;
-var FIRST_LINE = 0;
-var DETAILS_TAIL_LENGTH = 2048;
-var TRUNCATION_MARK = "... ";
-var ERROR_PREFIX = "error ";
-var { WINDOW_MINUTES } = run_wake_window;
-var WINDOW_VERDICT = "window";
-var { TRIAGE_VERDICT } = epic_triage;
-function driver_args(invocation) {
-  const rebuilt = run_invocation.rebuild(invocation);
-  if (rebuilt !== invocation) return void 0;
-  const named_count = run_invocation.issue_numbers(rebuilt)?.length ?? 0;
-  return [
-    "backlog:drive",
-    "--owner",
-    String(process.pid),
-    "--window",
-    String(WINDOW_MINUTES),
-    ...rebuilt.split(" ").slice(1 + named_count)
-  ];
-}
-function is_final_stop(verdict, read) {
-  return verdict?.startsWith("stop") === true && read.kind === "none";
-}
-function details_tail(details) {
-  return details.length > DETAILS_TAIL_LENGTH ? `${TRUNCATION_MARK}${details.slice(-DETAILS_TAIL_LENGTH)}` : details;
-}
-var ALREADY_CLAIMED = "the carry record is already this session's, so run no pnpm josh run:carry --begin;";
-var HAND_BACK = "then end the turn, which hands the loop back";
-var NEXT_BY_VERDICT = [
-  [
-    "retrospective",
-    `run what pnpm josh run:step prints (the retrospective below), close it with pnpm josh run:carry --retrospective --summary "<result>", ${HAND_BACK}`
-  ],
-  [
-    "merge human-review",
-    "stop the run, because the child stopped before its commit for a person (the section below)"
-  ],
-  ["epic #", `follow the named-issue sections below, ${HAND_BACK}`]
-];
-var NEXT_DEFAULT = `act on the result by the sections below, ${HAND_BACK}`;
-var NEXT_BESIDE = "\nNext: the carry record stays the supervisor's, whose driver keeps collecting and filling lanes beside this session, so run no pnpm josh run:carry; act on the result by the sections below, then end the turn";
-function next_move(verdict) {
-  if (verdict === TRIAGE_VERDICT) return NEXT_BESIDE;
-  const found = NEXT_BY_VERDICT.find(([prefix]) => verdict.startsWith(prefix));
-  return `
-Next: ${ALREADY_CLAIMED} ${found?.[1] ?? NEXT_DEFAULT}`;
-}
-function handoff_material(verdict, resume, details) {
-  const context = details === "" ? "" : `
-Details: ${details_tail(details)}`;
-  const epic = verdict.startsWith("epic #") ? "\nThe named item is an epic. Follow backlogrun-steps.md named epic procedure; do not launch the epic root as a fullrun child. After all children merge or park, record the root with pnpm josh run:carry --done <epic-number> before continuing to the next named item." : "";
-  const sections = `
-${run_step_section_driver.driver_sections(verdict)}`;
-  return `Driver result: ${verdict}
-${resume}${epic}${next_move(verdict)}${sections}${context}`;
-}
-function judged(verdict, resume, details) {
-  if (!run_wake_resume.is_valid(resume)) {
-    return { kind: "failed", note: `backlog:drive returned an invalid resume line: ${resume}` };
-  }
-  const kind = verdict === TRIAGE_VERDICT ? "triage" : "judgment";
-  return { kind, material: handoff_material(verdict, resume, details) };
-}
-function driver_result(out, read, details = "") {
-  const lines = out.split("\n");
-  const verdict = lines[FIRST_LINE];
-  if (is_final_stop(verdict, read)) return { kind: "finished" };
-  const resume = run_wake_resume.resume_of(out);
-  if (verdict === void 0 || resume === void 0) {
-    return { kind: "failed", note: `backlog:drive returned an incomplete result: ${out}` };
-  }
-  return judged(verdict, resume, details);
-}
-function cause_of(out) {
-  const errors = out.split("\n").filter((line) => line.startsWith(ERROR_PREFIX));
-  return errors.length > 0 ? errors.join("\n") : details_tail(out);
-}
-function failure_note(result) {
-  return [cause_of(result.out), details_tail(result.err ?? "")].filter(Boolean).join("\n");
-}
-function read_result(result, target) {
-  if (result === void 0) return { kind: "released" };
-  if (result.code !== SUCCESS2) return { kind: "failed", note: failure_note(result) };
-  return driver_result(result.out, run_carry.read_carry(target), result.err);
-}
-function claim_record(target, invocation) {
-  const current = run_carry.read_carry(target);
-  if (current.kind !== "carried" || current.carry.invocation !== invocation) return false;
-  if (current.carry.is_handed_off !== true && run_carry.is_held_by_another(current.carry)) {
-    return false;
-  }
-  const owner = {
-    ...run_carry.owner_of(process.pid),
-    provider: current.carry.scheduler_provider
-  };
-  return run_carry.adopt_carry(target, current.carry, owner) !== void 0;
-}
-var RERUN_VERDICTS = ["merge busy", "merge retry"];
-var RERUN_LIMIT = 10;
-var RERUN_PAUSE_MS = 6e4;
-async function pause(ms) {
-  await new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-function is_verdict(result, entries) {
-  const verdict = result.out.split("\n", 1)[FIRST_LINE] ?? "";
-  return result.code === SUCCESS2 && entries.some((entry) => verdict === entry || verdict.startsWith(`${entry} `));
-}
-function rerun_args(pass, result, remaining) {
-  const is_left = remaining > 0;
-  if (!is_left || !is_verdict(result, RERUN_VERDICTS)) return void 0;
-  return run_wake_resume.resumed_args(pass.base, run_wake_resume.resume_of(result.out));
-}
-async function run_driver(pass, args, remaining) {
-  const result = await josh_command.josh_run(args, true);
-  run_wake_resume.remember(pass.target, pass.carry, result);
-  if (is_verdict(result, [WINDOW_VERDICT])) return void 0;
-  const next = rerun_args(pass, result, remaining);
-  if (next === void 0) return result;
-  await pass.wait(RERUN_PAUSE_MS);
-  if (run_carry.read_carry(pass.target).kind !== "carried") return void 0;
-  return await run_driver(pass, next, remaining - 1);
-}
-async function deferred_triage(result, wait, is_parent_planning) {
-  if (result === void 0 || !is_verdict(result, [TRIAGE_VERDICT]) || !is_parent_planning()) {
-    return result;
-  }
-  await wait(RERUN_PAUSE_MS);
-  return void 0;
-}
-async function announced(result) {
-  if (result.kind === "judgment") await run_event_setup.emit(run_event_setup.STAGE.JUDGING);
-  return result;
-}
-function never_planning() {
-  return false;
-}
-function refused(note) {
-  return { kind: "failed", note };
-}
-function prepare(target, wait) {
-  const read = run_carry.read_carry(target);
-  if (read.kind !== "carried") return refused("The carry record changed.");
-  const base = driver_args(read.carry.invocation);
-  if (base === void 0) return refused("The carried invocation is invalid.");
-  const kept = run_wake_resume.stored(target, read.carry);
-  const args = kept === void 0 ? base : run_wake_resume.resumed_args(base, kept);
-  if (args === void 0) return refused("The kept driver resume line is invalid.");
-  return { kind: "ready", pass: { target, carry: read.carry, base, wait }, args };
-}
-async function drive_with(target, wait, is_parent_planning) {
-  const prepared = prepare(target, wait);
-  if (prepared.kind === "failed") return prepared;
-  if (!claim_record(target, prepared.pass.carry.invocation)) {
-    return { kind: "failed", note: "The driver could not claim the carry record." };
-  }
-  await run_event_setup.emit(run_event_setup.STAGE.HANDING_OFF);
-  const result = await deferred_triage(
-    await run_driver(prepared.pass, prepared.args, RERUN_LIMIT),
-    wait,
-    is_parent_planning
-  );
-  return await announced(read_result(result, target));
-}
-async function drive(target, wait = pause, is_parent_planning = never_planning) {
-  return await drive_with(target, wait, is_parent_planning);
-}
-var run_wake_driver = { RERUN_LIMIT, drive, driver_args, driver_result };
-
-// scripts/run/wake/run-wake-ports.ts
-var UNSAFE_INVOCATION_NOTE = "the carried invocation is not one this supervisor can continue \u2014 it is neither a backlogrun nor a queue it can rebuild, or it carries text that may not be passed to a command line";
-function note_to_stderr(note) {
-  console.error(`wake: ${note}`);
-}
-function say_session_running(context) {
-  run_event_setup.emit_to(context.event_target, run_event_setup.STAGE.SESSION, /* @__PURE__ */ new Date());
-}
-function session_owner(context, profile, session_id) {
-  return run_wake_handoff.session_owner({
-    worktree: context.worktree,
-    session_id,
-    provider: profile.provider
-  });
-}
-function launch_session(context, invocation, profile, session) {
-  const built = run_wake_session.wake_argv(invocation, profile, context.worktree, session);
-  if (built === void 0) return { kind: "failed", note: UNSAFE_INVOCATION_NOTE };
-  if (built.kind === "rejected") return { kind: "failed", note: built.note };
-  const target = { cwd: context.worktree, env: session.environment, log_path: context.log_target };
-  return run_wake_session.launch({ argv: built.argv, ...target, profile }, note_to_stderr);
-}
-function wake_beside(context, invocation, profile, session) {
-  const result = launch_session(context, invocation, profile, session);
-  const read = run_carry.read_carry(context.carry_target);
-  if (result.kind === "launched" && read.kind === "carried") {
-    run_wake_resume.name_beside(context.carry_target, read.carry, result.pid);
-  }
-  return result;
-}
-function wake_session(context, invocation, profile, session) {
-  const result = launch_session(context, invocation, profile, session);
-  if (result.kind === "launched") {
-    run_wake_handoff.hand_on(
-      context.carry_target,
-      session_owner(context, profile, session.id),
-      result.pid
-    );
-    say_session_running(context);
-  }
-  return result;
-}
-async function retry_closes2() {
-  await lane_close.retry_closes();
-  const notes = await lane_withdraw_closed.withdraw_closed();
-  for (const note of notes) note_to_stderr(note);
-}
-function is_session_at_work(carry) {
-  return run_carry.is_held_by_another(carry) && run_wake_handoff.has_session_begun(carry);
-}
-function session_ports(context, profile) {
-  return {
-    new_session_id: () => randomUUID(),
-    hand_off: (session_id) => {
-      run_wake_handoff.hand_to(context.carry_target, session_owner(context, profile, session_id));
-    },
-    wake: (invocation, session_id, material) => wake_session(context, invocation, profile, {
-      id: session_id,
-      material,
-      environment: run_headless.environment()
-    }),
-    wake_beside: (invocation, session_id, material) => wake_beside(context, invocation, profile, {
-      id: session_id,
-      material,
-      environment: run_headless.beside_environment()
-    })
-  };
-}
-function ports_for(context, profile, is_code_stale = async () => false) {
-  function is_planning() {
-    return backlogrun_launch.running_parent(context.git_directory) !== void 0;
-  }
-  return {
-    is_code_stale,
-    read_carry: () => run_carry.read_carry(context.carry_target),
-    is_owner_live: (read) => read.kind === "carried" && is_session_at_work(read.carry),
-    has_work: async () => true,
-    ...session_ports(context, profile),
-    drive: async () => await run_wake_driver.drive(context.carry_target, poll.sleep, is_planning),
-    sleep: poll.sleep,
-    now: () => /* @__PURE__ */ new Date(),
-    retry_closes: retry_closes2
-  };
-}
-var run_wake_ports = { note_to_stderr, ports_for };
-
-// scripts/lane/claude-lane-broker.ts
-var SCAN_INTERVAL_MS = 5e3;
-function is_served(lane) {
-  return !lane.is_stranded && !lane_relaunch.is_openai_lane(lane);
-}
-async function hold_server(lane, held) {
-  try {
-    await lane_session_broker.with_server(lane, async () => {
-      await held;
-    });
-  } catch (error) {
-    error_text.trace_swallowed("claude_lane_broker.hold_server", error);
-  }
-}
-function serve_lane(lane) {
-  const release = { stop: () => void 0 };
-  const held = new Promise((resolve) => {
-    release.stop = resolve;
-  });
-  return { stop: release.stop, done: hold_server(lane, held) };
-}
-async function forget_when_done(served, issue, entry) {
-  await entry.done;
-  if (served.get(issue) === entry) served.delete(issue);
-}
-function close_gone(served, open) {
-  for (const [issue, entry] of served) {
-    if (open.has(issue)) {
-      continue;
-    }
-    entry.stop();
-    void forget_when_done(served, issue, entry);
-  }
-}
-function open_new(served, lanes) {
-  for (const lane of lanes) {
-    if (!served.has(lane.issue)) served.set(lane.issue, serve_lane(lane));
-  }
-}
-async function scan(served, list2) {
-  try {
-    const listed = await list2();
-    const lanes = listed.filter((lane) => is_served(lane));
-    close_gone(served, new Set(lanes.map((lane) => lane.issue)));
-    open_new(served, lanes);
-  } catch (error) {
-    error_text.trace_swallowed("claude_lane_broker.scan", error);
-  }
-}
-async function scan_after(previous, served, list2) {
-  await previous;
-  await scan(served, list2);
-}
-function start(list2 = lane_registry.list_lanes) {
-  const served = /* @__PURE__ */ new Map();
-  const state = { scanning: scan(served, list2) };
-  const timer = setInterval(() => {
-    state.scanning = scan_after(state.scanning, served, list2);
-  }, SCAN_INTERVAL_MS).unref();
-  return async () => {
-    clearInterval(timer);
-    await state.scanning;
-    close_gone(served, /* @__PURE__ */ new Set());
-    await Promise.all(
-      [...served.values()].map(async (entry) => {
-        await entry.done;
-      })
-    );
-  };
-}
-async function serve_during(run2, list2 = lane_registry.list_lanes) {
-  const stop = start(list2);
-  try {
-    return await run2();
-  } finally {
-    await stop();
-  }
-}
-var claude_lane_broker = { SCAN_INTERVAL_MS, serve_during, start };
-
-// scripts/run/wake/run-wake-restart.ts
-var RESTART_LIMIT = 3;
-function is_restartable(stop, restarts, ports) {
-  return stop.reason === run_wake_loop.FAILED_REASON && restarts < RESTART_LIMIT && ports.is_resumable();
-}
-function restart_note(stop, restarts) {
-  return `the supervisor failed (${stop.note ?? "no note"}); restarting it, ${String(restarts + 1)} of ${String(RESTART_LIMIT)}`;
-}
-function with_restart_count(stop, restarts) {
-  if (restarts === 0 || stop.reason !== run_wake_loop.FAILED_REASON) return stop;
-  return {
-    ...stop,
-    note: [stop.note, `after ${String(restarts)} automatic restarts`].filter(Boolean).join("\n")
-  };
-}
-async function supervise(ports, restarts = 0) {
-  const stop = await ports.pass();
-  if (!is_restartable(stop, restarts, ports)) return with_restart_count(stop, restarts);
-  ports.note(restart_note(stop, restarts));
-  await ports.pause();
-  return await supervise(ports, restarts + 1);
-}
-var run_wake_restart = { RESTART_LIMIT, supervise };
-
-// scripts/run/wake/run-wake-supervise.ts
-function restart_ports(target) {
-  const { context, ports, interval_ms } = target;
-  return {
-    pass: async () => await run_wake_loop.run_loop(context.wake_target, ports, interval_ms),
-    is_resumable: () => run_carry.read_carry(context.carry_target).kind === "carried",
-    pause: async () => {
-      await poll.sleep(interval_ms);
-    },
-    note: target.note
-  };
-}
-async function supervise2(target) {
-  return await claude_lane_broker.serve_during(
-    async () => await run_wake_restart.supervise(restart_ports(target))
-  );
-}
-var run_wake_supervise = { supervise: supervise2 };
-
-// scripts/run/wake/run-wake-cli.ts
-var __josh_meta = import.meta;
-var __josh_source_url = new URL("../../scripts/run/wake/run-wake-cli.ts", __josh_meta.url).href;
-var __josh_source_filename = __josh_file_path(__josh_source_url);
-var __josh_source_dirname = __josh_dirname(__josh_source_filename);
-var SUCCESS_EXIT_CODE2 = 0;
-var FAILURE_EXIT_CODE2 = 1;
-var ONE_GROUP = 1;
-var MAX_INTERVAL_SECONDS = 3600;
-var SCRIPT_PATH = fileURLToPath(new URL("run-wake-main.ts", __josh_source_url));
-var STARTED_VERDICT = "started";
-var RUNNING_VERDICT = "running";
-var STOPPED_VERDICT = "stopped";
-var SUPERVISING_VERDICT = "supervising";
-var STALE_VERDICT = "stale";
-var NONE_VERDICT = "none";
-var UNKNOWN_VERDICT = "unknown";
-var FAILED_VERDICT = "failed";
-var NO_PROFILE_NOTE = "the scheduler profile could not be resolved";
-var RELOAD_FAILED_NOTE = "The supervisor's code changed, but the supervisor to replace it did not start";
-var TAKEOVER_NOTES = {
-  died: "it exited before it claimed the run",
-  unclaimed: "it did not claim the run in time, so it was stopped"
-};
-var SUPERSEDED_RESULT = "superseded";
-var REMOVED_RESULT = "removed";
-var STOPPED_STOP = { reason: "stopped", note: void 0 };
-var SUPERSEDED_NOTE = "another supervisor now holds the record, so it was left alone; this loop is the superseded one";
-var USAGE = "Usage: josh run:wake --start | --list | --stop | --loop [--interval <seconds>]";
-var OPTIONS = {
-  interval: { type: "string" },
-  list: { type: "boolean" },
-  loop: { type: "boolean" },
-  start: { type: "boolean" },
-  stop: { type: "boolean" }
-};
-function report(verdict, exit_code = SUCCESS_EXIT_CODE2) {
-  console.info(verdict);
-  return exit_code;
-}
-function usage() {
-  console.error(USAGE);
-  return FAILURE_EXIT_CODE2;
-}
-var { note_to_stderr: note_to_stderr2 } = run_wake_ports;
-function to_interval_ms(value) {
-  if (typeof value !== "string") return run_wake_window.PASS_INTERVAL_MS;
-  const seconds = cli_flags.to_positive(value);
-  return seconds === void 0 || seconds > MAX_INTERVAL_SECONDS ? void 0 : seconds * MS_PER_SECOND;
-}
-function group_count(values) {
-  const verbs = [values.start, values.stop, values.list, values.loop];
-  return verbs.filter((flag) => flag === true).length;
-}
-function context_of2(directory) {
-  return run_wake_describe.context_of(directory, note_to_stderr2);
-}
-async function resolve_context() {
-  const directory = await run_carry.repository_directory();
-  return directory === void 0 ? void 0 : context_of2(directory);
-}
-function refuse_without_carry(kind) {
-  console.error(`No carried run here to supervise \u2014 \`pnpm josh run:carry --json\` says ${kind}.`);
-  return report(NONE_VERDICT, FAILURE_EXIT_CODE2);
-}
-function launch_supervisor(context, interval, profile) {
-  if (profile === void 0) return { kind: "failed", note: NO_PROFILE_NOTE };
-  const argv2 = run_wake_session.supervisor_argv(SCRIPT_PATH, interval);
-  return run_wake_session.launch(
-    {
-      argv: argv2,
-      cwd: context.worktree,
-      log_path: context.log_target,
-      env: run_wake_session.supervisor_environment(profile)
-    },
-    note_to_stderr2
-  );
-}
-function start_for_launch(git_directory, provider) {
-  const resolved = run_wake_session.chosen_profile(provider);
-  if (resolved.kind === "rejected") return { kind: "failed", note: resolved.note };
-  return launch_supervisor(context_of2(git_directory), void 0, resolved.profile);
-}
-function spawn_supervisor(context, interval, profile) {
-  const result = launch_supervisor(context, interval, profile);
-  if (result.kind === "failed") {
-    console.error(`Could not start the supervisor: ${result.note}`);
-    return report(FAILED_VERDICT, FAILURE_EXIT_CODE2);
-  }
-  console.error(
-    `Supervisor started as process ${String(result.pid)}. Stop it with \`${run_wake_describe.STOP_COMMAND}\`.`
-  );
-  return report(STARTED_VERDICT);
-}
-function start2(context, interval) {
-  const read = run_carry.read_carry(context.carry_target);
-  if (read.kind !== "carried") return refuse_without_carry(read.kind);
-  const existing = run_wake.read_wake(context.wake_target);
-  if (existing !== void 0 && run_wake.is_supervisor_live(existing)) {
-    console.error(run_wake_describe.describe_wake_cited(existing, context));
-    return report(RUNNING_VERDICT);
-  }
-  return spawn_supervisor(context, interval, run_wake_session.scheduler_profile());
-}
-function restart_supervisor(git_directory, profile) {
-  const chosen = profile ?? run_wake_session.scheduler_profile();
-  return spawn_supervisor(context_of2(git_directory), void 0, chosen);
-}
-function tidy_up(target) {
-  const tidied = run_wake.tidy_own_wake(target);
-  if (tidied === SUPERSEDED_RESULT) note_to_stderr2(SUPERSEDED_NOTE);
-  return tidied;
-}
-function code_check(is_stale) {
-  return async () => !lane_session_broker.is_answering() && await is_stale();
-}
-function reload_failed(note) {
-  return { reason: run_wake_loop.FAILED_REASON, note: `${RELOAD_FAILED_NOTE}: ${note}` };
-}
-function as_not_handed_on(stop) {
-  return stop.reason === run_wake_loop.RELOAD_REASON ? STOPPED_STOP : stop;
-}
-async function reload(context, interval_ms, profile) {
-  const interval = String(Math.round(interval_ms / MS_PER_SECOND));
-  const result = launch_supervisor(context, interval, profile);
-  if (result.kind === "failed") return reload_failed(result.note);
-  const ports = run_wake_takeover.ports_of(context.wake_target);
-  const takeover = await run_wake_takeover.await_takeover(result.pid, ports);
-  if (takeover !== "taken") return reload_failed(TAKEOVER_NOTES[takeover]);
-  await run_event_stream_emit.emit(
-    run_event_stream.EVENT_KIND.NOTE,
-    `The supervisor's code changed on main, so process ${String(process.pid)} handed the run to process ${String(result.pid)} on the new code.`
-  );
-  return { reason: run_wake_loop.RELOAD_REASON, note: void 0 };
-}
-async function supervised(context, interval_ms, profile) {
-  const source = run_wake_code.source_of(context.worktree, SCRIPT_PATH);
-  const is_stale = code_check(await run_wake_code.watch(source, lane_session_broker.take_refusal));
-  const ports = run_wake_ports.ports_for(context, profile, is_stale);
-  const stop = await run_wake_supervise.supervise({
-    context,
-    ports,
-    interval_ms,
-    note: note_to_stderr2
-  });
-  if (tidy_up(context.wake_target) !== REMOVED_RESULT) return as_not_handed_on(stop);
-  if (stop.reason !== run_wake_loop.RELOAD_REASON) return stop;
-  return await reload(context, interval_ms, profile);
-}
-async function loop(context, interval_ms) {
-  const profile = run_wake_session.scheduler_profile();
-  if (profile === void 0) return report(FAILED_VERDICT, FAILURE_EXIT_CODE2);
-  const claimed = await run_wake_await.claim_run(context, profile, interval_ms);
-  if (claimed.kind === "running") return report(RUNNING_VERDICT);
-  if (claimed.kind === "refused") return refuse_without_carry(claimed.carry_kind);
-  run_wake_session.keep_awake(process.pid);
-  const stop = await supervised(context, interval_ms, claimed.wake.profile ?? profile);
-  return await run_wake_finish.finish(stop, context, claimed.carry.started_at);
-}
-function list(context) {
-  const wake = run_wake.read_wake(context.wake_target);
-  if (wake === void 0) return report(NONE_VERDICT);
-  console.error(run_wake_describe.describe_wake_cited(wake, context));
-  return report(run_wake.is_supervisor_live(wake) ? SUPERVISING_VERDICT : STALE_VERDICT);
-}
-function stop_supervisor(context) {
-  const stopped2 = run_wake_stop.stop(context.wake_target);
-  return report(stopped2 === void 0 ? NONE_VERDICT : STOPPED_VERDICT);
-}
-async function dispatch(values, context, interval_ms) {
-  if (values.loop === true) return await loop(context, interval_ms);
-  if (values.start === true) return start2(context, cli_flags.string_of(values.interval));
-  if (values.stop === true) return stop_supervisor(context);
-  return list(context);
-}
-async function run(argv2) {
-  const values = cli_flags.values_of(argv2, OPTIONS);
-  if (values === void 0 || group_count(values) !== ONE_GROUP) return usage();
-  const interval_ms = to_interval_ms(values.interval);
-  if (interval_ms === void 0) return usage();
-  const context = await resolve_context();
-  if (context === void 0) return report(UNKNOWN_VERDICT, FAILURE_EXIT_CODE2);
-  return await dispatch(values, context, interval_ms);
-}
-var run_wake_cli = {
-  FAILED_VERDICT,
-  NONE_VERDICT,
-  RUNNING_VERDICT,
-  SCRIPT_PATH,
-  STALE_VERDICT,
-  STOPPED_VERDICT,
-  SUPERVISING_VERDICT,
-  UNKNOWN_VERDICT,
-  USAGE,
-  RELOAD_FAILED_NOTE,
-  reload,
-  restart_supervisor,
-  run,
-  start_for_launch,
-  supervised
-};
-
-export {
-  run_wake_cli
-};