@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-GY4DMCKS.js

@@ -1,306 +0,0 @@
-import {
-  process_directories
-} from "./chunk-MXC4IBZ7.js";
-import {
-  transcript_tail
-} from "./chunk-EMTZAGT5.js";
-import {
-  figure_format
-} from "./chunk-ZZXO6TFH.js";
-import {
-  durable_state
-} from "./chunk-MPGJ4ONJ.js";
-import {
-  time_instant
-} from "./chunk-6WKJ3GDA.js";
-import {
-  lane_paths
-} from "./chunk-YIA6FC3K.js";
-import {
-  agent_provider
-} from "./chunk-JQXPLMCO.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/run/board/run-board-quota-read.ts
-import { open, readdir, readFile, stat } from "node:fs/promises";
-import path2 from "node:path";
-
-// scripts/agent/codex-home-source.ts
-import os from "node:os";
-import path from "node:path";
-function default_home() {
-  return path.join(os.homedir(), ".codex");
-}
-var codex_home_source = { default_home };
-
-// scripts/run/board/run-board-quota-read.ts
-import { z as z2 } from "zod";
-
-// scripts/run/board/run-board-quota-lane.ts
-import { z } from "zod";
-var CODEX_META = z.looseObject({
-  type: z.literal("session_meta"),
-  payload: z.looseObject({ cwd: z.string() })
-});
-function codex_lane(head, root = process.env[lane_paths.LANE_ROOT_KEY] ?? "") {
-  const meta = head.split("\n").map((line) => json_value.parse_with(line, CODEX_META));
-  const cwd = meta.find((event) => event !== void 0)?.payload.cwd;
-  return cwd === void 0 ? void 0 : process_directories.lane_of(cwd, root);
-}
-var run_board_quota_lane = { codex_lane };
-
-// scripts/run/board/run-board-quota-read.ts
-var MS_PER_SECOND = 1e3;
-var MINUTES_PER_HOUR = 60;
-var HOURS_PER_DAY = 24;
-var MINUTES_PER_DAY = MINUTES_PER_HOUR * HOURS_PER_DAY;
-var SHORT_WINDOW_HOURS = 5;
-var FIVE_HOURS_MINUTES = SHORT_WINDOW_HOURS * MINUTES_PER_HOUR;
-var DAYS_PER_WEEK = 7;
-var SEVEN_DAYS_MINUTES = DAYS_PER_WEEK * MINUTES_PER_DAY;
-var PERCENT = 100;
-var TAIL_BYTES = 262144;
-var TAIL_GROWTH = 8;
-var TAIL_LIMIT_BYTES = TAIL_BYTES * TAIL_GROWTH * TAIL_GROWTH;
-var SAMPLE_SIZE = 10;
-var SCAN_FACTOR = 3;
-var FILES_SCANNED = SAMPLE_SIZE * SCAN_FACTOR;
-var FILES_LIMIT = FILES_SCANNED * SCAN_FACTOR * SCAN_FACTOR;
-var MS_PER_DAY = MINUTES_PER_DAY * MINUTES_PER_HOUR * MS_PER_SECOND;
-var CLAUDE_MARK = '"rate_limit_event"';
-var CODEX_MARK = '"rate_limits":{';
-var CODEX_PREFIX = "rollout-";
-var CODEX_SUFFIX = ".jsonl";
-var LOG_SUFFIX = ".log";
-var TIMESTAMP_MARK = '"timestamp"';
-var LAUNCH_HEADER = /^=== (?<stamp>\S+) · started by process /u;
-var LAUNCH_HEADERS = /^=== \S+ · started by process .*$/gmu;
-var HEADER_PROVIDER = / · provider=(?<provider>\S+)/u;
-var { two_digits } = figure_format;
-var CLAUDE_WINDOW = z2.looseObject({ utilization: z2.number(), resetsAt: z2.number() });
-var CLAUDE_WINDOWS = z2.looseObject({
-  five_hour: CLAUDE_WINDOW.optional(),
-  seven_day: CLAUDE_WINDOW.optional()
-});
-var CLAUDE_INFO = z2.looseObject({ unifiedWindows: CLAUDE_WINDOWS });
-var CLAUDE_EVENT = z2.looseObject({
-  type: z2.literal("rate_limit_event"),
-  rate_limit_info: CLAUDE_INFO,
-  timestamp: z2.string().nullish().catch(void 0)
-});
-var CODEX_WINDOW = z2.looseObject({
-  used_percent: z2.number(),
-  window_minutes: z2.number(),
-  resets_at: z2.number()
-});
-var CODEX_LIMITS = z2.looseObject({
-  primary: CODEX_WINDOW.nullish(),
-  secondary: CODEX_WINDOW.nullish()
-});
-var CODEX_EVENT = z2.looseObject({
-  payload: z2.looseObject({ rate_limits: CODEX_LIMITS }),
-  timestamp: z2.string().nullish().catch(void 0)
-});
-var TIMED_LINE = z2.looseObject({ timestamp: z2.string() });
-function claude_window(minutes, window) {
-  if (window === void 0) return [];
-  const resets_ms = window.resetsAt * MS_PER_SECOND;
-  return [{ minutes, used_percent: Math.round(window.utilization * PERCENT), resets_ms }];
-}
-function claude_line(line) {
-  if (!line.includes(CLAUDE_MARK)) return void 0;
-  const event = json_value.parse_with(line, CLAUDE_EVENT);
-  if (event === void 0) return void 0;
-  const { five_hour, seven_day } = event.rate_limit_info.unifiedWindows;
-  return {
-    windows: [
-      ...claude_window(FIVE_HOURS_MINUTES, five_hour),
-      ...claude_window(SEVEN_DAYS_MINUTES, seven_day)
-    ],
-    taken_ms: time_instant.parse_instant(event.timestamp)
-  };
-}
-function codex_window(window) {
-  if (window === void 0 || window === null) return [];
-  const { used_percent, window_minutes, resets_at } = window;
-  return [{ minutes: window_minutes, used_percent, resets_ms: resets_at * MS_PER_SECOND }];
-}
-function codex_line(line) {
-  if (!line.includes(CODEX_MARK)) return void 0;
-  const event = json_value.parse_with(line, CODEX_EVENT);
-  if (event === void 0) return void 0;
-  const { primary, secondary } = event.payload.rate_limits;
-  return {
-    windows: [...codex_window(primary), ...codex_window(secondary)],
-    taken_ms: time_instant.parse_instant(event.timestamp)
-  };
-}
-function codex_heads(text) {
-  return text.split("\n").map((line) => codex_line(line)).filter((reading) => reading !== void 0);
-}
-function json_stamp(line) {
-  if (!line.includes(TIMESTAMP_MARK)) return void 0;
-  return json_value.parse_with(line, TIMED_LINE)?.timestamp;
-}
-function line_stamp(line) {
-  const stamp = LAUNCH_HEADER.exec(line)?.groups?.["stamp"];
-  return stamp ?? json_stamp(line);
-}
-function line_ms(line) {
-  return time_instant.parse_instant(line_stamp(line));
-}
-function time_before(lines, index) {
-  const timed = lines.slice(0, index).findLast((line) => line_ms(line) !== void 0);
-  return timed === void 0 ? void 0 : line_ms(timed);
-}
-function claude_at(lines, index) {
-  const reading = claude_line(lines[index] ?? "");
-  if (reading === void 0 || reading.taken_ms !== void 0) return reading;
-  return { ...reading, taken_ms: time_before(lines, index) };
-}
-function claude_reading(text) {
-  const lines = text.split("\n");
-  return claude_at(
-    lines,
-    lines.findLastIndex((line) => claude_line(line) !== void 0)
-  );
-}
-function codex_reading(text) {
-  return codex_heads(text).at(-1);
-}
-function claude_heads(text) {
-  const lines = text.split("\n");
-  return lines.flatMap((_line, index) => claude_at(lines, index) ?? []);
-}
-async function names_in(directory) {
-  try {
-    return await readdir(directory);
-  } catch {
-    return [];
-  }
-}
-async function file_of(file) {
-  try {
-    const { mtimeMs: mtime_ms } = await stat(file);
-    return [{ path: file, mtime_ms }];
-  } catch {
-    return [];
-  }
-}
-async function files_in(directory, is_wanted) {
-  const names = await names_in(directory);
-  const wanted = names.filter((name) => is_wanted(name));
-  const files = await Promise.all(
-    wanted.map(async (name) => await file_of(path2.join(directory, name)))
-  );
-  return files.flat();
-}
-function sorted(files) {
-  return files.toSorted((left, right) => right.mtime_ms - left.mtime_ms);
-}
-function newest(files, limit) {
-  return sorted(files).slice(0, limit);
-}
-function is_lane_log(name) {
-  const prefixes = [durable_state.PREFIX.LANE_DISPATCH, durable_state.PREFIX.HANDOFF_LOG];
-  return prefixes.some((prefix) => name.startsWith(prefix)) && name.endsWith(LOG_SUFFIX);
-}
-function last_provider(text) {
-  const header = text.match(LAUNCH_HEADERS)?.at(-1) ?? "";
-  return HEADER_PROVIDER.exec(header)?.groups?.["provider"];
-}
-function is_claude_launch(text) {
-  const provider = last_provider(text);
-  return provider === void 0 || provider === agent_provider.ANTHROPIC_PROVIDER;
-}
-var CLAUDE_LAUNCHES = /* @__PURE__ */ new Map();
-async function read_claude_launch(file) {
-  const known = CLAUDE_LAUNCHES.get(file.path);
-  if (known?.mtime_ms === file.mtime_ms) return known.is_claude;
-  const is_claude = is_claude_launch(await readFile(file.path, "utf8"));
-  CLAUDE_LAUNCHES.set(file.path, { mtime_ms: file.mtime_ms, is_claude });
-  return is_claude;
-}
-async function claude_log(file) {
-  try {
-    return await read_claude_launch(file) ? [file] : [];
-  } catch {
-    return [];
-  }
-}
-async function claude_files(root = durable_state.root(), limit = FILES_SCANNED) {
-  const scanned = newest(await files_in(root, is_lane_log), FILES_LIMIT);
-  const claude = [];
-  for (const file of scanned) {
-    if (claude.length >= limit) break;
-    claude.push(...await claude_log(file));
-  }
-  return claude;
-}
-function is_rollout(name) {
-  return name.startsWith(CODEX_PREFIX) && name.endsWith(CODEX_SUFFIX);
-}
-function day_directory(sessions, ms) {
-  const date = new Date(ms);
-  const month = two_digits(date.getMonth() + 1);
-  return path2.join(sessions, String(date.getFullYear()), month, two_digits(date.getDate()));
-}
-function codex_home() {
-  return process.env["CODEX_HOME"] ?? codex_home_source.default_home();
-}
-async function codex_files(now_ms, home = codex_home(), limit = FILES_SCANNED) {
-  const sessions = path2.join(home, "sessions");
-  const back = Array.from({ length: DAYS_PER_WEEK }, (_, day) => now_ms - day * MS_PER_DAY);
-  const days = back.map((ms) => day_directory(sessions, ms));
-  const found = await Promise.all(days.map(async (day) => await files_in(day, is_rollout)));
-  return newest(found.flat(), limit);
-}
-async function read_tail(file, bytes = TAIL_BYTES) {
-  return transcript_tail.read_tail(file, bytes);
-}
-async function read_head(file, bytes = TAIL_BYTES) {
-  const handle = await open(file, "r");
-  try {
-    const buffer = Buffer.alloc(bytes);
-    const { bytesRead: read } = await handle.read(buffer, 0, bytes, 0);
-    return buffer.subarray(0, read).toString("utf8");
-  } finally {
-    await handle.close();
-  }
-}
-function is_last_tail(reading, text, bytes) {
-  return (reading?.windows.length ?? 0) > 0 || Buffer.byteLength(text) < bytes || bytes >= TAIL_LIMIT_BYTES;
-}
-async function reading_in(tail_of, reading_of, bytes = TAIL_BYTES) {
-  const text = await tail_of(bytes);
-  const reading = reading_of(text);
-  if (is_last_tail(reading, text, bytes)) return reading;
-  return await reading_in(tail_of, reading_of, bytes * TAIL_GROWTH);
-}
-var run_board_quota_read = {
-  FILES_LIMIT,
-  FILES_SCANNED,
-  FIVE_HOURS_MINUTES,
-  SAMPLE_SIZE,
-  SCAN_FACTOR,
-  SEVEN_DAYS_MINUTES,
-  TAIL_BYTES,
-  TAIL_LIMIT_BYTES,
-  claude_files,
-  claude_heads,
-  claude_reading,
-  codex_files,
-  codex_heads,
-  codex_lane: run_board_quota_lane.codex_lane,
-  codex_reading,
-  read_head,
-  line_stamp,
-  read_tail,
-  reading_in
-};
-
-export {
-  run_board_quota_read
-};

