@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-PFO7EYAP.js

@@ -1,45 +0,0 @@
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/josh/session-model-record.ts
-import { text } from "node:stream/consumers";
-import { z } from "zod";
-var RECORD_PREFIX = "josh-session-model-";
-var RECORD_SUFFIX = ".txt";
-var payload_schema = z.object({
-  transcript_path: z.string().min(1),
-  model: z.string().min(1)
-});
-function record_path(transcript_path) {
-  return stamp_file.stamp_path(RECORD_PREFIX, transcript_path, RECORD_SUFFIX);
-}
-function record(raw_payload) {
-  const payload = json_value.parse_with(raw_payload, payload_schema);
-  if (payload === void 0) return void 0;
-  try {
-    stamp_file.write_text_stamp(record_path(payload.transcript_path), payload.model);
-  } catch {
-    return void 0;
-  }
-  return payload.model;
-}
-function recorded(transcript_path) {
-  if (transcript_path === void 0 || transcript_path === null) return void 0;
-  const model = stamp_file.read_stamp_text(record_path(transcript_path))?.trim();
-  return model === "" ? void 0 : model;
-}
-async function read_stdin() {
-  return process.stdin.isTTY ? "" : await text(process.stdin);
-}
-async function record_from_stdin() {
-  return record(await read_stdin());
-}
-var session_model_record = { read_stdin, record, record_from_stdin, record_path, recorded };
-
-export {
-  session_model_record
-};

package/dist/commands/chunk-PHLOTUB7.js

