@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-P43GWYR6.js

@@ -0,0 +1,185 @@
+import {
+  lane_preserve
+} from "./chunk-VMG3QB6C.js";
+import {
+  run_investigation_record
+} from "./chunk-JT5ICRFF.js";
+import {
+  lane_close
+} from "./chunk-XUXCFPDK.js";
+import {
+  lane_residents
+} from "./chunk-43H725LG.js";
+import {
+  issue_state_cli
+} from "./chunk-E4PFCTXN.js";
+import {
+  run_label
+} from "./chunk-KN46UC77.js";
+import {
+  lane_yield
+} from "./chunk-GZL6ISVM.js";
+import {
+  git_gh_issue_write
+} from "./chunk-4F4KARQN.js";
+import {
+  lane_registry
+} from "./chunk-NEOCCN6D.js";
+import {
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  lane_state
+} from "./chunk-7EAYFMDN.js";
+import {
+  lane_reap
+} from "./chunk-ON4IKRGS.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+
+// scripts/lane/lane-withdraw.ts
+var WITHDRAW_OCCASION = "lane withdraw";
+var CLOSED_STATE = "CLOSED";
+var CLOSED_KIND = "closed";
+var NO_LANE_KIND = "no-lane";
+var UNREADABLE_KIND = "unreadable";
+var OPEN_TAIL = "Its lane child was stopped and the lane closed. The Issue stays open: this run does not resume it, and the next run offers it again.";
+var STAYS_OPEN = "The Issue stays open: this run does not offer it again, the next run does.";
+var WITHDRAWER_TEXT = {
+  person: {
+    name: "a person",
+    cause: "a person withdrew it with `lane:withdraw`",
+    closed_head: "Its lane was withdrawn with `pnpm josh lane:withdraw` after the Issue was closed.",
+    open_head: "Withdrawn from the current run by a person with `pnpm josh lane:withdraw`.",
+    open_tail: OPEN_TAIL,
+    stays: STAYS_OPEN
+  },
+  supervisor: {
+    name: "the run:wake supervisor",
+    cause: "the `run:wake` supervisor withdrew it after its issue was closed",
+    closed_head: "Its lane was withdrawn by the `run:wake` supervisor after the Issue was closed.",
+    open_head: "Withdrawn from the current run by the `run:wake` supervisor.",
+    open_tail: OPEN_TAIL,
+    stays: STAYS_OPEN
+  },
+  merge: {
+    name: "the run:merge driver",
+    cause: "`run:merge` withdrew it after its issue was closed without a merge",
+    closed_head: "Its lane was withdrawn by `pnpm josh run:merge` after the Issue was closed without a merge.",
+    open_head: "Withdrawn from the current run by `pnpm josh run:merge`.",
+    open_tail: OPEN_TAIL,
+    stays: STAYS_OPEN
+  },
+  yield: lane_yield.YIELD_TEXT
+};
+function withdraw_comment({ reason, by, is_closed }) {
+  const head = is_closed ? WITHDRAWER_TEXT[by].closed_head : WITHDRAWER_TEXT[by].open_head;
+  const tail = is_closed ? "Its lane child was stopped and the lane closed, so it no longer holds a lane and is not resumed." : WITHDRAWER_TEXT[by].open_tail;
+  return [head, tail, `- Why: ${reason}`].join("\n");
+}
+async function record_withdraw(issue, { reason, by }) {
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.WITHDRAW,
+    `${issue_cite.plain_for("program", issue)} withdrawn by ${WITHDRAWER_TEXT[by].name}: ${reason}`
+  );
+}
+async function read_is_closed(issue) {
+  const read = await issue_state_cli.read_issue(issue);
+  if (read.kind !== "state") return void 0;
+  return read.state.state.toUpperCase() === CLOSED_STATE;
+}
+async function forget_investigation(issue, is_closed) {
+  if (!is_closed) return;
+  await run_investigation_record.remove(issue);
+}
+async function note_issue(issue, withdrawal, stash) {
+  const is_noted = await git_gh_issue_write.issue_try_comment(issue, withdraw_comment(withdrawal));
+  if (stash !== void 0) {
+    await lane_preserve.announce(issue, stash, WITHDRAWER_TEXT[withdrawal.by].cause);
+  }
+  await run_label.unmark(issue);
+  await forget_investigation(issue, withdrawal.is_closed);
+  return is_noted;
+}
+async function stop_and_close(lane, withdrawal) {
+  await record_withdraw(lane.issue, withdrawal);
+  const reaped = lane_reap.reap_child(lane).length;
+  const saved = await lane_preserve.keep_work(lane.issue, lane.directory, WITHDRAW_OCCASION);
+  if (saved.kind === "unsaved") return saved;
+  const is_noted = await note_issue(lane.issue, withdrawal, saved.stash);
+  const closed = await lane_close.close_lane(lane.issue);
+  if (closed.kind !== "incomplete") {
+    await lane_state.record_change({ issue: lane.issue, state: "ended", command: "lane:withdraw" });
+  }
+  return {
+    kind: "withdrawn",
+    by: withdrawal.by,
+    reaped,
+    stash: saved.stash,
+    is_noted,
+    is_closed: withdrawal.is_closed,
+    lane: closed.kind,
+    residents: closed.residents
+  };
+}
+async function withdraw(issue, reason, by = "person") {
+  issue_number_shape.require_issue_number(issue);
+  const is_closed = await read_is_closed(issue);
+  if (is_closed === void 0) return { kind: UNREADABLE_KIND };
+  const lane = await lane_registry.find_open_lane(issue);
+  if (lane === void 0) return { kind: is_closed ? CLOSED_KIND : NO_LANE_KIND };
+  return await stop_and_close(lane, { reason, by, is_closed });
+}
+function stash_sentence(stash) {
+  if (stash === void 0) return "The lane held no uncommitted work.";
+  return `Its uncommitted work was stashed \u2014 recover with \`pnpm josh stash:pop "${stash}"\`.`;
+}
+function lane_suffix(outcome, cited) {
+  const removed = outcome.lane === "incomplete" ? " The lane could not be fully removed." : "";
+  const residents = lane_residents.residents_sentence(outcome.residents, cited);
+  return residents === void 0 ? removed : `${removed} ${residents}`;
+}
+function withdrawn_text(outcome, issue) {
+  const cited = session_cite.issue(issue);
+  const stopped = outcome.reaped === 0 ? "Its child had already ended." : "Stopped its child.";
+  const head = `Withdrew ${cited}. ${stopped} ${stash_sentence(outcome.stash)}`;
+  const lane = lane_suffix(outcome, cited);
+  const noted = outcome.is_noted ? "" : " The comment saying so could not be posted.";
+  const issue_sentence = outcome.is_closed ? "The Issue was already closed, so its lane no longer holds a place." : WITHDRAWER_TEXT[outcome.by].stays;
+  return `${head} ${issue_sentence}${noted}${lane}`;
+}
+function unsaved_text(outcome, issue) {
+  return `The child for ${session_cite.issue(issue)} was stopped, but its uncommitted work could not be stashed (${outcome.reason}), so the lane is left at ${outcome.directory}; \`run:merge\` books it withdrawn.`;
+}
+function refused_text(outcome, issue) {
+  const cited = session_cite.issue(issue);
+  if (outcome.kind === CLOSED_KIND) {
+    return `${cited} is already closed and no lane is open for it, so there is nothing to withdraw.`;
+  }
+  if (outcome.kind === NO_LANE_KIND) {
+    return `No lane is open for ${cited}, so there is no child to withdraw.`;
+  }
+  return `The state of ${cited} could not be read, so nothing was stopped or closed \u2014 try again.`;
+}
+function describe(outcome, issue) {
+  if (outcome.kind === "unsaved") return unsaved_text(outcome, issue);
+  return outcome.kind === "withdrawn" ? withdrawn_text(outcome, issue) : refused_text(outcome, issue);
+}
+var WITHDRAWER_NAMES = Object.values(WITHDRAWER_TEXT).map(
+  (text) => text.name
+);
+var lane_withdraw = { WITHDRAWER_NAMES, describe, withdraw };
+
+export {
+  lane_withdraw
+};

