@joshuafolkken/kit 1.2114.0 → 1.3000.0

package/dist/commands/chunk-72J2G2E7.js

@@ -0,0 +1,1189 @@
+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-ST32OGPY.js";
+import {
+  lane_close
+} from "./chunk-Q7TV3OV6.js";
+import {
+  backlog_drive_args
+} from "./chunk-JHN6RCE6.js";
+import {
+  lane_session_broker
+} from "./chunk-MYNM3YMR.js";
+import {
+  ts_entry_loader
+} from "./chunk-VHRNXWVP.js";
+import {
+  lane_relaunch
+} from "./chunk-3GF52L5F.js";
+import {
+  document_section_cli
+} from "./chunk-CADFBQJJ.js";
+import {
+  run_stranded_detect
+} from "./chunk-VJLZ3IQQ.js";
+import {
+  run_wake
+} from "./chunk-6Q3XUCLM.js";
+import {
+  run_carry_ended
+} from "./chunk-ZVAIIHBE.js";
+import {
+  epic_triage
+} from "./chunk-AM44D7NF.js";
+import {
+  josh_command
+} from "./chunk-2VRITY55.js";
+import {
+  telegram_notify
+} from "./chunk-WJ4NEDNI.js";
+import {
+  run_step_section_table
+} from "./chunk-ZDSDPKCD.js";
+import {
+  gh_spawn
+} from "./chunk-3PEXBHRN.js";
+import {
+  backlogrun_launch
+} from "./chunk-TVJE67O2.js";
+import {
+  agent_argv
+} from "./chunk-NJT5L6IC.js";
+import {
+  claude_agent_argv
+} from "./chunk-OHVAEJSM.js";
+import {
+  run_event_setup
+} from "./chunk-BNXE3NVB.js";
+import {
+  agent_role_profile
+} from "./chunk-RIQ75QWR.js";
+import {
+  run_headless
+} from "./chunk-6WTVAL4D.js";
+import {
+  lane_registry
+} from "./chunk-LRS2OS5J.js";
+import {
+  run_liveness
+} from "./chunk-7S6VRZOH.js";
+import {
+  detached_launch
+} from "./chunk-C2SEDMZ3.js";
+import {
+  run_event_stream_emit
+} from "./chunk-34LAULSC.js";
+import {
+  run_event_stream
+} from "./chunk-NSAVEXVR.js";
+import {
+  agent_safe_text
+} from "./chunk-3LZXX5GL.js";
+import {
+  issue_citation
+} from "./chunk-X7PN54LZ.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
+};