@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-WTH6NTXU.js

@@ -1,128 +0,0 @@
-import {
-  test_unit_guard
-} from "./chunk-J6WKZRV2.js";
-import {
-  review_stamps
-} from "./chunk-MVHPRYHE.js";
-import {
-  gate_tree
-} from "./chunk-NFPD2P3V.js";
-import {
-  file_map_stamp
-} from "./chunk-CGLLAEKZ.js";
-import {
-  run_record_path
-} from "./chunk-WL5JHB3I.js";
-import {
-  hook_decision
-} from "./chunk-RLBFEHHC.js";
-
-// scripts/gate/scoped-green.ts
-var SWITCH_ENV_KEY = "JOSH_SCOPED_GREEN";
-var SUCCESS_EXIT_CODE = 0;
-var LINT_SCRIPT = "lint:related";
-var TEST_SCRIPT = "test:related";
-var LINT_COMMAND = `pnpm josh ${LINT_SCRIPT}`;
-var TEST_COMMAND = `pnpm josh ${TEST_SCRIPT}`;
-function checks_of(sources) {
-  const lint = {
-    script: LINT_SCRIPT,
-    command: LINT_COMMAND,
-    stamp: review_stamps.lint_related_stamp,
-    source: sources.lint
-  };
-  const test = {
-    script: TEST_SCRIPT,
-    command: TEST_COMMAND,
-    stamp: review_stamps.test_related_stamp,
-    source: sources.test
-  };
-  return sources.is_unit_skipped ?? test_unit_guard.is_skipping(process.cwd()) ? [lint] : [lint, test];
-}
-function describes_tree(check, tree, base, is_overlooked = run_record_path.is_run_record) {
-  const stamp = check.stamp.read(check.source);
-  return stamp !== void 0 && file_map_stamp.changed_since(stamp, tree).every((relative) => is_overlooked(relative)) && file_map_stamp.describes_base(stamp, base) && check.stamp.describes_inputs(stamp);
-}
-function is_describable(files, base) {
-  return base !== void 0 && Object.keys(files).length > 0;
-}
-function is_answerable(tree, base) {
-  if (!hook_decision.is_switch_enabled(SWITCH_ENV_KEY)) return false;
-  return is_describable(tree, base);
-}
-function stale_checks(tree, base, sources) {
-  if (!is_answerable(tree, base)) return [];
-  return checks_of(sources).filter((check) => !describes_tree(check, tree, base));
-}
-function missing_checks(tree, base, sources = {}) {
-  return stale_checks(tree, base, sources).map((check) => check.command);
-}
-function missing_scripts(tree, base, sources = {}) {
-  return stale_checks(tree, base, sources).map((check) => check.script);
-}
-function overlooks_nothing() {
-  return false;
-}
-function green_scripts(tree, base, sources = {}) {
-  if (!is_answerable(tree, base)) return [];
-  return checks_of(sources).filter((check) => describes_tree(check, tree, base, overlooks_nothing)).map((check) => check.script);
-}
-var REFUSAL_HEADLINE = "\u26D4 scoped checks not green on this tree";
-var REISSUE_STEP = "and reissue this command.";
-var LANE_CHILD_STEP = 'then hand over to `pnpm josh ship --detach --review "<title> #<N>"` rather than reissuing the gate \u2014 this is a dispatched lane child, and ship runs the gate beside the review (`.claude/skills/workflow-commands/chain-rule.md` step 0).';
-function refusal(missing, next_step) {
-  return `${REFUSAL_HEADLINE}: ${missing.join(" and ")} have not passed on the files this branch changed. The gate and review round 1 start together, so a brief composed now describes a tree neither check has read \u2014 joshuafolkken/kit#1503 spent 282 seconds, 31% of the run, picking up one lint rule and one failing test at a time after its review had already started. Run them in one call \u2014 \`${LINT_COMMAND} && ${TEST_COMMAND}\`, measured at 13.8 seconds \u2014 ${next_step} The record fixes when the checks run: only a merge with the default branch sharing nothing with this branch's change is recorded without a run. \`.claude/skills/workflow-commands/chain-rule.md\` \u2192 "Orchestration facts single-sourced here".`;
-}
-function next_step_of(sources) {
-  return sources.is_lane_child === true ? LANE_CHILD_STEP : REISSUE_STEP;
-}
-function refusal_for(tree, base, sources = {}) {
-  const missing = missing_checks(tree, base, sources);
-  return missing.length === 0 ? void 0 : refusal(missing, next_step_of(sources));
-}
-function is_recordable_scope(command_arguments) {
-  return command_arguments.length === 0;
-}
-async function read_before(command_arguments) {
-  if (!is_recordable_scope(command_arguments)) return void 0;
-  return await gate_tree.read_gate_tree();
-}
-function is_unmoved(before, after) {
-  if (before.base !== after.base) return false;
-  return JSON.stringify(before.files) === JSON.stringify(after.files);
-}
-function record_green(stamp, tree, target, blobs) {
-  if (!is_describable(tree.files, tree.base)) return;
-  try {
-    stamp.write(tree.files, target, tree.base, blobs);
-  } catch {
-  }
-}
-async function record_if_green(stamp, record) {
-  const { before, exit_code, target } = record;
-  if (before === void 0 || exit_code !== SUCCESS_EXIT_CODE || !is_unmoved(before, await gate_tree.read_gate_tree())) {
-    return;
-  }
-  record_green(stamp, before, target, record.blobs);
-}
-var scoped_green = {
-  LINT_COMMAND,
-  LINT_SCRIPT,
-  REFUSAL_HEADLINE,
-  SWITCH_ENV_KEY,
-  TEST_COMMAND,
-  TEST_SCRIPT,
-  green_scripts,
-  is_recordable_scope,
-  is_unmoved,
-  missing_checks,
-  missing_scripts,
-  read_before,
-  record_green,
-  record_if_green,
-  refusal_for
-};
-
-export {
-  scoped_green
-};

