@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/version/index.js

@@ -69,13 +69,13 @@ import path3 from "node:path";
 import path from "node:path";
 var MAX_DEPTH = 64;
 function list(start_directory) {
-  const directories = [];
+  const directories2 = [];
   let current = path.resolve(start_directory);
-  while (directories.length < MAX_DEPTH && !directories.includes(current)) {
-    directories.push(current);
+  while (directories2.length < MAX_DEPTH && !directories2.includes(current)) {
+    directories2.push(current);
     current = path.dirname(current);
   }
-  return directories;
+  return directories2;
 }
 function nearest(start_directory, is_match) {
   return list(start_directory).find((directory) => is_match(directory));
@@ -116,20 +116,20 @@ var ABSENT_CODE = "ENOENT";
 function is_absent(error) {
   return error instanceof Error && "code" in error && error.code === ABSENT_CODE;
 }
-function read_optional(path7) {
+function read_optional(path22) {
   try {
-    return readFileSync(path7, "utf8");
+    return readFileSync(path22, "utf8");
   } catch (error) {
     if (is_absent(error)) return void 0;
     throw error;
   }
 }
-function read_file_or_empty(path7) {
-  return read_optional(path7) ?? "";
+function read_file_or_empty(path22) {
+  return read_optional(path22) ?? "";
 }
-function read_if_readable(path7) {
+function read_if_readable(path22) {
   try {
-    return readFileSync(path7, "utf8");
+    return readFileSync(path22, "utf8");
   } catch {
     return void 0;
   }
@@ -267,12 +267,15 @@ function resolve_effective_upstream_version(base_url, package_name, options = {}
 var MS_PER_SECOND = 1e3;
 var SECONDS_PER_MINUTE = 60;
 var MS_PER_MINUTE = MS_PER_SECOND * SECONDS_PER_MINUTE;
+var PROBE_TIMEOUT_MS = 2e3;
 var FETCH_TIMEOUT_MS = 1e4;
+var GIT_TIMEOUT_MS = 1e4;
 var COMMAND_TIMEOUT_MS = 3e4;
 var INSTALL_TIMEOUT_MS = 6e5;
+var SUITE_TIMEOUT_MS = 18e5;
 
 // scripts/version/version-commands.ts
-import { execaSync as execaSync4 } from "execa";
+import { execaSync as execaSync5 } from "execa";
 
 // scripts/version/release-age.ts
 import { readFileSync as readFileSync3 } from "node:fs";
@@ -460,21 +463,1169 @@ function is_no_op_upgrade_command(command, installed) {
   return pins.every((pin) => installed.get(pin.name) === pin.version);
 }
 
+// scripts/version/upgrade-shell-command.ts
+import path10 from "node:path";
+
+// scripts/init/init-paths.ts
+import path6 from "node:path";
+import { fileURLToPath } from "node:url";
+var PACKAGE_DIR = path6.join(path6.dirname(fileURLToPath(import.meta.url)), "..", "..");
+var PROJECT_ROOT = process.cwd();
+
+// scripts/lib/shell-quote.ts
+var QUOTE = "'";
+var ESCAPED_QUOTE = String.raw`'\''`;
+function single_quoted(text) {
+  return QUOTE + text.split(QUOTE).join(ESCAPED_QUOTE) + QUOTE;
+}
+var BARE_WORD = /^[\w%+,./:=@-]+$/u;
+function word(token) {
+  return BARE_WORD.test(token) ? token : single_quoted(token);
+}
+var shell_quote = { single_quoted, word };
+
+// scripts/registry-migration/npm-acquisition.ts
+import path9 from "node:path";
+
+// scripts/config-merge/parse-jsonc.ts
+import { parseTree, printParseErrorCode } from "jsonc-parser";
+function property_key(property) {
+  return String(property.children?.[0]?.value);
+}
+function node_value(node) {
+  if (node === void 0) return void 0;
+  const children = node.children ?? [];
+  if (node.type === "array") return children.map((child) => node_value(child));
+  if (node.type !== "object") return node.value;
+  return Object.fromEntries(
+    children.map((property) => [property_key(property), node_value(property.children?.[1])])
+  );
+}
+function parse_jsonc(content) {
+  const errors = [];
+  const tree = parseTree(content, errors, { allowTrailingComma: true });
+  const [first_error] = errors;
+  if (first_error !== void 0) {
+    throw new SyntaxError(
+      `Invalid JSONC: ${printParseErrorCode(first_error.error)} at offset ${String(first_error.offset)}`
+    );
+  }
+  return json_object_schema.parse(node_value(tree));
+}
+
+// scripts/gh/fix-gh-packages-logic.ts
+import { loadAll as loadAll2 } from "js-yaml";
+import { z as z4 } from "zod";
+var GH_PACKAGES_HOST = "npm.pkg.github.com";
+var RESOLUTION_BLOCK = "\n    resolution:\n";
+var INTEGRITY_PREFIX = "      integrity: ";
+var TARBALL_PREFIX = "      tarball: ";
+var FLOW_RESOLUTION_LINE_START = "\n    resolution: {";
+var FLOW_TARBALL_KEY = ", tarball: ";
+var NPMRC_AUTH_TOKEN_PREFIX = `//${GH_PACKAGES_HOST}/:_authToken=`;
+var REGISTRY_KEY = ":registry";
+var lockfile_resolution_schema = z4.looseObject({
+  integrity: z4.string().optional(),
+  tarball: z4.string().optional()
+});
+var lockfile_package_schema = z4.looseObject({
+  resolution: lockfile_resolution_schema.optional()
+});
+var lockfile_document_schema = z4.looseObject({
+  packages: z4.record(z4.string(), lockfile_package_schema).optional()
+});
+function parse_lockfile_packages(raw) {
+  const merged = {};
+  for (const document of loadAll2(raw)) {
+    const { packages } = lockfile_document_schema.parse(document);
+    if (packages !== void 0) Object.assign(merged, packages);
+  }
+  return merged;
+}
+function registry_entry(line) {
+  const trimmed2 = line.trim();
+  if (!trimmed2.startsWith("@")) return void 0;
+  const eq_index = trimmed2.indexOf("=");
+  const key = trimmed2.slice(0, eq_index).trim();
+  if (eq_index === -1 || !key.endsWith(REGISTRY_KEY)) return void 0;
+  return [key.slice(0, -REGISTRY_KEY.length), trimmed2.slice(eq_index + 1).trim()];
+}
+function parse_scope_registries(npmrc2) {
+  const registries = /* @__PURE__ */ new Map();
+  for (const line of npmrc2.split("\n")) {
+    const entry2 = registry_entry(line);
+    if (entry2 !== void 0) registries.set(...entry2);
+  }
+  return registries;
+}
+function parse_gh_scopes(npmrc2) {
+  const entries = [...parse_scope_registries(npmrc2)];
+  return new Set(
+    entries.filter(([, registry]) => registry.replace(/\/$/u, "") === `https://${GH_PACKAGES_HOST}`).map(([scope2]) => scope2)
+  );
+}
+function extract_auth_token_from_line(line) {
+  const trimmed2 = line.trim();
+  if (!trimmed2.startsWith(NPMRC_AUTH_TOKEN_PREFIX)) return void 0;
+  const value = trimmed2.slice(NPMRC_AUTH_TOKEN_PREFIX.length);
+  if (value.startsWith("${") || value.length === 0) return void 0;
+  return value;
+}
+function parse_npmrc_auth_token(npmrc2) {
+  for (const line of npmrc2.split("\n")) {
+    const token = extract_auth_token_from_line(line);
+    if (token !== void 0) return token;
+  }
+  return void 0;
+}
+function scope_from_key(key) {
+  return key.startsWith("@") ? key.split("/", 1)[0] ?? "" : "";
+}
+function has_tarball(entry2) {
+  return entry2.resolution?.tarball !== void 0;
+}
+function package_path_from_key(key) {
+  const start = key.startsWith("@") ? 1 : 0;
+  const at_index = key.indexOf("@", start);
+  return at_index === -1 ? key : key.slice(0, at_index);
+}
+function package_version_from_key(key) {
+  const start = key.startsWith("@") ? 1 : 0;
+  const at_index = key.indexOf("@", start);
+  if (at_index === -1) return "";
+  return key.slice(at_index + 1).split("(", 1)[0] ?? "";
+}
+function should_fix_tarball(key, entry2, scopes) {
+  if (has_tarball(entry2)) return false;
+  const scope2 = scope_from_key(key);
+  return scope2.length > 0 && scopes.has(scope2);
+}
+function find_entry_start(content, package_key) {
+  const single = content.indexOf(`
+  '${package_key}':
+`);
+  if (single !== -1) return single;
+  return content.indexOf(`
+  "${package_key}":
+`);
+}
+function find_entry_end(content, entry_start) {
+  const next_match = /\n {2}['"]/u.exec(content.slice(entry_start + 1));
+  return next_match === null ? content.length : entry_start + 1 + next_match.index;
+}
+function find_integrity_eol_in_entry(entry_content) {
+  const resolution_pos = entry_content.indexOf(RESOLUTION_BLOCK);
+  if (resolution_pos === -1) return -1;
+  const integrity_pos = entry_content.indexOf(INTEGRITY_PREFIX, resolution_pos);
+  if (integrity_pos === -1) return -1;
+  return entry_content.indexOf("\n", integrity_pos);
+}
+function find_flow_resolution_brace(entry_content) {
+  const pos = entry_content.indexOf(FLOW_RESOLUTION_LINE_START);
+  if (pos === -1) return -1;
+  const line_end2 = entry_content.indexOf("\n", pos + 1);
+  const search_end = line_end2 === -1 ? entry_content.length : line_end2;
+  const brace = entry_content.lastIndexOf("}", search_end);
+  if (brace <= pos) return -1;
+  return brace;
+}
+function insert_expanded_tarball(content, entry_start, entry_end, tarball) {
+  const entry_content = content.slice(entry_start, entry_end);
+  const integrity_eol = find_integrity_eol_in_entry(entry_content);
+  if (integrity_eol === -1) return void 0;
+  if (entry_content.slice(integrity_eol + 1).startsWith(TARBALL_PREFIX)) return content;
+  const patched = `${entry_content.slice(0, integrity_eol + 1)}${TARBALL_PREFIX}${tarball}
+${entry_content.slice(integrity_eol + 1)}`;
+  return content.slice(0, entry_start) + patched + content.slice(entry_end);
+}
+function insert_flow_tarball(content, entry_start, entry_end, tarball) {
+  const entry_content = content.slice(entry_start, entry_end);
+  const brace_pos = find_flow_resolution_brace(entry_content);
+  if (brace_pos === -1) return void 0;
+  const open_brace = entry_content.lastIndexOf("{", brace_pos);
+  if (open_brace === -1) return void 0;
+  const flow_body = entry_content.slice(open_brace + 1, brace_pos);
+  if (/\btarball\s*:/u.test(flow_body)) return content;
+  const patched = `${entry_content.slice(0, brace_pos)}${FLOW_TARBALL_KEY}${tarball}${entry_content.slice(brace_pos)}`;
+  return content.slice(0, entry_start) + patched + content.slice(entry_end);
+}
+function insert_tarball_for_key(content, package_key, tarball) {
+  const entry_start = find_entry_start(content, package_key);
+  if (entry_start === -1) return content;
+  const entry_end = find_entry_end(content, entry_start);
+  return insert_expanded_tarball(content, entry_start, entry_end, tarball) ?? insert_flow_tarball(content, entry_start, entry_end, tarball) ?? content;
+}
+function patch_lockfile(content, patches) {
+  let result = content;
+  for (const [key, tarball] of patches) {
+    result = insert_tarball_for_key(result, key, tarball);
+  }
+  return result;
+}
+function resolve_token(environment_token, npmrc_token, get_fallback_token) {
+  if (environment_token !== void 0 && environment_token.length > 0) return environment_token;
+  if (npmrc_token !== void 0) return npmrc_token;
+  return get_fallback_token();
+}
+var fix_gh_packages_logic = {
+  parse_gh_scopes,
+  parse_scope_registries,
+  parse_npmrc_auth_token,
+  parse_lockfile_packages,
+  package_path_from_key,
+  package_version_from_key,
+  needs_tarball_fix: should_fix_tarball,
+  insert_tarball_for_key,
+  patch_lockfile,
+  resolve_token
+};
+
+// scripts/config-merge/list-patch.ts
+function is_matching(entry2, matchers) {
+  return matchers.some(
+    (matcher) => typeof matcher === "string" ? matcher === entry2 : matcher.test(entry2)
+  );
+}
+function apply_remove(existing, remove) {
+  if (remove === void 0 || remove.length === 0) return existing;
+  return existing.filter((entry2) => !is_matching(entry2, remove));
+}
+function collect_additions(kept, ensure2) {
+  if (ensure2 === void 0) return [];
+  return ensure2.filter((entry2) => !kept.includes(entry2));
+}
+function apply_list_patch(existing, patch) {
+  const kept = apply_remove(existing, patch.remove);
+  const additions = collect_additions(kept, patch.ensure);
+  const is_changed = additions.length > 0 || kept.length !== existing.length;
+  return { next: [...additions, ...kept], is_changed };
+}
+var list_patch = {
+  is_matching,
+  apply_list_patch
+};
+
+// scripts/config-merge/patch-json-key.ts
+import {
+  createScanner,
+  findNodeAtLocation,
+  getNodeValue,
+  parseTree as parseTree2,
+  stripComments
+} from "jsonc-parser";
+
+// scripts/config-merge/json-format.ts
+var PRINT_WIDTH = 100;
+var TAB_WIDTH = 2;
+var ARRAY_CLOSE = /^\t*\],?$/u;
+function is_array_open(line) {
+  return line.endsWith("[");
+}
+function is_leaf_element(line) {
+  return !line.endsWith("{") && !line.endsWith("[");
+}
+function line_width(line) {
+  const tabs = line.length - line.trimStart().length;
+  return tabs * TAB_WIDTH + (line.length - tabs);
+}
+function flatten_elements(elements) {
+  const scalars = elements.map((line) => line.trim().replace(/,$/u, ""));
+  return `[${scalars.join(", ")}]`;
+}
+function collect_block(lines, start) {
+  const close = lines.findIndex((line, index) => index > start && ARRAY_CLOSE.test(line));
+  if (close === -1) return void 0;
+  const elements = lines.slice(start + 1, close);
+  if (elements.some((line) => !is_leaf_element(line))) return void 0;
+  return { elements, close: lines[close] ?? "", end: close };
+}
+function try_inline(open, block) {
+  const trailing_comma = block.close.trimStart() === "]," ? "," : "";
+  const inlined = `${open.slice(0, -1)}${flatten_elements(block.elements)}${trailing_comma}`;
+  return line_width(inlined) <= PRINT_WIDTH ? inlined : void 0;
+}
+function rewrite_at(lines, index, line) {
+  const verbatim = { lines: [line], next: index + 1 };
+  const block = is_array_open(line) ? collect_block(lines, index) : void 0;
+  if (block === void 0) return verbatim;
+  const inlined = try_inline(line, block);
+  if (inlined === void 0) return verbatim;
+  return { lines: [inlined], next: block.end + 1 };
+}
+function inline_short_arrays(text) {
+  const lines = text.split("\n");
+  const output = [];
+  let index = 0;
+  while (index < lines.length) {
+    const rewrite = rewrite_at(lines, index, lines[index] ?? "");
+    output.push(...rewrite.lines);
+    index = rewrite.next;
+  }
+  return output.join("\n");
+}
+function format_json(value) {
+  return `${inline_short_arrays(JSON.stringify(value, void 0, "	"))}
+`;
+}
+function format_package_json(value) {
+  return `${JSON.stringify(value, void 0, "	")}
+`;
+}
+var json_format = {
+  format_json,
+  format_package_json
+};
+
+// scripts/config-merge/patch-json-key.ts
+var DOCUMENT_SUFFIX = "\n}\n";
+var DEFAULT_INDENT = "	";
+var LEADING_BLANKS = /^[\t ]*/u;
+var PREVIOUS_LINE_OFFSET = 2;
+var CRLF = "\r\n";
+var COMMA_PROBE_VALUE = 0;
+function render_value(key, value, has_trailing_comma) {
+  const probe_key = `${key} `;
+  const probe = has_trailing_comma ? { [key]: value, [probe_key]: COMMA_PROBE_VALUE } : { [key]: value };
+  const document = json_format.format_json(probe);
+  const prefix = `{
+	${JSON.stringify(key)}: `;
+  const suffix = has_trailing_comma ? `,
+	${JSON.stringify(probe_key)}: ${String(COMMA_PROBE_VALUE)}${DOCUMENT_SUFFIX}` : DOCUMENT_SUFFIX;
+  return document.slice(prefix.length, document.length - suffix.length);
+}
+function parse_root(content) {
+  const root2 = parseTree2(content);
+  return root2?.type === "object" ? root2 : void 0;
+}
+function replace_range(content, range, text) {
+  return content.slice(0, range.offset) + text + content.slice(range.offset + range.length);
+}
+function insert_at(content, offset, text) {
+  return replace_range(content, { offset, length: 0 }, text);
+}
+function render_indent(value_text, unit) {
+  if (unit === DEFAULT_INDENT || unit.length === 0) return value_text;
+  return value_text.replaceAll(/^\t+/gmu, (tabs) => unit.repeat(tabs.length));
+}
+function eol_of(content) {
+  return content.includes(CRLF) ? CRLF : "\n";
+}
+function fit_value(content, value_text, indent) {
+  const indented = render_indent(value_text, indent);
+  if (eol_of(content) === "\n") return indented;
+  return indented.split("\n").join(CRLF);
+}
+function line_indent(content, offset) {
+  const line_start = content.lastIndexOf("\n", offset - 1) + 1;
+  return LEADING_BLANKS.exec(content.slice(line_start, offset))?.[0] ?? "";
+}
+function line_end(content, offset) {
+  const index = content.indexOf("\n", offset);
+  if (index === -1) return content.length;
+  return index > offset && content[index - 1] === "\r" ? index - 1 : index;
+}
+function render_property(content, key, value_text, indent) {
+  return `${JSON.stringify(key)}: ${fit_value(content, value_text, indent)}`;
+}
+function insertion_offset(content, root2, value_end) {
+  return Math.min(line_end(content, value_end), root2.offset + root2.length - 1);
+}
+function separator_offset(content, offset, limit) {
+  const scanner = createScanner(content, true);
+  scanner.setPosition(offset);
+  scanner.scan();
+  const at = scanner.getTokenOffset();
+  return at < limit && content[at] === "," ? at : -1;
+}
+function has_separator_after(content, offset, limit) {
+  return separator_offset(content, offset, limit) !== -1;
+}
+function property_key2(property) {
+  const key = property.children?.[0]?.value;
+  return typeof key === "string" ? key : void 0;
+}
+function target_value_end(property) {
+  const value_node = property?.children?.[1];
+  return value_node === void 0 ? void 0 : value_node.offset + value_node.length;
+}
+function contains_comment(content, node) {
+  const text = content.slice(node.offset, node.offset + node.length);
+  return stripComments(text) !== text;
+}
+function rebalanced_value(content, key, value_node, has_trailing_comma) {
+  if (contains_comment(content, value_node)) return void 0;
+  const indent = line_indent(content, value_node.offset);
+  const rendered = fit_value(
+    content,
+    render_value(key, getNodeValue(value_node), has_trailing_comma),
+    indent
+  );
+  const current = content.slice(value_node.offset, value_node.offset + value_node.length);
+  return rendered === current ? void 0 : rendered;
+}
+function rebalance(content, property, has_trailing_comma) {
+  const key = property_key2(property);
+  const value_node = property.children?.[1];
+  if (key === void 0 || value_node === void 0) return content;
+  const rendered = rebalanced_value(content, key, value_node, has_trailing_comma);
+  return rendered === void 0 ? content : replace_range(content, value_node, rendered);
+}
+function append_after(content, root2, last, property) {
+  const value_end = last.offset + last.length;
+  const closing_brace = root2.offset + root2.length - 1;
+  const separator = has_separator_after(content, value_end, closing_brace) ? "" : ",";
+  const with_property = insert_at(content, insertion_offset(content, root2, value_end), property);
+  return insert_at(with_property, value_end, separator);
+}
+function insert_only_property(content, root2, property) {
+  const closing_brace = root2.offset + root2.length - 1;
+  const lead = content[closing_brace - 1] === "\n" ? "" : eol_of(content);
+  return insert_at(content, closing_brace, `${lead}${DEFAULT_INDENT}${property}${eol_of(content)}`);
+}
+function insert_property(content, root2, key, value_text) {
+  const last = root2.children?.at(-1);
+  if (last === void 0) {
+    const only = render_property(content, key, value_text, DEFAULT_INDENT);
+    return insert_only_property(content, root2, only);
+  }
+  const indent = line_indent(content, last.offset);
+  const property = `${eol_of(content)}${indent}${render_property(content, key, value_text, indent)}`;
+  return rebalance(append_after(content, root2, last, property), last, true);
+}
+function end_of_trailing_comment(content, end) {
+  const stop = line_end(content, end);
+  return content.slice(end, stop).trimStart().startsWith("//") ? stop : end;
+}
+function start_of_leading_comments(content, line_start, floor) {
+  let start = line_start;
+  while (start > floor) {
+    const previous = content.lastIndexOf("\n", start - PREVIOUS_LINE_OFFSET) + 1;
+    const is_comment_line = content.slice(previous, start).trimStart().startsWith("//");
+    if (!is_comment_line || previous < floor) return start;
+    start = previous;
+  }
+  return start;
+}
+function end_of_line_break(content, offset) {
+  if (content[offset] === "\r" && content[offset + 1] === "\n") return offset + PREVIOUS_LINE_OFFSET;
+  return content[offset] === "\n" ? offset + 1 : offset;
+}
+function body_range(content, root2, target2, separator_limit) {
+  const value_end = target2.offset + target2.length;
+  const comma = separator_limit === -1 ? -1 : separator_offset(content, value_end, separator_limit);
+  const end = end_of_trailing_comment(content, comma === -1 ? value_end : comma + 1);
+  const line_start = content.lastIndexOf("\n", target2.offset - 1) + 1;
+  const is_own_line = content.slice(line_start, target2.offset).trim().length === 0;
+  if (!is_own_line) return { offset: target2.offset, length: end - target2.offset };
+  const start = start_of_leading_comments(content, line_start, root2.offset + 1);
+  return { offset: start, length: end_of_line_break(content, end) - start };
+}
+function ranges_for_last_property(content, root2, previous, target2) {
+  const comma = separator_offset(content, previous.offset + previous.length, target2.offset);
+  const body = body_range(content, root2, target2, -1);
+  return comma === -1 ? [body] : [{ offset: comma, length: 1 }, body];
+}
+function removal_ranges(content, root2, index) {
+  const children = root2.children ?? [];
+  const target2 = children[index];
+  if (target2 === void 0) return [];
+  const next = children[index + 1];
+  if (next !== void 0) return [body_range(content, root2, target2, next.offset)];
+  const previous = children[index - 1];
+  if (previous === void 0) return [{ offset: root2.offset, length: root2.length }];
+  return ranges_for_last_property(content, root2, previous, target2);
+}
+function property_index(root2, key) {
+  return (root2.children ?? []).findIndex((child) => child.children?.[0]?.value === key);
+}
+function with_trailing_newline(content) {
+  return content.endsWith("\n") ? content : `${content}
+`;
+}
+function is_followed_by_comma(content, root2, key) {
+  const children = root2.children ?? [];
+  const index = property_index(root2, key);
+  if (index < 0) return false;
+  if (index < children.length - 1) return true;
+  const value_end = target_value_end(children[index]);
+  return value_end !== void 0 && has_separator_after(content, value_end, root2.offset + root2.length);
+}
+function set_json_key(content, key, value) {
+  const root2 = parse_root(content);
+  if (root2 === void 0) return content;
+  const existing = findNodeAtLocation(root2, [key]);
+  const value_text = render_value(
+    key,
+    value,
+    existing !== void 0 && is_followed_by_comma(content, root2, key)
+  );
+  if (existing === void 0) {
+    return with_trailing_newline(insert_property(content, root2, key, value_text));
+  }
+  const indented = fit_value(content, value_text, line_indent(content, existing.offset));
+  return with_trailing_newline(replace_range(content, existing, indented));
+}
+function resolve_parent(content, path22) {
+  const root2 = parse_root(content);
+  if (root2 === void 0) return void 0;
+  const parent = path22.length > 1 ? findNodeAtLocation(root2, path22.slice(0, -1)) : root2;
+  return parent?.type === "object" ? parent : void 0;
+}
+function cut_ranges(content, parent, ranges) {
+  const ordered2 = ranges.toSorted((left, right) => right.offset - left.offset);
+  let next = content;
+  for (const range of ordered2) {
+    next = replace_range(next, range, range.offset === parent.offset ? "{}" : "");
+  }
+  return next;
+}
+function rebalance_new_last(content, path22) {
+  const parent = resolve_parent(content, path22);
+  const last = parent?.children?.at(-1);
+  if (parent === void 0 || last === void 0) return content;
+  return rebalance(content, last, has_separator_after(content, parent.offset, parent.offset));
+}
+function cut_property(content, parent, path22) {
+  const index = property_index(parent, path22.at(-1) ?? "");
+  const ranges = removal_ranges(content, parent, index);
+  if (ranges.length === 0) return content;
+  const cut = cut_ranges(content, parent, ranges);
+  const did_end_object = index === (parent.children ?? []).length - 1;
+  return did_end_object ? rebalance_new_last(cut, path22) : cut;
+}
+function remove_json_path(content, path22) {
+  const parent = resolve_parent(content, path22);
+  if (parent === void 0) return content;
+  const next = cut_property(content, parent, path22);
+  return next === content ? content : with_trailing_newline(next);
+}
+function remove_json_key(content, key) {
+  return remove_json_path(content, [key]);
+}
+var patch_json_key = {
+  set_json_key,
+  remove_json_key,
+  remove_json_path,
+  eol_of,
+  fit_value,
+  line_indent
+};
+
+// scripts/config-merge/patch-json-list.ts
+function normalize_list(value) {
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value)) return value.map(String);
+  return [];
+}
+function patch_json_list_field(content, options) {
+  const parsed = parse_jsonc(content);
+  const existing = normalize_list(parsed[options.field]);
+  const { next, is_changed } = list_patch.apply_list_patch(existing, options);
+  if (!is_changed) return content;
+  return patch_json_key.set_json_key(content, options.field, [...next]);
+}
+var json_list = {
+  patch_json_list_field
+};
+
+// scripts/config-merge/patch-yaml-list.ts
+import { dump } from "js-yaml";
+var { parse_yaml: parse_yaml2 } = yaml_document;
+function read_yaml_list_field(content, field) {
+  const raw = parse_yaml2(content)[field];
+  if (typeof raw === "string") return [raw];
+  return Array.isArray(raw) ? string_array_schema.parse(raw) : [];
+}
+function replace_field(parsed, field, value) {
+  return Object.fromEntries(
+    Object.entries(parsed).map(([key, entry2]) => [key, key === field ? [...value] : entry2])
+  );
+}
+function insert_after(parsed, field, value, anchor) {
+  const entries = Object.entries(parsed);
+  const index = entries.findIndex(([key]) => key === anchor);
+  if (index === -1) return { ...parsed, [field]: [...value] };
+  return Object.fromEntries([
+    ...entries.slice(0, index + 1),
+    [field, [...value]],
+    ...entries.slice(index + 1)
+  ]);
+}
+function insert_new_field(parsed, field, value, position) {
+  if (position === "front") return { [field]: [...value], ...parsed };
+  if (position === "end") return { ...parsed, [field]: [...value] };
+  return insert_after(parsed, field, value, position.after);
+}
+function place_field(parsed, field, value, position) {
+  if (Object.hasOwn(parsed, field)) return replace_field(parsed, field, value);
+  return insert_new_field(parsed, field, value, position);
+}
+function patch_yaml_list_field(content, options) {
+  const parsed = parse_yaml2(content);
+  const existing = read_yaml_list_field(content, options.field);
+  const { next, is_changed } = list_patch.apply_list_patch(existing, options);
+  if (!is_changed) return content;
+  const placed = place_field(parsed, options.field, next, options.position ?? "front");
+  return dump(placed, options.quote_style === void 0 ? {} : { quoteStyle: options.quote_style });
+}
+var yaml_list = {
+  patch_yaml_list_field,
+  read_yaml_list_field
+};
+
+// scripts/config-merge/index.ts
+var config_merge = {
+  patch_yaml_list_field: yaml_list.patch_yaml_list_field,
+  read_yaml_list_field: yaml_list.read_yaml_list_field,
+  patch_json_list_field: json_list.patch_json_list_field
+};
+
+// scripts/safe-chain/preinstall-command.ts
+var INSTALL_GUIDE_ANCHOR = "installing-safe-chain";
+var INSTALL_GUIDE_URL = `https://github.com/joshuafolkken/kit/blob/main/SECURITY.md#${INSTALL_GUIDE_ANCHOR}`;
+var INTEGRATION_HINT = `Warning: safe-chain (@aikidosec/safe-chain) is not scanning this install because its shell integration is not active. Install it with the hash-verified steps at ${INSTALL_GUIDE_URL} - then restart your terminal.`;
+var LOCAL_INTEGRATION_CHECK_SOURCE = `if(!process.env.CI&&!process.env.GLOBAL_AGENT_HTTP_PROXY)console.warn('${INTEGRATION_HINT}')`;
+var SAFE_CHAIN_CMD = `node -e "${LOCAL_INTEGRATION_CHECK_SOURCE}"`;
+var LEGACY_PREINSTALL_RE = /^pnpm dlx @aikidosec\/safe-chain(?:@\S+)? setup-ci(?: && node -e "[^"]*")?$/u;
+function migrate_preinstall(value) {
+  return LEGACY_PREINSTALL_RE.test(value) ? SAFE_CHAIN_CMD : value;
+}
+var safe_chain_preinstall = {
+  SAFE_CHAIN_CMD,
+  LOCAL_INTEGRATION_CHECK_SOURCE,
+  INTEGRATION_HINT,
+  INSTALL_GUIDE_ANCHOR,
+  migrate_preinstall
+};
+
+// scripts/init/init-logic-migrate.ts
+function migrate_scripts(scripts) {
+  const current = scripts["preinstall"];
+  if (current === void 0) return scripts;
+  return { ...scripts, preinstall: safe_chain_preinstall.migrate_preinstall(current) };
+}
+var init_logic_migrate = { migrate_scripts };
+
+// scripts/init/init-logic-package-key-order.ts
+var PACKAGE_JSON_KEY_ORDER = [
+  "name",
+  "version",
+  "description",
+  "keywords",
+  "homepage",
+  "bugs",
+  "license",
+  "author",
+  "contributors",
+  "funding",
+  "files",
+  "main",
+  "browser",
+  "exports",
+  "imports",
+  "bin",
+  "man",
+  "directories",
+  "repository",
+  "type",
+  "types",
+  "typings",
+  "typesVersions",
+  "publishConfig",
+  "private",
+  "scripts",
+  "config",
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "peerDependenciesMeta",
+  "bundleDependencies",
+  "bundledDependencies",
+  "optionalDependencies",
+  "overrides",
+  "resolutions",
+  "packageManager",
+  "engines",
+  "devEngines",
+  "os",
+  "cpu",
+  "size-limit",
+  "pnpm"
+];
+
+// scripts/init/kit-base-preset.ts
+var KIT_LEFTHOOK_PRESET = /@joshuafolkken\/[^/]+\/lefthook\//u;
+var KIT_CSPELL_PRESET = /@joshuafolkken\/[^/]+\/cspell(?:\/|$)/u;
+var KIT_TSCONFIG_PRESET = /@joshuafolkken\/[^/]+\/tsconfig\//u;
+var SVELTEKIT_PRESET = /(?<![\w-])sveltekit(?![\w-])/u;
+function has_match(entries, pattern) {
+  return entries.some((entry2) => pattern.test(entry2));
+}
+function is_base_present(entries, subsystem_pattern) {
+  return has_match(entries, subsystem_pattern) || has_match(entries, SVELTEKIT_PRESET);
+}
+function is_lefthook_base_present(entries) {
+  return is_base_present(entries, KIT_LEFTHOOK_PRESET);
+}
+function is_cspell_base_present(entries) {
+  return is_base_present(entries, KIT_CSPELL_PRESET);
+}
+function is_tsconfig_base_present(entries) {
+  return is_base_present(entries, KIT_TSCONFIG_PRESET);
+}
+var kit_base_preset = {
+  is_lefthook_base_present,
+  is_cspell_base_present,
+  is_tsconfig_base_present
+};
+
+// scripts/init/tsconfig-preset-migration.ts
+import { existsSync as existsSync2 } from "node:fs";
+import path7 from "node:path";
+var LEGACY_PRESET_ENTRY = /@joshuafolkken\/[^/]+\/tsconfig\/[^/]+\.jsonc$/u;
+var LEGACY_SUFFIX = ".jsonc";
+var CURRENT_SUFFIX = ".json";
+var EXTENDS_FIELD = "extends";
+function is_migration_target_present(base_directory, entry2) {
+  return existsSync2(path7.resolve(base_directory, entry2));
+}
+function migrate_entry(base_directory, entry2) {
+  if (!LEGACY_PRESET_ENTRY.test(entry2)) return entry2;
+  const migrated = `${entry2.slice(0, -LEGACY_SUFFIX.length)}${CURRENT_SUFFIX}`;
+  return is_migration_target_present(base_directory, migrated) ? migrated : entry2;
+}
+function migrate_extends_value(base_directory, raw) {
+  if (typeof raw === "string") return migrate_entry(base_directory, raw);
+  if (Array.isArray(raw)) {
+    return string_array_schema.parse(raw).map((entry2) => migrate_entry(base_directory, entry2));
+  }
+  return raw;
+}
+function migrate_preset_paths(content, base_directory) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed[EXTENDS_FIELD];
+  const migrated = migrate_extends_value(base_directory, raw);
+  if (JSON.stringify(migrated) === JSON.stringify(raw)) return content;
+  return patch_json_key.set_json_key(content, EXTENDS_FIELD, migrated);
+}
+var tsconfig_preset_migration = {
+  migrate_preset_paths
+};
+
+// scripts/init/init-logic-json-merge.ts
+function merge_json_extends(content, entry2) {
+  return config_merge.patch_json_list_field(content, { field: EXTENDS_FIELD, ensure: [entry2] });
+}
+function read_extends_entries(content) {
+  const raw = parse_jsonc(content)[EXTENDS_FIELD];
+  if (typeof raw === "string") return [raw];
+  if (Array.isArray(raw)) return string_array_schema.parse(raw);
+  return [];
+}
+function merge_tsconfig_extends(content, entry2, base_directory) {
+  const migrated = tsconfig_preset_migration.migrate_preset_paths(content, base_directory);
+  if (kit_base_preset.is_tsconfig_base_present(read_extends_entries(migrated))) return migrated;
+  return merge_json_extends(migrated, entry2);
+}
+function extract_compiler_options(content) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["compilerOptions"];
+  if (raw === void 0) return {};
+  return json_object_schema.parse(raw);
+}
+function is_redundant_option(value, key, base_options) {
+  if (!Object.hasOwn(base_options, key)) return false;
+  return JSON.stringify(base_options[key]) === JSON.stringify(value);
+}
+var COMPILER_OPTIONS_FIELD = "compilerOptions";
+function drop_redundant_options(content, redundant) {
+  let current = content;
+  for (const key of redundant) {
+    current = patch_json_key.remove_json_path(current, [COMPILER_OPTIONS_FIELD, key]);
+  }
+  return current;
+}
+function serialize_stripped(content, kept, redundant) {
+  if (Object.keys(kept).length === 0) {
+    return patch_json_key.remove_json_key(content, COMPILER_OPTIONS_FIELD);
+  }
+  return drop_redundant_options(content, redundant);
+}
+function redundant_option_keys(current, base_options) {
+  return Object.entries(current).filter(([key, value]) => is_redundant_option(value, key, base_options)).map(([key]) => key);
+}
+function strip_redundant_compiler_options(content, base_options) {
+  const raw = parse_jsonc(content)[COMPILER_OPTIONS_FIELD];
+  if (raw === void 0) return content;
+  const current = json_object_schema.parse(raw);
+  const redundant = redundant_option_keys(current, base_options);
+  if (redundant.length === 0) return content;
+  const kept = Object.entries(current).filter(([key]) => !redundant.includes(key));
+  return serialize_stripped(content, Object.fromEntries(kept), redundant);
+}
+function merge_json_array_field(content, key, values) {
+  const parsed = parse_jsonc(content);
+  const existing = Object.hasOwn(parsed, key) ? string_array_schema.parse(parsed[key]) : [];
+  const to_add = values.filter((value) => !existing.includes(value));
+  if (to_add.length === 0) return content;
+  return patch_json_key.set_json_key(content, key, [...existing, ...to_add]);
+}
+function missing_entries(existing, additions) {
+  return Object.entries(additions).filter(([key]) => !Object.hasOwn(existing, key));
+}
+function merge_owned_entries(current, update) {
+  const current_object = json_object_schema.safeParse(current);
+  const update_object = json_object_schema.safeParse(update);
+  if (!current_object.success || !update_object.success) return void 0;
+  const owned = current_object.data;
+  const missing = missing_entries(owned, update_object.data);
+  if (missing.length === 0) return void 0;
+  return { ...owned, ...Object.fromEntries(missing) };
+}
+function collect_applicable_updates(parsed, updates) {
+  const resolved = Object.entries(updates).map(([key, value]) => [
+    key,
+    Object.hasOwn(parsed, key) ? merge_owned_entries(parsed[key], value) : value
+  ]);
+  return Object.fromEntries(resolved.filter(([, merged]) => merged !== void 0));
+}
+function merge_json_object(content, updates) {
+  const parsed = parse_jsonc(content);
+  const applicable = collect_applicable_updates(parsed, updates);
+  if (Object.keys(applicable).length === 0) return content;
+  let current = content;
+  for (const [key, value] of Object.entries(applicable)) {
+    current = patch_json_key.set_json_key(current, key, value);
+  }
+  return current;
+}
+function serialize_package_json(value) {
+  return json_format.format_package_json(value);
+}
+var SCRIPTS_PREPEND_KEYS = /* @__PURE__ */ new Set(["preinstall"]);
+function merge_package_scripts(content, scripts) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["scripts"];
+  const existing = raw === void 0 ? {} : string_record_schema.parse(raw);
+  const migrated = init_logic_migrate.migrate_scripts(existing);
+  const to_add = missing_entries(migrated, scripts);
+  const did_migrate = JSON.stringify(migrated) !== JSON.stringify(existing);
+  if (!did_migrate && to_add.length === 0) return content;
+  const prepend = Object.fromEntries(to_add.filter(([k]) => SCRIPTS_PREPEND_KEYS.has(k)));
+  const append2 = Object.fromEntries(to_add.filter(([k]) => !SCRIPTS_PREPEND_KEYS.has(k)));
+  return serialize_package_json({ ...parsed, scripts: { ...prepend, ...migrated, ...append2 } });
+}
+function upgrade_safe_chain_preinstall(content) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["scripts"];
+  if (raw === void 0) return content;
+  const scripts = string_record_schema.parse(raw);
+  const current = scripts["preinstall"];
+  if (current === void 0) return content;
+  const migrated = safe_chain_preinstall.migrate_preinstall(current);
+  if (migrated === current) return content;
+  return serialize_package_json({ ...parsed, scripts: { ...scripts, preinstall: migrated } });
+}
+function merge_development_dependencies(content, additions) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["devDependencies"];
+  const existing = raw === void 0 ? {} : string_record_schema.parse(raw);
+  const to_add = missing_entries(existing, additions);
+  if (to_add.length === 0) return content;
+  return serialize_package_json({
+    ...parsed,
+    devDependencies: { ...existing, ...Object.fromEntries(to_add) }
+  });
+}
+function merge_package_manager(content, value) {
+  if (value.length === 0) return content;
+  const parsed = parse_jsonc(content);
+  if ("packageManager" in parsed) return content;
+  return serialize_package_json({ ...parsed, packageManager: value });
+}
+function merge_development_engines(content, value) {
+  const parsed = parse_jsonc(content);
+  if ("devEngines" in parsed) return content;
+  return serialize_package_json({ ...parsed, devEngines: value });
+}
+function has_package_scripts_marker(content, marker) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["scripts"];
+  if (raw === void 0) return false;
+  const scripts = string_record_schema.parse(raw);
+  return Object.values(scripts).some((cmd) => cmd.includes(marker));
+}
+function merge_package_script_suffix(content, key, cmd) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["scripts"];
+  if (raw === void 0) return content;
+  const scripts = string_record_schema.parse(raw);
+  const existing = scripts[key];
+  if (existing === void 0 || existing.includes(cmd)) return content;
+  const updated_value = existing.trim().length === 0 ? cmd : `${existing} && ${cmd}`;
+  return serialize_package_json({ ...parsed, scripts: { ...scripts, [key]: updated_value } });
+}
+function replace_in_package_script(content, key, from, to) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["scripts"];
+  if (raw === void 0) return content;
+  const scripts = string_record_schema.parse(raw);
+  const existing = scripts[key];
+  if (!existing?.includes(from)) return content;
+  return serialize_package_json({
+    ...parsed,
+    // The replacer is a function so `to` is inserted verbatim: passed as a string, a `$&` or `$1`
+    // inside it would be read as a substitution pattern rather than as the text it is.
+    scripts: { ...scripts, [key]: existing.replace(from, () => to) }
+  });
+}
+function remove_script_with_marker(content, key, marker) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["scripts"];
+  if (raw === void 0) return content;
+  const scripts = string_record_schema.parse(raw);
+  if (!scripts[key]?.includes(marker)) return content;
+  const rest = Object.fromEntries(Object.entries(scripts).filter(([k]) => k !== key));
+  return serialize_package_json({ ...parsed, scripts: rest });
+}
+function sort_package_json_keys(content) {
+  const parsed = parse_jsonc(content);
+  const all_keys = Object.keys(parsed);
+  const known = PACKAGE_JSON_KEY_ORDER.filter((k) => Object.hasOwn(parsed, k));
+  const unknown = all_keys.filter((k) => !PACKAGE_JSON_KEY_ORDER.includes(k));
+  const ordered2 = Object.fromEntries([...known, ...unknown].map((k) => [k, parsed[k]]));
+  const serialized = serialize_package_json(ordered2);
+  const current = serialize_package_json(parsed);
+  if (serialized === current) return content;
+  return serialized;
+}
+var init_logic_json_merge = {
+  merge_json_extends,
+  merge_tsconfig_extends,
+  extract_compiler_options,
+  strip_redundant_compiler_options,
+  merge_json_array_field,
+  merge_json_object,
+  merge_package_scripts,
+  upgrade_safe_chain_preinstall,
+  merge_package_script_suffix,
+  replace_in_package_script,
+  remove_script_with_marker,
+  has_package_scripts_marker,
+  merge_development_dependencies,
+  merge_package_manager,
+  merge_development_engines,
+  sort_package_json_keys
+};
+
+// scripts/registry-migration/npm-acquisition.ts
+import { z as z5 } from "zod";
+
+// scripts/registry-migration/migrate-lock.ts
+import path8 from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { dump as dump2 } from "js-yaml";
+var SCOPE = "@joshuafolkken/";
+var KIT = `${SCOPE}kit`;
+var REGISTRY = "https://registry.npmjs.org/";
+var PNPM_VERSION = "12.17.0";
+function scoped_artifacts(content) {
+  return Object.entries(fix_gh_packages_logic.parse_lockfile_packages(content)).filter(([key]) => key.startsWith(SCOPE)).map(([key, entry2]) => ({
+    name: fix_gh_packages_logic.package_path_from_key(key),
+    version: fix_gh_packages_logic.package_version_from_key(key),
+    integrity: entry2.resolution?.integrity
+  }));
+}
+function importer_manifests(content) {
+  return yaml_document.parse_yaml_documents(content).flatMap(
+    (document) => yaml_document.is_mapping_document(document["importers"]) ? Object.keys(document["importers"]) : []
+  ).map((importer) => path8.join(importer, "package.json"));
+}
+function non_npm_resolution(content) {
+  const entries = Object.entries(fix_gh_packages_logic.parse_lockfile_packages(content)).filter(
+    ([key]) => key.startsWith(SCOPE)
+  );
+  for (const [key, entry2] of entries) {
+    const tarball = entry2.resolution?.tarball;
+    if (tarball !== void 0 && !tarball.startsWith(REGISTRY)) return key;
+  }
+  return void 0;
+}
+function has_npm_sources(content) {
+  return non_npm_resolution(content) === void 0;
+}
+function assert_npm_sources(content) {
+  const key = non_npm_resolution(content);
+  if (key !== void 0) throw new Error(`Non-npm resolution remains: ${key}`);
+}
+function npmrc(content) {
+  const newline = content.includes("\r\n") ? "\r\n" : "\n";
+  const lines = content.split(/\r?\n/u).filter((line) => !/^\s*@joshuafolkken:registry\s*=/u.test(line));
+  while (lines.at(-1) === "") lines.pop();
+  lines.push(`@joshuafolkken:registry=${REGISTRY}`, "");
+  return lines.join(newline);
+}
+function strip_tarball(resolution) {
+  if (yaml_document.is_mapping_document(resolution)) delete resolution["tarball"];
+}
+function strip_resolutions(document) {
+  if (!yaml_document.is_mapping_document(document["packages"])) return;
+  const scoped = Object.entries(document["packages"]).filter(([key]) => key.startsWith(SCOPE));
+  for (const [, entry2] of scoped) {
+    if (yaml_document.is_mapping_document(entry2)) strip_tarball(entry2["resolution"]);
+  }
+}
+function graph(content) {
+  const documents = yaml_document.parse_yaml_documents(content);
+  for (const document of documents) strip_resolutions(document);
+  return documents;
+}
+function assert_preserved(before, after) {
+  if (before === "") return;
+  if (!isDeepStrictEqual(graph(before), graph(after))) {
+    throw new Error(
+      "Resolution changed the dependency graph or unrelated metadata; no files changed"
+    );
+  }
+}
+function restore_checksum(original, resolved) {
+  const checksum = original["pnpmfileChecksum"];
+  if (checksum === void 0 || resolved["pnpmfileChecksum"] !== void 0) return false;
+  resolved["pnpmfileChecksum"] = checksum;
+  return true;
+}
+function restore_pnpmfile_checksum(before, after) {
+  const originals = yaml_document.parse_yaml_documents(before);
+  const resolved = yaml_document.parse_yaml_documents(after);
+  const restored = resolved.map(
+    (document, index) => restore_checksum(originals[index] ?? {}, document)
+  );
+  const prefix = after.startsWith("---") ? "---\n" : "";
+  return restored.includes(true) ? prefix + resolved.map((document) => dump2(document)).join("---\n") : after;
+}
+var migrate_lock = {
+  SCOPE,
+  KIT,
+  REGISTRY,
+  PNPM_VERSION,
+  scoped_artifacts,
+  npmrc,
+  assert_preserved,
+  restore_pnpmfile_checksum,
+  assert_npm_sources,
+  has_npm_sources,
+  importer_manifests
+};
+
+// scripts/registry-migration/npm-acquisition.ts
+var NPM = "https://registry.npmjs.org/";
+var SCOPE2 = "@joshuafolkken";
+var LOCKFILE = "pnpm-lock.yaml";
+var SCRIPTS = ["prepare", "postinstall"];
+var dependency_schema = z5.record(z5.string(), z5.string()).optional();
+var manifest_schema = z5.object({
+  dependencies: dependency_schema,
+  devDependencies: dependency_schema,
+  optionalDependencies: dependency_schema,
+  peerDependencies: dependency_schema
+});
+var scripts_schema = z5.looseObject({ scripts: z5.record(z5.string(), z5.string()).optional() });
+function read(root2, name) {
+  return file_reader.read_file_or_empty(path9.join(root2, name));
+}
+function is_npm(content) {
+  const registry = fix_gh_packages_logic.parse_scope_registries(content).get(SCOPE2);
+  return registry === NPM || registry === NPM.slice(0, -1);
+}
+function is_project_npm(root2 = process.cwd()) {
+  return is_npm(read(root2, ".npmrc")) && migrate_lock.has_npm_sources(read(root2, LOCKFILE));
+}
+function is_npm_only(root2) {
+  const npmrc2 = read(root2, ".npmrc");
+  return is_project_npm(root2) && fix_gh_packages_logic.parse_gh_scopes(npmrc2).size === 0;
+}
+function has_scoped_name(dependencies) {
+  return Object.keys(dependencies ?? {}).some((name) => name.startsWith(migrate_lock.SCOPE));
+}
+function has_scoped_dependencies(content) {
+  const manifest = manifest_schema.parse(parse_jsonc(content || "{}"));
+  return Object.values(manifest).some((dependencies) => has_scoped_name(dependencies));
+}
+function can_initialize(root2) {
+  return read(root2, "pnpm-workspace.yaml") === "" && !has_scoped_dependencies(read(root2, "package.json")) && migrate_lock.scoped_artifacts(read(root2, LOCKFILE)).length === 0;
+}
+function can_manage(root2) {
+  const content = read(root2, ".npmrc");
+  return is_npm(content) || !fix_gh_packages_logic.parse_scope_registries(content).has(SCOPE2) && can_initialize(root2);
+}
+function merge_npmrc(content, root2) {
+  if (is_npm(content)) return migrate_lock.npmrc(content);
+  if (fix_gh_packages_logic.parse_scope_registries(content).has(SCOPE2)) return content;
+  if (can_initialize(root2)) return migrate_lock.npmrc(content);
+  return content;
+}
+function is_script_value(content, key, value) {
+  return scripts_schema.parse(parse_jsonc(content)).scripts?.[key] === value;
+}
+function strip_script(content, key, command) {
+  const script = scripts_schema.parse(parse_jsonc(content)).scripts?.[key];
+  if (script === void 0) return content;
+  const suffix = ` && (${command} || true)`;
+  if (!script.endsWith(suffix)) return content;
+  return init_logic_json_merge.replace_in_package_script(
+    content,
+    key,
+    script,
+    script.slice(0, -suffix.length)
+  );
+}
+function merge_lifecycle(content, root2, command) {
+  if (!is_npm_only(root2)) return content;
+  let merged = content;
+  for (const key of SCRIPTS) merged = strip_script(merged, key, command);
+  return merged;
+}
+var npm_acquisition = {
+  is_npm,
+  is_project_npm,
+  is_npm_only,
+  is_script_value,
+  can_manage,
+  merge_npmrc,
+  merge_lifecycle
+};
+
 // scripts/version/upgrade-shell-command.ts
 var STEP_SEPARATOR = " && ";
 function update_scope_flag(is_local) {
   return is_local ? "-D" : "-g";
 }
 function update_argv(latest, is_local, config) {
-  return ["pnpm", "add", update_scope_flag(is_local), `${config.package_name}@${latest}`];
+  const registry = !is_local && config.package_name === KIT_PACKAGE_NAME ? ["--config.@joshuafolkken:registry=https://registry.npmjs.org/"] : [];
+  return [
+    "pnpm",
+    "add",
+    update_scope_flag(is_local),
+    ...registry,
+    `${config.package_name}@${latest}`
+  ];
 }
 function format_update_command(latest, is_local, config) {
   return update_argv(latest, is_local, config).join(" ");
 }