package/dist/commands/chunk-P6ASP2DY.js

@@ -0,0 +1,132 @@
+import {
+  lane_implement_rate_read
+} from "./chunk-PJYTUUTH.js";
+import {
+  git_path_quoting,
+  split_assess
+} from "./chunk-ZGEUWHFF.js";
+import {
+  lane_stage_budget
+} from "./chunk-AXXEMVRJ.js";
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+import {
+  change_base
+} from "./chunk-LBVYFW3I.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/split/split-measure.ts
+import { readFile } from "node:fs/promises";
+import path2 from "node:path";
+
+// scripts/split/split-relocations.ts
+import { lstat } from "node:fs/promises";
+import path from "node:path";
+var PAIR_FIELDS = 2;
+var RAW_OPTIONS = ["diff", "--raw", "-z", "--no-abbrev", "--no-relative", "--no-renames"];
+function raw_changes(raw) {
+  return raw.split("\0").flatMap(
+    (header, index, fields) => index % PAIR_FIELDS === 0 && fields[index + 1] !== void 0 ? { header, file: fields[index + 1] ?? "" } : []
+  );
+}
+function deleted_blobs(raw) {
+  return raw_changes(raw).flatMap(({ header, file }) => {
+    const object = /^:100\d+ \d+ (\w+) \w+ D$/u.exec(header)?.[1];
+    return object === void 0 ? [] : { file, object };
+  });
+}
+function added_paths(raw) {
+  return raw_changes(raw).filter((change) => change.header.endsWith(" A")).map((change) => change.file);
+}
+async function content_object(root, file) {
+  try {
+    const stat = await lstat(path.join(root, file));
+    if (!stat.isFile()) return void 0;
+    return await git_spawn.read(["-C", root, "hash-object", "--no-filters", "--", file]);
+  } catch {
+    return void 0;
+  }
+}
+function pair(deleted, addition) {
+  const index = deleted.findIndex((blob) => blob.object === addition.object);
+  if (index === -1) return [];
+  return deleted.splice(index, 1).flatMap((source) => [source.file, addition.file]);
+}
+function paired_paths(raw, additions) {
+  const deleted = deleted_blobs(raw);
+  const paths = additions.flatMap((addition) => pair(deleted, addition));
+  return new Set(paths.map((file) => git_path_quoting.quote(file)));
+}
+async function candidates(root, files) {
+  return await Promise.all(
+    files.map(async (file) => ({
+      file,
+      object: await content_object(root, file) ?? ""
+    }))
+  );
+}
+async function without_relocations(root, base, numstat, untracked) {
+  const raw = await git_spawn.read([...RAW_OPTIONS, base, "--"]);
+  const added = [...added_paths(raw), ...untracked];
+  const paired = paired_paths(raw, await candidates(root, added));
+  const rows = numstat.split("\n").filter((row) => !paired.has(row.split("	").slice(PAIR_FIELDS).join("	")));
+  return { numstat: rows.join("\n"), added };
+}
+var split_relocations = { without_relocations };
+
+// scripts/split/split-measure.ts
+var UNRESOLVED_BASE = "the change base could not be resolved";
+var NUL_BYTE = 0;
+var NO_CONTENT = Buffer.alloc(0);
+var NEWLINE = "\n";
+function line_count(content) {
+  if (content.includes(NUL_BYTE)) return 0;
+  const text = content.toString("utf8");
+  const newlines = text.split(NEWLINE).length - 1;
+  return text === "" || text.endsWith(NEWLINE) ? newlines : newlines + 1;
+}
+async function read_content(file_path) {
+  try {
+    return await readFile(file_path);
+  } catch {
+    return NO_CONTENT;
+  }
+}
+async function untracked_row(root, file) {
+  const lines = line_count(await read_content(path2.join(root, file)));
+  return `${String(lines)}	0	${git_path_quoting.quote(file)}`;
+}
+async function untracked_numstat(root, files) {
+  const rows = await Promise.all(files.map(async (file) => await untracked_row(root, file)));
+  return rows.join(NEWLINE);
+}
+async function read_guide() {
+  const measured = await lane_implement_rate_read.measurements();
+  return split_assess.guide_for(
+    lane_stage_budget.BUDGET_MINUTES.implement,
+    measured.implement_rate,
+    measured.growth
+  );
+}
+async function read_branch() {
+  const base = await change_base.resolved_through_merge();
+  if (base === void 0) throw new Error(UNRESOLVED_BASE);
+  const tracked = await git_command.diff_numstat_since(base);
+  const files = changed_paths.to_paths(await git_command.untracked_names()).map((file) => git_path_quoting.unquote(file));
+  const toplevel = await git_spawn.read(["rev-parse", "--show-toplevel"]);
+  const root = toplevel.trim();
+  const numstat = `${tracked}${NEWLINE}${await untracked_numstat(root, files)}`;
+  const adjusted = await split_relocations.without_relocations(root, base, numstat, files);
+  return split_assess.assess(adjusted.numstat, await read_guide(), new Set(adjusted.added));
+}
+var split_measure = { line_count, read_branch };
+
+export {
+  split_measure
+};