package/dist/commands/chunk-WWVYEHQT.js

@@ -1,272 +0,0 @@
-import {
-  LEDGER_FILE_EXTENSION,
-  LEGACY_LEDGER_FILE,
-  LEGACY_OBSERVATION_LEDGER_DIRECTORY,
-  LEGACY_OBSERVATION_LEDGER_PATHS,
-  MIGRATION_CLAIM_SUFFIX,
-  OBSERVATION_LEDGER_DIRECTORY,
-  observation_ledger
-} from "./chunk-SV4FZR24.js";
-import {
-  git_branch
-} from "./chunk-Q5Q2QYVU.js";
-import {
-  process_identity
-} from "./chunk-AKK56GNX.js";
-import {
-  git_spawn
-} from "./chunk-CJKPF5DJ.js";
-import {
-  file_reader
-} from "./chunk-ZNX2LJCQ.js";
-
-// scripts/observations/observation-ledger-line.ts
-var KEY_PREFIX = "- k:";
-var FIELD_SEPARATOR = " | ";
-var FIELD_COUNT = 5;
-var SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
-var DEPTH_PATTERN = /^d[1-9]\d*$/u;
-var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
-var SLUG_REASON = "the slug must be lowercase words joined by `-`";
-var DEPTH_REASON = "the depth must be `d1` or higher (never `d0`)";
-var DATE_REASON = "the date must be `YYYY-MM-DD`";
-var WHERE_REASON = "the `where` field is empty";
-var WHAT_REASON = "the `what` field is empty";
-function is_ledger_entry_line(line) {
-  return line.trimStart().startsWith(KEY_PREFIX);
-}
-function slug_of(first_field) {
-  return first_field.trimStart().slice(KEY_PREFIX.length);
-}
-function is_present(field = "") {
-  return field.trim().length > 0;
-}
-function matches(pattern, field = "") {
-  return pattern.test(field);
-}
-function slug_ok(key_field = "") {
-  return SLUG_PATTERN.test(slug_of(key_field));
-}
-function field_reason(fields) {
-  const [key_field, depth, date, where, what] = fields;
-  const checks = [
-    [slug_ok(key_field), SLUG_REASON],
-    [matches(DEPTH_PATTERN, depth), DEPTH_REASON],
-    [matches(DATE_PATTERN, date), DATE_REASON],
-    [is_present(where), WHERE_REASON],
-    [is_present(what), WHAT_REASON]
-  ];
-  return checks.find(([is_valid]) => !is_valid)?.[1];
-}
-function line_reason(line) {
-  const fields = line.split(FIELD_SEPARATOR);
-  if (fields.length !== FIELD_COUNT) {
-    return `expected ${String(FIELD_COUNT)} fields separated by " | " (a \`|\` in the last field is not allowed)`;
-  }
-  return field_reason(fields);
-}
-function broken_ledger_lines(content) {
-  return content.split("\n").filter((line) => is_ledger_entry_line(line)).map((line) => ({ line, reason: line_reason(line) })).filter((entry) => entry.reason !== void 0);
-}
-function missing_lines(candidates, ledger) {
-  const present = new Set(ledger.split("\n"));
-  return candidates.filter((line) => !present.has(line));
-}
-var observation_ledger_line = {
-  broken_ledger_lines,
-  is_ledger_entry_line,
-  line_reason,
-  missing_lines
-};
-
-// scripts/observations/observation-ledger-home.ts
-import { appendFile, mkdir, readdir, readFile } from "node:fs/promises";
-import path2 from "node:path";
-
-// scripts/observations/observation-ledger-migrate.ts
-import {
-  appendFileSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  renameSync,
-  rmdirSync,
-  rmSync
-} from "node:fs";
-import path from "node:path";
-var NEWLINE = "\n";
-function claim_path(legacy) {
-  return `${legacy}.${String(process.pid)}${MIGRATION_CLAIM_SUFFIX}`;
-}
-function claim(from, to) {
-  try {
-    renameSync(from, to);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function is_stale_claim(name, legacy_name) {
-  const prefix = `${legacy_name}.`;
-  if (!name.startsWith(prefix) || !name.endsWith(MIGRATION_CLAIM_SUFFIX)) return false;
-  const pid = Number(name.slice(prefix.length, -MIGRATION_CLAIM_SUFFIX.length));
-  return Number.isSafeInteger(pid) && !process_identity.is_present_pid(pid);
-}
-function stale_claims(legacy) {
-  const directory = path.dirname(legacy);
-  try {
-    return readdirSync(directory).filter((name) => is_stale_claim(name, path.basename(legacy))).map((name) => path.join(directory, name));
-  } catch {
-    return [];
-  }
-}
-function terminated(content) {
-  return content.length === 0 || content.endsWith(NEWLINE) ? content : `${content}${NEWLINE}`;
-}
-function carried(content, ledger) {
-  if (ledger === void 0) return terminated(content);
-  const lines = content.split(NEWLINE).filter((line) => line.length > 0);
-  const missing = observation_ledger_line.missing_lines(lines, ledger);
-  return missing.length === 0 ? "" : `${missing.join(NEWLINE)}${NEWLINE}`;
-}
-function absorb(claimed, target) {
-  mkdirSync(path.dirname(target), { recursive: true });
-  appendFileSync(
-    target,
-    carried(readFileSync(claimed, "utf8"), file_reader.read_if_readable(target)),
-    "utf8"
-  );
-  rmSync(claimed);
-}
-function absorb_stale(legacy, target) {
-  let count = 0;
-  for (const stale of stale_claims(legacy)) {
-    const claimed = claim_path(legacy);
-    if (!claim(stale, claimed)) continue;
-    absorb(claimed, target);
-    count += 1;
-  }
-  return count;
-}
-function migrate_one(legacy, target) {
-  const recovered = absorb_stale(legacy, target);
-  const claimed = claim_path(legacy);
-  if (!claim(legacy, claimed)) return recovered > 0;
-  absorb(claimed, target);
-  return true;
-}
-function source_name(name) {
-  const end = name.indexOf(LEDGER_FILE_EXTENSION);
-  return end === -1 ? void 0 : name.slice(0, end + LEDGER_FILE_EXTENSION.length);
-}
-function legacy_directory_names(directory) {
-  try {
-    const names = readdirSync(directory).map((name) => source_name(name));
-    return [...new Set(names.filter((name) => name !== void 0))];
-  } catch {
-    return [];
-  }
-}
-function migrate_directory(root) {
-  const legacy_directory = path.join(root, LEGACY_OBSERVATION_LEDGER_DIRECTORY);
-  const did_move = legacy_directory_names(legacy_directory).map(
-    (name) => migrate_one(
-      path.join(legacy_directory, name),
-      path.join(root, OBSERVATION_LEDGER_DIRECTORY, name)
-    )
-  ).some(Boolean);
-  try {
-    rmdirSync(legacy_directory);
-  } catch {
-  }
-  return did_move;
-}
-function migrate(root) {
-  const target = path.join(root, OBSERVATION_LEDGER_DIRECTORY, LEGACY_LEDGER_FILE);
-  const moved_files = LEGACY_OBSERVATION_LEDGER_PATHS.map(
-    (legacy) => migrate_one(path.join(root, legacy), target)
-  );
-  return [...moved_files, migrate_directory(root)].some(Boolean);
-}
-var observation_ledger_migrate = { migrate };
-
-// scripts/observations/observation-ledger-home.ts
-var DATE_END = 10;
-function ledger_root(cwd = process.cwd()) {
-  return cwd;
-}
-function ledger_directory(cwd = process.cwd()) {
-  const root = ledger_root(cwd);
-  observation_ledger_migrate.migrate(root);
-  return path2.join(root, OBSERVATION_LEDGER_DIRECTORY);
-}
-function file_path(name, cwd) {
-  ledger_directory(cwd);
-  return path2.join(ledger_root(cwd), observation_ledger.ledger_file(name));
-}
-function issue_path(issue, cwd = process.cwd()) {
-  return file_path(issue, cwd);
-}
-async function current_branch(cwd) {
-  try {
-    return await git_spawn.read(["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"]);
-  } catch {
-    return "";
-  }
-}
-function ledger_date(now) {
-  return now.toISOString().slice(0, DATE_END);
-}
-async function writer_path(now, cwd = process.cwd()) {
-  const issue = git_branch.issue_from_branch(await current_branch(cwd));
-  return file_path(issue ?? ledger_date(now), cwd);
-}
-async function read_file(target, is_strict) {
-  try {
-    const content = await readFile(target, "utf8");
-    return content.length === 0 || content.endsWith("\n") ? content : `${content}
-`;
-  } catch (error) {
-    if (is_strict) throw error;
-    return "";
-  }
-}
-async function ledger_files(directory, is_strict) {
-  try {
-    const names = await readdir(directory);
-    return names.filter((name) => observation_ledger.is_ledger_file_name(name)).toSorted((left, right) => left.localeCompare(right));
-  } catch (error) {
-    if (is_strict) throw error;
-    return void 0;
-  }
-}
-async function read(cwd = process.cwd(), is_strict = false) {
-  const directory = ledger_directory(cwd);
-  const files = await ledger_files(directory, is_strict);
-  if (files === void 0) return void 0;
-  const contents = await Promise.all(
-    files.map(async (name) => await read_file(path2.join(directory, name), is_strict))
-  );
-  return contents.join("");
-}
-async function append(target, lines) {
-  if (lines.length === 0) return;
-  await mkdir(path2.dirname(target), { recursive: true });
-  await appendFile(target, `${lines.join("\n")}
-`, "utf8");
-}
-var observation_ledger_home = {
-  append,
-  file_path,
-  issue_path,
-  ledger_date,
-  ledger_root,
-  read,
-  read_file,
-  writer_path
-};
-
-export {
-  observation_ledger_line,
-  observation_ledger_home
-};

package/dist/commands/chunk-X3TNPALI.js

@@ -1,213 +0,0 @@
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  process_identity
-} from "./chunk-AKK56GNX.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  agent_session_environment
-} from "./chunk-HHBC6QZE.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/josh/stamp-record.ts
-var NONE_READ = { kind: "none" };
-var UNREADABLE_READ = { kind: "unreadable" };
-function is_older_than(iso, max_age_ms, now) {
-  const at = Date.parse(iso);
-  if (Number.isNaN(at)) return true;
-  return now.getTime() - at > max_age_ms;
-}
-function classify(raw, spec, now) {
-  if (raw === void 0) return NONE_READ;
-  const record = spec.parse(raw);
-  if (record === void 0) return UNREADABLE_READ;
-  const is_expired2 = is_older_than(spec.timestamp_of(record), spec.max_age_ms, now);
-  return { kind: is_expired2 ? "expired" : "carried", record };
-}
-var stamp_record = { classify, is_older_than };
-
-// scripts/run/hold/run-hold.ts
-import { z } from "zod";
-var HOLD_PREFIX = "josh-run-hold-";
-var UNNUMBERED_ISSUE = "new";
-var HOLD_MAX_AGE_HOURS = 8;
-var MILLISECONDS_PER_HOUR = 36e5;
-var HOLD_MAX_AGE_MS = HOLD_MAX_AGE_HOURS * MILLISECONDS_PER_HOUR;
-var RELEASE_COMMAND = "pnpm josh run:release";
-var FORCE_RELEASE_COMMAND = `${RELEASE_COMMAND} --force`;
-var NOT_IDLE = 'that is not "nothing is running here"';
-var FREE_READ = { kind: "free" };
-var UNREADABLE_READ2 = { kind: "unreadable" };
-function hold_path(git_directory) {
-  return stamp_file.stamp_path(HOLD_PREFIX, git_directory);
-}
-async function worktree_directory() {
-  const directories = await git_command.git_directories();
-  return directories[0];
-}
-async function is_linked_worktree() {
-  const directories = await git_command.git_directories();
-  return directories[0] !== void 0 && directories[0] !== directories[1];
-}
-var run_hold_schema = z.object({
-  issue: z.string(),
-  taken_at: z.string(),
-  pid: z.number(),
-  is_fullrun: z.boolean().optional(),
-  is_halfrun_stop: z.boolean().optional(),
-  prrun_stop_head: z.string().optional(),
-  owner_pid: z.number().optional(),
-  owner_start: z.string().optional(),
-  notified_at: z.string().optional()
-});
-function parse_hold(raw) {
-  return json_value.parse_with(raw, run_hold_schema);
-}
-function is_expired(hold, now) {
-  return stamp_record.is_older_than(hold.taken_at, HOLD_MAX_AGE_MS, now);
-}
-function is_stop_marked(hold) {
-  return hold.is_halfrun_stop === true || hold.prrun_stop_head !== void 0;
-}
-function is_owner_gone(hold) {
-  if (is_stop_marked(hold) || hold.owner_pid === void 0) return false;
-  return process_identity.is_same_process(hold.owner_pid, hold.owner_start) === false;
-}
-function is_stale(hold, now) {
-  return is_expired(hold, now) || is_owner_gone(hold);
-}
-function classify2(raw, now) {
-  if (raw === void 0) return FREE_READ;
-  const hold = parse_hold(raw);
-  if (hold === void 0) return UNREADABLE_READ2;
-  return { kind: is_stale(hold, now) ? "stale" : "held", hold };
-}
-function read_hold(target, now = /* @__PURE__ */ new Date()) {
-  return classify2(stamp_file.read_stamp_text(target), now);
-}
-function session_owner(environment = process.env) {
-  const pid = agent_session_environment.session_pid(environment);
-  if (pid === void 0) return {};
-  return { owner_pid: pid, owner_start: process_identity.read_start(pid) };
-}
-function build_hold(issue, now, is_fullrun) {
-  return { issue, taken_at: now.toISOString(), pid: process.pid, is_fullrun, ...session_owner() };
-}
-function write_hold(target, issue, now = /* @__PURE__ */ new Date()) {
-  const hold = build_hold(issue, now);
-  stamp_file.write_stamp(target, hold);
-  return hold;
-}
-function create_hold(target, issue, now = /* @__PURE__ */ new Date(), is_fullrun) {
-  return stamp_file.create_stamp(target, build_hold(issue, now, is_fullrun));
-}
-var HALFRUN_STOP_FIELDS = { is_halfrun_stop: true };
-function create_stop_hold(target, issue, mark, now = /* @__PURE__ */ new Date()) {
-  return stamp_file.create_stamp(target, { ...build_hold(issue, now), ...mark });
-}
-function create_halfrun_stop_hold(target, issue, now = /* @__PURE__ */ new Date()) {
-  return create_stop_hold(target, issue, HALFRUN_STOP_FIELDS, now);
-}
-async function is_tree_dirty(directory) {
-  try {
-    const status = await git_command.status(directory);
-    return status.trim() !== "";
-  } catch (error) {
-    error_text.trace_swallowed("run_hold.is_tree_dirty", error);
-    return true;
-  }
-}
-function release_hold(target) {
-  stamp_file.remove_stamp(target);
-}
-function describe_holder(hold) {
-  const holder = hold.issue === UNNUMBERED_ISSUE ? "an unnumbered run" : session_cite.issue(hold.issue);
-  return `${holder}, recorded ${hold.taken_at} (pid ${String(hold.owner_pid ?? hold.pid)})`;
-}
-function own_release_command(issue) {
-  return issue === UNNUMBERED_ISSUE ? RELEASE_COMMAND : `${RELEASE_COMMAND} ${issue}`;
-}
-function is_own_hold(hold, claimant) {
-  return hold.issue === claimant;
-}
-function is_reentry(hold, claimant) {
-  return claimant !== UNNUMBERED_ISSUE && is_own_hold(hold, claimant);
-}
-function held_message(hold) {
-  return `This working tree is already held by ${describe_holder(hold)}. One run at a time per working tree: a second run here commits its files onto the other run's branch. If that record is stale, run \`${FORCE_RELEASE_COMMAND}\` in this working tree \u2014 it removes a record this run did not write, so be sure the run that did has ended \u2014 and ask again.`;
-}
-function foreign_release_message(hold) {
-  return `This working tree is held by ${describe_holder(hold)}, and this release did not claim it \u2014 nothing was removed. Release it as that run with \`${own_release_command(hold.issue)}\`, or, once you are sure it has ended, remove the record with \`${FORCE_RELEASE_COMMAND}\`.`;
-}
-function forced_release_message(hold) {
-  return `Forced: removed the run record held by ${describe_holder(hold)}.`;
-}
-function unreadable_message() {
-  return `This working tree's run record could not be read \u2014 ${NOT_IDLE}. Run \`${FORCE_RELEASE_COMMAND}\` in this working tree to clear it, then ask again.`;
-}
-function stale_reason(hold) {
-  return is_owner_gone(hold) ? "the session that wrote it has ended" : `older than ${String(HOLD_MAX_AGE_HOURS)} hours`;
-}
-function stale_message(hold) {
-  return `Replaced a stale run record held by ${describe_holder(hold)}: ${stale_reason(hold)}, so the run that wrote it has ended without releasing it.`;
-}
-function uncommitted_message(hold) {
-  return `This working tree still has uncommitted changes, and its run record \u2014 held by ${describe_holder(hold)} \u2014 has expired or outlived its session. That is a run which stopped for a person rather than one that finished, so the tree is not free: commit or stash the work, or run \`${own_release_command(hold.issue)}\` once you are done with it, then ask again.`;
-}
-function race_message(read, target) {
-  if (read.kind === "held") return held_message(read.hold);
-  return `A record already exists at ${target} and this run did not write it \u2014 ${NOT_IDLE}. Either another run claimed the tree at the same moment, or the record belongs to another account. Run \`${FORCE_RELEASE_COMMAND}\`, and remove that file by hand if it is still there.`;
-}
-function unknown_message() {
-  return `Could not read this working tree's git directory \u2014 ${NOT_IDLE}. Run this from inside the checkout the run will edit.`;
-}
-var run_hold = {
-  is_stop_marked,
-  FORCE_RELEASE_COMMAND,
-  HOLD_MAX_AGE_HOURS,
-  HOLD_MAX_AGE_MS,
-  RELEASE_COMMAND,
-  UNNUMBERED_ISSUE,
-  classify: classify2,
-  create_halfrun_stop_hold,
-  create_stop_hold,
-  HALFRUN_STOP_FIELDS,
-  create_hold,
-  describe_holder,
-  foreign_release_message,
-  forced_release_message,
-  held_message,
-  hold_path,
-  is_linked_worktree,
-  is_own_hold,
-  is_reentry,
-  is_tree_dirty,
-  own_release_command,
-  race_message,
-  read_hold,
-  release_hold,
-  session_owner,
-  stale_message,
-  stale_reason,
-  uncommitted_message,
-  unknown_message,
-  unreadable_message,
-  worktree_directory,
-  write_hold
-};
-
-export {
-  stamp_record,
-  run_hold
-};

