@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-736NECRD.js

@@ -0,0 +1,16 @@
+import {
+  git_gh_issue_write
+} from "./chunk-4F4KARQN.js";
+
+// scripts/issue/issue-park.ts
+async function apply(issue, label, body) {
+  const is_labelled = await git_gh_issue_write.issue_add_label(issue, label);
+  if (!is_labelled) return { is_labelled, is_commented: false };
+  const is_commented = await git_gh_issue_write.issue_try_comment(issue, body);
+  return { is_labelled, is_commented };
+}
+var issue_park = { apply };
+
+export {
+  issue_park
+};

package/dist/commands/chunk-77LEKVEE.js

@@ -0,0 +1,32 @@
+import {
+  time_transcript_line
+} from "./chunk-YSLGWRQN.js";
+import {
+  cost_blocks,
+  time_shell
+} from "./chunk-LHKXJD6L.js";
+
+// scripts/rules/tail-commands.ts
+function is_bash_use(block) {
+  return block.type === cost_blocks.TOOL_USE_TYPE && block.name === cost_blocks.BASH_TOOL;
+}
+function bash_commands_of(line) {
+  const parsed = time_transcript_line.parse_line(line);
+  if (parsed === void 0) return [];
+  return parsed.blocks.filter((block) => is_bash_use(block)).map((block) => time_shell.bash_command(block.input));
+}
+function prior_bash_commands(tail) {
+  return tail.split("\n").flatMap((line) => bash_commands_of(line));
+}
+function answered(text, is_call, token) {
+  const blocks = time_transcript_line.parse_text(text).flatMap((line) => line.blocks);
+  const call_ids = new Set(
+    blocks.filter((block) => is_call(time_shell.bash_command(block.input))).map((block) => block.id)
+  );
+  return blocks.some((block) => call_ids.has(block.result_id) && block.token_lines.includes(token));
+}
+var tail_commands = { answered, is_bash_use, prior_bash_commands };
+
+export {
+  tail_commands
+};

package/dist/commands/chunk-7CX5VYOL.js

@@ -0,0 +1,50 @@
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+
+// scripts/run/handoff/run-handoff-args.ts
+var BRIEF_FLAG = "--brief-file";
+var BACKLOG_KEYWORD = "backlogrun";
+var NOT_FOUND = -1;
+var FLAG_AND_VALUE = 2;
+var RETROSPECTIVE_KEYWORD = "retrospective";
+var TYPED_KEYWORDS = ["kickoff", "fullrun", "halfrun", "prrun"];
+var WORKFLOW_KEYWORDS = [...TYPED_KEYWORDS, RETROSPECTIVE_KEYWORD];
+var KEYWORDS = [...TYPED_KEYWORDS, BACKLOG_KEYWORD];
+var WORKFLOW_KEYWORD_TOKENS = WORKFLOW_KEYWORDS;
+function is_workflow_keyword(token) {
+  return WORKFLOW_KEYWORD_TOKENS.includes(token);
+}
+function refused(note) {
+  return { kind: "refused", note };
+}
+function workflow_of(keyword, rest) {
+  const at = rest.indexOf(BRIEF_FLAG);
+  const brief_file = at === NOT_FOUND ? void 0 : rest[at + 1];
+  if (brief_file === void 0 || brief_file.startsWith("-")) {
+    return refused(`${keyword} needs ${BRIEF_FLAG} <path>`);
+  }
+  const entry = [...rest.slice(0, at), ...rest.slice(at + FLAG_AND_VALUE)];
+  if (entry.includes(BRIEF_FLAG)) return refused(`${BRIEF_FLAG} is given more than once`);
+  const line = [keyword, ...entry.map((token) => issue_number_shape.issue_token(token))].join(" ");
+  return { kind: "workflow", keyword, line, brief_file };
+}
+function retrospective_of(rest) {
+  if (rest.length > 0) return refused(`${RETROSPECTIVE_KEYWORD} takes no other argument`);
+  const keyword = RETROSPECTIVE_KEYWORD;
+  return { kind: "workflow", keyword, line: keyword, brief_file: void 0 };
+}
+function parse(argv) {
+  const [keyword, ...rest] = argv;
+  if (keyword === BACKLOG_KEYWORD) return { kind: "backlogrun", rest };
+  if (keyword === RETROSPECTIVE_KEYWORD) return retrospective_of(rest);
+  if (!is_workflow_keyword(keyword)) {
+    return refused(`expected one of ${WORKFLOW_KEYWORDS.join(", ")}, ${BACKLOG_KEYWORD}`);
+  }
+  return workflow_of(keyword, rest);
+}
+var run_handoff_args = { BACKLOG_KEYWORD, KEYWORDS, RETROSPECTIVE_KEYWORD, parse };
+
+export {
+  run_handoff_args
+};