package/dist/commands/chunk-H6JQRHDC.js

@@ -1,80 +0,0 @@
-import {
-  agent_role_profile
-} from "./chunk-6UCWAFQY.js";
-import {
-  run_liveness
-} from "./chunk-3AEDZZNL.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-
-// scripts/lane/lane-report.ts
-var NO_LANES = "No lanes are open.";
-var OPEN_STATE = "open";
-var STRANDED_STATE = "stranded";
-var UNREADABLE_STATE = "unreadable";
-var UNKNOWN_VALUE = "-";
-var COLUMN_SEPARATOR = "  ";
-function lane_state(lane) {
-  if (lane.is_stranded) return STRANDED_STATE;
-  if (lane.seat_problem !== void 0) return lane.seat_problem;
-  if (lane.seat_held === false) return "seat released";
-  return lane.seat === void 0 ? UNREADABLE_STATE : OPEN_STATE;
-}
-function value_or_unknown(value) {
-  return value === void 0 ? UNKNOWN_VALUE : String(value);
-}
-function output_column(output) {
-  return `output ${output ?? UNKNOWN_VALUE}`;
-}
-function profile_column(lane) {
-  return `profile ${lane.profile === void 0 ? UNKNOWN_VALUE : agent_role_profile.describe(lane.profile)}`;
-}
-function event_column(lane) {
-  if (lane.output === void 0) return "agent -";
-  const state = run_liveness.describe_agent_state(lane.output);
-  return state ?? "agent -";
-}
-var PLAIN_CITE = issue_cite.citer(void 0, /* @__PURE__ */ new Map());
-function describe_lane(lane, cite = PLAIN_CITE) {
-  return [
-    cite(lane.issue),
-    `seat ${value_or_unknown(lane.seat)}`,
-    `dev ${value_or_unknown(lane.development_port)}`,
-    `preview ${value_or_unknown(lane.preview_port)}`,
-    lane.branch,
-    lane_state(lane),
-    lane.directory,
-    output_column(lane.output),
-    profile_column(lane),
-    event_column(lane)
-  ].join(COLUMN_SEPARATOR);
-}
-function describe_lanes(lanes, cite = PLAIN_CITE) {
-  if (lanes.length === 0) return NO_LANES;
-  return lanes.map((lane) => describe_lane(lane, cite)).join("\n");
-}
-function describe_ports(lane) {
-  if (lane.seat === void 0) return "no lane seat could be read";
-  return `seat ${String(lane.seat)}, dev ${value_or_unknown(lane.development_port)}, preview ${value_or_unknown(lane.preview_port)}`;
-}
-function describe_opened(lane) {
-  return `Opened a lane for ${session_cite.issue(lane.issue)} on ${lane.branch}: ${describe_ports(lane)}.`;
-}
-var lane_report = {
-  NO_LANES,
-  OPEN_STATE,
-  STRANDED_STATE,
-  UNREADABLE_STATE,
-  describe_lane,
-  describe_lanes,
-  describe_opened,
-  lane_state
-};
-
-export {
-  lane_report
-};

