@joshuafolkken/kit 1.1784.0 → 1.2116.0

package/dist/hooks/{chunk-WR2KQAYZ.js → chunk-7SIUNQXK.js}

@@ -1,13 +1,15 @@
 import {
-  GIT_TIMEOUT_MS,
   MS_PER_MINUTE,
-  MS_PER_SECOND,
   PLATFORM_TEMP_ROOT,
   PROBE_TIMEOUT_MS,
-  SUITE_TIMEOUT_MS,
   error_text,
+  git_command,
+  git_common_directory,
+  platform_temporary,
+  repo_discovery,
+  repo_origin,
   stamp_file
-} from "./chunk-AZX4FGQ3.js";
+} from "./chunk-45CJJOO7.js";
 
 // scripts/lib/json-value.ts
 function parse_or_undefined(text2) {
@@ -32,661 +34,141 @@ function is_record(value) {
 }
 var json_value = { parse_or_undefined, parse_with, parse_array, is_record };
 
-// scripts/git/constants.ts
-import { platform } from "node:os";
-var GIT_COMMAND_UNIX = "/usr/bin/git";
-var PORCELAIN_FLAG = "--porcelain";
-var UNTRACKED_FILES_FLAG = "--untracked-files=all";
-var GIT_BINARY_KEY = "JOSH_GIT_BINARY";
-function get_git_command() {
-  if (platform() === "win32") return String.raw`"C:\Program Files\Git\cmd\git.exe"`;
-  return GIT_COMMAND_UNIX;
-}
-function get_git_command_for_spawn() {
-  const binary = process.env[GIT_BINARY_KEY];
-  if (binary !== void 0 && binary !== "") return binary;
-  if (platform() === "win32") return String.raw`C:\Program Files\Git\cmd\git.exe`;
-  return GIT_COMMAND_UNIX;
-}
-var git_utilities = {
-  get_git_command,
-  get_git_command_for_spawn
-};
-
-// scripts/git/git-spawn.ts
-import { execa as execa3 } from "execa";
-
-// scripts/git/git-execa-error.ts
-function get_exit_code(error) {
-  if (typeof error !== "object" || error === null || !("exitCode" in error)) return void 0;
-  const { exitCode: exit_code } = error;
-  return typeof exit_code === "number" ? exit_code : void 0;
-}
-function has_timed_out(error) {
-  if (typeof error !== "object" || error === null || !("timedOut" in error)) return false;
-  return error.timedOut === true;
-}
-var TIMEOUT_EXIT_CODE = "timeout";
-function create_spawn_error(command, exit_code) {
-  const exit_code_string = exit_code === void 0 ? "unknown" : String(exit_code);
-  const error_message = `git ${command} exited with code ${exit_code_string}`;
-  return new Error(error_message, { cause: { exit_code: exit_code_string } });
-}
-
-// scripts/git/git-push-transport.ts
-import { execa as execa2 } from "execa";
-
-// scripts/git/git-ssh-keepalive.ts
-import { execa } from "execa";
-var SSH_KEEPALIVE_OPTIONS = "-o ServerAliveInterval=15 -o ServerAliveCountMax=3";
-var SSH_COMMAND_VARIABLE = "GIT_SSH_COMMAND";
-var SSH_LEGACY_VARIABLE = "GIT_SSH";
-var KEEPALIVE_SSH_COMMAND = `ssh ${SSH_KEEPALIVE_OPTIONS}`;
-var SSH_COMMAND_CONFIG_KEY = "core.sshCommand";
-var CONFIG_PROBE_ARGUMENTS = ["config", "--get", SSH_COMMAND_CONFIG_KEY];
-var PROBE_OPTIONS = { timeout: PROBE_TIMEOUT_MS };
-function to_environment_value(name) {
-  return process.env[name]?.trim() ?? "";
-}
-function to_configured_ssh_command() {
-  const from_command = to_environment_value(SSH_COMMAND_VARIABLE);
-  return from_command === "" ? to_environment_value(SSH_LEGACY_VARIABLE) : from_command;
-}
-async function has_configured_ssh_command() {
-  if (to_configured_ssh_command() !== "") return true;
-  try {
-    const git_command_bin = git_utilities.get_git_command_for_spawn();
-    const { stdout } = await execa(git_command_bin, CONFIG_PROBE_ARGUMENTS, PROBE_OPTIONS);
-    return stdout.trim() !== "";
-  } catch (error) {
-    return has_timed_out(error);
-  }
-}
-async function to_environment() {
-  const should_keep_alive = !await has_configured_ssh_command();
-  return should_keep_alive ? { [SSH_COMMAND_VARIABLE]: KEEPALIVE_SSH_COMMAND } : {};
-}
-var git_ssh_keepalive = {
-  to_environment
-};
-
-// scripts/git/git-push-transport.ts
-var PUSH_TIMEOUT_SECONDS = 120;
-var PUSH_TIMEOUT_MS = PUSH_TIMEOUT_SECONDS * MS_PER_SECOND;
-var PUSH_TIMEOUT_LABEL = `${String(PUSH_TIMEOUT_SECONDS)}s`;
-var PUSH_TIMEOUT_MESSAGE = "git push timed out";
-var PUSH_SUBCOMMAND = "push";
-async function to_push_options() {
-  return {
-    stdio: "inherit",
-    timeout: PUSH_TIMEOUT_MS,
-    env: await git_ssh_keepalive.to_environment()
-  };
-}
-async function did_push_time_out(arguments_list) {
-  const git_command_bin = git_utilities.get_git_command_for_spawn();
-  const options = await to_push_options();
-  try {
-    await execa2(git_command_bin, [PUSH_SUBCOMMAND, ...arguments_list], options);
-    return false;
-  } catch (error) {
-    if (has_timed_out(error)) return true;
-    throw create_spawn_error(PUSH_SUBCOMMAND, get_exit_code(error));
-  }
-}
-function to_manual_command(arguments_list) {
-  return ["git", PUSH_SUBCOMMAND, ...arguments_list].join(" ");
-}
-function to_retry_notice(arguments_list) {
-  return `${PUSH_TIMEOUT_MESSAGE} after ${PUSH_TIMEOUT_LABEL} \u2014 retrying once: ${to_manual_command(arguments_list)}`;
-}
-function create_timeout_error(arguments_list) {
-  const message = `${PUSH_TIMEOUT_MESSAGE} twice (${PUSH_TIMEOUT_LABEL} each). Re-run it by hand: ${to_manual_command(arguments_list)}`;
-  return new Error(message, { cause: { exit_code: TIMEOUT_EXIT_CODE } });
-}
-async function push(arguments_list) {
-  if (!await did_push_time_out(arguments_list)) return;
-  console.warn(to_retry_notice(arguments_list));
-  if (!await did_push_time_out(arguments_list)) return;
-  throw create_timeout_error(arguments_list);
-}
-var git_push_transport = {
-  push
-};
-
-// scripts/git/git-spawn.ts
-async function read(arguments_, timeout_ms = GIT_TIMEOUT_MS) {
-  const git_cmd = git_utilities.get_git_command_for_spawn();
-  const { stdout } = await execa3(git_cmd, arguments_, { timeout: timeout_ms });
-  return stdout.trimEnd();
-}
-var REMOTE_TIMEOUT_MS = PUSH_TIMEOUT_MS;
-function to_budget_error(command, error, timeout_ms) {
-  if (!has_timed_out(error)) return create_spawn_error(command, get_exit_code(error));
-  const seconds = String(Math.round(timeout_ms / MS_PER_SECOND));
-  return new Error(`git ${command} timed out after ${seconds}s`, {
-    cause: { exit_code: TIMEOUT_EXIT_CODE }
-  });
-}
-async function spawn_remote(arguments_, options) {
-  const git_cmd = git_utilities.get_git_command_for_spawn();
-  try {
-    const { stdout } = await execa3(git_cmd, arguments_, options);
-    return typeof stdout === "string" ? stdout.trimEnd() : "";
-  } catch (error) {
-    throw to_budget_error(arguments_[0] ?? "", error, options.timeout);
-  }
-}
-async function read_remote(arguments_, timeout_ms = REMOTE_TIMEOUT_MS) {
-  return await spawn_remote(arguments_, {
-    timeout: timeout_ms,
-    env: await git_ssh_keepalive.to_environment()
-  });
-}
-async function with_output_remote(command, arguments_list) {
-  await spawn_remote([command, ...arguments_list], {
-    stdio: "inherit",
-    timeout: REMOTE_TIMEOUT_MS,
-    env: await git_ssh_keepalive.to_environment()
-  });
-}
-async function with_output(command, arguments_list, options = {}) {
-  const { config_options = [], timeout_ms = GIT_TIMEOUT_MS } = options;
-  const git_command_bin = git_utilities.get_git_command_for_spawn();
-  const spawn_arguments = [...config_options, command, ...arguments_list];
-  try {
-    await execa3(git_command_bin, spawn_arguments, { stdio: "inherit", timeout: timeout_ms });
-  } catch (error) {
-    throw to_budget_error(command, error, timeout_ms);
-  }
-}
-var git_spawn = {
-  read,
-  read_remote,
-  with_output,
-  with_output_remote
-};
+// scripts/josh/durable-state.ts
+import { mkdirSync } from "node:fs";
+import path2 from "node:path";
 
-// scripts/git/git-diff-reads.ts
-var REFS_REMOTES_ORIGIN_PREFIX = "refs/remotes/origin/";
-var NAME_ONLY_FLAG = "--name-only";
-var DEFAULT_BRANCH_FALLBACK = "main";
-var DEFAULT_BRANCH_ARGUMENTS = ["symbolic-ref", "refs/remotes/origin/HEAD"];
-function default_branch_of(output) {
-  const trimmed = output?.trim() ?? "";
-  if (!trimmed.startsWith(REFS_REMOTES_ORIGIN_PREFIX)) return DEFAULT_BRANCH_FALLBACK;
-  return trimmed.slice(REFS_REMOTES_ORIGIN_PREFIX.length);
-}
-async function get_default_branch() {
+// scripts/josh/durable-state-migrate.ts
+import { constants, copyFileSync, lstatSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+var COPIED_MARKER = ".legacy-copied";
+var MARKER_MODE = 384;
+var LOG_RETENTION_DAYS = 14;
+var DAY_MS = 864e5;
+var LOG_SUFFIX = ".log";
+var RECORD_SUFFIXES = [".json", ".jsonl", LOG_SUFFIX];
+function is_record_name(name, prefixes) {
+  const has_prefix = prefixes.some((prefix) => name.startsWith(prefix));
+  return has_prefix && RECORD_SUFFIXES.some((suffix) => name.endsWith(suffix));
+}
+function list_names(directory) {
   try {
-    return default_branch_of(await git_spawn.read([...DEFAULT_BRANCH_ARGUMENTS]));
+    return readdirSync(directory);
   } catch {
-    return DEFAULT_BRANCH_FALLBACK;
+    return [];
   }
 }
-var MERGE_BASE_COMMAND = "merge-base";
-async function reference_exists(reference2) {
+function copy_record(from, to) {
   try {
-    await git_spawn.read(["rev-parse", "--verify", "--quiet", reference2]);
-    return true;
+    if (!stamp_file.is_own_regular_file(from)) return;
+    copyFileSync(from, to, constants.COPYFILE_EXCL);
   } catch {
-    return false;
   }
 }
-async function default_branch_reference() {
-  const default_branch = await get_default_branch();
-  const remote_reference = `${REFS_REMOTES_ORIGIN_PREFIX}${default_branch}`;
-  return await reference_exists(remote_reference) ? remote_reference : default_branch;
-}
-async function change_base() {
-  const default_branch = await default_branch_reference();
-  try {
-    return await git_spawn.read([MERGE_BASE_COMMAND, default_branch, "HEAD"]);
-  } catch {
-    return default_branch;
-  }
-}
-async function diff_main(file_path) {
-  return await git_spawn.read(["diff", await change_base(), "--", file_path]);
-}
-var NO_PATH_QUOTING = ["-c", "core.quotePath=false"];
-var NO_RELATIVE_PATHS = "--no-relative";
-var NO_RENAME_DETECTION = "--no-renames";
-async function change_base_commit() {
-  return await git_spawn.read(["rev-parse", await change_base()]);
-}
-async function diff_names_since(commit2) {
-  return await git_spawn.read([
-    ...NO_PATH_QUOTING,
-    "diff",
-    NAME_ONLY_FLAG,
-    NO_RELATIVE_PATHS,
-    NO_RENAME_DETECTION,
-    commit2,
-    "--"
-  ]);
-}
-async function tree_names_at(commit2, paths) {
-  return await git_spawn.read([
-    ...NO_PATH_QUOTING,
-    "ls-tree",
-    "-r",
-    NAME_ONLY_FLAG,
-    "--full-tree",
-    commit2,
-    "--",
-    ...paths
-  ]);
-}
-async function diff_main_names() {
-  return await diff_names_since(await change_base());
-}
-async function diff_cached_names() {
-  return await git_spawn.read([
-    ...NO_PATH_QUOTING,
-    "diff",
-    "--cached",
-    NAME_ONLY_FLAG,
-    NO_RELATIVE_PATHS,
-    NO_RENAME_DETECTION
-  ]);
-}
-async function diff_main_numstat() {
-  return await git_spawn.read([
-    ...NO_PATH_QUOTING,
-    "diff",
-    "--numstat",
-    NO_RELATIVE_PATHS,
-    NO_RENAME_DETECTION,
-    await change_base(),
-    "--"
-  ]);
-}
-var WHOLE_TREE_PATHSPEC = ":/";
-async function untracked_names() {
-  return await git_spawn.read([
-    ...NO_PATH_QUOTING,
-    "ls-files",
-    "--others",
-    "--exclude-standard",
-    "--full-name",
-    WHOLE_TREE_PATHSPEC
-  ]);
-}
-var git_diff_reads = {
-  DEFAULT_BRANCH_ARGUMENTS,
-  change_base,
-  change_base_commit,
-  default_branch_of,
-  default_branch_reference,
-  diff_cached_names,
-  diff_main,
-  diff_main_names,
-  diff_main_numstat,
-  diff_names_since,
-  get_default_branch,
-  tree_names_at,
-  untracked_names
-};
-
-// scripts/git/git-pre-push-hook.ts
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-var REMOTE = "origin";
-var HOOK_NAME = "pre-push";
-var PROBE_HOOK_NAME = "kit-hook-run-probe";
-var ALLOW_UNKNOWN_HOOK_NAME_FLAG = "--allow-unknown-hook-name";
-var HOOK_RUN = "run";
-var STDIN_FILE = "refs";
-var TEMPORARY_PREFIX = "kit-pre-push-";
-var ZERO_DIGIT = "0";
-async function read_remote_oid(branch2) {
-  try {
-    return await git_spawn.read([
-      "rev-parse",
-      "--verify",
-      "--quiet",
-      `refs/remotes/${REMOTE}/${branch2}`
-    ]);
-  } catch {
-    return void 0;
+function copy_legacy(from, to, prefixes) {
+  if (from === to) return;
+  for (const name of list_names(from)) {
+    if (is_record_name(name, prefixes)) copy_record(path.join(from, name), path.join(to, name));
   }
 }
-async function read_push_references() {
-  const [branch2, local_oid] = await Promise.all([
-    git_spawn.read(["rev-parse", "--abbrev-ref", "HEAD"]),
-    git_spawn.read(["rev-parse", "HEAD"])
-  ]);
-  return { branch: branch2, local_oid, remote_oid: await read_remote_oid(branch2) };
-}
-function to_stdin_line(references) {
-  const reference2 = `refs/heads/${references.branch}`;
-  const remote_oid = references.remote_oid ?? ZERO_DIGIT.repeat(references.local_oid.length);
-  return `${reference2} ${references.local_oid} ${reference2} ${remote_oid}
-`;
-}
-function to_hook_run_arguments(stdin_path, hook_name) {
-  return [HOOK_RUN, "--ignore-missing", `--to-stdin=${stdin_path}`, hook_name];
-}
-async function can_probe(probe_arguments) {
+function claim_copy(directory) {
   try {
-    await git_spawn.read(["hook", ...probe_arguments]);
+    writeFileSync(path.join(directory, COPIED_MARKER), "", { flag: "wx", mode: MARKER_MODE });
     return true;
   } catch {
     return false;
   }
 }
-async function can_run_hooks(stdin_path) {
-  const [, ...options] = to_hook_run_arguments(stdin_path, PROBE_HOOK_NAME);
-  if (await can_probe([HOOK_RUN, ALLOW_UNKNOWN_HOOK_NAME_FLAG, ...options])) return true;
-  return await can_probe([HOOK_RUN, ...options]);
+function copy_once(from, to, prefixes) {
+  if (claim_copy(to)) copy_legacy(from, to, prefixes);
+}
+function is_stale(target2, now_ms) {
+  const age_ms = now_ms - lstatSync(target2).mtimeMs;
+  return age_ms > LOG_RETENTION_DAYS * DAY_MS && stamp_file.is_own_regular_file(target2);
 }
-async function run_with_stdin(stdin_line) {
-  const directory = await mkdtemp(path.join(tmpdir(), TEMPORARY_PREFIX));
-  const stdin_path = path.join(directory, STDIN_FILE);
+function prune_log(target2, now_ms) {
   try {
-    await writeFile(stdin_path, stdin_line);
-    if (!await can_run_hooks(stdin_path)) return false;
-    const url = await git_spawn.read(["remote", "get-url", REMOTE]);
-    await git_spawn.with_output(
-      "hook",
-      [...to_hook_run_arguments(stdin_path, HOOK_NAME), "--", REMOTE, url],
-      { timeout_ms: SUITE_TIMEOUT_MS }
-    );
-    return true;
-  } finally {
-    await rm(directory, { force: true, recursive: true });
+    if (is_stale(target2, now_ms)) rmSync(target2, { force: true });
+  } catch {
   }
 }
-async function run() {
-  const references = await read_push_references();
-  if (references.local_oid === references.remote_oid) return true;
-  return await run_with_stdin(to_stdin_line(references));
-}
-var git_pre_push_hook = {
-  run
-};
-
-// scripts/lib/spawn-exit.ts
-function read_spawn_stdout(result) {
-  return result.stdout ?? "";
-}
-function read_spawn_stderr(result) {
-  return result.stderr ?? "";
-}
-
-// scripts/git/git-spawn-sync.ts
-import { execaSync } from "execa";
-
-// scripts/git/git-location-environment.ts
-var GIT_LOCATION_VARIABLES = [
-  "GIT_ALTERNATE_OBJECT_DIRECTORIES",
-  "GIT_COMMON_DIR",
-  "GIT_DIR",
-  "GIT_INDEX_FILE",
-  "GIT_NAMESPACE",
-  "GIT_OBJECT_DIRECTORY",
-  "GIT_WORK_TREE"
-];
-function location_free_environment() {
-  return Object.fromEntries(GIT_LOCATION_VARIABLES.map((name) => [name, void 0]));
-}
-function forget(name) {
-  Reflect.deleteProperty(process.env, name);
-}
-function restore_one(name, value) {
-  if (value === void 0) forget(name);
-  else process.env[name] = value;
-}
-function clear_git_location_variables() {
-  const previous = GIT_LOCATION_VARIABLES.map((name) => [name, process.env[name]]);
-  for (const [name] of previous) forget(name);
-  return () => {
-    for (const [name, value] of previous) restore_one(name, value);
-  };
-}
-var git_location_environment = { clear_git_location_variables, location_free_environment };
-
-// scripts/git/git-spawn-sync.ts
-var SUCCESS_EXIT_CODE = 0;
-var C_LOCALE = { LC_ALL: "C", LANGUAGE: "C" };
-function run2(args, options = {}) {
-  const result = execaSync(git_utilities.get_git_command_for_spawn(), args, {
-    ...options,
-    extendEnv: true,
-    reject: false,
-    timeout: options.timeout ?? GIT_TIMEOUT_MS
-  });
-  return {
-    exit_code: result.exitCode,
-    stdout: read_spawn_stdout(result),
-    stderr: read_spawn_stderr(result)
-  };
-}
-function read2(args, options = {}) {
-  const result = run2(args, options);
-  return result.exit_code === SUCCESS_EXIT_CODE ? result.stdout.trim() : void 0;
-}
-function origin_url(cwd) {
-  return read2(["config", "--get", "remote.origin.url"], {
-    cwd,
-    env: git_location_environment.location_free_environment()
-  });
-}
-function toplevel(timeout = GIT_TIMEOUT_MS) {
-  return run2(["rev-parse", "--show-toplevel"], { env: C_LOCALE, timeout });
-}
-var git_spawn_sync = { GIT_TIMEOUT_MS, C_LOCALE, run: run2, read: read2, origin_url, toplevel };
-
-// scripts/git/git-command.ts
-async function branch() {
-  return await git_spawn.read(["rev-parse", "--abbrev-ref", "HEAD"]);
-}
-async function status(directory) {
-  const location = directory === void 0 ? [] : ["-C", directory];
-  return await git_spawn.read([...location, "status", PORCELAIN_FLAG, UNTRACKED_FILES_FLAG]);
-}
-async function repository_root() {
-  const result = git_spawn_sync.toplevel();
-  if (result.exit_code !== 0) throw create_spawn_error("rev-parse", result.exit_code);
-  return result.stdout.trim();
-}
-async function head_commit() {
-  return await git_spawn.read(["rev-parse", "HEAD"]);
-}
-var GIT_DIRECTORY_ARGUMENTS = [
-  "rev-parse",
-  "--absolute-git-dir",
-  "--path-format=absolute",
-  "--git-common-dir"
-];
-async function git_directories() {
-  const output = await git_spawn.read([...GIT_DIRECTORY_ARGUMENTS]);
-  return output.split("\n").filter((line) => line !== "");
-}
-async function diff_cached(file_path) {
-  return await git_spawn.read(["diff", "--cached", file_path]);
-}
-async function fetch_branch(branch_name) {
-  const refspec = `+refs/heads/${branch_name}:refs/remotes/origin/${branch_name}`;
-  return await git_spawn.read_remote(["fetch", "origin", refspec]);
-}
-async function merge_fast_forward(branch_name) {
-  return await git_spawn.read(["merge", "--ff-only", `origin/${branch_name}`], SUITE_TIMEOUT_MS);
-}
-async function fast_forward_local(branch_name) {
-  return await git_spawn.read_remote(["fetch", "origin", `${branch_name}:${branch_name}`]);
-}
-async function merge_branch(branch_name, message) {
-  const message_arguments = message === void 0 ? [] : ["-m", message];
-  await git_spawn.with_output("merge", [...message_arguments, `origin/${branch_name}`], {
-    timeout_ms: SUITE_TIMEOUT_MS
-  });
-}
-async function checkout_b(branch_name) {
-  return await git_spawn.read(["checkout", "-b", branch_name], SUITE_TIMEOUT_MS);
-}
-async function checkout(branch_name) {
-  return await git_spawn.read(["checkout", branch_name], SUITE_TIMEOUT_MS);
-}
-async function commit(message) {
-  await git_spawn.with_output("commit", ["-m", message], { timeout_ms: SUITE_TIMEOUT_MS });
-}
-async function delete_branch(branch_name) {
-  await git_spawn.read(["branch", "-d", branch_name]);
-}
-async function read_commit_count(revisions) {
-  const output = await git_spawn.read(["rev-list", "--count", ...revisions]);
-  const parsed = Number(output);
-  if (output.length > 0 && Number.isFinite(parsed)) return parsed;
-  throw new Error(
-    `\`git rev-list --count ${revisions.join(" ")}\` printed \`${output}\` rather than a count`
-  );
-}
-async function commit_count_beyond(base, tip) {
-  return await read_commit_count([`${base}..${tip}`]);
-}
-async function commit_count_unpushed(branch_name) {
-  return await read_commit_count([branch_name, "--not", "--remotes"]);
-}
-function is_exit_code_128(cause) {
-  return typeof cause === "object" && cause !== null && "exit_code" in cause && cause.exit_code === "128";
-}
-function is_upstream_not_set_error(error) {
-  if (!(error instanceof Error)) return false;
-  const { cause } = error;
-  return cause !== void 0 && is_exit_code_128(cause);
-}
-var NO_VERIFY_FLAG = "--no-verify";
-async function push_with_upstream(branch_name, verify_flags) {
-  await git_push_transport.push([...verify_flags, "--set-upstream", "origin", branch_name]);
-}
-async function push2() {
-  const verify_flags = await git_pre_push_hook.run() ? [NO_VERIFY_FLAG] : [];
-  try {
-    await git_push_transport.push([...verify_flags]);
-  } catch (error) {
-    if (is_upstream_not_set_error(error)) {
-      const current_branch = await branch();
-      await push_with_upstream(current_branch, verify_flags);
-      return;
+function prune_stale_logs(directory, prefixes, now_ms) {
+  for (const name of list_names(directory)) {
+    if (name.endsWith(LOG_SUFFIX) && is_record_name(name, prefixes)) {
+      prune_log(path.join(directory, name), now_ms);
     }
-    throw error;
   }
 }
-async function pull_fast_forward() {
-  await git_spawn.with_output_remote("pull", ["--ff-only"]);
-}
-var SHORT_NAME_FORMAT = "--format=%(refname:short)";
-var REMOTES_FLAG = "--remotes";
-async function list_branches(flags, pattern) {
+var durable_state_migrate = { LOG_RETENTION_DAYS, copy_once, is_record_name, prune_stale_logs };
+
+// scripts/josh/durable-state.ts
+var RUN_STATE_DIRECTORY = "run-state";
+var OVERRIDE_STATE_DIRECTORY = "josh-state";
+var STATE_DIRECTORY_MODE = 448;
+function state_root(override, common) {
+  if (override !== void 0 && override !== "") {
+    return path2.join(override, OVERRIDE_STATE_DIRECTORY);
+  }
+  if (common === void 0) return PLATFORM_TEMP_ROOT;
+  return path2.join(common, git_common_directory.STATE_DIRECTORY, RUN_STATE_DIRECTORY);
+}
+var STATE_ROOT_OVERRIDE = process.env[platform_temporary.TEMP_ROOT_KEY];
+function root_for(common) {
+  return state_root(STATE_ROOT_OVERRIDE, common);
+}
+function root() {
+  return root_for(git_common_directory.repository());
+}
+var PREFIX = {
+  CARRY: "josh-run-carry-",
+  ENDED: "josh-run-ended-",
+  EVENTS: "josh-run-events-",
+  LANE_STATE: "josh-lane-state-",
+  LANE_LEDGER: "josh-lane-ledger-",
+  WAKE_LOG: "josh-run-wake-log-",
+  BACKLOGRUN_LAUNCH: "josh-backlogrun-launch-",
+  BACKLOGRUN_LOG: "josh-backlogrun-log-",
+  SHIP_LOG: "josh-ship-log-",
+  SHIP_RESULT: "josh-ship-result-",
+  LANE_DISPATCH: "josh-lane-dispatch-",
+  LANE_PLAN: "josh-lane-plan-"
+};
+var PREFIXES = Object.values(PREFIX);
+var ensured = /* @__PURE__ */ new Set();
+function prepare(directory) {
+  mkdirSync(directory, { recursive: true, mode: STATE_DIRECTORY_MODE });
+  durable_state_migrate.copy_once(PLATFORM_TEMP_ROOT, directory, PREFIXES);
+  durable_state_migrate.prune_stale_logs(directory, PREFIXES, Date.now());
+}
+function ensure(directory) {
+  if (ensured.has(directory)) return directory;
   try {
-    const output = await git_spawn.read([
-      "branch",
-      "--list",
-      SHORT_NAME_FORMAT,
-      ...flags,
-      pattern
-    ]);
-    return output.split("\n").filter((line) => line.trim() !== "");
+    prepare(directory);
   } catch {
-    return [];
-  }
-}
-async function branch_names(pattern) {
-  return await list_branches([], pattern);
-}
-async function branch_names_remote(pattern) {
-  return await list_branches([REMOTES_FLAG], pattern);
-}
-async function branch_exists(branch_name) {
-  const names = await branch_names(branch_name);
-  return names.length > 0;
-}
-var ALL_PATHS_PATHSPEC = ":/";
-function exclude_pathspec(file_path) {
-  return `:(exclude,top)${file_path}`;
-}
-async function add_tracked(excluded_paths) {
-  const exclusions = excluded_paths.map((file_path) => exclude_pathspec(file_path));
-  await git_spawn.read(["add", "-u", "--", ALL_PATHS_PATHSPEC, ...exclusions]);
-}
-async function add_path(file_path) {
-  await git_spawn.with_output("add", ["--", file_path]);
-}
-var FIRST_PARENT_FLAG = "--first-parent";
-async function log_first_parent(limit, file_path, tip = "HEAD") {
-  const output = await git_spawn.read([
-    "log",
-    FIRST_PARENT_FLAG,
-    "--format=%H",
-    `-n`,
-    String(limit),
-    tip,
-    "--",
-    file_path
-  ]);
-  return output.split("\n").filter((line) => line.length > 0);
-}
-async function show_file(spec) {
-  return await git_spawn.read(["show", spec]);
-}
-var MERGE_COUNT_ARGUMENTS = [
-  "rev-list",
-  "--count",
-  "--merges",
-  FIRST_PARENT_FLAG
-];
-function merge_count_arguments(range) {
-  return [...MERGE_COUNT_ARGUMENTS, range];
-}
-async function count_merges(range) {
-  const output = await git_spawn.read(merge_count_arguments(range));
-  const parsed = Number(output.trim());
-  return Number.isFinite(parsed) ? parsed : 0;
-}
-var git_command = {
-  GIT_DIRECTORY_ARGUMENTS,
-  branch,
-  status,
-  repository_root,
-  head_commit,
-  git_directories,
-  diff_cached,
-  // The default branch, the change base and every reading against it are `git-diff-reads.ts`'s,
-  // re-exported here so no call site, mock or spy moved with them.
-  ...git_diff_reads,
-  fetch_branch,
-  merge_fast_forward,
-  fast_forward_local,
-  merge_branch,
-  checkout_b,
-  checkout,
-  commit,
-  commit_count_beyond,
-  commit_count_unpushed,
-  delete_branch,
-  push: push2,
-  pull_fast_forward,
-  branch_exists,
-  branch_names,
-  branch_names_remote,
-  add_tracked,
-  add_path,
-  log_first_parent,
-  show_file,
-  count_merges,
-  merge_count_arguments,
-  is_upstream_not_set_error
+    return PLATFORM_TEMP_ROOT;
+  }
+  ensured.add(directory);
+  return directory;
+}
+function durable_path(prefix, key_root, suffix) {
+  return path2.join(ensure(root()), stamp_file.stamp_name(prefix, key_root, suffix));
+}
+var durable_state = {
+  PREFIX,
+  STATE_DIRECTORY_MODE,
+  ensure,
+  path: durable_path,
+  root,
+  root_for,
+  state_root
 };
 
 // scripts/josh/process-identity.ts
 import { execFileSync, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { readFileSync, rmSync } from "node:fs";
+import { readFileSync, rmSync as rmSync2 } from "node:fs";
 import { createServer } from "node:net";
-import path2 from "node:path";
+import path3 from "node:path";
 var PS_COMMAND = "/bin/ps";
 var FORMAT_FLAG = "-o";
 var START_TIME_FORMAT = "lstart=";
@@ -765,7 +247,7 @@ function close_beacon(token) {
   if (server === void 0) return;
   beacons.delete(token);
   server.close();
-  rmSync(token.slice(BEACON_SCHEME.length), { force: true });
+  rmSync2(token.slice(BEACON_SCHEME.length), { force: true });
 }
 function close_beacons() {
   for (const token of beacons.keys()) close_beacon(token);
@@ -777,30 +259,30 @@ function ensure_exit_cleanup() {
 }
 function ignore_beacon_error() {
 }
-function bind_beacon(target) {
-  return createServer().on("error", ignore_beacon_error).listen(target);
+function bind_beacon(target2) {
+  return createServer().on("error", ignore_beacon_error).listen(target2);
 }
-function try_bind_beacon(bind, target) {
+function try_bind_beacon(bind, target2) {
   try {
-    const server = bind(target);
+    const server = bind(target2);
     return server.listening ? server : void 0;
   } catch {
     return void 0;
   }
 }
 function open_beacon(bind = bind_beacon) {
-  const target = path2.join(PLATFORM_TEMP_ROOT, `${BEACON_PREFIX}${randomUUID()}${BEACON_SUFFIX}`);
-  const token = `${BEACON_SCHEME}${target}`;
-  const server = try_bind_beacon(bind, target);
+  const target2 = path3.join(PLATFORM_TEMP_ROOT, `${BEACON_PREFIX}${randomUUID()}${BEACON_SUFFIX}`);
+  const token = `${BEACON_SCHEME}${target2}`;
+  const server = try_bind_beacon(bind, target2);
   if (server === void 0) return void 0;
   server.unref();
   beacons.set(token, server);
   ensure_exit_cleanup();
   return token;
 }
-function resolve_own_start(probes = START_PROBES, platform2 = process.platform) {
+function resolve_own_start(probes = START_PROBES, platform = process.platform) {
   const start = read_start(process.pid, probes);
-  if (start !== void 0 || platform2 === WINDOWS_PLATFORM) return start;
+  if (start !== void 0 || platform === WINDOWS_PLATFORM) return start;
   return open_beacon();
 }
 function is_valid_beacon_name(name) {
@@ -810,28 +292,28 @@ function is_valid_beacon_name(name) {
 }
 function beacon_target(token) {
   if (!token.startsWith(BEACON_SCHEME)) return void 0;
-  const target = token.slice(BEACON_SCHEME.length);
-  if (path2.dirname(target) !== PLATFORM_TEMP_ROOT) return void 0;
-  return is_valid_beacon_name(path2.basename(target)) ? target : void 0;
+  const target2 = token.slice(BEACON_SCHEME.length);
+  if (path3.dirname(target2) !== PLATFORM_TEMP_ROOT) return void 0;
+  return is_valid_beacon_name(path3.basename(target2)) ? target2 : void 0;
 }
-function run_socket_probe(target, kill_after_ms = PROBE_TIMEOUT_MS) {
-  return spawnSync(process.execPath, ["-e", SOCKET_PROBE_SOURCE, target], {
+function run_socket_probe(target2, kill_after_ms = PROBE_TIMEOUT_MS) {
+  return spawnSync(process.execPath, ["-e", SOCKET_PROBE_SOURCE, target2], {
     stdio: "ignore",
     timeout: kill_after_ms
   }).status ?? void 0;
 }
-function is_live_beacon(target, probe = run_socket_probe) {
-  const status2 = probe(target);
-  if (status2 === BEACON_LIVE_STATUS) return true;
-  return status2 === BEACON_GONE_STATUS ? false : void 0;
+function is_live_beacon(target2, probe = run_socket_probe) {
+  const status = probe(target2);
+  if (status === BEACON_LIVE_STATUS) return true;
+  return status === BEACON_GONE_STATUS ? false : void 0;
 }
-function has_matching_start(pid, recorded_start, read3) {
-  const observed = read3(pid);
+function has_matching_start(pid, recorded_start, read) {
+  const observed = read(pid);
   return observed === void 0 ? void 0 : observed === recorded_start;
 }
-function matches_recorded_start(pid, recorded_start, read3) {
-  const target = beacon_target(recorded_start);
-  return target === void 0 ? has_matching_start(pid, recorded_start, read3) : is_live_beacon(target);
+function matches_recorded_start(pid, recorded_start, read) {
+  const target2 = beacon_target(recorded_start);
+  return target2 === void 0 ? has_matching_start(pid, recorded_start, read) : is_live_beacon(target2);
 }
 var own_probe = /* @__PURE__ */ new Map();
 function own_start() {
@@ -842,15 +324,15 @@ function own_fields() {
   const start = own_start();
   return { pid: process.pid, ...start !== void 0 && { process_start: start } };
 }
-function is_same_process(pid, recorded_start, read3 = read_start) {
+function is_same_process(pid, recorded_start, read = read_start) {
   if (pid === void 0 || !is_live_pid(pid)) return false;
   if (recorded_start === void 0) return void 0;
-  return matches_recorded_start(pid, recorded_start, read3);
+  return matches_recorded_start(pid, recorded_start, read);
 }
-function is_present_process(pid, recorded_start, read3 = read_start) {
+function is_present_process(pid, recorded_start, read = read_start) {
   if (!is_present_pid(pid)) return false;
   if (recorded_start === void 0) return void 0;
-  return matches_recorded_start(pid, recorded_start, read3);
+  return matches_recorded_start(pid, recorded_start, read);
 }
 function is_own_process(pid, recorded_start) {
   return pid === process.pid && recorded_start === own_start();
@@ -1124,9 +606,9 @@ function next_added(carry, additions) {
   }
   return next;
 }
-function add_issues(target, carry, additions) {
+function add_issues(target2, carry, additions) {
   const next = { ...carry, added: next_added(carry, additions) };
-  stamp_file.replace_stamp(target, next);
+  stamp_file.replace_stamp(target2, next);
   return next;
 }
 var run_carry_added = { add_issues, ordered };
@@ -1205,7 +687,7 @@ function next_counts(carry, change) {
     is_handed_off: cuts > NO_INCREMENT2
   };
 }
-function apply_change(target, carry, change, now = /* @__PURE__ */ new Date()) {
+function apply_change(target2, carry, change, now = /* @__PURE__ */ new Date()) {
   const effective = effective_change(carry, change);
   if (effective === void 0) return carry;
   const streak = run_carry_streak.next_state(carry, effective, now);
@@ -1219,47 +701,55 @@ function apply_change(target, carry, change, now = /* @__PURE__ */ new Date()) {
     done: next_done(carry, effective.done),
     retrospective: effective.retrospective === true || carry.retrospective
   };
-  stamp_file.replace_stamp(target, next);
+  stamp_file.replace_stamp(target2, next);
   return next;
 }
 var run_carry_change = { apply_change };
 
 // scripts/run/carry/run-carry-conversation.ts
 import { existsSync, statSync as statSync2 } from "node:fs";
-import path5 from "node:path";
+import path6 from "node:path";
 
 // scripts/cost-runtime/cost-transcript.ts
-import { readdirSync, readFileSync as readFileSync3, statSync } from "node:fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync3, statSync } from "node:fs";
 import { homedir } from "node:os";
-import path4 from "node:path";
+import path5 from "node:path";
 
 // scripts/lane/lane-paths.ts
-import path3 from "node:path";
+import path4 from "node:path";
 var LANE_ROOT_KEY = "JOSH_LANE_ROOT";
 var LANE_DIRECTORY_SUFFIX = "-lanes";
 var LANE_BRANCH_SUFFIX = "-lane";
-function default_lane_root(repository_root2) {
-  const name = path3.basename(repository_root2);
-  return path3.join(path3.dirname(repository_root2), `.${name}${LANE_DIRECTORY_SUFFIX}`);
+function default_lane_root(repository_root) {
+  const name = path4.basename(repository_root);
+  return path4.join(path4.dirname(repository_root), `.${name}${LANE_DIRECTORY_SUFFIX}`);
 }
-function lane_root(repository_root2, environment = process.env) {
+function lane_root(repository_root, environment = process.env) {
   const configured = environment[LANE_ROOT_KEY]?.trim() ?? "";
-  return configured.length === 0 ? default_lane_root(repository_root2) : path3.resolve(configured);
+  return configured.length === 0 ? default_lane_root(repository_root) : path4.resolve(configured);
 }
-function lane_directory(root, issue2) {
-  return path3.join(root, issue2);
+function lane_directory(root2, issue2) {
+  return path4.join(root2, issue2);
 }
 var DEFAULT_LANE_ROOT_PATTERN = new RegExp(String.raw`^\..+${LANE_DIRECTORY_SUFFIX}$`, "u");
 function is_lane_root(directory, environment) {
   const configured = environment[LANE_ROOT_KEY]?.trim() ?? "";
-  if (configured.length > 0) return path3.resolve(configured) === directory;
-  return DEFAULT_LANE_ROOT_PATTERN.test(path3.basename(directory));
+  if (configured.length > 0) return path4.resolve(configured) === directory;
+  return DEFAULT_LANE_ROOT_PATTERN.test(path4.basename(directory));
+}
+var CLAUDE_WORKTREES_PATTERN = /[/\\]\.claude[/\\]worktrees[/\\][^/\\]+(?:[/\\].*)?$/u;
+function checkout_of(directory) {
+  return directory.replace(CLAUDE_WORKTREES_PATTERN, "");
 }
 function lane_issue_of(directory, environment = process.env) {
-  const resolved = path3.resolve(directory);
-  const issue2 = path3.basename(resolved);
+  const resolved = checkout_of(path4.resolve(directory));
+  const issue2 = path4.basename(resolved);
   if (!issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue2)) return void 0;
-  return is_lane_root(path3.dirname(resolved), environment) ? issue2 : void 0;
+  return is_lane_root(path4.dirname(resolved), environment) ? issue2 : void 0;
+}
+function issue_here(directory = process.cwd(), environment = process.env) {
+  const lane = lane_issue_of(directory, environment);
+  return lane === void 0 ? void 0 : Number(lane);
 }
 function lane_branch(issue2) {
   return `${issue2}${LANE_BRANCH_SUFFIX}`;
@@ -1272,8 +762,10 @@ var lane_paths = {
   LANE_BRANCH_SUFFIX,
   LANE_ROOT_KEY,
   SEAT_LOCK_DIR,
+  checkout_of,
   default_lane_root,
   is_lane_entry,
+  issue_here,
   lane_branch,
   lane_directory,
   lane_issue_of,
@@ -1286,20 +778,20 @@ var ABSENT_CODE = "ENOENT";
 function is_absent(error) {
   return error instanceof Error && "code" in error && error.code === ABSENT_CODE;
 }
-function read_optional(path11) {
+function read_optional(path12) {
   try {
-    return readFileSync2(path11, "utf8");
+    return readFileSync2(path12, "utf8");
   } catch (error) {
     if (is_absent(error)) return void 0;
     throw error;
   }
 }
-function read_file_or_empty(path11) {
-  return read_optional(path11) ?? "";
+function read_file_or_empty(path12) {
+  return read_optional(path12) ?? "";
 }
-function read_if_readable(path11) {
+function read_if_readable(path12) {
   try {
-    return readFileSync2(path11, "utf8");
+    return readFileSync2(path12, "utf8");
   } catch {
     return void 0;
   }
@@ -1414,10 +906,10 @@ function later_instant(left, right) {
 }
 function dedupe(records) {
   const by_id = /* @__PURE__ */ new Map();
-  for (const record of records) {
-    const seen = by_id.get(record.request_id);
-    const at_ms = later_instant(seen?.at_ms, record.at_ms);
-    by_id.set(record.request_id, { ...seen ?? record, at_ms });
+  for (const record2 of records) {
+    const seen = by_id.get(record2.request_id);
+    const at_ms = later_instant(seen?.at_ms, record2.at_ms);
+    by_id.set(record2.request_id, { ...seen ?? record2, at_ms });
   }
   return [...by_id.values()];
 }
@@ -1434,7 +926,7 @@ function add_totals(left, right) {
 }
 function sum_totals(records) {
   let total = EMPTY_TOTALS;
-  for (const record of records) total = add_totals(total, record.totals);
+  for (const record2 of records) total = add_totals(total, record2.totals);
   return total;
 }
 function billed_input(totals) {
@@ -1452,7 +944,7 @@ var cost_usage = {
 };
 
 // scripts/cost-runtime/cost-transcript.ts
-var TRANSCRIPT_ROOT = path4.join(".claude", "projects");
+var TRANSCRIPT_ROOT = path5.join(".claude", "projects");
 var TRANSCRIPT_EXTENSION = ".jsonl";
 var SLUG_PATTERN = /[^a-zA-Z0-9-]/gu;
 var UNIT_DIRECTORY = "subagents";
@@ -1461,7 +953,7 @@ function project_slug(cwd) {
   return cwd.replaceAll(SLUG_PATTERN, "-");
 }
 function transcript_directory(cwd, home = homedir()) {
-  return path4.join(home, TRANSCRIPT_ROOT, project_slug(cwd));
+  return path5.join(home, TRANSCRIPT_ROOT, project_slug(cwd));
 }
 var GIT_ENTRY = ".git";
 var GITDIR_PREFIX = "gitdir:";
@@ -1469,7 +961,7 @@ var WORKTREE_SEGMENT = `/${GIT_ENTRY}/worktrees/`;
 var NOT_FOUND2 = -1;
 function linked_worktree_gitdir(cwd) {
   try {
-    const contents = readFileSync3(path4.join(cwd, GIT_ENTRY), "utf8").trim();
+    const contents = readFileSync3(path5.join(cwd, GIT_ENTRY), "utf8").trim();
     return contents.startsWith(GITDIR_PREFIX) ? contents.slice(GITDIR_PREFIX.length).trim() : "";
   } catch {
     return "";
@@ -1477,28 +969,28 @@ function linked_worktree_gitdir(cwd) {
 }
 function session_cwd(cwd) {
   const gitdir = linked_worktree_gitdir(cwd);
-  const absolute = gitdir === "" ? "" : path4.resolve(cwd, gitdir);
+  const absolute = gitdir === "" ? "" : path5.resolve(cwd, gitdir);
   const segment = absolute.indexOf(WORKTREE_SEGMENT);
   return segment === NOT_FOUND2 ? cwd : absolute.slice(0, segment);
 }
 function read_directory(directory) {
   try {
-    return readdirSync(directory);
+    return readdirSync2(directory);
   } catch {
     return [];
   }
 }
 function lane_transcript_directories(main_cwd, home) {
-  const projects = path4.join(home, TRANSCRIPT_ROOT);
+  const projects = path5.join(home, TRANSCRIPT_ROOT);
   const prefix = `${project_slug(lane_paths.lane_root(main_cwd))}-`;
   return read_directory(projects).filter(
     (name) => name.startsWith(prefix) && issue_number_shape.ISSUE_NUMBER_PATTERN.test(name.slice(prefix.length))
-  ).map((name) => path4.join(projects, name));
+  ).map((name) => path5.join(projects, name));
 }
 function transcript_directories(cwd, home = homedir()) {
-  const own2 = transcript_directory(cwd, home);
+  const own = transcript_directory(cwd, home);
   const lanes = session_cwd(cwd) === cwd ? lane_transcript_directories(cwd, home) : [];
-  return [.../* @__PURE__ */ new Set([own2, ...lanes])];
+  return [.../* @__PURE__ */ new Set([own, ...lanes])];
 }
 var OWN_DEPTH = 0;
 function home_directory() {
@@ -1524,16 +1016,16 @@ function without_extension(name) {
   return name.slice(0, -TRANSCRIPT_EXTENSION.length);
 }
 function own_files(directory, names) {
-  return names.filter((name) => is_transcript(name)).map((name) => to_session_file(path4.join(directory, name), without_extension(name), OWN_DEPTH)).filter((file) => file !== void 0);
+  return names.filter((name) => is_transcript(name)).map((name) => to_session_file(path5.join(directory, name), without_extension(name), OWN_DEPTH)).filter((file) => file !== void 0);
 }
 function unit_directory(directory, session_id) {
-  return path4.join(directory, session_id, UNIT_DIRECTORY);
+  return path5.join(directory, session_id, UNIT_DIRECTORY);
 }
 var UNIT_DEPTH = 1;
 function level_units(subagents_directory, prefix, depth) {
   return read_directory(subagents_directory).filter((name) => is_transcript(name)).map(
     (name) => to_session_file(
-      path4.join(subagents_directory, name),
+      path5.join(subagents_directory, name),
       `${prefix}${UNIT_ID_SEPARATOR}${without_extension(name)}`,
       depth
     )
@@ -1559,9 +1051,9 @@ function list_sessions(directory) {
     (left, right) => right.modified_ms - left.modified_ms
   );
 }
-function list_sessions_across(directories2) {
+function list_sessions_across(directories) {
   const seen = /* @__PURE__ */ new Set();
-  const merged = directories2.flatMap((directory) => list_sessions(directory));
+  const merged = directories.flatMap((directory) => list_sessions(directory));
   const newest_first = merged.toSorted((left, right) => right.modified_ms - left.modified_ms);
   const kept = [];
   for (const file of newest_first) {
@@ -1625,8 +1117,8 @@ function directory_exists(directory) {
     return false;
   }
 }
-function searched_directories(directories2) {
-  return directories2.map((directory) => ({
+function searched_directories(directories) {
+  return directories.map((directory) => ({
     path: directory,
     exists: directory_exists(directory)
   }));
@@ -1772,11 +1264,11 @@ var own_session = {
 
 // scripts/run/carry/run-carry-conversation.ts
 var CONVERSATION_QUIET_MS = 6e5;
-function own_transcript(environment = process.env, directories2 = cost_transcript.transcript_directories(process.cwd())) {
+function own_transcript(environment = process.env, directories = cost_transcript.transcript_directories(process.cwd())) {
   const session_id = own_session.session_id_of(environment);
   if (session_id === void 0) return void 0;
   const name = `${session_id}${cost_transcript.TRANSCRIPT_EXTENSION}`;
-  return directories2.map((directory) => path5.join(directory, name)).find((file) => existsSync(file));
+  return directories.map((directory) => path6.join(directory, name)).find((file) => existsSync(file));
 }
 function modified_ms(transcript) {
   try {
@@ -1810,7 +1302,7 @@ var run_carry_conversation = {
 };
 
 // scripts/run/carry/run-carry.ts
-var CARRY_PREFIX = "josh-run-carry-";
+var CARRY_PREFIX = durable_state.PREFIX.CARRY;
 var REPOSITORY_DIRECTORY_INDEX = 1;
 var NO_INCREMENT3 = 0;
 var MAX_CUTS = 6;
@@ -1844,11 +1336,11 @@ var run_carry_schema = z2.object({
   lane_limit: z2.number().int().positive().optional()
 });
 function carry_path(git_directory) {
-  return stamp_file.stamp_path(CARRY_PREFIX, git_directory);
+  return durable_state.path(CARRY_PREFIX, git_directory);
 }
 async function repository_directory() {
-  const directories2 = await git_command.git_directories();
-  return directories2[REPOSITORY_DIRECTORY_INDEX];
+  const directories = await git_command.git_directories();
+  return directories[REPOSITORY_DIRECTORY_INDEX];
 }
 function parse_carry(raw) {
   return json_value.parse_with(raw, run_carry_schema);
@@ -1861,11 +1353,11 @@ function classify2(raw) {
   }
   return { kind: "carried", carry };
 }
-function read_carry(target) {
-  return classify2(stamp_file.read_stamp_text(target));
+function read_carry(target2) {
+  return classify2(stamp_file.read_stamp_text(target2));
 }
-function owner_of(pid, read3 = process_identity.read_start, transcript = run_carry_conversation.own_transcript()) {
-  return { pid, start: read3(pid), transcript };
+function owner_of(pid, read = process_identity.read_start, transcript = run_carry_conversation.own_transcript()) {
+  return { pid, start: read(pid), transcript };
 }
 function fresh_carry(invocation, owner, now) {
   return {
@@ -1882,11 +1374,11 @@ function fresh_carry(invocation, owner, now) {
     is_owner_headless: owner.is_headless
   };
 }
-function begin_carry(target, invocation, owner = NO_OWNER, now = /* @__PURE__ */ new Date()) {
+function begin_carry(target2, invocation, owner = NO_OWNER, now = /* @__PURE__ */ new Date()) {
   const carry = fresh_carry(invocation, owner, now);
-  return stamp_file.create_stamp(target, carry) ? carry : void 0;
+  return stamp_file.create_stamp(target2, carry) ? carry : void 0;
 }
-function adopt_carry(target, carry, owner = NO_OWNER) {
+function adopt_carry(target2, carry, owner = NO_OWNER) {
   const next = {
     ...carry,
     owner_pid: owner.pid,
@@ -1895,8 +1387,8 @@ function adopt_carry(target, carry, owner = NO_OWNER) {
     is_owner_headless: owner.is_headless,
     is_handed_off: false
   };
-  stamp_file.remove_stamp(target);
-  return stamp_file.create_stamp(target, next) ? next : void 0;
+  stamp_file.remove_stamp(target2);
+  return stamp_file.create_stamp(target2, next) ? next : void 0;
 }
 function is_owner_live(carry, now = /* @__PURE__ */ new Date(), same_process = process_identity.is_same_process) {
   if (same_process(carry.owner_pid, carry.owner_start) !== false) return true;
@@ -1929,11 +1421,11 @@ function is_count_refused(carry, owner) {
 function is_at_cut_cap(carry) {
   return carry.cuts >= MAX_CUTS;
 }
-function end_carry(target) {
-  stamp_file.remove_stamp(target);
+function end_carry(target2) {
+  stamp_file.remove_stamp(target2);
 }
-function retrospective_done_of(read3) {
-  return read3.kind === "carried" && read3.carry.retrospective === true;
+function retrospective_done_of(read) {
+  return read.kind === "carried" && read.carry.retrospective === true;
 }
 function remaining_of(carry) {
   if (carry === void 0) return void 0;
@@ -2015,88 +1507,413 @@ var run_carry = {
   unreadable_message
 };
 
-// ports/index.js
-import { existsSync as existsSync2 } from "node:fs";
-import path6 from "node:path";
-var PORT_SEED_KEY = "PORT_SEED";
-var LANE_SEAT_KEY = "JOSH_LANE_SEAT";
-var ENV_FILE_NAME = ".env";
-var PACKAGE_FILE_NAME = "package.json";
-var PROJECT_ENVIRONMENT_KEYS = /* @__PURE__ */ new Set([PORT_SEED_KEY, LANE_SEAT_KEY, "PLAYWRIGHT_REUSE_SERVER"]);
-var DEV_PORT_BASE = 5173;
-var PREVIEW_PORT_BASE = 4173;
-var MIN_SEED = 0;
-var SEED_LANE_MULTIPLIER = 10;
-var MAX_LANE = 9;
-var MAX_SEED = 99;
-var INTEGER_PATTERN = /^\d+$/u;
-function fail_invalid(key, raw, max) {
-  throw new Error(
-    `${key} must be an integer between ${MIN_SEED} and ${max}, got ${JSON.stringify(raw)}. Unset it to use the default ports (dev ${DEV_PORT_BASE}, preview ${PREVIEW_PORT_BASE}).`
-  );
+// scripts/lane/lane-ledger-write.ts
+import { closeSync, constants as constants2, openSync, writeSync } from "node:fs";
+
+// scripts/lane/lane-ledger-schema.ts
+import { z as z4 } from "zod";
+
+// scripts/lane/lane-ledger-kind.ts
+var KIND = {
+  MERGE: "merge",
+  GATE: "gate",
+  LOAD: "load",
+  DISPATCH: "dispatch",
+  STAGE: "stage",
+  STOP: "stop",
+  OVERLAP: "overlap",
+  HELD: "held",
+  RELEASED: "released",
+  ROUND_ONE: "round-one",
+  ROUND_TWO: "round-two",
+  OFFERABLE: "offerable",
+  CORE_WAIT: "core-wait",
+  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",
+  SHIP_LAP: "ship-lap"
+};
+var lane_ledger_kind = { KIND };
+
+// scripts/lane/lane-ledger-schema-ship.ts
+import { z as z3 } from "zod";
+var { KIND: KIND2 } = lane_ledger_kind;
+var stop_schema = z3.object({
+  kind: z3.literal(KIND2.STOP),
+  at: z3.string(),
+  issue: z3.number(),
+  reason: z3.string(),
+  cause: z3.string().optional(),
+  preconditions: z3.array(z3.string()).optional(),
+  findings: z3.array(z3.string()).optional()
+});
+var unplanned_notice_schema = z3.object({
+  kind: z3.literal(KIND2.UNPLANNED_NOTICE),
+  at: z3.string(),
+  issue: z3.number(),
+  files: z3.array(z3.string())
+});
+var ship_lap_schema = z3.object({
+  kind: z3.literal(KIND2.SHIP_LAP),
+  at: z3.string(),
+  issue: z3.number(),
+  stage: z3.string(),
+  step: z3.string(),
+  elapsed_ms: z3.number()
+});
+var lane_ledger_schema_ship = { ship_lap_schema, stop_schema, unplanned_notice_schema };
+
+// scripts/lane/lane-ledger-schema.ts
+var { KIND: KIND3 } = lane_ledger_kind;
+var { ship_lap_schema: ship_lap_schema2, stop_schema: stop_schema2, unplanned_notice_schema: unplanned_notice_schema2 } = lane_ledger_schema_ship;
+var merge_schema = z4.object({ kind: z4.literal(KIND3.MERGE), at: z4.string(), issue: z4.number() });
+var check_schema = z4.object({
+  label: z4.string(),
+  elapsed_ms: z4.number(),
+  is_passed: z4.boolean(),
+  is_reused: z4.boolean().optional(),
+  // The CPU milliseconds the check's process tree spent, so a core weight can be re-measured from
+  // the ledger (joshuafolkken/kit#4362). Absent where the gate could not read it (off macOS).
+  cpu_ms: z4.number().optional(),
+  // Why the unit leg ran the whole suite instead of the related tests — a stable kind, never the
+  // file it names (joshuafolkken/kit#4397). Absent when it narrowed, and on every other check.
+  fallback: z4.string().optional(),
+  // The unit leg's since-green no-op: nothing moved, so it ran no test (joshuafolkken/kit#4457).
+  is_unmoved: z4.boolean().optional(),
+  // The width the check asked the core budget for, the width it ran at and how long it waited, so a
+  // unit claim's wait for room is read per run (joshuafolkken/kit#4451). Absent on a check that
+  // claimed none — a reused one, or one inside another gate's claim.
+  claim: z4.object({ requested: z4.number(), granted: z4.number(), waited_ms: z4.number() }).optional()
+});
+var gate_schema = z4.object({
+  kind: z4.literal(KIND3.GATE),
+  at: z4.string(),
+  elapsed_ms: z4.number(),
+  is_passed: z4.boolean(),
+  // The unit suite's own duration, present when this gate ran it — the one
+  // record of a full vitest run `josh metrics` reads, so the suite is never timed twice.
+  unit_ms: z4.number().optional(),
+  // The whole cores busy outside this gate, beyond the machine's baseline, at its start or its end —
+  // whichever was higher. Absent when the machine could not be read.
+  external_cores: z4.number().optional(),
+  // Each check's own duration and verdict, so `josh lane:stats` can name the check a slow gate waited
+  // on. A reused check started no process: its row says so, and its zero is no timing.
+  checks: z4.array(check_schema).optional(),
+  // A gate that reused a green record for this tree and base and started no check: counted, never
+  // timed (joshuafolkken/kit#4397).
+  is_reused: z4.boolean().optional(),
+  // The lane the gate ran in, so `josh lane:breakdown` puts its checks under the lane's ship gate;
+  // absent outside a lane and on a row written before it (joshuafolkken/kit#5319).
+  issue: z4.number().optional()
+});
+var process_kind_schema = z4.object({
+  kind: z4.string(),
+  cpu_percent: z4.number(),
+  rss_mb: z4.number(),
+  count: z4.number()
+});
+var load_schema = z4.object({
+  kind: z4.literal(KIND3.LOAD),
+  at: z4.string(),
+  load: z4.number(),
+  available_mb: z4.number().optional(),
+  swapped_mb: z4.number().optional(),
+  lanes: z4.number().optional(),
+  // The heaviest process kinds at the instant of the sample (`lane-process-load.ts`), so the load the
+  // core budget's ledger does not explain can be read back by what made it (joshuafolkken/kit#3874).
+  processes: z4.array(process_kind_schema).optional()
+});
+var dispatch_schema = z4.object({
+  kind: z4.literal(KIND3.DISPATCH),
+  at: z4.string(),
+  issue: z4.number()
+});
+var stage_schema = z4.object({
+  kind: z4.literal(KIND3.STAGE),
+  at: z4.string(),
+  stage: z4.string(),
+  elapsed_ms: z4.number(),
+  issue: z4.number().optional(),
+  last_check: z4.string().optional(),
+  check_ms: z4.record(z4.string(), z4.number()).optional()
+});
+var overlap_schema = z4.object({
+  kind: z4.literal(KIND3.OVERLAP),
+  at: z4.string(),
+  issue: z4.number(),
+  lanes: z4.array(z4.number()),
+  paths: z4.array(z4.string()),
+  waited_ms: z4.number(),
+  is_cleared: z4.boolean()
+});
+var held_schema = z4.object({
+  kind: z4.literal(KIND3.HELD),
+  at: z4.string(),
+  reason: z4.string(),
+  waiting: z4.array(z4.number()).optional()
+});
+var released_schema = z4.object({ kind: z4.literal(KIND3.RELEASED), at: z4.string() });
+var lane_state_schema = z4.object({
+  kind: z4.literal(KIND3.LANE_STATE),
+  at: z4.string(),
+  issue: z4.number(),
+  state: z4.enum(["paused", "running"])
+});
+var round_one_schema = z4.object({
+  kind: z4.literal(KIND3.ROUND_ONE),
+  at: z4.string(),
+  issue: z4.number(),
+  verdict: z4.string()
+});
+var round_two_schema = z4.object({
+  kind: z4.literal(KIND3.ROUND_TWO),
+  at: z4.string(),
+  issue: z4.number(),
+  verdict: z4.string(),
+  code: z4.string()
+});
+var offerable_schema = z4.object({
+  kind: z4.literal(KIND3.OFFERABLE),
+  at: z4.string(),
+  is_offerable: z4.boolean()
+});
+var core_wait_schema = z4.object({
+  kind: z4.literal(KIND3.CORE_WAIT),
+  at: z4.string(),
+  command: z4.string(),
+  waited_ms: z4.number(),
+  issue: z4.number().optional()
+});
+var unit_file_schema = z4.object({ file: z4.string(), elapsed_ms: z4.number() });
+var unit_files_schema = z4.object({
+  kind: z4.literal(KIND3.UNIT_FILES),
+  at: z4.string(),
+  files: z4.array(unit_file_schema)
+});
+var test_related_schema = z4.object({
+  kind: z4.literal(KIND3.TEST_RELATED),
+  at: z4.string(),
+  scope: z4.string(),
+  changed: z4.number(),
+  synced: z4.number(),
+  since_map: z4.number(),
+  readers: z4.number(),
+  test_files: z4.number().optional(),
+  trigger_files: z4.array(z4.string()).optional(),
+  elapsed_ms: z4.number()
+});
+var pinned_origin_schema = z4.enum(["run-review", "pre-detach", "manual"]);
+var test_pinned_probe_schema = z4.object({
+  file: z4.string(),
+  tests: z4.number().optional(),
+  elapsed_ms: z4.number()
+});
+var test_pinned_schema = z4.object({
+  kind: z4.literal(KIND3.TEST_PINNED),
+  at: z4.string(),
+  issue: z4.number().optional(),
+  held: z4.number(),
+  rewired: z4.number().optional(),
+  probes: z4.array(test_pinned_probe_schema),
+  elapsed_ms: z4.number(),
+  origin: pinned_origin_schema.optional(),
+  discarded: z4.boolean().optional()
+});
+var split_notice_schema = z4.object({
+  kind: z4.literal(KIND3.SPLIT_NOTICE),
+  at: z4.string(),
+  issue: z4.number(),
+  files: z4.number(),
+  lines: z4.number()
+});
+var split_filed_schema = z4.object({
+  kind: z4.literal(KIND3.SPLIT_FILED),
+  at: z4.string(),
+  issue: z4.number(),
+  child: z4.string()
+});
+var push_miss_schema = z4.object({
+  kind: z4.literal(KIND3.PUSH_MISS),
+  at: z4.string(),
+  scope: z4.enum(["whole", "related"]),
+  reason: z4.string()
+});
+var entry_schema = z4.discriminatedUnion("kind", [
+  merge_schema,
+  gate_schema,
+  load_schema,
+  dispatch_schema,
+  stage_schema,
+  stop_schema2,
+  overlap_schema,
+  held_schema,
+  released_schema,
+  round_one_schema,
+  round_two_schema,
+  offerable_schema,
+  core_wait_schema,
+  unit_files_schema,
+  test_related_schema,
+  test_pinned_schema,
+  split_notice_schema,
+  split_filed_schema,
+  unplanned_notice_schema2,
+  lane_state_schema,
+  push_miss_schema,
+  ship_lap_schema2
+]);
+var lane_ledger_schema = { KIND: KIND3, entry_schema, pinned_origin_schema };
+
+// 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 } = constants2;
+var APPEND_FLAGS = O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW;
+var { KIND: KIND4 } = lane_ledger_schema;
+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 read_trimmed(environment, key) {
-  const raw = environment[key];
-  return raw === void 0 ? "" : raw.trim();
+function append(path12, entry) {
+  const descriptor = openSync(path12, APPEND_FLAGS, LEDGER_FILE_MODE);
+  try {
+    if (stamp_file.is_own_regular_file(path12)) {
+      writeSync(descriptor, `${JSON.stringify(entry)}${LINE_SEPARATOR}`);
+    }
+  } finally {
+    closeSync(descriptor);
+  }
 }
-function resolve_bounded(environment, key, max) {
-  const trimmed = read_trimmed(environment, key);
-  if (trimmed.length === 0) return MIN_SEED;
-  if (!INTEGER_PATTERN.test(trimmed)) fail_invalid(key, trimmed, max);
-  const value = Number(trimmed);
-  if (value > max) fail_invalid(key, trimmed, max);
-  return value;
+async function record(entry, path12) {
+  try {
+    const destination = path12 ?? await target();
+    if (destination !== void 0) append(destination, entry);
+  } catch {
+  }
 }
-function resolve_seed(environment = process.env) {
-  return resolve_bounded(environment, PORT_SEED_KEY, MAX_SEED);
+function now_iso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
 }
-function resolve_lane(environment = process.env) {
-  return resolve_bounded(environment, LANE_SEAT_KEY, MAX_LANE);
+async function record_gate(path12, gate) {
+  await record({ kind: KIND4.GATE, at: now_iso(), ...gate }, path12);
 }
-function resolve_offset(environment = process.env) {
-  return resolve_seed(environment) * SEED_LANE_MULTIPLIER + resolve_lane(environment);
+async function record_merge(issue2, at = /* @__PURE__ */ new Date()) {
+  await record({ kind: KIND4.MERGE, at: at.toISOString(), issue: issue2 });
 }
-function offset_from(base, environment) {
-  return base + resolve_offset(environment);
+async function record_dispatch(issue2, path12) {
+  await record({ kind: KIND4.DISPATCH, at: now_iso(), issue: issue2 }, path12);
 }
-function resolve_development_port(environment = process.env) {
-  return offset_from(DEV_PORT_BASE, environment);
+async function record_stage(stage, path12) {
+  await record({ kind: KIND4.STAGE, at: now_iso(), ...stage }, path12);
 }
-function resolve_preview_port(environment = process.env) {
-  return offset_from(PREVIEW_PORT_BASE, environment);
+async function record_stop(stop, path12) {
+  await record({ kind: KIND4.STOP, at: now_iso(), ...stop }, path12);
 }
-function resolve_project_directory(directory) {
-  const start = path6.resolve(directory);
-  let current = start;
-  while (!existsSync2(path6.join(current, PACKAGE_FILE_NAME))) {
-    const parent = path6.dirname(current);
-    if (parent === current) return start;
-    current = parent;
-  }
-  return current;
+async function record_overlap(overlap, path12) {
+  await record({ kind: KIND4.OVERLAP, at: now_iso(), ...overlap }, path12);
 }
-function discard_loaded_keys(snapshot) {
-  for (const key of Object.keys(process.env)) {
-    if (!PROJECT_ENVIRONMENT_KEYS.has(key) && !Object.hasOwn(snapshot, key)) {
-      Reflect.deleteProperty(process.env, key);
-    }
-  }
+async function record_held(held, path12) {
+  const waiting = held.waiting ?? [];
+  const named = waiting.length > 0 ? { waiting: [...waiting] } : {};
+  await record({ kind: KIND4.HELD, at: now_iso(), reason: held.reason, ...named }, path12);
 }
-function load_environment_file(directory = process.cwd()) {
-  const file = path6.join(resolve_project_directory(directory), ENV_FILE_NAME);
-  if (!existsSync2(file)) return false;
-  const snapshot = { ...process.env };
-  process.loadEnvFile(file);
-  discard_loaded_keys(snapshot);
-  return true;
+async function record_released(path12) {
+  await record({ kind: KIND4.RELEASED, at: now_iso() }, path12);
 }
-var ports = {
-  load_environment_file,
-  resolve_project_directory,
-  resolve_seed,
-  resolve_lane,
-  resolve_development_port,
-  resolve_preview_port
+async function record_lane_state(change, path12) {
+  await record({ kind: KIND4.LANE_STATE, at: now_iso(), ...change }, path12);
+}
+async function record_offerable(is_offerable, path12) {
+  await record({ kind: KIND4.OFFERABLE, at: now_iso(), is_offerable }, path12);
+}
+async function record_round_one(round_one, path12) {
+  await record({ kind: KIND4.ROUND_ONE, at: now_iso(), ...round_one }, path12);
+}
+async function record_round_two(round_two, path12) {
+  await record({ kind: KIND4.ROUND_TWO, at: now_iso(), ...round_two }, path12);
+}
+async function record_core_wait(wait, path12) {
+  await record({ kind: KIND4.CORE_WAIT, at: now_iso(), ...wait }, path12);
+}
+async function record_unit_files(files, path12) {
+  await record({ kind: KIND4.UNIT_FILES, at: now_iso(), files: [...files] }, path12);
+}
+async function record_test_related(run, path12) {
+  await record({ kind: KIND4.TEST_RELATED, at: now_iso(), ...run }, path12);
+}
+async function record_test_pinned(run, path12) {
+  await record({ kind: KIND4.TEST_PINNED, at: now_iso(), ...run }, path12);
+}
+async function record_split_notice(notice, path12) {
+  await record({ kind: KIND4.SPLIT_NOTICE, at: now_iso(), ...notice }, path12);
+}
+async function record_split_filed(filed, path12) {
+  await record({ kind: KIND4.SPLIT_FILED, at: now_iso(), ...filed }, path12);
+}
+async function record_push_miss(miss, path12) {
+  await record({ kind: KIND4.PUSH_MISS, at: now_iso(), ...miss }, path12);
+}
+async function record_ship_lap(lap, path12) {
+  await record({ kind: KIND4.SHIP_LAP, at: now_iso(), ...lap }, path12);
+}
+async function record_unplanned_notice(notice, path12) {
+  await record({ kind: KIND4.UNPLANNED_NOTICE, at: now_iso(), ...notice }, path12);
+}
+var lane_ledger_write = {
+  CI_WAIT_STAGE,
+  CODERABBIT_RATE_LIMIT_STAGE,
+  CODERABBIT_RETRIGGER_STAGE,
+  CODERABBIT_WAIT_STAGE,
+  KIND: KIND4,
+  LINE_SEPARATOR,
+  PRE_DETACH_STAGE,
+  ROUND_ONE_REUSED,
+  append,
+  record,
+  record_core_wait,
+  record_dispatch,
+  record_gate,
+  record_held,
+  record_lane_state,
+  record_released,
+  record_merge,
+  record_overlap,
+  record_offerable,
+  record_push_miss,
+  record_round_one,
+  record_round_two,
+  record_ship_lap,
+  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
 };
 
 // scripts/issue/issue-cite.ts
@@ -2138,17 +1955,17 @@ function bare_target(token, default_repo) {
 function parse_target(token, default_repo) {
   return qualified_target(token) ?? bare_target(token, default_repo);
 }
-function label(target) {
-  return plain(target.number, target.repo);
+function label(target2) {
+  return plain(target2.number, target2.repo);
 }
-function missing_line(target) {
-  return `\u2716 ${label(target)}: issue does not resolve \u2014 check the number and the repository`;
+function missing_line(target2) {
+  return `\u2716 ${label(target2)}: issue does not resolve \u2014 check the number and the repository`;
 }
-function unreadable_line(target) {
-  return `\u2716 ${label(target)}: could not be read \u2014 a rate limit, expired auth, or a dropped connection`;
+function unreadable_line(target2) {
+  return `\u2716 ${label(target2)}: could not be read \u2014 a rate limit, expired auth, or a dropped connection`;
 }
-function no_repo_line(target) {
-  return `\u2716 ${label(target)}: could not read this repository \u2014 check gh auth and the origin remote`;
+function no_repo_line(target2) {
+  return `\u2716 ${label(target2)}: could not read this repository \u2014 check gh auth and the origin remote`;
 }
 var issue_cite = {
   citation_line,
@@ -2162,65 +1979,8 @@ var issue_cite = {
   unreadable_line
 };
 
-// scripts/git/git-common-directory.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
-var OWN_GIT_DIRECTORY = 0;
-var COMMON_GIT_DIRECTORY = 1;
-var PROBE_TIMEOUT_MS2 = 5e3;
-var answers = /* @__PURE__ */ new Map();
-function probe_environment(cwd) {
-  if (cwd === void 0) return process.env;
-  return { ...process.env, ...git_location_environment.location_free_environment() };
-}
-function cache_key(cwd) {
-  if (cwd !== void 0) return `explicit\0${cwd}`;
-  const locations = GIT_LOCATION_VARIABLES.map((name) => process.env[name] ?? "");
-  return ["inherited", process.cwd(), ...locations].join("\0");
-}
-function read_directories(cwd) {
-  try {
-    const output = execFileSync2(
-      git_utilities.get_git_command_for_spawn(),
-      [...git_command.GIT_DIRECTORY_ARGUMENTS],
-      {
-        cwd,
-        env: probe_environment(cwd),
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-        timeout: PROBE_TIMEOUT_MS2
-      }
-    );
-    return output.split("\n").filter((line) => line !== "");
-  } catch {
-    return [];
-  }
-}
-function directories(cwd) {
-  const key = cache_key(cwd);
-  const known = answers.get(key);
-  if (known !== void 0) return known;
-  const read3 = read_directories(cwd);
-  if (read3.length > 0) answers.set(key, read3);
-  return read3;
-}
-function own(cwd) {
-  return directories(cwd)[OWN_GIT_DIRECTORY];
-}
-function repository(cwd) {
-  return directories(cwd)[COMMON_GIT_DIRECTORY];
-}
-function select_linked(found) {
-  const own_directory = found[OWN_GIT_DIRECTORY];
-  const common = found[COMMON_GIT_DIRECTORY];
-  return own_directory === void 0 || common === void 0 || own_directory === common ? void 0 : common;
-}
-function resolve(cwd) {
-  return select_linked(directories(cwd));
-}
-var git_common_directory = { directories, own, repository, resolve, select_linked };
-
 // scripts/run/ship/run-ship-stage.ts
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 var STAGE = {
   PREFLIGHT: "preflight",
   REVIEW: "review",
@@ -2245,11 +2005,12 @@ var WORD_SEPARATOR = " ";
 var STARTED_SEPARATOR = ",";
 var STARTED_INDEX = 3;
 var WORD_COUNT = STARTED_INDEX + 1;
-var record_schema = z3.object({
-  done: z3.array(z3.string()),
-  started: z3.array(z3.string()).default([]),
-  is_merge_waiting: z3.boolean().default(false),
-  is_place_waiting: z3.boolean().default(false)
+var REASON_SEPARATOR = " | ";
+var record_schema = z5.object({
+  done: z5.array(z5.string()),
+  started: z5.array(z5.string()).default([]),
+  is_merge_waiting: z5.boolean().default(false),
+  is_place_waiting: z5.boolean().default(false)
 });
 var EMPTY_RECORD = {
   done: [],
@@ -2257,70 +2018,70 @@ var EMPTY_RECORD = {
   is_merge_waiting: false,
   is_place_waiting: false
 };
-function record_path(repository2, issue2) {
-  return stamp_file.stamp_path(`${RECORD_PREFIX}${issue2}${RECORD_SEPARATOR}`, repository2);
+function record_path(repository, issue2) {
+  return stamp_file.stamp_path(`${RECORD_PREFIX}${issue2}${RECORD_SEPARATOR}`, repository);
 }
 function parse_record(raw) {
   return json_value.parse_with(raw, record_schema) ?? EMPTY_RECORD;
 }
-function read_record(target) {
-  const raw = stamp_file.read_stamp_text(target);
+function read_record(target2) {
+  const raw = stamp_file.read_stamp_text(target2);
   return raw === void 0 ? EMPTY_RECORD : parse_record(raw);
 }
-function read_done(target) {
-  return new Set(read_record(target).done);
+function read_done(target2) {
+  return new Set(read_record(target2).done);
 }
-function mark_done(target, stage) {
-  const record = read_record(target);
-  stamp_file.replace_stamp(target, { ...record, done: [.../* @__PURE__ */ new Set([...record.done, stage])] });
+function mark_done(target2, stage) {
+  const record2 = read_record(target2);
+  stamp_file.replace_stamp(target2, { ...record2, done: [.../* @__PURE__ */ new Set([...record2.done, stage])] });
 }
-function read_started(target) {
-  return read_record(target).started;
+function read_started(target2) {
+  return read_record(target2).started;
 }
-function mark_started(target, stage) {
-  const record = read_record(target);
-  stamp_file.replace_stamp(target, { ...record, started: [.../* @__PURE__ */ new Set([...record.started, stage])] });
+function mark_started(target2, stage) {
+  const record2 = read_record(target2);
+  stamp_file.replace_stamp(target2, { ...record2, started: [.../* @__PURE__ */ new Set([...record2.started, stage])] });
 }
-function end_attempt(target) {
-  stamp_file.replace_stamp(target, { ...read_record(target), started: [], is_merge_waiting: false });
+function end_attempt(target2) {
+  stamp_file.replace_stamp(target2, { ...read_record(target2), started: [], is_merge_waiting: false });
 }
-function read_merge_waiting(target) {
-  return read_record(target).is_merge_waiting;
+function read_merge_waiting(target2) {
+  return read_record(target2).is_merge_waiting;
 }
-function mark_merge_waiting(target, is_merge_waiting) {
-  stamp_file.replace_stamp(target, { ...read_record(target), is_merge_waiting });
+function mark_merge_waiting(target2, is_merge_waiting) {
+  stamp_file.replace_stamp(target2, { ...read_record(target2), is_merge_waiting });
 }
-function read_place_waiting(target) {
-  return read_record(target).is_place_waiting;
+function read_place_waiting(target2) {
+  return read_record(target2).is_place_waiting;
 }
-function mark_place_waiting(target, is_place_waiting) {
-  stamp_file.replace_stamp(target, { ...read_record(target), is_place_waiting });
+function mark_place_waiting(target2, is_place_waiting) {
+  stamp_file.replace_stamp(target2, { ...read_record(target2), is_place_waiting });
 }
-function clear_waits(target) {
-  stamp_file.replace_stamp(target, {
-    ...read_record(target),
+function clear_waits(target2) {
+  stamp_file.replace_stamp(target2, {
+    ...read_record(target2),
     is_merge_waiting: false,
     is_place_waiting: false
   });
 }
-function clear(target) {
-  stamp_file.remove_stamp(target);
+function clear(target2) {
+  stamp_file.remove_stamp(target2);
 }
 function is_shipped(state) {
   return state.is_committed && state.is_pushed;
 }
 var DONE_BY = {
   // The preflight asks what the commit stage would refuse on, so a commit is
-  // its output as it is the gate's; a resumed commit stage still asks `git -y`'s own preflight.
-  [STAGE.PREFLIGHT]: (_done, state) => state.is_merged || state.is_committed,
-  // The `--review` round precedes the commit, so a commit is its output as it
-  // is the gate's. A record alone is not honored: before a commit the tree may have been edited since
-  // the recorded round, and only a commit pins the tree that round read — unless the issue changed since.
-  [STAGE.REVIEW]: (_done, state) => state.is_merged || state.is_committed && state.is_review_stale !== true,
-  [STAGE.GATE]: (_done, state) => state.is_merged || state.is_committed,
-  // The merge of the default branch before the commit: once committed, a
-  // conflicting pull request is the followup's to merge again.
-  [STAGE.SYNC]: (_done, state) => state.is_merged || state.is_committed,
+  // its output; a resumed commit stage still asks `git -y`'s own preflight.
+  [STAGE.PREFLIGHT]: (done, state) => state.is_merged || done.has(STAGE.PREFLIGHT) && state.is_committed,
+  // The sync stage commits locally before the review round and the gate, without pushing
+  // (`run-ship-sync.ts`), so a commit is neither's output: a pushed one on a clean tree is, as only the
+  // commit stage after the gate pushes — unless the issue changed since.
+  [STAGE.REVIEW]: (done, state) => state.is_merged || done.has(STAGE.REVIEW) && is_shipped(state) && state.is_review_stale !== true,
+  [STAGE.GATE]: (done, state) => state.is_merged || done.has(STAGE.GATE) && is_shipped(state),
+  // The merge of the default branch before the gate: once pushed, a default branch that
+  // moved is the followup's to merge again.
+  [STAGE.SYNC]: (done, state) => state.is_merged || done.has(STAGE.SYNC) && is_shipped(state),
   [STAGE.COMMIT]: (done, state) => state.is_merged || done.has(STAGE.COMMIT) && is_shipped(state),
   // The round-2 pass reads the pushed fix delta, so its record is honored only
   // while that push still stands — new work pushed on top reruns it.
@@ -2344,8 +2105,22 @@ function event_text(issue2, stage, phase, started = []) {
   const full = started.length > 0 ? [...words, listed] : words;
   return full.join(WORD_SEPARATOR);
 }
+function with_reason(text2, reason) {
+  return reason === void 0 ? text2 : `${text2}${REASON_SEPARATOR}${reason}`;
+}
+function words_part(text2) {
+  return text2.split(REASON_SEPARATOR, 1)[0] ?? "";
+}
 function started_of(text2) {
-  return text2.split(WORD_SEPARATOR, WORD_COUNT)[STARTED_INDEX]?.split(STARTED_SEPARATOR);
+  return words_part(text2).split(WORD_SEPARATOR, WORD_COUNT)[STARTED_INDEX]?.split(STARTED_SEPARATOR);
+}
+function words_of(text2) {
+  const [, stage = "", phase = ""] = words_part(text2).split(WORD_SEPARATOR, WORD_COUNT);
+  return { stage, phase };
+}
+function reason_of(text2) {
+  const at = text2.indexOf(REASON_SEPARATOR);
+  return at === -1 ? void 0 : text2.slice(at + REASON_SEPARATOR.length);
 }
 var CONFLICT = "conflict";
 function stop_reason(stage, conflicts = []) {
@@ -2361,6 +2136,7 @@ var run_ship_stage = {
   end_attempt,
   event_text,
   is_done,
+  is_shipped,
   mark_done,
   mark_merge_waiting,
   mark_place_waiting,
@@ -2369,19 +2145,22 @@ var run_ship_stage = {
   read_merge_waiting,
   read_place_waiting,
   read_started,
+  reason_of,
   record_path,
   started_of,
+  with_reason,
+  words_of,
   stop_reason
 };
 
 // scripts/git/repository-lock.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { linkSync, renameSync, rmSync as rmSync2 } from "node:fs";
+import { linkSync, renameSync, rmSync as rmSync3 } from "node:fs";
 import { setTimeout as sleep } from "node:timers/promises";
 
 // scripts/josh/process-owner.ts
-import { z as z4 } from "zod";
-var process_owner_schema = z4.object({ pid: z4.number(), process_start: z4.string().optional() });
+import { z as z6 } from "zod";
+var process_owner_schema = z6.object({ pid: z6.number(), process_start: z6.string().optional() });
 
 // scripts/git/repository-lock.ts
 var POLL_INTERVAL_MS = 200;
@@ -2395,53 +2174,53 @@ function parse_owner(raw) {
   const parsed = process_owner_schema.safeParse(json_value.parse_or_undefined(raw));
   return parsed.success ? parsed.data : void 0;
 }
-function read_owner(target) {
-  return parse_owner(stamp_file.read_stamp_text(target));
+function read_owner(target2) {
+  return parse_owner(stamp_file.read_stamp_text(target2));
 }
 function is_owner_gone(owner) {
   return process_identity.is_same_process(owner.pid, owner.process_start) === false;
 }
-function restore(aside, target) {
+function restore(aside, target2) {
   try {
-    linkSync(aside, target);
+    linkSync(aside, target2);
   } catch {
   }
 }
-function stale_record(target, is_gone) {
-  const raw = stamp_file.read_stamp_text(target);
+function stale_record(target2, is_gone) {
+  const raw = stamp_file.read_stamp_text(target2);
   const owner = parse_owner(raw);
   return owner !== void 0 && is_gone(owner) ? raw : void 0;
 }
-function move_aside(target) {
-  const aside = `${target}.${String(process.pid)}.${randomUUID2()}`;
+function move_aside(target2) {
+  const aside = `${target2}.${String(process.pid)}.${randomUUID2()}`;
   try {
-    renameSync(target, aside);
+    renameSync(target2, aside);
     return aside;
   } catch {
     return void 0;
   }
 }
-function clear_stale(target, is_gone = is_owner_gone) {
-  const raw = stale_record(target, is_gone);
+function clear_stale(target2, is_gone = is_owner_gone) {
+  const raw = stale_record(target2, is_gone);
   if (raw === void 0) return;
-  const aside = move_aside(target);
+  const aside = move_aside(target2);
   if (aside === void 0) return;
-  if (stamp_file.read_stamp_text(aside) !== raw) restore(aside, target);
-  rmSync2(aside, { force: true });
+  if (stamp_file.read_stamp_text(aside) !== raw) restore(aside, target2);
+  rmSync3(aside, { force: true });
 }
-function claim(target) {
-  clear_stale(target);
-  return stamp_file.create_stamp(target, process_identity.own_fields());
+function claim(target2) {
+  clear_stale(target2);
+  return stamp_file.create_stamp(target2, process_identity.own_fields());
 }
-function release(target) {
-  const owner = read_owner(target);
+function release(target2) {
+  const owner = read_owner(target2);
   if (owner !== void 0 && process_identity.is_own_process(owner.pid, owner.process_start)) {
-    stamp_file.remove_stamp(target);
+    stamp_file.remove_stamp(target2);
   }
 }
-async function acquire(target, max_wait_ms) {
+async function acquire(target2, max_wait_ms) {
   const deadline = Date.now() + max_wait_ms;
-  while (!claim(target)) {
+  while (!claim(target2)) {
     if (Date.now() >= deadline) return false;
     await sleep(POLL_INTERVAL_MS);
   }
@@ -2450,40 +2229,40 @@ async function acquire(target, max_wait_ms) {
 function sleep_sync(ms) {
   Atomics.wait(SLEEP_CELL, 0, 0, ms);
 }
-function acquire_sync(target, max_wait_ms) {
+function acquire_sync(target2, max_wait_ms) {
   const deadline = Date.now() + max_wait_ms;
-  while (!claim(target)) {
+  while (!claim(target2)) {
     if (Date.now() >= deadline) return false;
     sleep_sync(SYNC_POLL_INTERVAL_MS);
   }
   return true;
 }
-async function with_lock(work, target, max_wait_ms) {
-  if (!await acquire(target, max_wait_ms)) return void 0;
+async function with_lock(work, target2, max_wait_ms) {
+  if (!await acquire(target2, max_wait_ms)) return void 0;
   try {
     return await work();
   } finally {
-    release(target);
+    release(target2);
   }
 }
-function with_lock_sync(work, target, max_wait_ms) {
-  if (!acquire_sync(target, max_wait_ms)) return void 0;
+function with_lock_sync(work, target2, max_wait_ms) {
+  if (!acquire_sync(target2, max_wait_ms)) return void 0;
   try {
     return work();
   } finally {
-    release(target);
+    release(target2);
   }
 }
 var repository_lock = { clear_stale, lock_path, with_lock, with_lock_sync };
 
 // scripts/run/event/run-event-stream.ts
-import { z as z5 } from "zod";
-var EVENT_PREFIX = "josh-run-events-";
+import { z as z7 } from "zod";
+var EVENT_PREFIX = durable_state.PREFIX.EVENTS;
 var EVENT_SUFFIX = ".jsonl";
 var EVENT_CAP = 15e3;
 var FIRST_POSITION = 0;
 var POSITION_INCREMENT = 1;
-var LINE_SEPARATOR = "\n";
+var LINE_SEPARATOR2 = "\n";
 var WORD_SEPARATOR2 = " ";
 var STAGE_PHASE_INDEX = 2;
 var LOCK_SUFFIX = ".lock";
@@ -2495,6 +2274,10 @@ var EVENT_KIND = {
   PARK: "park",
   SPLIT: "split",
   OUTAGE: "outage",
+  // A Claude usage limit stopped a lane child (joshuafolkken/kit#4745). Its text names the reset time,
+  // which `backlog:drive` reads to hold launches until then; it counts against no streak, so it is not an
+  // `OUTAGE`.
+  USAGE_LIMIT: "usage-limit",
   CUT: "cut",
   // A fresh session adopted an implementation cut — `run:cut --resume` answered `resume-impl`. The
   // resume clears the cut record, so without this the `cut` would stay the newest position and
@@ -2555,6 +2338,11 @@ var EVENT_KIND = {
   // The position that hands control back: `run:step` prints the command that
   // shows the stopped report, so the agent fixes it and relaunches rather than rebuilding the context.
   SHIP_STOP: "ship-stop",
+  // The relaunch meant to answer a `SHIP_STOP` started nothing — the broker refused it, or the direct
+  // spawn failed (joshuafolkken/kit#4765). `run:merge` reads it, not the transcript's mtime, to tell the
+  // stop went unanswered, and a re-dispatch cap's park names its reason. A trace: the stop stays the
+  // position `run:step` answers.
+  RELAUNCH_FAILED: "relaunch-failed",
   // An Issue the run filed on its way, written by `issue:file`, so a run started from the command line
   // still surfaces what it found — `run:board`'s findings section reads it.
   FILED: "filed",
@@ -2595,7 +2383,15 @@ var EVENT_KIND = {
   // `backlog:drive` found nothing of the run in flight and only paused lanes left, paused past the
   // silent window (joshuafolkken/kit#4270). Emitted once per pause episode (`emit_once_since_with`,
   // reset by `LANE_STATE`), it is the dedup marker for the one paused-lane Telegram. A trace.
-  PAUSED_NOTICE: "paused-notice"
+  PAUSED_NOTICE: "paused-notice",
+  // `backlog:drive` ran a due issue's measurement declaration itself, found it within its bound and
+  // closed the issue through `issue:measured` — no lane was launched for it (joshuafolkken/kit#4621).
+  // `run:board` draws it merged. A trace: the parent's position is the drive's, not this close.
+  MEASURED: "measured",
+  // The host slept while `backlog:drive` sampled its load (joshuafolkken/kit#5032): the sampler's timer
+  // ran late by more than a few intervals. `at` is the wake and `elapsed_ms` how long the sleep
+  // lasted; every lane's net time takes it out (`lane-sleep.ts`). A trace.
+  SLEEP: "sleep"
 };
 var EVENT_KINDS = Object.values(EVENT_KIND);
 var TRACE_KINDS = /* @__PURE__ */ new Set([
@@ -2610,7 +2406,10 @@ var TRACE_KINDS = /* @__PURE__ */ new Set([
   EVENT_KIND.PR_CHECKS,
   EVENT_KIND.IDLE_NOTICE,
   EVENT_KIND.LANE_STATE,
-  EVENT_KIND.PAUSED_NOTICE
+  EVENT_KIND.PAUSED_NOTICE,
+  EVENT_KIND.MEASURED,
+  EVENT_KIND.RELAUNCH_FAILED,
+  EVENT_KIND.SLEEP
 ]);
 var DISPOSABLE_KINDS = /* @__PURE__ */ new Set([
   EVENT_KIND.SHIP_STAGE,
@@ -2618,20 +2417,21 @@ var DISPOSABLE_KINDS = /* @__PURE__ */ new Set([
   EVENT_KIND.SETUP,
   EVENT_KIND.PR_CHECKS
 ]);
-var event_schema = z5.object({
-  pos: z5.number(),
-  at: z5.string(),
-  kind: z5.string(),
-  text: z5.string(),
+var event_schema = z7.object({
+  pos: z7.number(),
+  at: z7.string(),
+  kind: z7.string(),
+  text: z7.string(),
   // The child's time on a lane, recorded once by the writer of an ending (joshuafolkken/kit#4481), so a
-  // reader never has to find its launch again. An event written before it has none.
-  elapsed_ms: z5.number().optional()
+  // reader never has to find its launch again. An event written before it has none. A `sleep` event
+  // carries the sleep's length here.
+  elapsed_ms: z7.number().optional()
 });
 function is_event_kind(value) {
   return EVENT_KINDS.includes(value);
 }
-function target_of(repository2) {
-  return stamp_file.stamp_path(EVENT_PREFIX, repository2, EVENT_SUFFIX);
+function target_of2(repository) {
+  return durable_state.path(EVENT_PREFIX, repository, EVENT_SUFFIX);
 }
 function is_present(event) {
   return event !== void 0;
@@ -2639,13 +2439,13 @@ function is_present(event) {
 function parse_line2(line) {
   return event_schema.safeParse(json_value.parse_or_undefined(line)).data;
 }
-function read_lines(target) {
-  const raw = stamp_file.read_stamp_text(target);
+function read_lines(target2) {
+  const raw = stamp_file.read_stamp_text(target2);
   if (raw === void 0) return [];
-  return raw.split(LINE_SEPARATOR).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => parse_line2(line)).filter(is_present);
+  return raw.split(LINE_SEPARATOR2).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => parse_line2(line)).filter(is_present);
 }
-function read_events(target) {
-  return read_lines(target).filter((event) => is_event_kind(event.kind));
+function read_events(target2) {
+  return read_lines(target2).filter((event) => is_event_kind(event.kind));
 }
 function last_position(events) {
   return events[events.length - POSITION_INCREMENT]?.pos ?? FIRST_POSITION;
@@ -2687,19 +2487,19 @@ function bounded(events) {
   return events.filter((event) => !dropped.has(event)).slice(-EVENT_CAP);
 }
 function serialize(events) {
-  return `${events.map((event) => JSON.stringify(event)).join(LINE_SEPARATOR)}${LINE_SEPARATOR}`;
+  return `${events.map((event) => JSON.stringify(event)).join(LINE_SEPARATOR2)}${LINE_SEPARATOR2}`;
 }
-function append_held(target, event) {
-  const position = last_position(read_lines(target)) + POSITION_INCREMENT;
-  const events = bounded([...read_events(target), { pos: position, ...event }]);
-  stamp_file.replace_text_stamp(target, serialize(events));
+function append_held(target2, event) {
+  const position = last_position(read_lines(target2)) + POSITION_INCREMENT;
+  const events = bounded([...read_events(target2), { pos: position, ...event }]);
+  stamp_file.replace_text_stamp(target2, serialize(events));
   return position;
 }
-function append_event(target, event) {
+function append_event(target2, event) {
   if (!is_event_kind(event.kind)) return { appended: false, position: FIRST_POSITION };
-  const lock = `${target}${LOCK_SUFFIX}`;
+  const lock = `${target2}${LOCK_SUFFIX}`;
   const position = repository_lock.with_lock_sync(
-    () => append_held(target, event),
+    () => append_held(target2, event),
     lock,
     LOCK_WAIT_MS
   );
@@ -2711,18 +2511,18 @@ function append_event(target, event) {
   }
   return { appended: true, position };
 }
-function append(target, kind, text2, at) {
-  return append_event(target, { at, kind, text: text2 });
+function append2(target2, kind, text2, at) {
+  return append_event(target2, { at, kind, text: text2 });
 }
-function read_from(target, position) {
-  const events = read_events(target);
+function read_from(target2, position) {
+  const events = read_events(target2);
   return {
     events: events.filter((event) => event.pos > position),
     next_position: last_position(events)
   };
 }
-function read_last(target) {
-  return read_events(target).findLast((event) => !TRACE_KINDS.has(event.kind));
+function read_last(target2) {
+  return read_events(target2).findLast((event) => !TRACE_KINDS.has(event.kind));
 }
 function has_since(events, kind, reset_kind) {
   const reset_at = events.findLastIndex((event) => event.kind === reset_kind);
@@ -2737,7 +2537,7 @@ var run_event_stream = {
   EVENT_KIND,
   EVENT_KINDS,
   TRACE_KINDS,
-  append,
+  append: append2,
   append_event,
   format_event,
   has_since,
@@ -2745,280 +2545,7 @@ var run_event_stream = {
   read_events,
   read_from,
   read_last,
-  target_of
-};
-
-// scripts/discovery/repo-origin.ts
-var GITHUB_HOST = "github.com";
-var SSH_ALIAS_PATTERN = /^github(?:-\w+)*$/u;
-var GIT_SUFFIX = ".git";
-var PATH_SEPARATOR2 = "/";
-var USER_SEPARATOR = "@";
-var HOST_SEPARATOR = ":";
-var OWNER_INDEX = 0;
-var REPO_INDEX = 1;
-var REPO_PATH_SEGMENTS = 2;
-var NOT_FOUND4 = -1;
-var SECTION_PREFIX = "[";
-var ORIGIN_SECTION = /^\[remote\s+"origin"\]$/u;
-var REMOTE_SECTION = /^\[remote\s+"[^"]+"\]$/u;
-var URL_KEY = "url";
-function is_github_hostname(host) {
-  return host.toLowerCase() === GITHUB_HOST;
-}
-function is_github_ssh_host(host) {
-  const normalized = host.toLowerCase();
-  return is_github_hostname(normalized) || SSH_ALIAS_PATTERN.test(normalized);
-}
-function strip_git_suffix(name) {
-  return name.endsWith(GIT_SUFFIX) ? name.slice(0, -GIT_SUFFIX.length) : name;
-}
-function to_identity(repository_path) {
-  const segments = repository_path.split(PATH_SEPARATOR2).filter((segment) => segment !== "");
-  if (segments.length !== REPO_PATH_SEGMENTS) return void 0;
-  const owner = segments[OWNER_INDEX] ?? "";
-  const repo = strip_git_suffix(segments[REPO_INDEX] ?? "");
-  return repo === "" ? void 0 : { owner, repo };
-}
-function parse_scp_like(url) {
-  const user_end = url.indexOf(USER_SEPARATOR);
-  const authority = user_end === NOT_FOUND4 ? url : url.slice(user_end + 1);
-  const host_end = authority.indexOf(HOST_SEPARATOR);
-  if (host_end === NOT_FOUND4 || !is_github_ssh_host(authority.slice(0, host_end))) return void 0;
-  return to_identity(authority.slice(host_end + 1));
-}
-function parse_url_like(url) {
-  try {
-    const parsed = new URL(url);
-    return is_github_hostname(parsed.hostname) ? to_identity(parsed.pathname) : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function parse_origin_url(url) {
-  const trimmed = url.trim();
-  if (trimmed === "") return void 0;
-  return parse_url_like(trimmed) ?? parse_scp_like(trimmed);
-}
-function is_section_header(line) {
-  return line.startsWith(SECTION_PREFIX);
-}
-function origin_section_lines(lines) {
-  const start = lines.findIndex((line) => ORIGIN_SECTION.test(line));
-  if (start === NOT_FOUND4) return [];
-  const rest = lines.slice(start + 1);
-  const end = rest.findIndex((line) => is_section_header(line));
-  return end === NOT_FOUND4 ? rest : rest.slice(0, end);
-}
-function url_value(line) {
-  const separator = line.indexOf("=");
-  if (separator === NOT_FOUND4 || line.slice(0, separator).trim() !== URL_KEY) return void 0;
-  return line.slice(separator + 1).trim();
-}
-function parse_origin_from_config(content) {
-  const lines = content.split("\n").map((line) => line.trim());
-  return origin_section_lines(lines).map((line) => url_value(line)).find((url) => url !== void 0);
-}
-function section_groups(lines) {
-  const groups = [];
-  for (const line of lines) {
-    if (is_section_header(line)) groups.push([line]);
-    else groups.at(-1)?.push(line);
-  }
-  return groups;
-}
-function parse_remote_urls_from_config(content) {
-  const lines = content.split("\n").map((line) => line.trim());
-  return section_groups(lines).filter((group) => REMOTE_SECTION.test(group[0] ?? "")).flatMap((group) => group.map((line) => url_value(line))).filter((url) => url !== void 0);
-}
-function format_identity(identity) {
-  return `${identity.owner}${PATH_SEPARATOR2}${identity.repo}`.toLowerCase();
-}
-var repo_origin = {
-  GITHUB_HOST,
-  is_github_hostname,
-  is_github_ssh_host,
-  parse_origin_from_config,
-  parse_origin_url,
-  parse_remote_urls_from_config,
-  format_identity
-};
-
-// scripts/discovery/repo-discovery.ts
-import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync3 } from "node:fs";
-import path7 from "node:path";
-
-// scripts/lib/stamped-memo.ts
-import { lstatSync } from "node:fs";
-var NO_STAMP = "";
-var STAMP_SEPARATOR = ":";
-function create() {
-  const answers2 = /* @__PURE__ */ new Map();
-  return {
-    of(key, stamp, compute) {
-      const known = answers2.get(key);
-      if (known?.stamp === stamp) return known.value;
-      const value = compute();
-      answers2.set(key, { stamp, value });
-      return value;
-    },
-    keep(keys) {
-      for (const key of answers2.keys()) if (!keys.has(key)) answers2.delete(key);
-    }
-  };
-}
-function file_stamp(file) {
-  try {
-    const status2 = lstatSync(file);
-    return [status2.ino, status2.mtimeMs, status2.ctimeMs, status2.size].join(STAMP_SEPARATOR);
-  } catch {
-    return NO_STAMP;
-  }
-}
-var stamped_memo = { NO_STAMP, create, file_stamp };
-
-// scripts/discovery/repo-map-logic.ts
-var OVERRIDE_ENTRY_SEPARATOR = ",";
-var OVERRIDE_PAIR_SEPARATOR = "=";
-var OVERRIDE_PAIR_PARTS = 2;
-var KEY_INDEX = 0;
-var PATH_INDEX = 1;
-function is_same_owner(identity, current_owner) {
-  return identity.owner.toLowerCase() === current_owner.toLowerCase();
-}
-function add_entry(target, origin_url2, repository_path, current_owner) {
-  if (origin_url2 === void 0) return;
-  const identity = repo_origin.parse_origin_url(origin_url2);
-  if (identity === void 0 || !is_same_owner(identity, current_owner)) return;
-  target.set(repo_origin.format_identity(identity), repository_path);
-}
-function parse_override_entry(entry) {
-  const parts = entry.split(OVERRIDE_PAIR_SEPARATOR).map((part) => part.trim());
-  if (parts.length !== OVERRIDE_PAIR_PARTS) return void 0;
-  const key = parts[KEY_INDEX] ?? "";
-  const repository_path = parts[PATH_INDEX] ?? "";
-  if (repository_path === "") return void 0;
-  return { path: repository_path, origin_url: `https://${repo_origin.GITHUB_HOST}/${key}` };
-}
-function parse_overrides(raw) {
-  if (raw === void 0) return [];
-  return raw.split(OVERRIDE_ENTRY_SEPARATOR).map((entry) => parse_override_entry(entry)).filter((entry) => entry !== void 0);
-}
-function build_repository_map(discovered, current_owner, override_value) {
-  const result = /* @__PURE__ */ new Map();
-  for (const entry of discovered) add_entry(result, entry.origin_url, entry.path, current_owner);
-  for (const entry of parse_overrides(override_value)) {
-    add_entry(result, entry.origin_url, entry.path, current_owner);
-  }
-  return result;
-}
-var repo_map_logic = {
-  is_same_owner,
-  build_repository_map
-};
-
-// scripts/discovery/repo-discovery.ts
-var GIT_DIRECTORY = ".git";
-var GIT_CONFIG = "config";
-var GITDIR_PREFIX2 = "gitdir:";
-var COMMON_DIRECTORY_FILE = "commondir";
-var OVERRIDE_ENV_KEY = "JOSH_REPO_PATHS";
-function resolve_common_directory(git_directory) {
-  const pointer = path7.join(git_directory, COMMON_DIRECTORY_FILE);
-  if (!existsSync3(pointer)) return git_directory;
-  try {
-    return path7.resolve(git_directory, readFileSync4(pointer, "utf8").trim());
-  } catch {
-    return git_directory;
-  }
-}
-function follow_git_file(repository_path, git_file) {
-  const pointer = readFileSync4(git_file, "utf8").trim();
-  if (!pointer.startsWith(GITDIR_PREFIX2)) return void 0;
-  return path7.resolve(repository_path, pointer.slice(GITDIR_PREFIX2.length).trim());
-}
-function resolve_git_directory(repository_path) {
-  const candidate = path7.join(repository_path, GIT_DIRECTORY);
-  if (!existsSync3(candidate)) return void 0;
-  try {
-    if (statSync3(candidate).isDirectory()) return candidate;
-    const linked = follow_git_file(repository_path, candidate);
-    return linked === void 0 ? void 0 : resolve_common_directory(linked);
-  } catch {
-    return void 0;
-  }
-}
-function read_text(file) {
-  try {
-    return readFileSync4(file, "utf8");
-  } catch {
-    return void 0;
-  }
-}
-var git_directories2 = stamped_memo.create();
-var configs = stamped_memo.create();
-function read_config(repository_path) {
-  const git_entry = path7.join(repository_path, GIT_DIRECTORY);
-  const git_directory = git_directories2.of(
-    repository_path,
-    stamped_memo.file_stamp(git_entry),
-    () => resolve_git_directory(repository_path)
-  );
-  if (git_directory === void 0) return void 0;
-  const config = path7.join(git_directory, GIT_CONFIG);
-  return configs.of(config, stamped_memo.file_stamp(config), () => read_text(config));
-}
-function read_origin_url(repository_path) {
-  const config = read_config(repository_path);
-  return config === void 0 ? void 0 : repo_origin.parse_origin_from_config(config);
-}
-function read_remote_urls(repository_path) {
-  const config = read_config(repository_path);
-  return config === void 0 ? [] : repo_origin.parse_remote_urls_from_config(config);
-}
-function sibling_directories(parent) {
-  try {
-    return readdirSync2(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path7.join(parent, entry.name)).toSorted((left, right) => left.localeCompare(right));
-  } catch {
-    return [];
-  }
-}
-function scan_siblings(parent) {
-  return sibling_directories(parent).map((repository_path) => ({
-    path: repository_path,
-    origin_url: read_origin_url(repository_path)
-  }));
-}
-function resolve_current_owner(repository_path) {
-  const origin_url2 = read_origin_url(repository_path);
-  if (origin_url2 === void 0) return void 0;
-  return repo_origin.parse_origin_url(origin_url2)?.owner;
-}
-function main_worktree(repository_path) {
-  const git_directory = resolve_git_directory(repository_path);
-  if (git_directory === void 0 || path7.basename(git_directory) !== GIT_DIRECTORY) {
-    return repository_path;
-  }
-  return path7.dirname(git_directory);
-}
-function discover_repositories(repository_path, environment = process.env) {
-  const main = main_worktree(repository_path);
-  const current_owner = resolve_current_owner(main);
-  if (current_owner === void 0) return /* @__PURE__ */ new Map();
-  return repo_map_logic.build_repository_map(
-    scan_siblings(path7.dirname(main)),
-    current_owner,
-    environment[OVERRIDE_ENV_KEY]
-  );
-}
-var repo_discovery = {
-  OVERRIDE_ENV_KEY,
-  main_worktree,
-  read_origin_url,
-  read_remote_urls,
-  resolve_current_owner,
-  scan_siblings,
-  discover_repositories
+  target_of: target_of2
 };
 
 // scripts/rules/issue-citation.ts
@@ -3093,26 +2620,9 @@ function bare_references(message) {
   for (const line of prose_lines(message)) collect_line_references(line, found);
   return [...new Set(found)];
 }
-function prompt_references(prompt) {
-  const found = /* @__PURE__ */ new Set();
-  for (const match of prompt.matchAll(ISSUE_NUMBER)) {
-    found.add(repo_prefix(prompt, match.index) + match[0]);
-  }
-  return found;
-}
-function unquoted_references(message, prompt) {
-  const quoted = prompt_references(prompt);
-  return bare_references(message).filter((reference2) => !quoted.has(reference2));
-}
 function has_bare_reference(message) {
   return bare_references(message).length > 0;
 }
-function cite_argument(reference2) {
-  return reference2.startsWith("#") ? reference2.slice(1) : reference2;
-}
-function cite_arguments(references) {
-  return references.map((reference2) => cite_argument(reference2));
-}
 function reference_link(reference2, default_slug) {
   const slug = reference2.prefix === "" ? default_slug : reference2.prefix;
   const number = reference2.text.slice(1);
@@ -3143,11 +2653,9 @@ function linkify(message, slug) {
 }
 var issue_citation = {
   bare_references,
-  cite_arguments,
   has_bare_reference,
   linkify,
-  prose_lines,
-  unquoted_references
+  prose_lines
 };
 
 // scripts/issue/session-cite.ts
@@ -3171,7 +2679,7 @@ var session_cite = {
 
 // scripts/lane/lane-state.ts
 import { readdirSync as readdirSync3 } from "node:fs";
-import path8 from "node:path";
+import path7 from "node:path";
 
 // scripts/lib/figure-format.ts
 var USD_DECIMALS = 4;
@@ -3215,23 +2723,23 @@ var figure_format = {
 };
 
 // scripts/lane/lane-state.ts
-import { z as z6 } from "zod";
-var STATE_PREFIX = "josh-lane-state-";
+import { z as z8 } from "zod";
+var STATE_PREFIX = durable_state.PREFIX.LANE_STATE;
 var STATE_SUFFIX = ".json";
 var LOCK_SUFFIX2 = ".lock";
 var LOCK_WAIT_MS2 = 5e3;
 var LANE_STATES = ["open", "running", "paused", "ended"];
 var NO_STATE_HINT = "no lane state \u2014 counted in use";
-var lane_run_schema = z6.object({ started_at: z6.string(), owner_pid: z6.number().optional() });
-var stuck_schema = z6.object({ pid: z6.number(), reason: z6.string() });
-var lane_state_schema = z6.object({
-  issue: z6.string(),
+var lane_run_schema = z8.object({ started_at: z8.string(), owner_pid: z8.number().optional() });
+var stuck_schema = z8.object({ pid: z8.number(), reason: z8.string() });
+var lane_state_schema2 = z8.object({
+  issue: z8.string(),
   run: lane_run_schema.optional(),
-  state: z6.enum(LANE_STATES),
-  launched_at: z6.string().optional(),
-  changed_at: z6.string(),
-  changed_by: z6.string(),
-  stuck: z6.array(stuck_schema).optional()
+  state: z8.enum(LANE_STATES),
+  launched_at: z8.string().optional(),
+  changed_at: z8.string(),
+  changed_by: z8.string(),
+  stuck: z8.array(stuck_schema).optional()
 });
 var TRANSITIONS = {
   open: ["open", "running", "ended"],
@@ -3240,17 +2748,17 @@ var TRANSITIONS = {
   ended: ["ended", "open"]
 };
 function state_path(directory, issue2) {
-  return stamp_file.stamp_path(STATE_PREFIX, directory, `-${issue2}${STATE_SUFFIX}`);
+  return durable_state.path(STATE_PREFIX, directory, `-${issue2}${STATE_SUFFIX}`);
 }
 function is_allowed(from, to) {
   return from === void 0 || TRANSITIONS[from].includes(to);
 }
 function read_record2(directory, issue2) {
   const raw = stamp_file.read_stamp_text(state_path(directory, issue2));
-  return raw === void 0 ? void 0 : json_value.parse_with(raw, lane_state_schema);
+  return raw === void 0 ? void 0 : json_value.parse_with(raw, lane_state_schema2);
 }
-function write_record(directory, record) {
-  stamp_file.replace_stamp(state_path(directory, record.issue), record);
+function write_record(directory, record2) {
+  stamp_file.replace_stamp(state_path(directory, record2.issue), record2);
 }
 function current_run(directory) {
   const carried = run_carry.read_carry(run_carry.carry_path(directory));
@@ -3277,9 +2785,9 @@ function apply_held(change, directory, now) {
   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 };
+  const record2 = next_record(change, previous, directory, now);
+  write_record(directory, record2);
+  return { kind: "written", record: record2 };
 }
 var NO_DIRECTORY = { kind: "skipped", reason: "no git directory" };
 function locked(directory, issue2, held) {
@@ -3303,60 +2811,75 @@ async function outcome_of(change, options) {
   if (directory === void 0) return NO_DIRECTORY;
   return apply(change, directory, options.now ?? /* @__PURE__ */ new Date());
 }
-async function settled_outcome(change, options) {
+async function settled(write) {
   try {
-    return await outcome_of(change, options);
+    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_outcome(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(issue2, directory) {
-  const root = await resolve_directory(directory);
-  return root === void 0 ? void 0 : read_record2(root, issue2);
+  const root2 = await resolve_directory(directory);
+  return root2 === void 0 ? void 0 : read_record2(root2, issue2);
 }
 function recorded_issues(directory) {
   const empty = state_path(directory, "");
-  const head = path8.basename(empty).slice(0, -STATE_SUFFIX.length);
-  return readdirSync3(path8.dirname(empty)).filter((name) => name.startsWith(head) && name.endsWith(STATE_SUFFIX)).map((name) => name.slice(head.length, -STATE_SUFFIX.length)).filter((issue2) => issue2.length > 0);
+  const head = path7.basename(empty).slice(0, -STATE_SUFFIX.length);
+  return readdirSync3(path7.dirname(empty)).filter((name) => name.startsWith(head) && name.endsWith(STATE_SUFFIX)).map((name) => name.slice(head.length, -STATE_SUFFIX.length)).filter((issue2) => issue2.length > 0);
 }
 async function read_records(directory) {
-  const root = await resolve_directory(directory);
-  if (root === void 0) return [];
-  const records = recorded_issues(root).map((issue2) => read_record2(root, issue2));
-  return records.filter((record) => record !== void 0);
+  const root2 = await resolve_directory(directory);
+  if (root2 === void 0) return [];
+  const records = recorded_issues(root2).map((issue2) => read_record2(root2, issue2));
+  return records.filter((record2) => record2 !== void 0);
 }
 function stuck_held(issue2, stuck, directory) {
   const previous = read_record2(directory, issue2);
   if (previous === void 0) return { kind: "skipped", reason: "no record" };
-  const record = { ...previous, stuck };
-  write_record(directory, record);
-  return { kind: "written", record };
+  const record2 = { ...previous, stuck };
+  write_record(directory, record2);
+  return { kind: "written", record: record2 };
 }
 async function record_stuck(issue2, stuck, directory) {
-  const root = await resolve_directory(directory);
-  if (root === void 0) return NO_DIRECTORY;
-  return locked(root, issue2, () => stuck_held(issue2, stuck, root));
+  const root2 = await resolve_directory(directory);
+  if (root2 === void 0) return NO_DIRECTORY;
+  return locked(root2, issue2, () => stuck_held(issue2, stuck, root2));
+}
+function adopted_held(change, directory, now) {
+  if (read_record2(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 read3 = issues.map((issue2) => [
+  const root2 = await resolve_directory(directory);
+  if (root2 === void 0) return /* @__PURE__ */ new Map();
+  const read = issues.map((issue2) => [
     issue2,
-    read_record2(root, issue2)
+    read_record2(root2, issue2)
   ]);
-  return new Map(read3.filter((entry) => entry[1] !== void 0));
+  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);
+function paused_note(record2) {
+  if (record2?.state !== "paused") return void 0;
+  return paused_text(Date.parse(record2.changed_at), record2.changed_by);
 }
 var lane_state = {
   LANE_STATES,
@@ -3367,6 +2890,7 @@ var lane_state = {
   read_records,
   read_state,
   read_states,
+  record_adopted,
   record_change,
   record_stuck,
   state_path
@@ -3390,9 +2914,9 @@ function scoped_events(events, scope) {
   if (floor === void 0) return void 0;
   return events.filter((event) => is_within(event, floor));
 }
-function scope_of(read3) {
-  if (read3.kind !== "carried") return UNKNOWN_EVENT_SCOPE;
-  return { kind: SINCE_SCOPE, started_at: read3.carry.started_at };
+function scope_of(read) {
+  if (read.kind !== "carried") return UNKNOWN_EVENT_SCOPE;
+  return { kind: SINCE_SCOPE, started_at: read.carry.started_at };
 }
 function last_scoped_event(events, scope) {
   return scoped_events(events, scope)?.findLast(
@@ -3403,15 +2927,15 @@ var SHIP_POSITION_KINDS = /* @__PURE__ */ new Set([
   run_event_stream.EVENT_KIND.SHIP_LAUNCH,
   run_event_stream.EVENT_KIND.SHIP_STOP
 ]);
-var KIND = run_event_stream.EVENT_KIND;
+var KIND5 = run_event_stream.EVENT_KIND;
 var BATCH_RECORD_KINDS = /* @__PURE__ */ new Set([
-  KIND.CHILD_LAUNCH,
-  KIND.RESTART,
-  KIND.WITHDRAW,
-  KIND.PARK,
-  KIND.SPLIT,
-  KIND.RETROSPECTIVE,
-  KIND.STRANDED
+  KIND5.CHILD_LAUNCH,
+  KIND5.RESTART,
+  KIND5.WITHDRAW,
+  KIND5.PARK,
+  KIND5.SPLIT,
+  KIND5.RETROSPECTIVE,
+  KIND5.STRANDED
 ]);
 var ISSUE_REFERENCE = /#(\d+)/u;
 function is_foreign_ship_event(event, issue2) {
@@ -3431,7 +2955,7 @@ function is_lane_position(event, issue2) {
 }
 function since_own_launch(events, issue2) {
   const launch = events.findLastIndex(
-    (event) => event.kind === KIND.CHILD_LAUNCH && names_issue(event, issue2)
+    (event) => event.kind === KIND5.CHILD_LAUNCH && names_issue(event, issue2)
   );
   return events.slice(launch + 1);
 }
@@ -3441,30 +2965,30 @@ function is_foreign_event(event, issue2, is_lane_child) {
 }
 function last_issue_event(events, scope, issue2, is_lane_child) {
   const attempt = is_lane_child ? since_own_launch(events, issue2) : events;
-  const own2 = attempt.filter((event) => !is_foreign_event(event, issue2, is_lane_child));
-  if (scope.kind === SINCE_SCOPE) return last_scoped_event(own2, scope);
-  return own2.findLast((event) => is_own_ship_event(event, issue2));
+  const own = attempt.filter((event) => !is_foreign_event(event, issue2, is_lane_child));
+  if (scope.kind === SINCE_SCOPE) return last_scoped_event(own, scope);
+  return own.findLast((event) => is_own_ship_event(event, issue2));
 }
 var LAUNCH_OR_SETTLE_KINDS = /* @__PURE__ */ new Set([
-  KIND.CHILD_LAUNCH,
-  KIND.MERGE,
-  KIND.PARK,
-  KIND.SPLIT,
-  KIND.WITHDRAW
+  KIND5.CHILD_LAUNCH,
+  KIND5.MERGE,
+  KIND5.PARK,
+  KIND5.SPLIT,
+  KIND5.WITHDRAW
 ]);
 function is_merge_owed(events, scope, issue2) {
   const newest = (scoped_events(events, scope) ?? []).findLast(
     (event) => LAUNCH_OR_SETTLE_KINDS.has(event.kind) && names_issue(event, issue2)
   );
-  return newest?.kind === KIND.CHILD_LAUNCH;
+  return newest?.kind === KIND5.CHILD_LAUNCH;
 }
 function is_launch_or_withdrawal(event, issue2) {
-  const is_kind = event.kind === KIND.CHILD_LAUNCH || event.kind === KIND.WITHDRAW;
+  const is_kind = event.kind === KIND5.CHILD_LAUNCH || event.kind === KIND5.WITHDRAW;
   return is_kind && names_issue(event, issue2);
 }
 function is_withdrawn(events, issue2) {
   const newest = events.findLast((event) => is_launch_or_withdrawal(event, issue2));
-  return newest?.kind === KIND.WITHDRAW;
+  return newest?.kind === KIND5.WITHDRAW;
 }
 var run_event_scope = {
   UNKNOWN_EVENT_SCOPE,
@@ -3498,15 +3022,16 @@ function issue_spans(pair) {
 var lane_spans = { issue_spans };
 
 // scripts/run/board/run-board-lane-time.ts
-var KIND2 = run_event_stream.EVENT_KIND;
-var LAUNCH_KINDS = /* @__PURE__ */ new Set([KIND2.CHILD_LAUNCH, KIND2.RESTART]);
+var KIND6 = run_event_stream.EVENT_KIND;
+var LAUNCH_KINDS = /* @__PURE__ */ new Set([KIND6.CHILD_LAUNCH, KIND6.RESTART]);
 var OFF_LANE_KINDS = /* @__PURE__ */ new Set([
-  KIND2.MERGE,
-  KIND2.PARK,
-  KIND2.WITHDRAW,
-  KIND2.OUTAGE,
-  KIND2.SPLIT,
-  KIND2.STOP
+  KIND6.MERGE,
+  KIND6.PARK,
+  KIND6.WITHDRAW,
+  KIND6.OUTAGE,
+  KIND6.USAGE_LIMIT,
+  KIND6.SPLIT,
+  KIND6.STOP
 ]);
 function moments_of(events, kinds) {
   return events.filter((event) => kinds.has(event.kind)).map((event) => ({
@@ -3537,24 +3062,24 @@ function in_lane_ms(spans, end_ms) {
 function elapsed_of(spans, started_ms, ended_ms) {
   return spans.length === 0 ? ended_ms - started_ms : in_lane_ms(spans, ended_ms);
 }
-function launched_ms(record) {
-  const launched_at = record?.launched_at;
+function launched_ms(record2) {
+  const launched_at = record2?.launched_at;
   return launched_at === void 0 ? void 0 : Date.parse(launched_at);
 }
-function counted_from(run3, started_ms) {
-  return run3 === void 0 ? started_ms : Date.parse(run3.started_at);
+function counted_from(run, started_ms) {
+  return run === void 0 ? started_ms : Date.parse(run.started_at);
 }
 function is_ended(spans) {
   return spans.at(-1)?.end_ms !== void 0;
 }
-function ending_elapsed(read3) {
-  const started_ms = launched_ms(read3.record);
+function ending_elapsed(read) {
+  const started_ms = launched_ms(read.record);
   if (started_ms === void 0) return void 0;
-  const from_ms = counted_from(read3.record?.run, started_ms);
-  const spans = (spans_of(read3.events).get(read3.issue) ?? []).filter(
+  const from_ms = counted_from(read.record?.run, started_ms);
+  const spans = (spans_of(read.events).get(read.issue) ?? []).filter(
     (span) => span.from_ms >= from_ms
   );
-  return is_ended(spans) ? void 0 : elapsed_of(spans, started_ms, read3.ended_ms);
+  return is_ended(spans) ? void 0 : elapsed_of(spans, started_ms, read.ended_ms);
 }
 var run_board_lane_time = {
   LAUNCH_KINDS,
@@ -3566,12 +3091,12 @@ var run_board_lane_time = {
 };
 
 // scripts/run/event/run-event-stream-emit.ts
-function now_iso() {
+function now_iso2() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 async function stream_target() {
-  const repository2 = await run_carry.repository_directory();
-  return repository2 === void 0 ? void 0 : run_event_stream.target_of(repository2);
+  const repository = await run_carry.repository_directory();
+  return repository === void 0 ? void 0 : run_event_stream.target_of(repository);
 }
 async function lane_record(issue2) {
   try {
@@ -3581,57 +3106,57 @@ async function lane_record(issue2) {
     return void 0;
   }
 }
-async function ending_fields(target, event) {
+async function ending_fields(target2, event) {
   const issue2 = run_event_scope.issue_named(event);
   if (issue2 === void 0 || !run_board_lane_time.OFF_LANE_KINDS.has(event.kind)) return {};
   const elapsed_ms = run_board_lane_time.ending_elapsed({
-    events: run_event_stream.read_events(target),
+    events: run_event_stream.read_events(target2),
     issue: Number(issue2),
     record: await lane_record(issue2),
     ended_ms: Date.parse(event.at)
   });
   return elapsed_ms === void 0 ? {} : { elapsed_ms };
 }
-async function append_at(target, kind, text2, at) {
+async function append_at(target2, kind, text2, at) {
   const event = { kind, text: text2, at: at.toISOString() };
-  return run_event_stream.append_event(target, {
+  return run_event_stream.append_event(target2, {
     ...event,
-    ...await ending_fields(target, event)
+    ...await ending_fields(target2, event)
   });
 }
 async function emit(kind, text2, at = /* @__PURE__ */ new Date()) {
   try {
-    const target = await stream_target();
-    if (target === void 0) return;
-    await append_at(target, kind, text2, at);
+    const target2 = await stream_target();
+    if (target2 === void 0) return;
+    await append_at(target2, kind, text2, at);
   } catch {
   }
 }
 async function emit_once(kind, text2) {
   try {
-    const target = await stream_target();
-    if (target === void 0 || run_event_stream.read_last(target)?.kind === kind) return false;
-    return run_event_stream.append(target, kind, text2, now_iso()).appended;
+    const target2 = await stream_target();
+    if (target2 === void 0 || run_event_stream.read_last(target2)?.kind === kind) return false;
+    return run_event_stream.append(target2, kind, text2, now_iso2()).appended;
   } catch (error) {
     error_text.trace_swallowed("run_event_stream_emit.emit_once", error);
     return false;
   }
 }
-function invocation_events(repository2, target) {
-  const events = run_event_stream.read_events(target);
-  const scope = run_event_scope.scope_of(run_carry.read_carry(run_carry.carry_path(repository2)));
+function invocation_events(repository, target2) {
+  const events = run_event_stream.read_events(target2);
+  const scope = run_event_scope.scope_of(run_carry.read_carry(run_carry.carry_path(repository)));
   return run_event_scope.scoped_events(events, scope) ?? events;
 }
 async function emit_once_since_with(kind, reset_kind, compose) {
   try {
-    const repository2 = await run_carry.repository_directory();
-    if (repository2 === void 0) return void 0;
-    const target = run_event_stream.target_of(repository2);
-    if (run_event_stream.has_since(invocation_events(repository2, target), kind, reset_kind)) {
+    const repository = await run_carry.repository_directory();
+    if (repository === void 0) return void 0;
+    const target2 = run_event_stream.target_of(repository);
+    if (run_event_stream.has_since(invocation_events(repository, target2), kind, reset_kind)) {
       return void 0;
     }
     const text2 = await compose();
-    return run_event_stream.append(target, kind, text2, now_iso()).appended ? text2 : void 0;
+    return run_event_stream.append(target2, kind, text2, now_iso2()).appended ? text2 : void 0;
   } catch (error) {
     error_text.trace_swallowed("run_event_stream_emit.emit_once_since", error);
     return void 0;
@@ -3646,11 +3171,11 @@ async function emit_heartbeat(line) {
 }
 async function current_events() {
   try {
-    const repository2 = await run_carry.repository_directory();
-    if (repository2 === void 0) return [];
-    const read3 = run_carry.read_carry(run_carry.carry_path(repository2));
-    const scope = run_event_scope.scope_of(read3);
-    const events = run_event_stream.read_events(run_event_stream.target_of(repository2));
+    const repository = await run_carry.repository_directory();
+    if (repository === void 0) return [];
+    const read = run_carry.read_carry(run_carry.carry_path(repository));
+    const scope = run_event_scope.scope_of(read);
+    const events = run_event_stream.read_events(run_event_stream.target_of(repository));
     return run_event_scope.scoped_events(events, scope) ?? [];
   } catch {
     return [];
@@ -3658,16 +3183,16 @@ async function current_events() {
 }
 async function invocation_or_all_events() {
   try {
-    const repository2 = await run_carry.repository_directory();
-    return repository2 === void 0 ? [] : invocation_events(repository2, run_event_stream.target_of(repository2));
+    const repository = await run_carry.repository_directory();
+    return repository === void 0 ? [] : invocation_events(repository, run_event_stream.target_of(repository));
   } catch {
     return [];
   }
 }
 async function all_events() {
   try {
-    const target = await stream_target();
-    return target === void 0 ? [] : run_event_stream.read_events(target);
+    const target2 = await stream_target();
+    return target2 === void 0 ? [] : run_event_stream.read_events(target2);
   } catch {
     return [];
   }
@@ -3685,17 +3210,154 @@ var run_event_stream_emit = {
   stream_target
 };
 
+// ports/index.js
+import { existsSync as existsSync2 } from "node:fs";
+import path8 from "node:path";
+var PORT_SEED_KEY = "PORT_SEED";
+var LANE_SEAT_KEY = "JOSH_LANE_SEAT";
+var ENV_FILE_NAME = ".env";
+var PACKAGE_FILE_NAME = "package.json";
+var PROJECT_ENVIRONMENT_KEYS = /* @__PURE__ */ new Set([PORT_SEED_KEY, LANE_SEAT_KEY, "PLAYWRIGHT_REUSE_SERVER"]);
+var DEV_PORT_BASE = 5173;
+var PREVIEW_PORT_BASE = 4173;
+var MIN_SEED = 0;
+var SEED_LANE_MULTIPLIER = 10;
+var MAX_LANE = 9;
+var MAX_SEED = 99;
+var INTEGER_PATTERN = /^\d+$/u;
+function fail_invalid(key, raw, max) {
+  throw new Error(
+    `${key} must be an integer between ${MIN_SEED} and ${max}, got ${JSON.stringify(raw)}. Unset it to use the default ports (dev ${DEV_PORT_BASE}, preview ${PREVIEW_PORT_BASE}).`
+  );
+}
+function read_trimmed(environment, key) {
+  const raw = environment[key];
+  return raw === void 0 ? "" : raw.trim();
+}
+function resolve_bounded(environment, key, max) {
+  const trimmed = read_trimmed(environment, key);
+  if (trimmed.length === 0) return MIN_SEED;
+  if (!INTEGER_PATTERN.test(trimmed)) fail_invalid(key, trimmed, max);
+  const value = Number(trimmed);
+  if (value > max) fail_invalid(key, trimmed, max);
+  return value;
+}
+function resolve_seed(environment = process.env) {
+  return resolve_bounded(environment, PORT_SEED_KEY, MAX_SEED);
+}
+function resolve_lane(environment = process.env) {
+  return resolve_bounded(environment, LANE_SEAT_KEY, MAX_LANE);
+}
+function resolve_offset(environment = process.env) {
+  return resolve_seed(environment) * SEED_LANE_MULTIPLIER + resolve_lane(environment);
+}
+function offset_from(base, environment) {
+  return base + resolve_offset(environment);
+}
+function resolve_development_port(environment = process.env) {
+  return offset_from(DEV_PORT_BASE, environment);
+}
+function resolve_preview_port(environment = process.env) {
+  return offset_from(PREVIEW_PORT_BASE, environment);
+}
+function resolve_project_directory(directory) {
+  const start = path8.resolve(directory);
+  let current = start;
+  while (!existsSync2(path8.join(current, PACKAGE_FILE_NAME))) {
+    const parent = path8.dirname(current);
+    if (parent === current) return start;
+    current = parent;
+  }
+  return current;
+}
+function discard_loaded_keys(snapshot) {
+  for (const key of Object.keys(process.env)) {
+    if (!PROJECT_ENVIRONMENT_KEYS.has(key) && !Object.hasOwn(snapshot, key)) {
+      Reflect.deleteProperty(process.env, key);
+    }
+  }
+}
+function load_environment_file(directory = process.cwd()) {
+  const file = path8.join(resolve_project_directory(directory), ENV_FILE_NAME);
+  if (!existsSync2(file)) return false;
+  const snapshot = { ...process.env };
+  process.loadEnvFile(file);
+  discard_loaded_keys(snapshot);
+  return true;
+}
+var ports = {
+  load_environment_file,
+  resolve_project_directory,
+  resolve_seed,
+  resolve_lane,
+  resolve_development_port,
+  resolve_preview_port
+};
+
+// scripts/josh/josh-command-types.ts
+var OPTIONAL_ENV_FILE_FLAGS = [`--env-file-if-exists=${ENV_FILE_NAME}`];
+var ESLINT_CACHE_FILE = ".eslintcache";
+var TS_BUILD_INFO_FILE = ".tsbuildinfo";
+var CSPELL_CACHE_FILE = ".cspellcache";
+var ESLINT_EDIT_CACHE_FILE = ".eslintcache.edit";
+var ESLINT_RELATED_CACHE_FILE = ".eslintcache.related";
+var PRETTIER_CACHE_FILE = ".prettiercache";
+var PRETTIER_RELATED_CACHE_FILE = ".prettiercache.related";
+var CSPELL_COMMIT_CACHE_FILE = ".cspellcache.commit";
+var ESLINT_COMMIT_CACHE_FILE = ".eslintcache.commit";
+var ROOTED_JSON_PORTABILITY = "rooted-json";
+var ESLINT_CACHE_SPEC = {
+  cache_file: ESLINT_CACHE_FILE,
+  portability: ROOTED_JSON_PORTABILITY
+};
+var TS_CACHE_SPEC = {
+  cache_file: TS_BUILD_INFO_FILE,
+  portability: "raw"
+};
+var CSPELL_CACHE_SPEC = {
+  cache_file: CSPELL_CACHE_FILE,
+  portability: "raw"
+};
+var GATE_CACHE_SPECS = [
+  ESLINT_CACHE_SPEC,
+  TS_CACHE_SPEC,
+  CSPELL_CACHE_SPEC
+];
+var GATE_CACHE_FILES = GATE_CACHE_SPECS.map((spec) => spec.cache_file);
+var IGNORED_CACHE_FILES = [
+  ...GATE_CACHE_FILES,
+  ESLINT_EDIT_CACHE_FILE,
+  ESLINT_RELATED_CACHE_FILE,
+  PRETTIER_CACHE_FILE,
+  PRETTIER_RELATED_CACHE_FILE,
+  CSPELL_COMMIT_CACHE_FILE,
+  ESLINT_COMMIT_CACHE_FILE
+];
+var CONTENT_CACHE_FLAGS = ["--cache", "--cache-strategy", "content"];
+var CACHE_LOCATION_FLAG = "--cache-location";
+function content_cache_flags(cache_file) {
+  return [...CONTENT_CACHE_FLAGS, CACHE_LOCATION_FLAG, cache_file];
+}
+var ESLINT_CACHE_FLAGS = content_cache_flags(ESLINT_CACHE_FILE);
+var ESLINT_EDIT_CACHE_FLAGS = content_cache_flags(ESLINT_EDIT_CACHE_FILE);
+var ESLINT_RELATED_CACHE_FLAGS = content_cache_flags(ESLINT_RELATED_CACHE_FILE);
+var CSPELL_CACHE_FLAGS = content_cache_flags(CSPELL_CACHE_FILE);
+var PRETTIER_CACHE_FLAGS = content_cache_flags(PRETTIER_CACHE_FILE);
+var PRETTIER_RELATED_CACHE_FLAGS = content_cache_flags(PRETTIER_RELATED_CACHE_FILE);
+var CSPELL_COMMIT_CACHE_FLAGS = content_cache_flags(CSPELL_COMMIT_CACHE_FILE);
+var ESLINT_COMMIT_CACHE_FLAGS = content_cache_flags(ESLINT_COMMIT_CACHE_FILE);
+
 // scripts/lib/ancestor-directories.ts
 import path9 from "node:path";
 var MAX_DEPTH = 64;
 function list(start_directory) {
-  const directories2 = [];
+  const directories = [];
   let current = path9.resolve(start_directory);
-  while (directories2.length < MAX_DEPTH && !directories2.includes(current)) {
-    directories2.push(current);
+  while (directories.length < MAX_DEPTH && !directories.includes(current)) {
+    directories.push(current);
     current = path9.dirname(current);
   }
-  return directories2;
+  return directories;
 }
 function nearest(start_directory, is_match) {
   return list(start_directory).find((directory) => is_match(directory));
@@ -3703,14 +3365,14 @@ function nearest(start_directory, is_match) {
 var ancestor_directories = { list, nearest };
 
 // scripts/lib/package-manifest.ts
-import { readFileSync as readFileSync5 } from "node:fs";
+import { readFileSync as readFileSync4 } from "node:fs";
 import path10 from "node:path";
 var PACKAGE_JSON = "package.json";
 function manifest_path(directory) {
   return path10.join(directory, PACKAGE_JSON);
 }
 function read_manifest(directory, schema) {
-  const text2 = readFileSync5(manifest_path(directory), "utf8");
+  const text2 = readFileSync4(manifest_path(directory), "utf8");
   return schema.parse(JSON.parse(text2));
 }
 function read_manifest_if_valid(directory, schema) {
@@ -3720,135 +3382,210 @@ function read_manifest_if_valid(directory, schema) {
 }
 var package_manifest = { manifest_path, read_manifest, read_manifest_if_valid };
 
+// scripts/gate/toolchain-inputs.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync3, readdirSync as readdirSync4, readFileSync as readFileSync5 } from "node:fs";
+import path11 from "node:path";
+var PACKAGE_FILES = [
+  "package.json",
+  "pnpm-lock.yaml",
+  "pnpm-workspace.yaml",
+  "package-lock.json",
+  "yarn.lock",
+  "bun.lock",
+  "bun.lockb",
+  ".npmrc",
+  "node_modules/.modules.yaml"
+];
+var CONFIG_ENTRIES = [
+  /^eslint\.config\.[cm]?[jt]s$/u,
+  /^tsconfig(?:\.[\w-]+)?\.json$/u
+];
+var CONFIG_DIRECTORIES = /* @__PURE__ */ new Set(["eslint", "tsconfig"]);
+var TEST_MARKER = ".test.";
+var SEPARATOR = "/";
+var DIGEST_ALGORITHM = "sha256";
+function by_code_unit(left, right) {
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+function to_posix(relative) {
+  return relative.split(path11.sep).join(SEPARATOR);
+}
+function is_config_entry(name) {
+  return CONFIG_ENTRIES.some((entry) => entry.test(name));
+}
+function is_config_module(relative) {
+  const [top = ""] = relative.split(SEPARATOR, 1);
+  return CONFIG_DIRECTORIES.has(top) && !path11.basename(relative).includes(TEST_MARKER);
+}
+function is_input(relative) {
+  const posix = to_posix(relative);
+  if (PACKAGE_FILES.includes(posix)) return true;
+  return is_config_entry(posix) || is_config_module(posix);
+}
+function modules_under(root2, directory) {
+  const absolute = path11.join(root2, directory);
+  if (!existsSync3(absolute)) return [];
+  return readdirSync4(absolute, { recursive: true, withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => to_posix(path11.relative(root2, path11.join(entry.parentPath, entry.name)))).filter((relative) => is_config_module(relative));
+}
+function paths(root2) {
+  const present = PACKAGE_FILES.filter((relative) => existsSync3(path11.join(root2, relative)));
+  const entries = readdirSync4(root2).filter((name) => is_config_entry(name));
+  const modules = [...CONFIG_DIRECTORIES].flatMap((directory) => modules_under(root2, directory));
+  return [...present, ...entries, ...modules].toSorted(by_code_unit);
+}
+function read_or_empty(file) {
+  try {
+    return readFileSync5(file);
+  } catch {
+    return new Uint8Array();
+  }
+}
+function digest(root2) {
+  const hash = createHash(DIGEST_ALGORITHM);
+  for (const relative of paths(root2)) {
+    hash.update(`${relative}\0`).update(read_or_empty(path11.join(root2, relative))).update("\0");
+  }
+  return hash.digest("hex");
+}
+var toolchain_inputs = { digest, is_input, PACKAGE_FILES, paths };
+
 // scripts/git/git-schemas.ts
-import { z as z7 } from "zod";
-var package_name_schema = z7.object({ name: z7.string().min(1) });
-var rollup_item_schema = z7.looseObject({
+import { z as z9 } from "zod";
+var package_name_schema = z9.object({ name: z9.string().min(1) });
+var rollup_item_schema = z9.looseObject({
   // eslint-disable-next-line @typescript-eslint/naming-convention -- GraphQL field name from GitHub API
-  __typename: z7.string().nullish(),
-  state: z7.string().nullish(),
-  status: z7.string().nullish(),
-  conclusion: z7.string().nullish(),
-  name: z7.string().nullish(),
-  context: z7.string().nullish(),
-  description: z7.string().nullish()
+  __typename: z9.string().nullish(),
+  state: z9.string().nullish(),
+  status: z9.string().nullish(),
+  conclusion: z9.string().nullish(),
+  name: z9.string().nullish(),
+  context: z9.string().nullish(),
+  description: z9.string().nullish()
 });
-var pr_raw_schema = z7.object({
-  statusCheckRollup: z7.array(rollup_item_schema).optional(),
+var pr_raw_schema = z9.object({
+  statusCheckRollup: z9.array(rollup_item_schema).optional(),
   // The base branch's required status check contexts, read from its rules — empty where none are
   // set or they could not be read (`git-gh-branch-rules.ts`).
-  requiredContexts: z7.array(z7.string()).optional(),
-  mergeStateStatus: z7.string().optional(),
-  reviewDecision: z7.string().optional(),
-  headRefOid: z7.string().optional()
+  requiredContexts: z9.array(z9.string()).optional(),
+  mergeStateStatus: z9.string().optional(),
+  reviewDecision: z9.string().optional(),
+  headRefOid: z9.string().optional()
 });
-var pull_comment_schema = z7.object({
-  body: z7.string().optional(),
-  html_url: z7.string().optional(),
-  user: z7.object({ login: z7.string().optional() }).optional()
+var pull_comment_schema = z9.object({
+  body: z9.string().optional(),
+  html_url: z9.string().optional(),
+  user: z9.object({ login: z9.string().optional() }).optional()
 });
-var ai_review_pull_comment_schema = z7.object({
-  body: z7.string().optional(),
-  url: z7.string().optional(),
-  author: z7.object({ login: z7.string().optional() }).optional()
+var ai_review_pull_comment_schema = z9.object({
+  body: z9.string().optional(),
+  url: z9.string().optional(),
+  author: z9.object({ login: z9.string().optional() }).optional(),
+  updatedAt: z9.string().optional()
 });
-var pr_info_schema = z7.object({
-  mergeable: z7.union([z7.boolean(), z7.string()]).nullable().optional(),
-  mergeStateStatus: z7.string().nullable().optional(),
-  state: z7.string().optional()
+var pr_info_schema = z9.object({
+  mergeable: z9.union([z9.boolean(), z9.string()]).nullable().optional(),
+  mergeStateStatus: z9.string().nullable().optional(),
+  state: z9.string().optional()
 });
-var epic_issue_schema = z7.object({
-  number: z7.number(),
-  body: z7.string().optional(),
+var epic_issue_schema = z9.object({
+  number: z9.number(),
+  body: z9.string().optional(),
   // REST answers null for an issue never closed and `reopened` for one a person reopened.
-  stateReason: z7.string().nullish()
+  stateReason: z9.string().nullish()
 });
-var blocking_issue_schema = z7.object({
-  number: z7.number(),
-  state: z7.string().optional(),
-  repository_url: z7.string().optional()
+var blocking_issue_schema = z9.object({
+  number: z9.number(),
+  state: z9.string().optional(),
+  repository_url: z9.string().optional()
 });
-var blocked_by_schema = z7.object({
-  nodes: z7.array(blocking_issue_schema).default([]),
-  totalCount: z7.number().optional()
+var blocked_by_schema = z9.object({
+  nodes: z9.array(blocking_issue_schema).default([]),
+  totalCount: z9.number().optional()
 }).optional();
-var epic_child_schema = z7.object({
-  state: z7.string().optional(),
+var epic_child_schema = z9.object({
+  state: z9.string().optional(),
   blockedBy: blocked_by_schema
 });
-var rest_comment_schema = z7.looseObject({
-  body: z7.string().nullish(),
-  html_url: z7.string().optional(),
-  user: z7.looseObject({ login: z7.string().optional() }).nullish()
+var rest_comment_schema = z9.looseObject({
+  body: z9.string().nullish(),
+  html_url: z9.string().optional(),
+  user: z9.looseObject({ login: z9.string().optional() }).nullish(),
+  updated_at: z9.string().optional()
 });
-var issue_label_schema = z7.object({ name: z7.string() });
-var epic_subject_schema = z7.object({
-  number: z7.number(),
-  state: z7.string().optional(),
-  labels: z7.array(issue_label_schema).optional(),
-  body: z7.string().optional()
+var issue_label_schema = z9.object({ name: z9.string() });
+var epic_subject_schema = z9.object({
+  number: z9.number(),
+  state: z9.string().optional(),
+  labels: z9.array(issue_label_schema).optional(),
+  body: z9.string().optional()
 });
-var open_issue_schema = z7.object({
-  number: z7.number(),
-  title: z7.string(),
-  labels: z7.array(issue_label_schema).optional(),
-  createdAt: z7.string(),
+var author_fields_schema = {
+  author_association: z9.string().nullish(),
+  user: z9.looseObject({ login: z9.string() }).nullish()
+};
+var open_issue_schema = z9.object({
+  number: z9.number(),
+  title: z9.string(),
+  labels: z9.array(issue_label_schema).optional(),
+  createdAt: z9.string(),
   blockedBy: blocked_by_schema,
   // Present only on the pickup listing, which reads it for the paths each issue declares.
-  body: z7.string().optional()
+  body: z9.string().optional(),
+  ...author_fields_schema,
+  // Assembled by the pickup from the author above, never read off the listing: whether the author
+  // has write access. Absent on every other listing.
+  author_trusted: z9.boolean().optional()
 });
 
 export {
   json_value,
   file_reader,
+  figure_format,
+  pr_raw_schema,
+  epic_issue_schema,
+  blocking_issue_schema,
+  blocked_by_schema,
+  rest_comment_schema,
+  issue_label_schema,
+  author_fields_schema,
+  open_issue_schema,
+  durable_state,
   process_identity,
-  process_owner_schema,
   issue_number_shape,
-  lane_paths,
-  stamped_memo,
-  PORCELAIN_FLAG,
-  UNTRACKED_FILES_FLAG,
-  get_exit_code,
-  has_timed_out,
-  git_spawn,
-  git_diff_reads,
-  GIT_LOCATION_VARIABLES,
-  git_spawn_sync,
-  git_command,
   cli_flags,
   run_invocation,
+  lane_paths,
   time_instant,
   cost_usage,
   cost_transcript,
   agent_session_environment,
   own_session,
   run_carry,
-  PORT_SEED_KEY,
-  LANE_SEAT_KEY,
-  ENV_FILE_NAME,
-  ports,
-  figure_format,
-  pr_raw_schema,
-  epic_issue_schema,
-  blocking_issue_schema,
-  blocked_by_schema,
-  rest_comment_schema,
-  issue_label_schema,
-  open_issue_schema,
+  lane_ledger_schema,
+  lane_ledger_write,
   issue_cite,
-  git_common_directory,
+  process_owner_schema,
   repository_lock,
   run_ship_stage,
   run_event_stream,
-  repo_origin,
-  repo_map_logic,
-  repo_discovery,
   issue_citation,
   session_cite,
   lane_state,
   run_event_scope,
   run_event_stream_emit,
+  PORT_SEED_KEY,
+  LANE_SEAT_KEY,
+  ENV_FILE_NAME,
+  ports,
+  OPTIONAL_ENV_FILE_FLAGS,
+  ESLINT_RELATED_CACHE_FILE,
+  ESLINT_EDIT_CACHE_FLAGS,
+  ESLINT_RELATED_CACHE_FLAGS,
+  PRETTIER_RELATED_CACHE_FLAGS,
   ancestor_directories,
   PACKAGE_JSON,
-  package_manifest
+  package_manifest,
+  toolchain_inputs
 };