@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-JEYITIWB.js

@@ -0,0 +1,423 @@
+import {
+  cost_pricing
+} from "./chunk-5PLJ7R3D.js";
+import {
+  transcript_cwd
+} from "./chunk-DKM4UJQU.js";
+import {
+  cost_attribute
+} from "./chunk-6CJXLPRI.js";
+import {
+  agent_provider,
+  cost_transcript,
+  cost_usage,
+  own_session
+} from "./chunk-DDZVMXZD.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/cost-runtime/cost-verdict.ts
+var FAILURE_EXIT_CODE = 1;
+var OVER_VERDICT = "over";
+var UNDER_VERDICT = "under";
+function per_request_cost(measurement2) {
+  return measurement2.billed_input_per_request.at(-1) ?? 0;
+}
+function classify(measurement2, limit) {
+  return per_request_cost(measurement2) > limit ? OVER_VERDICT : UNDER_VERDICT;
+}
+function over_summary(measurement2, limit) {
+  const total = measurement2.billed_input_per_request.length;
+  return `${String(per_request_cost(measurement2))} billed input tokens per request, on the newest of ${String(total)} request(s); limit ${String(limit)}`;
+}
+function report_over(measurement2, limit) {
+  if (measurement2 === void 0 || measurement2.billed_input_per_request.length === 0) {
+    console.error("No requests in this session; there is nothing to hand off.");
+    return FAILURE_EXIT_CODE;
+  }
+  console.info(classify(measurement2, limit));
+  console.error(over_summary(measurement2, limit));
+  return 0;
+}
+var cost_verdict = {
+  OVER_VERDICT,
+  UNDER_VERDICT,
+  classify,
+  per_request_cost,
+  report_over
+};
+
+// scripts/cost-runtime/codex-usage.ts
+import { globSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+var THREAD_ID_PATTERN = /^[A-Za-z0-9-]+$/u;
+var SESSION_META_SCHEMA = z.looseObject({
+  type: z.literal("session_meta"),
+  payload: z.looseObject({ id: z.string(), cwd: z.string() })
+});
+var TOTAL_USAGE_SCHEMA = z.looseObject({ input_tokens: z.number().nonnegative() });
+var TOKEN_COUNT_SCHEMA = z.looseObject({
+  type: z.literal("event_msg"),
+  payload: z.looseObject({
+    type: z.literal("token_count"),
+    info: z.looseObject({
+      total_token_usage: TOTAL_USAGE_SCHEMA,
+      last_token_usage: TOTAL_USAGE_SCHEMA
+    })
+  })
+});
+function same_project(cwd, target) {
+  return cost_transcript.session_cwd(cwd) === cost_transcript.session_cwd(target);
+}
+function billed_per_request(usages) {
+  return usages.map((usage) => usage.last_token_usage.input_tokens);
+}
+function measurement_from(content, target, thread_id) {
+  const values = content.split("\n").map((line) => json_value.parse_or_undefined(line));
+  const metadata = values.flatMap((value) => {
+    const parsed = SESSION_META_SCHEMA.safeParse(value);
+    return parsed.success ? [parsed.data] : [];
+  });
+  const usages = values.flatMap((value) => {
+    const parsed = TOKEN_COUNT_SCHEMA.safeParse(value);
+    return parsed.success ? [parsed.data.payload.info] : [];
+  });
+  const session = metadata.find((entry) => entry.payload.id === thread_id);
+  if (session === void 0 || usages.length === 0 || !same_project(session.payload.cwd, target)) {
+    return void 0;
+  }
+  return { billed_input_per_request: billed_per_request(usages) };
+}
+function rollout_files(home, thread_id) {
+  if (!THREAD_ID_PATTERN.test(thread_id)) return [];
+  return globSync(`sessions/**/*${thread_id}.jsonl`, { cwd: home }).map(
+    (file) => path.join(home, file)
+  );
+}
+function read_measurement(file, target, thread_id) {
+  try {
+    return measurement_from(readFileSync(file, "utf8"), target, thread_id);
+  } catch {
+    return void 0;
+  }
+}
+function latest_measurement(files, target, thread_id) {
+  for (const file of files.toReversed()) {
+    const measured = read_measurement(file, target, thread_id);
+    if (measured !== void 0) return measured;
+  }
+  return void 0;
+}
+function measurement(target, default_home, environment = process.env) {
+  const thread_id = environment["CODEX_THREAD_ID"];
+  if (thread_id === void 0) return void 0;
+  const home = environment["CODEX_HOME"] ?? path.join(default_home, ".codex");
+  return latest_measurement(rollout_files(home, thread_id), target, thread_id);
+}
+var codex_usage = { measurement };
+
+// scripts/cost-runtime/context-cut-payback.ts
+var POST_CUT_CONTEXT = 6e4;
+var EXPECTED_REMAINING_REQUESTS = 23;
+function write_over_read(model) {
+  return cost_pricing.CACHE_WRITE_5M_MULTIPLIER / cost_pricing.cache_read_multiplier_of(model);
+}
+function break_even_context(model, remaining = EXPECTED_REMAINING_REQUESTS) {
+  if (remaining <= 0) return Infinity;
+  return Math.round(POST_CUT_CONTEXT * (1 + write_over_read(model) / remaining));
+}
+function break_even_requests(current_context, model) {
+  const saved_per_request = current_context - POST_CUT_CONTEXT;
+  if (saved_per_request <= 0) return Infinity;
+  return POST_CUT_CONTEXT * write_over_read(model) / saved_per_request;
+}
+function pays_back(current_context, model, remaining = EXPECTED_REMAINING_REQUESTS) {
+  return current_context > break_even_context(model, remaining);
+}
+var context_cut_payback = {
+  POST_CUT_CONTEXT,
+  EXPECTED_REMAINING_REQUESTS,
+  break_even_context,
+  break_even_requests,
+  pays_back
+};
+
+// scripts/cost-runtime/cost-corpus.ts
+function accumulate_missing(sessions) {
+  return {
+    no_usage_lines: sessions.reduce((sum, session) => sum + session.no_usage_lines, 0),
+    malformed_lines: sessions.reduce((sum, session) => sum + session.malformed_lines, 0),
+    unreadable_sessions: sessions.filter((session) => !session.is_readable).length,
+    // Filled by the attribution, which is the only step that knows a unit could not follow its
+    // parent; a per-session tally cannot see it, so it is zero here and set for an issue scope below.
+    unattributed_sessions: 0
+  };
+}
+function load_corpus(cwd) {
+  const files = cost_transcript.list_sessions_across(cost_transcript.transcript_directories(cwd));
+  const sessions = files.map((file) => cost_transcript.read_session(file));
+  return { sessions, files, missing: accumulate_missing(sessions) };
+}
+function session_meta(corpus) {
+  return new Map(
+    corpus.files.map((file) => [
+      file.session_id,
+      { is_delegated: file.is_delegated, owner: cost_transcript.owning_session_id(file) }
+    ])
+  );
+}
+function issue_set(records) {
+  const issues = cost_attribute.group_by_issue(records).map((group) => group.issue).filter((issue) => issue !== cost_attribute.UNATTRIBUTED_KEY);
+  return new Set(issues);
+}
+function sole_of(issues) {
+  if (issues.size !== 1) return cost_attribute.UNATTRIBUTED_KEY;
+  return [...issues][0] ?? cost_attribute.UNATTRIBUTED_KEY;
+}
+function owner_sets(corpus, meta) {
+  const own = corpus.sessions.filter(
+    (session) => meta.get(session.session_id)?.is_delegated !== true
+  );
+  return new Map(own.map((session) => [session.session_id, issue_set(session.records)]));
+}
+function pairs_with_inherited(session, inherited, is_delegated) {
+  return cost_attribute.group_by_issue(session.records).flatMap(
+    (group) => group.records.map((record) => ({
+      record,
+      issue: group.issue === cost_attribute.UNATTRIBUTED_KEY ? inherited : group.issue,
+      baseline_tokens: session.baseline_tokens,
+      session_id: session.session_id,
+      is_delegated
+    }))
+  );
+}
+var NO_ISSUES = /* @__PURE__ */ new Set();
+function parent_issues(session, meta, owners) {
+  const entry = meta.get(session.session_id);
+  if (entry?.is_delegated !== true) return NO_ISSUES;
+  return owners.get(entry.owner) ?? NO_ISSUES;
+}
+function pairs_of_session(session, meta, owners) {
+  const is_delegated = meta.get(session.session_id)?.is_delegated === true;
+  const candidates = parent_issues(session, meta, owners);
+  const inherited = is_delegated ? sole_of(candidates) : cost_attribute.UNATTRIBUTED_KEY;
+  const pairs = pairs_with_inherited(session, inherited, is_delegated);
+  const has_unattributed = pairs.some((pair) => pair.issue === cost_attribute.UNATTRIBUTED_KEY);
+  if (!is_delegated || !has_unattributed) return { pairs };
+  return { pairs, unattributed_candidates: candidates };
+}
+function attribute_corpus(corpus) {
+  const meta = session_meta(corpus);
+  const owners = owner_sets(corpus, meta);
+  const per_session = corpus.sessions.map((session) => pairs_of_session(session, meta, owners));
+  return {
+    pairs: per_session.flatMap((one) => one.pairs),
+    unattributed: per_session.flatMap(
+      (one) => one.unattributed_candidates === void 0 ? [] : [one.unattributed_candidates]
+    )
+  };
+}
+function floor_for_issue(unattributed, issue_number) {
+  return unattributed.filter((set) => set.size === 0 || set.has(issue_number)).length;
+}
+function is_better(candidate, existing) {
+  const { UNATTRIBUTED_KEY } = cost_attribute;
+  return existing.issue === UNATTRIBUTED_KEY && candidate.issue !== UNATTRIBUTED_KEY;
+}
+function values_of(best) {
+  const collected = [];
+  for (const [, pair] of best) collected.push(pair);
+  return collected;
+}
+function dedupe_across_sessions(pairs) {
+  const best = /* @__PURE__ */ new Map();
+  for (const pair of pairs) {
+    const existing = best.get(pair.record.request_id);
+    if (existing === void 0 || is_better(pair, existing)) {
+      best.set(pair.record.request_id, pair);
+    }
+  }
+  return values_of(best);
+}
+function attributed(corpus) {
+  return dedupe_across_sessions(attribute_corpus(corpus).pairs);
+}
+function mainline_records(pairs) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const pair of pairs) {
+    if (pair.is_delegated) continue;
+    groups.set(pair.session_id, [...groups.get(pair.session_id) ?? [], pair.record]);
+  }
+  return [...groups.values()];
+}
+var cost_corpus = {
+  load_corpus,
+  attribute_corpus,
+  floor_for_issue,
+  attributed,
+  mainline_records
+};
+
+// scripts/cost-runtime/cost-cli.ts
+var FAILURE_EXIT_CODE2 = 1;
+var USAGE = "Usage: josh cost (--cut | --over <tokens-per-request>) [--path <dir>]";
+var UNMEASURABLE_VERDICT = "unmeasurable";
+var CUT_LIMIT = "cut";
+function to_threshold(raw) {
+  if (raw === void 0 || raw.trim() === "") return void 0;
+  const parsed = Number(raw);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
+}
+function is_unparsed(raw, parsed) {
+  return parsed === void 0 && raw !== void 0;
+}
+function cut_threshold(measurement2) {
+  return context_cut_payback.break_even_context(measurement2?.model);
+}
+function limit_of(limit, measurement2) {
+  return limit === CUT_LIMIT ? cut_threshold(measurement2) : limit;
+}
+function threshold_option(over) {
+  return over === void 0 ? {} : { over };
+}
+function path_option(path2) {
+  return path2 === void 0 ? {} : { path: path2 };
+}
+function cut_options(values) {
+  return values.over === void 0 ? { over: CUT_LIMIT, ...path_option(values.path) } : void 0;
+}
+function to_options(values) {
+  if (values.cut === true) return cut_options(values);
+  const over = to_threshold(values.over);
+  if (is_unparsed(values.over, over)) return void 0;
+  return { ...threshold_option(over), ...path_option(values.path) };
+}
+var PARSE_ARGS_OPTIONS = {
+  cut: { type: "boolean" },
+  over: { type: "string" },
+  path: { type: "string" }
+};
+function parse_options(argv) {
+  const values = cli_flags.values_of(argv, PARSE_ARGS_OPTIONS);
+  return values === void 0 ? void 0 : to_options(values);
+}
+function report_empty(cwd, session_id) {
+  const searched = cost_transcript.searched_directories(cost_transcript.transcript_directories(cwd));
+  for (const line of cost_transcript.missing_message(searched, session_id)) console.error(line);
+  return FAILURE_EXIT_CODE2;
+}
+function provider_of(environment) {
+  const resolved = agent_provider.resolve_provider(environment);
+  if (resolved.kind !== "provider" || resolved.is_default === true) return void 0;
+  return resolved.provider;
+}
+function measurement_of(session) {
+  return {
+    billed_input_per_request: session.records.map(
+      (record) => cost_usage.billed_input(record.totals)
+    ),
+    model: session.records.at(-1)?.model
+  };
+}
+function anthropic_own(target, environment) {
+  const corpus = cost_corpus.load_corpus(target);
+  const selection = own_session.select_own_session(corpus.files, environment);
+  if (selection.kind === "absent") return { kind: "absent", session_id: selection.session_id };
+  const session = corpus.sessions[selection.index];
+  if (session === void 0) return { kind: "empty" };
+  return { kind: "measured", measurement: measurement_of(session) };
+}
+function anthropic_measurement(target, environment) {
+  const own = anthropic_own(target, environment);
+  return own.kind === "measured" ? own.measurement : void 0;
+}
+function same_openai_project(target, cwd) {
+  return cost_transcript.session_cwd(target) === cost_transcript.session_cwd(cwd);
+}
+function reject_openai_cross_project(context, target, cwd) {
+  if (context.provider !== "openai" || context.path === void 0 || same_openai_project(target, cwd)) {
+    return false;
+  }
+  console.error(
+    "OpenAI --path cannot select a thread from another project; run josh cost in that project."
+  );
+  return true;
+}
+function measure(target, provider, environment) {
+  return provider === "openai" ? codex_usage.measurement(target, cost_transcript.home_directory(), environment) : anthropic_measurement(target, environment);
+}
+function run_over_anthropic(own, target, limit) {
+  if (own.kind === "measured") {
+    return cost_verdict.report_over(own.measurement, limit_of(limit, own.measurement));
+  }
+  return report_empty(target, own.kind === "absent" ? own.session_id : void 0);
+}
+function run_over_codex(target, limit, environment) {
+  const measurement2 = measure(target, "openai", environment);
+  if (measurement2 !== void 0) {
+    return cost_verdict.report_over(measurement2, limit_of(limit, measurement2));
+  }
+  console.error(`No Codex usage found for the current OpenAI thread under ${target}.`);
+  return FAILURE_EXIT_CODE2;
+}
+function run_over(target, limit, provider, environment) {
+  if (provider === "anthropic") {
+    return run_over_anthropic(anthropic_own(target, environment), target, limit);
+  }
+  return run_over_codex(target, limit, environment);
+}
+function verdict_of(measurement2) {
+  if (measurement2 === void 0 || measurement2.billed_input_per_request.length === 0) {
+    return UNMEASURABLE_VERDICT;
+  }
+  return cost_verdict.classify(measurement2, cut_threshold(measurement2));
+}
+function figures_of(measurement2) {
+  const verdict = verdict_of(measurement2);
+  const is_priced = measurement2 !== void 0 && verdict !== UNMEASURABLE_VERDICT;
+  const cost = is_priced ? cost_verdict.per_request_cost(measurement2) : void 0;
+  return { verdict, cost, threshold: cut_threshold(measurement2) };
+}
+function session_figures(cwd = process.cwd(), environment = process.env) {
+  const provider = provider_of(environment);
+  return figures_of(provider === void 0 ? void 0 : measure(cwd, provider, environment));
+}
+function session_verdict(cwd = process.cwd(), environment = process.env) {
+  return session_figures(cwd, environment).verdict;
+}
+function run_context(argv, environment) {
+  const options = parse_options(argv);
+  if (options?.over === void 0) return void 0;
+  const provider = provider_of(environment);
+  if (provider === void 0) return void 0;
+  return { over: options.over, path: options.path, provider };
+}
+function run(argv, cwd = process.cwd(), environment = process.env) {
+  const context = run_context(argv, environment);
+  if (context === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE2;
+  }
+  const target = transcript_cwd.resolve(context.path, cwd);
+  if (reject_openai_cross_project(context, target, cwd)) return FAILURE_EXIT_CODE2;
+  return run_over(target, context.over, context.provider, environment);
+}
+var cost_cli = {
+  UNMEASURABLE_VERDICT,
+  USAGE,
+  parse_options,
+  to_threshold,
+  run,
+  session_figures,
+  session_verdict
+};
+
+export {
+  cost_verdict,
+  cost_cli
+};