-function build_upgrade_command(latest, is_local, config) {
+function needs_migration(is_local, package_name, root2) {
+  return is_local && package_name === KIT_PACKAGE_NAME && !npm_acquisition.is_project_npm(root2);
+}
+function build_upgrade_command(latest, is_local, config, root2 = process.cwd()) {
   const steps = [update_argv(latest, is_local, config)];
+  if (needs_migration(is_local, config.package_name, root2)) {
+    steps.unshift(["node", path10.join(PACKAGE_DIR, "dist/registry-migrate.mjs"), latest]);
+  }
   if (is_local) steps.push(["node_modules/.bin/tsx", config.fix_gh_packages_path]);
-  return { text: steps.map((step) => step.join(" ")).join(STEP_SEPARATOR), steps };
+  return {
+    text: steps.map((step) => step.map((argument) => shell_quote.word(argument)).join(" ")).join(STEP_SEPARATOR),
+    steps
+  };
 }
 function shell_upgrade_command(command) {
   return { text: command, steps: [["sh", "-c", command]] };
@@ -644,6 +1795,12 @@ 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/josh/agent-session-environment.ts
 var SESSION_ID_KEY = "CLAUDE_CODE_SESSION_ID";
@@ -748,8 +1905,8 @@ function throw_first_failure(failures) {
   throw first;
 }
 async function drain(pool, worker) {
-  for (let entry = pool.queue.shift(); entry !== void 0 && pool.failures.length === 0; entry = pool.queue.shift()) {
-    const [index, item] = entry;
+  for (let entry2 = pool.queue.shift(); entry2 !== void 0 && pool.failures.length === 0; entry2 = pool.queue.shift()) {
+    const [index, item] = entry2;
     try {
       pool.results.push({ index, value: await worker(item, index) });
     } catch (error) {
@@ -772,20 +1929,20 @@ async function bounded_map(items, limit, worker) {
 }
 function limiter(limit) {
   const width = pool_width(limit, Infinity);
-  const waiting = [];
+  const waiting2 = [];
   let active = 0;
   return {
     async run(task) {
       if (active < width) active += 1;
       else {
-        await new Promise((resolve) => {
-          waiting.push(resolve);
+        await new Promise((resolve2) => {
+          waiting2.push(resolve2);
         });
       }
       try {
         return await task();
       } finally {
-        const next = waiting.shift();
+        const next = waiting2.shift();
         if (next === void 0) active -= 1;
         else next();
       }
@@ -858,7 +2015,7 @@ function redact(text) {
 function string_leaves(value) {
   if (typeof value === "string") return [value];
   if (typeof value !== "object" || value === null) return [];
-  return Object.values(value).flatMap((entry) => string_leaves(entry));
+  return Object.values(value).flatMap((entry2) => string_leaves(entry2));
 }
 function decoded(body) {
   const value = json_value.parse_or_undefined(body);
@@ -876,7 +2033,7 @@ var token_shape = {
 };
 
 // scripts/gh/git-gh-exec.ts
-import { execa as execa2, execaSync } from "execa";
+import { execa as execa5, execaSync as execaSync2 } from "execa";
 
 // scripts/rules/git-argv.ts
 var ENV_ASSIGNMENT = /^[A-Za-z_]\w*=/u;
@@ -925,15 +2082,15 @@ function words_of(segment) {
   return segment.match(WORD) ?? [];
 }
 var PATH_SEPARATOR2 = "/";
-function program_name(word) {
-  return word.slice(word.lastIndexOf(PATH_SEPARATOR2) + NEXT);
+function program_name(word2) {
+  return word2.slice(word2.lastIndexOf(PATH_SEPARATOR2) + NEXT);
 }
-function is_wrapper_token(word) {
-  return word === SUBSHELL_OPEN || ENV_ASSIGNMENT.test(word.replaceAll(WORD_QUOTING, "")) || WRAPPER_WORDS.has(program_name(word));
+function is_wrapper_token(word2) {
+  return word2 === SUBSHELL_OPEN || ENV_ASSIGNMENT.test(word2.replaceAll(WORD_QUOTING, "")) || WRAPPER_WORDS.has(program_name(word2));
 }
-function wrapper_flag_width(word = "") {
-  if (!word.startsWith(FLAG_PREFIX)) return 0;
-  return WRAPPER_VALUE_FLAGS.has(word) ? AFTER_VALUE : NEXT;
+function wrapper_flag_width(word2 = "") {
+  if (!word2.startsWith(FLAG_PREFIX)) return 0;
+  return WRAPPER_VALUE_FLAGS.has(word2) ? AFTER_VALUE : NEXT;
 }
 function after_wrapper_word(words, index) {
   let next = index + NEXT;
@@ -967,9 +2124,9 @@ function after_globals(words) {
 function program_of(segment) {
   const words = words_of(segment);
   const command_index = after_wrapper(words);
-  const word = words[command_index];
-  if (word === void 0) return void 0;
-  return { name: program_name(word), args: words.slice(command_index + NEXT) };
+  const word2 = words[command_index];
+  if (word2 === void 0) return void 0;
+  return { name: program_name(word2), args: words.slice(command_index + NEXT) };
 }
 function arguments_of(segment, command) {
   const call = program_of(segment);
@@ -1054,16 +2211,16 @@ function is_gh_api(segment) {
 }
 function flags_of(segment) {
   const words = (git_argv.arguments_of(segment, GH_COMMAND) ?? []).map(
-    (word) => word.replace(INCLUDE_CLUSTER, "-")
+    (word2) => word2.replace(INCLUDE_CLUSTER, "-")
   );
   let has_value_pending = false;
-  return words.map((word, index) => [word, words[index + NEXT2] ?? ""]).filter(([word]) => {
+  return words.map((word2, index) => [word2, words[index + NEXT2] ?? ""]).filter(([word2]) => {
     if (has_value_pending) {
       has_value_pending = false;
       return false;
     }
-    has_value_pending = API_VALUE_TAKING_FLAGS.has(word);
-    return word.startsWith(FLAG_PREFIX2);
+    has_value_pending = API_VALUE_TAKING_FLAGS.has(word2);
+    return word2.startsWith(FLAG_PREFIX2);
   });
 }
 function method_value(flag, next) {
@@ -1110,9 +2267,9 @@ function file_path(flag, value) {
 }
 function field_source(flag, raw) {
   const value = raw.replaceAll(QUOTES, "");
-  const path7 = file_path(flag, value);
-  if (path7 === void 0) return { kind: "text", value: field_value(value) };
-  return path7 === STANDARD_INPUT ? void 0 : { kind: "file", value: path7 };
+  const path22 = file_path(flag, value);
+  if (path22 === void 0) return { kind: "text", value: field_value(value) };
+  return path22 === STANDARD_INPUT ? void 0 : { kind: "file", value: path22 };
 }
 function field_sources(segment) {
   return flags_of(segment).flatMap(([flag, next]) => {
@@ -1167,16 +2324,16 @@ function placeholder_of(segment, previous = "") {
   if (NUMBER.test(segment)) return "{n}";
   return SHA.test(segment) ? "{sha}" : segment;
 }
-function normalized(path7) {
-  const [bare = ""] = path7.replace(/^\//u, "").split("?", 1);
+function normalized(path22) {
+  const [bare = ""] = path22.replace(/^\//u, "").split("?", 1);
   const segments = bare.split("/");
   const is_repo = segments[0] === OWNER_REPO[0];
   return segments.map(
     (segment, index) => is_repo && index < OWNER_REPO.length ? OWNER_REPO[index] : placeholder_of(segment, segments[index - 1])
   ).join("/");
 }
-function of_api(path7, method = DEFAULT_METHOD) {
-  const bare = normalized(path7);
+function of_api(path22, method = DEFAULT_METHOD) {
+  const bare = normalized(path22);
   return bare === GRAPHQL ? GRAPHQL : `${method.toUpperCase()} ${bare}`;
 }
 function path_of(arguments_) {
@@ -1203,109 +2360,3005 @@ function class_of(kind) {
 }
 var gh_call_kind = { of, of_api, class_of };
 
-// scripts/gh/gh-request-tally.ts
-var STATE_KEY = /* @__PURE__ */ Symbol.for("josh.gh-request-tally");
-function is_state(value) {
-  return typeof value === "object" && value !== null && Reflect.has(value, "endpoints");
+// scripts/run/startup/run-startup.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+
+// scripts/josh/stamp-file.ts
+import { createHash } from "node:crypto";
+import { lstatSync, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import path12 from "node:path";
+
+// scripts/josh/platform-temporary.ts
+import { accessSync, constants } from "node:fs";
+import { tmpdir } from "node:os";
+var POSIX_TEMP_ROOT = "/tmp";
+var WINDOWS_PLATFORM = "win32";
+function is_writable_directory(directory) {
+  try {
+    accessSync(directory, constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
 }
-function shared_state() {
-  const existing = Reflect.get(globalThis, STATE_KEY);
-  if (is_state(existing)) return existing;
-  const state = {
-    tally: { calls: 0, not_modified: 0 },
-    endpoints: /* @__PURE__ */ new Map(),
-    core: { read: void 0, start: void 0 }
-  };
-  Reflect.set(globalThis, STATE_KEY, state);
-  return state;
+function resolve_temporary_root(platform2, can_write = is_writable_directory) {
+  if (platform2 === WINDOWS_PLATFORM) return tmpdir();
+  return can_write(POSIX_TEMP_ROOT) ? POSIX_TEMP_ROOT : tmpdir();
 }
-var { tally, endpoints, core } = shared_state();
-function watch_core(read) {
-  core.read = async () => {
-    try {
-      return await read();
-    } catch {
-      return void 0;
-    }
-  };
+var TEMP_ROOT_KEY = "JOSH_TEMP_ROOT";
+function temporary_root(override, platform2) {
+  return override === void 0 || override === "" ? resolve_temporary_root(platform2) : override;
 }
-function endpoint_of(kind) {
-  const count = endpoints.get(kind) ?? { calls: 0, not_modified: 0 };
-  endpoints.set(kind, count);
-  return count;
+var PLATFORM_TEMP_ROOT = temporary_root(process.env[TEMP_ROOT_KEY], process.platform);
+var platform_temporary = {
+  TEMP_ROOT_KEY,
+  resolve_temporary_root,
+  is_writable_directory,
+  temporary_root
+};
+
+// scripts/lib/atomic-write.ts
+import { randomUUID } from "node:crypto";
+import { chmodSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import path11 from "node:path";
+var STAGING_EXTENSION = ".tmp";
+var CREATE_EXCLUSIVE_FLAG = "wx";
+function staging_path(target2, staging_directory) {
+  const name = `${path11.basename(target2)}.${String(process.pid)}.${randomUUID()}${STAGING_EXTENSION}`;
+  return path11.join(staging_directory, name);
+}
+function write_staged(staging, content, mode) {
+  writeFileSync(staging, content, {
+    flag: CREATE_EXCLUSIVE_FLAG,
+    ...mode !== void 0 && { mode }
+  });
+  if (mode !== void 0) chmodSync(staging, mode);
 }
-function snapshot() {
-  const entries = [...endpoints].map(([kind, count]) => [kind, { ...count }]);
-  return { ...tally, endpoints: Object.fromEntries(entries) };
+function replace_file(target2, content, options = {}) {
+  const directory = options.staging_directory ?? path11.dirname(target2);
+  const staging = staging_path(target2, directory);
+  mkdirSync(directory, { recursive: true });
+  try {
+    write_staged(staging, content, options.mode);
+    renameSync(staging, target2);
+  } finally {
+    rmSync(staging, { force: true });
+  }
 }
-function count_call(kind) {
-  if (core.read !== void 0) core.start ??= core.read();
-  tally.calls += 1;
-  endpoint_of(kind).calls += 1;
+var atomic_write = { replace_file };
+
+// scripts/josh/stamp-file.ts
+var HASH_ALGORITHM = "sha256";
+var STAMP_SUFFIX = ".json";
+var STAMP_KEY_LENGTH = 16;
+var STAMP_FILE_MODE = 384;
+var STAMP_WRITE_FLAG = "wx";
+var STAMP_CREATE_FLAG = STAMP_WRITE_FLAG;
+var EXISTS_ERROR_CODE = "EEXIST";
+var ACCOUNT_KEY_SEPARATOR = ":";
+function digest(content) {
+  return createHash(HASH_ALGORITHM).update(content).digest("hex");
+}
+function account_key() {
+  return String(process.getuid?.() ?? "");
+}
+function stamp_name(prefix, root2 = PACKAGE_DIR, suffix = STAMP_SUFFIX) {
+  const key = digest(`${account_key()}${ACCOUNT_KEY_SEPARATOR}${root2}`).slice(0, STAMP_KEY_LENGTH);
+  return `${prefix}${key}${suffix}`;
+}
+function stamp_path(prefix, root2 = PACKAGE_DIR, suffix = STAMP_SUFFIX) {
+  return path12.join(PLATFORM_TEMP_ROOT, stamp_name(prefix, root2, suffix));
+}
+function write_exclusively(target2, content) {
+  rmSync2(target2, { force: true });
+  writeFileSync2(target2, content, { flag: STAMP_WRITE_FLAG, mode: STAMP_FILE_MODE });
+  return target2;
+}
+function write_stamp(target2, payload) {
+  return write_exclusively(target2, JSON.stringify(payload));
+}
+function is_own_regular_file(source) {
+  const stats = lstatSync(source);
+  if (!stats.isFile()) return false;
+  const uid = process.getuid?.();
+  return uid === void 0 || stats.uid === uid;
+}
+function is_foreign_file(target2) {
+  try {
+    return lstatSync(target2).isFile() && !is_own_regular_file(target2);
+  } catch {
+    return false;
+  }
 }
-function count_not_modified(kind) {
-  tally.not_modified += 1;
-  endpoint_of(kind).not_modified += 1;
+function replace_text_stamp(target2, text) {
+  if (is_foreign_file(target2)) {
+    throw new Error(`refusing to replace another account's file: ${target2}`);
+  }
+  atomic_write.replace_file(target2, text, { mode: STAMP_FILE_MODE });
+  return target2;
 }
-function to_delta(start, end) {
-  if (start === void 0 || start.reset_ms !== end?.reset_ms) return void 0;
-  return end.used - start.used;
+function replace_stamp(target2, payload) {
+  return replace_text_stamp(target2, JSON.stringify(payload));
 }
-async function core_delta() {
-  if (core.read === void 0 || core.start === void 0) return void 0;
-  const [start, end] = await Promise.all([core.start, core.read()]);
-  return to_delta(start, end);
+function write_text_stamp(target2, text) {
+  return write_exclusively(target2, text);
 }
-function reset() {
-  tally.calls = 0;
-  tally.not_modified = 0;
-  endpoints.clear();
-  core.read = void 0;
-  core.start = void 0;
+function create_stamp(target2, payload) {
+  try {
+    writeFileSync2(target2, JSON.stringify(payload), {
+      flag: STAMP_CREATE_FLAG,
+      mode: STAMP_FILE_MODE
+    });
+    return true;
+  } catch (error) {
+    if (error.code === EXISTS_ERROR_CODE) return false;
+    throw error;
+  }
 }
-var gh_request_tally = {
-  watch_core,
-  count_call,
-  count_not_modified,
-  snapshot,
-  core_delta,
-  reset
-};
-
-// scripts/gh/git-gh-check.ts
-import { execa } from "execa";
-var GH_NOT_INSTALLED_MSG = "gh CLI is not installed. Install it from https://cli.github.com/";
-var gh_check = {};
-async function run_gh_check() {
+function remove_stamp(target2) {
+  rmSync2(target2, { force: true });
+}
+function read_stamp_text(source) {
   try {
-    await execa("gh", ["--version"], { timeout: COMMAND_TIMEOUT_MS });
+    if (!is_own_regular_file(source)) return void 0;
+    return readFileSync5(source, "utf8");
   } catch {
-    delete gh_check.promise;
-    throw new Error(GH_NOT_INSTALLED_MSG);
+    return void 0;
   }
 }
-async function check_gh_installed() {
-  gh_check.promise ??= run_gh_check();
-  await gh_check.promise;
+var stamp_file = {
+  create_stamp,
+  digest,
+  is_own_regular_file,
+  read_stamp_text,
+  replace_stamp,
+  replace_text_stamp,
+  remove_stamp,
+  stamp_name,
+  stamp_path,
+  write_stamp,
+  write_text_stamp
+};
+
+// scripts/lane/lane-ledger-kind.ts
+var KIND = {
+  STARTUP: "startup",
+  MERGE: "merge",
+  GATE: "gate",
+  LOAD: "load",
+  DISPATCH: "dispatch",
+  STAGE: "stage",
+  STOP: "stop",
+  CHAIN: "chain",
+  OVERLAP: "overlap",
+  HELD: "held",
+  RELEASED: "released",
+  ROUND_ONE: "round-one",
+  ROUND_TWO: "round-two",
+  OFFERABLE: "offerable",
+  OFFER: "offer",
+  CORE_WAIT: "core-wait",
+  CORE_ADMISSION: "core-admission",
+  UNIT_FILES: "unit-files",
+  TEST_RELATED: "test-related",
+  TEST_PINNED: "test-pinned",
+  SPLIT_NOTICE: "split-notice",
+  SPLIT_FILED: "split-filed",
+  UNPLANNED_NOTICE: "unplanned-notice",
+  LANE_STATE: "lane-state",
+  PUSH_MISS: "push-miss",
+  EARLY_PUSH: "early-push",
+  SHIP_LAP: "ship-lap",
+  SIZE: "size",
+  LIMIT: "limit"
+};
+var lane_ledger_kind = { KIND };
+
+// scripts/lib/inherited-scope.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+function storage(key) {
+  const symbol = Symbol.for(key);
+  const existing = Reflect.get(globalThis, symbol);
+  const scope2 = existing instanceof AsyncLocalStorage ? existing : new AsyncLocalStorage();
+  Reflect.set(globalThis, symbol, scope2);
+  return scope2;
+}
+function create(key, schema) {
+  const scope2 = storage(key);
+  function local() {
+    return schema.safeParse(scope2.getStore()).data;
+  }
+  function current() {
+    return local() ?? json_value.parse_with(process.env[key] ?? "", schema);
+  }
+  async function within(value, run3) {
+    return await scope2.run(value, run3);
+  }
+  function environment() {
+    const value = current();
+    return value === void 0 ? {} : { [key]: JSON.stringify(value) };
+  }
+  return { current, local, within, environment };
 }
+var inherited_scope = { create };
 
-// scripts/git/parse-json-array.ts
-function parse_json_loose(raw_json) {
-  return json_value.parse_or_undefined(raw_json);
+// scripts/run/startup/run-startup-schema.ts
+import { z as z6 } from "zod";
+var scope_schema = z6.object({
+  run: z6.string(),
+  attempt: z6.string(),
+  issue: z6.string().optional(),
+  span: z6.string().optional(),
+  parent: z6.string().optional(),
+  destination: z6.string().optional()
+});
+var entry_schema = scope_schema.omit({ destination: true }).extend({
+  kind: z6.literal(lane_ledger_kind.KIND.STARTUP),
+  at: z6.string(),
+  at_ms: z6.number().nonnegative().optional(),
+  id: z6.string(),
+  parent: z6.string().optional(),
+  phase: z6.string(),
+  edge: z6.enum(["start", "done", "failed", "waiting", "api", "cache"]),
+  elapsed_ms: z6.number().nonnegative().optional(),
+  metric: z6.string().optional(),
+  key: z6.string().optional()
+});
+var run_startup_schema = { scope_schema, entry_schema };
+
+// scripts/run/startup/run-startup-store.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+
+// scripts/lane/lane-ledger-write.ts
+import { closeSync, constants as constants3, openSync, writeSync } from "node:fs";
+
+// scripts/josh/durable-state.ts
+import { mkdirSync as mkdirSync2 } from "node:fs";
+import path16 from "node:path";
+
+// scripts/git/git-common-directory.ts
+import { execFileSync } from "node:child_process";
+
+// scripts/josh/durable-state-root.ts
+import path13 from "node:path";
+var STATE_DIRECTORY = "josh";
+var RUN_STATE_DIRECTORY = "run-state";
+var OVERRIDE_STATE_DIRECTORY = "josh-state";
+function state_root(override, read_common) {
+  if (override !== void 0 && override !== "") {
+    return path13.join(override, OVERRIDE_STATE_DIRECTORY);
+  }
+  const common = read_common();
+  if (common === void 0) return PLATFORM_TEMP_ROOT;
+  return path13.join(common, STATE_DIRECTORY, RUN_STATE_DIRECTORY);
+}
+var STATE_ROOT_OVERRIDE = process.env[platform_temporary.TEMP_ROOT_KEY];
+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-",
+  HANDOFF_LOG: "josh-run-handoff-log-",
+  SHIP_LOG: "josh-ship-log-",
+  SHIP_RESULT: "josh-ship-result-",
+  LANE_DISPATCH: "josh-lane-dispatch-",
+  LANE_PLAN: "josh-lane-plan-",
+  INVESTIGATION: "josh-investigation-record-",
+  GH_USAGE: "josh-gh-usage-"
+};
+var durable_state_root = {
+  PREFIX,
+  STATE_DIRECTORY,
+  STATE_ROOT_OVERRIDE,
+  state_root
+};
+
+// 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-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);
+  }
 }
-function parse_json_object_or_undefined(raw_json, schema) {
-  const value = parse_json_loose(raw_json);
-  if (value === void 0) return void 0;
-  return schema.parse(value);
+async function to_environment() {
+  const should_keep_alive = !await has_configured_ssh_command();
+  return should_keep_alive ? { [SSH_COMMAND_VARIABLE]: KEEPALIVE_SSH_COMMAND } : {};
 }
-var parse_json = {
-  parse_json_object_or_undefined
+var git_ssh_keepalive = {
+  to_environment
 };
 
-// scripts/gh/git-gh-failure.ts
-import { z as z4 } from "zod";
-var error_document_schema = z4.object({ status: z4.union([z4.string(), z4.number()]).optional() }).catch({});
-var GH_FAILURE_FIELD = "gh_failure";
+// 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 read2(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: read2,
+  read_remote,
+  with_output,
+  with_output_remote
+};
+
+// 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 trimmed2 = output?.trim() ?? "";
+  if (!trimmed2.startsWith(REFS_REMOTES_ORIGIN_PREFIX)) return DEFAULT_BRANCH_FALLBACK;
+  return trimmed2.slice(REFS_REMOTES_ORIGIN_PREFIX.length);
+}
+async function get_default_branch() {
+  try {
+    return default_branch_of(await git_spawn.read([...DEFAULT_BRANCH_ARGUMENTS]));
+  } catch {
+    return DEFAULT_BRANCH_FALLBACK;
+  }
+}
+var MERGE_BASE_COMMAND = "merge-base";
+function reference_check_arguments(reference) {
+  return ["rev-parse", "--verify", "--quiet", reference];
+}
+function remote_reference_of(default_branch) {
+  return `${REFS_REMOTES_ORIGIN_PREFIX}${default_branch}`;
+}
+async function reference_exists(reference) {
+  try {
+    await git_spawn.read([...reference_check_arguments(reference)]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function default_branch_reference() {
+  const default_branch = await get_default_branch();
+  const remote_reference = remote_reference_of(default_branch);
+  return await reference_exists(remote_reference) ? remote_reference : default_branch;
+}
+function merge_base_arguments(reference) {
+  return [MERGE_BASE_COMMAND, reference, "HEAD"];
+}
+function incoming_base_arguments(reference) {
+  return [MERGE_BASE_COMMAND, reference, "MERGE_HEAD"];
+}
+function later_base_arguments(base, incoming) {
+  return [MERGE_BASE_COMMAND, "--independent", base, incoming];
+}
+function later_base_of(output, base) {
+  const [later = ""] = output?.split("\n", 1) ?? [];
+  return later === "" ? base : later;
+}
+async function change_base() {
+  const default_branch = await default_branch_reference();
+  try {
+    return await git_spawn.read([...merge_base_arguments(default_branch)]);
+  } catch {
+    return default_branch;
+  }
+}
+async function diff_main(file_path2) {
+  return await git_spawn.read(["diff", await change_base(), "--", file_path2]);
+}
+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()]);
+}
+function names_since_arguments(commit2) {
+  return [
+    ...NO_PATH_QUOTING,
+    "diff",
+    NAME_ONLY_FLAG,
+    NO_RELATIVE_PATHS,
+    NO_RENAME_DETECTION,
+    commit2,
+    "--"
+  ];
+}
+async function diff_names_since(commit2) {
+  return await git_spawn.read([...names_since_arguments(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_numstat_since(base) {
+  return await git_spawn.read([
+    ...NO_PATH_QUOTING,
+    "diff",
+    "--numstat",
+    NO_RELATIVE_PATHS,
+    NO_RENAME_DETECTION,
+    base,
+    "--"
+  ]);
+}
+var WHOLE_TREE_PATHSPEC = ":/";
+var UNTRACKED_ARGUMENTS = [
+  ...NO_PATH_QUOTING,
+  "ls-files",
+  "--others",
+  "--exclude-standard",
+  "--full-name",
+  WHOLE_TREE_PATHSPEC
+];
+async function untracked_names() {
+  return await git_spawn.read([...UNTRACKED_ARGUMENTS]);
+}
+var git_diff_reads = {
+  DEFAULT_BRANCH_ARGUMENTS,
+  UNTRACKED_ARGUMENTS,
+  change_base,
+  change_base_commit,
+  default_branch_of,
+  default_branch_reference,
+  diff_cached_names,
+  diff_main,
+  diff_main_names,
+  diff_numstat_since,
+  diff_names_since,
+  get_default_branch,
+  incoming_base_arguments,
+  later_base_arguments,
+  later_base_of,
+  merge_base_arguments,
+  names_since_arguments,
+  reference_check_arguments,
+  remote_reference_of,
+  tree_names_at,
+  untracked_names
+};
+
+// scripts/git/git-pre-push-hook.ts
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import path14 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;
+  }
+}
+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 reference = `refs/heads/${references.branch}`;
+  const remote_oid = references.remote_oid ?? ZERO_DIGIT.repeat(references.local_oid.length);
+  return `${reference} ${references.local_oid} ${reference} ${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) {
+  try {
+    await git_spawn.read(["hook", ...probe_arguments]);
+    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]);
+}
+async function run_with_stdin(stdin_line) {
+  const directory = await mkdtemp(path14.join(tmpdir2(), TEMPORARY_PREFIX));
+  const stdin_path = path14.join(directory, STDIN_FILE);
+  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 });
+  }
+}
+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 read3(args, options = {}) {
+  const result = run2(args, options);
+  return result.exit_code === SUCCESS_EXIT_CODE ? result.stdout.trim() : void 0;
+}
+function located(cwd) {
+  if (cwd === void 0) return {};
+  return { cwd, env: git_location_environment.location_free_environment() };
+}
+function origin_url(cwd) {
+  return read3(["config", "--get", "remote.origin.url"], located(cwd));
+}
+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: read3, located, origin_url, toplevel };
+
+// scripts/git/git-command.ts
+var BRANCH_ARGUMENTS = ["rev-parse", "--abbrev-ref", "HEAD"];
+async function branch() {
+  return await git_spawn.read([...BRANCH_ARGUMENTS]);
+}
+async function branch_at(directory) {
+  return await git_spawn.read(["-C", directory, ...BRANCH_ARGUMENTS]);
+}
+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_path2) {
+  return await git_spawn.read(["diff", "--cached", file_path2]);
+}
+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;
+    }
+    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) {
+  try {
+    const output = await git_spawn.read([
+      "branch",
+      "--list",
+      SHORT_NAME_FORMAT,
+      ...flags,
+      pattern
+    ]);
+    return output.split("\n").filter((line) => line.trim() !== "");
+  } 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_path2) {
+  return `:(exclude,top)${file_path2}`;
+}
+async function add_tracked(excluded_paths) {
+  const exclusions = excluded_paths.map((file_path2) => exclude_pathspec(file_path2));
+  await git_spawn.read(["add", "-u", "--", ALL_PATHS_PATHSPEC, ...exclusions]);
+}
+async function add_path(file_path2) {
+  await git_spawn.with_output("add", ["--", file_path2]);
+}
+var FIRST_PARENT_FLAG = "--first-parent";
+async function log_first_parent(limit, file_path2, tip = "HEAD") {
+  const output = await git_spawn.read([
+    "log",
+    FIRST_PARENT_FLAG,
+    "--format=%H",
+    `-n`,
+    String(limit),
+    tip,
+    "--",
+    file_path2
+  ]);
+  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,
+  branch_at,
+  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
+};
+
+// scripts/git/git-common-directory.ts
+var { STATE_DIRECTORY: STATE_DIRECTORY2 } = durable_state_root;
+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 = execFileSync(
+      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 read4 = read_directories(cwd);
+  if (read4.length > 0) answers.set(key, read4);
+  return read4;
+}
+function own(cwd) {
+  return directories(cwd)[OWN_GIT_DIRECTORY];
+}
+function repository(cwd) {
+  return directories(cwd)[COMMON_GIT_DIRECTORY];
+}
+async function read_repository() {
+  try {
+    const found = await git_command.git_directories();
+    return found[COMMON_GIT_DIRECTORY];
+  } catch {
+    return void 0;
+  }
+}
+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 = {
+  STATE_DIRECTORY: STATE_DIRECTORY2,
+  directories,
+  own,
+  read_repository,
+  repository,
+  resolve,
+  select_linked
+};
+
+// scripts/josh/durable-state-migrate.ts
+import { constants as constants2, copyFileSync, lstatSync as lstatSync2, readdirSync, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import path15 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 NOTE_SUFFIX = ".md";
+var RECORD_SUFFIXES = [".json", ".jsonl", LOG_SUFFIX, NOTE_SUFFIX];
+var PRUNED_SUFFIXES = [LOG_SUFFIX, NOTE_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 readdirSync(directory);
+  } catch {
+    return [];
+  }
+}
+function copy_record(from, to) {
+  try {
+    if (!stamp_file.is_own_regular_file(from)) return;
+    copyFileSync(from, to, constants2.COPYFILE_EXCL);
+  } catch {
+  }
+}
+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(path15.join(from, name), path15.join(to, name));
+  }
+}
+function claim_copy(directory) {
+  try {
+    writeFileSync3(path15.join(directory, COPIED_MARKER), "", { flag: "wx", mode: MARKER_MODE });
+    return true;
+  } catch {
+    return false;
+  }
+}
+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 - lstatSync2(target2).mtimeMs;
+  return age_ms > LOG_RETENTION_DAYS * DAY_MS && stamp_file.is_own_regular_file(target2);
+}
+function prune_log(target2, now_ms) {
+  try {
+    if (is_stale(target2, now_ms)) rmSync3(target2, { force: true });
+  } catch {
+  }
+}
+function prune_stale_logs(directory, prefixes, now_ms) {
+  for (const name of list_names(directory)) {
+    const is_pruned = PRUNED_SUFFIXES.some((suffix) => name.endsWith(suffix));
+    if (is_pruned && is_record_name(name, prefixes)) {
+      prune_log(path15.join(directory, name), now_ms);
+    }
+  }
+}
+var durable_state_migrate = { LOG_RETENTION_DAYS, copy_once, is_record_name, prune_stale_logs };
+
+// scripts/josh/durable-state.ts
+var STATE_DIRECTORY_MODE = 448;
+var { PREFIX: PREFIX2, STATE_ROOT_OVERRIDE: STATE_ROOT_OVERRIDE2, state_root: state_root2 } = durable_state_root;
+function root() {
+  return state_root2(STATE_ROOT_OVERRIDE2, git_common_directory.repository);
+}
+var PREFIXES = Object.values(PREFIX2);
+var ensured = /* @__PURE__ */ new Set();
+function prepare(directory) {
+  mkdirSync2(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 {
+    prepare(directory);
+  } catch {
+    return PLATFORM_TEMP_ROOT;
+  }
+  ensured.add(directory);
+  return directory;
+}
+function durable_path(prefix, key_root, suffix) {
+  return path16.join(ensure(root()), stamp_file.stamp_name(prefix, key_root, suffix));
+}
+var durable_state = {
+  PREFIX: PREFIX2,
+  ensure,
+  path: durable_path,
+  root,
+  state_root: state_root2
+};
+
+// scripts/agent/agent-provider.ts
+import { z as z7 } from "zod";
+var EMPTY_LENGTH = 0;
+var PROVIDER_SCHEMA = z7.enum(["anthropic", "openai"]);
+var ANTHROPIC_PROVIDER = "anthropic";
+var OPENAI_PROVIDER = "openai";
+var CODEX_SESSION_KEY = "CODEX_THREAD_ID";
+function trimmed(value) {
+  const result = value?.trim();
+  return result === void 0 || result.length === EMPTY_LENGTH ? void 0 : result;
+}
+function rejection(key, value, expected) {
+  return { kind: "rejected", note: `${key}=${value} ${expected}, so the agent was not started` };
+}
+function has_session(environment, keys) {
+  return keys.some((key) => trimmed(environment[key]) !== void 0);
+}
+var CONFLICTING_SESSIONS = {
+  kind: "rejected",
+  note: "both Codex and Claude Code sessions were detected"
+};
+var HANDED_PROVIDER_KEY = "JOSH_AGENT_PROVIDER";
+var DEFAULT_PROVIDER = {
+  kind: "provider",
+  provider: ANTHROPIC_PROVIDER,
+  is_default: true
+};
+var DEFAULT_NOTICE = ` No agent session or ${HANDED_PROVIDER_KEY} was found, so the provider defaulted to ${ANTHROPIC_PROVIDER} (Claude Code).`;
+function handed_provider(environment) {
+  const value = trimmed(environment[HANDED_PROVIDER_KEY]);
+  if (value === void 0) return DEFAULT_PROVIDER;
+  const parsed = PROVIDER_SCHEMA.safeParse(value);
+  return parsed.success ? { kind: "provider", provider: parsed.data } : rejection(HANDED_PROVIDER_KEY, value, "is not an allowed provider");
+}
+function detected_provider(environment) {
+  const has_codex = has_session(environment, [CODEX_SESSION_KEY]);
+  const has_claude = has_session(environment, agent_session_environment.PARENT_SESSION_KEYS);
+  if (has_codex === has_claude) return has_codex ? CONFLICTING_SESSIONS : void 0;
+  return { kind: "provider", provider: has_codex ? OPENAI_PROVIDER : ANTHROPIC_PROVIDER };
+}
+function resolve_provider(environment = process.env) {
+  return detected_provider(environment) ?? handed_provider(environment);
+}
+function default_notice(environment = process.env) {
+  const selected = resolve_provider(environment);
+  return selected.kind === "provider" && selected.is_default === true ? DEFAULT_NOTICE : "";
+}
+function warn_of_default(environment = process.env) {
+  const notice = default_notice(environment).trim();
+  if (notice !== "") console.error(notice);
+}
+function has_completion_callback(environment = process.env) {
+  const selected = resolve_provider(environment);
+  return selected.kind !== "provider" || selected.provider !== OPENAI_PROVIDER;
+}
+function handoff_environment(environment = process.env) {
+  const selected = resolve_provider(environment);
+  return selected.kind === "provider" ? { [HANDED_PROVIDER_KEY]: selected.provider } : {};
+}
+var agent_provider = {
+  ANTHROPIC_PROVIDER,
+  CODEX_SESSION_KEY,
+  HANDED_PROVIDER_KEY,
+  OPENAI_PROVIDER,
+  PROVIDER_SCHEMA,
+  default_notice,
+  handoff_environment,
+  has_completion_callback,
+  rejection,
+  resolve_provider,
+  trimmed,
+  warn_of_default
+};
+
+// scripts/josh/process-identity.ts
+import { execFileSync as execFileSync2, spawnSync } from "node:child_process";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { readFileSync as readFileSync6, rmSync as rmSync4 } from "node:fs";
+import { createServer } from "node:net";
+import path17 from "node:path";
+var PS_COMMAND = "/bin/ps";
+var FORMAT_FLAG = "-o";
+var START_TIME_FORMAT = "lstart=";
+var PID_FLAG = "-p";
+var PROBE_ENVIRONMENT = { TZ: "UTC", LC_ALL: "C" };
+var LIVENESS_SIGNAL = 0;
+var NO_SUCH_PROCESS = "ESRCH";
+var LOWEST_REAL_PID = 1;
+var PROC_START_FIELD_INDEX = 19;
+var BEACON_SCHEME = "socket:";
+var BEACON_SUFFIX = ".sock";
+var BEACON_PREFIX = `josh-process-identity-${String(process.getuid?.() ?? "")}-`;
+var BEACON_ID_LENGTH = 36;
+var BEACON_ID_PATTERN = /^[\da-f-]+$/u;
+var WINDOWS_PLATFORM2 = "win32";
+var BEACON_LIVE_STATUS = 0;
+var BEACON_UNKNOWN_STATUS = 1;
+var BEACON_GONE_STATUS = 2;
+var SOCKET_PROBE_SOURCE = `const net=require('node:net');const socket=net.createConnection(process.argv[1]);socket.once('connect',()=>process.exit(${String(BEACON_LIVE_STATUS)}));socket.once('error',(error)=>process.exit(['ECONNREFUSED','ENOENT'].includes(error.code)?${String(BEACON_GONE_STATUS)}:${String(BEACON_UNKNOWN_STATUS)}));socket.setTimeout(1000,()=>process.exit(${String(BEACON_UNKNOWN_STATUS)}));`;
+var beacons = /* @__PURE__ */ new Map();
+var exit_cleanup = { is_registered: false };
+function signal_refusal(pid) {
+  try {
+    process.kill(pid, LIVENESS_SIGNAL);
+    return void 0;
+  } catch (error) {
+    return error.code ?? NO_SUCH_PROCESS;
+  }
+}
+function is_live_pid(pid) {
+  return pid >= LOWEST_REAL_PID && signal_refusal(pid) === void 0;
+}
+function is_present_pid(pid) {
+  return pid >= LOWEST_REAL_PID && signal_refusal(pid) !== NO_SUCH_PROCESS;
+}
+function read_proc_start(pid) {
+  try {
+    const stat = readFileSync6(`/proc/${String(pid)}/stat`, "utf8");
+    const fields = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/u);
+    const start = fields[PROC_START_FIELD_INDEX];
+    return start === void 0 ? void 0 : `proc:${start}`;
+  } catch {
+    return void 0;
+  }
+}
+function read_ps_start(pid) {
+  try {
+    const printed = execFileSync2(
+      PS_COMMAND,
+      [FORMAT_FLAG, START_TIME_FORMAT, PID_FLAG, String(pid)],
+      {
+        encoding: "utf8",
+        timeout: PROBE_TIMEOUT_MS,
+        stdio: ["ignore", "pipe", "ignore"],
+        env: PROBE_ENVIRONMENT
+      }
+    ).trim();
+    return printed.length > 0 ? printed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var START_PROBES = { read_proc_start, read_ps_start };
+function safe_probe(probe, pid) {
+  try {
+    return probe(pid);
+  } catch {
+    return void 0;
+  }
+}
+function read_start(pid, probes = START_PROBES) {
+  return safe_probe(probes.read_proc_start, pid) ?? safe_probe(probes.read_ps_start, pid);
+}
+function close_beacon(token) {
+  const server = beacons.get(token);
+  if (server === void 0) return;
+  beacons.delete(token);
+  server.close();
+  rmSync4(token.slice(BEACON_SCHEME.length), { force: true });
+}
+function close_beacons() {
+  for (const token of beacons.keys()) close_beacon(token);
+}
+function ensure_exit_cleanup() {
+  if (exit_cleanup.is_registered) return;
+  exit_cleanup.is_registered = true;
+  process.once("exit", close_beacons);
+}
+function ignore_beacon_error() {
+}
+function bind_beacon(target2) {
+  return createServer().on("error", ignore_beacon_error).listen(target2);
+}
+function try_bind_beacon(bind, target2) {
+  try {
+    const server = bind(target2);
+    return server.listening ? server : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function open_beacon(bind = bind_beacon) {
+  const target2 = path17.join(PLATFORM_TEMP_ROOT, `${BEACON_PREFIX}${randomUUID2()}${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) {
+  const start = read_start(process.pid, probes);
+  if (start !== void 0 || platform2 === WINDOWS_PLATFORM2) return start;
+  return open_beacon();
+}
+function is_valid_beacon_name(name) {
+  if (!name.startsWith(BEACON_PREFIX) || !name.endsWith(BEACON_SUFFIX)) return false;
+  const id = name.slice(BEACON_PREFIX.length, -BEACON_SUFFIX.length);
+  return id.length === BEACON_ID_LENGTH && BEACON_ID_PATTERN.test(id);
+}
+function beacon_target(token) {
+  if (!token.startsWith(BEACON_SCHEME)) return void 0;
+  const target2 = token.slice(BEACON_SCHEME.length);
+  if (path17.dirname(target2) !== PLATFORM_TEMP_ROOT) return void 0;
+  return is_valid_beacon_name(path17.basename(target2)) ? target2 : void 0;
+}
+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(target2, probe = run_socket_probe) {
+  const own3 = beacons.get(`${BEACON_SCHEME}${target2}`);
+  if (own3 !== void 0) return own3.listening;
+  const status2 = probe(target2);
+  if (status2 === BEACON_LIVE_STATUS) return true;
+  return status2 === BEACON_GONE_STATUS ? false : void 0;
+}
+function has_matching_start(pid, recorded_start, read4) {
+  const observed = read4(pid);
+  return observed === void 0 ? void 0 : observed === recorded_start;
+}
+function matches_recorded_start(pid, recorded_start, read4) {
+  const target2 = beacon_target(recorded_start);
+  return target2 === void 0 ? has_matching_start(pid, recorded_start, read4) : is_live_beacon(target2);
+}
+var own_probe = /* @__PURE__ */ new Map();
+function own_start() {
+  if (!own_probe.has(process.pid)) own_probe.set(process.pid, resolve_own_start());
+  return own_probe.get(process.pid);
+}
+function own_fields() {
+  const start = own_start();
+  return { pid: process.pid, ...start !== void 0 && { process_start: start } };
+}
+function is_same_process(pid, recorded_start, read4 = 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, read4);
+}
+function is_present_process(pid, recorded_start, read4 = read_start) {
+  if (!is_present_pid(pid)) return false;
+  if (recorded_start === void 0) return void 0;
+  return matches_recorded_start(pid, recorded_start, read4);
+}
+function is_own_process(pid, recorded_start) {
+  return pid === process.pid && recorded_start === own_start();
+}
+var process_identity = {
+  PROBE_ENVIRONMENT,
+  START_PROBES,
+  START_TIME_FORMAT,
+  close_beacon,
+  is_live_beacon,
+  is_live_pid,
+  is_own_process,
+  is_present_pid,
+  is_present_process,
+  is_same_process,
+  open_beacon,
+  own_fields,
+  own_start,
+  read_start,
+  resolve_own_start,
+  run_socket_probe
+};
+
+// scripts/issue/issue-number-shape.ts
+var ISSUE_NUMBER_PATTERN = /^[1-9]\d*$/u;
+var BAD_ISSUE_MESSAGE = "Not an issue number: ";
+var ISSUE_PREFIX = "#";
+function is_issue_number(value) {
+  return ISSUE_NUMBER_PATTERN.test(value);
+}
+function require_issue_number(issue) {
+  if (!is_issue_number(issue)) throw new Error(`${BAD_ISSUE_MESSAGE}${issue}`);
+}
+function single_of(positionals) {
+  const [issue_number, ...rest] = positionals;
+  const is_single = rest.length === 0 && issue_number !== void 0;
+  return is_single && ISSUE_NUMBER_PATTERN.test(issue_number) ? issue_number : void 0;
+}
+function issue_token(token) {
+  return ISSUE_NUMBER_PATTERN.test(token) ? `${ISSUE_PREFIX}${token}` : token;
+}
+var issue_number_shape = {
+  ISSUE_NUMBER_PATTERN,
+  is_issue_number,
+  issue_token,
+  require_issue_number,
+  single_of
+};
+
+// scripts/lib/cli-flags.ts
+import { parseArgs } from "node:util";
+var HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
+function usage_line(known_flags, command) {
+  if (known_flags.length === 0) return `Usage: josh ${command}`;
+  return `Usage: josh ${command} [${known_flags.join("] [")}]`;
+}
+function refuse_unknown_flags(argv, known_flags, command) {
+  const unknown = argv.filter((argument) => !known_flags.includes(argument));
+  if (unknown.length === 0) return void 0;
+  return `Unknown argument(s): ${unknown.join(" ")}
+${usage_line(known_flags, command)}`;
+}
+function answer_help_or_unknown(argv, known_flags, command) {
+  if (argv.some((argument) => HELP_FLAGS.has(argument))) {
+    console.info(usage_line(known_flags, command));
+    return 0;
+  }
+  const refusal = refuse_unknown_flags(argv, known_flags, command);
+  if (refusal === void 0) return void 0;
+  console.error(refusal);
+  return 1;
+}
+function parse_or_undefined2(config) {
+  try {
+    return parseArgs(config);
+  } catch {
+    return void 0;
+  }
+}
+function values_of(argv, options) {
+  return parse_or_undefined2({ args: [...argv], options })?.values;
+}
+function arguments_of2(argv, options) {
+  return parse_or_undefined2({ args: [...argv], options, allowPositionals: true });
+}
+function string_of(value) {
+  return typeof value === "string" ? value : void 0;
+}
+var LONG_FLAG_PREFIX = "--";
+var SHORT_FLAG_PREFIX = "-";
+function option_name(flag) {
+  return flag.slice(LONG_FLAG_PREFIX.length);
+}
+function is_unusable_value(value) {
+  if (typeof value === "boolean" || value.length === 0) return true;
+  return value !== SHORT_FLAG_PREFIX && value.startsWith(SHORT_FLAG_PREFIX);
+}
+function given_values(argv, flag) {
+  const name = option_name(flag);
+  const given = parse_or_undefined2({
+    args: [...argv],
+    options: { [name]: { type: "string", multiple: true } },
+    strict: false,
+    allowPositionals: true
+  })?.values[name];
+  return Array.isArray(given) ? given : [];
+}
+function is_value_unusable(argv, flag) {
+  return given_values(argv, flag).some((value) => is_unusable_value(value));
+}
+function attach_one(attached, argument, flags) {
+  const previous = attached.at(-1);
+  if (previous !== void 0 && flags.includes(previous)) {
+    attached[attached.length - 1] = `${previous}=${argument}`;
+  } else attached.push(argument);
+}
+function attach_values(argv, flags) {
+  const attached = [];
+  for (const argument of argv) attach_one(attached, argument, flags);
+  return attached;
+}
+var COUNT_PATTERN = /^\d+$/u;
+var POSITIVE_PATTERN = /^[1-9]\d*$/u;
+function to_integer(raw, pattern) {
+  if (raw === void 0 || !pattern.test(raw)) return void 0;
+  const parsed = Number(raw);
+  return Number.isSafeInteger(parsed) ? parsed : void 0;
+}
+function to_count(raw) {
+  return to_integer(raw, COUNT_PATTERN);
+}
+function to_positive(raw) {
+  return to_integer(raw, POSITIVE_PATTERN);
+}
+function read_positive_setting(raw, name, fallback) {
+  const trimmed2 = raw?.trim() ?? "";
+  if (trimmed2 === "") return { kind: "limit", limit: fallback };
+  const limit = to_positive(trimmed2);
+  if (limit !== void 0) return { kind: "limit", limit };
+  return { kind: "problem", problem: `${name} must be a positive integer, not "${trimmed2}"` };
+}
+var cli_flags = {
+  to_count,
+  to_positive,
+  read_positive_setting,
+  attach_values,
+  usage_line,
+  refuse_unknown_flags,
+  answer_help_or_unknown,
+  parse_or_undefined: parse_or_undefined2,
+  values_of,
+  arguments_of: arguments_of2,
+  string_of,
+  option_name,
+  given_values,
+  is_value_unusable
+};
+
+// scripts/run/run-invocation.ts
+var BACKLOG_COMMAND = "backlogrun";
+var KNOWN_FLAGS = ["--max", "--idle"];
+var ONLY_FLAG = "--only";
+var OPTIONS = {
+  max: { type: "string" },
+  idle: { type: "string" },
+  only: { type: "boolean" }
+};
+var ISSUE_PREFIX2 = "#";
+var FLAG_PREFIX3 = "-";
+var TOKEN_SEPARATOR = " ";
+var FIRST_TOKEN = 0;
+var FIRST_ARGUMENT_INDEX = 1;
+var EMPTY_LENGTH2 = 0;
+var NOT_FOUND = -1;
+function tokens_of(invocation) {
+  return invocation.split(TOKEN_SEPARATOR).filter((token) => token.length > EMPTY_LENGTH2);
+}
+function render_option(token) {
+  if (token.name === cli_flags.option_name(ONLY_FLAG)) return ONLY_FLAG;
+  const flag = KNOWN_FLAGS.find((known) => cli_flags.option_name(known) === token.name);
+  const value = cli_flags.to_count(token.value);
+  if (flag === void 0 || value === void 0) return void 0;
+  return `${flag} ${String(value)}`;
+}
+function rendered_options(tokens) {
+  const rendered = [];
+  for (const token of tokens) {
+    const part = render_option(token);
+    if (part === void 0) return void 0;
+    rendered.push(part);
+  }
+  return rendered;
+}
+function issue_of(token) {
+  if (!token.startsWith(ISSUE_PREFIX2)) return void 0;
+  const digits = token.slice(ISSUE_PREFIX2.length);
+  if (!issue_number_shape.ISSUE_NUMBER_PATTERN.test(digits)) return void 0;
+  const issue = Number(digits);
+  return Number.isSafeInteger(issue) ? issue : void 0;
+}
+function issues_of(tokens) {
+  const issues = [];
+  for (const token of tokens) {
+    const issue = issue_of(token.value ?? "");
+    if (issue === void 0) return void 0;
+    issues.push(issue);
+  }
+  return issues;
+}
+function argument_tokens(invocation) {
+  const tokens = tokens_of(invocation);
+  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return void 0;
+  return cli_flags.parse_or_undefined({
+    args: tokens.slice(FIRST_ARGUMENT_INDEX),
+    options: OPTIONS,
+    allowPositionals: true,
+    tokens: true
+  })?.tokens;
+}
+function parse2(invocation) {
+  const tokens = argument_tokens(invocation);
+  if (tokens === void 0) return void 0;
+  const stop = tokens.findIndex((token) => token.kind !== "positional");
+  const split_at = stop === NOT_FOUND ? tokens.length : stop;
+  const issues = issues_of(tokens.slice(FIRST_TOKEN, split_at));
+  const flags = rendered_options(tokens.slice(split_at));
+  if (issues === void 0 || flags === void 0) return void 0;
+  return { issues, flags };
+}
+function issue_token2(issue) {
+  return `${ISSUE_PREFIX2}${String(issue)}`;
+}
+function joined(command, rendered) {
+  return [command, ...rendered].join(TOKEN_SEPARATOR);
+}
+function rebuild(invocation) {
+  const parsed = parse2(invocation);
+  if (parsed === void 0) return void 0;
+  return joined(BACKLOG_COMMAND, [
+    ...parsed.issues.map((issue) => issue_token2(issue)),
+    ...parsed.flags
+  ]);
+}
+function issue_numbers(invocation) {
+  const tokens = tokens_of(invocation);
+  const stop = tokens.findIndex((token) => token.startsWith(FLAG_PREFIX3));
+  const leading = stop === NOT_FOUND ? tokens : tokens.slice(FIRST_TOKEN, stop);
+  const issues = parse2(leading.join(TOKEN_SEPARATOR))?.issues;
+  if (issues === void 0 || issues.length === EMPTY_LENGTH2) return void 0;
+  return issues;
+}
+function has_only(invocation) {
+  return parse2(invocation)?.flags.includes(ONLY_FLAG) === true;
+}
+var run_invocation = {
+  has_only,
+  issue_numbers,
+  rebuild
+};
+
+// scripts/run/carry/run-carry.ts
+import { z as z9 } from "zod";
+
+// scripts/run/carry/run-carry-added.ts
+function issues_of2(added, is_priority) {
+  return added.filter((entry2) => entry2.is_priority === is_priority).map((entry2) => entry2.issue);
+}
+function ordered(declared, added = []) {
+  const sequence = [...issues_of2(added, true), ...declared, ...issues_of2(added, false)];
+  return sequence.filter((issue, index) => sequence.indexOf(issue) === index);
+}
+function next_added(carry, additions) {
+  const next = [...carry.added ?? []];
+  for (const addition of additions) {
+    if (next.every((entry2) => entry2.issue !== addition.issue)) next.push(addition);
+  }
+  return next;
+}
+function add_issues(target2, carry, additions, retries = []) {
+  const next = {
+    ...carry,
+    added: additions.length === 0 ? carry.added : next_added(carry, additions),
+    done: carry.done?.filter((issue) => !retries.includes(issue))
+  };
+  stamp_file.replace_stamp(target2, next);
+  return next;
+}
+var run_carry_added = { add_issues, ordered };
+
+// scripts/run/carry/run-carry-streak.ts
+var NO_INCREMENT = 0;
+var OUTAGE_FOLD_WINDOW_MS = 12e4;
+function has_increment(value) {
+  return (value ?? NO_INCREMENT) > NO_INCREMENT;
+}
+function next_failures(carry, change) {
+  if (has_increment(change.merged)) return NO_INCREMENT;
+  return carry.failures + (change.failures ?? NO_INCREMENT);
+}
+function is_within_fold_window(last_outage_at, now) {
+  if (last_outage_at === void 0) return false;
+  const last = Date.parse(last_outage_at);
+  if (Number.isNaN(last)) return false;
+  return now.getTime() - last <= OUTAGE_FOLD_WINDOW_MS;
+}
+function folded_outage(carry) {
+  return { outages: carry.outages, last_outage_at: carry.last_outage_at };
+}
+function counted_outage(carry, change, now) {
+  const outages = carry.outages + (change.outages ?? NO_INCREMENT);
+  return { outages, last_outage_at: now.toISOString() };
+}
+function next_outage(carry, change, now) {
+  if (has_increment(change.outages)) {
+    return is_within_fold_window(carry.last_outage_at, now) ? folded_outage(carry) : counted_outage(carry, change, now);
+  }
+  const is_reachable = has_increment(change.merged) || has_increment(change.failures);
+  return is_reachable ? { outages: NO_INCREMENT, last_outage_at: void 0 } : folded_outage(carry);
+}
+function next_state(carry, change, now) {
+  const outage = next_outage(carry, change, now);
+  return {
+    failures: next_failures(carry, change),
+    outages: outage.outages,
+    last_outage_at: outage.last_outage_at
+  };
+}
+var run_carry_streak = { next_state };
+
+// scripts/run/carry/run-carry-change.ts
+var NO_INCREMENT2 = 0;
+function next_done(carry, done) {
+  if (done === void 0) return carry.done;
+  const current = carry.done ?? [];
+  return current.includes(done) ? current : [...current, done];
+}
+function next_merged_issues(carry, issue) {
+  if (issue === void 0) return carry.merged_issues;
+  const current = carry.merged_issues ?? [];
+  return current.includes(issue) ? current : [...current, issue];
+}
+function is_duplicate_merge(carry, change) {
+  const issue = change.merged_issue;
+  return issue !== void 0 && carry.merged_issues?.includes(issue) === true;
+}
+function has_other_change(change) {
+  const amounts = [change.filed, change.cuts, change.failures, change.outages];
+  const has_amount = amounts.some((amount) => (amount ?? NO_INCREMENT2) > NO_INCREMENT2);
+  return has_amount || change.done !== void 0 || change.retrospective === true;
+}
+function effective_change(carry, change) {
+  if (!is_duplicate_merge(carry, change)) return change;
+  return has_other_change(change) ? { ...change, merged: NO_INCREMENT2 } : void 0;
+}
+function next_counts(carry, change) {
+  const cuts = change.cuts ?? NO_INCREMENT2;
+  return {
+    merged: carry.merged + (change.merged ?? NO_INCREMENT2),
+    filed: carry.filed + (change.filed ?? NO_INCREMENT2),
+    cuts: carry.cuts + cuts,
+    is_handed_off: cuts > NO_INCREMENT2
+  };
+}
+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);
+  const next = {
+    ...carry,
+    ...next_counts(carry, effective),
+    merged_issues: next_merged_issues(carry, effective.merged_issue),
+    failures: streak.failures,
+    outages: streak.outages,
+    last_outage_at: streak.last_outage_at,
+    done: next_done(carry, effective.done),
+    retrospective: effective.retrospective === true || carry.retrospective
+  };
+  stamp_file.replace_stamp(target2, next);
+  return next;
+}
+var run_carry_change = { apply_change };
+
+// scripts/run/carry/run-carry-conversation.ts
+import { existsSync as existsSync3, statSync as statSync2 } from "node:fs";
+import path20 from "node:path";
+
+// scripts/cost-runtime/cost-transcript.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync7, statSync } from "node:fs";
+import { homedir } from "node:os";
+import path19 from "node:path";
+
+// scripts/lane/lane-paths.ts
+import path18 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 = path18.basename(repository_root2);
+  return path18.join(path18.dirname(repository_root2), `.${name}${LANE_DIRECTORY_SUFFIX}`);
+}
+function lane_root(repository_root2, environment = process.env) {
+  const configured = environment[LANE_ROOT_KEY]?.trim() ?? "";
+  return configured.length === 0 ? default_lane_root(repository_root2) : path18.resolve(configured);
+}
+function lane_directory(root2, issue) {
+  return path18.join(root2, issue);
+}
+var DEFAULT_LANE_ROOT_PATTERN = new RegExp(String.raw`^\..+${LANE_DIRECTORY_SUFFIX}$`, "u");
+var DEFAULT_LANE_FILE_PATTERN = new RegExp(
+  String.raw`([/\\])\.([^/\\]+)${LANE_DIRECTORY_SUFFIX}[/\\]\d+(?=[/\\]|$)`,
+  "u"
+);
+function main_checkout_path(file) {
+  return file.replace(DEFAULT_LANE_FILE_PATTERN, "$1$2");
+}
+function is_lane_root(directory, environment) {
+  const configured = environment[LANE_ROOT_KEY]?.trim() ?? "";
+  if (configured.length > 0) return path18.resolve(configured) === directory;
+  return DEFAULT_LANE_ROOT_PATTERN.test(path18.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 = checkout_of(path18.resolve(directory));
+  const issue = path18.basename(resolved);
+  if (!issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue)) return void 0;
+  return is_lane_root(path18.dirname(resolved), environment) ? issue : void 0;
+}
+function lanes_root_of(checkout2, environment = process.env) {
+  const resolved = checkout_of(path18.resolve(checkout2));
+  if (lane_issue_of(resolved, environment) === void 0) return lane_root(resolved, environment);
+  return path18.dirname(resolved);
+}
+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(issue) {
+  return `${issue}${LANE_BRANCH_SUFFIX}`;
+}
+var SEAT_LOCK_DIR = ".seat-locks";
+function is_lane_entry(name) {
+  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(name) || DEFAULT_LANE_ROOT_PATTERN.test(name);
+}
+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,
+  lane_root,
+  lanes_root_of,
+  main_checkout_path
+};
+
+// scripts/time-runtime/time-instant.ts
+function parse_instant(raw) {
+  if (raw === null || raw === void 0) return void 0;
+  const parsed = Date.parse(raw);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+var time_instant = { parse_instant };
+
+// scripts/cost-runtime/cost-usage.ts
+import { z as z8 } from "zod";
+var CACHE_CREATION_SCHEMA = z8.object({
+  ephemeral_1h_input_tokens: z8.number().nullish(),
+  ephemeral_5m_input_tokens: z8.number().nullish()
+});
+var USAGE_SCHEMA = z8.object({
+  input_tokens: z8.number(),
+  cache_creation_input_tokens: z8.number().nullish(),
+  cache_read_input_tokens: z8.number().nullish(),
+  output_tokens: z8.number(),
+  output_tokens_details: z8.object({ thinking_tokens: z8.number().nullish() }).nullish(),
+  cache_creation: CACHE_CREATION_SCHEMA.nullish()
+});
+var MESSAGE_SCHEMA = z8.object({
+  id: z8.string().nullish(),
+  model: z8.string().nullish(),
+  usage: USAGE_SCHEMA.nullish()
+});
+var LINE_SCHEMA = z8.object({
+  type: z8.string(),
+  requestId: z8.string().nullish(),
+  uuid: z8.string().nullish(),
+  gitBranch: z8.string().nullish(),
+  timestamp: z8.string().nullish(),
+  message: MESSAGE_SCHEMA.nullish()
+});
+var SYNTHETIC_MODEL = "<synthetic>";
+var EMPTY_TOTALS = {
+  input_tokens: 0,
+  cache_write_5m_tokens: 0,
+  cache_write_1h_tokens: 0,
+  cache_read_tokens: 0,
+  output_tokens: 0,
+  thinking_tokens: 0,
+  thinking_measured: false
+};
+var UNKNOWN_MODEL = "unknown";
+var UNKNOWN_BRANCH = "";
+function split_cache_write(usage) {
+  const total = usage.cache_creation_input_tokens ?? 0;
+  const detail = usage.cache_creation;
+  if (!detail) return { write_5m: total, write_1h: 0 };
+  const write_1h = detail.ephemeral_1h_input_tokens ?? 0;
+  return { write_5m: detail.ephemeral_5m_input_tokens ?? total - write_1h, write_1h };
+}
+function thinking_usage(usage) {
+  const raw = usage.output_tokens_details?.thinking_tokens;
+  return { tokens: raw ?? 0, measured: raw !== null && raw !== void 0 };
+}
+function to_totals(usage) {
+  const { write_5m, write_1h } = split_cache_write(usage);
+  const thinking = thinking_usage(usage);
+  return {
+    input_tokens: usage.input_tokens,
+    cache_write_5m_tokens: write_5m,
+    cache_write_1h_tokens: write_1h,
+    cache_read_tokens: usage.cache_read_input_tokens ?? 0,
+    output_tokens: usage.output_tokens,
+    thinking_tokens: thinking.tokens,
+    thinking_measured: thinking.measured
+  };
+}
+function declared_id(data) {
+  return data.requestId ?? data.message?.id ?? data.uuid ?? void 0;
+}
+function request_id_of(data, usage) {
+  const fallback = `${data.timestamp ?? ""}-${String(usage.output_tokens)}`;
+  return declared_id(data) ?? fallback;
+}
+function to_record(data, usage) {
+  return {
+    request_id: request_id_of(data, usage),
+    model: data.message?.model ?? UNKNOWN_MODEL,
+    branch: data.gitBranch ?? UNKNOWN_BRANCH,
+    at_ms: time_instant.parse_instant(data.timestamp),
+    totals: to_totals(usage)
+  };
+}
+var ASSISTANT_TYPE = "assistant";
+function is_priced_line(data) {
+  return data.type === ASSISTANT_TYPE && data.message?.model !== SYNTHETIC_MODEL;
+}
+function classify(data) {
+  if (!is_priced_line(data)) return { kind: "skipped" };
+  const usage = data.message?.usage;
+  return usage ? { kind: "record", record: to_record(data, usage) } : { kind: "no_usage" };
+}
+function parse_line(line) {
+  if (line.trim() === "") return { kind: "skipped" };
+  const parsed = LINE_SCHEMA.safeParse(json_value.parse_or_undefined(line));
+  return parsed.success ? classify(parsed.data) : { kind: "malformed" };
+}
+function later_instant(left, right) {
+  if (left === void 0) return right;
+  if (right === void 0) return left;
+  return Math.max(left, right);
+}
+function dedupe(records) {
+  const by_id = /* @__PURE__ */ new Map();
+  for (const record4 of records) {
+    const seen = by_id.get(record4.request_id);
+    const at_ms = later_instant(seen?.at_ms, record4.at_ms);
+    by_id.set(record4.request_id, { ...seen ?? record4, at_ms });
+  }
+  return [...by_id.values()];
+}
+function add_totals(left, right) {
+  return {
+    input_tokens: left.input_tokens + right.input_tokens,
+    cache_write_5m_tokens: left.cache_write_5m_tokens + right.cache_write_5m_tokens,
+    cache_write_1h_tokens: left.cache_write_1h_tokens + right.cache_write_1h_tokens,
+    cache_read_tokens: left.cache_read_tokens + right.cache_read_tokens,
+    output_tokens: left.output_tokens + right.output_tokens,
+    thinking_tokens: left.thinking_tokens + right.thinking_tokens,
+    thinking_measured: left.thinking_measured || right.thinking_measured
+  };
+}
+function sum_totals(records) {
+  let total = EMPTY_TOTALS;
+  for (const record4 of records) total = add_totals(total, record4.totals);
+  return total;
+}
+function billed_input(totals) {
+  return totals.input_tokens + totals.cache_write_5m_tokens + totals.cache_write_1h_tokens + totals.cache_read_tokens;
+}
+var cost_usage = {
+  EMPTY_TOTALS,
+  UNKNOWN_MODEL,
+  SYNTHETIC_MODEL,
+  parse_line,
+  dedupe,
+  add_totals,
+  sum_totals,
+  billed_input
+};
+
+// scripts/cost-runtime/cost-transcript.ts
+var TRANSCRIPT_ROOT = path19.join(".claude", "projects");
+var TRANSCRIPT_EXTENSION = ".jsonl";
+var SLUG_PATTERN = /[^a-zA-Z0-9-]/gu;
+var UNIT_DIRECTORY = "subagents";
+var UNIT_ID_SEPARATOR = "/";
+function project_slug(cwd) {
+  return cwd.replaceAll(SLUG_PATTERN, "-");
+}
+function transcript_directory(cwd, home = homedir()) {
+  return path19.join(home, TRANSCRIPT_ROOT, project_slug(cwd));
+}
+var GIT_ENTRY = ".git";
+var GITDIR_PREFIX = "gitdir:";
+var WORKTREE_SEGMENT = `/${GIT_ENTRY}/worktrees/`;
+var NOT_FOUND2 = -1;
+function linked_worktree_gitdir(cwd) {
+  try {
+    const contents = readFileSync7(path19.join(cwd, GIT_ENTRY), "utf8").trim();
+    return contents.startsWith(GITDIR_PREFIX) ? contents.slice(GITDIR_PREFIX.length).trim() : "";
+  } catch {
+    return "";
+  }
+}
+function session_cwd(cwd) {
+  const gitdir = linked_worktree_gitdir(cwd);
+  const absolute = gitdir === "" ? "" : path19.resolve(cwd, gitdir);
+  const segment = absolute.indexOf(WORKTREE_SEGMENT);
+  return segment === NOT_FOUND2 ? cwd : absolute.slice(0, segment);
+}
+function read_directory(directory) {
+  try {
+    return readdirSync2(directory);
+  } catch {
+    return [];
+  }
+}
+function lane_transcript_directories(main_cwd, home) {
+  const projects = path19.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) => path19.join(projects, name));
+}
+function transcript_directories(cwd, home = homedir()) {
+  const own3 = transcript_directory(cwd, home);
+  const lanes = session_cwd(cwd) === cwd ? lane_transcript_directories(cwd, home) : [];
+  return [.../* @__PURE__ */ new Set([own3, ...lanes])];
+}
+var OWN_DEPTH = 0;
+function home_directory() {
+  return homedir();
+}
+function to_session_file(full_path, session_id, depth) {
+  try {
+    return {
+      session_id,
+      path: full_path,
+      modified_ms: statSync(full_path).mtimeMs,
+      is_delegated: depth > OWN_DEPTH,
+      depth
+    };
+  } catch {
+    return void 0;
+  }
+}
+function is_transcript(name) {
+  return name.endsWith(TRANSCRIPT_EXTENSION);
+}
+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(path19.join(directory, name), without_extension(name), OWN_DEPTH)).filter((file) => file !== void 0);
+}
+function unit_directory(directory, session_id) {
+  return path19.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(
+      path19.join(subagents_directory, name),
+      `${prefix}${UNIT_ID_SEPARATOR}${without_extension(name)}`,
+      depth
+    )
+  ).filter((file) => file !== void 0);
+}
+function collect_units(subagents_directory, prefix, depth) {
+  const nested = read_directory(subagents_directory).filter((name) => !is_transcript(name)).flatMap(
+    (name) => collect_units(
+      unit_directory(subagents_directory, name),
+      `${prefix}${UNIT_ID_SEPARATOR}${name}`,
+      depth + 1
+    )
+  );
+  return [...level_units(subagents_directory, prefix, depth), ...nested];
+}
+function unit_files(directory, session_name) {
+  return collect_units(unit_directory(directory, session_name), session_name, UNIT_DEPTH);
+}
+function list_sessions(directory) {
+  const names = read_directory(directory);
+  const units = names.filter((name) => !is_transcript(name)).flatMap((name) => unit_files(directory, name));
+  return [...own_files(directory, names), ...units].toSorted(
+    (left, right) => right.modified_ms - left.modified_ms
+  );
+}
+function list_sessions_across(directories2) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = directories2.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) {
+    if (seen.has(file.session_id)) continue;
+    seen.add(file.session_id);
+    kept.push(file);
+  }
+  return kept;
+}
+function owning_session_id(file) {
+  const [owner] = file.session_id.split(UNIT_ID_SEPARATOR);
+  return owner ?? file.session_id;
+}
+function parent_session_id(file) {
+  const separator = file.session_id.lastIndexOf(UNIT_ID_SEPARATOR);
+  return separator === NOT_FOUND2 ? file.session_id : file.session_id.slice(0, separator);
+}
+function latest_own_index(files) {
+  const index = files.findIndex((file) => !file.is_delegated);
+  return index === -1 ? 0 : index;
+}
+function empty_session() {
+  return {
+    records: [],
+    no_usage_lines: 0,
+    malformed_lines: 0,
+    is_readable: false,
+    baseline_tokens: 0
+  };
+}
+function tally(content) {
+  const outcomes = content.split("\n").map((line) => cost_usage.parse_line(line));
+  const records = outcomes.flatMap(
+    (outcome) => outcome.kind === "record" ? [outcome.record] : []
+  );
+  const unique = cost_usage.dedupe(records);
+  const [first] = unique;
+  return {
+    records: unique,
+    no_usage_lines: outcomes.filter((outcome) => outcome.kind === "no_usage").length,
+    malformed_lines: outcomes.filter((outcome) => outcome.kind === "malformed").length,
+    is_readable: true,
+    baseline_tokens: first === void 0 ? 0 : cost_usage.billed_input(first.totals)
+  };
+}
+function read_session(file) {
+  const content = file_reader.read_if_readable(file.path);
+  if (content === void 0) return { session_id: file.session_id, ...empty_session() };
+  return { session_id: file.session_id, ...tally(content) };
+}
+function read_raw(file) {
+  return file_reader.read_if_readable(file.path) ?? "";
+}
+function read_optional2(file) {
+  return file_reader.read_if_readable(file.path);
+}
+function directory_exists(directory) {
+  try {
+    return statSync(directory).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function searched_directories(directories2) {
+  return directories2.map((directory) => ({
+    path: directory,
+    exists: directory_exists(directory)
+  }));
+}
+function describe_searched(directory) {
+  return `  ${directory.path} \u2014 ${directory.exists ? "no transcripts here" : "no such directory"}`;
+}
+function missing_message(searched, session_id) {
+  const lead = session_id === void 0 ? "No transcripts found. Searched:" : `No transcript named ${session_id}. Searched:`;
+  const listed = searched.map((directory) => describe_searched(directory));
+  if (session_id !== void 0) return [lead, ...listed];
+  return [
+    lead,
+    ...listed,
+    "Claude Code writes them per project; run this from the project it ran in."
+  ];
+}
+var cost_transcript = {
+  TRANSCRIPT_EXTENSION,
+  TRANSCRIPT_ROOT,
+  UNIT_DIRECTORY,
+  project_slug,
+  transcript_directory,
+  transcript_directories,
+  session_cwd,
+  lane_transcript_directories,
+  unit_directory,
+  list_sessions,
+  list_sessions_across,
+  searched_directories,
+  owning_session_id,
+  parent_session_id,
+  latest_own_index,
+  tally,
+  read_session,
+  read_raw,
+  read_optional: read_optional2,
+  missing_message,
+  home_directory
+};
+
+// scripts/cost-runtime/own-session.ts
+var NOT_FOUND3 = -1;
+function session_id_of(environment) {
+  const value = environment[agent_session_environment.SESSION_ID_KEY];
+  return value === void 0 || value === "" ? void 0 : value;
+}
+function select_own_session(files, environment) {
+  const session_id = session_id_of(environment);
+  if (session_id === void 0) {
+    return { kind: "own", index: cost_transcript.latest_own_index(files) };
+  }
+  const index = files.findIndex((file) => file.session_id === session_id);
+  return index === NOT_FOUND3 ? { kind: "absent", session_id } : { kind: "own", index };
+}
+var own_session = {
+  session_id_of,
+  select_own_session
+};
+
+// scripts/run/carry/run-carry-conversation.ts
+var CONVERSATION_QUIET_MS = 6e5;
+function transcript_of(session_id, directory) {
+  return path20.join(directory, `${session_id}${cost_transcript.TRANSCRIPT_EXTENSION}`);
+}
+function own_transcript(environment = process.env, directories2 = cost_transcript.transcript_directories(process.cwd())) {
+  const session_id = own_session.session_id_of(environment);
+  if (session_id === void 0) return void 0;
+  return directories2.map((directory) => transcript_of(session_id, directory)).find((file) => existsSync3(file));
+}
+function modified_ms(transcript) {
+  try {
+    return statSync2(transcript).mtimeMs;
+  } catch {
+    return void 0;
+  }
+}
+function is_recent(modified, now) {
+  return modified !== void 0 && now.getTime() - modified <= CONVERSATION_QUIET_MS;
+}
+function is_conversation_live(carry, now = /* @__PURE__ */ new Date(), read_modified = modified_ms) {
+  if (carry.is_handed_off === true || carry.owner_transcript === void 0) return false;
+  return is_recent(read_modified(carry.owner_transcript), now);
+}
+function is_same_conversation(carry, owner) {
+  return owner.transcript !== void 0 && owner.transcript === carry.owner_transcript;
+}
+function reclaim_owner(carry, owner) {
+  if (carry.is_handed_off === true || !is_same_conversation(carry, owner) || owner.pid === carry.owner_pid) {
+    return carry;
+  }
+  return { ...carry, owner_pid: owner.pid, owner_start: owner.start };
+}
+var run_carry_conversation = {
+  CONVERSATION_QUIET_MS,
+  transcript_of,
+  own_transcript,
+  is_conversation_live,
+  is_same_conversation,
+  reclaim_owner
+};
+
+// scripts/lane/lane-child-mark-keys.ts
+var KEY = "JOSH_LANE_CHILD";
+var OVERRUN_KEY = "JOSH_LANE_OVERRUN";
+var MARK_KEYS = [KEY, OVERRUN_KEY];
+var lane_child_mark_keys = { KEY, MARK_KEYS, OVERRUN_KEY };
+
+// scripts/lane/lane-child-marker.ts
+var { KEY: KEY2, OVERRUN_KEY: OVERRUN_KEY2 } = lane_child_mark_keys;
+var CACHE_TTL_KEY = "CLAUDE_CODE_PROMPT_CACHE_TTL";
+var CACHE_TTL = "5m";
+var OVERRUN_VALUE = "1";
+function environment_for(issue) {
+  issue_number_shape.require_issue_number(issue);
+  return { [KEY2]: issue, [CACHE_TTL_KEY]: CACHE_TTL };
+}
+function marked_issue(source = process.env) {
+  const value = source[KEY2];
+  if (value === void 0) return void 0;
+  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(value) ? value : void 0;
+}
+function overrun_environment_for(issue) {
+  return { ...environment_for(issue), [OVERRUN_KEY2]: OVERRUN_VALUE };
+}
+function is_overrun(source = process.env) {
+  return source[OVERRUN_KEY2] === OVERRUN_VALUE && marked_issue(source) !== void 0;
+}
+function is_child_of(directory, source = process.env) {
+  const marked = marked_issue(source);
+  return marked !== void 0 && marked === lane_paths.lane_issue_of(directory, { ...source });
+}
+var lane_child_marker = {
+  KEY: KEY2,
+  OVERRUN_KEY: OVERRUN_KEY2,
+  env_for: environment_for,
+  overrun_env_for: overrun_environment_for,
+  is_child_of,
+  is_overrun,
+  marked_issue
+};
+
+// scripts/run/run-headless-keys.ts
+var HEADLESS_ENV_KEY = "JOSH_RUN_HEADLESS";
+var HANDOFF_CHILD_KEY = "JOSH_HANDOFF_CHILD";
+var BESIDE_CHILD_KEY = "JOSH_BESIDE_CHILD";
+var MARK_KEYS2 = [HEADLESS_ENV_KEY, HANDOFF_CHILD_KEY, BESIDE_CHILD_KEY];
+var run_headless_keys = {
+  BESIDE_CHILD_KEY,
+  HANDOFF_CHILD_KEY,
+  HEADLESS_ENV_KEY,
+  MARK_KEYS: MARK_KEYS2
+};
+
+// scripts/run/carry/run-carry-session.ts
+var KEY3 = "JOSH_CARRY_SESSION";
+function own2() {
+  if (lane_child_marker.marked_issue(process.env) !== void 0 || process.env[run_headless_keys.BESIDE_CHILD_KEY] === "1" || process.env[run_headless_keys.HANDOFF_CHILD_KEY] === "1") {
+    return void 0;
+  }
+  return process.env[KEY3];
+}
+function is_owned_by(carry, owner) {
+  if (carry.owner_session !== void 0) return carry.owner_session === owner.session;
+  if (run_carry_conversation.is_same_conversation(carry, owner)) return true;
+  return carry.owner_pid === owner.pid && carry.owner_start === owner.start;
+}
+function retain_execution(carry, owner) {
+  if (owner.session === void 0 || owner.session !== carry.owner_session || owner.pid !== void 0) {
+    return owner;
+  }
+  return {
+    ...owner,
+    pid: carry.owner_pid,
+    start: carry.owner_start,
+    provider: carry.scheduler_provider,
+    is_headless: carry.is_owner_headless
+  };
+}
+var run_carry_session = { KEY: KEY3, own: own2, is_owned_by, retain_execution };
+
+// scripts/run/carry/run-carry.ts
+var CARRY_PREFIX = durable_state.PREFIX.CARRY;
+var REPOSITORY_DIRECTORY_INDEX = 1;
+var NO_INCREMENT3 = 0;
+var MAX_CUTS = 6;
+var END_COMMAND = "pnpm josh run:carry --end";
+var RESUME_COMMAND = "pnpm josh run:carry --resume";
+var READ_COMMAND = "pnpm josh run:carry --json";
+var NO_OWNER = {};
+var carry_addition_schema = z9.object({ issue: z9.number(), is_priority: z9.boolean() });
+var run_carry_schema = z9.object({
+  scheduler_provider: agent_provider.PROVIDER_SCHEMA.optional(),
+  invocation: z9.string(),
+  started_at: z9.string(),
+  merged: z9.number(),
+  merged_issues: z9.array(z9.number()).optional(),
+  filed: z9.number(),
+  cuts: z9.number(),
+  // Defaulted, so a record that lacks the streak parses with a zero streak rather than failing to read.
+  failures: z9.number().default(0),
+  outages: z9.number().default(0),
+  last_outage_at: z9.string().optional(),
+  // An absent owner reads as "no owner declared", which is the not-provably-live answer rather than a
+  // live one.
+  owner_pid: z9.number().optional(),
+  owner_session: z9.string().optional(),
+  owner_start: z9.string().optional(),
+  owner_transcript: z9.string().optional(),
+  is_owner_headless: z9.boolean().optional(),
+  is_handed_off: z9.boolean().optional(),
+  done: z9.array(z9.number()).optional(),
+  retrospective: z9.boolean().optional(),
+  added: z9.array(carry_addition_schema).optional(),
+  lane_limit: z9.number().int().positive().optional(),
+  launch_limit: z9.number().int().positive().optional()
+});
+function carry_path(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];
+}
+function parse_carry(raw) {
+  return json_value.parse_with(raw, run_carry_schema);
+}
+function classify2(raw) {
+  if (raw === void 0) return { kind: "none" };
+  const carry = parse_carry(raw);
+  if (carry === void 0 || Number.isNaN(Date.parse(carry.started_at))) {
+    return { kind: "unreadable" };
+  }
+  return { kind: "carried", carry };
+}
+function read_carry(target2) {
+  return classify2(stamp_file.read_stamp_text(target2));
+}
+function owner_of(pid, read4 = process_identity.read_start, transcript = run_carry_conversation.own_transcript()) {
+  return { pid, start: read4(pid), transcript };
+}
+function session_owner() {
+  const pid = agent_session_environment.own_session_pid();
+  const owner = pid === void 0 ? NO_OWNER : owner_of(pid);
+  const session = run_carry_session.own();
+  return session === void 0 ? owner : { ...owner, session };
+}
+function fresh_carry(invocation, owner, now) {
+  return {
+    ...owner.provider && { scheduler_provider: owner.provider },
+    invocation,
+    started_at: now.toISOString(),
+    merged: NO_INCREMENT3,
+    filed: NO_INCREMENT3,
+    cuts: NO_INCREMENT3,
+    failures: NO_INCREMENT3,
+    outages: NO_INCREMENT3,
+    owner_pid: owner.pid,
+    owner_session: owner.session,
+    owner_start: owner.start,
+    owner_transcript: owner.transcript,
+    is_owner_headless: owner.is_headless
+  };
+}
+function begin_carry(target2, invocation, owner = NO_OWNER, now = /* @__PURE__ */ new Date()) {
+  const carry = fresh_carry(invocation, owner, now);
+  return stamp_file.create_stamp(target2, carry) ? carry : void 0;
+}
+function adopt_carry(target2, carry, owner = NO_OWNER) {
+  const next_owner = run_carry_session.retain_execution(carry, owner);
+  const next = {
+    ...carry,
+    scheduler_provider: next_owner.provider,
+    owner_pid: next_owner.pid,
+    owner_session: owner.session,
+    owner_start: next_owner.start,
+    owner_transcript: owner.transcript,
+    is_owner_headless: next_owner.is_headless,
+    is_handed_off: false
+  };
+  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;
+  return carry.is_owner_headless !== true && run_carry_conversation.is_conversation_live(carry, now);
+}
+var { is_owned_by: is_owned_by2 } = run_carry_session;
+function is_foreign_live_owner(carry, owner) {
+  return is_owner_live(carry) && !is_owned_by2(carry, owner);
+}
+function is_held_by_self(carry, caller = owner_of(process.pid)) {
+  return carry.owner_pid === caller.pid && carry.owner_start === caller.start;
+}
+function is_held_by_another(carry, is_live = is_owner_live) {
+  return !is_held_by_self(carry) && is_live(carry);
+}
+function is_handed_off_to(carry, invocation) {
+  return carry.is_handed_off === true && carry.invocation === invocation;
+}
+function classify_claim(carry, request) {
+  if (is_handed_off_to(carry, request.invocation)) return "resume";
+  if (is_foreign_live_owner(carry, request.owner)) return "busy";
+  if (carry.invocation !== request.invocation) return "mismatch";
+  return request.is_adoption ? "resume" : "standing";
+}
+function is_count_refused(carry, owner) {
+  return carry.is_handed_off === true || is_foreign_live_owner(carry, owner);
+}
+function is_at_cut_cap(carry) {
+  return carry.cuts >= MAX_CUTS;
+}
+function end_carry(target2) {
+  stamp_file.remove_stamp(target2);
+}
+function retrospective_done_of(read4) {
+  return read4.kind === "carried" && read4.carry.retrospective === true;
+}
+function left_of(carry, declared) {
+  const done = carry.done ?? [];
+  return run_carry_added.ordered(declared, carry.added).filter((issue) => !done.includes(issue));
+}
+function remaining_of(carry) {
+  if (carry === void 0) return void 0;
+  const declared = run_invocation.issue_numbers(carry.invocation);
+  const left = left_of(carry, declared ?? []);
+  return declared === void 0 && left.length === 0 ? void 0 : left;
+}
+function done_note(carry) {
+  const done = carry.done ?? [];
+  return done.length === 0 ? "" : `, issues ${done.join(", ")} done`;
+}
+function describe_carry(carry) {
+  return `${carry.invocation} started ${carry.started_at}; ${String(carry.merged)} merged, ${String(carry.filed)} filed, ${String(carry.failures)} failed in a row, ${String(carry.outages)} outage(s) in a row, ${String(carry.cuts)} cut(s) crossed${done_note(carry)}`;
+}
+function mismatch_message(carry, invocation) {
+  return `A different invocation is carried here \u2014 ${describe_carry(carry)}. This one is \`${invocation}\`. End the standing record with \`${END_COMMAND}\` once you know its run is over, then begin again.`;
+}
+function busy_message(carry) {
+  return `A live run holds this budget \u2014 ${describe_carry(carry)}, owner pid ${String(carry.owner_pid)} still running. Nothing was established. Wait for that run, or end its record with \`${END_COMMAND}\` once you know it is over.`;
+}
+function claim_command(invocation) {
+  return `${RESUME_COMMAND} "${invocation}"`;
+}
+function standing_message(carry) {
+  return `A run record is standing here that no cut handed off \u2014 ${describe_carry(carry)}. Nothing was established. Carry that budget with \`${claim_command(carry.invocation)}\`, or discard it with \`${END_COMMAND}\` and begin again.`;
+}
+function count_refused_message(carry) {
+  if (carry.is_handed_off === true) {
+    return `This budget was handed off at a cut and is waiting for its successor \u2014 ${describe_carry(carry)}. Nothing was counted; the cutting session must not advance a handed-off budget.`;
+  }
+  return `A live run owns this budget \u2014 ${describe_carry(carry)}, owner pid ${String(carry.owner_pid)} still running. Nothing was counted; only its owner advances the budget.`;
+}
+function lost_message() {
+  return `Another process established a run record here first, so nothing was established. Read it with \`${READ_COMMAND}\`.`;
+}
+function nothing_to_resume_message() {
+  return `Nothing is carried here, so there is no budget to resume. Begin one with \`pnpm josh run:carry --begin "<invocation>"\`.`;
+}
+function unreadable_message() {
+  return `A run record is here but could not be read; clear it with \`${END_COMMAND}\` once you know no run is using it.`;
+}
+function unknown_message() {
+  return "This repository\u2019s git directory could not be read, so no run record was established.";
+}
+var run_carry = {
+  END_COMMAND,
+  MAX_CUTS,
+  NO_OWNER,
+  RESUME_COMMAND,
+  adopt_carry,
+  apply_change: run_carry_change.apply_change,
+  begin_carry,
+  busy_message,
+  carry_path,
+  claim_command,
+  classify: classify2,
+  classify_claim,
+  count_refused_message,
+  is_at_cut_cap,
+  describe_carry,
+  end_carry,
+  mismatch_message,
+  fresh_carry,
+  is_count_refused,
+  is_foreign_live_owner,
+  is_held_by_another,
+  is_held_by_self,
+  is_owner_live,
+  lost_message,
+  nothing_to_resume_message,
+  owner_of,
+  parse_carry,
+  read_carry,
+  remaining_of,
+  repository_directory,
+  retrospective_done_of,
+  session_owner,
+  standing_message,
+  unknown_message,
+  unreadable_message
+};
+
+// 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 } = constants3;
+var APPEND_FLAGS = O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW;
+var { KIND: KIND2 } = lane_ledger_kind;
+function target_of(repository2) {
+  return durable_state.path(LEDGER_PREFIX, repository2, LEDGER_SUFFIX);
+}
+async function target() {
+  if (process.env["VITEST"] !== void 0) return void 0;
+  try {
+    const repository2 = await run_carry.repository_directory();
+    return repository2 === void 0 ? void 0 : target_of(repository2);
+  } catch {
+    return void 0;
+  }
+}
+function append(path22, entry2) {
+  const descriptor = openSync(path22, APPEND_FLAGS, LEDGER_FILE_MODE);
+  try {
+    if (!stamp_file.is_own_regular_file(path22)) {
+      throw new Error("Ledger is not an owned regular file");
+    }
+    writeSync(descriptor, `${JSON.stringify(entry2)}${LINE_SEPARATOR}`);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+async function record(entry2, path22) {
+  try {
+    const destination = path22 ?? await target();
+    if (destination !== void 0) append(destination, entry2);
+  } catch {
+  }
+}
+function now_iso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function record_gate(path22, gate) {
+  await record({ kind: KIND2.GATE, at: now_iso(), ...gate }, path22);
+}
+async function record_merge(issue, at = /* @__PURE__ */ new Date()) {
+  await record({ kind: KIND2.MERGE, at: at.toISOString(), issue });
+}
+async function record_dispatch(issue, path22) {
+  await record({ kind: KIND2.DISPATCH, at: now_iso(), issue }, path22);
+}
+async function record_stage(stage, path22) {
+  await record({ kind: KIND2.STAGE, at: now_iso(), ...stage }, path22);
+}
+async function record_stop(stop, path22) {
+  await record({ kind: KIND2.STOP, at: now_iso(), ...stop }, path22);
+}
+async function record_chain(chain, path22) {
+  await record({ kind: KIND2.CHAIN, at: now_iso(), ...chain }, path22);
+}
+async function record_overlap(overlap, path22) {
+  await record({ kind: KIND2.OVERLAP, at: now_iso(), ...overlap }, path22);
+}
+async function record_held(held, path22) {
+  const waiting2 = held.waiting ?? [];
+  const named = waiting2.length > 0 ? { waiting: [...waiting2] } : {};
+  await record({ kind: KIND2.HELD, at: now_iso(), reason: held.reason, ...named }, path22);
+}
+async function record_released(path22) {
+  await record({ kind: KIND2.RELEASED, at: now_iso() }, path22);
+}
+async function record_lane_state(change, path22) {
+  await record({ kind: KIND2.LANE_STATE, at: now_iso(), ...change }, path22);
+}
+async function record_offerable(is_offerable, path22) {
+  await record({ kind: KIND2.OFFERABLE, at: now_iso(), is_offerable }, path22);
+}
+async function record_offer(offer, path22) {
+  await record({ kind: KIND2.OFFER, at: now_iso(), ...offer }, path22);
+}
+async function record_round_one(round_one, path22) {
+  await record({ kind: KIND2.ROUND_ONE, at: now_iso(), ...round_one }, path22);
+}
+async function record_round_two(round_two, path22) {
+  await record({ kind: KIND2.ROUND_TWO, at: now_iso(), ...round_two }, path22);
+}
+async function record_core_wait(wait, path22) {
+  const is_immediate = wait.admission_reason !== void 0 && wait.wait_reason === void 0;
+  const kind = is_immediate ? KIND2.CORE_ADMISSION : KIND2.CORE_WAIT;
+  await record({ kind, at: now_iso(), ...wait }, path22);
+}
+async function record_unit_files(files, path22) {
+  await record({ kind: KIND2.UNIT_FILES, at: now_iso(), files: [...files] }, path22);
+}
+async function record_test_related(run3, path22) {
+  await record({ kind: KIND2.TEST_RELATED, at: now_iso(), ...run3 }, path22);
+}
+async function record_test_pinned(run3, path22) {
+  await record({ kind: KIND2.TEST_PINNED, at: now_iso(), ...run3 }, path22);
+}
+async function record_split_notice(notice, path22) {
+  await record({ kind: KIND2.SPLIT_NOTICE, at: now_iso(), ...notice }, path22);
+}
+async function record_split_filed(filed, path22) {
+  const destination = path22 ?? await target();
+  if (destination === void 0) throw new Error("Could not resolve the split-child ledger");
+  append(destination, { kind: KIND2.SPLIT_FILED, at: now_iso(), ...filed });
+}
+async function record_push_miss(miss, path22) {
+  await record({ kind: KIND2.PUSH_MISS, at: now_iso(), ...miss }, path22);
+}
+async function record_early_push(push3, path22) {
+  await record({ kind: KIND2.EARLY_PUSH, at: now_iso(), ...push3 }, path22);
+}
+async function record_ship_lap(lap, path22) {
+  await record({ kind: KIND2.SHIP_LAP, at: now_iso(), ...lap }, path22);
+}
+async function record_size(size, path22) {
+  await record({ kind: KIND2.SIZE, at: now_iso(), ...size }, path22);
+}
+async function record_unplanned_notice(notice, path22) {
+  await record({ kind: KIND2.UNPLANNED_NOTICE, at: now_iso(), ...notice }, path22);
+}
+var lane_ledger_write = {
+  CI_WAIT_STAGE,
+  CODERABBIT_RATE_LIMIT_STAGE,
+  CODERABBIT_RETRIGGER_STAGE,
+  CODERABBIT_WAIT_STAGE,
+  KIND: KIND2,
+  LINE_SEPARATOR,
+  PRE_DETACH_STAGE,
+  ROUND_ONE_REUSED,
+  append,
+  record,
+  record_chain,
+  record_core_wait,
+  record_dispatch,
+  record_gate,
+  record_held,
+  record_lane_state,
+  record_released,
+  record_merge,
+  record_overlap,
+  record_offer,
+  record_offerable,
+  record_push_miss,
+  record_early_push,
+  record_round_one,
+  record_round_two,
+  record_ship_lap,
+  record_size,
+  record_split_filed,
+  record_split_notice,
+  record_stage,
+  record_stop,
+  record_test_pinned,
+  record_test_related,
+  record_unit_files,
+  record_unplanned_notice,
+  target,
+  target_of
+};
+
+// scripts/run/startup/run-startup-store.ts
+async function carried_identity(issue) {
+  const repository2 = await run_carry.repository_directory();
+  if (repository2 === void 0) return void 0;
+  const read4 = run_carry.read_carry(run_carry.carry_path(repository2));
+  if (read4.kind !== "carried") return void 0;
+  return {
+    run: `${repository2}:${read4.carry.started_at}`,
+    attempt: randomUUID3(),
+    destination: lane_ledger_write.target_of(repository2),
+    ...issue !== void 0 && { issue }
+  };
+}
+async function identity(issue) {
+  try {
+    if (process.env["VITEST"] !== void 0) return void 0;
+    return await carried_identity(issue);
+  } catch {
+    return void 0;
+  }
+}
+async function record2(entry2, destination) {
+  await lane_ledger_write.record(entry2, destination);
+}
+function counts(rows, edge) {
+  const result = {};
+  for (const row of rows) {
+    if (row.edge !== edge) continue;
+    const key = row.metric ?? "unknown";
+    result[key] = (result[key] ?? 0) + 1;
+  }
+  return result;
+}
+function is_terminal(row) {
+  return row.edge === "done" || row.edge === "failed" || row.edge === "waiting";
+}
+function summary(start, rows) {
+  const ending = rows.find(is_terminal);
+  return {
+    start,
+    status: ending?.edge ?? "incomplete",
+    elapsed_ms: ending?.elapsed_ms,
+    api: counts(rows, "api"),
+    cache: counts(rows, "cache")
+  };
+}
+function by_span(entries) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of entries) {
+    const group = groups.get(row.id) ?? [];
+    group.push(row);
+    groups.set(row.id, group);
+  }
+  return groups;
+}
+function summarize(entries) {
+  const groups = by_span(entries);
+  return entries.filter((row) => row.edge === "start").map((start) => summary(start, groups.get(start.id) ?? []));
+}
+function timestamp(row) {
+  return row.at_ms ?? Date.parse(row.at);
+}
+function before_end(row, other, endings) {
+  const end = endings.get(other.id);
+  return end !== void 0 && timestamp(row) < end;
+}
+function overlaps(left, right, endings) {
+  if (left.id === right.id || left.key !== right.key) return false;
+  return before_end(left, right, endings) && before_end(right, left, endings);
+}
+function concurrent_misses(entries) {
+  const fills = entries.filter((row) => row.edge === "cache" && row.metric === "fill");
+  const endings = new Map(entries.filter(is_terminal).map((row) => [row.id, timestamp(row)]));
+  return fills.filter((row) => fills.some((other) => overlaps(row, other, endings)));
+}
+var run_startup_store = { identity, record: record2, summarize, concurrent_misses };
+
+// scripts/run/startup/run-startup.ts
+var ENVIRONMENT_KEY = "JOSH_STARTUP_SCOPE";
+var scope = inherited_scope.create(ENVIRONMENT_KEY, run_startup_schema.scope_schema);
+async function record3(row) {
+  try {
+    await run_startup_store.record(row, scope.current()?.destination);
+  } catch {
+  }
+}
+function entry(current, name, edge) {
+  return run_startup_schema.entry_schema.parse({
+    ...current,
+    kind: lane_ledger_kind.KIND.STARTUP,
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    at_ms: performance.timeOrigin + performance.now(),
+    id: current.span ?? randomUUID4(),
+    phase: name,
+    edge
+  });
+}
+async function completed(name, run3, options) {
+  const current = scope.current();
+  if (current === void 0) return await run3();
+  const started = performance.now();
+  await record3(entry(current, name, "start"));
+  const ending = { edge: "failed" };
+  try {
+    const value = await run3();
+    ending.edge = options.edge_of?.(value) ?? "done";
+    return value;
+  } finally {
+    await record3({ ...entry(current, name, ending.edge), elapsed_ms: performance.now() - started });
+  }
+}
+async function current_scope(options) {
+  return scope.current() ?? (options.root === true ? await run_startup_store.identity(options.issue) : void 0);
+}
+async function phase(name, run3, options = {}) {
+  const current = await current_scope(options);
+  if (current === void 0) return await run3();
+  const next = {
+    ...current,
+    parent: current.span,
+    span: randomUUID4(),
+    ...options.issue !== void 0 && { issue: options.issue }
+  };
+  return await scope.within(next, async () => await completed(name, run3, options));
+}
+function metric(edge, name, key) {
+  const current = scope.current();
+  if (current === void 0) return;
+  void record3({
+    ...entry(current, "", edge),
+    metric: name,
+    ...key !== void 0 && { key: stamp_file.digest(key) }
+  });
+}
+async function waiting(name) {
+  const current = scope.current();
+  const started = performance.now();
+  const place = { ...current, span: randomUUID4(), parent: current?.span };
+  if (current !== void 0) await record3(entry({ ...current, ...place }, name, "start"));
+  return async () => {
+    if (current === void 0) return;
+    await record3({
+      ...entry({ ...current, ...place }, name, "waiting"),
+      elapsed_ms: performance.now() - started
+    });
+  };
+}
+var run_startup = {
+  ENVIRONMENT_KEY,
+  phase,
+  metric,
+  waiting,
+  environment: scope.environment,
+  within: scope.within
+};
+
+// scripts/gh/gh-request-tally.ts
+var STATE_KEY = /* @__PURE__ */ Symbol.for("josh.gh-request-tally");
+function is_state(value) {
+  return typeof value === "object" && value !== null && Reflect.has(value, "endpoints");
+}
+function shared_state() {
+  const existing = Reflect.get(globalThis, STATE_KEY);
+  if (is_state(existing)) return existing;
+  const state = {
+    tally: { calls: 0, not_modified: 0 },
+    endpoints: /* @__PURE__ */ new Map(),
+    core: { read: void 0, start: void 0 }
+  };
+  Reflect.set(globalThis, STATE_KEY, state);
+  return state;
+}
+var { tally: tally2, endpoints, core } = shared_state();
+function watch_core(read4) {
+  core.read = async () => {
+    try {
+      return await read4();
+    } catch {
+      return void 0;
+    }
+  };
+}
+function endpoint_of(kind) {
+  const count = endpoints.get(kind) ?? { calls: 0, not_modified: 0 };
+  endpoints.set(kind, count);
+  return count;
+}
+function snapshot() {
+  const entries = [...endpoints].map(([kind, count]) => [kind, { ...count }]);
+  return { ...tally2, endpoints: Object.fromEntries(entries) };
+}
+function count_call(kind) {
+  run_startup.metric("api", gh_call_kind.class_of(kind));
+  if (core.read !== void 0) core.start ??= core.read();
+  tally2.calls += 1;
+  endpoint_of(kind).calls += 1;
+}
+function count_not_modified(kind) {
+  tally2.not_modified += 1;
+  endpoint_of(kind).not_modified += 1;
+}
+function to_delta(start, end) {
+  if (start === void 0 || start.reset_ms !== end?.reset_ms) return void 0;
+  return end.used - start.used;
+}
+async function core_delta() {
+  if (core.read === void 0 || core.start === void 0) return void 0;
+  const [start, end] = await Promise.all([core.start, core.read()]);
+  return to_delta(start, end);
+}
+function reset() {
+  tally2.calls = 0;
+  tally2.not_modified = 0;
+  endpoints.clear();
+  core.read = void 0;
+  core.start = void 0;
+}
+var gh_request_tally = {
+  watch_core,
+  count_call,
+  count_not_modified,
+  snapshot,
+  core_delta,
+  reset
+};
+
+// scripts/gh/git-gh-check.ts
+import { execa as execa4 } from "execa";
+var GH_NOT_INSTALLED_MSG = "gh CLI is not installed. Install it from https://cli.github.com/";
+var gh_check = {};
+async function run_gh_check() {
+  try {
+    await execa4("gh", ["--version"], { timeout: COMMAND_TIMEOUT_MS });
+  } catch {
+    delete gh_check.promise;
+    throw new Error(GH_NOT_INSTALLED_MSG);
+  }
+}
+async function check_gh_installed() {
+  gh_check.promise ??= run_gh_check();
+  await gh_check.promise;
+}
+
+// scripts/git/parse-json-array.ts
+function parse_json_loose(raw_json) {
+  return json_value.parse_or_undefined(raw_json);
+}
+function parse_json_object_or_undefined(raw_json, schema) {
+  const value = parse_json_loose(raw_json);
+  if (value === void 0) return void 0;
+  return schema.parse(value);
+}
+var parse_json = {
+  parse_json_object_or_undefined
+};
+
+// scripts/gh/git-gh-failure.ts
+import { z as z10 } from "zod";
+var error_document_schema = z10.object({ status: z10.union([z10.string(), z10.number()]).optional() }).catch({});
+var GH_FAILURE_FIELD = "gh_failure";
 function has_stdout_field(error) {
   return error instanceof Error && "stdout" in error && typeof error.stdout === "string";
 }
@@ -1315,8 +5368,8 @@ function has_gh_failure(error) {
 function parse_response_status(stdout) {
   const document = parse_json.parse_json_object_or_undefined(stdout, error_document_schema);
   if (document?.status === void 0) return void 0;
-  const status = Number(document.status);
-  return Number.isSafeInteger(status) ? status : void 0;
+  const status2 = Number(document.status);
+  return Number.isSafeInteger(status2) ? status2 : void 0;
 }
 function classify_stdout(stdout) {
   return { status: parse_response_status(stdout) };
@@ -1358,17 +5411,17 @@ var DEFAULT_HOOKS = {
   }
 };
 function summary_status(error) {
-  const { status } = SUMMARY_STATUS_PATTERN.exec(error.message)?.groups ?? {};
-  return status === void 0 ? void 0 : Number(status);
+  const { status: status2 } = SUMMARY_STATUS_PATTERN.exec(error.message)?.groups ?? {};
+  return status2 === void 0 ? void 0 : Number(status2);
 }
 function has_answer(spawn_error) {
   if (!(spawn_error instanceof Error) || !("stdout" in spawn_error)) return false;
   return typeof spawn_error.stdout === "string" && spawn_error.stdout.trim().length > 0;
 }
-function is_transient_status(status, spawn_error, is_read2) {
+function is_transient_status(status2, spawn_error, is_read2) {
   if (is_read2 && has_timed_out(spawn_error)) return true;
-  if (status === void 0) return !has_answer(spawn_error);
-  return status >= SERVER_ERROR_FLOOR;
+  if (status2 === void 0) return !has_answer(spawn_error);
+  return status2 >= SERVER_ERROR_FLOOR;
 }
 function is_final_spawn(spawn_error, is_read2) {
   return !is_read2 && has_timed_out(spawn_error) || get_exit_code(spawn_error) === GH_AUTH_REQUIRED_EXIT_CODE;
@@ -1376,8 +5429,8 @@ function is_final_spawn(spawn_error, is_read2) {
 function is_transient_request(error, is_read2) {
   const failure = gh_failure.failure_of(error);
   if (failure === void 0 || !(error instanceof Error)) return false;
-  const status = failure.status ?? summary_status(error);
-  return !is_final_spawn(error.cause, is_read2) && is_transient_status(status, error.cause, is_read2);
+  const status2 = failure.status ?? summary_status(error);
+  return !is_final_spawn(error.cause, is_read2) && is_transient_status(status2, error.cause, is_read2);
 }
 function is_transient(error) {
   return is_transient_request(error, false);
@@ -1459,9 +5512,9 @@ function to_timeout_prefix(error) {
 function to_gh_error(error) {
   const stderr = has_stderr_field(error) ? error.stderr.trim() : "";
   const stdout = has_stdout_field(error) ? error.stdout.trim() : "";
-  const summary = stderr.length > 0 ? stderr : error_text.message_of(error);
-  const detail = stdout.length > 0 ? `${summary}
-${stdout}` : summary;
+  const summary2 = stderr.length > 0 ? stderr : error_text.message_of(error);
+  const detail = stdout.length > 0 ? `${summary2}
+${stdout}` : summary2;
   return gh_failure.attach(
     new Error(`${to_timeout_prefix(error)}${detail}`, { cause: error }),
     gh_failure.classify_stdout(stdout)
@@ -1473,7 +5526,7 @@ async function spawn_gh_command(arguments_, timeout_ms, cwd) {
   const options = to_spawn_options(timeout_ms, cwd);
   gh_request_tally.count_call(gh_call_kind.of(arguments_));
   try {
-    const { stdout } = await execa2("gh", arguments_, options);
+    const { stdout } = await execa5("gh", arguments_, options);
     return stdout.trimEnd();
   } catch (error) {
     throw to_gh_error(error);
@@ -1487,7 +5540,7 @@ async function spawn_gh_command_with_stdin(input) {
   const options = { input: input.stdin_body, ...to_spawn_options(input.timeout_ms, input.cwd) };
   gh_request_tally.count_call(gh_call_kind.of(input.args));
   try {
-    const { stdout } = await execa2("gh", input.args, options);
+    const { stdout } = await execa5("gh", input.args, options);
     return stdout.trimEnd();
   } catch (error) {
     throw to_gh_error(error);
@@ -1498,31 +5551,31 @@ async function exec_gh_command_with_stdin(input) {
 }
 var STATUS_LINE_PATTERN = /^HTTP\/[\d.]+ (?<status>\d{3})\b/u;
 function parse_status_line(output) {
-  const { status } = STATUS_LINE_PATTERN.exec(output)?.groups ?? {};
-  return status === void 0 ? void 0 : Number(status);
+  const { status: status2 } = STATUS_LINE_PATTERN.exec(output)?.groups ?? {};
+  return status2 === void 0 ? void 0 : Number(status2);
 }
 function status_of_failure(error) {
   return has_stdout_field(error) ? parse_status_line(error.stdout) : void 0;
 }
-async function spawn_gh_api_status(path7, timeout_ms) {
+async function spawn_gh_api_status(path22, timeout_ms) {
   const options = to_spawn_options(timeout_ms);
   try {
     await check_gh_installed();
-    gh_request_tally.count_call(gh_call_kind.of_api(path7));
-    const { stdout } = await execa2("gh", ["api", "--include", "--silent", path7], options);
+    gh_request_tally.count_call(gh_call_kind.of_api(path22));
+    const { stdout } = await execa5("gh", ["api", "--include", "--silent", path22], options);
     return parse_status_line(stdout);
   } catch (error) {
     return status_of_failure(error);
   }
 }
-async function exec_gh_api_status(path7, timeout_ms) {
-  return await gh_slots.run(async () => await spawn_gh_api_status(path7, timeout_ms));
+async function exec_gh_api_status(path22, timeout_ms) {
+  return await gh_slots.run(async () => await spawn_gh_api_status(path22, timeout_ms));
 }
-function exec_gh_api_status_sync(path7, timeout_ms) {
+function exec_gh_api_status_sync(path22, timeout_ms) {
   const options = to_spawn_options(timeout_ms);
-  gh_request_tally.count_call(gh_call_kind.of_api(path7));
+  gh_request_tally.count_call(gh_call_kind.of_api(path22));
   try {
-    const { stdout } = execaSync("gh", ["api", "--include", "--silent", path7], options);
+    const { stdout } = execaSync2("gh", ["api", "--include", "--silent", path22], options);
     return parse_status_line(stdout);
   } catch (error) {
     return status_of_failure(error);
@@ -1578,7 +5631,7 @@ async function exec_gh_api(request) {
 async function exec_gh_api_uncounted(request) {
   const options = to_spawn_options(request.timeout_ms, request.cwd);
   try {
-    const { stdout } = await execa2("gh", to_gh_api_args(request), options);
+    const { stdout } = await execa5("gh", to_gh_api_args(request), options);
     return stdout.trimEnd();
   } catch (error) {
     throw to_gh_error(error);
@@ -1591,7 +5644,7 @@ function exec_gh_api_sync(request) {
   const gh_arguments = to_gh_api_args(request);
   gh_request_tally.count_call(gh_call_kind.of(gh_arguments));
   try {
-    const { stdout } = execaSync("gh", gh_arguments, options);
+    const { stdout } = execaSync2("gh", gh_arguments, options);
     return stdout.trimEnd();
   } catch (error) {
     throw to_gh_error(error);
@@ -1618,9 +5671,9 @@ var git_gh_exec = {
 };
 
 // scripts/version/npm-registry.ts
-import { execaSync as execaSync2 } from "execa";
+import { execaSync as execaSync3 } from "execa";
 import semver3 from "semver";
-import { z as z5 } from "zod";
+import { z as z11 } from "zod";
 var PUBLIC_REGISTRY = "https://registry.npmjs.org";
 var ABBREVIATED_ACCEPT = "application/vnd.npm.install-v1+json";
 var FULL_ACCEPT = "application/json";
@@ -1636,24 +5689,36 @@ var github_scopes = /* @__PURE__ */ new Map();
 var FETCH_SCRIPT = [
   "const [url, accept] = process.argv.slice(1)",
   "const response = await fetch(url, { headers: { accept } })",
-  "if (!response.ok) process.exit(1)",
+  "if (!response.ok) { console.error(`HTTP ${response.status}`); process.exit(1) }",
   "process.stdout.write(await response.text())"
 ].join("\n");
-var version_schema = z5.string().refine((value) => semver3.valid(value) === value);
-var latest_schema = z5.looseObject({ "dist-tags": z5.looseObject({ latest: version_schema }) });
-var times_schema = z5.looseObject({ time: release_age.release_times_schema });
-var name_schema = z5.looseObject({ name: z5.string().optional() });
+var version_schema = z11.string().refine((value) => semver3.valid(value) === value);
+var latest_schema = z11.looseObject({ "dist-tags": z11.looseObject({ latest: version_schema }) });
+var public_version_schema = z11.looseObject({
+  name: z11.string(),
+  version: version_schema,
+  dist: z11.looseObject({ tarball: z11.url(), integrity: z11.string() })
+});
+var times_schema = z11.looseObject({ time: release_age.release_times_schema });
+var name_schema = z11.looseObject({ name: z11.string().optional() });
 var PUBLISHING_SCOPE = "@joshuafolkken/";
 function packument_url(package_name) {
   return `${PUBLIC_REGISTRY}/${package_name.replace(SCOPE_SEPARATOR, () => ENCODED_SCOPE_SEPARATOR)}`;
 }
-function read_packument(package_name, accept) {
-  const result = execaSync2(
+function read_packument(package_name, accept, should_require = false, version) {
+  const base = packument_url(package_name);
+  const url = version === void 0 ? base : `${base}/${version}`;
+  const result = execaSync3(
     process.execPath,
-    ["--input-type=module", "-e", FETCH_SCRIPT, packument_url(package_name), accept],
+    ["--input-type=module", "-e", FETCH_SCRIPT, url, accept],
     { reject: false, timeout: FETCH_TIMEOUT_MS }
   );
-  if (result.exitCode !== 0) return void 0;
+  if (result.exitCode !== 0) {
+    if (should_require) {
+      throw new Error(`Public npm request failed: ${package_name}: ${result.stderr}`);
+    }
+    return void 0;
+  }
   return json_value.parse_or_undefined(result.stdout);
 }
 function is_github_registry(value) {
@@ -1664,20 +5729,21 @@ function is_github_registry(value) {
     return false;
   }
 }
-function is_github_scope(scope) {
-  const is_cached_github = github_scopes.get(scope);
+function is_github_scope(scope2) {
+  const is_cached_github = github_scopes.get(scope2);
   if (is_cached_github !== void 0) return is_cached_github;
-  const result = execaSync2(PNPM, ["config", "get", `${scope}${SCOPE_REGISTRY_SUFFIX}`], {
+  const result = execaSync3(PNPM, ["config", "get", `${scope2}${SCOPE_REGISTRY_SUFFIX}`], {
     reject: false,
     timeout: FETCH_TIMEOUT_MS
   });
   const is_github = result.exitCode === 0 && is_github_registry(result.stdout.trim());
-  github_scopes.set(scope, is_github);
+  github_scopes.set(scope2, is_github);
   return is_github;
 }
 function is_public_source(package_name) {
-  const scope = SCOPE_PATTERN.exec(package_name)?.[0];
-  return scope === void 0 || !is_github_scope(scope);
+  if (package_name === KIT_PACKAGE_NAME) return true;
+  const scope2 = SCOPE_PATTERN.exec(package_name)?.[0];
+  return scope2 === void 0 || !is_github_scope(scope2);
 }
 function read_latest(package_name) {
   if (!is_public_source(package_name)) return void 0;
@@ -1693,6 +5759,15 @@ function has_public_version(package_name, version) {
   const parsed = times_schema.safeParse(read_packument(package_name, FULL_ACCEPT));
   return parsed.success && parsed.data.time[version] !== void 0;
 }
+function read_public_version(package_name, version) {
+  if (!version_schema.safeParse(version).success) return void 0;
+  const selected = public_version_schema.safeParse(
+    read_packument(package_name, FULL_ACCEPT, true, version)
+  );
+  if (!selected.success) return void 0;
+  const entry2 = selected.data;
+  return entry2.name === package_name && entry2.version === version ? entry2 : void 0;
+}
 function published_package_name(cwd) {
   const name = package_manifest.read_manifest_if_valid(cwd, name_schema)?.name;
   if (name?.startsWith(PUBLISHING_SCOPE) !== true) return void 0;
@@ -1700,7 +5775,7 @@ function published_package_name(cwd) {
 }
 function view(spec, field, format = "text") {
   const format_arguments = format === "json" ? [JSON_FLAG] : [];
-  const result = execaSync2(PNPM, ["view", spec, field, ...format_arguments], {
+  const result = execaSync3(PNPM, ["view", spec, field, ...format_arguments], {
     reject: false,
     timeout: COMMAND_TIMEOUT_MS
   });
@@ -1714,6 +5789,7 @@ var npm_registry = {
   packument_url,
   published_package_name,
   read_latest,
+  read_public_version,
   read_release_times,
   valid_version,
   view
@@ -1773,8 +5849,8 @@ function fetch_release_times(versions_endpoint, package_name) {
 }
 
 // scripts/version/version-targets.ts
-import path6 from "node:path";
-import { execaSync as execaSync3 } from "execa";
+import path21 from "node:path";
+import { execaSync as execaSync4 } from "execa";
 var NODE_MODULES2 = "node_modules";
 function build_pnpm_ls_arguments(package_name) {
   return ["ls", "-g", "--json", package_name];
@@ -1785,11 +5861,11 @@ function parse_global_version(stdout, package_name) {
   return parsed.data[0]?.dependencies?.[package_name]?.version;
 }
 function read_global_version(package_name) {
-  const result = execaSync3("pnpm", build_pnpm_ls_arguments(package_name), { reject: false });
+  const result = execaSync4("pnpm", build_pnpm_ls_arguments(package_name), { reject: false });
   return parse_global_version(result.stdout, package_name);
 }
 function read_project_version(cwd, package_name) {
-  const package_directory = path6.join(cwd, NODE_MODULES2, package_name);
+  const package_directory = path21.join(cwd, NODE_MODULES2, package_name);
   return package_manifest.read_manifest_if_valid(package_directory, package_version_schema)?.version;
 }
 function read_workspace_version(cwd) {
@@ -1893,7 +5969,7 @@ function run_check(config) {
 }
 function run_upgrade_step(step) {
   const [executable = "", ...rest] = step;
-  const result = execaSync4(executable, rest, {
+  const result = execaSync5(executable, rest, {
     stdio: "inherit",
     reject: false,
     timeout: INSTALL_TIMEOUT_MS