@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-KIS7JFNP.js

@@ -0,0 +1,217 @@
+import {
+  durable_state,
+  run_carry
+} from "./chunk-DS53UUDH.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/lane/lane-ledger-write.ts
+import { closeSync, constants, openSync, writeSync } from "node:fs";
+
+// scripts/lane/lane-ledger-kind.ts
+var KIND = {
+  STARTUP: "startup",
+  MERGE: "merge",
+  GATE: "gate",
+  LOAD: "load",
+  DISPATCH: "dispatch",
+  STAGE: "stage",
+  STOP: "stop",
+  CHAIN: "chain",
+  OVERLAP: "overlap",
+  HELD: "held",
+  RELEASED: "released",
+  ROUND_ONE: "round-one",
+  ROUND_TWO: "round-two",
+  OFFERABLE: "offerable",
+  OFFER: "offer",
+  CORE_WAIT: "core-wait",
+  CORE_ADMISSION: "core-admission",
+  UNIT_FILES: "unit-files",
+  TEST_RELATED: "test-related",
+  TEST_PINNED: "test-pinned",
+  SPLIT_NOTICE: "split-notice",
+  SPLIT_FILED: "split-filed",
+  UNPLANNED_NOTICE: "unplanned-notice",
+  LANE_STATE: "lane-state",
+  PUSH_MISS: "push-miss",
+  EARLY_PUSH: "early-push",
+  SHIP_LAP: "ship-lap",
+  SIZE: "size",
+  LIMIT: "limit"
+};
+var lane_ledger_kind = { KIND };
+
+// scripts/lane/lane-ledger-write.ts
+var LEDGER_PREFIX = durable_state.PREFIX.LANE_LEDGER;
+var LEDGER_SUFFIX = ".jsonl";
+var LINE_SEPARATOR = "\n";
+var CI_WAIT_STAGE = "ci-wait";
+var CODERABBIT_WAIT_STAGE = "coderabbit-wait";
+var CODERABBIT_RATE_LIMIT_STAGE = "coderabbit-rate-limit";
+var CODERABBIT_RETRIGGER_STAGE = "coderabbit-retriggered";
+var PRE_DETACH_STAGE = "pre-detach";
+var ROUND_ONE_REUSED = "reused";
+var LEDGER_FILE_MODE = 384;
+var { O_APPEND, O_CREAT, O_NOFOLLOW, O_WRONLY } = constants;
+var APPEND_FLAGS = O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW;
+var { KIND: KIND2 } = lane_ledger_kind;
+function target_of(repository) {
+  return durable_state.path(LEDGER_PREFIX, repository, LEDGER_SUFFIX);
+}
+async function target() {
+  if (process.env["VITEST"] !== void 0) return void 0;
+  try {
+    const repository = await run_carry.repository_directory();
+    return repository === void 0 ? void 0 : target_of(repository);
+  } catch {
+    return void 0;
+  }
+}
+function append(path, entry) {
+  const descriptor = openSync(path, APPEND_FLAGS, LEDGER_FILE_MODE);
+  try {
+    if (!stamp_file.is_own_regular_file(path)) {
+      throw new Error("Ledger is not an owned regular file");
+    }
+    writeSync(descriptor, `${JSON.stringify(entry)}${LINE_SEPARATOR}`);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+async function record(entry, path) {
+  try {
+    const destination = path ?? await target();
+    if (destination !== void 0) append(destination, entry);
+  } catch {
+  }
+}
+function now_iso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function record_gate(path, gate) {
+  await record({ kind: KIND2.GATE, at: now_iso(), ...gate }, path);
+}
+async function record_merge(issue, at = /* @__PURE__ */ new Date()) {
+  await record({ kind: KIND2.MERGE, at: at.toISOString(), issue });
+}
+async function record_dispatch(issue, path) {
+  await record({ kind: KIND2.DISPATCH, at: now_iso(), issue }, path);
+}
+async function record_stage(stage, path) {
+  await record({ kind: KIND2.STAGE, at: now_iso(), ...stage }, path);
+}
+async function record_stop(stop, path) {
+  await record({ kind: KIND2.STOP, at: now_iso(), ...stop }, path);
+}
+async function record_chain(chain, path) {
+  await record({ kind: KIND2.CHAIN, at: now_iso(), ...chain }, path);
+}
+async function record_overlap(overlap, path) {
+  await record({ kind: KIND2.OVERLAP, at: now_iso(), ...overlap }, path);
+}
+async function record_held(held, path) {
+  const waiting = held.waiting ?? [];
+  const named = waiting.length > 0 ? { waiting: [...waiting] } : {};
+  await record({ kind: KIND2.HELD, at: now_iso(), reason: held.reason, ...named }, path);
+}
+async function record_released(path) {
+  await record({ kind: KIND2.RELEASED, at: now_iso() }, path);
+}
+async function record_lane_state(change, path) {
+  await record({ kind: KIND2.LANE_STATE, at: now_iso(), ...change }, path);
+}
+async function record_offerable(is_offerable, path) {
+  await record({ kind: KIND2.OFFERABLE, at: now_iso(), is_offerable }, path);
+}
+async function record_offer(offer, path) {
+  await record({ kind: KIND2.OFFER, at: now_iso(), ...offer }, path);
+}
+async function record_round_one(round_one, path) {
+  await record({ kind: KIND2.ROUND_ONE, at: now_iso(), ...round_one }, path);
+}
+async function record_round_two(round_two, path) {
+  await record({ kind: KIND2.ROUND_TWO, at: now_iso(), ...round_two }, path);
+}
+async function record_core_wait(wait, path) {
+  const is_immediate = wait.admission_reason !== void 0 && wait.wait_reason === void 0;
+  const kind = is_immediate ? KIND2.CORE_ADMISSION : KIND2.CORE_WAIT;
+  await record({ kind, at: now_iso(), ...wait }, path);
+}
+async function record_unit_files(files, path) {
+  await record({ kind: KIND2.UNIT_FILES, at: now_iso(), files: [...files] }, path);
+}
+async function record_test_related(run, path) {
+  await record({ kind: KIND2.TEST_RELATED, at: now_iso(), ...run }, path);
+}
+async function record_test_pinned(run, path) {
+  await record({ kind: KIND2.TEST_PINNED, at: now_iso(), ...run }, path);
+}
+async function record_split_notice(notice, path) {
+  await record({ kind: KIND2.SPLIT_NOTICE, at: now_iso(), ...notice }, path);
+}
+async function record_split_filed(filed, path) {
+  const destination = path ?? await target();
+  if (destination === void 0) throw new Error("Could not resolve the split-child ledger");
+  append(destination, { kind: KIND2.SPLIT_FILED, at: now_iso(), ...filed });
+}
+async function record_push_miss(miss, path) {
+  await record({ kind: KIND2.PUSH_MISS, at: now_iso(), ...miss }, path);
+}
+async function record_early_push(push, path) {
+  await record({ kind: KIND2.EARLY_PUSH, at: now_iso(), ...push }, path);
+}
+async function record_ship_lap(lap, path) {
+  await record({ kind: KIND2.SHIP_LAP, at: now_iso(), ...lap }, path);
+}
+async function record_size(size, path) {
+  await record({ kind: KIND2.SIZE, at: now_iso(), ...size }, path);
+}
+async function record_unplanned_notice(notice, path) {
+  await record({ kind: KIND2.UNPLANNED_NOTICE, at: now_iso(), ...notice }, path);
+}
+var lane_ledger_write = {
+  CI_WAIT_STAGE,
+  CODERABBIT_RATE_LIMIT_STAGE,
+  CODERABBIT_RETRIGGER_STAGE,
+  CODERABBIT_WAIT_STAGE,
+  KIND: KIND2,
+  LINE_SEPARATOR,
+  PRE_DETACH_STAGE,
+  ROUND_ONE_REUSED,
+  append,
+  record,
+  record_chain,
+  record_core_wait,
+  record_dispatch,
+  record_gate,
+  record_held,
+  record_lane_state,
+  record_released,
+  record_merge,
+  record_overlap,
+  record_offer,
+  record_offerable,
+  record_push_miss,
+  record_early_push,
+  record_round_one,
+  record_round_two,
+  record_ship_lap,
+  record_size,
+  record_split_filed,
+  record_split_notice,
+  record_stage,
+  record_stop,
+  record_test_pinned,
+  record_test_related,
+  record_unit_files,
+  record_unplanned_notice,
+  target,
+  target_of
+};
+
+export {
+  lane_ledger_kind,
+  lane_ledger_write
+};

package/dist/commands/chunk-KKHD3C2P.js

@@ -0,0 +1,114 @@
+import {
+  document_section_cli
+} from "./chunk-NR2JDBPV.js";
+import {
+  run_step_section_table
+} from "./chunk-JSJDIEGZ.js";
+import {
+  agent_session_environment
+} from "./chunk-HHBC6QZE.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  PLATFORM_TEMP_ROOT
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/run/run-step-section-once.ts
+import { createHash } from "node:crypto";
+import { existsSync, writeFileSync } from "node:fs";
+import path from "node:path";
+var MARKER_PREFIX = "josh-section-";
+var DIGEST_LENGTH = 16;
+var TEXT_KEY_PREFIX = "text\n";
+function marker_of(key) {
+  const session = process.env[agent_session_environment.SESSION_ID_KEY];
+  if (session === void 0) return void 0;
+  const digest = createHash("sha256").update(`${session}
+${key}`).digest("hex").slice(0, DIGEST_LENGTH);
+  return path.join(PLATFORM_TEMP_ROOT, `${MARKER_PREFIX}${digest}`);
+}
+function section_key(found) {
+  return `${found.document}
+${found.heading}`;
+}
+function is_key_recorded(key) {
+  const marker = marker_of(key);
+  return marker !== void 0 && existsSync(marker);
+}
+function record_key(key) {
+  const marker = marker_of(key);
+  if (marker !== void 0) writeFileSync(marker, "");
+}
+function is_recorded(found) {
+  return is_key_recorded(section_key(found));
+}
+function record(found) {
+  record_key(section_key(found));
+}
+function is_text_recorded(text) {
+  return is_key_recorded(`${TEXT_KEY_PREFIX}${text}`);
+}
+function record_text(text) {
+  record_key(`${TEXT_KEY_PREFIX}${text}`);
+}
+function repeat_line(found) {
+  const fetch = `pnpm josh doc:section ${found.document} "${found.heading}"`;
+  return `section: ${found.document} \u2192 "${found.heading}" \u2014 printed earlier this session; after a compaction: ${fetch}`;
+}
+var run_step_section_once = { is_recorded, is_text_recorded, record, record_text, repeat_line };
+
+// scripts/run/run-step-section.ts
+var JOSH_PREFIX = "pnpm josh ";
+var COMMAND_SEPARATOR = " ";
+var SUCCESS_EXIT_CODE = 0;
+var { GOVERNING_SECTIONS, LANE_CHILD_SECTIONS } = run_step_section_table;
+function key_of(action) {
+  if (action.kind !== "command") return action.line;
+  const [subcommand = ""] = action.line.slice(JOSH_PREFIX.length).split(COMMAND_SEPARATOR);
+  return subcommand;
+}
+function section_for(key, is_lane_child) {
+  const lane_child_section = is_lane_child ? LANE_CHILD_SECTIONS.get(key) : void 0;
+  return lane_child_section ?? GOVERNING_SECTIONS.get(key);
+}
+function print_section(key, root = process.cwd(), is_lane_child = false) {
+  const found = section_for(key, is_lane_child);
+  if (found === void 0) return SUCCESS_EXIT_CODE;
+  const exit_code = document_section_cli.run([found.document, found.heading], root);
+  if (exit_code === SUCCESS_EXIT_CODE) run_step_section_once.record(found);
+  return exit_code;
+}
+function print_once(key, root = process.cwd()) {
+  const is_lane_child = lane_child_marker.is_child_of(root);
+  const found = section_for(key, is_lane_child);
+  if (found === void 0 || !run_step_section_once.is_recorded(found)) {
+    return print_section(key, root, is_lane_child);
+  }
+  console.info(run_step_section_once.repeat_line(found));
+  return SUCCESS_EXIT_CODE;
+}
+function print_for(action, is_lane_child = false, root = process.cwd()) {
+  return print_section(key_of(action), root, is_lane_child);
+}
+var { CUT, ENTRY, PARK, PAUSE, PROGRESS, RESUME, RETROSPECTIVE } = run_step_section_table;
+var run_step_section = {
+  CUT,
+  ENTRY,
+  GOVERNING_SECTIONS,
+  PARK,
+  PAUSE,
+  PROGRESS,
+  RESUME,
+  RETROSPECTIVE,
+  LANE_CHILD_SECTIONS,
+  key_of,
+  print_for,
+  print_once,
+  print_section
+};
+
+export {
+  run_step_section_once,
+  run_step_section
+};

package/dist/commands/chunk-KKIIY5I5.js

@@ -0,0 +1,67 @@
+import {
+  REPOSITORY_LABELS
+} from "./chunk-QQBMVC5W.js";
+import {
+  git_gh_exec
+} from "./chunk-43DU7DYZ.js";
+
+// scripts/repo/repository-labels.ts
+function labels_endpoint(repo) {
+  return `repos/${repo}/labels`;
+}
+function request(api) {
+  try {
+    return git_gh_exec.exec_gh_api_sync(api);
+  } catch {
+    return void 0;
+  }
+}
+function read_existing(repo) {
+  const path = labels_endpoint(repo);
+  const listing = request({ path, should_paginate: true, jq_filter: ".[].name" });
+  return listing?.split("\n").filter((name) => name.length > 0);
+}
+function missing_labels(existing, wanted) {
+  const names = new Set(existing.map((name) => name.toLowerCase()));
+  return wanted.filter((label) => !names.has(label.name.toLowerCase()));
+}
+function create_label(label, repo) {
+  const body = JSON.stringify(label);
+  const is_created = request({ path: labels_endpoint(repo), method: "POST", body }) !== void 0;
+  if (is_created) console.info(`  \u2714 label ${label.name}`);
+  return is_created;
+}
+function label_names(labels) {
+  return labels.map((label) => label.name);
+}
+function unreadable(wanted, target = "this repository") {
+  const names = label_names(wanted);
+  console.warn(
+    `  \u26A0 could not read the labels of ${target}; make sure these exist: ${names.join(", ")}`
+  );
+  return names;
+}
+function create_missing(missing, repo) {
+  const names = label_names(missing.filter((label) => !create_label(label, repo)));
+  if (names.length > 0) {
+    console.warn(`  \u26A0 could not create these labels; create them by hand: ${names.join(", ")}`);
+  }
+  return names;
+}
+function ensure_labels(repo, extra = []) {
+  const wanted = [...REPOSITORY_LABELS, ...extra];
+  if (repo === void 0) return unreadable(wanted);
+  const existing = read_existing(repo);
+  if (existing === void 0) return unreadable(wanted, repo);
+  return create_missing(missing_labels(existing, wanted), repo);
+}
+function planned_labels(repo) {
+  if (repo === void 0) return label_names(REPOSITORY_LABELS);
+  const existing = read_existing(repo);
+  return existing === void 0 ? void 0 : label_names(missing_labels(existing, REPOSITORY_LABELS));
+}
+var repository_labels = { ensure_labels, planned_labels };
+
+export {
+  repository_labels
+};

package/dist/commands/chunk-KN46UC77.js

@@ -0,0 +1,114 @@
+import {
+  git_followup_label
+} from "./chunk-UWMB6EOU.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  run_ship_lap
+} from "./chunk-HRN73FQJ.js";
+import {
+  resolve_tsx_runner
+} from "./chunk-VL5I2IOD.js";
+import {
+  detached_launch
+} from "./chunk-HDVSZ6CZ.js";
+import {
+  IN_PROGRESS_LABEL,
+  NEEDS_HUMAN_MERGE_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  package_path
+} from "./chunk-3CCGKX7Y.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/run/run-maintenance.ts
+import { execa } from "execa";
+var LABEL_SCRIPT = "scripts/run/run-label-main.ts";
+var SWEEP_SCRIPT = "scripts/run/tidy/run-tidy-main.ts";
+var HOLD_PARENT = "run:entry \u203A run:hold";
+function argv(script, args) {
+  const runner = resolve_tsx_runner();
+  return {
+    command: runner.executable,
+    args: [...runner.leading_arguments, package_path(script), ...args]
+  };
+}
+function background(script, args, prefix) {
+  const log_path = stamp_file.stamp_path(prefix, process.cwd(), ".log");
+  const result = detached_launch.launch(
+    {
+      argv: argv(script, args),
+      cwd: process.cwd(),
+      log_path,
+      env: run_ship_lap.environment(HOLD_PARENT)
+    },
+    console.warn
+  );
+  const state = result.kind === "failed" ? result.note : `pid ${String(result.pid)}`;
+  console.warn(`run maintenance: ${result.kind} (${state}) \u2014 ${log_path}`);
+}
+async function label(issue) {
+  const command = argv(LABEL_SCRIPT, [issue]);
+  const result = await execa(command.command, command.args, {
+    reject: false,
+    timeout: MS_PER_MINUTE
+  });
+  if (result.exitCode === 0) return true;
+  console.warn(
+    `run label: ${result.timedOut ? "60s timeout" : "failed"}; retry queued for ${session_cite.issue(issue)}`
+  );
+  background(LABEL_SCRIPT, [issue, "--retry"], `josh-run-label-retry-${issue}-`);
+  return false;
+}
+function sweep() {
+  background(SWEEP_SCRIPT, [], "josh-run-sweep-");
+}
+var run_maintenance = { label, sweep };
+
+// scripts/run/run-label.ts
+var MARK_RECOVERY = "gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=in-progress'";
+var UNMARK_RECOVERY = "gh api -X DELETE repos/{owner}/{repo}/issues/<N>/labels/in-progress";
+var PARK_RECOVERY = "gh api -X DELETE repos/{owner}/{repo}/issues/<N>/labels/needs-human-merge";
+function warn(action, issue, recovery, label2 = IN_PROGRESS_LABEL) {
+  console.warn(
+    `\u26A0 could not ${action} \`${label2}\` on ${session_cite.issue(issue)} \u2014 run by hand: ${recovery}`
+  );
+}
+async function mark(issue) {
+  const is_marked = await run_maintenance.label(issue);
+  if (!is_marked) warn("apply", issue, MARK_RECOVERY);
+  return is_marked;
+}
+async function unmark(issue) {
+  try {
+    await git_followup_label.strip_in_progress(issue);
+    return true;
+  } catch {
+    warn("remove", issue, UNMARK_RECOVERY);
+    return false;
+  }
+}
+async function claim(issue) {
+  const is_cleared = await git_gh_command.issue_clear_label(issue, NEEDS_HUMAN_MERGE_LABEL);
+  if (!is_cleared) warn("remove", issue, PARK_RECOVERY, NEEDS_HUMAN_MERGE_LABEL);
+  return await git_gh_command.issue_apply_label(issue, IN_PROGRESS_LABEL);
+}
+var run_label = {
+  claim,
+  mark,
+  unmark
+};
+
+export {
+  run_maintenance,
+  run_label
+};

package/dist/commands/chunk-KP2BVAS5.js

@@ -0,0 +1,125 @@
+import {
+  lane_stage_stats
+} from "./chunk-J4XHEOOW.js";
+import {
+  lane_stats
+} from "./chunk-2XLR7R6E.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-size-stats.ts
+var COLUMNS = [
+  "measured lanes",
+  "files actual / declared median",
+  "lines actual / declared median",
+  "pre-split misses"
+];
+var MISS_COLUMNS = ["pre-split miss", "files declared \u2192 actual", "lines declared \u2192 actual"];
+var DECIMALS = 1;
+function sizes_of(entries) {
+  return entries.filter((entry) => entry.kind === "size").toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at));
+}
+function merged_sizes(entries, window) {
+  const sizes = sizes_of(entries);
+  return lane_stats.in_window(entries, window).filter((entry) => entry.kind === "merge").map(
+    (merge) => sizes.findLast(
+      (size) => size.issue === merge.issue && Date.parse(size.at) <= Date.parse(merge.at)
+    )
+  ).filter((size) => size !== void 0);
+}
+function ratio_of(sizes, axis) {
+  const values = sizes.filter((size) => size.declared[axis] > 0).map((size) => size.actual[axis] / size.declared[axis]);
+  return lane_stats.median(values);
+}
+function ratio_cell(sizes, axis) {
+  const median = ratio_of(sizes, axis);
+  return median === void 0 ? lane_stats.MISSING : median.toFixed(DECIMALS);
+}
+function lines_ratio(entries, window) {
+  return ratio_of(merged_sizes(entries, window), "lines");
+}
+function ratios(entries, window) {
+  const sizes = merged_sizes(entries, window);
+  const files = ratio_of(sizes, "files");
+  const lines = ratio_of(sizes, "lines");
+  return { ...files !== void 0 && { files }, ...lines !== void 0 && { lines } };
+}
+function header(columns) {
+  return [lane_stats.to_row(columns), lane_stats.to_row(columns.map(() => "---"))];
+}
+function change_cell(size, axis) {
+  return `${String(size.declared[axis])} \u2192 ${String(size.actual[axis])}`;
+}
+function miss_rows(misses) {
+  if (misses.length === 0) return [];
+  const rows = misses.map(
+    (size) => lane_stats.to_row([
+      issue_cite.plain_for("terminal", size.issue),
+      change_cell(size, "files"),
+      change_cell(size, "lines")
+    ])
+  );
+  return ["", ...header(MISS_COLUMNS), ...rows];
+}
+function table(entries, window) {
+  const sizes = merged_sizes(entries, window);
+  const misses = sizes.filter((size) => size.missed === true);
+  return [
+    ...header(COLUMNS),
+    lane_stats.to_row([
+      String(sizes.length),
+      ratio_cell(sizes, "files"),
+      ratio_cell(sizes, "lines"),
+      String(misses.length)
+    ]),
+    ...miss_rows(misses)
+  ].join("\n");
+}
+var lane_size_stats = { lines_ratio, merged_sizes, ratios, table };
+
+// scripts/lane/lane-implement-rate.ts
+var COLUMNS2 = ["implement-rate lanes", "implement min / 100 actual lines median"];
+var LINES_PER_RATE = 100;
+var DECIMALS2 = 1;
+function per_lines(ms, lines) {
+  return ms === void 0 ? void 0 : ms / MS_PER_MINUTE * LINES_PER_RATE / lines;
+}
+function rates_of(entries, window) {
+  const implement = lane_stage_stats.implement_by_issue(entries);
+  return lane_size_stats.merged_sizes(entries, window).filter((size) => size.actual.lines > 0).map((size) => per_lines(implement.get(size.issue), size.actual.lines)).filter((value) => lane_stage_stats.is_number(value));
+}
+function rate(entries, window) {
+  const rates = rates_of(entries, window);
+  const median = lane_stats.median(rates);
+  return median === void 0 ? void 0 : { median, lanes: rates.length };
+}
+function table2(entries, window) {
+  const measured = rate(entries, window);
+  return [
+    lane_stats.to_row(COLUMNS2),
+    lane_stats.to_row(COLUMNS2.map(() => "---")),
+    lane_stats.to_row([
+      String(measured?.lanes ?? 0),
+      measured?.median.toFixed(DECIMALS2) ?? lane_stats.MISSING
+    ])
+  ].join("\n");
+}
+function minutes_for(lines, measured) {
+  return lines * measured.median / LINES_PER_RATE;
+}
+function lines_for(minutes, measured) {
+  if (measured === void 0 || !Number.isFinite(measured.median) || measured.median <= 0) {
+    return void 0;
+  }
+  return minutes * LINES_PER_RATE / measured.median;
+}
+var lane_implement_rate = { lines_for, minutes_for, rate, table: table2 };
+
+export {
+  lane_size_stats,
+  lane_implement_rate
+};