package/dist/commands/chunk-PBAEJ5PT.js

@@ -0,0 +1,38 @@
+import {
+  file_map_stamp
+} from "./chunk-M32UPB2D.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/gate/moved-paths.ts
+var NAME_SEPARATOR = "\0";
+var BASE_DIFF = ["diff", "--name-only", "--no-renames", "-z"];
+async function base_diff(from, to) {
+  if (from === to) return [];
+  try {
+    const names = await git_spawn.read([...BASE_DIFF, from, to]);
+    return names.split(NAME_SEPARATOR).filter((name) => name !== "");
+  } catch {
+    return void 0;
+  }
+}
+async function moved_parts(stamp, tree) {
+  const is_unread = Object.keys(tree.files).length === 0;
+  if (is_unread || stamp.base === void 0 || tree.base === void 0) return void 0;
+  const synced = await base_diff(stamp.base, tree.base);
+  if (synced === void 0) return void 0;
+  return { changed: file_map_stamp.changed_since(stamp, tree.files), synced };
+}
+function union_of(parts) {
+  return [.../* @__PURE__ */ new Set([...parts.changed, ...parts.synced])];
+}
+async function moved_since(stamp, tree) {
+  const parts = await moved_parts(stamp, tree);
+  return parts === void 0 ? void 0 : union_of(parts);
+}
+var moved_paths = { moved_parts, moved_since, union_of };
+
+export {
+  moved_paths
+};