package/dist/commands/chunk-7DGHFBU7.js

@@ -0,0 +1,247 @@
+import {
+  git_common_directory
+} from "./chunk-JPMAW2VZ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/security/security-audit-logic.ts
+import path from "node:path";
+var BINARY_NAME = "osv-scanner";
+var LOCKFILE_PATH = "pnpm-lock.yaml";
+var MANAGED_TOOL_SEGMENTS = ["node_modules", ".cache", "josh-tools"];
+var WINDOWS_PLATFORM = "win32";
+var WINDOWS_BINARY_SUFFIX = ".exe";
+var INSTALL_INSTRUCTIONS = [
+  "",
+  "Install options:",
+  "  Managed: pnpm josh audit:provision",
+  "  macOS:  brew install osv-scanner",
+  "  Go:     go install github.com/google/osv-scanner/v2/cmd/osv-scanner@latest",
+  '  Docker: docker run --rm -v "$PWD:/src" ghcr.io/google/osv-scanner --lockfile=/src/pnpm-lock.yaml',
+  "",
+  "Docs: https://google.github.io/osv-scanner/"
+].join("\n");
+function build_scanner_arguments(lockfile_path) {
+  return [`--lockfile=${lockfile_path}`];
+}
+function build_managed_binary_path(project_root, platform) {
+  const suffix = platform === WINDOWS_PLATFORM ? WINDOWS_BINARY_SUFFIX : "";
+  return path.join(project_root, ...MANAGED_TOOL_SEGMENTS, `${BINARY_NAME}${suffix}`);
+}
+function format_missing_binary_error(binary_name) {
+  return `${binary_name} is not installed.
+${INSTALL_INSTRUCTIONS}`;
+}
+var security_audit_logic = {
+  BINARY_NAME,
+  LOCKFILE_PATH,
+  build_managed_binary_path,
+  build_scanner_arguments,
+  format_missing_binary_error
+};
+
+// scripts/security/security-audit-provision-logic.ts
+var SCANNER_VERSION = "2.6.0";
+var MINIMUM_SCANNER_VERSION = SCANNER_VERSION;
+var RELEASE_BASE_URL = "https://github.com/google/osv-scanner/releases/download";
+var WINDOWS_PLATFORM2 = "win32";
+var WINDOWS_ASSET_SUFFIX = ".exe";
+var SESSION_DOWNLOAD_TIMEOUT_MS = 6e4;
+var FORCED_DOWNLOAD_TIMEOUT_MS = 6e5;
+function build_download_timeout(is_forced) {
+  return is_forced ? FORCED_DOWNLOAD_TIMEOUT_MS : SESSION_DOWNLOAD_TIMEOUT_MS;
+}
+var MS_PER_HOUR = 36e5;
+var HOURS_BEFORE_RETRY = 6;
+var RETRY_INTERVAL_MS = HOURS_BEFORE_RETRY * MS_PER_HOUR;
+var PLATFORM_NAMES = {
+  darwin: "darwin",
+  linux: "linux",
+  win32: "windows"
+};
+var ARCHITECTURE_NAMES = {
+  arm64: "arm64",
+  x64: "amd64"
+};
+var ASSET_CHECKSUMS = {
+  "osv-scanner_darwin_amd64": "60c5296637e977b28eeda5c7f13573e447659a632922737f94d11fa7e30ad6ca",
+  "osv-scanner_darwin_arm64": "98c460dcd37de25819babd757d04542045b6243113e209edcd4d89fedb0256b4",
+  "osv-scanner_linux_amd64": "ca69b3d3cd08f889a49dc0a383122f71cc528b83803671df5fd874d97485b108",
+  "osv-scanner_linux_arm64": "2c71403eb443d05891c4f268c3ad771cf4f16e5443463fd7851ef8f454d3c7e4",
+  "osv-scanner_windows_amd64.exe": "e0ed7644118b717b028c249ee9d3515024e55e8510747ca08906eb96765354d6",
+  "osv-scanner_windows_arm64.exe": "ca1379da0e408279ef2c85cde0846a903495738a91c7b065a208048437c1686c"
+};
+function build_asset_name(platform, architecture) {
+  const platform_name = PLATFORM_NAMES[platform];
+  const architecture_name = ARCHITECTURE_NAMES[architecture];
+  if (platform_name === void 0 || architecture_name === void 0) return void 0;
+  const suffix = platform === WINDOWS_PLATFORM2 ? WINDOWS_ASSET_SUFFIX : "";
+  return `${security_audit_logic.BINARY_NAME}_${platform_name}_${architecture_name}${suffix}`;
+}
+function build_download_url(asset_name) {
+  return `${RELEASE_BASE_URL}/v${SCANNER_VERSION}/${asset_name}`;
+}
+function resolve_asset(platform, architecture) {
+  const name = build_asset_name(platform, architecture);
+  if (name === void 0) return void 0;
+  const sha256 = ASSET_CHECKSUMS[name];
+  if (sha256 === void 0) return void 0;
+  return { name, sha256, url: build_download_url(name) };
+}
+function format_already_present(location) {
+  return `osv-scanner is already available (${location}); nothing to provision.`;
+}
+function format_unsupported_platform(platform, architecture) {
+  return `No pinned osv-scanner build for ${platform}/${architecture}; install it manually to run the pre-push audit.`;
+}
+function format_download_failure(url, reason) {
+  return `Could not fetch osv-scanner from ${url}: ${reason}. Run \`pnpm josh audit:provision --force\` to retry with a longer timeout; until then the pre-push audit will report the missing binary.`;
+}
+function format_checksum_mismatch(asset_name, expected, actual) {
+  return `Checksum mismatch for ${asset_name}: expected ${expected}, got ${actual}. Nothing was installed.`;
+}
+function format_installed(target_path) {
+  return `Installed osv-scanner v${SCANNER_VERSION} at ${target_path}.`;
+}
+function format_recent_failure() {
+  return `A previous attempt to provision osv-scanner failed less than ${String(HOURS_BEFORE_RETRY)} hours ago; not retrying at session start. Run \`pnpm josh audit:provision --force\` to try again now.`;
+}
+function format_provision_error(reason) {
+  return `Could not provision osv-scanner: ${reason}. The pre-push audit will report the missing binary.`;
+}
+var SCANNER_VERSION_PATTERN = /osv-scanner version:\s*(\d+\.\d+\.\d+)/u;
+function parse_scanner_version(version_output) {
+  return SCANNER_VERSION_PATTERN.exec(version_output)?.[1];
+}
+function to_version_parts(version) {
+  return version.split(".").map(Number);
+}
+function compare_versions(left, right) {
+  const left_parts = to_version_parts(left);
+  const right_parts = to_version_parts(right);
+  const length = Math.max(left_parts.length, right_parts.length);
+  for (let index = 0; index < length; index += 1) {
+    const difference = (left_parts[index] ?? 0) - (right_parts[index] ?? 0);
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}
+function meets_version_floor(version) {
+  return compare_versions(version, MINIMUM_SCANNER_VERSION) >= 0;
+}
+function format_below_floor(version) {
+  return `osv-scanner ${version} is below the required v${MINIMUM_SCANNER_VERSION}; older builds parse only part of pnpm-lock.yaml, so a clean result here is not proof the lockfile is clean. Run \`pnpm josh audit:provision --force\` to install v${SCANNER_VERSION}.`;
+}
+var security_audit_provision_logic = {
+  RETRY_INTERVAL_MS,
+  SESSION_DOWNLOAD_TIMEOUT_MS,
+  SCANNER_VERSION,
+  MINIMUM_SCANNER_VERSION,
+  build_asset_name,
+  build_download_timeout,
+  build_download_url,
+  format_already_present,
+  format_below_floor,
+  format_checksum_mismatch,
+  format_download_failure,
+  format_installed,
+  format_provision_error,
+  format_recent_failure,
+  format_unsupported_platform,
+  meets_version_floor,
+  parse_scanner_version,
+  resolve_asset
+};
+
+// scripts/security/security-audit.ts
+import { accessSync, constants, statSync } from "node:fs";
+import path2 from "node:path";
+import { execaSync } from "execa";
+var FAILURE_EXIT_CODE = 1;
+var GIT_DIRECTORY_NAME = ".git";
+var UNKNOWN_VERSION = "unknown";
+function is_binary_available(binary_name) {
+  const result = execaSync(binary_name, ["--version"], { stdio: "ignore", reject: false });
+  return result.exitCode !== void 0;
+}
+function scanner_version(binary_or_path) {
+  const result = execaSync(binary_or_path, ["--version"], { reject: false });
+  if (result.exitCode === void 0) return void 0;
+  return security_audit_provision_logic.parse_scanner_version(result.stdout);
+}
+function meets_floor(binary_or_path) {
+  const version = scanner_version(binary_or_path);
+  return version !== void 0 && security_audit_provision_logic.meets_version_floor(version);
+}
+function is_executable_file(candidate_path) {
+  try {
+    accessSync(candidate_path, constants.X_OK);
+    const stats = statSync(candidate_path);
+    return stats.isFile() && stats.size > 0;
+  } catch {
+    return false;
+  }
+}
+function managed_root(project_root) {
+  const common = git_common_directory.repository(project_root);
+  if (common === void 0 || path2.basename(common) !== GIT_DIRECTORY_NAME) return project_root;
+  return path2.dirname(common);
+}
+function managed_binary_path(project_root, platform) {
+  return security_audit_logic.build_managed_binary_path(managed_root(project_root), platform);
+}
+function managed_scanner(project_root, platform) {
+  const managed_path = managed_binary_path(project_root, platform);
+  return is_executable_file(managed_path) && meets_floor(managed_path) ? managed_path : void 0;
+}
+function resolve_scanner(project_root, platform) {
+  const { BINARY_NAME: BINARY_NAME2 } = security_audit_logic;
+  const has_path_binary = is_binary_available(BINARY_NAME2);
+  if (has_path_binary && meets_floor(BINARY_NAME2)) {
+    return { path: BINARY_NAME2, is_below_floor: false };
+  }
+  const managed = managed_scanner(project_root, platform);
+  if (managed !== void 0) return { path: managed, is_below_floor: false };
+  return has_path_binary ? { path: BINARY_NAME2, is_below_floor: true } : void 0;
+}
+var FORWARDED_OUTPUT = ["inherit", "pipe"];
+function run_scanner(scanner_path) {
+  const { LOCKFILE_PATH: LOCKFILE_PATH2, build_scanner_arguments: build_scanner_arguments2 } = security_audit_logic;
+  const result = execaSync(scanner_path, [...build_scanner_arguments2(LOCKFILE_PATH2)], {
+    stdin: "inherit",
+    stdout: FORWARDED_OUTPUT,
+    stderr: FORWARDED_OUTPUT,
+    reject: false
+  });
+  return result.exitCode ?? FAILURE_EXIT_CODE;
+}
+function warn_below_floor(scanner_path) {
+  const version = scanner_version(scanner_path) ?? UNKNOWN_VERSION;
+  console.warn(security_audit_provision_logic.format_below_floor(version));
+}
+function run() {
+  const { BINARY_NAME: BINARY_NAME2, format_missing_binary_error: format_missing_binary_error2 } = security_audit_logic;
+  const choice = resolve_scanner(PROJECT_ROOT, process.platform);
+  if (choice === void 0) {
+    console.error(format_missing_binary_error2(BINARY_NAME2));
+    return FAILURE_EXIT_CODE;
+  }
+  if (choice.is_below_floor) warn_below_floor(choice.path);
+  return run_scanner(choice.path);
+}
+var security_audit = {
+  is_binary_available,
+  is_executable_file,
+  managed_binary_path,
+  meets_floor,
+  resolve_scanner,
+  run,
+  run_scanner
+};
+
+export {
+  security_audit_logic,
+  security_audit_provision_logic,
+  security_audit
+};

package/dist/commands/chunk-7EAYFMDN.js

@@ -0,0 +1,235 @@
+import {
+  repository_lock
+} from "./chunk-NUCFIYZL.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  lane_state_record
+} from "./chunk-UUH3DE77.js";
+import {
+  durable_state,
+  run_carry
+} from "./chunk-DS53UUDH.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-state.ts
+import { readdirSync } from "node:fs";
+import path from "node:path";
+
+// scripts/lib/figure-format.ts
+var USD_DECIMALS = 4;
+var PERCENT_SCALE = 100;
+var PERCENT_DECIMALS = 1;
+var MINUTE_DECIMALS = 1;
+var CLOCK_WIDTH = 2;
+var CLOCK_PAD = "0";
+function format_usd(usd, decimals = USD_DECIMALS) {
+  return `$${usd.toFixed(decimals)}`;
+}
+function format_tokens(count) {
+  return count.toLocaleString("en-US");
+}
+function format_share(part, whole) {
+  if (whole === 0) return "n/a";
+  return `${(part / whole * PERCENT_SCALE).toFixed(PERCENT_DECIMALS)}%`;
+}
+function format_minutes(duration_ms) {
+  return `${(duration_ms / MS_PER_MINUTE).toFixed(MINUTE_DECIMALS)} min`;
+}
+function two_digits(value) {
+  return String(value).padStart(CLOCK_WIDTH, CLOCK_PAD);
+}
+function clock_of(ms) {
+  const date = new Date(ms);
+  return [date.getHours(), date.getMinutes(), date.getSeconds()].map((value) => two_digits(value)).join(":");
+}
+function minute_of(ms) {
+  const date = new Date(ms);
+  return [date.getHours(), date.getMinutes()].map((value) => two_digits(value)).join(":");
+}
+var figure_format = {
+  format_usd,
+  format_tokens,
+  format_share,
+  format_minutes,
+  two_digits,
+  clock_of,
+  minute_of
+};
+
+// scripts/lane/lane-state.ts
+var LOCK_SUFFIX = ".lock";
+var LOCK_WAIT_MS = 5e3;
+var { HUMAN_REVIEW, LANE_STATES, STATE_SUFFIX } = lane_state_record;
+var NO_STATE_HINT = "no lane state \u2014 counted in use";
+var TRANSITIONS = {
+  open: ["open", "running", "paused", HUMAN_REVIEW, "ended"],
+  running: ["running", "paused", HUMAN_REVIEW, "ended"],
+  paused: ["paused", "running", "ended"],
+  [HUMAN_REVIEW]: [HUMAN_REVIEW, "running", "ended"],
+  ended: ["ended", "open"]
+};
+function state_path(directory, issue) {
+  return path.join(
+    durable_state.ensure(durable_state.root()),
+    lane_state_record.record_name(directory, issue)
+  );
+}
+function is_allowed(from, to) {
+  return from === void 0 || TRANSITIONS[from].includes(to);
+}
+function read_record(directory, issue) {
+  return lane_state_record.read_record_file(state_path(directory, issue));
+}
+function write_record(directory, record) {
+  stamp_file.replace_stamp(state_path(directory, record.issue), record);
+}
+function current_run(directory) {
+  const carried = run_carry.read_carry(run_carry.carry_path(directory));
+  if (carried.kind !== "carried") return void 0;
+  return { started_at: carried.carry.started_at, owner_pid: carried.carry.owner_pid };
+}
+function launch_fields(change, directory, now) {
+  if (change.is_launch !== true) return {};
+  return { run: current_run(directory), launched_at: now.toISOString() };
+}
+function next_record(change, previous, directory, now) {
+  if (previous?.changed_by === lane_state_record.DEPENDENCY_WAIT_COMMAND && change.is_launch === true) {
+    return previous;
+  }
+  return {
+    // An open starts a fresh life: a reopened lane keeps nothing of the run that launched it before.
+    ...change.state !== "open" && previous,
+    issue: change.issue,
+    state: change.state,
+    changed_at: now.toISOString(),
+    changed_by: change.command,
+    ...launch_fields(change, directory, now)
+  };
+}
+function apply_held(change, directory, now) {
+  const previous = read_record(directory, change.issue);
+  if (!is_allowed(previous?.state, change.state)) {
+    return { kind: "skipped", reason: `no ${previous?.state ?? ""} \u2192 ${change.state} transition` };
+  }
+  const record = next_record(change, previous, directory, now);
+  write_record(directory, record);
+  return { kind: "written", record };
+}
+var NO_DIRECTORY = { kind: "skipped", reason: "no git directory" };
+function locked(directory, issue, held) {
+  const lock = `${state_path(directory, issue)}${LOCK_SUFFIX}`;
+  const outcome = repository_lock.with_lock_sync(held, lock, LOCK_WAIT_MS);
+  return outcome ?? { kind: "skipped", reason: `gave up waiting for the lock at ${lock}` };
+}
+function apply(change, directory, now) {
+  return locked(directory, change.issue, () => apply_held(change, directory, now));
+}
+function warn(change, reason) {
+  console.warn(
+    `${change.command} ${session_cite.issue(change.issue)}: lane state not recorded \u2014 ${reason}`
+  );
+}
+async function resolve_directory(directory) {
+  return directory ?? await run_carry.repository_directory();
+}
+async function outcome_of(change, options) {
+  const directory = await resolve_directory(options.directory);
+  if (directory === void 0) return NO_DIRECTORY;
+  return apply(change, directory, options.now ?? /* @__PURE__ */ new Date());
+}
+async function settled(write) {
+  try {
+    return await write();
+  } catch (error) {
+    return { kind: "skipped", reason: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function record_change(change, options = {}) {
+  const outcome = await settled(async () => await outcome_of(change, options));
+  if (outcome.kind === "skipped") warn(change, outcome.reason);
+  return outcome;
+}
+async function read_state(issue, directory) {
+  const root = await resolve_directory(directory);
+  return root === void 0 ? void 0 : read_record(root, issue);
+}
+function recorded_issues(directory) {
+  const empty = state_path(directory, "");
+  const head = path.basename(empty).slice(0, -STATE_SUFFIX.length);
+  return readdirSync(path.dirname(empty)).filter((name) => name.startsWith(head) && name.endsWith(STATE_SUFFIX)).map((name) => name.slice(head.length, -STATE_SUFFIX.length)).filter((issue) => issue.length > 0);
+}
+async function read_records(directory) {
+  const root = await resolve_directory(directory);
+  if (root === void 0) return [];
+  const records = recorded_issues(root).map((issue) => read_record(root, issue));
+  return records.filter((record) => record !== void 0);
+}
+function stuck_held(issue, stuck, directory) {
+  const previous = read_record(directory, issue);
+  if (previous === void 0) return { kind: "skipped", reason: "no record" };
+  const record = { ...previous, stuck };
+  write_record(directory, record);
+  return { kind: "written", record };
+}
+async function record_stuck(issue, stuck, directory) {
+  const root = await resolve_directory(directory);
+  if (root === void 0) return NO_DIRECTORY;
+  return locked(root, issue, () => stuck_held(issue, stuck, root));
+}
+function adopted_held(change, directory, now) {
+  if (read_record(directory, change.issue) !== void 0) {
+    return { kind: "skipped", reason: "a record exists" };
+  }
+  return apply_held(change, directory, now);
+}
+async function adopted_outcome(change, options) {
+  const directory = await resolve_directory(options.directory);
+  if (directory === void 0) return NO_DIRECTORY;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  return locked(directory, change.issue, () => adopted_held(change, directory, now));
+}
+async function record_adopted(change, options = {}) {
+  return await settled(async () => await adopted_outcome(change, options));
+}
+async function read_states(issues, directory) {
+  const root = await resolve_directory(directory);
+  if (root === void 0) return /* @__PURE__ */ new Map();
+  const read = issues.map((issue) => [
+    issue,
+    read_record(root, issue)
+  ]);
+  return new Map(read.filter((entry) => entry[1] !== void 0));
+}
+function paused_text(since_ms, changed_by) {
+  return `paused since ${figure_format.minute_of(since_ms)} by ${changed_by}`;
+}
+function paused_note(record) {
+  if (record?.state !== "paused") return void 0;
+  return paused_text(Date.parse(record.changed_at), record.changed_by);
+}
+var lane_state = {
+  LANE_STATES,
+  NO_STATE_HINT,
+  is_allowed,
+  paused_note,
+  paused_text,
+  read_records,
+  read_state,
+  read_states,
+  record_adopted,
+  record_change,
+  record_stuck,
+  state_path
+};
+
+export {
+  figure_format,
+  lane_state
+};

package/dist/commands/chunk-7HP3FQGQ.js

@@ -0,0 +1,51 @@
+import {
+  review_diff_parts
+} from "./chunk-MY3RSOS5.js";
+import {
+  bash_output_cap_reader
+} from "./chunk-JFLFGLE4.js";
+import {
+  capped_print_part
+} from "./chunk-3WWQFCGX.js";
+import {
+  PLATFORM_TEMP_ROOT
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/document/capped-print.ts
+import { mkdtempSync, writeFileSync } from "node:fs";
+import path from "node:path";
+var FILE_MODE = 384;
+var LINE_BREAK = "\n";
+var HEADROOM_CHARS = 512;
+function write_parts(label, text, cap) {
+  const directory = mkdtempSync(path.join(PLATFORM_TEMP_ROOT, capped_print_part.DIRECTORY_PREFIX));
+  return review_diff_parts.part_texts(label, text, cap).map((part, index) => {
+    const file = path.join(directory, capped_print_part.part_name(index));
+    writeFileSync(file, part, { flag: "wx", mode: FILE_MODE });
+    return file;
+  });
+}
+function part_count(count) {
+  return `written as ${String(count)} part file${count === 1 ? "" : "s"} under it`;
+}
+function listing(text, cap, files) {
+  const figures = `${text.length.toLocaleString("en-US")} > ${cap.toLocaleString("en-US")} characters`;
+  const lead = `Over the Bash cap (${figures}) \u2014 ${part_count(files.length)}, together exactly the output. Read every part with the Read tool, in one turn, not cat:`;
+  return [lead, ...files.map((file) => `  ${file}`)].join(LINE_BREAK);
+}
+function output_budget(root) {
+  return Math.max(1, bash_output_cap_reader.bash_output_cap(root) - HEADROOM_CHARS);
+}
+function capped_print(text, label, root = process.cwd()) {
+  const budget = output_budget(root);
+  if (text.length < budget) {
+    console.info(text);
+    return;
+  }
+  console.info(listing(text, budget, write_parts(label, text, budget)));
+}
+var capped_output = { HEADROOM_CHARS, capped_print, output_budget };
+
+export {
+  capped_output
+};