package/dist/commands/chunk-KPAJBJXG.js

@@ -0,0 +1,63 @@
+import {
+  durable_state
+} from "./chunk-DS53UUDH.js";
+import {
+  agent_provider
+} from "./chunk-DDZVMXZD.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/carry/run-carry-ended.ts
+import path from "node:path";
+import { z } from "zod";
+var ENDED_PREFIX = durable_state.PREFIX.ENDED;
+var TRANSCRIPT_SUFFIX = ".jsonl";
+var ended_run_schema = z.object({
+  scheduler_provider: agent_provider.PROVIDER_SCHEMA.optional(),
+  invocation: z.string(),
+  started_at: z.string(),
+  ended_at: z.string(),
+  stopped: z.string().optional(),
+  session: z.string().optional()
+});
+function ended_path(git_directory) {
+  return durable_state.path(ENDED_PREFIX, git_directory);
+}
+function session_of(transcript) {
+  return transcript === void 0 ? void 0 : path.basename(transcript, TRANSCRIPT_SUFFIX);
+}
+function stop_of(transcript, stopped) {
+  return stopped === void 0 ? {} : { stopped, session: session_of(transcript) };
+}
+function record_ended(target, read, now = /* @__PURE__ */ new Date(), stopped) {
+  if (read.kind !== "carried") return;
+  const { invocation, started_at, owner_transcript } = read.carry;
+  const ended_at = now.toISOString();
+  stamp_file.replace_stamp(target, {
+    ...read.carry.scheduler_provider && { scheduler_provider: read.carry.scheduler_provider },
+    invocation,
+    started_at,
+    ended_at,
+    ...stop_of(owner_transcript, stopped)
+  });
+}
+function parse_ended(raw) {
+  return json_value.parse_with(raw, ended_run_schema);
+}
+function read_ended(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  return raw === void 0 ? void 0 : parse_ended(raw);
+}
+function has_ended(target, started_at) {
+  const ended = read_ended(target);
+  return ended !== void 0 && ended.started_at === started_at;
+}
+var run_carry_ended = { ended_path, has_ended, read_ended, record_ended };
+
+export {
+  run_carry_ended
+};