@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-UYHREBT7.js

@@ -0,0 +1,99 @@
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.js";
+
+// scripts/issue/markdown-section.ts
+var HEADING_PREFIX = "## ";
+var LINE_BREAK_PATTERN = /\r?\n/u;
+function is_heading(line) {
+  return line.trimStart().startsWith(HEADING_PREFIX);
+}
+function is_the_heading(line, heading) {
+  return line.trim() === heading;
+}
+function next_fence(line, fence) {
+  const marker = /^ {0,3}(`{3,}|~{3,})/u.exec(line)?.[1];
+  if (fence === "") return marker;
+  const closing = new RegExp(
+    String.raw`^ {0,3}${fence.charAt(0)}{${String(fence.length)},}\s*$`,
+    "u"
+  );
+  if (closing.test(line)) return "";
+  return void 0;
+}
+function lines_of(body) {
+  return body.split(LINE_BREAK_PATTERN);
+}
+function canonical_lines(body) {
+  return lines_of(body).map((line) => issue_body_keys.canonical_line(line));
+}
+function blank_fences(lines) {
+  let fence = "";
+  const visible = [];
+  for (const line of lines) {
+    const next = next_fence(line, fence);
+    visible.push(next === void 0 && fence === "" ? line : "");
+    fence = next ?? fence;
+  }
+  return visible;
+}
+function fence_free_lines(body) {
+  return blank_fences(canonical_lines(body));
+}
+function written_fence_free_lines(body) {
+  return blank_fences(lines_of(body));
+}
+function unfenced_lines(body) {
+  return fence_free_lines(body).map((line) => line.replace(/^(?: {4}|\t).*/u, ""));
+}
+function has_unfenced_line(body, text) {
+  return unfenced_lines(body).some((line) => line.trim() === text);
+}
+function has_line(body, text) {
+  return has_unfenced_line(body, text);
+}
+function section_bounds(body, is_target) {
+  const visible = unfenced_lines(body);
+  const start = visible.findIndex((line) => is_target(line));
+  if (start === -1) return [0, 0];
+  const end = visible.slice(start + 1).findIndex((line) => is_heading(line));
+  return [start + 1, end === -1 ? visible.length : start + 1 + end];
+}
+function section_lines_matching(body, is_target) {
+  const lines = canonical_lines(body);
+  const [start, end] = section_bounds(body, is_target);
+  return lines.slice(start, end);
+}
+function written_section_lines_matching(body, is_target) {
+  const [start, end] = section_bounds(body, is_target);
+  return lines_of(body).slice(start, end);
+}
+function map_section(body, is_target, transform) {
+  const [start, end] = section_bounds(body, is_target);
+  const lines = body.split(/(?<=\n)/u);
+  return [
+    ...lines.slice(0, start),
+    transform(lines.slice(start, end).join("")),
+    ...lines.slice(end)
+  ].join("");
+}
+function section_lines(body, heading) {
+  return section_lines_matching(body, (line) => is_the_heading(line, heading));
+}
+var markdown_section = {
+  canonical_lines,
+  map_section,
+  section_lines,
+  section_lines_matching,
+  fence_free_lines,
+  lines_of,
+  unfenced_lines,
+  has_line,
+  has_unfenced_line,
+  written_fence_free_lines,
+  written_section_lines_matching
+};
+
+export {
+  markdown_section
+};

package/dist/commands/chunk-V2KHY4UQ.js

@@ -0,0 +1,393 @@
+import {
+  openai_lane_supervisor
+} from "./chunk-ELCYNBZO.js";
+import {
+  api_outage,
+  run_ending
+} from "./chunk-GL3VOBWB.js";
+import {
+  lane_dispatch_log,
+  lane_seat_start
+} from "./chunk-TSS2RKBC.js";
+import {
+  lane_dispatch_dependency
+} from "./chunk-ELZQL6M3.js";
+import {
+  run_label
+} from "./chunk-6NXTP5JT.js";
+import {
+  telegram_notify
+} from "./chunk-MQNKIKJ6.js";
+import {
+  run_park
+} from "./chunk-TLCFZAL4.js";
+import {
+  agent_argv
+} from "./chunk-IV6ETHVB.js";
+import {
+  agent_worker_profile
+} from "./chunk-LL6G34MF.js";
+import {
+  git_gh_issue_write
+} from "./chunk-C3Y42PHX.js";
+import {
+  agent_role_profile
+} from "./chunk-O5JGV7NA.js";
+import {
+  lane_registry
+} from "./chunk-KXZR7UAE.js";
+import {
+  run_liveness
+} from "./chunk-L7GYJHDX.js";
+import {
+  lane_environment
+} from "./chunk-CVRDJCOE.js";
+import {
+  detached_launch
+} from "./chunk-MOAPWO34.js";
+import {
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  lane_state
+} from "./chunk-V36OV7AP.js";
+import {
+  IN_PROGRESS_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  lane_child_invocation,
+  lane_reap
+} from "./chunk-VFW6XZH7.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  ENV_FILE_NAME
+} from "./chunk-IGD6QJPH.js";
+import {
+  run_startup
+} from "./chunk-IZPMBGAI.js";
+import {
+  lane_ledger_write
+} from "./chunk-V56NLG7I.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+
+// scripts/lane/lane-output.ts
+var NO_OUTPUT = "This lane records no output path yet.";
+var FORBIDDEN_CHARACTERS = /["\n\r]/u;
+function invalid_reason(output) {
+  if (FORBIDDEN_CHARACTERS.test(output)) return "the path cannot hold a quote or a line break";
+  return run_liveness.to_safe_path(output) === void 0 ? "the path has to be one `run:liveness` can read: absolute, and under the home or temp directory" : void 0;
+}
+async function record_output(issue, output, profile) {
+  const reason = invalid_reason(output);
+  if (reason !== void 0) return { kind: "invalid", reason };
+  const lane = await lane_registry.find_open_lane(issue);
+  if (lane === void 0) return { kind: "no-lane" };
+  const content = lane_registry.read_environment(lane.directory);
+  if (content === void 0) return { kind: "unreadable", lane };
+  lane_registry.write_environment(
+    lane.directory,
+    lane_environment.with_lane_output(content, output, profile)
+  );
+  return { kind: "recorded", lane, output };
+}
+async function read_output(issue) {
+  const lane = await lane_registry.find_open_lane(issue);
+  if (lane === void 0) return { kind: "no-lane" };
+  const { output } = lane;
+  if (output === void 0) return { kind: "none", lane };
+  return { kind: "read", lane, output };
+}
+function describe_refusal(refusal, issue) {
+  if (refusal.kind === "invalid") {
+    return `That output path cannot be recorded: ${refusal.reason}. \`pnpm josh run:liveness\` reads only an absolute path, so a record it cannot use would be worse than none.`;
+  }
+  if (refusal.kind === "unreadable") {
+    return `The lane for ${session_cite.issue(issue)} has a ${ENV_FILE_NAME} that cannot be read at ${refusal.lane.directory}. Fix it and run this again \u2014 writing a new one would drop the lane's port seat with it.`;
+  }
+  return `No lane is open for ${session_cite.issue(issue)}. Run \`pnpm josh lane:list\` to see what is open.`;
+}
+var lane_output = {
+  NO_OUTPUT,
+  describe_refusal,
+  read_output,
+  record_output
+};
+
+// scripts/lane/lane-resume.ts
+var ANTHROPIC = "anthropic";
+function fresh_plan(issue) {
+  return { kind: "fresh", invocation: lane_child_invocation.child_invocation(issue) };
+}
+function resumable_session(record, provider) {
+  if (provider !== ANTHROPIC || record === void 0) return void 0;
+  return api_outage.is_outage(record) ? record.session_id : void 0;
+}
+function plan(issue, record, provider) {
+  const session_id = resumable_session(record, provider);
+  if (session_id === void 0) return fresh_plan(issue);
+  return {
+    kind: "resume",
+    session_id,
+    invocation: lane_child_invocation.outage_resume_invocation(issue)
+  };
+}
+var lane_resume = { plan };
+
+// scripts/lane/lane-dispatch-prepare.ts
+function built_for(plan2, profile, lane) {
+  if (plan2.kind === "resume") {
+    return agent_argv.with_resume_in(plan2.invocation, profile, plan2.session_id, lane.directory);
+  }
+  return agent_argv.with_profile_in(plan2.invocation, profile, lane.directory);
+}
+async function worker_profile(lane) {
+  const worker = await agent_worker_profile.resolve(
+    lane.directory,
+    async () => await git_gh_issue_write.read_label_names(lane.issue)
+  );
+  if (worker.kind === "unset") return agent_role_profile.resolve(agent_role_profile.WORKER);
+  return worker.kind === "rejected" ? worker : { kind: "profile", profile: worker.worker.agent };
+}
+async function prepared(lane, is_fresh) {
+  const resolved = await worker_profile(lane);
+  if (resolved.kind === "rejected") return resolved;
+  const record = is_fresh ? void 0 : run_ending.read_exit(lane_dispatch_log.default_log_path(lane));
+  const plan2 = lane_resume.plan(lane.issue, record, resolved.profile.provider);
+  const built = built_for(plan2, resolved.profile, lane);
+  if (built.kind === "rejected") return built;
+  const resumed_from = plan2.kind === "resume" ? plan2.session_id : void 0;
+  return {
+    kind: "prepared",
+    invocation: plan2.invocation,
+    argv: built.argv,
+    profile: built.profile,
+    resumed_from
+  };
+}
+var lane_dispatch_prepare = { prepared };
+
+// scripts/lane/lane-dispatch.ts
+var NOTE_SEPARATOR = "; ";
+var WARNING_RECOVERY = "Check the lane with `pnpm josh lane:list`, then run `pnpm josh lane:dispatch <issue-number>` again.";
+var LABEL_UNSET_KIND = "label-unset";
+var RESTART_START = "restart";
+var DEPENDENCY_WAIT = "dependency-wait";
+function child_invocation(issue) {
+  return lane_child_invocation.child_invocation(issue);
+}
+function resume_invocation(issue) {
+  return lane_child_invocation.resume_invocation(issue);
+}
+function default_log_path(lane) {
+  return lane_dispatch_log.default_log_path(lane);
+}
+async function resolved_log(lane, profile) {
+  const outcome = await lane_output.record_output(lane.issue, default_log_path(lane), profile);
+  if (outcome.kind === "recorded") return { kind: "ready", path: outcome.output };
+  return { kind: "unrecordable", reason: lane_output.describe_refusal(outcome, lane.issue) };
+}
+function failed_start(request, note, notes) {
+  return {
+    kind: "failed",
+    lane: request.lane,
+    log_path: request.log_path,
+    note: [note, ...notes].join(NOTE_SEPARATOR)
+  };
+}
+function dispatched_of(request, pid, notes) {
+  return { ...request, pid, notes, kind: "dispatched" };
+}
+function existing_dispatch(request) {
+  if (request.profile.provider !== "openai") return void 0;
+  const active = openai_lane_supervisor.active(request.lane.directory);
+  if (active?.issue !== request.lane.issue) return void 0;
+  if (!openai_lane_supervisor.approve(request.lane.directory, active.nonce)) {
+    return failed_start(
+      request,
+      `the OpenAI supervisor for lane ${session_cite.issue(request.lane.issue)} was cancelled`,
+      []
+    );
+  }
+  return dispatched_of(request, active.pid, []);
+}
+function launch_argv(request, nonce) {
+  if (request.profile.provider !== "openai") return request.argv;
+  if (nonce === void 0) throw new Error("OpenAI supervisor nonce is missing");
+  return openai_lane_supervisor.supervisor_argv(request.lane.issue, nonce);
+}
+async function openai_dispatched_start(request, notes, nonce, pid) {
+  const owner = await openai_lane_supervisor.wait_for_active(request.lane.directory, pid);
+  if (owner?.issue !== request.lane.issue) {
+    if (nonce !== void 0) openai_lane_supervisor.cancel(request.lane.directory, nonce);
+    return failed_start(
+      request,
+      `the OpenAI supervisor did not claim lane ${session_cite.issue(request.lane.issue)}`,
+      notes
+    );
+  }
+  if (!openai_lane_supervisor.approve(request.lane.directory, owner.nonce)) {
+    return failed_start(
+      request,
+      `the OpenAI supervisor for lane ${session_cite.issue(request.lane.issue)} was cancelled`,
+      notes
+    );
+  }
+  return dispatched_of(request, owner.pid, notes);
+}
+async function dispatched_start(request, pid, notes, nonce) {
+  return request.profile.provider === "openai" ? await openai_dispatched_start(request, notes, nonce, pid) : dispatched_of(request, pid, notes);
+}
+function worker_environment(lane) {
+  return {
+    ...lane_child_marker.env_for(lane.issue),
+    ...lane_seat_start.environment(lane),
+    [run_startup.ENVIRONMENT_KEY]: ""
+  };
+}
+async function started(request) {
+  const notes = [];
+  const existing = existing_dispatch(request);
+  if (existing !== void 0) return existing;
+  run_park.clear(request.lane.issue, request.lane.directory);
+  const nonce = request.profile.provider === "openai" ? openai_lane_supervisor.new_nonce() : void 0;
+  const result = detached_launch.launch(
+    {
+      argv: launch_argv(request, nonce),
+      cwd: request.lane.directory,
+      log_path: request.log_path,
+      profile: request.profile,
+      env: worker_environment(request.lane)
+    },
+    (note) => {
+      notes.push(note);
+    }
+  );
+  if (result.kind !== "launched") return failed_start(request, result.note, notes);
+  return await dispatched_start(request, result.pid, notes, nonce);
+}
+async function mark_in_progress(issue) {
+  return await run_label.claim(issue);
+}
+async function record_started(issue, start) {
+  const now = /* @__PURE__ */ new Date();
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.CHILD_LAUNCH,
+    `${issue_cite.plain_for("program", issue)} dispatched`,
+    now
+  );
+  await lane_ledger_write.record_dispatch(Number(issue));
+  await lane_state.record_change(
+    {
+      issue,
+      state: "running",
+      command: start === RESTART_START ? "lane:restart" : "lane:dispatch",
+      is_launch: true
+    },
+    { now }
+  );
+}
+async function claimed(issue, start) {
+  if (start === RESTART_START) return { is_applied: true };
+  return await mark_in_progress(issue);
+}
+async function start_wait(issue, request, start) {
+  if (request.profile.provider !== "openai" && lane_reap.is_child_running(issue)) {
+    return { kind: DEPENDENCY_WAIT, reason: "child is already running" };
+  }
+  const wait = await lane_dispatch_dependency.check(issue);
+  if (wait !== void 0 && start === RESTART_START) await lane_dispatch_dependency.defer(issue);
+  return wait;
+}
+async function finish_dispatch(issue, request, start) {
+  const wait = await start_wait(issue, request, start);
+  if (wait !== void 0) return wait;
+  const mark = await claimed(issue, start);
+  if (!mark.is_applied) return { kind: LABEL_UNSET_KIND, reason: mark.reason };
+  await lane_dispatch_dependency.begin(issue);
+  const outcome = await started(request);
+  const is_failed = outcome.kind === "failed";
+  await (is_failed ? run_label.unmark(issue) : record_started(issue, start));
+  return outcome;
+}
+async function dispatch_child(issue, start = "resumable") {
+  issue_number_shape.require_issue_number(issue);
+  const lane = await lane_registry.find_open_lane(issue);
+  if (lane === void 0) return { kind: "no-lane" };
+  const built = await lane_dispatch_prepare.prepared(lane, start === RESTART_START);
+  const log_path = default_log_path(lane);
+  if (built.kind === "rejected") return { kind: "failed", lane, log_path, note: built.note };
+  const log = await resolved_log(lane, built.profile);
+  if (log.kind !== "ready") return log;
+  return await lane_seat_start.start(
+    lane,
+    async (seated) => await finish_dispatch(issue, { lane: seated, log_path: log.path, ...built }, start)
+  );
+}
+function log_sentence(outcome, issue) {
+  const poll = `run \`pnpm josh run:liveness ${issue} --output ${outcome.log_path}\` \u2014 it reads the child's process for itself`;
+  if (outcome.notes.length > 0) {
+    return ` Its output is NOT being kept \u2014 ${outcome.notes.join(NOTE_SEPARATOR)} \u2014 so ${outcome.log_path} will not grow and the process trace is the only answer: ${poll}.`;
+  }
+  return ` It writes to ${outcome.log_path}. Wait on it with \`pnpm josh lane:await ${issue}\` in the background and end the turn; once that output falls silent, ${poll}.`;
+}
+function resume_sentence(outcome) {
+  if (outcome.resumed_from === void 0) {
+    return " Started fresh \u2014 no resumable session was found in the lane record.";
+  }
+  return ` Resumed session ${outcome.resumed_from} \u2014 the disconnected child's context was recovered.`;
+}
+function describe_dispatch(outcome, issue) {
+  if (outcome.kind === "no-lane") {
+    return `No lane is open for ${session_cite.issue(issue)}. Run \`pnpm josh lane:open ${issue}\` first, then dispatch into it.`;
+  }
+  if (outcome.kind === "unrecordable") return outcome.reason;
+  if (outcome.kind === LABEL_UNSET_KIND) {
+    return `The child for ${session_cite.issue(issue)} was not started: the \`${IN_PROGRESS_LABEL}\` label could not be applied (${outcome.reason}), so the lane would be counted as empty. Nothing was launched.`;
+  }
+  if (outcome.kind === "failed") {
+    return `The child for ${session_cite.issue(issue)} did not start: ${outcome.note}.${agent_role_profile.default_notice()} Its log is at ${outcome.log_path}.`;
+  }
+  return `Dispatched \`${outcome.invocation}\` as process ${String(outcome.pid)} in ${outcome.lane.directory} with ${agent_role_profile.describe(outcome.profile)}.${agent_role_profile.default_notice()}${resume_sentence(outcome)}${log_sentence(outcome, issue)}`;
+}
+function describe(outcome, issue) {
+  return outcome.kind === DEPENDENCY_WAIT ? outcome.reason : describe_dispatch(outcome, issue);
+}
+function is_worth_warning(outcome) {
+  if (outcome.kind === DEPENDENCY_WAIT) return false;
+  return outcome.kind !== "dispatched" || outcome.notes.length > 0;
+}
+async function warn_of_problem(outcome, issue) {
+  await telegram_notify.warn({
+    issue_title: `lane child dispatch ${issue_cite.plain_for("telegram", issue)}`,
+    body: describe(outcome, issue),
+    recovery: WARNING_RECOVERY
+  });
+}
+var lane_dispatch = {
+  child_invocation,
+  claim_marker: mark_in_progress,
+  default_log_path,
+  describe,
+  dispatch_child,
+  is_worth_warning,
+  resume_invocation,
+  warn_of_problem
+};
+
+export {
+  lane_output,
+  lane_dispatch
+};