package/dist/commands/chunk-XC6GG5JR.js

@@ -1,78 +0,0 @@
-import {
-  lane_stop_stats
-} from "./chunk-MWO6FOSZ.js";
-import {
-  lane_stage_stats
-} from "./chunk-IBAYXCMU.js";
-import {
-  lane_stats
-} from "./chunk-XXC32PVL.js";
-import {
-  run_event_stream
-} from "./chunk-NSAVEXVR.js";
-
-// scripts/lane/lane-cut-stats.ts
-var CUT_PHASE = /cut \(([^)]+)\)$/u;
-var UNKNOWN_PHASE = "unknown";
-var ALL = "all";
-var COLUMNS = ["cuts", "per lane median", "per lane max", "total"];
-function cuts_of(events) {
-  return events.filter((event) => event.kind === run_event_stream.EVENT_KIND.CUT).map((event) => ({
-    issue: lane_stop_stats.issue_of(event),
-    phase: CUT_PHASE.exec(event.text)?.[1] ?? UNKNOWN_PHASE
-  }));
-}
-function phases_of(cuts) {
-  return [...new Set(cuts.map((cut) => cut.phase))].toSorted(
-    (left, right) => left.localeCompare(right)
-  );
-}
-function count_text(name, count) {
-  return `${name} \xD7${String(count)}`;
-}
-function line(events, issue) {
-  const cuts = cuts_of(events).filter((cut) => cut.issue === issue);
-  if (cuts.length === 0) return void 0;
-  const causes = phases_of(cuts).map(
-    (phase) => count_text(phase, cuts.filter((cut) => cut.phase === phase).length)
-  );
-  return `${count_text("run:cut", cuts.length)} (${causes.join(", ")})`;
-}
-function lanes_of(entries, cuts) {
-  const dispatched = entries.filter((entry) => lane_stage_stats.is_dispatch(entry));
-  return [.../* @__PURE__ */ new Set([...dispatched.map((entry) => entry.issue), ...cuts.map((cut) => cut.issue)])];
-}
-function count_cell(value) {
-  return value === void 0 ? lane_stats.MISSING : String(value);
-}
-function row(name, lanes, cuts) {
-  const per_lane = lanes.map((issue) => cuts.filter((cut) => cut.issue === issue).length);
-  return lane_stats.to_row([
-    name,
-    count_cell(lane_stats.median(per_lane)),
-    count_cell(lane_stats.peak(per_lane)),
-    String(cuts.length)
-  ]);
-}
-function table(entries, window, events) {
-  const cuts = cuts_of(lane_stats.in_window(events, window));
-  const lanes = lanes_of(lane_stats.in_window(entries, window), cuts);
-  const phase_rows = phases_of(cuts).map(
-    (phase) => row(
-      phase,
-      lanes,
-      cuts.filter((cut) => cut.phase === phase)
-    )
-  );
-  return [
-    lane_stats.to_row(COLUMNS),
-    lane_stats.to_row(COLUMNS.map(() => "---")),
-    row(ALL, lanes, cuts),
-    ...phase_rows
-  ].join("\n");
-}
-var lane_cut_stats = { line, table };
-
-export {
-  lane_cut_stats
-};