package/dist/commands/chunk-PCZROH3R.js

@@ -0,0 +1,100 @@
+import {
+  issue_observation_gate
+} from "./chunk-YJZAD4Z5.js";
+import {
+  issue_sample_gate
+} from "./chunk-CQUZ6TNQ.js";
+import {
+  measure_declaration
+} from "./chunk-34JJYCIY.js";
+import {
+  markdown_section
+} from "./chunk-JZK33TA5.js";
+import {
+  issue_body_keys
+} from "./chunk-KXK2A2HB.js";
+
+// scripts/issue/issue-not-before.ts
+var BACKGROUND_HEADING = issue_body_keys.heading("background");
+var PREFIX = issue_body_keys.prefix("not_before");
+var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}Z$/u;
+var ISO_TAIL = ":00.000Z";
+var EXAMPLE = `${PREFIX} 2099-01-01T09:00Z`;
+var MALFORMED = `\`${PREFIX}\` must be a UTC time written YYYY-MM-DDTHH:MMZ
+${EXAMPLE}`;
+var MAX_WAIT_DAYS = 7;
+var DAY_MS = 864e5;
+var MAX_WAIT_MS = MAX_WAIT_DAYS * DAY_MS;
+var MINUTES_LENGTH = 16;
+var TOO_LATE = `\`${PREFIX}\` of a measurement follow-up must be at most ${String(MAX_WAIT_DAYS)} days after filing \u2014 wait on samples with \`${issue_sample_gate.DECLARATION}\` instead`;
+var BOTH = `a measurement follow-up declares one of \`${PREFIX}\` and \`${issue_body_keys.prefix("sample_gate")}\`, not both \u2014 keep the condition`;
+var HEADING_MARKS = /^#{1,6}\s+/u;
+var STRAY_HEADINGS = [
+  { name: "\u5B9F\u65BD\u53EF\u80FD\u65E5", declaration: `${PREFIX} YYYY-MM-DDTHH:MMZ` },
+  { name: "\u5B9F\u65BD\u53EF\u80FD\u6761\u4EF6", declaration: issue_sample_gate.DECLARATION }
+];
+function declared_value(body) {
+  const background = markdown_section.section_lines(body, BACKGROUND_HEADING).join("\n");
+  const line = markdown_section.unfenced_lines(background).map((text) => text.trim()).find((text) => text.startsWith(PREFIX));
+  return line?.slice(PREFIX.length).trim();
+}
+function is_valid(value) {
+  if (!DATE_PATTERN.test(value)) return false;
+  const time = Date.parse(value);
+  return !Number.isNaN(time) && new Date(time).toISOString() === `${value.slice(0, -1)}${ISO_TAIL}`;
+}
+function date_of(body = "") {
+  const value = declared_value(body);
+  return value !== void 0 && is_valid(value) ? value : void 0;
+}
+function is_date_due(body, now) {
+  const date = date_of(body);
+  return date === void 0 || Date.parse(date) <= now;
+}
+function is_due(body, now = Date.now()) {
+  return is_date_due(body, now) && issue_sample_gate.wait_of(body) === void 0 && issue_observation_gate.wait_of(body) === void 0;
+}
+function waiting_ms(body, now = Date.now()) {
+  if (is_date_due(body, now)) return void 0;
+  return Date.parse(String(date_of(body)));
+}
+function waiting_date(body, now = Date.now()) {
+  return is_date_due(body, now) ? void 0 : date_of(body);
+}
+function waiting_reason(body, now = Date.now()) {
+  const date = waiting_date(body, now);
+  if (date !== void 0) return `not before ${date}`;
+  const wait = issue_sample_gate.wait_of(body);
+  return wait === void 0 ? issue_observation_gate.wait_of(body)?.reason : issue_sample_gate.reason_of(wait);
+}
+function stray_heading_problems(body) {
+  const headings = markdown_section.unfenced_lines(body).map((line) => line.trim()).filter((line) => HEADING_MARKS.test(line)).map((line) => line.replace(HEADING_MARKS, ""));
+  return STRAY_HEADINGS.filter(({ name }) => headings.some((text) => text.startsWith(name))).map(
+    ({ name, declaration }) => `heading \`${name}\` is not read \u2014 declare it under \`${BACKGROUND_HEADING}\` as \`${declaration}\``
+  );
+}
+function latest_date(now) {
+  return `${new Date(now + MAX_WAIT_MS).toISOString().slice(0, MINUTES_LENGTH)}Z`;
+}
+function measurement_wait_problems(body, now) {
+  const date = date_of(body);
+  if (date === void 0 || !measure_declaration.is_stated(body)) return [];
+  if (issue_sample_gate.cited_number(body) !== void 0) return [BOTH];
+  return Date.parse(date) > now + MAX_WAIT_MS ? [`${TOO_LATE}
+${PREFIX} ${latest_date(now)}`] : [];
+}
+function problems(body, now = Date.now()) {
+  const value = declared_value(body);
+  const date_problems = value === void 0 || is_valid(value) ? [] : [MALFORMED];
+  return [
+    ...stray_heading_problems(body),
+    ...date_problems,
+    ...measurement_wait_problems(body, now),
+    ...issue_sample_gate.problems(body)
+  ];
+}
+var issue_not_before = { is_due, problems, waiting_date, waiting_ms, waiting_reason };
+
+export {
+  issue_not_before
+};