package/dist/commands/chunk-JGX7JIW4.js

@@ -0,0 +1,126 @@
+import {
+  review_tree
+} from "./chunk-R36VZIKU.js";
+import {
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+
+// scripts/review/review-round-one-blobs.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+var ABSENT = review_tree.ABSENT_DIGEST;
+var SUCCESS_EXIT_CODE = 0;
+var NUL = "\0";
+var NEWLINE = "\n";
+var TAB = "	";
+var SPACE = " ";
+var OID_FIELD = 2;
+var WRITE_FLAGS = ["-w"];
+var READ_FLAGS = [];
+function repository_root() {
+  return git_spawn_sync.read(["rev-parse", "--show-toplevel"]);
+}
+function hash_paths(root, paths, flags) {
+  const present = paths.filter((relative) => existsSync(path.join(root, relative)));
+  const output = present.length === 0 ? "" : git_spawn_sync.read(["hash-object", ...flags, "--", ...present], { cwd: root });
+  if (output === void 0) return void 0;
+  const hashes = output.split(NEWLINE);
+  const hashed = new Map(present.map((relative, index) => [relative, hashes[index] ?? ABSENT]));
+  return Object.fromEntries(paths.map((relative) => [relative, hashed.get(relative) ?? ABSENT]));
+}
+function parse_entry(entry) {
+  const tab = entry.indexOf(TAB);
+  return [entry.slice(tab + 1), entry.slice(0, tab).split(SPACE)[OID_FIELD] ?? ABSENT];
+}
+function blobs_at(commit, paths, root) {
+  const result = git_spawn_sync.run(["ls-tree", "-r", "-z", commit, "--", ...paths], { cwd: root });
+  if (result.exit_code !== SUCCESS_EXIT_CODE) return void 0;
+  return Object.fromEntries(
+    result.stdout.split(NUL).filter((entry) => entry !== "").map((entry) => parse_entry(entry))
+  );
+}
+function merged_blob({ base, round_one, moved }, root) {
+  if ([base, round_one, moved].includes(ABSENT)) return void 0;
+  return git_spawn_sync.read(["merge-file", "--object-id", round_one, base, moved], { cwd: root });
+}
+function carried_blob(sides, root) {
+  if (sides.round_one === sides.base) return sides.moved;
+  if (sides.moved === sides.base || sides.moved === sides.round_one) return sides.round_one;
+  return merged_blob(sides, root);
+}
+function sides_of(relative, readings) {
+  const base = readings.before[relative] ?? ABSENT;
+  return {
+    base,
+    round_one: readings.blobs[relative] ?? base,
+    moved: readings.after[relative] ?? ABSENT
+  };
+}
+function carried_answer(relative, readings, root) {
+  const carried = carried_blob(sides_of(relative, readings), root);
+  return carried === void 0 ? void 0 : carried === readings.now[relative];
+}
+function differing(paths, readings, root) {
+  const answers = paths.map((relative) => carried_answer(relative, readings, root));
+  if (answers.includes(void 0)) return void 0;
+  return paths.filter((_relative, index) => answers[index] === false);
+}
+function read_readings(input, paths, root) {
+  const before = blobs_at(input.from, paths, root);
+  const after = blobs_at(input.to, paths, root);
+  const now = hash_paths(root, paths, READ_FLAGS);
+  if (before === void 0 || after === void 0 || now === void 0) return void 0;
+  return { blobs: input.blobs, before, after, now };
+}
+function delta_of(input, root) {
+  const paths = [.../* @__PURE__ */ new Set([...Object.keys(input.blobs), ...input.paths])].toSorted(
+    (left, right) => left.localeCompare(right)
+  );
+  const readings = paths.length === 0 ? void 0 : read_readings(input, paths, root);
+  if (paths.length === 0) return [];
+  return readings === void 0 ? void 0 : differing(paths, readings, root);
+}
+function carry_of({ blobs, from, to, paths }) {
+  if (blobs === void 0 || from === void 0 || to === void 0) return void 0;
+  return { blobs, from, to, paths };
+}
+function carried_delta(input) {
+  const carry = carry_of(input);
+  const root = repository_root();
+  return carry === void 0 || root === void 0 ? void 0 : delta_of(carry, root);
+}
+function answers_of(carry, root) {
+  const { paths } = carry;
+  const readings = paths.length === 0 ? void 0 : read_readings(carry, paths, root);
+  if (paths.length === 0) return {};
+  if (readings === void 0) return void 0;
+  return Object.fromEntries(
+    paths.map((relative) => [relative, carried_answer(relative, readings, root)])
+  );
+}
+function carried_each(input) {
+  const carry = carry_of(input);
+  const root = repository_root();
+  return carry === void 0 || root === void 0 ? void 0 : answers_of(carry, root);
+}
+function unmoved_between(from, to, paths, root) {
+  if (from === to || paths.length === 0) return paths;
+  const before = blobs_at(from, paths, root);
+  const after = blobs_at(to, paths, root);
+  if (before === void 0 || after === void 0) return void 0;
+  return paths.filter((relative) => (before[relative] ?? ABSENT) === (after[relative] ?? ABSENT));
+}
+function unmoved({ from, to, paths }) {
+  const root = repository_root();
+  if (root === void 0 || from === void 0 || to === void 0) return void 0;
+  return unmoved_between(from, to, paths, root);
+}
+function capture(paths) {
+  const root = repository_root();
+  return root === void 0 ? void 0 : hash_paths(root, paths, WRITE_FLAGS);
+}
+var review_round_one_blobs = { capture, carried_delta, carried_each, unmoved };
+
+export {
+  review_round_one_blobs
+};

package/dist/commands/chunk-JHIGDFBS.js

@@ -0,0 +1,59 @@
+import {
+  epic_parse
+} from "./chunk-VDGNXSP3.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  parse_json_object_or_undefined
+} from "./chunk-43DU7DYZ.js";
+
+// scripts/lib/settled-together.ts
+async function settled_together(first, second) {
+  const [result, other] = await Promise.allSettled([first, second]);
+  if (result.status === "rejected") throw result.reason;
+  if (other.status === "rejected") throw other.reason;
+}
+
+// scripts/followup/git-followup-issue-close.ts
+import { z } from "zod";
+var CLOSE_WAIT = { attempts: 3, interval_ms: 2e3 };
+var CLOSE_RECOVERY = "gh api -X PATCH repos/{owner}/{repo}/issues/<N> -f state=closed";
+var state_read_schema = z.object({ state: z.string().optional() });
+async function is_issue_closed(issue_number) {
+  const raw = await git_gh_command.issue_get_state_and_relations(issue_number);
+  const parsed = raw === void 0 ? void 0 : parse_json_object_or_undefined(raw, state_read_schema);
+  return epic_parse.is_state_closed(parsed?.state);
+}
+var FOLLOWUP_CLOSER = "pnpm josh followup";
+function build_close_comment(pr_url, closer = FOLLOWUP_CLOSER) {
+  return `Closed by \`${closer}\`: ${pr_url ?? "the merged pull request"} merged, but GitHub did not apply its \`closes #N\` keyword (joshuafolkken/kit#2770).`;
+}
+async function ensure_issue_closed(input, wait = CLOSE_WAIT) {
+  const { issue_number } = input;
+  const is_done = issue_number === void 0 || await poll.poll_until(async () => await is_issue_closed(issue_number), wait);
+  if (is_done) return;
+  console.warn(
+    `\u26A0\uFE0F  Issue ${session_cite.issue(issue_number)} is still open after the merge \u2014 closing it.`
+  );
+  const comment = build_close_comment(input.pr_url, input.closer);
+  if (!await git_gh_command.issue_close(issue_number, comment)) {
+    throw new Error(`gh api could not close issue ${session_cite.issue(issue_number)}`);
+  }
+}
+var git_followup_issue_close = {
+  ensure_issue_closed,
+  build_close_comment,
+  CLOSE_RECOVERY
+};
+
+export {
+  settled_together,
+  git_followup_issue_close
+};