@@ -1,366 +0,0 @@
-import {
-  openai_lane_supervisor
-} from "./chunk-J22PSIXR.js";
-import {
-  api_outage,
-  run_ending
-} from "./chunk-4N32QKJZ.js";
-import {
-  lane_dispatch_log,
-  lane_seat_start
-} from "./chunk-AC26ZUG5.js";
-import {
-  run_label
-} from "./chunk-T4F33UKZ.js";
-import {
-  telegram_notify
-} from "./chunk-WJ4NEDNI.js";
-import {
-  run_park
-} from "./chunk-MN425CU6.js";
-import {
-  agent_argv
-} from "./chunk-NU7W6QGT.js";
-import {
-  agent_worker_profile
-} from "./chunk-FVDQNMP6.js";
-import {
-  git_gh_issue_write
-} from "./chunk-RN2YDNLF.js";
-import {
-  agent_role_profile
-} from "./chunk-6UCWAFQY.js";
-import {
-  lane_registry
-} from "./chunk-452HWOJ7.js";
-import {
-  run_liveness
-} from "./chunk-3AEDZZNL.js";
-import {
-  lane_environment
-} from "./chunk-5ZTQX7OS.js";
-import {
-  detached_launch
-} from "./chunk-C2SEDMZ3.js";
-import {
-  run_event_stream_emit
-} from "./chunk-OKZWEVR4.js";
-import {
-  run_event_stream
-} from "./chunk-NSAVEXVR.js";
-import {
-  lane_state
-} from "./chunk-ZZXO6TFH.js";
-import {
-  IN_PROGRESS_LABEL
-} from "./chunk-QQBMVC5W.js";
-import {
-  lane_child_marker
-} from "./chunk-QAHFPCFR.js";
-import {
-  lane_child_invocation
-} from "./chunk-EW4NPUMQ.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  lane_ledger_write
-} from "./chunk-I63RNFFR.js";
-import {
-  issue_number_shape
-} from "./chunk-66NX6EXR.js";
-import {
-  ENV_FILE_NAME
-} from "./chunk-IGD6QJPH.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";
-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);
-}
-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: {
-        ...lane_child_marker.env_for(request.lane.issue),
-        ...lane_seat_start.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 finish_dispatch(issue, request, start) {
-  const mark = await claimed(issue, start);
-  if (!mark.is_applied) return { kind: LABEL_UNSET_KIND, reason: mark.reason };
-  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(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 is_worth_warning(outcome) {
-  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-PTNQCCIB.js

@@ -1,41 +0,0 @@
-import {
-  release_history,
-  release_plan
-} from "./chunk-D7OAU32Z.js";
-import {
-  version_targets
-} from "./chunk-LPSULLNK.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-
-// scripts/followup/git-followup-pending.ts
-var MERGE_PENDING_NOTE = "\u2014 this run's merge is not counted; it lands next";
-async function read_tip(options) {
-  if (options.tip !== void 0) return options.tip;
-  const default_branch = await git_command.get_default_branch();
-  await git_command.fetch_branch(default_branch);
-  return `origin/${default_branch}`;
-}
-async function read_pending(options) {
-  try {
-    const current_version = version_targets.read_workspace_version(options.cwd ?? process.cwd());
-    if (current_version === void 0) return void 0;
-    const tip = await read_tip(options);
-    const plan = await release_history.read_release_plan(current_version, options.reader, tip);
-    return plan?.pending;
-  } catch {
-    return void 0;
-  }
-}
-async function pending_release_line(options) {
-  const pending = await read_pending(options);
-  if (pending === void 0) return void 0;
-  const line = release_plan.format_pending_line(pending);
-  return options.is_merge_pending ? `${line} ${MERGE_PENDING_NOTE}` : line;
-}
-var git_followup_pending = { MERGE_PENDING_NOTE, pending_release_line, read_pending };
-
-export {
-  git_followup_pending
-};

package/dist/commands/chunk-PTZEFQUX.js

@@ -1,211 +0,0 @@
-import {
-  run_merge,
-  run_merge_cli
-} from "./chunk-ZBZ5DDCH.js";
-import {
-  run_wake_handoff
-} from "./chunk-EBI2BAKQ.js";
-import {
-  issue_merged
-} from "./chunk-HTIDHEEN.js";
-import {
-  backlog_drive_adopt
-} from "./chunk-24ZDAWML.js";
-import {
-  issue_state_cli
-} from "./chunk-BRHPRDDV.js";
-import {
-  run_carry_ended
-} from "./chunk-ZVAIIHBE.js";
-import {
-  stash_orphans
-} from "./chunk-EYMPBHDN.js";
-import {
-  telegram_notify
-} from "./chunk-WJ4NEDNI.js";
-import {
-  git_stash
-} from "./chunk-K64EIHD2.js";
-import {
-  backlogrun_launch
-} from "./chunk-2EZTYLO4.js";
-import {
-  lane_handoff
-} from "./chunk-BYFC6MD2.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  run_carry
-} from "./chunk-MPGJ4ONJ.js";
-import {
-  bounded_pool
-} from "./chunk-EBVS2LKX.js";
-
-// scripts/backlog/backlog-preflight.ts
-function launch_started(git_directory) {
-  const started_at = backlogrun_launch.pending_launch(git_directory)?.started_at;
-  return started_at === void 0 ? void 0 : new Date(started_at);
-}
-function launcher_owner(provider) {
-  return { ...run_carry.owner_of(process.pid), transcript: void 0, provider };
-}
-function preflight(request) {
-  const target = run_carry.carry_path(request.git_directory);
-  const owner = launcher_owner(request.provider);
-  const started = launch_started(request.git_directory);
-  const begun = run_carry.begin_carry(target, request.invocation, owner, started);
-  if (begun === void 0) return { kind: "standing" };
-  run_wake_handoff.hand_off(target);
-  return { kind: "handed-off", carry: { ...begun, is_handed_off: true } };
-}
-function is_driven_for(git_directory, carry, owner) {
-  const parent = backlogrun_launch.running_parent(git_directory);
-  return parent !== void 0 && parent === owner.pid && carry.owner_pid !== parent;
-}
-var backlog_preflight = { is_driven_for, preflight };
-
-// scripts/run/merge/run-merge-collect.ts
-async function closed_merge(child) {
-  return await issue_merged.read_merged(child) ? { merged_pr: void 0 } : void 0;
-}
-async function open_merge(child, read) {
-  const merged_pr = await run_merge_cli.read_merged_pr(child, read);
-  return merged_pr === void 0 ? void 0 : { merged_pr };
-}
-async function merge_of(child) {
-  const read = await issue_state_cli.read_issue(child);
-  if (read.kind !== "state") return void 0;
-  const is_closed = run_merge.classify_child(read.state) === "merged";
-  return is_closed ? await closed_merge(child) : await open_merge(child, read);
-}
-async function collect_lane(lane, owner) {
-  if (lane_handoff.is_ship_running(lane.issue, process.cwd())) return;
-  const merge = await merge_of(lane.issue);
-  if (merge === void 0) return;
-  const ctx = { child: lane.issue, epic: void 0, repo: void 0, over: void 0, owner };
-  await run_merge_cli.record_merged({ ...ctx, merged_pr: merge.merged_pr });
-}
-async function collect_all(lanes, owner) {
-  for (const lane of lanes) {
-    try {
-      await collect_lane(lane, owner);
-    } catch (error) {
-      console.error(
-        `run:carry: lane ${session_cite.issue(lane.issue)} was not collected: ${String(error)}`
-      );
-    }
-  }
-}
-function owner_of(carry) {
-  return { pid: carry.owner_pid, start: carry.owner_start, transcript: carry.owner_transcript };
-}
-async function collect_carried(carry) {
-  await collect_all(await backlog_drive_adopt.active_lanes(), owner_of(carry));
-}
-async function collect_merged(directory) {
-  const read = run_carry.read_carry(run_carry.carry_path(directory));
-  if (read.kind !== "carried") return;
-  try {
-    await collect_carried(read.carry);
-  } catch (error) {
-    console.error(`run:carry: the run's merged lanes were not collected: ${String(error)}`);
-  }
-}
-var run_merge_collect = { collect_merged };
-
-// scripts/run/run-stop-notify.ts
-var STOP_TITLE = "backlogrun stopped";
-var STOP_RECOVERY = "If this did not arrive, `pnpm josh run:wake --list` relays the last progress line.";
-function plan(read, reason) {
-  if (reason === void 0 || reason.length === 0 || read.kind !== "carried") return void 0;
-  return { reason };
-}
-async function announce(notice) {
-  return await telegram_notify.confirm({
-    issue_title: STOP_TITLE,
-    body: notice.reason,
-    recovery: STOP_RECOVERY,
-    recommended: "Resolve the reason above, then run `backlogrun` again",
-    alternatives: ["Leave the backlog stopped until a later session"]
-  });
-}
-var run_stop_notify = {
-  announce,
-  plan
-};
-
-// scripts/run/carry/run-carry-stash.ts
-var READ_CONCURRENCY = 8;
-var CLOSED_STATE = "CLOSED";
-var FAILURE_NOTE = "The closed-issue stash check failed; review the stack by hand with `git stash list`.";
-async function verdict_of(issue) {
-  const read = await issue_state_cli.read_issue(issue);
-  if (read.kind !== "state") return "unreadable";
-  return read.state.state === CLOSED_STATE ? "closed" : "open";
-}
-async function read_closed(issues) {
-  const verdicts = await bounded_pool.bounded_map(
-    issues,
-    READ_CONCURRENCY,
-    async (issue) => await verdict_of(issue)
-  );
-  return {
-    closed: new Set(issues.filter((_issue, index) => verdicts[index] === "closed")),
-    unreadable: issues.filter((_issue, index) => verdicts[index] === "unreadable")
-  };
-}
-function unreadable_note(unreadable) {
-  const issues = unreadable.map((issue) => session_cite.issue(issue)).join(", ");
-  return `Could not read ${issues}, so a stash of theirs may be missing above; ${FAILURE_NOTE}`;
-}
-async function report_orphans() {
-  try {
-    const entries = await git_stash.list();
-    const read = await read_closed(stash_orphans.issues_of(entries));
-    const report = stash_orphans.format_report(stash_orphans.orphans(entries, read.closed));
-    if (report !== void 0) console.error(report);
-    if (read.unreadable.length > 0) console.error(unreadable_note(read.unreadable));
-  } catch {
-    console.error(FAILURE_NOTE);
-  }
-}
-var run_carry_stash = { FAILURE_NOTE, report_orphans };
-
-// scripts/run/carry/run-carry-end.ts
-async function announce_stop(read, request) {
-  if (!request.is_announced) return;
-  const notice = run_stop_notify.plan(read, request.stopped);
-  if (notice !== void 0) await run_stop_notify.announce(notice);
-}
-async function report_end(read) {
-  if (read.kind === "none") return;
-  await run_carry_stash.report_orphans();
-}
-function keep_ended(directory, read, stopped) {
-  try {
-    run_carry_ended.record_ended(run_carry_ended.ended_path(directory), read, /* @__PURE__ */ new Date(), stopped);
-  } catch (error) {
-    console.error(`run:carry: the ended run was not recorded for run:board: ${String(error)}`);
-  }
-}
-function close_record(directory, stopped) {
-  const target = run_carry.carry_path(directory);
-  const read = run_carry.read_carry(target);
-  keep_ended(directory, read, stopped);
-  run_carry.end_carry(target);
-  return read;
-}
-async function end_run(directory, request) {
-  await run_merge_collect.collect_merged(directory);
-  const read = close_record(directory, request.stopped);
-  await announce_stop(read, request);
-  await report_end(read);
-  return read;
-}
-var run_carry_end = { end_run };
-
-export {
-  backlog_preflight,
-  run_carry_end
-};