@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-EKKUHXFD.js

@@ -0,0 +1,241 @@
+import {
+  review_stamps
+} from "./chunk-PMC2N6JK.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PACKAGE_JSON
+} from "./chunk-WB4T3VY2.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+
+// scripts/review/review-code-tree.ts
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+// scripts/review/comment-ranges.ts
+var COMMENT_OPENINGS = ["//", "/*"];
+var MARK = "\uE000";
+var LINE_BREAK = "\n";
+var SEPARATOR = " ";
+var RAW_BLOCK = /<(?<tag>script|style)\b[^>]*>(?<body>[\s\S]*?)<\/\k<tag>>/gu;
+var SCRIPT_TAG = "script";
+var MARKUP_COMMENT = /<!--[\s\S]*?-->/gu;
+var VIRTUAL_FILE_NAME = "fix-delta.ts";
+var DIRECTIVE_MARKERS = [
+  "///",
+  "@ts-",
+  "eslint",
+  "jshint",
+  "global ",
+  "globals ",
+  "prettier-ignore",
+  "svelte-ignore",
+  "cspell",
+  "v8 ignore",
+  "c8 ignore",
+  "istanbul ignore",
+  "__PURE__",
+  "__NO_SIDE_EFFECTS__",
+  "@vite-ignore",
+  "webpack",
+  "@jsx",
+  "@vitest-environment"
+];
+var JSDOC_TYPE_TAG = /@(?:type|typedef|param|returns?|template|satisfies|import|callback|overload|enum|this)\b/u;
+var JSDOC_TYPE_EXPRESSION = /@\w+\s*\{/u;
+function is_directive(text, range) {
+  const comment = text.slice(range[0], range[1]);
+  if (JSDOC_TYPE_TAG.test(comment) || JSDOC_TYPE_EXPRESSION.test(comment)) return true;
+  return DIRECTIVE_MARKERS.some((marker) => comment.includes(marker));
+}
+function is_comment(text, range) {
+  return COMMENT_OPENINGS.some((opening) => text.startsWith(opening, range[0]));
+}
+function trivia_at(api, text, position) {
+  const found = [
+    ...api.getLeadingCommentRanges(text, position) ?? [],
+    ...api.getTrailingCommentRanges(text, position) ?? []
+  ];
+  return found.map((range) => [range.pos, range.end]);
+}
+function collect(api, node, source, into) {
+  if (api.isJSDoc(node)) return;
+  into.push(...trivia_at(api, source.text, node.pos));
+  for (const child of node.getChildren(source)) collect(api, child, source, into);
+}
+function script_ranges(api, text) {
+  const source = api.createSourceFile(VIRTUAL_FILE_NAME, text, api.ScriptTarget.Latest, false);
+  const diagnostics = source.parseDiagnostics;
+  if (diagnostics === void 0 || diagnostics.length > 0) return void 0;
+  const ranges = [];
+  collect(api, source, source, ranges);
+  return ranges.filter((range) => is_comment(text, range));
+}
+function shifted(ranges, offset) {
+  return ranges.map((range) => [range[0] + offset, range[1] + offset]);
+}
+function is_inside(blocks, index) {
+  return blocks.some((block) => index >= block[0] && index < block[1]);
+}
+function markup_ranges(text, blocks) {
+  return [...text.matchAll(MARKUP_COMMENT)].filter((match) => !is_inside(blocks, match.index)).map((match) => [match.index, match.index + match[0].length]);
+}
+function block_ranges(api, match) {
+  if (match.groups?.["tag"] !== SCRIPT_TAG) return [];
+  const body = match.groups["body"] ?? "";
+  const ranges = script_ranges(api, body);
+  return ranges && shifted(ranges, match.index + match[0].indexOf(body));
+}
+function svelte_ranges(api, text) {
+  const matches = [...text.matchAll(RAW_BLOCK)];
+  const scripts = matches.map((match) => block_ranges(api, match));
+  if (scripts.includes(void 0)) return void 0;
+  const blocks = matches.map((match) => [match.index, match.index + match[0].length]);
+  return [...scripts.flatMap((ranges) => ranges ?? []), ...markup_ranges(text, blocks)];
+}
+function mark_for(text, start, end) {
+  return text.slice(start, end).includes(LINE_BREAK) ? `${MARK}${LINE_BREAK}${MARK}` : MARK;
+}
+function marked(text, ranges) {
+  const ordered = ranges.toSorted((left, right) => left[0] - right[0]);
+  let result = "";
+  let cursor = 0;
+  for (const [start, end] of ordered) {
+    if (start < cursor) continue;
+    result += `${text.slice(cursor, start)}${mark_for(text, start, end)}`;
+    cursor = end;
+  }
+  return `${result}${text.slice(cursor)}`;
+}
+function normalized_line(line) {
+  if (!line.includes(MARK)) return [line];
+  const indentation = line.slice(0, line.length - line.trimStart().length);
+  const words = line.split(MARK).map((part) => part.trim()).filter((part) => part !== "");
+  return words.length === 0 ? [] : [`${indentation}${words.join(SEPARATOR)}`];
+}
+function without(text, ranges) {
+  return marked(text, ranges).split(LINE_BREAK).flatMap((line) => normalized_line(line)).join(LINE_BREAK);
+}
+function strip(api, text, is_svelte2) {
+  const ranges = is_svelte2 ? svelte_ranges(api, text) : script_ranges(api, text);
+  return ranges && without(
+    text,
+    ranges.filter((range) => !is_directive(text, range))
+  );
+}
+var comment_ranges = { strip };
+
+// scripts/review/import-specifiers.ts
+var VIRTUAL_FILE_NAME2 = "import-delta.ts";
+var SVELTE_EXTENSION = ".svelte";
+var EMPTY_SPECIFIER = "''";
+function specifier_ranges(api, text) {
+  const source = api.createSourceFile(VIRTUAL_FILE_NAME2, text, api.ScriptTarget.Latest, true);
+  return source.statements.filter((statement) => api.isImportDeclaration(statement)).filter((statement) => statement.importClause !== void 0).map((statement) => [statement.moduleSpecifier.getStart(source), statement.moduleSpecifier.end]);
+}
+function blank(api, text, relative) {
+  if (relative.endsWith(SVELTE_EXTENSION)) return text;
+  const ranges = specifier_ranges(api, text);
+  const starts = [0, ...ranges.map(([, end]) => end)];
+  return starts.map((start, index) => text.slice(start, ranges[index]?.[0] ?? text.length)).join(EMPTY_SPECIFIER);
+}
+var import_specifiers = { blank };
+
+// scripts/review/review-code-tree.ts
+var SCRIPT_EXTENSIONS = [".ts", ".js"];
+var SVELTE_EXTENSION2 = ".svelte";
+var EXCLUDED_PREFIX = ".claude/";
+var TYPESCRIPT_MODULE = "typescript";
+function is_svelte(relative) {
+  return relative.endsWith(SVELTE_EXTENSION2);
+}
+function is_source(relative) {
+  if (relative.startsWith(EXCLUDED_PREFIX)) return false;
+  return is_svelte(relative) || SCRIPT_EXTENSIONS.some((extension) => relative.endsWith(extension));
+}
+function load_typescript(root) {
+  try {
+    return createRequire(path.join(root, PACKAGE_JSON))(TYPESCRIPT_MODULE);
+  } catch {
+    return void 0;
+  }
+}
+function text_digest(api, text, relative) {
+  const code = comment_ranges.strip(api, text, is_svelte(relative));
+  return code === void 0 ? void 0 : stamp_file.digest(code);
+}
+function inert_digest(api) {
+  return (text, relative) => text_digest(api, import_specifiers.blank(api, text, relative), relative);
+}
+function code_digest(digest, root, relative) {
+  try {
+    return digest(readFileSync(path.join(root, relative), "utf8"), relative);
+  } catch {
+    return void 0;
+  }
+}
+async function base_digest(digest, base, relative) {
+  try {
+    const text = await git_command.show_file(`${base}:${relative}`);
+    return digest(`${text}
+`, relative);
+  } catch {
+    return void 0;
+  }
+}
+function digests_of(root, paths, digest) {
+  const entries = paths.filter((relative) => is_source(relative)).flatMap((relative) => {
+    const value = code_digest(digest, root, relative);
+    return value === void 0 ? [] : [[relative, value]];
+  });
+  return Object.fromEntries(entries);
+}
+function tree_of(root, paths, api = load_typescript(root)) {
+  if (api === void 0) return {};
+  return digests_of(root, paths, (text, relative) => text_digest(api, text, relative));
+}
+async function read(paths, root) {
+  return tree_of(root ?? await git_command.repository_root(), paths);
+}
+async function record(paths, base, target, root) {
+  try {
+    review_stamps.round_one_code_stamp.write(await read(paths, root), target, base);
+  } catch {
+    review_stamps.clear_round_one_code(target);
+  }
+}
+function comment_only(snapshot, tree, base, unmoved = []) {
+  if (snapshot === void 0 || base === void 0) return [];
+  const is_same_base = snapshot.base === base;
+  return Object.keys(snapshot.files).filter(
+    (relative) => snapshot.files[relative] === tree[relative] && (is_same_base || unmoved.includes(relative))
+  );
+}
+async function inert_since(base, paths, root, api) {
+  const checkout = root ?? await git_command.repository_root();
+  const typescript = api ?? load_typescript(checkout);
+  if (typescript === void 0) return [];
+  const digest = inert_digest(typescript);
+  const tree = digests_of(checkout, paths, digest);
+  const sources = Object.keys(tree);
+  const digests = await Promise.all(
+    sources.map(async (relative) => await base_digest(digest, base, relative))
+  );
+  return sources.filter((relative, index) => digests[index] === tree[relative]);
+}
+var review_code_tree = {
+  comment_only,
+  inert_since,
+  load_typescript,
+  read,
+  record,
+  tree_of
+};
+
+export {
+  review_code_tree
+};

package/dist/commands/chunk-ELCYNBZO.js

@@ -0,0 +1,430 @@
+import {
+  lane_session_broker
+} from "./chunk-XDWCF4XH.js";
+import {
+  ts_entry_loader
+} from "./chunk-VHRNXWVP.js";
+import {
+  lane_dispatch_log
+} from "./chunk-TSS2RKBC.js";
+import {
+  lane_dispatch_dependency
+} from "./chunk-ELZQL6M3.js";
+import {
+  agent_argv
+} from "./chunk-IV6ETHVB.js";
+import {
+  run_cut
+} from "./chunk-OTCWA4QE.js";
+import {
+  run_ship_detach
+} from "./chunk-Z7C2O5JC.js";
+import {
+  detached_launch
+} from "./chunk-MOAPWO34.js";
+import {
+  lane_child_invocation
+} from "./chunk-VFW6XZH7.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  process_owner_schema
+} from "./chunk-HLUS2M3D.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  git_common_directory
+} from "./chunk-MT6TRLFD.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/lane/openai-lane-supervisor.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { fileURLToPath } from "node:url";
+
+// scripts/lane/openai-lane-ship.ts
+var POLL_MS = 250;
+async function current(issue) {
+  const repository = await git_common_directory.read_repository();
+  return repository === void 0 ? void 0 : run_ship_detach.read_result(repository, issue);
+}
+async function settled(issue) {
+  const read3 = await current(issue);
+  if (read3 === void 0) return "abnormal";
+  return read3.result === "running" ? void 0 : read3.result;
+}
+async function wait_for_ship(issue, prior_launch) {
+  const read3 = await current(issue);
+  if (read3 === void 0 || read3.launch_id === prior_launch) return "none";
+  if (read3.result !== "running") return read3.result;
+  return await poll.wait_for(async () => await settled(issue), { interval_ms: POLL_MS });
+}
+var openai_lane_ship = { current, wait_for_ship };
+
+// scripts/lane/openai-lane-supervisor-decision.ts
+import { z } from "zod";
+var DECISION_PREFIX = "josh-openai-lane-supervisor-decision-";
+var APPROVAL_POLL_MS = 50;
+var APPROVAL_POLL_LIMIT = 200;
+var schema = z.object({
+  nonce: z.string(),
+  decision: z.enum(["approved", "cancelled"])
+});
+function target(lane_directory, nonce) {
+  return stamp_file.stamp_path(`${DECISION_PREFIX}${nonce}-`, lane_directory);
+}
+function read(lane_directory, nonce) {
+  const raw = stamp_file.read_stamp_text(target(lane_directory, nonce)) ?? "";
+  return json_value.parse_with(raw, schema);
+}
+function decide(lane_directory, nonce, decision) {
+  const value = { nonce, decision };
+  return stamp_file.create_stamp(target(lane_directory, nonce), value) || read(lane_directory, nonce)?.decision === decision;
+}
+function approve(lane_directory, nonce) {
+  return decide(lane_directory, nonce, "approved");
+}
+function cancel(lane_directory, nonce) {
+  return decide(lane_directory, nonce, "cancelled");
+}
+async function wait_for_decision(lane_directory, nonce) {
+  return await poll.poll_for(() => read(lane_directory, nonce)?.decision, {
+    attempts: APPROVAL_POLL_LIMIT,
+    interval_ms: APPROVAL_POLL_MS
+  });
+}
+async function is_approved(lane_directory, nonce) {
+  return await wait_for_decision(lane_directory, nonce) === "approved";
+}
+function remove(lane_directory, nonce) {
+  stamp_file.remove_stamp(target(lane_directory, nonce));
+}
+var openai_lane_supervisor_decision = { approve, cancel, is_approved, remove, wait_for_decision };
+
+// scripts/lane/openai-lane-supervisor-owner.ts
+import { randomUUID } from "node:crypto";
+import { linkSync, statSync, unlinkSync } from "node:fs";
+import { z as z2 } from "zod";
+var OWNER_PREFIX = "josh-openai-lane-supervisor-";
+var STATE_PREFIX = "josh-openai-lane-supervisor-state-";
+var CLAIM_POLL_MS = 50;
+var CLAIM_POLL_LIMIT = 600;
+var owner_schema = process_owner_schema.extend({
+  issue: z2.string(),
+  nonce: z2.string(),
+  pid: z2.number().int().positive()
+});
+var state_schema = z2.object({
+  owner_nonce: z2.string(),
+  child_pid: z2.number().int().positive().optional(),
+  child_process_start: z2.string().optional(),
+  resume_cut: z2.string().optional(),
+  epoch: z2.number().int().nonnegative()
+});
+function marker_path(lane_directory) {
+  return stamp_file.stamp_path(OWNER_PREFIX, lane_directory);
+}
+function state_path(lane_directory) {
+  return stamp_file.stamp_path(STATE_PREFIX, lane_directory);
+}
+function parsed_stamp(target2, schema2) {
+  return json_value.parse_with(stamp_file.read_stamp_text(target2) ?? "", schema2);
+}
+function read2(lane_directory) {
+  return parsed_stamp(marker_path(lane_directory), owner_schema);
+}
+function read_state(lane_directory, nonce) {
+  const state = parsed_stamp(state_path(lane_directory), state_schema);
+  return state?.owner_nonce === nonce ? state : void 0;
+}
+function is_live(owner) {
+  return process_identity.is_same_process(owner.pid, owner.process_start) !== false;
+}
+function active(lane_directory) {
+  const owner = read2(lane_directory);
+  return owner !== void 0 && is_live(owner) ? owner : void 0;
+}
+function claim_status(lane_directory, pid) {
+  const owner = active(lane_directory);
+  if (owner !== void 0) return { owner };
+  if (pid !== void 0 && !process_identity.is_present_pid(pid)) return { owner: void 0 };
+  return void 0;
+}
+async function wait_for_active(lane_directory, pid) {
+  const owner = await poll.poll_for(() => claim_status(lane_directory, pid), {
+    attempts: CLAIM_POLL_LIMIT,
+    interval_ms: CLAIM_POLL_MS
+  });
+  return owner?.owner;
+}
+function remove_if_unchanged(target2) {
+  const snapshot = `${target2}.${String(process.pid)}.${randomUUID()}`;
+  try {
+    linkSync(target2, snapshot);
+    const current2 = statSync(target2);
+    const linked = statSync(snapshot);
+    if (current2.dev === linked.dev && current2.ino === linked.ino) unlinkSync(target2);
+  } catch {
+  } finally {
+    stamp_file.remove_stamp(snapshot);
+  }
+}
+function live_child(state) {
+  if (state?.child_pid === void 0) return void 0;
+  const { child_pid, child_process_start } = state;
+  if (process_identity.is_same_process(child_pid, child_process_start) === false) return void 0;
+  return {
+    pid: child_pid,
+    ...child_process_start !== void 0 && { process_start: child_process_start }
+  };
+}
+function carried_child(lane_directory, owner) {
+  if (owner === void 0) return void 0;
+  return live_child(read_state(lane_directory, owner.nonce));
+}
+function remove_stale_owner(target2, previous) {
+  if (previous !== void 0 && is_live(previous)) return false;
+  if (stamp_file.read_stamp_text(target2) !== void 0) remove_if_unchanged(target2);
+  return true;
+}
+function previous_resume(lane_directory, owner) {
+  if (owner === void 0) return void 0;
+  return read_state(lane_directory, owner.nonce)?.resume_cut;
+}
+function claim(issue, lane_directory, nonce) {
+  const target2 = marker_path(lane_directory);
+  const previous = read2(lane_directory);
+  if (!remove_stale_owner(target2, previous)) return void 0;
+  const child = carried_child(lane_directory, previous);
+  const resume_cut = previous_resume(lane_directory, previous);
+  const owner = { issue, nonce, ...process_identity.own_fields() };
+  if (!stamp_file.create_stamp(target2, owner)) return void 0;
+  stamp_file.replace_stamp(state_path(lane_directory), {
+    owner_nonce: nonce,
+    resume_cut,
+    epoch: 0,
+    ...child !== void 0 && {
+      child_pid: child.pid,
+      ...child.process_start !== void 0 && {
+        child_process_start: child.process_start
+      }
+    }
+  });
+  return owner;
+}
+function update(lane_directory, owner, state) {
+  if (read2(lane_directory)?.nonce !== owner.nonce) return;
+  stamp_file.replace_stamp(state_path(lane_directory), state);
+}
+function release(lane_directory, nonce) {
+  if (read2(lane_directory)?.nonce !== nonce) return;
+  stamp_file.remove_stamp(state_path(lane_directory));
+  stamp_file.remove_stamp(marker_path(lane_directory));
+  openai_lane_supervisor_decision.remove(lane_directory, nonce);
+}
+var openai_lane_supervisor_owner = {
+  active,
+  claim,
+  marker_path,
+  read_state,
+  release,
+  state_path,
+  update,
+  wait_for_active
+};
+
+// scripts/lane/openai-lane-supervisor.ts
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../scripts/lane/openai-lane-supervisor.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 { claim: claim2, read_state: read_state2, release: release2, update: update2 } = openai_lane_supervisor_owner;
+var CHILD_POLL_MS = 250;
+var SUPERVISOR_SCRIPT = fileURLToPath(new URL("openai-lane-supervisor-entry.ts", __josh_source_url));
+function handed_off(cut, issue) {
+  return cut?.is_handed_off === true && cut.issue === issue && cut.invocation === run_cut.invocation_for(issue);
+}
+async function standing_cut(issue) {
+  const git_directory = await run_cut.worktree_directory();
+  if (git_directory === void 0) return void 0;
+  const read_cut = run_cut.read_cut(run_cut.cut_path(git_directory));
+  return read_cut.kind === "carried" && handed_off(read_cut.cut, issue) ? read_cut.cut : void 0;
+}
+function child_argv(lane, profile, is_resume, override) {
+  const invocation = override ?? (is_resume ? lane_child_invocation.resume_invocation(lane.issue) : lane_child_invocation.child_invocation(lane.issue));
+  const built = agent_argv.with_profile_in(invocation, profile, lane.directory);
+  if (built.kind === "rejected") throw new Error(built.note);
+  return built.argv;
+}
+var LAUNCH_FAILED_KIND = "launch-failed";
+function completion_code(result, ship) {
+  return ship === "abnormal" || result.kind === "abnormal" ? 1 : 0;
+}
+function record_child(generation, child_pid) {
+  const { lane, owner, epoch } = generation;
+  const child_process_start = process_identity.read_start(child_pid);
+  update2(lane.directory, owner, {
+    owner_nonce: owner.nonce,
+    epoch,
+    child_pid,
+    resume_cut: generation.resume_cut,
+    ...child_process_start !== void 0 && { child_process_start }
+  });
+}
+function child_result(result) {
+  if (result.kind === "failed") return { kind: LAUNCH_FAILED_KIND, note: result.note };
+  if (result.exit_code === 0) return { kind: "completed" };
+  const note = `OpenAI lane child exited abnormally (${String(result.exit_code)})`;
+  console.error(note);
+  return { kind: "abnormal", note };
+}
+async function prepare_generation(generation) {
+  const { lane, owner } = generation;
+  const cut = await standing_cut(lane.issue);
+  if (cut === void 0) return { ...generation, resume_cut: void 0 };
+  const resume_cut = JSON.stringify(cut);
+  if (read_state2(lane.directory, owner.nonce)?.resume_cut === resume_cut) {
+    console.error(
+      `OpenAI supervisor ${session_cite.issue(lane.issue)}: resume did not adopt cut ${cut.cut_at}; stopping with work and cut preserved`
+    );
+    return void 0;
+  }
+  return { ...generation, resume_cut };
+}
+async function launch_ready_child(generation) {
+  const { lane, profile, is_resume } = generation;
+  update2(lane.directory, generation.owner, {
+    owner_nonce: generation.owner.nonce,
+    epoch: generation.epoch,
+    resume_cut: generation.resume_cut
+  });
+  const result = await detached_launch.launch_attached(
+    {
+      argv: child_argv(lane, profile, is_resume, generation.invocation),
+      cwd: lane.directory,
+      log_path: lane_dispatch_log.default_log_path(lane),
+      profile,
+      env: lane_child_marker.env_for(lane.issue)
+    },
+    (note) => {
+      console.error(`OpenAI lane child launch: ${note}`);
+    },
+    (child_pid) => {
+      record_child(generation, child_pid);
+    }
+  );
+  return child_result(result);
+}
+async function launch_child(generation) {
+  const wait = await lane_dispatch_dependency.check(generation.lane.issue);
+  if (wait !== void 0) {
+    await lane_dispatch_dependency.defer(generation.lane.issue);
+    return { kind: LAUNCH_FAILED_KIND, note: wait.reason };
+  }
+  await lane_dispatch_dependency.begin(generation.lane.issue);
+  return await launch_ready_child(generation);
+}
+async function stop_invocation(issue) {
+  const current2 = await openai_lane_ship.current(issue);
+  return current2?.stop_invocation ?? lane_child_invocation.ship_stop_invocation(issue);
+}
+async function run_child(generation) {
+  const ready = await prepare_generation(generation);
+  if (ready === void 0) return { kind: LAUNCH_FAILED_KIND, note: "cut resume failed" };
+  return await launch_child(ready);
+}
+async function run_generations(generation) {
+  const prior = await openai_lane_ship.current(generation.lane.issue);
+  const result = await run_child(generation);
+  if (result.kind === LAUNCH_FAILED_KIND) return 1;
+  if (await standing_cut(generation.lane.issue) !== void 0) {
+    return await run_generations({ ...generation, epoch: generation.epoch + 1, is_resume: true });
+  }
+  const ship = await openai_lane_ship.wait_for_ship(generation.lane.issue, prior?.launch_id);
+  if (ship === "failed") {
+    return await run_generations({
+      ...generation,
+      epoch: generation.epoch + 1,
+      is_resume: false,
+      invocation: await stop_invocation(generation.lane.issue)
+    });
+  }
+  return completion_code(result, ship);
+}
+async function wait_for_inherited_child(child_pid, child_process_start) {
+  await poll.wait_for(
+    () => process_identity.is_same_process(child_pid, child_process_start) === false || void 0,
+    { interval_ms: CHILD_POLL_MS }
+  );
+}
+async function recovered_resume(lane, nonce) {
+  const child_pid = read_state2(lane.directory, nonce)?.child_pid;
+  if (child_pid === void 0) return false;
+  await wait_for_inherited_child(child_pid, read_state2(lane.directory, nonce)?.child_process_start);
+  if (await standing_cut(lane.issue) === void 0) return void 0;
+  return true;
+}
+async function run_claimed(lane, profile, owner) {
+  const is_recovered = await recovered_resume(lane, owner.nonce);
+  if (is_recovered === void 0) return 0;
+  const is_resume = is_recovered || await standing_cut(lane.issue) !== void 0;
+  const epoch = (read_state2(lane.directory, owner.nonce)?.epoch ?? 0) + 1;
+  return await run_generations({ lane, profile, owner, is_resume, epoch });
+}
+async function is_approved2(lane, nonce) {
+  const decision = await openai_lane_supervisor_decision.wait_for_decision(lane.directory, nonce);
+  if (decision === "approved") return true;
+  const reason = decision === "cancelled" ? "late claim \u2014 dispatcher cancelled" : "approval timed out";
+  console.error(`OpenAI supervisor ${session_cite.issue(lane.issue)}: ${reason}; exiting`);
+  return false;
+}
+async function supervise(lane, profile, nonce) {
+  const owner = claim2(lane.issue, lane.directory, nonce);
+  if (owner === void 0) return 0;
+  try {
+    if (!await is_approved2(lane, nonce)) return 0;
+    return await lane_session_broker.with_server(
+      lane,
+      async () => await run_claimed(lane, profile, owner)
+    );
+  } finally {
+    release2(lane.directory, nonce);
+  }
+}
+function supervisor_argv(issue, nonce) {
+  return {
+    command: process.execPath,
+    args: [...ts_entry_loader.loader_argv(process.execArgv), SUPERVISOR_SCRIPT, issue, nonce]
+  };
+}
+var openai_lane_supervisor = {
+  active: openai_lane_supervisor_owner.active,
+  approve: openai_lane_supervisor_decision.approve,
+  cancel: openai_lane_supervisor_decision.cancel,
+  claim: claim2,
+  marker_path: openai_lane_supervisor_owner.marker_path,
+  new_nonce: randomUUID2,
+  release: release2,
+  state_path: openai_lane_supervisor_owner.state_path,
+  supervise,
+  supervisor_argv,
+  wait_for_active: openai_lane_supervisor_owner.wait_for_active
+};
+
+export {
+  openai_lane_supervisor
+};