@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-4ZQM4I7R.js

@@ -1,533 +0,0 @@
-import {
-  run_hold_block
-} from "./chunk-KZZWPUJW.js";
-import {
-  run_cli_fault
-} from "./chunk-HRLGFRAV.js";
-import {
-  run_label,
-  run_maintenance
-} from "./chunk-T4F33UKZ.js";
-import {
-  run_halfrun_resume,
-  run_hold_session
-} from "./chunk-SASX3W2M.js";
-import {
-  telegram_test
-} from "./chunk-AK7SEO4Y.js";
-import {
-  test_e2e_stamp
-} from "./chunk-7YZXS3AK.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  git_gh_repo
-} from "./chunk-GJYMI2CM.js";
-import {
-  run_preflight
-} from "./chunk-AJ65WNJB.js";
-import {
-  git_gh_pr_read
-} from "./chunk-23GH6B3D.js";
-import {
-  run_stage
-} from "./chunk-UWLLZQJB.js";
-import {
-  run_ship_lap
-} from "./chunk-PE7B7242.js";
-import {
-  git_branch
-} from "./chunk-Q5Q2QYVU.js";
-import {
-  git_gh_issue_read
-} from "./chunk-ENKFCOVY.js";
-import {
-  run_hold
-} from "./chunk-X3TNPALI.js";
-import {
-  lane_state
-} from "./chunk-ZZXO6TFH.js";
-import {
-  shell_quote
-} from "./chunk-W2IA2LV3.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  issue_number_shape
-} from "./chunk-66NX6EXR.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-
-// scripts/lib/stdout-on-stderr.ts
-function set_stdout_write(stream_write) {
-  process.stdout.write = stream_write;
-}
-async function run(work) {
-  const saved = { write: process.stdout.write.bind(process.stdout) };
-  set_stdout_write(process.stderr.write.bind(process.stderr));
-  try {
-    return await work();
-  } finally {
-    set_stdout_write(saved.write);
-  }
-}
-var stdout_on_stderr = { run };
-
-// scripts/run/run-prrun-resume.ts
-var PRRUN_MERGED = "prrun-merged";
-var PRRUN_MERGE = "prrun-merge";
-var PRRUN_GATE = "prrun-gate";
-function is_untouched(facts) {
-  return facts.head === facts.stop_head && facts.pr_head === facts.stop_head && !facts.is_dirty;
-}
-function decide(facts) {
-  if (facts.is_merged) return PRRUN_MERGED;
-  return is_untouched(facts) ? PRRUN_MERGE : PRRUN_GATE;
-}
-function stop_head_of(read, issue) {
-  const hold = run_halfrun_resume.hold_of(read);
-  return hold?.issue === issue ? hold.prrun_stop_head : void 0;
-}
-async function read_merge_state() {
-  return await git_gh_command.pr_get_merge_state(await git_branch.current());
-}
-async function read_facts(stop_head) {
-  const [state, head, is_dirty] = await Promise.all([
-    read_merge_state(),
-    git_command.head_commit(),
-    run_hold.is_tree_dirty()
-  ]);
-  return {
-    is_merged: state?.is_merged === true,
-    stop_head,
-    head,
-    pr_head: state?.head_sha,
-    is_dirty
-  };
-}
-async function resume_token(issue) {
-  const target = await run_halfrun_resume.hold_target();
-  if (target === void 0) return void 0;
-  const stop_head = stop_head_of(run_hold.read_hold(target), issue);
-  return stop_head === void 0 ? void 0 : decide(await read_facts(stop_head));
-}
-async function adopt(issue) {
-  const target = await run_halfrun_resume.hold_target();
-  if (target === void 0 || stop_head_of(run_hold.read_hold(target), issue) === void 0) {
-    return false;
-  }
-  return run_halfrun_resume.take_over(target, issue);
-}
-async function mark_stop_at(target, issue) {
-  const head = await git_command.head_commit();
-  return run_halfrun_resume.mark_stop_at(target, issue, { prrun_stop_head: head });
-}
-var run_prrun_resume = {
-  PRRUN_GATE,
-  PRRUN_MERGE,
-  PRRUN_MERGED,
-  adopt,
-  decide,
-  mark_stop_at,
-  resume_token,
-  stop_head_of
-};
-
-// scripts/run/hold/run-hold-adopt.ts
-var ADOPTED = "adopted";
-var NO_RECORD = "none";
-var FOREIGN = "foreign";
-var UNREADABLE = "unreadable";
-function rekey(target, issue) {
-  const read = run_hold.read_hold(target);
-  if (read.kind === "unreadable") return UNREADABLE;
-  const hold = run_halfrun_resume.hold_of(read);
-  if (hold === void 0) return NO_RECORD;
-  if (hold.issue !== run_hold.UNNUMBERED_ISSUE && hold.issue !== issue) return FOREIGN;
-  stamp_file.write_stamp(target, { ...hold, issue });
-  return ADOPTED;
-}
-function no_record_message(issue) {
-  return `run:hold --adopt: this tree holds no record to adopt \u2014 claim it with \`pnpm josh run:hold ${issue}\`.`;
-}
-function foreign_message(issue) {
-  return `run:hold --adopt: this tree is held for another issue, so it is not handed to issue ${issue}; \`--adopt\` only re-keys a \`new\` run's unnumbered record.`;
-}
-async function adopt2(target, issue) {
-  const result = rekey(target, issue);
-  if (result === ADOPTED) await run_label.mark(issue);
-  return result;
-}
-var run_hold_adopt = {
-  ADOPTED,
-  NO_RECORD,
-  UNREADABLE,
-  adopt: adopt2,
-  foreign_message,
-  no_record_message
-};
-
-// scripts/run/hold/run-stop-notify.ts
-var TITLE_PLACEHOLDER = "<title>";
-var PR_PLACEHOLDER = "<pr-url>";
-var HALFRUN = "halfrun";
-var PRRUN = "prrun";
-function reference_of(facts) {
-  return issue_cite.plain_for("telegram", facts.issue);
-}
-function commit_title(facts) {
-  return shell_quote.single_quoted(`${facts.title ?? TITLE_PLACEHOLDER} ${reference_of(facts)}`);
-}
-function with_urls(values, facts) {
-  const with_issue = facts.issue_url === void 0 ? values : { ...values, "issue-url": facts.issue_url };
-  return facts.pr_url === void 0 ? with_issue : { ...with_issue, "pr-url": facts.pr_url };
-}
-function halfrun_values(facts) {
-  const title = commit_title(facts);
-  const body = [
-    "halfrun ready for manual verification",
-    run_stage.next_line(HALFRUN, facts.issue),
-    `Without an agent: pnpm josh git -y ${title} && pnpm josh followup ${title}`
-  ].join("\n");
-  const values = {
-    "task-type": "confirmation",
-    body,
-    recommended: `Verify by hand, then prrun ${reference_of(facts)}`,
-    alternative: [`fullrun ${reference_of(facts)}`]
-  };
-  return with_urls(values, facts);
-}
-function human_review_values(facts, directory) {
-  const body = [
-    "needs-human-review: implemented and gated, stopped before the commit",
-    run_stage.next_line(HALFRUN, facts.issue),
-    `Working tree: ${directory}`
-  ].join("\n");
-  const values = {
-    "task-type": "confirmation",
-    body,
-    recommended: `Review the working tree, then prrun ${reference_of(facts)}`,
-    alternative: [`fullrun ${reference_of(facts)}`]
-  };
-  return with_urls(values, facts);
-}
-function prrun_values(facts) {
-  const body = [
-    `prrun ready to merge: ${facts.pr_url ?? PR_PLACEHOLDER}`,
-    run_stage.next_line(PRRUN, facts.issue),
-    `After a manual merge, without an agent: pnpm josh followup ${commit_title(facts)}`
-  ].join("\n");
-  const values = {
-    "task-type": "confirmation",
-    body,
-    recommended: `fullrun ${reference_of(facts)}`,
-    alternative: ["Merge by hand, then pnpm josh followup"]
-  };
-  return with_urls(values, facts);
-}
-async function issue_facts(issue) {
-  const slug = await git_gh_repo.repo_get_name_with_owner();
-  const title = await git_gh_issue_read.issue_get_title(issue);
-  return {
-    issue,
-    title,
-    issue_url: slug === void 0 ? void 0 : issue_cite.issue_url(slug, issue)
-  };
-}
-async function prrun_facts(issue) {
-  const pr_url = await git_gh_pr_read.pr_get_url(await git_command.branch());
-  return { ...await issue_facts(issue), pr_url };
-}
-async function send_composed(target, compose) {
-  const { values, title } = await compose();
-  const titled = title === void 0 ? values : { ...values, "issue-title": title };
-  await stdout_on_stderr.run(async () => {
-    await telegram_test.send_values(titled);
-  });
-  run_hold_session.mark_notified(target);
-}
-async function send(target, compose) {
-  try {
-    await send_composed(target, compose);
-  } catch (error) {
-    console.error(`\u26A0\uFE0F  run:hold could not send the stop confirmation: ${String(error)}`);
-  }
-}
-async function send_halfrun(target, issue) {
-  await send(target, async () => {
-    const facts = await issue_facts(issue);
-    return { values: halfrun_values(facts), title: facts.title };
-  });
-}
-async function send_prrun(target, issue) {
-  await send(target, async () => {
-    const facts = await prrun_facts(issue);
-    return { values: prrun_values(facts), title: facts.title };
-  });
-}
-async function send_human_review(target, issue) {
-  await send(target, async () => {
-    const facts = await issue_facts(issue);
-    const directory = await git_command.repository_root();
-    return { values: human_review_values(facts, directory), title: facts.title };
-  });
-}
-var run_stop_notify = {
-  halfrun_values,
-  human_review_values,
-  prrun_values,
-  send_halfrun,
-  send_human_review,
-  send_prrun
-};
-
-// scripts/run/hold/run-hold-cli.ts
-var SUCCESS_EXIT_CODE = 0;
-var FAILURE_EXIT_CODE = 1;
-var RELEASE_FLAG = "--release";
-var FORCE_FLAG = "--force";
-var FULLRUN_FLAG = "--fullrun";
-var HALFRUN_STOP_FLAG = "--halfrun-stop";
-var PRRUN_STOP_FLAG = "--prrun-stop";
-var HUMAN_REVIEW_STOP_FLAG = "--human-review-stop";
-var ADOPT_FLAG = "--adopt";
-var MAX_CLAIM_ARGUMENTS = 2;
-var USAGE = "Usage: josh run:hold [<issue-number> [--fullrun | --halfrun-stop | --human-review-stop | --prrun-stop]] | josh run:hold --adopt <issue-number> | josh run:release [<issue-number> | --force]";
-var COMMAND = "run:hold";
-var HOLD_VERDICT = "hold";
-var BUSY_VERDICT = "busy";
-var UNKNOWN_VERDICT = "unknown";
-var RELEASED_VERDICT = "released";
-var NONE_VERDICT = "none";
-var HELD_VERDICT = "held";
-var E2E_OWED_VERDICT = "e2e-owed";
-var FORCE_RELEASE_KIND = "force-release";
-var HALFRUN_STOP_KIND = "halfrun-stop";
-var HUMAN_REVIEW_STOP_KIND = "human-review-stop";
-var PRRUN_STOP_KIND = "prrun-stop";
-var ADOPT_KIND = "adopt";
-var STOP_KINDS = /* @__PURE__ */ new Set([
-  HALFRUN_STOP_KIND,
-  HUMAN_REVIEW_STOP_KIND,
-  PRRUN_STOP_KIND
-]);
-function is_stop_request(request) {
-  return STOP_KINDS.has(request.kind);
-}
-var FORCE_RELEASE_REQUEST = { kind: FORCE_RELEASE_KIND };
-function release_request(claimant) {
-  return { kind: "release", claimant };
-}
-var STOP_KIND_BY_FLAG = /* @__PURE__ */ new Map([
-  [HALFRUN_STOP_FLAG, HALFRUN_STOP_KIND],
-  [HUMAN_REVIEW_STOP_FLAG, HUMAN_REVIEW_STOP_KIND],
-  [PRRUN_STOP_FLAG, PRRUN_STOP_KIND]
-]);
-function numbered_claim(issue, flag) {
-  if (flag === void 0) return { kind: "claim", issue };
-  const stop_kind = STOP_KIND_BY_FLAG.get(flag);
-  if (stop_kind !== void 0) return { kind: stop_kind, issue };
-  return flag === FULLRUN_FLAG ? { kind: "claim", issue, is_fullrun: true } : void 0;
-}
-function parse_claim(argv) {
-  const [first, flag] = argv;
-  if (first === void 0) return { kind: "claim", issue: run_hold.UNNUMBERED_ISSUE };
-  if (argv.length > MAX_CLAIM_ARGUMENTS || !issue_number_shape.ISSUE_NUMBER_PATTERN.test(first)) {
-    return void 0;
-  }
-  return numbered_claim(first, flag);
-}
-function parse_release_argument(first) {
-  if (first === FORCE_FLAG) return FORCE_RELEASE_REQUEST;
-  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(first) ? release_request(first) : void 0;
-}
-function parse_release(argv) {
-  const [first] = argv;
-  if (first === void 0) return release_request(run_hold.UNNUMBERED_ISSUE);
-  return argv.length > 1 ? void 0 : parse_release_argument(first);
-}
-function parse_adopt(argv) {
-  const [issue] = argv;
-  if (issue === void 0 || argv.length > 1) return void 0;
-  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue) ? { kind: ADOPT_KIND, issue } : void 0;
-}
-function parse_request(argv) {
-  if (argv[0] === RELEASE_FLAG) return parse_release(argv.slice(1));
-  if (argv[0] === ADOPT_FLAG) return parse_adopt(argv.slice(1));
-  return parse_claim(argv);
-}
-function report(message, verdict, code) {
-  console.error(message);
-  console.info(verdict);
-  return code;
-}
-function report_busy(message) {
-  return report(message, BUSY_VERDICT, SUCCESS_EXIT_CODE);
-}
-function report_hold() {
-  console.info(HOLD_VERDICT);
-  return SUCCESS_EXIT_CODE;
-}
-function take_free_tree(target, request) {
-  const is_taken = run_hold.create_hold(target, request.issue, /* @__PURE__ */ new Date(), request.is_fullrun);
-  if (is_taken) return report_hold();
-  return report_busy(run_hold.race_message(run_hold.read_hold(target), target));
-}
-function replace_stale(target, request, hold) {
-  console.error(run_hold.stale_message(hold));
-  run_hold.release_hold(target);
-  return take_free_tree(target, request);
-}
-function take_tree(target, request, read) {
-  if (read.kind === "held") return report_hold();
-  return read.kind === "stale" ? replace_stale(target, request, read.hold) : take_free_tree(target, request);
-}
-function report_preflight(decision) {
-  console.error(`${decision.reason}
-${decision.advice}`);
-  console.info(decision.verdict);
-  return SUCCESS_EXIT_CODE;
-}
-async function preflight_gate(issue, is_linked) {
-  if (is_linked || issue === run_hold.UNNUMBERED_ISSUE) return void 0;
-  const decision = await run_preflight.check(issue);
-  if (decision.verdict === run_preflight.CLEAN_VERDICT) return void 0;
-  return report_preflight(decision);
-}
-async function claim(target, request, is_linked) {
-  const gate = await run_ship_lap.timed(
-    "preflight",
-    async () => await preflight_gate(request.issue, is_linked)
-  );
-  if (gate !== void 0) return gate;
-  const read = run_hold.read_hold(target);
-  const blocked = await run_hold_block.blocking_message(read, request.issue);
-  if (blocked !== void 0) return report_busy(blocked);
-  const code = await run_ship_lap.timed("take_tree", async () => take_tree(target, request, read));
-  if (code === SUCCESS_EXIT_CODE) run_maintenance.sweep();
-  return code;
-}
-function remove_record(target, was_present) {
-  run_hold.release_hold(target);
-  console.info(was_present ? RELEASED_VERDICT : NONE_VERDICT);
-  return SUCCESS_EXIT_CODE;
-}
-function report_held(hold) {
-  return report(run_hold.foreign_release_message(hold), HELD_VERDICT, FAILURE_EXIT_CODE);
-}
-function report_unreadable_record() {
-  return report(run_hold.unreadable_message(), UNKNOWN_VERDICT, FAILURE_EXIT_CODE);
-}
-function release_record(target, claimant) {
-  const read = run_hold.read_hold(target);
-  if (read.kind === "free") return remove_record(target, false);
-  if (read.kind === "unreadable") return report_unreadable_record();
-  if (!run_hold.is_own_hold(read.hold, claimant)) return report_held(read.hold);
-  return remove_record(target, true);
-}
-async function release(target, claimant) {
-  const code = release_record(target, claimant);
-  const is_own_end = code === SUCCESS_EXIT_CODE && claimant !== run_hold.UNNUMBERED_ISSUE;
-  if (is_own_end) await run_label.unmark(claimant);
-  return code;
-}
-function force_release(target) {
-  const read = run_hold.read_hold(target);
-  if (read.kind === "held" || read.kind === "stale") {
-    console.error(run_hold.forced_release_message(read.hold));
-  }
-  return remove_record(target, read.kind !== "free");
-}
-function report_unknown() {
-  return report(run_hold.unknown_message(), UNKNOWN_VERDICT, FAILURE_EXIT_CODE);
-}
-function report_usage() {
-  console.error(USAGE);
-  return FAILURE_EXIT_CODE;
-}
-var SEND_BY_KIND = {
-  [HALFRUN_STOP_KIND]: run_stop_notify.send_halfrun,
-  [HUMAN_REVIEW_STOP_KIND]: run_stop_notify.send_human_review,
-  [PRRUN_STOP_KIND]: run_stop_notify.send_prrun
-};
-async function marked_stop(target, request) {
-  if (request.kind === HUMAN_REVIEW_STOP_KIND) {
-    await lane_state.record_change({
-      issue: request.issue,
-      state: "human-review",
-      command: "run:hold --human-review-stop"
-    });
-  }
-  await SEND_BY_KIND[request.kind](target, request.issue);
-  return report_hold();
-}
-async function e2e_refusal(request) {
-  if (request.kind === PRRUN_STOP_KIND || await test_e2e_stamp.is_current_tree()) return void 0;
-  return report(
-    "run:hold: `pnpm josh test:e2e` has not answered green on this tree \u2014 run it, then mark the stop again.",
-    E2E_OWED_VERDICT,
-    FAILURE_EXIT_CODE
-  );
-}
-async function mark_stop(target, request) {
-  const refusal = await e2e_refusal(request);
-  if (refusal !== void 0) return refusal;
-  const mark = request.kind === PRRUN_STOP_KIND ? await run_prrun_resume.mark_stop_at(target, request.issue) : run_halfrun_resume.mark_stop_at(target, request.issue);
-  if (mark === run_halfrun_resume.MARKED) return await marked_stop(target, request);
-  if (mark === run_halfrun_resume.UNREADABLE) return report_unreadable_record();
-  return report_busy(run_hold.race_message(run_hold.read_hold(target), target));
-}
-async function adopt3(target, issue) {
-  const result = await run_hold_adopt.adopt(target, issue);
-  if (result === run_hold_adopt.ADOPTED) return report_hold();
-  if (result === run_hold_adopt.UNREADABLE) return report_unreadable_record();
-  if (result === run_hold_adopt.NO_RECORD) {
-    return report(run_hold_adopt.no_record_message(issue), NONE_VERDICT, FAILURE_EXIT_CODE);
-  }
-  return report(run_hold_adopt.foreign_message(issue), BUSY_VERDICT, FAILURE_EXIT_CODE);
-}
-async function dispatch(request, target, is_linked) {
-  if (request.kind === "claim") return await claim(target, request, is_linked);
-  if (request.kind === ADOPT_KIND) return await adopt3(target, request.issue);
-  if (is_stop_request(request)) return await mark_stop(target, request);
-  if (request.kind === FORCE_RELEASE_KIND) return force_release(target);
-  return await release(target, request.claimant);
-}
-async function answer(request) {
-  const directory = await run_cli_fault.directory_of(COMMAND, run_hold.worktree_directory);
-  if (directory === void 0) return report_unknown();
-  const is_linked = await run_hold.is_linked_worktree();
-  return await dispatch(request, run_hold.hold_path(directory), is_linked);
-}
-async function run2(argv) {
-  const request = parse_request(argv);
-  if (request === void 0) return report_usage();
-  try {
-    return await answer(request);
-  } catch (error) {
-    return report(run_cli_fault.message(COMMAND, error), UNKNOWN_VERDICT, FAILURE_EXIT_CODE);
-  }
-}
-var run_hold_cli = {
-  BUSY_VERDICT,
-  HELD_VERDICT,
-  HOLD_VERDICT,
-  NONE_VERDICT,
-  RELEASED_VERDICT,
-  UNKNOWN_VERDICT,
-  USAGE,
-  parse_request,
-  run: run2
-};
-
-export {
-  stdout_on_stderr,
-  run_prrun_resume,
-  run_hold_cli
-};