package/dist/commands/chunk-PF3PMT2Q.js

@@ -0,0 +1,46 @@
+import {
+  issue_evidence_exit
+} from "./chunk-HNFBEB4L.js";
+import {
+  epic_close
+} from "./chunk-FT33ZCSB.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  MEASURED_LABEL,
+  MEASURED_UNMET_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/issue/issue-measured-close.ts
+async function apply_label(issue_number, label = MEASURED_LABEL) {
+  const write = await git_gh_command.issue_apply_label(issue_number, label);
+  if (!write.is_applied) console.error(`${label} not applied: ${write.reason}`);
+  return write.is_applied;
+}
+async function close_issue(issue_number) {
+  const is_closed = await git_gh_command.issue_close(issue_number, void 0);
+  if (is_closed) await epic_close.close_completed_epics({ issue_number, is_merged: true });
+  else console.error(`Issue ${session_cite.issue(issue_number)} not closed`);
+  return is_closed;
+}
+async function label_and_close(issue_number) {
+  return await apply_label(issue_number) && await close_issue(issue_number);
+}
+async function mark_unmet_and_close(issue_number) {
+  return await apply_label(issue_number, MEASURED_UNMET_LABEL) && await label_and_close(issue_number);
+}
+var COMMAND = "issue:measured";
+var MEASURED_EXIT = { command: COMMAND, finish: label_and_close };
+var MEASURED_UNMET_EXIT = { command: COMMAND, finish: mark_unmet_and_close };
+async function close(issue_number, evidence) {
+  return await issue_evidence_exit.write({ issue_number, evidence }, MEASURED_EXIT);
+}
+var issue_measured_close = { MEASURED_EXIT, MEASURED_UNMET_EXIT, close };
+
+export {
+  issue_measured_close
+};

package/dist/commands/chunk-PILH72AV.js

@@ -0,0 +1,170 @@
+import {
+  lane_hand_back_hold
+} from "./chunk-AU563VKH.js";
+import {
+  lane_held_stats
+} from "./chunk-R3F7F3TX.js";
+import {
+  backlog_hold_codes
+} from "./chunk-MXPCEZL5.js";
+import {
+  type_check_step
+} from "./chunk-RMDLFLPE.js";
+import {
+  check_reuse
+} from "./chunk-KHGDZQRG.js";
+import {
+  structural_checks
+} from "./chunk-3D5T6KMW.js";
+import {
+  metrics_totals
+} from "./chunk-HEFUC4ZW.js";
+import {
+  gate_tree
+} from "./chunk-R36VZIKU.js";
+import {
+  lane_ledger
+} from "./chunk-2O64H5UJ.js";
+import {
+  gate_labels
+} from "./chunk-WQ6FS544.js";
+import {
+  lane_ledger_write
+} from "./chunk-KIS7JFNP.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
+};