package/dist/commands/chunk-HATKF6VX.js

@@ -1,173 +0,0 @@
-import {
-  run_ship_probe
-} from "./chunk-NILSN7A4.js";
-import {
-  run_ship_detach
-} from "./chunk-G4E4M2P4.js";
-import {
-  run_ship_stage
-} from "./chunk-OHNP3QL2.js";
-import {
-  issue_number_shape
-} from "./chunk-66NX6EXR.js";
-import {
-  poll
-} from "./chunk-SBGTCT2C.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/run/ship/run-ship-wait-cli.ts
-import { setTimeout as sleep2 } from "node:timers/promises";
-
-// scripts/run/ship/run-ship-waiter.ts
-import { setTimeout as sleep } from "node:timers/promises";
-import { z } from "zod";
-var HEARTBEAT_PREFIX = "josh-ship-waiter-";
-var HANDOFF_PREFIX = "josh-ship-handoff-";
-var DECISION_PREFIX = "josh-ship-handoff-taken-";
-var KEY_SEPARATOR = "-";
-var TAKEN = "taken";
-var WITHDRAWN = "withdrawn";
-var SESSION_GAP_MS = 12e4;
-var OFFER_POLL_MS = 1e3;
-var heartbeat_schema = z.object({ at: z.number() });
-var offer_schema = z.object({ at: z.number(), note: z.string() });
-function path_of(prefix, repository, issue) {
-  return stamp_file.stamp_path(`${prefix}${issue}${KEY_SEPARATOR}`, repository);
-}
-function beat(repository, issue, at = Date.now()) {
-  stamp_file.replace_stamp(path_of(HEARTBEAT_PREFIX, repository, issue), { at });
-}
-function leave(repository, issue) {
-  stamp_file.remove_stamp(path_of(HEARTBEAT_PREFIX, repository, issue));
-}
-function is_waited(repository, issue, now = Date.now()) {
-  const raw = stamp_file.read_stamp_text(path_of(HEARTBEAT_PREFIX, repository, issue));
-  const heartbeat = raw === void 0 ? void 0 : json_value.parse_with(raw, heartbeat_schema);
-  return heartbeat !== void 0 && now - heartbeat.at < SESSION_GAP_MS;
-}
-function decide(repository, issue, decision) {
-  return stamp_file.create_stamp(path_of(DECISION_PREFIX, repository, issue), decision);
-}
-function clear_offer(repository, issue) {
-  stamp_file.remove_stamp(path_of(HANDOFF_PREFIX, repository, issue));
-  stamp_file.remove_stamp(path_of(DECISION_PREFIX, repository, issue));
-}
-function offered_note(repository, issue, now) {
-  const raw = stamp_file.read_stamp_text(path_of(HANDOFF_PREFIX, repository, issue));
-  const offered = raw === void 0 ? void 0 : json_value.parse_with(raw, offer_schema);
-  return offered !== void 0 && now - offered.at < SESSION_GAP_MS ? offered.note : void 0;
-}
-function take(repository, issue, now = Date.now()) {
-  const note = offered_note(repository, issue, now);
-  if (note === void 0 || !decide(repository, issue, TAKEN)) return void 0;
-  stamp_file.remove_stamp(path_of(HANDOFF_PREFIX, repository, issue));
-  return note;
-}
-async function await_taken(repository, issue) {
-  const decision = path_of(DECISION_PREFIX, repository, issue);
-  const is_taken = await poll.poll_until(() => stamp_file.read_stamp_text(decision) !== void 0, {
-    attempts: Math.ceil(SESSION_GAP_MS / OFFER_POLL_MS),
-    interval_ms: OFFER_POLL_MS,
-    sleeper: sleep
-  });
-  if (is_taken) return true;
-  await sleep(OFFER_POLL_MS);
-  return !decide(repository, issue, WITHDRAWN);
-}
-async function offer(repository, issue, note) {
-  if (!is_waited(repository, issue)) return false;
-  clear_offer(repository, issue);
-  stamp_file.replace_stamp(path_of(HANDOFF_PREFIX, repository, issue), { at: Date.now(), note });
-  const is_taken = await await_taken(repository, issue);
-  stamp_file.remove_stamp(path_of(HANDOFF_PREFIX, repository, issue));
-  return is_taken;
-}
-var run_ship_waiter = { SESSION_GAP_MS, beat, is_waited, leave, offer, take };
-
-// scripts/run/ship/run-ship-wait-cli.ts
-var VERDICT = {
-  RETURNED: "returned",
-  PASSED: "passed",
-  ENDED: "ended",
-  PENDING: "pending"
-};
-var CHUNK_MS = 27e4;
-var POLL_MS = 2e3;
-var SUCCESS_EXIT_CODE = 0;
-var FAILURE_EXIT_CODE = 1;
-var USAGE = "Usage: josh ship:wait <N>";
-var NO_REPOSITORY_NOTE = "not inside a git repository";
-var { COMMIT, FOLLOWUP, REPORT } = run_ship_stage.STAGE;
-var PAST_COMMIT = /* @__PURE__ */ new Set([FOLLOWUP, REPORT]);
-function is_committed(repository, issue) {
-  const target = run_ship_stage.record_path(repository, issue);
-  const started = run_ship_stage.read_started(target);
-  if (started.some((stage) => PAST_COMMIT.has(stage))) return true;
-  return started.includes(COMMIT) && run_ship_stage.read_done(target).has(COMMIT);
-}
-function ended(repository, issue) {
-  const result = run_ship_detach.read_result(repository, issue)?.result;
-  if (result === "running") return void 0;
-  return { verdict: result === "success" ? VERDICT.PASSED : VERDICT.ENDED };
-}
-function settled(repository, issue) {
-  const note = run_ship_waiter.take(repository, issue);
-  if (note !== void 0) return { verdict: VERDICT.RETURNED, note };
-  if (is_committed(repository, issue)) return { verdict: VERDICT.PASSED };
-  return ended(repository, issue);
-}
-async function wait_within(repository, issue, deadline) {
-  return await poll.wait_for(
-    () => {
-      if (Date.now() >= deadline) return { verdict: VERDICT.PENDING };
-      run_ship_waiter.beat(repository, issue);
-      return settled(repository, issue);
-    },
-    { interval_ms: POLL_MS, sleeper: sleep2 }
-  );
-}
-async function wait_for(repository, issue, chunk_ms = CHUNK_MS) {
-  const waited = await wait_within(repository, issue, Date.now() + chunk_ms);
-  if (waited.verdict !== VERDICT.PENDING) run_ship_waiter.leave(repository, issue);
-  return waited;
-}
-function chunk_left() {
-  return CHUNK_MS - performance.now();
-}
-function next_action(issue) {
-  return {
-    [VERDICT.RETURNED]: "the ship stopped: fix what the note below says, then ship again",
-    [VERDICT.PASSED]: "the supervisor ships the rest: end the turn",
-    [VERDICT.ENDED]: "nothing is left to wait for: end the turn",
-    [VERDICT.PENDING]: `still before the commit: on \`pnpm josh cost --cut\` \`under\`, run \`pnpm josh ship:wait ${issue}\` again; else end the turn`
-  };
-}
-function report(issue, waited) {
-  console.info(`${waited.verdict} \u2014 ${next_action(issue)[waited.verdict]}`);
-  if (waited.note !== void 0) console.info(waited.note);
-}
-async function run(argv) {
-  const issue = issue_number_shape.single_of(argv);
-  if (issue === void 0) {
-    console.error(USAGE);
-    return FAILURE_EXIT_CODE;
-  }
-  const repository = await run_ship_probe.repository_directory();
-  if (repository === void 0) {
-    console.error(NO_REPOSITORY_NOTE);
-    return FAILURE_EXIT_CODE;
-  }
-  report(issue, await wait_for(repository, issue, chunk_left()));
-  return SUCCESS_EXIT_CODE;
-}
-var run_ship_wait_cli = { CHUNK_MS, VERDICT, run, wait_for };
-
-export {
-  run_ship_waiter,
-  run_ship_wait_cli
-};

package/dist/commands/chunk-HG2NZQD5.js

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