package/dist/commands/chunk-JI2EGXZX.js

@@ -0,0 +1,53 @@
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+
+// scripts/josh/path-decision.ts
+var STAGED_FLAG = "--staged";
+var JSON_FLAG = "--json";
+var KNOWN_FLAGS = [STAGED_FLAG, JSON_FLAG];
+var FAILURE_EXIT_CODE = 1;
+var MAX_LISTED_PATHS = 5;
+function has_unknown_flag(argv, known) {
+  return argv.some((argument) => !known.includes(argument));
+}
+function parse_options(argv) {
+  if (has_unknown_flag(argv, KNOWN_FLAGS)) return void 0;
+  return { is_staged: argv.includes(STAGED_FLAG), is_json: argv.includes(JSON_FLAG) };
+}
+function format_path_list(paths) {
+  const listed = paths.slice(0, MAX_LISTED_PATHS).join(", ");
+  if (paths.length <= MAX_LISTED_PATHS) return listed;
+  return `${listed}, +${String(paths.length - MAX_LISTED_PATHS)} more`;
+}
+function print_decision(key, answer, reason, is_json) {
+  if (is_json) {
+    console.info(JSON.stringify({ [key]: answer, reason }));
+    return;
+  }
+  console.info(answer);
+  console.error(reason);
+}
+async function run_path_decision(argv, command) {
+  const options = parse_options(argv);
+  if (options === void 0) {
+    console.error(command.usage);
+    return FAILURE_EXIT_CODE;
+  }
+  const paths = await changed_paths.read_changed_paths(options.is_staged);
+  const answer = await command.decide(paths, options.is_staged);
+  print_decision(command.key, answer, command.explain(paths, answer), options.is_json);
+  return 0;
+}
+var path_decision = {
+  format_path_list,
+  has_unknown_flag,
+  JSON_FLAG,
+  parse_options,
+  print_decision,
+  run_path_decision
+};
+
+export {
+  path_decision
+};