@joshuafolkken/kit 1.1240.0 → 1.1373.0

package/dist/hooks/chunk-UTHMB4O2.js

@@ -0,0 +1,1590 @@
+import {
+  lane_child_marker
+} from "./chunk-Z5TMJIPW.js";
+import {
+  ENV_FILE_NAME,
+  LANE_SEAT_KEY,
+  PORCELAIN_FLAG,
+  PORT_SEED_KEY,
+  agent_session_environment,
+  file_reader,
+  git_command,
+  git_spawn,
+  git_utilities,
+  issue_number_shape,
+  json_value,
+  lane_paths,
+  ports,
+  process_identity,
+  process_owner_schema,
+  run_carry
+} from "./chunk-NZN2UFI6.js";
+import {
+  INSTALL_TIMEOUT_MS,
+  PLATFORM_TEMP_ROOT,
+  PROBE_TIMEOUT_MS,
+  SUITE_TIMEOUT_MS,
+  stamp_file
+} from "./chunk-NEC4AT4Z.js";
+
+// scripts/agent/agent-headless.ts
+var KEY = "JOSH_AGENT_HEADLESS";
+var VALUE = "1";
+function environment() {
+  return { [KEY]: VALUE };
+}
+function is_headless(source = process.env) {
+  return source[KEY] === VALUE;
+}
+var agent_headless = { KEY, environment, is_headless };
+
+// scripts/lane/lane-reap.ts
+import { execFileSync } from "node:child_process";
+
+// scripts/issue/issue-cite.ts
+var GITHUB_URL_PREFIX = "https://github.com/";
+var ISSUE_PATH = "/issues/";
+var SUMMARY_SEPARATOR = " \u2014 ";
+var REPO_QUALIFIED = /^([^\s/#]+\/[^\s/#]+)#(\d+)$/u;
+var BARE_NUMBER = /^#?(\d+)$/u;
+function plain(number, repo = "") {
+  return `${repo}#${String(number)}`;
+}
+function issue_url(slug, number) {
+  return `${GITHUB_URL_PREFIX}${slug}${ISSUE_PATH}${number}`;
+}
+function citation_line(slug, number, summary) {
+  return `[${plain(number)}](${issue_url(slug, number)})${SUMMARY_SEPARATOR}${summary}`;
+}
+function reference(slug, number, title) {
+  if (slug === void 0) return plain(number);
+  return title === void 0 ? `[${plain(number)}](${issue_url(slug, number)})` : citation_line(slug, number, title);
+}
+function citer(slug, titles) {
+  return function cite(number) {
+    return reference(slug, number, titles.get(number));
+  };
+}
+function qualified_target(token) {
+  const match = REPO_QUALIFIED.exec(token);
+  if (match === null) return void 0;
+  const [, repo = "", number = ""] = match;
+  return { number, repo };
+}
+function bare_target(token, default_repo) {
+  const match = BARE_NUMBER.exec(token);
+  if (match === null) return void 0;
+  const [, number = ""] = match;
+  return { number, repo: default_repo };
+}
+function parse_target(token, default_repo) {
+  return qualified_target(token) ?? bare_target(token, default_repo);
+}
+function label(target) {
+  return plain(target.number, target.repo);
+}
+function missing_line(target) {
+  return `\u2716 ${label(target)}: issue does not resolve \u2014 check the number and the repository`;
+}
+function unreadable_line(target) {
+  return `\u2716 ${label(target)}: could not be read \u2014 a rate limit, expired auth, or a dropped connection`;
+}
+function no_repo_line(target) {
+  return `\u2716 ${label(target)}: could not read this repository \u2014 check gh auth and the origin remote`;
+}
+var issue_cite = {
+  citation_line,
+  citer,
+  issue_url,
+  missing_line,
+  no_repo_line,
+  parse_target,
+  plain,
+  reference,
+  unreadable_line
+};
+
+// scripts/run/ship/run-ship-stage.ts
+import { z } from "zod";
+var STAGE = {
+  PREFLIGHT: "preflight",
+  REVIEW: "review",
+  GATE: "gate",
+  SYNC: "sync",
+  COMMIT: "commit",
+  ROUND_TWO: "round-2",
+  FOLLOWUP: "followup",
+  REPORT: "report"
+};
+var PHASE = {
+  START: "start",
+  DONE: "done",
+  FAILED: "failed",
+  SKIPPED: "skipped"
+};
+var RECORD_PREFIX = "josh-ship-stages-";
+var RECORD_SEPARATOR = "-";
+var SKIP_COMMIT_FLAG = "--skip-commit";
+var SKIP_PUSH_FLAG = "--skip-push";
+var WORD_SEPARATOR = " ";
+var STARTED_SEPARATOR = ",";
+var STARTED_INDEX = 3;
+var WORD_COUNT = STARTED_INDEX + 1;
+var record_schema = z.object({
+  done: z.array(z.string()),
+  started: z.array(z.string()).default([])
+});
+var EMPTY_RECORD = { done: [], started: [] };
+function record_path(repository2, issue) {
+  return stamp_file.stamp_path(`${RECORD_PREFIX}${issue}${RECORD_SEPARATOR}`, repository2);
+}
+function parse_record(raw) {
+  return json_value.parse_with(raw, record_schema) ?? EMPTY_RECORD;
+}
+function read_record(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  return raw === void 0 ? EMPTY_RECORD : parse_record(raw);
+}
+function read_done(target) {
+  return new Set(read_record(target).done);
+}
+function mark_done(target, stage) {
+  const record = read_record(target);
+  stamp_file.replace_stamp(target, { ...record, done: [.../* @__PURE__ */ new Set([...record.done, stage])] });
+}
+function read_started(target) {
+  return read_record(target).started;
+}
+function mark_started(target, stage) {
+  const record = read_record(target);
+  stamp_file.replace_stamp(target, { ...record, started: [.../* @__PURE__ */ new Set([...record.started, stage])] });
+}
+function end_attempt(target) {
+  stamp_file.replace_stamp(target, { ...read_record(target), started: [] });
+}
+function clear(target) {
+  stamp_file.remove_stamp(target);
+}
+function is_shipped(state) {
+  return state.is_committed && state.is_pushed;
+}
+var DONE_BY = {
+  // The preflight asks what the commit stage would refuse on, so a commit is
+  // its output as it is the gate's; a resumed commit stage still asks `git -y`'s own preflight.
+  [STAGE.PREFLIGHT]: (_done, state) => state.is_merged || state.is_committed,
+  // The `--review` round precedes the commit, so a commit is its output as it
+  // is the gate's. A record alone is not honored: before a commit the tree may have been edited since
+  // the recorded round, and only a commit pins the tree that round read.
+  [STAGE.REVIEW]: (_done, state) => state.is_merged || state.is_committed,
+  [STAGE.GATE]: (_done, state) => state.is_merged || state.is_committed,
+  // The merge of the default branch before the commit: once committed, a
+  // conflicting pull request is the followup's to merge again.
+  [STAGE.SYNC]: (_done, state) => state.is_merged || state.is_committed,
+  [STAGE.COMMIT]: (done, state) => state.is_merged || done.has(STAGE.COMMIT) && is_shipped(state),
+  // The round-2 pass reads the pushed fix delta, so its record is honored only
+  // while that push still stands — new work pushed on top reruns it.
+  [STAGE.ROUND_TWO]: (done, state) => state.is_merged || done.has(STAGE.ROUND_TWO) && is_shipped(state),
+  // A recorded followup still needs the shipped state: a record left by a merged ship whose report
+  // failed must not pass over the followup of new, not-yet-pushed work on the same issue.
+  [STAGE.FOLLOWUP]: (done, state) => state.is_merged || done.has(STAGE.FOLLOWUP) && is_shipped(state),
+  [STAGE.REPORT]: (done) => done.has(STAGE.REPORT)
+};
+function is_done(stage, done, state, has_body = false) {
+  if (has_body && stage === STAGE.COMMIT && !state.is_merged) return false;
+  return DONE_BY[stage](done, state);
+}
+function commit_flags(state) {
+  if (!state.is_committed) return [];
+  return state.is_pushed ? [SKIP_COMMIT_FLAG, SKIP_PUSH_FLAG] : [SKIP_COMMIT_FLAG];
+}
+function event_text(issue, stage, phase, started = []) {
+  const words = [issue_cite.plain(issue), stage, phase];
+  const listed = [...new Set(started)].join(STARTED_SEPARATOR);
+  const full = started.length > 0 ? [...words, listed] : words;
+  return full.join(WORD_SEPARATOR);
+}
+function started_of(text) {
+  return text.split(WORD_SEPARATOR, WORD_COUNT)[STARTED_INDEX]?.split(STARTED_SEPARATOR);
+}
+var CONFLICT = "conflict";
+function stop_reason(stage, conflicts = []) {
+  return conflicts.length > 0 ? CONFLICT : stage;
+}
+var run_ship_stage = {
+  PHASE,
+  STAGE,
+  clear,
+  commit_flags,
+  end_attempt,
+  event_text,
+  is_done,
+  mark_done,
+  mark_started,
+  read_done,
+  read_started,
+  record_path,
+  started_of,
+  stop_reason
+};
+
+// scripts/run/ship/run-ship-next.ts
+var { STAGE: STAGE2 } = run_ship_stage;
+var COMMAND = {
+  LOG: "pnpm josh ship --log",
+  DETACH: "pnpm josh ship --detach",
+  DETACH_REVIEW: "pnpm josh ship --detach --review"
+};
+var ESCAPED_QUOTE = String.raw`'\''`;
+var BARE_WORD = /^[\w%+,./:=@-]+$/u;
+function quoted(title) {
+  return `'${title.split("'").join(ESCAPED_QUOTE)}'`;
+}
+function shell_word(token) {
+  return BARE_WORD.test(token) ? token : quoted(token);
+}
+function resume_of(args) {
+  const cites = args.cites.flatMap((cite) => ["--cite", cite]);
+  return {
+    title: args.title,
+    flags: [...args.notify, ...args.body, ...cites],
+    is_review: args.is_review
+  };
+}
+function ship_command(command, resume) {
+  const words = [...resume.flags, resume.title].map((token) => shell_word(token));
+  return [command, ...words].join(" ");
+}
+function detach_again(resume) {
+  return `leave the fix uncommitted and run \`${ship_command(COMMAND.DETACH, resume)}\`.`;
+}
+function detach_as_started(resume) {
+  const command = resume.is_review ? COMMAND.DETACH_REVIEW : COMMAND.DETACH;
+  return `leave the fix uncommitted and run \`${ship_command(command, resume)}\`.`;
+}
+var AFTER_FIX = {
+  [STAGE2.PREFLIGHT]: detach_as_started,
+  [STAGE2.REVIEW]: detach_as_started,
+  [STAGE2.GATE]: detach_as_started,
+  [STAGE2.SYNC]: detach_as_started,
+  [STAGE2.COMMIT]: detach_as_started,
+  [STAGE2.ROUND_TWO]: detach_again,
+  [STAGE2.FOLLOWUP]: detach_again,
+  [STAGE2.REPORT]: detach_again
+};
+function conflict_step(conflicts) {
+  return `Resolve the conflict with origin/main in ${conflicts.join(", ")} (the merge is left in progress: remove the conflict markers in those files), then`;
+}
+function next_step(issue, stage, resume) {
+  const conflicts = resume.conflicts ?? [];
+  if (conflicts.length > 0) return `${conflict_step(conflicts)} ${AFTER_FIX[stage](resume)}`;
+  return `Read the stopped report with \`${COMMAND.LOG} ${issue}\`, fix the ${stage} failure, then ${AFTER_FIX[stage](resume)}`;
+}
+var run_ship_next = { COMMAND, next_step, quoted, resume_of };
+
+// scripts/lane/lane-child-invocation.ts
+var CHILD_INVOCATION = "fullrun";
+var RESUME_GUIDE = ".claude/skills/workflow-commands/pre-gate-cut.md";
+var SHIP_PROCESS = String.raw`(josh(\.[jt]s)? ship|run-ship-cli\.ts)`;
+function child_invocation(issue) {
+  issue_number_shape.require_issue_number(issue);
+  return `${CHILD_INVOCATION} ${issue_cite.plain(issue)}`;
+}
+function process_pattern(issue) {
+  issue_number_shape.require_issue_number(issue);
+  return `(${CHILD_INVOCATION}|${SHIP_PROCESS} .*) ${issue_cite.plain(issue)}$`;
+}
+function resume_invocation(issue) {
+  const preamble = `Resuming the lane child for issue ${issue_cite.plain(issue)} \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Run \`pnpm josh run:cut --resume ${issue}\` before anything else and follow the matching verdict in ${RESUME_GUIDE}: \`resume\` goes to the gate, \`resume-impl\` continues implementation. Only on \`fresh\` proceed as an ordinary`;
+  return `${preamble} ${child_invocation(issue)}`;
+}
+function outage_resume_invocation(issue) {
+  const preamble = `Resuming the lane child for issue ${issue_cite.plain(issue)} after an API disconnection \u2014 your session was restored with its full context, so do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Continue the run from where it stopped: run \`pnpm josh run:step ${issue}\` to find the next action, redoing only the last step if it did not complete.`;
+  return `${preamble} ${child_invocation(issue)}`;
+}
+function ship_stop_invocation(issue, stop) {
+  const opening = `Resuming the lane child for issue ${issue_cite.plain(issue)} after its detached ship supervisor stopped at a failed stage \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md).`;
+  const next = stop === void 0 ? `Run \`pnpm josh run:step ${issue}\` and read the stopped report it names, fix what stopped the ship, then hand the region back per chain-rule.md.` : run_ship_next.next_step(issue, stop.stage, stop);
+  return `${opening} ${next} Do not re-plan or re-implement what is already on the branch. ${child_invocation(issue)}`;
+}
+var lane_child_invocation = {
+  child_invocation,
+  outage_resume_invocation,
+  process_pattern,
+  resume_invocation,
+  ship_stop_invocation
+};
+
+// scripts/lane/lane-reap.ts
+var PGREP_COMMAND = "pgrep";
+var MATCH_FULL_COMMAND_LINE = "-f";
+var CHILDREN_OF_FLAG = "-P";
+var PS_COMMAND = "/bin/ps";
+var PARENT_FORMAT = ["-o", "ppid=", "-p"];
+var TERMINATE_SIGNAL = "SIGTERM";
+var LOWEST_CHILD_PID = 2;
+function parse_pids(printed) {
+  return printed.split("\n").map((line) => Number(line.trim())).filter((pid) => Number.isSafeInteger(pid) && pid >= LOWEST_CHILD_PID);
+}
+function run_probe(command, args) {
+  try {
+    return execFileSync(command, [...args], {
+      encoding: "utf8",
+      timeout: PROBE_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return "";
+  }
+}
+function parent_of(pid) {
+  return parse_pids(run_probe(PS_COMMAND, [...PARENT_FORMAT, String(pid)]))[0];
+}
+function terminate(pid) {
+  try {
+    process.kill(pid, TERMINATE_SIGNAL);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var SYSTEM_PROBES = {
+  matching: (pattern) => parse_pids(run_probe(PGREP_COMMAND, [MATCH_FULL_COMMAND_LINE, pattern])),
+  children_of: (pid) => parse_pids(run_probe(PGREP_COMMAND, [CHILDREN_OF_FLAG, String(pid)])),
+  parent_of,
+  terminate
+};
+function ancestry_of(pid, probes) {
+  const ancestry = /* @__PURE__ */ new Set([pid]);
+  let current = probes.parent_of(pid);
+  while (current !== void 0 && !ancestry.has(current)) {
+    ancestry.add(current);
+    current = probes.parent_of(current);
+  }
+  return ancestry;
+}
+function own_ancestry(probes = SYSTEM_PROBES) {
+  return ancestry_of(process.pid, probes);
+}
+function tree_of(roots, probes) {
+  const tree = [];
+  const pending = [...roots];
+  let next = pending.shift();
+  while (next !== void 0) {
+    if (!tree.includes(next)) {
+      tree.push(next);
+      pending.push(...probes.children_of(next));
+    }
+    next = pending.shift();
+  }
+  return tree;
+}
+function reap_child(issue, probes = SYSTEM_PROBES) {
+  const own2 = own_ancestry(probes);
+  const pattern = lane_child_invocation.process_pattern(issue);
+  const roots = probes.matching(pattern).filter((pid) => !own2.has(pid));
+  const doomed = tree_of(roots, probes).filter((pid) => !own2.has(pid));
+  return doomed.filter((pid) => probes.terminate(pid));
+}
+var lane_reap = {
+  own_ancestry,
+  parse_pids,
+  reap_child
+};
+
+// scripts/lane/lane-registry.ts
+import { existsSync as existsSync2 } from "node:fs";
+import path2 from "node:path";
+
+// scripts/discovery/repo-discovery.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+
+// scripts/discovery/repo-origin.ts
+var GITHUB_HOST = "github.com";
+var SSH_ALIAS_PATTERN = /^github(?:-\w+)*$/u;
+var GIT_SUFFIX = ".git";
+var PATH_SEPARATOR = "/";
+var USER_SEPARATOR = "@";
+var HOST_SEPARATOR = ":";
+var OWNER_INDEX = 0;
+var REPO_INDEX = 1;
+var REPO_PATH_SEGMENTS = 2;
+var NOT_FOUND = -1;
+var SECTION_PREFIX = "[";
+var ORIGIN_SECTION = /^\[remote\s+"origin"\]$/u;
+var REMOTE_SECTION = /^\[remote\s+"[^"]+"\]$/u;
+var URL_KEY = "url";
+function is_github_hostname(host) {
+  return host.toLowerCase() === GITHUB_HOST;
+}
+function is_github_ssh_host(host) {
+  const normalized = host.toLowerCase();
+  return is_github_hostname(normalized) || SSH_ALIAS_PATTERN.test(normalized);
+}
+function strip_git_suffix(name) {
+  return name.endsWith(GIT_SUFFIX) ? name.slice(0, -GIT_SUFFIX.length) : name;
+}
+function to_identity(repository_path) {
+  const segments = repository_path.split(PATH_SEPARATOR).filter((segment) => segment !== "");
+  if (segments.length !== REPO_PATH_SEGMENTS) return void 0;
+  const owner = segments[OWNER_INDEX] ?? "";
+  const repo = strip_git_suffix(segments[REPO_INDEX] ?? "");
+  return repo === "" ? void 0 : { owner, repo };
+}
+function parse_scp_like(url) {
+  const user_end = url.indexOf(USER_SEPARATOR);
+  const authority = user_end === NOT_FOUND ? url : url.slice(user_end + 1);
+  const host_end = authority.indexOf(HOST_SEPARATOR);
+  if (host_end === NOT_FOUND) return void 0;
+  if (!is_github_ssh_host(authority.slice(0, host_end))) return void 0;
+  return to_identity(authority.slice(host_end + 1));
+}
+function parse_url_like(url) {
+  try {
+    const parsed = new URL(url);
+    return is_github_hostname(parsed.hostname) ? to_identity(parsed.pathname) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parse_origin_url(url) {
+  const trimmed2 = url.trim();
+  if (trimmed2 === "") return void 0;
+  return parse_url_like(trimmed2) ?? parse_scp_like(trimmed2);
+}
+function is_section_header(line) {
+  return line.startsWith(SECTION_PREFIX);
+}
+function origin_section_lines(lines) {
+  const start = lines.findIndex((line) => ORIGIN_SECTION.test(line));
+  if (start === NOT_FOUND) return [];
+  const rest = lines.slice(start + 1);
+  const end = rest.findIndex((line) => is_section_header(line));
+  return end === NOT_FOUND ? rest : rest.slice(0, end);
+}
+function url_value(line) {
+  const separator = line.indexOf("=");
+  if (separator === NOT_FOUND) return void 0;
+  if (line.slice(0, separator).trim() !== URL_KEY) return void 0;
+  return line.slice(separator + 1).trim();
+}
+function parse_origin_from_config(content) {
+  const lines = content.split("\n").map((line) => line.trim());
+  return origin_section_lines(lines).map((line) => url_value(line)).find((url) => url !== void 0);
+}
+function section_groups(lines) {
+  const groups = [];
+  for (const line of lines) {
+    if (is_section_header(line)) groups.push([line]);
+    else groups.at(-1)?.push(line);
+  }
+  return groups;
+}
+function parse_remote_urls_from_config(content) {
+  const lines = content.split("\n").map((line) => line.trim());
+  return section_groups(lines).filter((group) => REMOTE_SECTION.test(group[0] ?? "")).flatMap((group) => group.map((line) => url_value(line))).filter((url) => url !== void 0);
+}
+function format_identity(identity) {
+  return `${identity.owner}${PATH_SEPARATOR}${identity.repo}`.toLowerCase();
+}
+var repo_origin = {
+  GITHUB_HOST,
+  is_github_hostname,
+  is_github_ssh_host,
+  parse_origin_from_config,
+  parse_origin_url,
+  parse_remote_urls_from_config,
+  format_identity
+};
+
+// scripts/discovery/repo-map-logic.ts
+var OVERRIDE_ENTRY_SEPARATOR = ",";
+var OVERRIDE_PAIR_SEPARATOR = "=";
+var OVERRIDE_PAIR_PARTS = 2;
+var KEY_INDEX = 0;
+var PATH_INDEX = 1;
+function is_same_owner(identity, current_owner) {
+  return identity.owner.toLowerCase() === current_owner.toLowerCase();
+}
+function add_entry(target, origin_url, repository_path, current_owner) {
+  if (origin_url === void 0) return;
+  const identity = repo_origin.parse_origin_url(origin_url);
+  if (identity === void 0 || !is_same_owner(identity, current_owner)) return;
+  target.set(repo_origin.format_identity(identity), repository_path);
+}
+function parse_override_entry(entry) {
+  const parts = entry.split(OVERRIDE_PAIR_SEPARATOR).map((part) => part.trim());
+  if (parts.length !== OVERRIDE_PAIR_PARTS) return void 0;
+  const key = parts[KEY_INDEX] ?? "";
+  const repository_path = parts[PATH_INDEX] ?? "";
+  if (repository_path === "") return void 0;
+  return { path: repository_path, origin_url: `https://${repo_origin.GITHUB_HOST}/${key}` };
+}
+function parse_overrides(raw) {
+  if (raw === void 0) return [];
+  return raw.split(OVERRIDE_ENTRY_SEPARATOR).map((entry) => parse_override_entry(entry)).filter((entry) => entry !== void 0);
+}
+function build_repository_map(discovered, current_owner, override_value2) {
+  const result = /* @__PURE__ */ new Map();
+  for (const entry of discovered) add_entry(result, entry.origin_url, entry.path, current_owner);
+  for (const entry of parse_overrides(override_value2)) {
+    add_entry(result, entry.origin_url, entry.path, current_owner);
+  }
+  return result;
+}
+var repo_map_logic = {
+  is_same_owner,
+  build_repository_map
+};
+
+// scripts/discovery/repo-discovery.ts
+var GIT_DIRECTORY = ".git";
+var GIT_CONFIG = "config";
+var GITDIR_PREFIX = "gitdir:";
+var COMMON_DIRECTORY_FILE = "commondir";
+var OVERRIDE_ENV_KEY = "JOSH_REPO_PATHS";
+function resolve_common_directory(git_directory) {
+  const pointer = path.join(git_directory, COMMON_DIRECTORY_FILE);
+  if (!existsSync(pointer)) return git_directory;
+  try {
+    return path.resolve(git_directory, readFileSync(pointer, "utf8").trim());
+  } catch {
+    return git_directory;
+  }
+}
+function follow_git_file(repository_path, git_file) {
+  const pointer = readFileSync(git_file, "utf8").trim();
+  if (!pointer.startsWith(GITDIR_PREFIX)) return void 0;
+  return path.resolve(repository_path, pointer.slice(GITDIR_PREFIX.length).trim());
+}
+function resolve_git_directory(repository_path) {
+  const candidate = path.join(repository_path, GIT_DIRECTORY);
+  if (!existsSync(candidate)) return void 0;
+  try {
+    if (statSync(candidate).isDirectory()) return candidate;
+    const linked = follow_git_file(repository_path, candidate);
+    return linked === void 0 ? void 0 : resolve_common_directory(linked);
+  } catch {
+    return void 0;
+  }
+}
+function read_config(repository_path) {
+  const git_directory = resolve_git_directory(repository_path);
+  if (git_directory === void 0) return void 0;
+  try {
+    return readFileSync(path.join(git_directory, GIT_CONFIG), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function read_origin_url(repository_path) {
+  const config = read_config(repository_path);
+  return config === void 0 ? void 0 : repo_origin.parse_origin_from_config(config);
+}
+function read_remote_urls(repository_path) {
+  const config = read_config(repository_path);
+  return config === void 0 ? [] : repo_origin.parse_remote_urls_from_config(config);
+}
+function sibling_directories(parent) {
+  try {
+    return readdirSync(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path.join(parent, entry.name)).toSorted((left, right) => left.localeCompare(right));
+  } catch {
+    return [];
+  }
+}
+function scan_siblings(parent) {
+  return sibling_directories(parent).map((repository_path) => ({
+    path: repository_path,
+    origin_url: read_origin_url(repository_path)
+  }));
+}
+function resolve_current_owner(repository_path) {
+  const origin_url = read_origin_url(repository_path);
+  if (origin_url === void 0) return void 0;
+  return repo_origin.parse_origin_url(origin_url)?.owner;
+}
+function main_worktree(repository_path) {
+  const git_directory = resolve_git_directory(repository_path);
+  if (git_directory === void 0) return repository_path;
+  if (path.basename(git_directory) !== GIT_DIRECTORY) return repository_path;
+  return path.dirname(git_directory);
+}
+function discover_repositories(repository_path, environment3 = process.env) {
+  const main = main_worktree(repository_path);
+  const current_owner = resolve_current_owner(main);
+  if (current_owner === void 0) return /* @__PURE__ */ new Map();
+  return repo_map_logic.build_repository_map(
+    scan_siblings(path.dirname(main)),
+    current_owner,
+    environment3[OVERRIDE_ENV_KEY]
+  );
+}
+var repo_discovery = {
+  OVERRIDE_ENV_KEY,
+  main_worktree,
+  read_origin_url,
+  read_remote_urls,
+  resolve_current_owner,
+  scan_siblings,
+  discover_repositories
+};
+
+// scripts/git/git-ls-remote.ts
+var LS_REMOTE_COMMAND = "ls-remote";
+var HEADS_FLAG = "--heads";
+var ORIGIN_REMOTE = "origin";
+var HEADS_REF_PREFIX = "refs/heads/";
+function ls_remote_branch_arguments(branch_name) {
+  return [LS_REMOTE_COMMAND, HEADS_FLAG, ORIGIN_REMOTE, `${HEADS_REF_PREFIX}${branch_name}`];
+}
+
+// scripts/git/repository-lock.ts
+import { randomUUID } from "node:crypto";
+import { linkSync, renameSync, rmSync } from "node:fs";
+import { setTimeout as sleep } from "node:timers/promises";
+
+// scripts/git/git-common-directory.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+
+// 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-common-directory.ts
+var OWN_GIT_DIRECTORY = 0;
+var COMMON_GIT_DIRECTORY = 1;
+var PROBE_TIMEOUT_MS2 = 5e3;
+var answers = /* @__PURE__ */ new Map();
+function probe_environment(cwd) {
+  if (cwd === void 0) return process.env;
+  return { ...process.env, ...git_location_environment.location_free_environment() };
+}
+function cache_key(cwd) {
+  if (cwd !== void 0) return `explicit\0${cwd}`;
+  const locations = GIT_LOCATION_VARIABLES.map((name) => process.env[name] ?? "");
+  return ["inherited", process.cwd(), ...locations].join("\0");
+}
+function read_directories(cwd) {
+  try {
+    const output = execFileSync2(
+      git_utilities.get_git_command_for_spawn(),
+      [...git_command.GIT_DIRECTORY_ARGUMENTS],
+      {
+        cwd,
+        env: probe_environment(cwd),
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: PROBE_TIMEOUT_MS2
+      }
+    );
+    return output.split("\n").filter((line) => line !== "");
+  } catch {
+    return [];
+  }
+}
+function directories(cwd) {
+  const key = cache_key(cwd);
+  const known = answers.get(key);
+  if (known !== void 0) return known;
+  const read = read_directories(cwd);
+  if (read.length > 0) answers.set(key, read);
+  return read;
+}
+function own(cwd) {
+  return directories(cwd)[OWN_GIT_DIRECTORY];
+}
+function repository(cwd) {
+  return directories(cwd)[COMMON_GIT_DIRECTORY];
+}
+function select_linked(found) {
+  const own_directory = found[OWN_GIT_DIRECTORY];
+  const common = found[COMMON_GIT_DIRECTORY];
+  return own_directory !== void 0 && common !== void 0 && own_directory !== common ? common : void 0;
+}
+function resolve(cwd) {
+  return select_linked(directories(cwd));
+}
+var git_common_directory = { directories, own, repository, resolve, select_linked };
+
+// scripts/git/repository-lock.ts
+var POLL_INTERVAL_MS = 200;
+var SYNC_POLL_INTERVAL_MS = 10;
+var SLEEP_CELL = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+function lock_path(prefix, cwd) {
+  return stamp_file.stamp_path(prefix, git_common_directory.repository(cwd) ?? cwd ?? process.cwd());
+}
+function parse_owner(raw) {
+  if (raw === void 0) return void 0;
+  const parsed = process_owner_schema.safeParse(json_value.parse_or_undefined(raw));
+  return parsed.success ? parsed.data : void 0;
+}
+function read_owner(target) {
+  return parse_owner(stamp_file.read_stamp_text(target));
+}
+function is_owner_gone(owner) {
+  return process_identity.is_same_process(owner.pid, owner.process_start) === false;
+}
+function restore(aside, target) {
+  try {
+    linkSync(aside, target);
+  } catch {
+  }
+}
+function stale_record(target, is_gone2) {
+  const raw = stamp_file.read_stamp_text(target);
+  const owner = parse_owner(raw);
+  return owner !== void 0 && is_gone2(owner) ? raw : void 0;
+}
+function move_aside(target) {
+  const aside = `${target}.${String(process.pid)}.${randomUUID()}`;
+  try {
+    renameSync(target, aside);
+    return aside;
+  } catch {
+    return void 0;
+  }
+}
+function clear_stale(target, is_gone2 = is_owner_gone) {
+  const raw = stale_record(target, is_gone2);
+  if (raw === void 0) return;
+  const aside = move_aside(target);
+  if (aside === void 0) return;
+  if (stamp_file.read_stamp_text(aside) !== raw) restore(aside, target);
+  rmSync(aside, { force: true });
+}
+function claim(target) {
+  clear_stale(target);
+  return stamp_file.create_stamp(target, process_identity.own_fields());
+}
+function release(target) {
+  const owner = read_owner(target);
+  if (owner !== void 0 && process_identity.is_own_process(owner.pid, owner.process_start)) {
+    stamp_file.remove_stamp(target);
+  }
+}
+async function acquire(target, max_wait_ms) {
+  const deadline = Date.now() + max_wait_ms;
+  while (!claim(target)) {
+    if (Date.now() >= deadline) return false;
+    await sleep(POLL_INTERVAL_MS);
+  }
+  return true;
+}
+function sleep_sync(ms) {
+  Atomics.wait(SLEEP_CELL, 0, 0, ms);
+}
+function acquire_sync(target, max_wait_ms) {
+  const deadline = Date.now() + max_wait_ms;
+  while (!claim(target)) {
+    if (Date.now() >= deadline) return false;
+    sleep_sync(SYNC_POLL_INTERVAL_MS);
+  }
+  return true;
+}
+async function with_lock(work, target, max_wait_ms) {
+  if (!await acquire(target, max_wait_ms)) return void 0;
+  try {
+    return await work();
+  } finally {
+    release(target);
+  }
+}
+function with_lock_sync(work, target, max_wait_ms) {
+  if (!acquire_sync(target, max_wait_ms)) return void 0;
+  try {
+    return work();
+  } finally {
+    release(target);
+  }
+}
+var repository_lock = { clear_stale, lock_path, with_lock, with_lock_sync };
+
+// scripts/git/git-worktree.ts
+var WORKTREE = "worktree";
+var WORKTREE_LOCK_PREFIX = "josh-worktree-lock-";
+var WORKTREE_LOCK_MAX_WAIT_MS = 12e4;
+async function locked(arguments_, timeout_ms) {
+  const target = repository_lock.lock_path(WORKTREE_LOCK_PREFIX);
+  const output = await repository_lock.with_lock(
+    async () => await git_spawn.read(arguments_, timeout_ms),
+    target,
+    WORKTREE_LOCK_MAX_WAIT_MS
+  );
+  if (output === void 0) {
+    throw new Error(
+      `git ${arguments_.join(" ")}: timed out waiting for the work-tree lock ${target}`
+    );
+  }
+  return output;
+}
+async function worktree_list() {
+  return await git_spawn.read([WORKTREE, "list", PORCELAIN_FLAG]);
+}
+async function worktree_add(directory, branch_name, start_point) {
+  const flags = start_point === void 0 ? ["add"] : ["add", "--no-track", "-b", branch_name];
+  return await locked([WORKTREE, ...flags, directory, start_point ?? branch_name], SUITE_TIMEOUT_MS);
+}
+async function worktree_add_detached(directory, commit) {
+  return await locked([WORKTREE, "add", "--detach", directory, commit], SUITE_TIMEOUT_MS);
+}
+async function worktree_remove(directory) {
+  return await locked([WORKTREE, "remove", "--force", directory], INSTALL_TIMEOUT_MS);
+}
+async function worktree_prune() {
+  return await locked([WORKTREE, "prune"]);
+}
+async function ls_remote_branch(branch_name) {
+  return await git_spawn.read_remote(ls_remote_branch_arguments(branch_name));
+}
+async function branch_delete(branch_name) {
+  return await git_spawn.read(["branch", "-D", branch_name]);
+}
+var git_worktree = {
+  branch_delete,
+  ls_remote_branch,
+  worktree_add,
+  worktree_add_detached,
+  worktree_list,
+  worktree_prune,
+  worktree_remove
+};
+
+// scripts/agent/agent-role-profile.ts
+import { z as z2 } from "zod";
+var FIRST_PRINTABLE_CODE = 32;
+var DELETE_CODE = 127;
+var FIRST_CODE_POINT = 0;
+var EMPTY_LENGTH = 0;
+var MAX_VALUE_LENGTH = 4096;
+var ROLE_SCHEMA = z2.enum(["scheduler", "worker", "reviewer"]);
+var PROVIDER_SCHEMA = z2.enum(["anthropic", "openai"]);
+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_SCHEMA.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 ANTHROPIC_PROVIDER = "anthropic";
+var OPENAI_PROVIDER = "openai";
+var OPENAI_MODEL = "gpt-6.1-sol";
+var ANTHROPIC_MODEL = "claude-opus-5-5";
+var CODEX_SESSION_KEY = "CODEX_THREAD_ID";
+var DEFAULT_PROFILES = {
+  scheduler: {
+    provider: ANTHROPIC_PROVIDER,
+    role: SCHEDULER,
+    model: ANTHROPIC_MODEL,
+    effort: "medium"
+  },
+  worker: { provider: ANTHROPIC_PROVIDER, role: WORKER, model: ANTHROPIC_MODEL, effort: "medium" },
+  reviewer: {
+    provider: ANTHROPIC_PROVIDER,
+    role: REVIEWER,
+    model: ANTHROPIC_MODEL,
+    effort: "high"
+  }
+};
+var OPENAI_PROFILES = {
+  scheduler: { provider: OPENAI_PROVIDER, role: SCHEDULER, model: OPENAI_MODEL, effort: "medium" },
+  worker: { provider: OPENAI_PROVIDER, role: WORKER, model: OPENAI_MODEL, effort: "medium" },
+  reviewer: { provider: OPENAI_PROVIDER, role: REVIEWER, model: OPENAI_MODEL, effort: "high" }
+};
+var PROVIDER_PROFILES = { anthropic: DEFAULT_PROFILES, openai: OPENAI_PROFILES };
+var SHIP_EFFORT = "low";
+var PHASE_EFFORT = {
+  worker: { [PRE_GATE_PHASE]: SHIP_EFFORT }
+};
+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" };
+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_safe_value(value) {
+  if (value.length === EMPTY_LENGTH || value.length > MAX_VALUE_LENGTH) return false;
+  for (const character of value) if (is_control_character(character)) return false;
+  return true;
+}
+function trimmed(value) {
+  const result = value?.trim();
+  return result === void 0 || result.length === EMPTY_LENGTH ? void 0 : result;
+}
+function override_value(role, field, environment3) {
+  const key = ENV_KEYS[role][field];
+  const value = trimmed(environment3[key]);
+  if (value !== void 0) return { key, value };
+  if (role !== WORKER) return { key, value: void 0 };
+  const legacy = LEGACY_WORKER_KEYS[field];
+  const legacy_value = trimmed(environment3[legacy]);
+  return legacy_value === void 0 ? { key, value: void 0 } : { key: legacy, value: legacy_value };
+}
+function model_override(role, environment3, provider) {
+  const key = ENV_KEYS[role].model;
+  return provider === OPENAI_PROVIDER ? { key, value: void 0 } : override_value(role, "model", environment3);
+}
+function rejection(key, value, expected) {
+  return { kind: "rejected", note: `${key}=${value} ${expected}, so the agent was not started` };
+}
+function resolved_effort(override, fallback) {
+  const parsed = EFFORT_SCHEMA.safeParse(override.value ?? fallback);
+  return parsed.success ? { kind: "effort", effort: parsed.data } : rejection(override.key, override.value ?? "", "is not an allowed effort");
+}
+function has_session(environment3, keys) {
+  return keys.some((key) => trimmed(environment3[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(environment3) {
+  const value = trimmed(environment3[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(environment3) {
+  const has_codex = has_session(environment3, [CODEX_SESSION_KEY]);
+  const has_claude = has_session(environment3, 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(environment3 = process.env) {
+  return detected_provider(environment3) ?? handed_provider(environment3);
+}
+function default_notice(environment3 = process.env) {
+  const selected = resolve_provider(environment3);
+  return selected.kind === "provider" && selected.is_default === true ? DEFAULT_NOTICE : "";
+}
+function warn_of_default(environment3 = process.env) {
+  const notice = default_notice(environment3).trim();
+  if (notice !== "") console.error(notice);
+}
+function has_completion_callback(environment3 = process.env) {
+  const selected = resolve_provider(environment3);
+  return selected.kind !== "provider" || selected.provider !== OPENAI_PROVIDER;
+}
+function handoff_environment(environment3 = process.env) {
+  const selected = resolve_provider(environment3);
+  return selected.kind === "provider" ? { [HANDED_PROVIDER_KEY]: selected.provider } : {};
+}
+function validate(profile, model_key) {
+  if (!is_safe_value(profile.model)) {
+    return rejection(model_key, profile.model, "is not a safe model");
+  }
+  return { kind: "profile", profile };
+}
+function phase_effort(role, phase, fallback) {
+  const parsed = PHASE_SCHEMA.safeParse(phase);
+  if (!parsed.success) return fallback;
+  return PHASE_EFFORT[role]?.[parsed.data] ?? fallback;
+}
+function overridden_effort(profile, phase, environment3) {
+  const parsed = EFFORT_SCHEMA.safeParse(override_value(profile.role, "effort", environment3).value);
+  return parsed.success ? parsed.data : phase_effort(profile.role, phase, profile.effort);
+}
+function with_phase_effort(profile, phase, environment3 = process.env) {
+  return { ...profile, effort: overridden_effort(profile, phase, environment3) };
+}
+function resolve2(role, environment3 = process.env, phase) {
+  const selected = resolve_provider(environment3);
+  if (selected.kind === "rejected") return selected;
+  const defaults = PROVIDER_PROFILES[selected.provider][role];
+  const model = model_override(role, environment3, selected.provider);
+  const effort = override_value(role, "effort", environment3);
+  const resolved = resolved_effort(effort, phase_effort(role, 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 describe(profile) {
+  return `provider=${profile.provider} role=${profile.role} model=${profile.model} effort=${profile.effort}`;
+}
+function parse(value) {
+  const parsed = PROFILE_SCHEMA.safeParse(value);
+  return parsed.success && is_safe_value(parsed.data.model) ? parsed.data : void 0;
+}
+var agent_role_profile = {
+  CODEX_SESSION_KEY,
+  DEFAULT_PROFILES,
+  HANDED_PROVIDER_KEY,
+  IMPLEMENTATION_PHASE,
+  MAX_VALUE_LENGTH,
+  OPENAI_PROFILES,
+  PRE_GATE_PHASE,
+  PROFILE_SCHEMA,
+  REVIEWER,
+  SCHEDULER,
+  WORKER,
+  default_notice,
+  describe,
+  handoff_environment,
+  has_completion_callback,
+  is_safe_value,
+  parse,
+  resolve: resolve2,
+  resolve_provider,
+  warn_of_default,
+  with_phase_effort
+};
+
+// scripts/lane/lane-environment.ts
+var LANE_OUTPUT_KEY = "JOSH_LANE_OUTPUT";
+var LANE_PROVIDER_KEY = "JOSH_LANE_AGENT_PROVIDER";
+var LANE_ROLE_KEY = "JOSH_LANE_AGENT_ROLE";
+var LANE_MODEL_KEY = "JOSH_LANE_AGENT_MODEL";
+var LANE_EFFORT_KEY = "JOSH_LANE_AGENT_EFFORT";
+var ASSIGNMENT_SEPARATOR = "=";
+var EXPORT_PREFIX = "export ";
+var QUOTE_CHARACTERS = /* @__PURE__ */ new Set(['"', "'"]);
+var MIN_QUOTED_LENGTH = 2;
+var FIRST_CHARACTER_END = 1;
+var LAST_CHARACTER_START = -1;
+function strip_export(line) {
+  const trimmed2 = line.trimStart();
+  return trimmed2.startsWith(EXPORT_PREFIX) ? trimmed2.slice(EXPORT_PREFIX.length).trimStart() : trimmed2;
+}
+function is_key_line(line, key) {
+  const body = strip_export(line);
+  if (!body.startsWith(key)) return false;
+  return body.slice(key.length).trimStart().startsWith(ASSIGNMENT_SEPARATOR);
+}
+function is_seat_line(line) {
+  return is_key_line(line, LANE_SEAT_KEY);
+}
+function is_output_line(line) {
+  return is_key_line(line, LANE_OUTPUT_KEY);
+}
+function split_lines(content) {
+  const trimmed2 = content.trimEnd();
+  return trimmed2.length === 0 ? [] : trimmed2.split("\n");
+}
+function is_quoted(raw) {
+  const first = raw.slice(0, FIRST_CHARACTER_END);
+  if (!QUOTE_CHARACTERS.has(first)) return false;
+  return raw.length >= MIN_QUOTED_LENGTH && raw.endsWith(first);
+}
+function unquote(raw) {
+  return is_quoted(raw) ? raw.slice(FIRST_CHARACTER_END, LAST_CHARACTER_START) : raw;
+}
+function assignment_value(line) {
+  return unquote(line.slice(line.indexOf(ASSIGNMENT_SEPARATOR) + FIRST_CHARACTER_END).trim());
+}
+function read_assignment(content, key) {
+  const line = split_lines(content).findLast((entry) => is_key_line(entry, key));
+  return line === void 0 ? void 0 : assignment_value(line);
+}
+function read_root_seed(content) {
+  return ports.resolve_seed({ [PORT_SEED_KEY]: read_assignment(content, PORT_SEED_KEY) });
+}
+function read_lane_seat(content) {
+  const raw = read_assignment(content, LANE_SEAT_KEY);
+  return raw === void 0 ? void 0 : ports.resolve_lane({ [LANE_SEAT_KEY]: raw });
+}
+function read_lane_ports(content) {
+  const environment3 = {
+    [PORT_SEED_KEY]: read_assignment(content, PORT_SEED_KEY),
+    [LANE_SEAT_KEY]: read_assignment(content, LANE_SEAT_KEY)
+  };
+  return {
+    development: ports.resolve_development_port(environment3),
+    preview: ports.resolve_preview_port(environment3)
+  };
+}
+function read_lane_output(content) {
+  const line = split_lines(content).findLast((entry) => is_output_line(entry));
+  const raw = line === void 0 ? void 0 : assignment_value(line);
+  return raw === void 0 || raw.length === 0 ? void 0 : raw;
+}
+function read_lane_profile(content) {
+  return agent_role_profile.parse({
+    provider: read_assignment(content, LANE_PROVIDER_KEY),
+    role: read_assignment(content, LANE_ROLE_KEY),
+    model: read_assignment(content, LANE_MODEL_KEY),
+    effort: read_assignment(content, LANE_EFFORT_KEY)
+  });
+}
+function replace_assignment(lines, keep, assignment, key) {
+  return lines.flatMap((entry, index) => {
+    if (index === keep) return [assignment];
+    if (is_key_line(entry, key)) return [];
+    return [entry];
+  });
+}
+function upsert_assignment(content, key, value) {
+  const assignment = `${key}${ASSIGNMENT_SEPARATOR}${value}`;
+  const lines = split_lines(content);
+  const last = lines.findLastIndex((entry) => is_key_line(entry, key));
+  const body = last === -1 ? [...lines, assignment] : replace_assignment(lines, last, assignment, key);
+  return `${body.join("\n")}
+`;
+}
+function lane_file_content(root_content, seat) {
+  return upsert_assignment(root_content, LANE_SEAT_KEY, String(seat));
+}
+function with_lane_output(content, output, profile) {
+  const recorded = upsert_assignment(content, LANE_OUTPUT_KEY, `"${output}"`);
+  if (profile === void 0) return recorded;
+  const with_provider = upsert_assignment(recorded, LANE_PROVIDER_KEY, profile.provider);
+  const with_role = upsert_assignment(with_provider, LANE_ROLE_KEY, profile.role);
+  const with_model = upsert_assignment(with_role, LANE_MODEL_KEY, profile.model);
+  return upsert_assignment(with_model, LANE_EFFORT_KEY, profile.effort);
+}
+var lane_environment = {
+  is_seat_line,
+  lane_file_content,
+  read_lane_output,
+  read_lane_profile,
+  read_lane_ports,
+  read_lane_seat,
+  read_root_seed,
+  with_lane_output
+};
+
+// scripts/lane/lane-registry.ts
+var WORKTREE_PREFIX = "worktree ";
+var BRANCH_PREFIX = "branch refs/heads/";
+var BLOCK_SEPARATOR = "\n\n";
+function line_value(lines, prefix) {
+  return lines.find((line) => line.startsWith(prefix))?.slice(prefix.length);
+}
+function seat_from_content(content) {
+  const seat = lane_environment.read_lane_seat(content);
+  if (seat === void 0) return void 0;
+  const port_pair = lane_environment.read_lane_ports(content);
+  return { seat, development_port: port_pair.development, preview_port: port_pair.preview };
+}
+var EMPTY_SEAT = {
+  seat: void 0,
+  development_port: void 0,
+  preview_port: void 0
+};
+function held_seat(content) {
+  if (content === void 0) return EMPTY_SEAT;
+  return seat_from_content(content) ?? EMPTY_SEAT;
+}
+function read_environment(directory) {
+  return file_reader.read_if_readable(path2.join(directory, ENV_FILE_NAME));
+}
+function branch_issue(branch) {
+  if (!branch?.endsWith(lane_paths.LANE_BRANCH_SUFFIX)) return void 0;
+  const issue = branch.slice(0, -lane_paths.LANE_BRANCH_SUFFIX.length);
+  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue) ? issue : void 0;
+}
+function is_gone(directory) {
+  return !existsSync2(directory);
+}
+function build_lane(issue, branch, directory, is_stranded) {
+  const content = is_stranded ? void 0 : read_environment(directory);
+  const held = held_seat(content);
+  const output = content === void 0 ? void 0 : lane_environment.read_lane_output(content);
+  const profile = content === void 0 ? void 0 : lane_environment.read_lane_profile(content);
+  return {
+    issue,
+    branch,
+    directory,
+    seat: held.seat,
+    development_port: held.development_port,
+    preview_port: held.preview_port,
+    output,
+    profile,
+    is_stranded
+  };
+}
+function is_lane_directory(root, issue, directory) {
+  return directory === lane_paths.lane_directory(root, issue);
+}
+function parse_block(block, root) {
+  const lines = block.split("\n");
+  const directory = line_value(lines, WORKTREE_PREFIX);
+  const branch = line_value(lines, BRANCH_PREFIX);
+  const issue = branch_issue(branch);
+  if (directory === void 0 || branch === void 0 || issue === void 0) return void 0;
+  if (!is_lane_directory(root, issue, directory)) return void 0;
+  return build_lane(issue, branch, directory, is_gone(directory));
+}
+function is_lane(lane) {
+  return lane !== void 0;
+}
+async function worktree_blocks() {
+  const listing = await git_worktree.worktree_list();
+  return listing.split(BLOCK_SEPARATOR);
+}
+async function main_repository_root() {
+  return repo_discovery.main_worktree(await git_command.repository_root());
+}
+async function list_lanes() {
+  const root = lane_paths.lane_root(await main_repository_root());
+  const blocks = await worktree_blocks();
+  const lanes = blocks.map((block) => parse_block(block, root)).filter(is_lane);
+  return lanes.toSorted((left, right) => Number(left.issue) - Number(right.issue));
+}
+async function registered_directories() {
+  const blocks = await worktree_blocks();
+  return blocks.flatMap((block) => line_value(block.split("\n"), WORKTREE_PREFIX) ?? []);
+}
+async function has_lanes_in_flight() {
+  const lanes = await list_lanes();
+  return lanes.some((lane) => !lane.is_stranded);
+}
+function used_seats(lanes) {
+  return lanes.map((lane) => lane.seat).filter((seat) => seat !== void 0);
+}
+function unreadable_lanes(lanes) {
+  return lanes.filter((lane) => !lane.is_stranded && lane.seat === void 0);
+}
+function find_lane(lanes, issue) {
+  return lanes.find((lane) => lane.issue === issue);
+}
+async function find_open_lane(issue) {
+  return find_lane(await list_lanes(), issue);
+}
+var lane_registry = {
+  find_lane,
+  find_open_lane,
+  has_lanes_in_flight,
+  list_lanes,
+  main_repository_root,
+  parse_block,
+  read_environment,
+  registered_directories,
+  unreadable_lanes,
+  used_seats
+};
+
+// scripts/run/run-headless.ts
+var HEADLESS_ENV_KEY = "JOSH_RUN_HEADLESS";
+var HEADLESS_VALUE = "1";
+function environment2() {
+  return { [HEADLESS_ENV_KEY]: HEADLESS_VALUE };
+}
+function is_headless2(source = process.env) {
+  return source[HEADLESS_ENV_KEY] === HEADLESS_VALUE;
+}
+function is_headless_parent(source) {
+  return is_headless2(source) && lane_child_marker.marked_issue(source) === void 0;
+}
+function is_cut_capped(carry, source = process.env) {
+  return !is_headless_parent(source) && run_carry.is_at_cut_cap(carry);
+}
+function is_driving(read) {
+  return read?.kind === "carried" && read.carry.is_handed_off !== true;
+}
+async function read_carry_here() {
+  const repository2 = await run_carry.repository_directory();
+  return repository2 === void 0 ? void 0 : run_carry.read_carry(run_carry.carry_path(repository2));
+}
+async function must_keep_waiting(source = process.env) {
+  if (!is_headless_parent(source) || !await lane_registry.has_lanes_in_flight()) return false;
+  return is_driving(await read_carry_here());
+}
+async function current_carry() {
+  const read = await read_carry_here();
+  return read?.kind === "carried" ? read.carry : void 0;
+}
+function is_owned_here(carry, ancestry) {
+  return carry.owner_pid !== void 0 && ancestry().has(carry.owner_pid);
+}
+function driven_here(read, ancestry) {
+  if (read?.kind !== "carried" || !is_driving(read)) return void 0;
+  return is_owned_here(read.carry, ancestry) ? read.carry : void 0;
+}
+async function driving_carry(source = process.env, ancestry = lane_reap.own_ancestry) {
+  if (lane_child_marker.marked_issue(source) !== void 0) return void 0;
+  return driven_here(await read_carry_here(), ancestry);
+}
+async function is_backlog_parent(source = process.env, ancestry = lane_reap.own_ancestry) {
+  return await driving_carry(source, ancestry) !== void 0;
+}
+var run_headless = {
+  HEADLESS_ENV_KEY,
+  current_carry,
+  driven_here,
+  driving_carry,
+  environment: environment2,
+  is_backlog_parent,
+  is_cut_capped,
+  is_headless: is_headless2,
+  is_owned_here,
+  must_keep_waiting
+};
+
+// scripts/run/detached-launch.ts
+import { spawn } from "node:child_process";
+import { closeSync, constants, openSync, writeSync } from "node:fs";
+
+// scripts/agent/agent-launch-environment.ts
+import { existsSync as existsSync3, lstatSync, mkdirSync, readlinkSync, symlinkSync, unlinkSync } from "node:fs";
+import path4 from "node:path";
+
+// scripts/gh/gh-cli-token.ts
+import { execaSync } from "execa";
+var GH_CLI_TIMEOUT_MS = 5e3;
+function get() {
+  try {
+    const { stdout } = execaSync("gh", ["auth", "token"], { timeout: GH_CLI_TIMEOUT_MS });
+    const token = stdout.trim();
+    return token.length > 0 ? token : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var gh_cli_token = { get };
+
+// scripts/agent/agent-session-role.ts
+var KEY2 = "JOSH_AGENT_ROLE";
+function environment_for(role) {
+  return { [KEY2]: role };
+}
+function is_reviewer(source = process.env) {
+  return source[KEY2] === agent_role_profile.REVIEWER;
+}
+var agent_session_role = { KEY: KEY2, env_for: environment_for, is_reviewer };
+
+// scripts/agent/codex-home-source.ts
+import os from "node:os";
+import path3 from "node:path";
+function default_home() {
+  return path3.join(os.homedir(), ".codex");
+}
+var codex_home_source = { default_home };
+
+// scripts/agent/agent-launch-environment.ts
+var OPENAI_PROVIDER2 = "openai";
+var REVIEWER_HOME = ["node_modules", ".cache", "josh", "openai", "reviewer-home"];
+var HOME_FILES = ["auth.json", "config.toml"];
+var PRIVATE_DIRECTORY_MODE = 448;
+function openai_environment() {
+  const token = gh_cli_token.get();
+  return token === void 0 ? { TMPDIR: PLATFORM_TEMP_ROOT } : { GH_TOKEN: token, TMPDIR: PLATFORM_TEMP_ROOT };
+}
+function remove_old_home_link(source, target) {
+  const current = lstatSync(target, { throwIfNoEntry: false });
+  if (current === void 0) return false;
+  if (!current.isSymbolicLink()) throw new Error(`Reviewer home file is not a link: ${target}`);
+  if (existsSync3(source) && readlinkSync(target) === source) return true;
+  unlinkSync(target);
+  return false;
+}
+function link_home_file(source_home, target_home, name) {
+  const source = path4.join(source_home, name);
+  const target = path4.join(target_home, name);
+  if (!remove_old_home_link(source, target) && existsSync3(source)) symlinkSync(source, target);
+}
+function reviewer_home(cwd, environment3) {
+  const source = environment3["CODEX_HOME"] ?? process.env["CODEX_HOME"] ?? codex_home_source.default_home();
+  const target = path4.resolve(cwd, ...REVIEWER_HOME);
+  mkdirSync(target, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+  for (const name of HOME_FILES) link_home_file(source, target, name);
+  return target;
+}
+function build(cwd, profile, environment3 = {}) {
+  if (profile === void 0) return environment3;
+  const marked = {
+    ...agent_headless.environment(),
+    ...agent_session_role.env_for(profile.role),
+    ...environment3
+  };
+  if (profile.provider !== OPENAI_PROVIDER2) return marked;
+  const base = { ...openai_environment(), ...marked };
+  return profile.role === agent_role_profile.REVIEWER ? { ...base, CODEX_HOME: reviewer_home(cwd, environment3) } : base;
+}
+var agent_launch_environment = { build };
+
+// scripts/run/detached-launch.ts
+var NO_PID_NOTE = "the process started without a pid";
+var UNSAFE_NOTE = "the wake command or its arguments contain characters that are not safe to execute";
+var { is_safe_value: is_safe_value2 } = agent_role_profile;
+function is_safe_argv(argv) {
+  return is_safe_value2(argv.command) && argv.args.every((value) => is_safe_value2(value));
+}
+function note_of(error) {
+  return error instanceof Error ? error.message : JSON.stringify(error);
+}
+function launched(pid) {
+  return { kind: "launched", pid };
+}
+var LOG_FLAGS = constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW;
+var LOG_MODE = 384;
+function profile_suffix(profile) {
+  return profile === void 0 ? "" : ` \xB7 ${agent_role_profile.describe(profile)}`;
+}
+function log_header(argv, profile) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString();
+  return `
+=== ${stamp} \xB7 started by process ${String(process.pid)} \xB7 ${argv.command}${profile_suffix(profile)} ===
+`;
+}
+function opened_log(log_path, on_error) {
+  const descriptor = openSync(log_path, LOG_FLAGS, LOG_MODE);
+  if (!stamp_file.is_own_regular_file(log_path)) {
+    closeSync(descriptor);
+    on_error(`${log_path} is not this account's own file, so nothing is kept there`);
+    return void 0;
+  }
+  return descriptor;
+}
+function stamped(descriptor, argv, profile, on_error) {
+  if (descriptor === void 0) return;
+  try {
+    writeSync(descriptor, log_header(argv, profile));
+  } catch (error) {
+    on_error(`the session log could not be written: ${note_of(error)}`);
+  }
+}
+function open_log(log_path, on_error) {
+  if (log_path === void 0) return void 0;
+  try {
+    return opened_log(log_path, on_error);
+  } catch (error) {
+    on_error(`the session log at ${log_path} could not be opened: ${note_of(error)}`);
+    return void 0;
+  }
+}
+function ensure_log(log_path, on_error) {
+  const descriptor = open_log(log_path, on_error);
+  if (descriptor !== void 0) closeSync(descriptor);
+}
+function spawn_options(cwd, log, environment3 = {}, is_detached = true) {
+  return {
+    cwd,
+    detached: is_detached,
+    stdio: log === void 0 ? "ignore" : ["ignore", log, log],
+    env: { ...process.env, ...agent_session_environment.removed_environment(), ...environment3 }
+  };
+}
+function notify_spawn(pid, on_spawn, on_error) {
+  if (pid === void 0) return;
+  try {
+    on_spawn(pid);
+  } catch (error) {
+    on_error(`the child state could not be recorded: ${note_of(error)}`);
+  }
+}
+async function attached_spawn(request, log, on_error, on_spawn) {
+  return await new Promise((resolve3) => {
+    const environment3 = agent_launch_environment.build(request.cwd, request.profile, request.env);
+    const child = spawn(
+      request.argv.command,
+      [...request.argv.args],
+      spawn_options(request.cwd, log, environment3, false)
+    );
+    child.once("error", (error) => {
+      on_error(note_of(error));
+      resolve3({ kind: "failed", note: note_of(error) });
+    });
+    child.once("exit", (exit_code) => {
+      resolve3({ kind: "completed", pid: child.pid ?? 0, exit_code });
+    });
+    notify_spawn(child.pid, on_spawn, on_error);
+  });
+}
+function ignore_spawn(_pid) {
+}
+function spawned(request, log, on_error) {
+  const { command, args } = request.argv;
+  const environment3 = agent_launch_environment.build(request.cwd, request.profile, request.env);
+  const child = spawn(command, [...args], spawn_options(request.cwd, log, environment3));
+  child.on("error", (error) => {
+    on_error(note_of(error));
+  });
+  child.unref();
+  return child.pid === void 0 ? { kind: "failed", note: NO_PID_NOTE } : launched(child.pid);
+}
+function launch(request, on_error) {
+  if (!is_safe_argv(request.argv)) return { kind: "failed", note: UNSAFE_NOTE };
+  const log = open_log(request.log_path, on_error);
+  try {
+    stamped(log, request.argv, request.profile, on_error);
+    return spawned(request, log, on_error);
+  } catch (error) {
+    return { kind: "failed", note: note_of(error) };
+  } finally {
+    if (log !== void 0) closeSync(log);
+  }
+}
+async function launch_attached(request, on_error, on_spawn = ignore_spawn) {
+  if (!is_safe_argv(request.argv)) return { kind: "failed", note: UNSAFE_NOTE };
+  const log = open_log(request.log_path, on_error);
+  try {
+    stamped(log, request.argv, request.profile, on_error);
+    return await attached_spawn(request, log, on_error, on_spawn);
+  } catch (error) {
+    return { kind: "failed", note: note_of(error) };
+  } finally {
+    if (log !== void 0) closeSync(log);
+  }
+}
+var detached_launch = {
+  UNSAFE_NOTE,
+  ensure_log,
+  is_safe_argv,
+  is_safe_value: is_safe_value2,
+  launch,
+  launch_attached,
+  log_header,
+  note_of
+};
+
+export {
+  issue_cite,
+  git_common_directory,
+  repository_lock,
+  run_ship_stage,
+  agent_role_profile,
+  agent_session_role,
+  lane_child_invocation,
+  repo_origin,
+  repo_discovery,
+  agent_headless,
+  detached_launch,
+  lane_registry,
+  run_headless
+};