@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/dist/commands/read-set-cli.js

@@ -0,0 +1,1927 @@
+#!/usr/bin/env tsx
+
+// scripts/document/read-set-cli.ts
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+
+// scripts/agent/lane-instructions.ts
+import path6 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// scripts/cost-runtime/cost-tokens.ts
+var ASCII_CHARS_PER_TOKEN = 3;
+var WIDE_TOKENS_PER_CHAR = 1;
+var ASCII_LIMIT = 128;
+function count_chars(text) {
+  let ascii_chars = 0;
+  let wide_chars = 0;
+  for (const char of text) {
+    if ((char.codePointAt(0) ?? 0) < ASCII_LIMIT) ascii_chars += 1;
+    else wide_chars += 1;
+  }
+  return { ascii_chars, wide_chars };
+}
+function estimate(text) {
+  const { ascii_chars, wide_chars } = count_chars(text);
+  return Math.round(ascii_chars / ASCII_CHARS_PER_TOKEN) + wide_chars * WIDE_TOKENS_PER_CHAR;
+}
+function ascii_bytes_to_tokens(bytes) {
+  return Math.round(bytes / ASCII_CHARS_PER_TOKEN);
+}
+var cost_tokens = {
+  ASCII_CHARS_PER_TOKEN,
+  count_chars,
+  estimate,
+  ascii_bytes_to_tokens
+};
+
+// scripts/lib/read-file.ts
+import { readFileSync } from "node:fs";
+var ABSENT_CODE = "ENOENT";
+function is_absent(error) {
+  return error instanceof Error && "code" in error && error.code === ABSENT_CODE;
+}
+function read_optional(path9) {
+  try {
+    return readFileSync(path9, "utf8");
+  } catch (error) {
+    if (is_absent(error)) return void 0;
+    throw error;
+  }
+}
+function read_file_or_empty(path9) {
+  return read_optional(path9) ?? "";
+}
+function read_if_readable(path9) {
+  try {
+    return readFileSync(path9, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+var file_reader = { is_absent, read_optional, read_file_or_empty, read_if_readable };
+
+// scripts/document/document-scan.ts
+var COMMAND_PATTERN = /`(?:pnpm )?josh ([a-z][a-z0-9:-]+)/gu;
+var LABEL_PATTERN = /(?:labels\[\]=|\/labels\/|labels -f name=)([a-z][a-z0-9:_-]*)/gu;
+var SECTION_PATTERN = /(?<![\w./:`-])(?<tick>`?)(?<file>[\w./-]+\.md)\k<tick>\s*→\s*(?:§\w+,\s*)?["「](?<heading>[^"」]+)["」]/gu;
+var ADJACENT_PATTERN = /["「](?<heading>[^"「」]+)["」]\s+(?:above|below)\b/gu;
+var BARE_ARROW_PATTERN = /→\s*(?:§\w+,\s*)?["「](?<heading>[^"「」]+)["」]/gu;
+var LINK_TARGET_PATTERN = /\]\([^)\s]*\)/gu;
+var LINK_PATTERN = /\]\(([\w./-]+\.(?:md|png|jpe?g|gif|svg|webp))(?:#[\w-]+)?\)/gu;
+var PLACEHOLDER_FILES = /* @__PURE__ */ new Set(["x.md", "foo.md", "file.md", "path.md"]);
+function matches(text, pattern) {
+  return [...text.matchAll(pattern)];
+}
+function command_references(text) {
+  return matches(text, COMMAND_PATTERN).map((match) => match[1] ?? "").filter((name) => !name.endsWith(":"));
+}
+function is_real_label(token) {
+  return token.length > 0 && !token.endsWith(":") && !token.includes("<");
+}
+function label_references(text) {
+  return matches(text, LABEL_PATTERN).map((match) => match[1] ?? "").filter((token) => is_real_label(token));
+}
+function base_name(path9) {
+  return path9.split("/").at(-1) ?? path9;
+}
+function is_placeholder_file(name) {
+  return name.includes("<") || PLACEHOLDER_FILES.has(base_name(name).toLowerCase());
+}
+function section_references(text) {
+  return matches(text.replaceAll(LINK_TARGET_PATTERN, ""), SECTION_PATTERN).map(({ groups }) => ({ file: groups?.["file"] ?? "", heading: groups?.["heading"] ?? "" })).filter((reference) => !is_placeholder_file(reference.file));
+}
+function headings_matching(text, pattern) {
+  return matches(text, pattern).map(({ groups }) => groups?.["heading"] ?? "");
+}
+function adjacent_references(text) {
+  return headings_matching(text, ADJACENT_PATTERN);
+}
+function bare_arrow_references(text) {
+  const unfiled = text.replaceAll(LINK_TARGET_PATTERN, "").replaceAll(SECTION_PATTERN, "");
+  return headings_matching(unfiled, BARE_ARROW_PATTERN);
+}
+function link_targets(text) {
+  return matches(text, LINK_PATTERN).map((match) => match[1] ?? "").filter((file) => !is_placeholder_file(file));
+}
+function normalize_reference(heading) {
+  return heading.replaceAll("`", "").split(/\s+/u).filter((word) => word !== ">").join(" ");
+}
+function reference_forms(title) {
+  const normalized = normalize_reference(title);
+  return [normalized, normalized.replace(/^\d+[a-z]?\. /u, "")];
+}
+var document_scan = {
+  adjacent_references,
+  bare_arrow_references,
+  command_references,
+  label_references,
+  link_targets,
+  normalize_reference,
+  reference_forms,
+  section_references
+};
+
+// scripts/document/document-section.ts
+var HEADING_PATTERN = /^(?<hashes>#{1,6}) (?<title>.*)$/u;
+var FENCE = "```";
+var SINGLE_MATCH = 1;
+var BOLD_LABEL_PATTERN = /\*\*([^*]+?)\*\*/gu;
+var BOLD_DELIMITER = "**";
+var CODE_SPAN_PATTERN = /``[^\n]*?``|`[^`\n]*`/gu;
+var LABEL_LEVEL = 7;
+var LIST_ITEM_PATTERN = /^(?<indent>\s*)(?:[-*]|\d+\.) /u;
+function to_heading(line, index) {
+  const groups = HEADING_PATTERN.exec(line)?.groups;
+  if (groups === void 0) return void 0;
+  const { hashes = "", title = "" } = groups;
+  return { level: hashes.length, title: title.trim(), line: index };
+}
+function push_heading(found, line, index) {
+  const heading = to_heading(line, index);
+  if (heading !== void 0) found.push(heading);
+}
+function fenced_flags(lines) {
+  let is_inside_fence = false;
+  return lines.map(function is_fenced(line) {
+    if (!line.startsWith(FENCE)) return is_inside_fence;
+    is_inside_fence = !is_inside_fence;
+    return true;
+  });
+}
+function headings(markdown) {
+  const lines = markdown.split("\n");
+  const fenced = fenced_flags(lines);
+  const found = [];
+  for (const [index, line] of lines.entries()) {
+    if (fenced[index] !== true) push_heading(found, line, index);
+  }
+  return found;
+}
+function titles(markdown) {
+  return headings(markdown).map((heading) => heading.title);
+}
+function line_starts(markdown) {
+  return [...markdown.matchAll(/\n/gu)].map((match) => match.index + SINGLE_MATCH);
+}
+function line_of(starts, offset) {
+  return starts.filter((start) => start <= offset).length;
+}
+function unfenced_text(markdown) {
+  const lines = markdown.split("\n");
+  const fenced = fenced_flags(lines);
+  return lines.map((line, index) => fenced[index] === true ? "" : line).join("\n");
+}
+function code_masked(text) {
+  return text.replaceAll(CODE_SPAN_PATTERN, (span) => span.replaceAll("*", " "));
+}
+function labels(markdown) {
+  const text = unfenced_text(markdown);
+  const starts = line_starts(text);
+  return [...code_masked(text).matchAll(BOLD_LABEL_PATTERN)].map((match) => ({
+    level: LABEL_LEVEL,
+    title: text.slice(
+      match.index + BOLD_DELIMITER.length,
+      match.index + match[0].length - BOLD_DELIMITER.length
+    ),
+    line: line_of(starts, match.index)
+  }));
+}
+function is_match(heading, wanted) {
+  return document_scan.reference_forms(heading.title).some((form) => form.startsWith(wanted));
+}
+function prefixed(found, wanted) {
+  const normalized = document_scan.normalize_reference(wanted);
+  return found.filter((heading) => is_match(heading, normalized));
+}
+function is_exact(heading, wanted) {
+  return document_scan.reference_forms(heading.title).includes(wanted);
+}
+function select(found, wanted) {
+  const normalized = document_scan.normalize_reference(wanted);
+  const exact = found.find((heading) => is_exact(heading, normalized));
+  if (exact !== void 0) return exact;
+  const near = prefixed(found, wanted);
+  return near.length === SINGLE_MATCH ? near[0] : void 0;
+}
+function last_line_of(found, chosen, total_lines2) {
+  const next = found.find((heading) => heading.line > chosen.line && heading.level <= chosen.level);
+  return (next === void 0 ? total_lines2 : next.line) - SINGLE_MATCH;
+}
+function indent_of(line) {
+  return line.length - line.trimStart().length;
+}
+function is_sibling_item(line, depth) {
+  const { indent } = LIST_ITEM_PATTERN.exec(line)?.groups ?? {};
+  return indent !== void 0 && indent.length <= depth;
+}
+function ends_block(line, depth) {
+  if (line.trim() === "" || HEADING_PATTERN.test(line)) return true;
+  return is_sibling_item(line, depth);
+}
+function label_last_line(lines, label) {
+  const depth = indent_of(lines[label.line] ?? "");
+  const end = lines.findIndex((line, index) => index > label.line && ends_block(line, depth));
+  return (end === -1 ? lines.length : end) - SINGLE_MATCH;
+}
+function choose(markdown, wanted) {
+  const found = headings(markdown);
+  if (prefixed(found, wanted).length > 0) return select(found, wanted);
+  return select(labels(markdown), wanted);
+}
+function extent_of(markdown, chosen) {
+  const lines = markdown.split("\n");
+  if (chosen.level === LABEL_LEVEL) return label_last_line(lines, chosen);
+  return last_line_of(headings(markdown), chosen, lines.length);
+}
+function section(markdown, wanted) {
+  const chosen = choose(markdown, wanted);
+  if (chosen === void 0) return void 0;
+  const last_line = extent_of(markdown, chosen);
+  const lines = markdown.split("\n").slice(chosen.line, last_line + SINGLE_MATCH);
+  return {
+    title: chosen.title,
+    level: chosen.level,
+    first_line: chosen.line,
+    last_line,
+    text: lines.join("\n")
+  };
+}
+function candidates(markdown, wanted) {
+  const near = prefixed(headings(markdown), wanted);
+  const listed = near.length > 0 ? near : prefixed(labels(markdown), wanted);
+  return listed.map((heading) => heading.title);
+}
+function read_optional2(file_path) {
+  return file_reader.read_if_readable(file_path);
+}
+var document_section = {
+  candidates,
+  fenced_flags,
+  headings,
+  read_optional: read_optional2,
+  section,
+  titles
+};
+
+// scripts/init/distributed-paths.ts
+var KIT_PACKAGE_PATH_PREFIX = "node_modules/@joshuafolkken/kit/";
+var PROMPTS_PACKAGE_PREFIX = `${KIT_PACKAGE_PATH_PREFIX}prompts/`;
+var ESLINT_PACKAGE_PREFIX = `${KIT_PACKAGE_PATH_PREFIX}eslint/`;
+var GITHUB_REPO_BLOB_BASE = "https://github.com/joshuafolkken/kit/blob/main/";
+var GITHUB_REPO_TREE_BASE = "https://github.com/joshuafolkken/kit/tree/main/";
+var CLAUDE_MD_IMPORT_LINE = "@node_modules/@joshuafolkken/kit/dist/CLAUDE.md";
+var OLD_CLAUDE_MD_BOOTSTRAP = "> Fresh checkout: if kit is not installed, run `pnpm install` first, then reread this file before doing any other work.";
+var CLAUDE_MD_BOOTSTRAP = '> Fresh checkout: before `pnpm install`, run `pnpm config get "@joshuafolkken:registry"` from the project root to check the effective registry, including user-level settings. If it points to GitHub Packages, [set up authentication](https://github.com/joshuafolkken/kit/blob/main/docs/authentication.md#1-get-a-token-from-the-gh-cli) first. Then run `pnpm install` and reread this file before doing any other work.';
+function transform_prompt_paths(content) {
+  return content.replaceAll(
+    /`prompts\/([^`*]+)`/gu,
+    (_match, prompt_path) => `\`${PROMPTS_PACKAGE_PREFIX}${prompt_path}\``
+  );
+}
+function transform_eslint_paths(content) {
+  return content.replaceAll(
+    /`eslint\/([^`*]+)`/gu,
+    (_match, eslint_path) => `\`${ESLINT_PACKAGE_PREFIX}${eslint_path}\``
+  );
+}
+function transform_test_file_paths(content) {
+  return content.replaceAll(
+    /`([^`*]+\.(?:test|spec)\.ts)`/gu,
+    (_match, test_path) => `\`${GITHUB_REPO_BLOB_BASE}${test_path}\``
+  );
+}
+function github_url_base(reference_path) {
+  return reference_path.endsWith("/") ? GITHUB_REPO_TREE_BASE : GITHUB_REPO_BLOB_BASE;
+}
+function transform_documentation_paths(content) {
+  return content.replaceAll(
+    /`(docs\/[^`*]*)`/gu,
+    (_match, documentation_path) => `\`${github_url_base(documentation_path)}${documentation_path}\``
+  );
+}
+function transform_distributed_paths(content) {
+  const with_prompts = transform_prompt_paths(content);
+  const with_eslint = transform_eslint_paths(with_prompts);
+  const with_tests = transform_test_file_paths(with_eslint);
+  return transform_documentation_paths(with_tests);
+}
+function ensure_claude_md_import(existing) {
+  if (existing === void 0) return `${CLAUDE_MD_BOOTSTRAP}
+
+${CLAUDE_MD_IMPORT_LINE}
+`;
+  const updated = existing.replace(OLD_CLAUDE_MD_BOOTSTRAP, () => CLAUDE_MD_BOOTSTRAP);
+  if (updated.includes(CLAUDE_MD_IMPORT_LINE)) {
+    if (updated.includes(CLAUDE_MD_BOOTSTRAP)) return updated;
+    return `${CLAUDE_MD_BOOTSTRAP}
+
+${updated}`;
+  }
+  return `${CLAUDE_MD_BOOTSTRAP}
+
+${CLAUDE_MD_IMPORT_LINE}
+
+${updated}`;
+}
+var FULL_CLAUDE_MD_LINES = /* @__PURE__ */ new Set([
+  CLAUDE_MD_BOOTSTRAP,
+  OLD_CLAUDE_MD_BOOTSTRAP,
+  CLAUDE_MD_IMPORT_LINE
+]);
+function remove_claude_md_import(content) {
+  const lines = content.split("\n");
+  return lines.filter((line, index) => {
+    if (FULL_CLAUDE_MD_LINES.has(line)) return false;
+    return line !== "" || !FULL_CLAUDE_MD_LINES.has(lines[index - 1] ?? "");
+  }).join("\n");
+}
+var distributed_paths = {
+  transform_prompt_paths,
+  transform_distributed_paths,
+  ensure_claude_md_import,
+  remove_claude_md_import,
+  CLAUDE_MD_IMPORT_LINE,
+  KIT_PACKAGE_PATH_PREFIX
+};
+
+// scripts/josh/package-directory.ts
+import { existsSync } from "node:fs";
+
+// scripts/lib/ancestor-directories.ts
+import path from "node:path";
+var MAX_DEPTH = 64;
+function list(start_directory) {
+  const directories = [];
+  let current = path.resolve(start_directory);
+  while (directories.length < MAX_DEPTH && !directories.includes(current)) {
+    directories.push(current);
+    current = path.dirname(current);
+  }
+  return directories;
+}
+function nearest(start_directory, is_match2) {
+  return list(start_directory).find((directory) => is_match2(directory));
+}
+var ancestor_directories = { list, nearest };
+
+// scripts/lib/package-manifest.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import path2 from "node:path";
+
+// scripts/lib/json-value.ts
+function parse_or_undefined(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function parse_with(text, schema) {
+  const value = parse_or_undefined(text);
+  if (value === void 0) return void 0;
+  const parsed = schema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
+}
+function parse_array(text) {
+  const value = parse_or_undefined(text);
+  return Array.isArray(value) ? value : void 0;
+}
+function is_record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var json_value = { parse_or_undefined, parse_with, parse_array, is_record };
+
+// scripts/lib/package-manifest.ts
+var PACKAGE_JSON = "package.json";
+function manifest_path(directory) {
+  return path2.join(directory, PACKAGE_JSON);
+}
+function read_manifest(directory, schema) {
+  const text = readFileSync2(manifest_path(directory), "utf8");
+  return schema.parse(JSON.parse(text));
+}
+function read_manifest_if_valid(directory, schema) {
+  const text = file_reader.read_if_readable(manifest_path(directory));
+  if (text === void 0) return void 0;
+  return json_value.parse_with(text, schema);
+}
+var package_manifest = { manifest_path, read_manifest, read_manifest_if_valid };
+
+// scripts/josh/package-directory.ts
+function find_package_directory(start_directory) {
+  return ancestor_directories.nearest(
+    start_directory,
+    (directory) => existsSync(package_manifest.manifest_path(directory))
+  ) ?? start_directory;
+}
+
+// scripts/josh/stamp-file.ts
+import { createHash } from "node:crypto";
+import { lstatSync, readFileSync as readFileSync3, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import path5 from "node:path";
+
+// scripts/init/init-paths.ts
+import path3 from "node:path";
+import { fileURLToPath } from "node:url";
+var PACKAGE_DIR = path3.join(path3.dirname(fileURLToPath(import.meta.url)), "..", "..");
+var PROJECT_ROOT = process.cwd();
+
+// 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 resolve_temporary_root(platform, can_write = is_writable_directory) {
+  if (platform === WINDOWS_PLATFORM) return tmpdir();
+  return can_write(POSIX_TEMP_ROOT) ? POSIX_TEMP_ROOT : tmpdir();
+}
+var TEMP_ROOT_KEY = "JOSH_TEMP_ROOT";
+function temporary_root(override, platform) {
+  return override === void 0 || override === "" ? resolve_temporary_root(platform) : override;
+}
+var PLATFORM_TEMP_ROOT = temporary_root(process.env[TEMP_ROOT_KEY], process.platform);
+
+// scripts/lib/atomic-write.ts
+import { randomUUID } from "node:crypto";
+import { chmodSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import path4 from "node:path";
+var STAGING_EXTENSION = ".tmp";
+var CREATE_EXCLUSIVE_FLAG = "wx";
+function staging_path(target, staging_directory) {
+  const name = `${path4.basename(target)}.${String(process.pid)}.${randomUUID()}${STAGING_EXTENSION}`;
+  return path4.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 replace_file(target, content, options = {}) {
+  const directory = options.staging_directory ?? path4.dirname(target);
+  const staging = staging_path(target, directory);
+  mkdirSync(directory, { recursive: true });
+  try {
+    write_staged(staging, content, options.mode);
+    renameSync(staging, target);
+  } finally {
+    rmSync(staging, { force: true });
+  }
+}
+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, root = PACKAGE_DIR, suffix = STAMP_SUFFIX) {
+  const key = digest(`${account_key()}${ACCOUNT_KEY_SEPARATOR}${root}`).slice(0, STAMP_KEY_LENGTH);
+  return `${prefix}${key}${suffix}`;
+}
+function stamp_path(prefix, root = PACKAGE_DIR, suffix = STAMP_SUFFIX) {
+  return path5.join(PLATFORM_TEMP_ROOT, stamp_name(prefix, root, suffix));
+}
+function write_exclusively(target, content) {
+  rmSync2(target, { force: true });
+  writeFileSync2(target, content, { flag: STAMP_WRITE_FLAG, mode: STAMP_FILE_MODE });
+  return target;
+}
+function write_stamp(target, payload) {
+  return write_exclusively(target, 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(target) {
+  try {
+    return lstatSync(target).isFile() && !is_own_regular_file(target);
+  } catch {
+    return false;
+  }
+}
+function replace_text_stamp(target, text) {
+  if (is_foreign_file(target)) {
+    throw new Error(`refusing to replace another account's file: ${target}`);
+  }
+  atomic_write.replace_file(target, text, { mode: STAMP_FILE_MODE });
+  return target;
+}
+function replace_stamp(target, payload) {
+  return replace_text_stamp(target, JSON.stringify(payload));
+}
+function write_text_stamp(target, text) {
+  return write_exclusively(target, text);
+}
+function create_stamp(target, payload) {
+  try {
+    writeFileSync2(target, 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;
+  }
+}
+function remove_stamp(target) {
+  rmSync2(target, { force: true });
+}
+function read_stamp_text(source) {
+  try {
+    if (!is_own_regular_file(source)) return void 0;
+    return readFileSync3(source, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+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/agent/lane-instructions.ts
+var LANE_DOCUMENT = "prompts/collaboration-workflow/lane-instructions.md";
+var RULES_FILE = "CLAUDE.md";
+var POINTER_FILE = "AGENTS.md";
+var INCLUDE_PATTERN = /^<!-- include: CLAUDE\.md → "(?<wanted>.+)" -->$/u;
+var PROMPT_FILE_FLAG = "--append-system-prompt-file";
+var SETTINGS_FLAG = "--settings";
+var PROMPT_FILE_PREFIX = "josh-lane-instructions-";
+var PROMPT_FILE_SUFFIX = ".md";
+var PACKAGE_DIRECTORY = find_package_directory(path6.dirname(fileURLToPath2(import.meta.url)));
+function expand_line(line, rules) {
+  const wanted = INCLUDE_PATTERN.exec(line)?.groups?.["wanted"];
+  if (wanted === void 0) return line;
+  return document_section.section(rules, wanted)?.text;
+}
+function compose(lane_markdown, rules) {
+  const expanded = lane_markdown.split("\n").map((line) => expand_line(line, rules));
+  if (expanded.includes(void 0)) return void 0;
+  return expanded.join("\n");
+}
+function rules_sources(cwd) {
+  const imported = distributed_paths.CLAUDE_MD_IMPORT_LINE.replace(/^@/u, "");
+  return [path6.join(cwd, RULES_FILE), path6.join(cwd, imported)];
+}
+function composed_from(lane_markdown, rules_path) {
+  const rules = document_section.read_optional(rules_path);
+  return rules === void 0 ? void 0 : compose(lane_markdown, rules);
+}
+function composed_set(cwd, package_directory) {
+  const lane_markdown = document_section.read_optional(path6.join(package_directory, LANE_DOCUMENT));
+  if (lane_markdown === void 0) return void 0;
+  for (const rules_path of rules_sources(cwd)) {
+    const text = composed_from(lane_markdown, rules_path);
+    if (text !== void 0) return { text, rules_path };
+  }
+  return void 0;
+}
+function composed_in(cwd, package_directory = PACKAGE_DIRECTORY) {
+  return composed_set(cwd, package_directory)?.text;
+}
+function written(text) {
+  const file_path = stamp_file.stamp_path(PROMPT_FILE_PREFIX, text, PROMPT_FILE_SUFFIX);
+  if (stamp_file.read_stamp_text(file_path) === text) return file_path;
+  try {
+    return stamp_file.replace_text_stamp(file_path, text);
+  } catch {
+    return void 0;
+  }
+}
+function excluded_settings(rules_path, cwd) {
+  return JSON.stringify({ claudeMdExcludes: [rules_path, path6.join(cwd, POINTER_FILE)] });
+}
+function flags(cwd = process.cwd()) {
+  const set = composed_set(cwd, PACKAGE_DIRECTORY);
+  const prompt_file = set === void 0 ? void 0 : written(set.text);
+  if (set === void 0 || prompt_file === void 0) return [];
+  return [PROMPT_FILE_FLAG, prompt_file, SETTINGS_FLAG, excluded_settings(set.rules_path, cwd)];
+}
+function tokens_of(text) {
+  return cost_tokens.estimate(text).toLocaleString("en-US");
+}
+function rules_tokens(rules_path) {
+  return tokens_of(document_section.read_optional(rules_path) ?? "");
+}
+function resident_line(cwd = process.cwd()) {
+  const set = composed_set(cwd, PACKAGE_DIRECTORY);
+  const rules = rules_tokens(set?.rules_path ?? path6.join(cwd, RULES_FILE));
+  const lane_tokens = set === void 0 ? "not composed" : `${tokens_of(set.text)} tok`;
+  return `  resident: lane instructions ${lane_tokens} in place of ${RULES_FILE} ${rules} tok`;
+}
+var lane_instructions = {
+  PROMPT_FILE_FLAG,
+  SETTINGS_FLAG,
+  compose,
+  composed_in,
+  flags,
+  resident_line
+};
+
+// scripts/document/entry-read-set.ts
+import { existsSync as existsSync2 } from "node:fs";
+import path8 from "node:path";
+
+// scripts/document/bash-output-cap.ts
+import path7 from "node:path";
+var SETTINGS_FILE = path7.join(".claude", "settings.json");
+var HARNESS_DEFAULT_CAP_CHARS = 3e4;
+var ENV_KEY = "env";
+var CAP_KEY = "BASH_MAX_OUTPUT_LENGTH";
+var NONE = 0;
+function property_of(value, key) {
+  if (typeof value !== "object" || value === null) return void 0;
+  return Reflect.get(value, key);
+}
+function declared_cap(text) {
+  try {
+    return property_of(property_of(JSON.parse(text), ENV_KEY), CAP_KEY);
+  } catch {
+    return void 0;
+  }
+}
+function bash_output_cap(root) {
+  const text = document_section.read_optional(path7.join(root, SETTINGS_FILE)) ?? "";
+  const chars = Number(declared_cap(text));
+  return Number.isSafeInteger(chars) && chars > NONE ? chars : HARNESS_DEFAULT_CAP_CHARS;
+}
+var bash_output_cap_reader = { HARNESS_DEFAULT_CAP_CHARS, bash_output_cap };
+
+// scripts/document/read-set-cost.ts
+var NOTHING = 0;
+var ONE_LINE = 1;
+function cost_of(text) {
+  return { bytes: Buffer.byteLength(text, "utf8"), tokens: cost_tokens.estimate(text) };
+}
+function total(costs) {
+  const running = { bytes: NOTHING, tokens: NOTHING };
+  for (const cost of costs) {
+    running.bytes += cost.bytes;
+    running.tokens += cost.tokens;
+  }
+  return running;
+}
+function add_range(charged, found) {
+  for (let index = found.first_line; index <= found.last_line; index += ONE_LINE) charged.add(index);
+}
+function charged_lines(markdown, headings2) {
+  const charged = /* @__PURE__ */ new Set();
+  for (const heading of headings2) {
+    const found = document_section.section(markdown, heading);
+    if (found === void 0) return void 0;
+    add_range(charged, found);
+  }
+  return charged;
+}
+function extend_or_start(runs, index) {
+  const current = runs.at(-1);
+  if (current?.at(-1) === index - ONE_LINE) current.push(index);
+  else runs.push([index]);
+}
+function contiguous_runs(charged) {
+  const runs = [];
+  const ascending = [...charged].toSorted((left, right) => left - right);
+  for (const index of ascending) extend_or_start(runs, index);
+  return runs;
+}
+function run_text(lines, run2) {
+  return run2.map((index) => lines[index] ?? "").join("\n");
+}
+function scoped_file_cost(markdown, headings2) {
+  const charged = charged_lines(markdown, headings2);
+  if (charged === void 0) return cost_of(markdown);
+  const lines = markdown.split("\n");
+  return total(contiguous_runs(charged).map((run2) => cost_of(run_text(lines, run2))));
+}
+var read_set_cost = { cost_of, scoped_file_cost, total };
+
+// scripts/document/read-set-point-of-use.ts
+var POINT_OF_USE_FILES = /* @__PURE__ */ new Set([
+  "latest-gate.md",
+  "followup.md",
+  "chain-rule.md",
+  "background-commands.md",
+  "pre-gate-cut.md",
+  "progress-watcher.md",
+  "backlogrun-child.md",
+  "backlogrun-lanes.md",
+  "backlogrun-progress.md",
+  "backlogrun-park.md",
+  "backlogrun-steps.md",
+  // Read only when a delegated unit goes silent or a lane's pull request conflicts with `main` — a
+  // failure path, so a run in which nothing fails never reads it.
+  "backlogrun-recovery.md",
+  // Read only when `run:step` prints `pnpm josh retrospective` at a run's stop position — the very
+  // end of a run, never the entry. Kept out of every entry's read for the
+  // same reason the phase documents above are: no run that never drains its backlog reaches it.
+  "retrospective.md"
+]);
+var DEFERRED_DECISIONS = /* @__PURE__ */ new Set(["delegation.md", "issue-scout.md"]);
+var POINT_OF_USE_BY_ENTRY = /* @__PURE__ */ new Map([
+  ["kickoff", DEFERRED_DECISIONS],
+  ["fullrun", DEFERRED_DECISIONS],
+  ["halfrun", DEFERRED_DECISIONS],
+  ["prrun", DEFERRED_DECISIONS],
+  ["backlogrun", /* @__PURE__ */ new Set([...DEFERRED_DECISIONS, "fullrun.md", "split-assessment.md"])]
+]);
+var NO_PER_ENTRY_FILES = /* @__PURE__ */ new Set();
+function is_point_of_use(entry, file) {
+  if (POINT_OF_USE_FILES.has(file)) return true;
+  return (POINT_OF_USE_BY_ENTRY.get(entry) ?? NO_PER_ENTRY_FILES).has(file);
+}
+function point_of_use_files(entry, cited) {
+  const reached = [...POINT_OF_USE_FILES].filter((file) => cited.has(file));
+  return [...reached, ...POINT_OF_USE_BY_ENTRY.get(entry) ?? NO_PER_ENTRY_FILES];
+}
+var read_set_point_of_use = {
+  POINT_OF_USE_FILES,
+  POINT_OF_USE_BY_ENTRY,
+  is_point_of_use,
+  point_of_use_files
+};
+
+// scripts/document/entry-read-set.ts
+var { POINT_OF_USE_FILES: POINT_OF_USE_FILES2, POINT_OF_USE_BY_ENTRY: POINT_OF_USE_BY_ENTRY2, is_point_of_use: is_point_of_use2, point_of_use_files: point_of_use_files2 } = read_set_point_of_use;
+var { cost_of: cost_of2, scoped_file_cost: scoped_file_cost2, total: total2 } = read_set_cost;
+var SKILL_DIRECTORY = path8.join(".claude", "skills", "workflow-commands");
+var SKILL_FILE = "SKILL.md";
+var TABLE_SECTION = "1. Which file to read";
+var NOTHING2 = 0;
+var HEADING_JOINER = '" + "';
+var SUBSECTION_PREFIX = "### ";
+var TABLE_ROW = /^\|(?<entry>[^|]+)\|(?<files>[^|]+)\|\s*$/u;
+var MARKDOWN_NAME = /`(?<name>[\w.-]+\.md)`/gu;
+var ENTRY_KEYWORD = /`(?<keyword>[a-z]+)/u;
+var SECTION_REFERENCE = /`(?<file>[\w.-]+\.md)` *→ *"(?<heading>[^"]+)"/gu;
+var WHITESPACE_RUN = /\s+/gu;
+function document_path(root, name) {
+  const in_project = path8.join(root, SKILL_DIRECTORY, name);
+  const in_package = path8.join(PACKAGE_DIR, SKILL_DIRECTORY, name);
+  const project_manifest = path8.join(root, "package.json");
+  if (root !== "" && existsSync2(project_manifest) && existsSync2(in_package)) return in_package;
+  return existsSync2(in_project) ? in_project : in_package;
+}
+function read_document(root, name) {
+  return document_section.read_optional(document_path(root, name)) ?? "";
+}
+function unique(names) {
+  return [...new Set(names)];
+}
+function all_matches(text, pattern) {
+  const scanner = new RegExp(pattern.source, pattern.flags);
+  const found = [];
+  let match = scanner.exec(text);
+  while (match !== null) {
+    found.push(match);
+    match = scanner.exec(text);
+  }
+  return found;
+}
+function group_of(match, name) {
+  return match.groups?.[name] ?? "";
+}
+function names_in(text) {
+  return all_matches(text, MARKDOWN_NAME).map((match) => group_of(match, "name"));
+}
+function columns_of(line) {
+  const groups = TABLE_ROW.exec(line)?.groups;
+  if (groups === void 0) return void 0;
+  const { entry = "", files = "" } = groups;
+  return { entry, files };
+}
+function to_row(line) {
+  const columns = columns_of(line);
+  if (columns === void 0) return void 0;
+  const { keyword } = ENTRY_KEYWORD.exec(columns.entry)?.groups ?? {};
+  return keyword === void 0 ? void 0 : { keyword, files: names_in(columns.files) };
+}
+function push_row(rows, line) {
+  const row2 = to_row(line);
+  if (row2 !== void 0 && row2.files.length > NOTHING2) rows.set(row2.keyword, row2.files);
+}
+function table_rows(root) {
+  const rows = /* @__PURE__ */ new Map();
+  const found = document_section.section(read_document(root, SKILL_FILE), TABLE_SECTION);
+  const lines = (found?.text ?? "").split("\n");
+  for (const line of lines) {
+    if (line.startsWith(SUBSECTION_PREFIX)) break;
+    push_row(rows, line);
+  }
+  return rows;
+}
+function files_for(root, entry) {
+  const declared = table_rows(root).get(entry) ?? [];
+  return unique([SKILL_FILE, ...declared]).filter((file) => !is_point_of_use2(entry, file));
+}
+function fold(text) {
+  return text.replaceAll(WHITESPACE_RUN, " ").trim();
+}
+function is_sibling_document(root, name) {
+  return document_section.read_optional(document_path(root, name)) !== void 0;
+}
+function is_counted(root, entry, reference, files) {
+  if (is_point_of_use2(entry, reference.file)) return false;
+  return !files.includes(reference.file) && is_sibling_document(root, reference.file);
+}
+function to_reference(match) {
+  return { file: group_of(match, "file"), heading: fold(group_of(match, "heading")) };
+}
+function references_from(root, entry, text, files) {
+  return all_matches(text, SECTION_REFERENCE).map((match) => to_reference(match)).filter((reference) => is_counted(root, entry, reference, files));
+}
+function sort_key(reference) {
+  return `${reference.file} ${reference.heading}`;
+}
+function dedupe(references) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const reference of references) seen.set(sort_key(reference), reference);
+  return [...seen].map(([, reference]) => reference);
+}
+function sections_for(root, entry, files) {
+  const found = files.filter((file) => file !== SKILL_FILE).flatMap((file) => references_from(root, entry, read_document(root, file), files));
+  return dedupe(found).toSorted((left, right) => sort_key(left).localeCompare(sort_key(right)));
+}
+function read_set(root, entry) {
+  const files = files_for(root, entry);
+  return { entry, files, sections: sections_for(root, entry, files) };
+}
+function section_cost(root, reference) {
+  const found = document_section.section(read_document(root, reference.file), reference.heading);
+  return {
+    ...reference,
+    // **An unresolvable reference is charged at the whole file.** Reporting it at zero would let a
+    // broken pointer read as a saving, which is the one direction this measurement must not move.
+    cost: cost_of2(found?.text ?? read_document(root, reference.file)),
+    is_resolved: found !== void 0
+  };
+}
+function referenced_cost(root, sections) {
+  const files = unique(sections.map((reference) => reference.file));
+  return total2(files.map((file) => cost_of2(read_document(root, file))));
+}
+function headings_for(sections, file) {
+  return sections.filter((reference) => reference.file === file).map((one) => one.heading);
+}
+function scoped_cost(root, sections) {
+  const files = unique(sections.map((reference) => reference.file));
+  return total2(
+    files.map((file) => scoped_file_cost2(read_document(root, file), headings_for(sections, file)))
+  );
+}
+function file_costs(root, names) {
+  return names.map((file) => ({ file, cost: cost_of2(read_document(root, file)) }));
+}
+function point_of_use_cost(root, file, references) {
+  const markdown = read_document(root, file);
+  const headings2 = unique(references.filter((one) => one.file === file).map((one) => one.heading));
+  if (headings2.length === NOTHING2) {
+    return { file, heading: "", cost: cost_of2(markdown), is_resolved: true };
+  }
+  return {
+    file,
+    heading: headings2.join(HEADING_JOINER),
+    cost: scoped_file_cost2(markdown, headings2),
+    is_resolved: headings2.every(
+      (heading) => document_section.section(markdown, heading) !== void 0
+    )
+  };
+}
+function path_texts(root, entry, table_text) {
+  const manifests = files_for(root, entry).filter((file) => file !== SKILL_FILE);
+  const rows = table_text.split("\n").filter((line) => line.startsWith("|") && line.includes(`\`${entry}\``));
+  return [...manifests.map((file) => read_document(root, file)), ...rows];
+}
+function point_of_use_references(root, entry, table_text) {
+  const manifests = files_for(root, entry).filter((file) => file !== SKILL_FILE);
+  const texts = [table_text, ...manifests.map((file) => read_document(root, file))];
+  return texts.flatMap(
+    (text) => all_matches(text, SECTION_REFERENCE).map((match) => to_reference(match))
+  );
+}
+function point_of_use_costs(root, entry, also) {
+  const table_text = document_section.section(read_document(root, SKILL_FILE), TABLE_SECTION)?.text ?? "";
+  const references = point_of_use_references(root, entry, table_text);
+  const named = path_texts(root, entry, table_text).flatMap((text) => names_in(text));
+  const cited = /* @__PURE__ */ new Set([...also, ...named]);
+  return point_of_use_files2(entry, cited).map((file) => point_of_use_cost(root, file, references));
+}
+function costed(root, entry, also = /* @__PURE__ */ new Set()) {
+  const { files, sections } = read_set(root, entry);
+  const own_costs = file_costs(root, files);
+  const section_costs = sections.map((reference) => section_cost(root, reference));
+  const own = total2(own_costs.map((row2) => row2.cost));
+  return {
+    entry,
+    files: own_costs,
+    sections: section_costs,
+    point_of_use: point_of_use_costs(root, entry, also),
+    bash_output_cap: bash_output_cap_reader.bash_output_cap(root),
+    whole: total2([own, referenced_cost(root, sections)]),
+    scoped: total2([own, scoped_cost(root, sections)])
+  };
+}
+function entries(root) {
+  return [...table_rows(root)].map(([keyword]) => keyword);
+}
+var entry_read_set = {
+  HARNESS_DEFAULT_CAP_CHARS: bash_output_cap_reader.HARNESS_DEFAULT_CAP_CHARS,
+  POINT_OF_USE_BY_ENTRY: POINT_OF_USE_BY_ENTRY2,
+  POINT_OF_USE_FILES: POINT_OF_USE_FILES2,
+  SECTION_REFERENCE,
+  SKILL_DIRECTORY,
+  SKILL_FILE,
+  TABLE_SECTION,
+  bash_output_cap: bash_output_cap_reader.bash_output_cap,
+  cost_of: cost_of2,
+  costed,
+  document_path,
+  entries,
+  read_set,
+  total: total2
+};
+
+// scripts/document/read-set-trim.ts
+function subtract(left, right) {
+  return { bytes: left.bytes - right.bytes, tokens: left.tokens - right.tokens };
+}
+function skill_text(root) {
+  const path9 = entry_read_set.document_path(root, entry_read_set.SKILL_FILE);
+  return document_section.read_optional(path9) ?? "";
+}
+function section_cost2(text, heading) {
+  return entry_read_set.cost_of(document_section.section(text, heading)?.text ?? "");
+}
+function unused_skill_cost(root, sections) {
+  const text = skill_text(root);
+  return entry_read_set.total(sections.map((heading) => section_cost2(text, heading)));
+}
+function reduce_skill(file, saving) {
+  if (file.file !== entry_read_set.SKILL_FILE) return file;
+  return { file: file.file, cost: subtract(file.cost, saving) };
+}
+function costed2(root, spec) {
+  const base = entry_read_set.costed(root, spec.base_entry, spec.reached_point_of_use);
+  const saving = unused_skill_cost(root, spec.unused_skill_sections);
+  return {
+    ...base,
+    entry: spec.label,
+    files: base.files.map((file) => reduce_skill(file, saving)),
+    point_of_use: base.point_of_use.filter((one) => !spec.skipped_point_of_use.has(one.file)),
+    whole: subtract(base.whole, saving),
+    scoped: subtract(base.scoped, saving)
+  };
+}
+var read_set_trim = { costed: costed2 };
+
+// scripts/document/backlogrun-parent-read-set.ts
+var BACKLOGRUN = "backlogrun";
+var UNUSED_SKILL_SECTIONS = [
+  "3. What stays resident, and what is read from here"
+];
+var SKIPPED_POINT_OF_USE = /* @__PURE__ */ new Set();
+var REACHED_POINT_OF_USE = /* @__PURE__ */ new Set([
+  "retrospective.md",
+  "backlogrun-recovery.md"
+]);
+function costed3(root) {
+  return read_set_trim.costed(root, {
+    base_entry: BACKLOGRUN,
+    label: BACKLOGRUN,
+    unused_skill_sections: UNUSED_SKILL_SECTIONS,
+    skipped_point_of_use: SKIPPED_POINT_OF_USE,
+    reached_point_of_use: REACHED_POINT_OF_USE
+  });
+}
+var backlogrun_parent_read_set = {
+  BACKLOGRUN,
+  REACHED_POINT_OF_USE,
+  UNUSED_SKILL_SECTIONS,
+  costed: costed3
+};
+
+// scripts/document/lane-child-read-set.ts
+var LANE_CHILD = "lane-child";
+var FULLRUN = "fullrun";
+var UNUSED_SKILL_SECTIONS2 = [
+  "0. The rule that fires before any of them \u2014 explicit invocation",
+  "3. What stays resident, and what is read from here"
+];
+var SKIPPED_POINT_OF_USE2 = /* @__PURE__ */ new Set([
+  "backlogrun-child.md",
+  "backlogrun-lanes.md",
+  "backlogrun-progress.md",
+  "backlogrun-steps.md",
+  "delegation.md",
+  "issue-scout.md",
+  "latest-gate.md",
+  "progress-watcher.md",
+  "retrospective.md"
+]);
+var REACHED_POINT_OF_USE2 = /* @__PURE__ */ new Set(["backlogrun-park.md", "pre-gate-cut.md"]);
+function costed4(root) {
+  return read_set_trim.costed(root, {
+    base_entry: FULLRUN,
+    label: LANE_CHILD,
+    unused_skill_sections: UNUSED_SKILL_SECTIONS2,
+    skipped_point_of_use: SKIPPED_POINT_OF_USE2,
+    reached_point_of_use: REACHED_POINT_OF_USE2
+  });
+}
+var lane_child_read_set = {
+  LANE_CHILD,
+  REACHED_POINT_OF_USE: REACHED_POINT_OF_USE2,
+  SKIPPED_POINT_OF_USE: SKIPPED_POINT_OF_USE2,
+  UNUSED_SKILL_SECTIONS: UNUSED_SKILL_SECTIONS2,
+  costed: costed4
+};
+
+// scripts/agent/agent-role-profile.ts
+import { z as z2 } from "zod";
+
+// scripts/josh/agent-session-environment.ts
+var SESSION_ID_KEY = "CLAUDE_CODE_SESSION_ID";
+var AGENT_PID_KEY = "CLAUDE_PID";
+var PARENT_SESSION_KEYS = [
+  "CLAUDE_CODE_MESSAGING_SOCKET",
+  "CLAUDE_CODE_MESSAGING_TOKEN",
+  SESSION_ID_KEY,
+  "CLAUDE_CODE_CHILD_SESSION"
+];
+var PROXY_KEYS = [
+  "ALL_PROXY",
+  "HTTP_PROXY",
+  "HTTPS_PROXY",
+  "all_proxy",
+  "http_proxy",
+  "https_proxy",
+  "GLOBAL_AGENT_HTTP_PROXY",
+  "GLOBAL_AGENT_HTTPS_PROXY"
+];
+var PROXY_CERTIFICATE_KEY = "NODE_EXTRA_CA_CERTS";
+var LOOPBACK_HOSTS = ["localhost", "ip6-localhost", "[::1]"];
+var LOOPBACK_PREFIX = "127.";
+var NO_HOST = "";
+function parsed_host(value) {
+  try {
+    return new URL(value).hostname;
+  } catch {
+    return NO_HOST;
+  }
+}
+function proxy_host(value) {
+  const direct = parsed_host(value);
+  return direct === NO_HOST ? parsed_host(`http://${value}`) : direct;
+}
+function is_loopback_host(host) {
+  return host.startsWith(LOOPBACK_PREFIX) || LOOPBACK_HOSTS.includes(host);
+}
+function is_loopback_proxy(value) {
+  if (value === void 0 || value === NO_HOST) return false;
+  return is_loopback_host(proxy_host(value));
+}
+function is_declared(value) {
+  return value !== void 0 && value !== NO_HOST;
+}
+function loopback_proxy_keys(source, is_removed = is_loopback_proxy) {
+  const declared = PROXY_KEYS.filter((key) => is_declared(source[key]));
+  const matched = declared.filter((key) => is_removed(source[key]));
+  const is_certificate_included = matched.length > 0 && matched.length === declared.length;
+  return is_certificate_included ? [...matched, PROXY_CERTIFICATE_KEY] : matched;
+}
+function to_removed(keys) {
+  return Object.fromEntries(keys.map((key) => [key, void 0]));
+}
+function removed_environment(source = process.env) {
+  return to_removed([...PARENT_SESSION_KEYS, ...loopback_proxy_keys(source)]);
+}
+var SCANNER_DIRECTORY = ".safe-chain";
+var PATH_SEPARATOR = /[/\\]/u;
+function is_scanner_certificate(value) {
+  return value?.split(PATH_SEPARATOR).includes(SCANNER_DIRECTORY) ?? false;
+}
+var SCANNER_PROXY_KEY = "HTTPS_PROXY";
+function is_scanner_proxy(source) {
+  const scanner_proxy = source[SCANNER_PROXY_KEY];
+  return function is_match2(value) {
+    return value === scanner_proxy && is_loopback_proxy(value);
+  };
+}
+function removed_proxy_environment(source = process.env) {
+  if (!is_scanner_certificate(source[PROXY_CERTIFICATE_KEY])) return {};
+  return to_removed(loopback_proxy_keys(source, is_scanner_proxy(source)));
+}
+var agent_session_environment = {
+  AGENT_PID_KEY,
+  LOOPBACK_HOSTS,
+  PARENT_SESSION_KEYS,
+  PROXY_CERTIFICATE_KEY,
+  PROXY_KEYS,
+  SESSION_ID_KEY,
+  removed_environment,
+  removed_proxy_environment
+};
+
+// scripts/agent/agent-provider.ts
+import { z } from "zod";
+var EMPTY_LENGTH = 0;
+var PROVIDER_SCHEMA = z.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/agent/agent-safe-text.ts
+var FIRST_PRINTABLE_CODE = 32;
+var DELETE_CODE = 127;
+var FIRST_CODE_POINT = 0;
+var EMPTY_LENGTH2 = 0;
+var MAX_VALUE_LENGTH = 4096;
+var MAX_PROMPT_LENGTH = 65536;
+var LINE_FEED = "\n";
+var SPACE = " ";
+function is_control_character(character) {
+  const code = character.codePointAt(FIRST_CODE_POINT) ?? FIRST_PRINTABLE_CODE;
+  return code < FIRST_PRINTABLE_CODE || code === DELETE_CODE;
+}
+function is_line_feed(character) {
+  return character === LINE_FEED;
+}
+function is_never_allowed() {
+  return false;
+}
+function is_refused(character, is_allowed) {
+  return is_control_character(character) && !is_allowed(character);
+}
+function is_safe_text(value, is_allowed, max_length) {
+  if (value.length === EMPTY_LENGTH2 || value.length > max_length) return false;
+  for (const character of value) if (is_refused(character, is_allowed)) return false;
+  return true;
+}
+function is_safe_value(value) {
+  return is_safe_text(value, is_never_allowed, MAX_VALUE_LENGTH);
+}
+function is_safe_prompt(value) {
+  return is_safe_text(value, is_line_feed, MAX_PROMPT_LENGTH);
+}
+function printable_character(character) {
+  return is_refused(character, is_line_feed) ? SPACE : character;
+}
+function printable(text) {
+  return Array.from(text, printable_character).join("");
+}
+var agent_safe_text = {
+  MAX_PROMPT_LENGTH,
+  MAX_VALUE_LENGTH,
+  is_safe_prompt,
+  is_safe_value,
+  printable
+};
+
+// scripts/agent/agent-role-profile.ts
+var {
+  ANTHROPIC_PROVIDER: ANTHROPIC_PROVIDER2,
+  CODEX_SESSION_KEY: CODEX_SESSION_KEY2,
+  HANDED_PROVIDER_KEY: HANDED_PROVIDER_KEY2,
+  OPENAI_PROVIDER: OPENAI_PROVIDER2,
+  PROVIDER_SCHEMA: PROVIDER_SCHEMA2,
+  default_notice: default_notice2,
+  handoff_environment: handoff_environment2,
+  has_completion_callback: has_completion_callback2,
+  rejection: rejection2,
+  resolve_provider: resolve_provider2,
+  trimmed: trimmed2,
+  warn_of_default: warn_of_default2
+} = agent_provider;
+var ROLE_SCHEMA = z2.enum(["scheduler", "worker", "reviewer"]);
+var EFFORT_SCHEMA = z2.enum(["low", "medium", "high", "xhigh", "max"]);
+var PHASE_SCHEMA = z2.enum(["implementation", "pre-gate"]);
+var PROFILE_SCHEMA = z2.object({
+  provider: PROVIDER_SCHEMA2.default("anthropic"),
+  role: ROLE_SCHEMA,
+  model: z2.string(),
+  effort: EFFORT_SCHEMA
+});
+var SCHEDULER = "scheduler";
+var WORKER = "worker";
+var REVIEWER = "reviewer";
+var IMPLEMENTATION_PHASE = "implementation";
+var PRE_GATE_PHASE = "pre-gate";
+var OPENAI_MODEL = "gpt-6.1-sol";
+var ANTHROPIC_MODEL = "claude-opus-5-5";
+var REVIEW_EFFORT = "medium";
+var VERIFICATION_EFFORT = "high";
+function role_profiles(provider, model) {
+  return {
+    scheduler: { provider, role: SCHEDULER, model, effort: "medium" },
+    worker: { provider, role: WORKER, model, effort: "medium" },
+    reviewer: { provider, role: REVIEWER, model, effort: REVIEW_EFFORT }
+  };
+}
+var DEFAULT_PROFILES = role_profiles(ANTHROPIC_PROVIDER2, ANTHROPIC_MODEL);
+var OPENAI_PROFILES = role_profiles(OPENAI_PROVIDER2, OPENAI_MODEL);
+var PROVIDER_PROFILES = { anthropic: DEFAULT_PROFILES, openai: OPENAI_PROFILES };
+var FIRST_REVIEW_ROUND = 1;
+var VERIFICATION_MODEL = "claude-sonnet-5-5";
+var VERIFICATION_PROFILES = {
+  anthropic: {
+    ...DEFAULT_PROFILES.reviewer,
+    model: VERIFICATION_MODEL,
+    effort: VERIFICATION_EFFORT
+  },
+  openai: { ...OPENAI_PROFILES.reviewer, effort: VERIFICATION_EFFORT }
+};
+var VERIFICATION_KEYS = {
+  model: "JOSH_REVIEWER_VERIFICATION_MODEL",
+  effort: "JOSH_REVIEWER_VERIFICATION_EFFORT"
+};
+var SHIP_EFFORT = "low";
+var PHASE_EFFORT = {
+  worker: { [PRE_GATE_PHASE]: SHIP_EFFORT }
+};
+var PHASE_MODEL_KEYS = {
+  worker: { [PRE_GATE_PHASE]: "JOSH_WORKER_SHIP_MODEL" }
+};
+var ENV_KEYS = {
+  scheduler: { model: "JOSH_SCHEDULER_MODEL", effort: "JOSH_SCHEDULER_EFFORT" },
+  worker: { model: "JOSH_WORKER_MODEL", effort: "JOSH_WORKER_EFFORT" },
+  reviewer: { model: "JOSH_REVIEWER_MODEL", effort: "JOSH_REVIEWER_EFFORT" }
+};
+var LEGACY_WORKER_KEYS = { model: "JOSH_LANE_MODEL", effort: "JOSH_LANE_EFFORT" };
+var { MAX_VALUE_LENGTH: MAX_VALUE_LENGTH2, is_safe_prompt: is_safe_prompt2, is_safe_value: is_safe_value2, printable: printable2 } = agent_safe_text;
+function is_verification(role, round) {
+  return role === REVIEWER && round !== void 0 && round > FIRST_REVIEW_ROUND;
+}
+function override_keys(role, field, round) {
+  const key = ENV_KEYS[role][field];
+  if (role === WORKER) return [key, LEGACY_WORKER_KEYS[field]];
+  return is_verification(role, round) ? [VERIFICATION_KEYS[field], key] : [key];
+}
+function override_value(role, field, environment, round) {
+  const keys = override_keys(role, field, round);
+  const key = keys.find((candidate) => trimmed2(environment[candidate]) !== void 0);
+  return key === void 0 ? { key: keys[0], value: void 0 } : { key, value: trimmed2(environment[key]) };
+}
+function phase_entry(table, role, phase) {
+  const parsed = PHASE_SCHEMA.safeParse(phase);
+  return parsed.success ? table[role]?.[parsed.data] : void 0;
+}
+function phase_model(role, provider, phase, environment) {
+  const key = provider === OPENAI_PROVIDER2 ? void 0 : phase_entry(PHASE_MODEL_KEYS, role, phase);
+  if (key === void 0) return void 0;
+  const value = trimmed2(environment[key]);
+  return value === void 0 ? void 0 : { key, value };
+}
+function model_override(role, environment, provider, stage) {
+  const phased = phase_model(role, provider, stage.phase, environment);
+  if (phased !== void 0) return phased;
+  return provider === OPENAI_PROVIDER2 ? { key: ENV_KEYS[role].model, value: void 0 } : override_value(role, "model", environment, stage.round);
+}
+function resolved_effort(override, fallback) {
+  const parsed = EFFORT_SCHEMA.safeParse(override.value ?? fallback);
+  return parsed.success ? { kind: "effort", effort: parsed.data } : rejection2(override.key, override.value ?? "", "is not an allowed effort");
+}
+function validate(profile, model_key) {
+  if (!is_safe_value2(profile.model)) {
+    return rejection2(model_key, profile.model, "is not a safe model");
+  }
+  return { kind: "profile", profile };
+}
+function phase_effort(role, phase, fallback) {
+  return phase_entry(PHASE_EFFORT, role, phase) ?? fallback;
+}
+function overridden_effort(profile, phase, environment) {
+  const parsed = EFFORT_SCHEMA.safeParse(override_value(profile.role, "effort", environment).value);
+  return parsed.success ? parsed.data : phase_effort(profile.role, phase, profile.effort);
+}
+function with_phase(profile, phase, environment = process.env) {
+  const effort = overridden_effort(profile, phase, environment);
+  const model = phase_model(profile.role, profile.provider, phase, environment);
+  if (model === void 0) return { kind: "profile", profile: { ...profile, effort } };
+  return validate({ ...profile, model: model.value, effort }, model.key);
+}
+function stage_defaults(provider, role, round) {
+  return is_verification(role, round) ? VERIFICATION_PROFILES[provider] : PROVIDER_PROFILES[provider][role];
+}
+function resolve_stage(role, environment, stage) {
+  const selected = resolve_provider2(environment);
+  if (selected.kind === "rejected") return selected;
+  const defaults = stage_defaults(selected.provider, role, stage.round);
+  const model = model_override(role, environment, selected.provider, stage);
+  const effort = override_value(role, "effort", environment, stage.round);
+  const resolved = resolved_effort(effort, phase_effort(role, stage.phase, defaults.effort));
+  if (resolved.kind === "rejected") return resolved;
+  const profile = {
+    provider: selected.provider,
+    role,
+    model: model.value ?? defaults.model,
+    effort: resolved.effort
+  };
+  return validate(profile, model.key);
+}
+function resolve(role, environment = process.env, phase) {
+  return resolve_stage(role, environment, { phase });
+}
+function resolve_review(round, environment = process.env) {
+  return resolve_stage(REVIEWER, environment, { round });
+}
+function describe(profile) {
+  return `provider=${profile.provider} role=${profile.role} model=${profile.model} effort=${profile.effort}`;
+}
+function describe_review(round, profile) {
+  return `review round ${String(round)} \xB7 ${describe(profile)}`;
+}
+function parse(value) {
+  const parsed = PROFILE_SCHEMA.safeParse(value);
+  return parsed.success && is_safe_value2(parsed.data.model) ? parsed.data : void 0;
+}
+var agent_role_profile = {
+  CODEX_SESSION_KEY: CODEX_SESSION_KEY2,
+  DEFAULT_PROFILES,
+  HANDED_PROVIDER_KEY: HANDED_PROVIDER_KEY2,
+  IMPLEMENTATION_PHASE,
+  MAX_VALUE_LENGTH: MAX_VALUE_LENGTH2,
+  OPENAI_PROFILES,
+  PRE_GATE_PHASE,
+  PROFILE_SCHEMA,
+  REVIEWER,
+  SCHEDULER,
+  VERIFICATION_PROFILES,
+  WORKER,
+  default_notice: default_notice2,
+  describe,
+  describe_review,
+  handoff_environment: handoff_environment2,
+  has_completion_callback: has_completion_callback2,
+  is_safe_prompt: is_safe_prompt2,
+  is_safe_value: is_safe_value2,
+  parse,
+  printable: printable2,
+  resolve,
+  resolve_provider: resolve_provider2,
+  resolve_review,
+  warn_of_default: warn_of_default2,
+  with_phase
+};
+
+// 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 z3 } from "zod";
+var CACHE_CREATION_SCHEMA = z3.object({
+  ephemeral_1h_input_tokens: z3.number().nullish(),
+  ephemeral_5m_input_tokens: z3.number().nullish()
+});
+var USAGE_SCHEMA = z3.object({
+  input_tokens: z3.number(),
+  cache_creation_input_tokens: z3.number().nullish(),
+  cache_read_input_tokens: z3.number().nullish(),
+  output_tokens: z3.number(),
+  output_tokens_details: z3.object({ thinking_tokens: z3.number().nullish() }).nullish(),
+  cache_creation: CACHE_CREATION_SCHEMA.nullish()
+});
+var MESSAGE_SCHEMA = z3.object({
+  id: z3.string().nullish(),
+  model: z3.string().nullish(),
+  usage: USAGE_SCHEMA.nullish()
+});
+var LINE_SCHEMA = z3.object({
+  type: z3.string(),
+  requestId: z3.string().nullish(),
+  uuid: z3.string().nullish(),
+  gitBranch: z3.string().nullish(),
+  timestamp: z3.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 total3 = usage.cache_creation_input_tokens ?? 0;
+  const detail = usage.cache_creation;
+  if (!detail) return { write_5m: total3, write_1h: 0 };
+  const write_1h = detail.ephemeral_1h_input_tokens ?? 0;
+  return { write_5m: detail.ephemeral_5m_input_tokens ?? total3 - 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 dedupe2(records) {
+  const by_id = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const seen = by_id.get(record.request_id);
+    const at_ms = later_instant(seen?.at_ms, record.at_ms);
+    by_id.set(record.request_id, { ...seen ?? record, at_ms });
+  }
+  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 total3 = EMPTY_TOTALS;
+  for (const record of records) total3 = add_totals(total3, record.totals);
+  return total3;
+}
+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: dedupe2,
+  add_totals,
+  sum_totals,
+  billed_input
+};
+
+// scripts/cost-runtime/cost-pricing.ts
+var CACHE_WRITE_5M_MULTIPLIER = 1.25;
+var CACHE_WRITE_1H_MULTIPLIER = 2;
+var DEFAULT_CACHE_READ_MULTIPLIER = 0.1;
+var HALVED_CACHE_READ_MULTIPLIER = 0.05;
+var QUARTERED_CACHE_READ_MULTIPLIER = 0.025;
+var TOKENS_PER_MILLION = 1e6;
+var LONG_PROMPT_SUFFIX = ":long-prompt";
+var LONG_PROMPT_THRESHOLD = 1e5;
+var MODEL_PRICES = {
+  "claude-fable-5-1": {
+    input: 10,
+    output: 50,
+    cache_read_multiplier: QUARTERED_CACHE_READ_MULTIPLIER
+  },
+  "claude-mythos-5-1": {
+    input: 10,
+    output: 50,
+    cache_read_multiplier: QUARTERED_CACHE_READ_MULTIPLIER
+  },
+  "claude-fable-5": { input: 10, output: 50 },
+  "claude-mythos-5": { input: 10, output: 50 },
+  "claude-opus-5-5": { input: 4, output: 20, cache_read_multiplier: HALVED_CACHE_READ_MULTIPLIER },
+  "claude-opus-5": { input: 5, output: 25 },
+  "claude-opus-4-8": { input: 5, output: 25 },
+  "claude-opus-4-7": { input: 5, output: 25 },
+  "claude-opus-4-6": { input: 5, output: 25 },
+  "claude-sonnet-5-5": {
+    input: 2,
+    output: 10,
+    cache_read_multiplier: HALVED_CACHE_READ_MULTIPLIER
+  },
+  "claude-sonnet-5": { input: 2, output: 10 },
+  "claude-sonnet-4-6": { input: 3, output: 15 },
+  "claude-haiku-5-5": { input: 0.1, output: 0.5 },
+  [`claude-haiku-5-5${LONG_PROMPT_SUFFIX}`]: { input: 0.5, output: 2.5 },
+  "claude-haiku-4-5": { input: 1, output: 5 }
+};
+var CONTEXT_MARKER = "[";
+var DATE_SUFFIX = /-\d{8}$/u;
+function known_id(model) {
+  const base = model.split(CONTEXT_MARKER)[0] ?? model;
+  return [base, base.replace(DATE_SUFFIX, "")].find((id) => Object.hasOwn(MODEL_PRICES, id));
+}
+function resolve_price(model) {
+  const id = known_id(model);
+  return id === void 0 ? void 0 : MODEL_PRICES[id];
+}
+function cache_read_multiplier(price) {
+  return price.cache_read_multiplier ?? DEFAULT_CACHE_READ_MULTIPLIER;
+}
+function cache_read_multiplier_of(model) {
+  const price = model === void 0 ? void 0 : resolve_price(model);
+  return price === void 0 ? DEFAULT_CACHE_READ_MULTIPLIER : cache_read_multiplier(price);
+}
+function estimate_cost(totals, price) {
+  const weighted_input = totals.input_tokens + totals.cache_write_5m_tokens * CACHE_WRITE_5M_MULTIPLIER + totals.cache_write_1h_tokens * CACHE_WRITE_1H_MULTIPLIER + totals.cache_read_tokens * cache_read_multiplier(price);
+  return (weighted_input * price.input + totals.output_tokens * price.output) / TOKENS_PER_MILLION;
+}
+function priced(tokens, rate) {
+  return tokens * rate / TOKENS_PER_MILLION;
+}
+function estimate_composition(totals, price) {
+  return {
+    input_usd: priced(totals.input_tokens, price.input),
+    cache_write_5m_usd: priced(
+      totals.cache_write_5m_tokens * CACHE_WRITE_5M_MULTIPLIER,
+      price.input
+    ),
+    cache_write_1h_usd: priced(
+      totals.cache_write_1h_tokens * CACHE_WRITE_1H_MULTIPLIER,
+      price.input
+    ),
+    cache_read_usd: priced(totals.cache_read_tokens * cache_read_multiplier(price), price.input),
+    output_usd: priced(totals.output_tokens, price.output)
+  };
+}
+function to_model_cost(model, totals) {
+  const price = resolve_price(model);
+  if (price === void 0) return { model, totals };
+  return { model, totals, cost_usd: estimate_cost(totals, price) };
+}
+function billed_model(usage) {
+  const long_id = `${known_id(usage.model) ?? usage.model}${LONG_PROMPT_SUFFIX}`;
+  const is_long = cost_usage.billed_input(usage.totals) > LONG_PROMPT_THRESHOLD;
+  return is_long && Object.hasOwn(MODEL_PRICES, long_id) ? long_id : usage.model;
+}
+function cost_by_model(records) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const model = billed_model(record);
+    const running = grouped.get(model) ?? cost_usage.EMPTY_TOTALS;
+    grouped.set(model, cost_usage.add_totals(running, record.totals));
+  }
+  return [...grouped].map(([model, totals]) => to_model_cost(model, totals));
+}
+function total_cost(costs) {
+  return {
+    usd: costs.reduce((sum, entry) => sum + (entry.cost_usd ?? 0), 0),
+    unpriced: costs.filter((entry) => entry.cost_usd === void 0).map((entry) => entry.model)
+  };
+}
+function cost_of3(records) {
+  return total_cost(cost_by_model(records)).usd;
+}
+var cost_pricing = {
+  CACHE_WRITE_5M_MULTIPLIER,
+  CACHE_WRITE_1H_MULTIPLIER,
+  DEFAULT_CACHE_READ_MULTIPLIER,
+  LONG_PROMPT_THRESHOLD,
+  resolve_price,
+  cache_read_multiplier_of,
+  estimate_cost,
+  estimate_composition,
+  cost_by_model,
+  total_cost,
+  cost_of: cost_of3
+};
+
+// scripts/document/read-set-pricing.ts
+var ASSUMED_REQUESTS = 118;
+var REFERENCE_MODEL = agent_role_profile.DEFAULT_PROFILES.worker.model;
+function dollars_per_run(tokens) {
+  const price = cost_pricing.resolve_price(REFERENCE_MODEL);
+  if (price === void 0) return 0;
+  return cost_pricing.estimate_cost(
+    { ...cost_usage.EMPTY_TOTALS, cache_read_tokens: tokens * ASSUMED_REQUESTS },
+    price
+  );
+}
+var read_set_pricing = {
+  ASSUMED_REQUESTS,
+  REFERENCE_MODEL,
+  dollars_per_run
+};
+
+// scripts/document/read-set-cli.ts
+var { BACKLOGRUN: BACKLOGRUN2 } = backlogrun_parent_read_set;
+var ARGV_OFFSET = 2;
+var FAILURE_EXIT_CODE = 1;
+var FLAG_PREFIX = "-";
+var JSON_FLAG = "--json";
+var JSON_INDENT = 2;
+var NOTHING3 = 0;
+var PERCENT = 100;
+var LABEL_GUTTER = 4;
+var NUMBER_WIDTH = 9;
+var DOLLAR_WIDTH = 7;
+var DOLLAR_DECIMALS = 2;
+var PREMISE = `  $ = cost per run, assuming a ${String(read_set_pricing.ASSUMED_REQUESTS)}-request run (each entry-read token re-read from cache per request)`;
+var USAGE = "Usage: josh read:set [<entry>] [--json]";
+var WHOLE_LABEL = "whole \u2014 every referenced file read in full";
+var SCOPED_LABEL = "scoped \u2014 referenced sections only";
+var TOTAL_READ_LABEL = "total read \u2014 scoped entry plus point-of-use reached";
+var SECTION_LABEL = "-- sections referenced out of the set --";
+var POINT_OF_USE_LABEL = "-- read at the point of use, not at the entry --";
+var LANE_CHILD_NOTE = [
+  "  a dispatched lane child (`JOSH_LANE_CHILD`) reads this trimmed set:",
+  "  - skips the point-of-use documents the parent owns \u2014 child dispatch, lane opening, the progress watcher and the hand-off",
+  "  - omits SKILL.md \xA70/\xA73 \u2014 dispatch already authorized the run and a leaf child edits no rule"
+];
+var BACKLOGRUN_PARENT_NOTE = [
+  "  the backlogrun parent (scheduler) reads this trimmed set:",
+  "  - omits SKILL.md \xA73 \u2014 the parent edits no rule mid-run",
+  "  - keeps every point-of-use document \u2014 the parent is the one dispatching children and running lanes"
+];
+var FETCH_RULE = "fetch: one `Read` call per file \u2014 never `cat`, and never two files in one command.";
+var OVER_CAP_NOTE = "   Read (over the Bash cap)";
+var UNDER_CAP_NOTE = "   Read";
+function to_number(value) {
+  return value.toLocaleString("en-US").padStart(NUMBER_WIDTH);
+}
+function to_dollars(tokens) {
+  return `$${read_set_pricing.dollars_per_run(tokens).toFixed(DOLLAR_DECIMALS)}`.padStart(
+    DOLLAR_WIDTH
+  );
+}
+function row(label, cost, width, note = "") {
+  return `  ${label.padEnd(width)}${to_number(cost.tokens)} tok ${to_number(cost.bytes)} B ${to_dollars(cost.tokens)}${note}`;
+}
+function fetch_note(bytes, cap) {
+  return bytes > cap ? OVER_CAP_NOTE : UNDER_CAP_NOTE;
+}
+function section_label(section2) {
+  const mark = section2.is_resolved ? "" : " (unresolved \u2014 charged whole)";
+  return `${section2.file} \u2192 "${section2.heading}"${mark}`;
+}
+function point_of_use_label(section2) {
+  return section2.heading === "" ? section2.file : section_label(section2);
+}
+function saved_percent(report) {
+  if (report.whole.tokens === NOTHING3) return NOTHING3;
+  return Math.round((report.whole.tokens - report.scoped.tokens) / report.whole.tokens * PERCENT);
+}
+function labels_of(report) {
+  return [
+    ...report.files.map((entry) => entry.file),
+    ...report.sections.map((section2) => section_label(section2)),
+    ...report.point_of_use.map((entry) => point_of_use_label(entry)),
+    WHOLE_LABEL,
+    SCOPED_LABEL,
+    TOTAL_READ_LABEL
+  ];
+}
+function total_read(report) {
+  return entry_read_set.total([report.scoped, ...report.point_of_use.map((one) => one.cost)]);
+}
+function label_width(report) {
+  return Math.max(...labels_of(report).map((label) => label.length)) + LABEL_GUTTER;
+}
+function file_lines(report, width) {
+  return report.files.map(
+    (entry) => row(entry.file, entry.cost, width, fetch_note(entry.cost.bytes, report.bash_output_cap))
+  );
+}
+function point_of_use_lines(report, width) {
+  if (report.point_of_use.length === NOTHING3) return [];
+  return [
+    `  ${POINT_OF_USE_LABEL}`,
+    ...report.point_of_use.map((entry) => row(point_of_use_label(entry), entry.cost, width))
+  ];
+}
+function fetch_lines(report) {
+  const cap = report.bash_output_cap.toLocaleString("en-US");
+  return [
+    `  ${FETCH_RULE}`,
+    `  A Bash result is truncated past ${cap} characters, so a \`cat\` of any file marked`,
+    `  \`${OVER_CAP_NOTE.trim()}\` returns a preview rather than the file, and it is then read a second time.`,
+    ""
+  ];
+}
+function section_lines(report, width) {
+  if (report.sections.length === NOTHING3) return [];
+  return [
+    `  ${SECTION_LABEL}`,
+    ...report.sections.map((section2) => row(section_label(section2), section2.cost, width))
+  ];
+}
+function total_lines(report, width) {
+  const saved = report.whole.tokens - report.scoped.tokens;
+  return [
+    "",
+    row(WHOLE_LABEL, report.whole, width),
+    row(SCOPED_LABEL, report.scoped, width),
+    row(TOTAL_READ_LABEL, total_read(report), width),
+    `  saved by reading sections: ${saved.toLocaleString("en-US")} tok (${String(saved_percent(report))}%)`,
+    ""
+  ];
+}
+function note_lines(report) {
+  if (report.entry === lane_child_read_set.LANE_CHILD) {
+    return [...LANE_CHILD_NOTE, lane_instructions.resident_line(), ""];
+  }
+  if (report.entry === BACKLOGRUN2) return [...BACKLOGRUN_PARENT_NOTE, ""];
+  return [];
+}
+function report_lines(report) {
+  const width = label_width(report);
+  return [
+    `entry: ${report.entry}`,
+    PREMISE,
+    ...note_lines(report),
+    ...file_lines(report, width),
+    ...section_lines(report, width),
+    ...point_of_use_lines(report, width),
+    ...total_lines(report, width),
+    ...fetch_lines(report)
+  ];
+}
+function known_entries(root) {
+  return [...entry_read_set.entries(root), lane_child_read_set.LANE_CHILD];
+}
+function wanted_entries(argv, root) {
+  const named = argv.filter((value) => !value.startsWith(FLAG_PREFIX));
+  return named.length > NOTHING3 ? named : known_entries(root);
+}
+function unknown_entries(wanted, root) {
+  const known = known_entries(root);
+  return wanted.filter((entry) => !known.includes(entry));
+}
+function costed_entry(root, entry) {
+  if (entry === lane_child_read_set.LANE_CHILD) return lane_child_read_set.costed(root);
+  if (entry === BACKLOGRUN2) return backlogrun_parent_read_set.costed(root);
+  return entry_read_set.costed(root, entry);
+}
+function printed(reports, is_json) {
+  if (is_json) return JSON.stringify(reports, void 0, JSON_INDENT);
+  return reports.flatMap((report) => report_lines(report)).join("\n");
+}
+function run(argv, root = process.cwd()) {
+  const wanted = wanted_entries(argv, root);
+  const unknown = unknown_entries(wanted, root);
+  if (wanted.length === NOTHING3 || unknown.length > NOTHING3) {
+    console.error(`${USAGE}
+Known entries: ${known_entries(root).join(", ")}`);
+    return FAILURE_EXIT_CODE;
+  }
+  const reports = wanted.map((entry) => costed_entry(root, entry));
+  console.info(printed(reports, argv.includes(JSON_FLAG)));
+  return 0;
+}
+function main(argv) {
+  process.exitCode = run(argv);
+}
+var read_set_cli = {
+  FETCH_RULE,
+  JSON_FLAG,
+  POINT_OF_USE_LABEL,
+  SCOPED_LABEL,
+  TOTAL_READ_LABEL,
+  WHOLE_LABEL,
+  known_entries,
+  run,
+  saved_percent
+};
+if (process.argv[1] === fileURLToPath3(import.meta.url)) main(process.argv.slice(ARGV_OFFSET));
+export {
+  read_set_cli
+};