package/dist/commands/chunk-V36OV7AP.js

@@ -0,0 +1,191 @@
+import {
+  figure_format
+} from "./chunk-OYZP5ANC.js";
+import {
+  repository_lock
+} from "./chunk-GC73YEU7.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  lane_state_record
+} from "./chunk-UUH3DE77.js";
+import {
+  durable_state,
+  run_carry
+} from "./chunk-JSJS3OT7.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/lane/lane-state.ts
+import { readdirSync } from "node:fs";
+import path from "node:path";
+var LOCK_SUFFIX = ".lock";
+var LOCK_WAIT_MS = 5e3;
+var { HUMAN_REVIEW, LANE_STATES, STATE_SUFFIX } = lane_state_record;
+var NO_STATE_HINT = "no lane state \u2014 counted in use";
+var TRANSITIONS = {
+  open: ["open", "running", "paused", HUMAN_REVIEW, "ended"],
+  running: ["running", "paused", HUMAN_REVIEW, "ended"],
+  paused: ["paused", "running", "ended"],
+  [HUMAN_REVIEW]: [HUMAN_REVIEW, "running", "ended"],
+  ended: ["ended", "open"]
+};
+function state_path(directory, issue) {
+  return path.join(
+    durable_state.ensure(durable_state.root()),
+    lane_state_record.record_name(directory, issue)
+  );
+}
+function is_allowed(from, to) {
+  return from === void 0 || TRANSITIONS[from].includes(to);
+}
+function read_record(directory, issue) {
+  return lane_state_record.read_record_file(state_path(directory, issue));
+}
+function write_record(directory, record) {
+  stamp_file.replace_stamp(state_path(directory, record.issue), record);
+}
+function current_run(directory) {
+  const carried = run_carry.read_carry(run_carry.carry_path(directory));
+  if (carried.kind !== "carried") return void 0;
+  return { started_at: carried.carry.started_at, owner_pid: carried.carry.owner_pid };
+}
+function launch_fields(change, directory, now) {
+  if (change.is_launch !== true) return {};
+  return { run: current_run(directory), launched_at: now.toISOString() };
+}
+function next_record(change, previous, directory, now) {
+  if (previous?.changed_by === lane_state_record.DEPENDENCY_WAIT_COMMAND && change.is_launch === true) {
+    return previous;
+  }
+  return {
+    // An open starts a fresh life: a reopened lane keeps nothing of the run that launched it before.
+    ...change.state !== "open" && previous,
+    issue: change.issue,
+    state: change.state,
+    changed_at: now.toISOString(),
+    changed_by: change.command,
+    ...launch_fields(change, directory, now)
+  };
+}
+function apply_held(change, directory, now) {
+  const previous = read_record(directory, change.issue);
+  if (!is_allowed(previous?.state, change.state)) {
+    return { kind: "skipped", reason: `no ${previous?.state ?? ""} \u2192 ${change.state} transition` };
+  }
+  const record = next_record(change, previous, directory, now);
+  write_record(directory, record);
+  return { kind: "written", record };
+}
+var NO_DIRECTORY = { kind: "skipped", reason: "no git directory" };
+function locked(directory, issue, held) {
+  const lock = `${state_path(directory, issue)}${LOCK_SUFFIX}`;
+  const outcome = repository_lock.with_lock_sync(held, lock, LOCK_WAIT_MS);
+  return outcome ?? { kind: "skipped", reason: `gave up waiting for the lock at ${lock}` };
+}
+function apply(change, directory, now) {
+  return locked(directory, change.issue, () => apply_held(change, directory, now));
+}
+function warn(change, reason) {
+  console.warn(
+    `${change.command} ${session_cite.issue(change.issue)}: lane state not recorded \u2014 ${reason}`
+  );
+}
+async function resolve_directory(directory) {
+  return directory ?? await run_carry.repository_directory();
+}
+async function outcome_of(change, options) {
+  const directory = await resolve_directory(options.directory);
+  if (directory === void 0) return NO_DIRECTORY;
+  return apply(change, directory, options.now ?? /* @__PURE__ */ new Date());
+}
+async function settled(write) {
+  try {
+    return await write();
+  } catch (error) {
+    return { kind: "skipped", reason: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function record_change(change, options = {}) {
+  const outcome = await settled(async () => await outcome_of(change, options));
+  if (outcome.kind === "skipped") warn(change, outcome.reason);
+  return outcome;
+}
+async function read_state(issue, directory) {
+  const root = await resolve_directory(directory);
+  return root === void 0 ? void 0 : read_record(root, issue);
+}
+function recorded_issues(directory) {
+  const empty = state_path(directory, "");
+  const head = path.basename(empty).slice(0, -STATE_SUFFIX.length);
+  return readdirSync(path.dirname(empty)).filter((name) => name.startsWith(head) && name.endsWith(STATE_SUFFIX)).map((name) => name.slice(head.length, -STATE_SUFFIX.length)).filter((issue) => issue.length > 0);
+}
+async function read_records(directory) {
+  const root = await resolve_directory(directory);
+  if (root === void 0) return [];
+  const records = recorded_issues(root).map((issue) => read_record(root, issue));
+  return records.filter((record) => record !== void 0);
+}
+function stuck_held(issue, stuck, directory) {
+  const previous = read_record(directory, issue);
+  if (previous === void 0) return { kind: "skipped", reason: "no record" };
+  const record = { ...previous, stuck };
+  write_record(directory, record);
+  return { kind: "written", record };
+}
+async function record_stuck(issue, stuck, directory) {
+  const root = await resolve_directory(directory);
+  if (root === void 0) return NO_DIRECTORY;
+  return locked(root, issue, () => stuck_held(issue, stuck, root));
+}
+function adopted_held(change, directory, now) {
+  if (read_record(directory, change.issue) !== void 0) {
+    return { kind: "skipped", reason: "a record exists" };
+  }
+  return apply_held(change, directory, now);
+}
+async function adopted_outcome(change, options) {
+  const directory = await resolve_directory(options.directory);
+  if (directory === void 0) return NO_DIRECTORY;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  return locked(directory, change.issue, () => adopted_held(change, directory, now));
+}
+async function record_adopted(change, options = {}) {
+  return await settled(async () => await adopted_outcome(change, options));
+}
+async function read_states(issues, directory) {
+  const root = await resolve_directory(directory);
+  if (root === void 0) return /* @__PURE__ */ new Map();
+  const read = issues.map((issue) => [
+    issue,
+    read_record(root, issue)
+  ]);
+  return new Map(read.filter((entry) => entry[1] !== void 0));
+}
+function paused_text(since_ms, changed_by) {
+  return `paused since ${figure_format.minute_of(since_ms)} by ${changed_by}`;
+}
+function paused_note(record) {
+  if (record?.state !== "paused") return void 0;
+  return paused_text(Date.parse(record.changed_at), record.changed_by);
+}
+var lane_state = {
+  LANE_STATES,
+  NO_STATE_HINT,
+  is_allowed,
+  paused_note,
+  paused_text,
+  read_records,
+  read_state,
+  read_states,
+  record_adopted,
+  record_change,
+  record_stuck,
+  state_path
+};
+
+export {
+  lane_state
+};