package/dist/commands/chunk-54X37JEJ.js

@@ -1,170 +0,0 @@
-import {
-  lane_hand_back_hold
-} from "./chunk-BJA5U4Q7.js";
-import {
-  lane_held_stats
-} from "./chunk-F6IQHZYY.js";
-import {
-  backlog_hold_codes
-} from "./chunk-ZAAHZY2A.js";
-import {
-  type_check_step
-} from "./chunk-RMDLFLPE.js";
-import {
-  check_reuse
-} from "./chunk-KZ5BBBMO.js";
-import {
-  structural_checks
-} from "./chunk-BMTYUJNT.js";
-import {
-  metrics_totals
-} from "./chunk-ORKVN2LO.js";
-import {
-  gate_tree
-} from "./chunk-NFPD2P3V.js";
-import {
-  lane_ledger
-} from "./chunk-ZNR75OXP.js";
-import {
-  gate_labels
-} from "./chunk-WQ6FS544.js";
-import {
-  lane_ledger_write
-} from "./chunk-I63RNFFR.js";
-import {
-  buffered_process
-} from "./chunk-JZHY7D6D.js";
-
-// scripts/run/ship/run-ship-pre-detach.ts
-import { existsSync } from "node:fs";
-import path from "node:path";
-var SUCCESS_EXIT_CODE = 0;
-var FAILURE_EXIT_CODE = 1;
-var SECTION_SEPARATOR = "\n\n";
-var PASSED = "pre-detach checks passed";
-var UNPINNED = "unpinned";
-var { METRICS_RERECORD_COMMAND } = metrics_totals;
-var STATIC_CHECKS = [
-  { list: ["josh", "exports:unused"], label: gate_labels.EXPORTS_LABEL },
-  { list: ["josh", "cspell:dot"] }
-];
-var GUARD_TEST_TARGETS = [
-  "scripts/document",
-  "scripts/claude",
-  "scripts/rules",
-  "scripts/josh/josh-command-map.test.ts",
-  ...structural_checks.STRUCTURAL_GUARD_TARGETS,
-  "tools/test/pure-files.test.ts"
-];
-var { GUARD_TEST_COMMAND, failure_prefix, failure_section } = structural_checks;
-function present_targets(directory) {
-  return GUARD_TEST_TARGETS.filter((target) => existsSync(path.join(directory, target)));
-}
-function guard_tests(directory) {
-  const targets = present_targets(directory);
-  return targets.length === 0 ? [] : [{ list: [...GUARD_TEST_COMMAND, ...targets] }];
-}
-async function metrics_runs(directory) {
-  const started = performance.now();
-  const result = await metrics_totals.totals_check(directory);
-  if (result === void 0) return [];
-  return [
-    { check: { list: METRICS_RERECORD_COMMAND }, result, elapsed_ms: performance.now() - started }
-  ];
-}
-async function command_lists(directory) {
-  const type_check = await type_check_step.resolve_type_check_args(directory);
-  return [
-    { list: type_check, label: gate_labels.TYPE_CHECK_LABEL },
-    ...STATIC_CHECKS,
-    ...guard_tests(directory)
-  ];
-}
-async function run_in(directory, check) {
-  const started = performance.now();
-  const result = await buffered_process.run_buffered_process(check.list, { cwd: directory });
-  return { check, result, elapsed_ms: performance.now() - started };
-}
-function is_gate_run(run) {
-  return run.check.label !== void 0;
-}
-function gate_results(runs) {
-  return runs.filter((run) => is_gate_run(run)).map(({ check, result, elapsed_ms }) => {
-    return { ...result, label: check.label, command: check.list.join(" "), elapsed_ms };
-  });
-}
-function verdict(runs) {
-  const failed = runs.filter(({ result }) => buffered_process.is_process_failed(result));
-  if (failed.length === 0) return { code: SUCCESS_EXIT_CODE, out: PASSED };
-  return {
-    code: FAILURE_EXIT_CODE,
-    out: failed.map(({ check, result }) => failure_section(check.list, result)).join(SECTION_SEPARATOR)
-  };
-}
-async function not_asked() {
-  return { code: SUCCESS_EXIT_CODE, out: PASSED };
-}
-function joined(result, pinned) {
-  if (pinned.code === SUCCESS_EXIT_CODE) return result;
-  if (result.code === SUCCESS_EXIT_CODE) return pinned;
-  return { code: FAILURE_EXIT_CODE, out: [result.out, pinned.out].join(SECTION_SEPARATOR) };
-}
-function red_kinds(result, pinned) {
-  return [
-    ...result.code === SUCCESS_EXIT_CODE ? [] : [lane_ledger_write.PRE_DETACH_STAGE],
-    ...pinned.code === SUCCESS_EXIT_CODE ? [] : [UNPINNED]
-  ];
-}
-function with_pinned(result, pinned) {
-  const preconditions = red_kinds(result, pinned);
-  const answer = joined(result, pinned);
-  return preconditions.length === 0 ? answer : { ...answer, preconditions };
-}
-async function checks(directory = process.cwd(), records = check_reuse.DEFAULT_RECORDS, pinned = not_asked) {
-  const metrics = await metrics_runs(directory);
-  const [lists, tree] = await Promise.all([command_lists(directory), gate_tree.read_gate_tree()]);
-  const [runs, pinned_result] = await Promise.all([
-    Promise.all(lists.map(async (check) => await run_in(directory, check))),
-    pinned()
-  ]);
-  await check_reuse.record_green_checks(gate_results(runs), tree, records);
-  return with_pinned(verdict([...runs, ...metrics]), pinned_result);
-}
-var run_ship_pre_detach = {
-  GUARD_TEST_TARGETS,
-  METRICS_RERECORD_COMMAND,
-  PASSED,
-  STATIC_CHECKS,
-  UNPINNED,
-  checks,
-  failure_prefix,
-  with_pinned
-};
-
-// scripts/lane/lane-hand-back-held.ts
-var { DRIVERLESS_PREFIX } = backlog_hold_codes;
-function is_driverless(reason) {
-  return reason.startsWith(DRIVERLESS_PREFIX);
-}
-function is_closed(ledger, now_ms) {
-  return lane_held_stats.open_reason(lane_ledger.read_entries(ledger), now_ms) === void 0;
-}
-async function hold(ledger, now_ms) {
-  const reason = lane_hand_back_hold.take(ledger);
-  if (reason !== void 0 && is_closed(ledger, now_ms)) {
-    await lane_ledger_write.record_held({ reason: `${DRIVERLESS_PREFIX}${reason}` }, ledger);
-  }
-}
-async function record(ledger, now_ms = Date.now()) {
-  try {
-    const resolved = ledger ?? await lane_ledger.target();
-    if (resolved !== void 0) await hold(resolved, now_ms);
-  } catch {
-  }
-}
-var lane_hand_back_held = { DRIVERLESS_PREFIX, is_driverless, record };
-
-export {
-  run_ship_pre_detach,
-  lane_hand_back_held
-};