@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-MDGPJOLK.js

@@ -0,0 +1,351 @@
+import {
+  issue_read
+} from "./chunk-3F3RNIG2.js";
+import {
+  git_gh_issue_read
+} from "./chunk-TFYYXETQ.js";
+import {
+  lane_state
+} from "./chunk-7EAYFMDN.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  durable_state
+} from "./chunk-DS53UUDH.js";
+import {
+  git_common_directory
+} from "./chunk-JPMAW2VZ.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/lane/lane-plan-approval.ts
+import { z } from "zod";
+var evidence_schema = z.object({
+  issue: z.number().int().positive(),
+  paths: z.array(z.string().min(1)).min(1),
+  source: z.url(),
+  rationale: z.string().trim().min(1)
+});
+var lines_axis = {
+  declared_lines: z.number().int().positive(),
+  max_lines: z.number().int().positive()
+};
+var files_axis = {
+  declared_files: z.number().int().positive(),
+  max_files: z.number().int().positive()
+};
+var scope_schema = z.union([
+  evidence_schema.extend({ ...lines_axis, ...files_axis }),
+  evidence_schema.extend(lines_axis),
+  evidence_schema.extend(files_axis)
+]);
+var approval_schema = z.intersection(
+  scope_schema,
+  z.object({ author: z.string(), body: z.string() })
+);
+var FLAG = "--size-approval";
+var FLAG_WIDTH = 2;
+function split(argv) {
+  const at = argv.indexOf(FLAG);
+  if (at === -1) return { tokens: argv };
+  return {
+    tokens: [...argv.slice(0, at), ...argv.slice(at + FLAG_WIDTH)],
+    file: argv[at + 1] ?? ""
+  };
+}
+function is_source(row, source) {
+  return row.html_url === source && row.is_trusted === true;
+}
+function scope_of(file) {
+  const text = file_reader.read_if_readable(file) ?? "";
+  return json_value.parse_with(text, scope_schema);
+}
+async function read(file, issue) {
+  const scope = scope_of(file);
+  if (scope?.issue !== issue) return void 0;
+  const raw = await git_gh_issue_read.issue_list_comments(String(issue));
+  const comments = await issue_read.parse_comments(raw);
+  const comment = comments?.find((row) => is_source(row, scope.source));
+  if (comment === void 0) return void 0;
+  return { ...scope, author: comment.author, body: comment.body };
+}
+async function attach(plan, file) {
+  if (file === void 0) return plan;
+  const approval = await read(file, plan.issue);
+  return approval === void 0 ? void 0 : { ...plan, size_approval: approval };
+}
+function bounds(approval, reason) {
+  if (reason === "lines" && "declared_lines" in approval) {
+    return { declared: approval.declared_lines, max: approval.max_lines };
+  }
+  if (reason === "files" && "declared_files" in approval) {
+    return { declared: approval.declared_files, max: approval.max_files };
+  }
+  return void 0;
+}
+function allows(approval, plan, over) {
+  const bound = bounds(approval, over.reason);
+  if (bound === void 0) return false;
+  return approval.issue === plan.issue && plan.paths.every((file) => approval.paths.includes(file)) && over.declared === bound.declared && over.measured <= bound.max;
+}
+var lane_plan_approval = { allows, approval_schema, attach, read, split };
+
+// scripts/backlog/backlog-overlap.ts
+var CODE_SPAN = /`([^`\s]+)`/gu;
+var LINE_SUFFIX = /:\d+(?:[-:]\d+)?$/u;
+var FILE_EXTENSION = /\.[a-z]\w*$/iu;
+var ROOT_FILE_EXTENSION = /\.(?:[cm]?[jt]sx?|svelte|jsonc?|md|ya?ml|css|html|sh|toml|txt|properties)$/u;
+var GLOB = "*";
+var ISSUE_MARK = "#";
+var SEPARATOR = "/";
+var MIN_DIRECTORY_DEPTH = 2;
+var DOCS_DIRECTORY = "docs/";
+var MARKDOWN = ".md";
+function without_glob(path) {
+  const glob = path.indexOf(GLOB);
+  return glob === -1 ? path : path.slice(0, path.lastIndexOf(SEPARATOR, glob) + 1);
+}
+function is_narrow(directory) {
+  return directory.split(SEPARATOR).filter(Boolean).length >= MIN_DIRECTORY_DEPTH;
+}
+function is_file(path) {
+  return (path.includes(SEPARATOR) ? FILE_EXTENSION : ROOT_FILE_EXTENSION).test(path);
+}
+function claim_of(path) {
+  if (path.endsWith(SEPARATOR)) return is_narrow(path) ? path : void 0;
+  return is_file(path) ? path : void 0;
+}
+function path_claims(tokens) {
+  const paths = tokens.filter((token) => !token.includes(ISSUE_MARK)).map((token) => claim_of(without_glob(token.replace(LINE_SUFFIX, ""))));
+  return new Set(paths.filter((path) => path !== void 0));
+}
+function declared_paths(body) {
+  return path_claims([...body.matchAll(CODE_SPAN)].map((match) => match[1] ?? ""));
+}
+function declared_of(issues) {
+  return new Map(issues.map((issue) => [issue.number, declared_paths(issue.body ?? "")]));
+}
+function contains(outer, inner) {
+  return outer.endsWith(SEPARATOR) ? inner.startsWith(outer) : outer === inner;
+}
+function is_shared_document(path) {
+  return path.startsWith(DOCS_DIRECTORY) && (path.endsWith(SEPARATOR) || path.endsWith(MARKDOWN));
+}
+function overlaps(left, right) {
+  if (is_shared_document(left) || is_shared_document(right)) return false;
+  return contains(left, right) || contains(right, left);
+}
+function claims_of(declared, holders) {
+  const pairs = holders.flatMap(
+    (number) => [...declared.get(number) ?? []].map((path) => [path, number])
+  );
+  return new Map(pairs);
+}
+function running_numbers(read3) {
+  return read3.kind === "busy" ? read3.issues.map((issue) => issue.number) : [];
+}
+function running_claims(declared, read3) {
+  return claims_of(declared, running_numbers(read3));
+}
+function paths_of(child, declared, repo) {
+  if (child.repo !== repo) return /* @__PURE__ */ new Set();
+  return declared.get(child.number) ?? /* @__PURE__ */ new Set();
+}
+function clash_of(claims, paths) {
+  const clashes = [...paths].flatMap(
+    (path) => [...claims].filter(([claimed]) => overlaps(claimed, path)).map(([claimed, holder]) => ({ path, claimed, holder }))
+  );
+  return clashes[0];
+}
+function path_clash(paths, declared, holders) {
+  return clash_of(claims_of(declared, holders), paths);
+}
+function running_clash(child, declared, holding) {
+  return path_clash(paths_of(child, declared, holding.repo), declared, holding.holders);
+}
+function holds(declared, holder, waiting) {
+  return clash_of(claims_of(declared, [holder]), declared.get(waiting) ?? /* @__PURE__ */ new Set()) !== void 0;
+}
+function paused_tail(clash, lanes) {
+  const note = lane_state.paused_note(lanes.get(String(clash.holder)));
+  return note === void 0 ? "" : ` \u2014 ${note}`;
+}
+function clash_note(child, clash, lanes) {
+  const waiting = session_cite.issue(child.number, void 0, child.repo);
+  const holder = session_cite.issue(clash.holder, void 0, child.repo);
+  return `${waiting} waits: its \`${clash.path}\` overlaps \`${clash.claimed}\`, which ${holder} declares${paused_tail(clash, lanes)}.`;
+}
+function visit(walk, child, paths) {
+  const clash = clash_of(walk.claims, paths);
+  if (clash === void 0) {
+    walk.offered.push(child);
+    for (const path of paths) walk.claims.set(path, child.number);
+    return;
+  }
+  walk.withheld.push(child);
+  walk.notes.push(clash_note(child, clash, walk.lanes));
+}
+function merged_notice(notice, notes) {
+  const parts = notice === void 0 ? notes : [notice, ...notes];
+  return parts.length === 0 ? void 0 : parts.join("\n");
+}
+function separate(selection, declared, context) {
+  const walk = {
+    claims: running_claims(declared, context.read),
+    lanes: context.lanes ?? /* @__PURE__ */ new Map(),
+    offered: [],
+    withheld: [],
+    notes: []
+  };
+  for (const child of selection.offered) visit(walk, child, paths_of(child, declared, context.repo));
+  const notice = merged_notice(selection.notice, walk.notes);
+  const withheld = [...walk.withheld, ...selection.withheld];
+  return { offered: walk.offered, withheld, ...notice !== void 0 && { notice } };
+}
+var backlog_overlap = {
+  declared_of,
+  declared_paths,
+  holds,
+  path_claims,
+  path_clash,
+  running_clash,
+  running_numbers,
+  separate
+};
+
+// scripts/lane/lane-plan.ts
+import fs from "node:fs";
+import { z as z2 } from "zod";
+var lane_plan_schema = z2.object({
+  issue: z2.number(),
+  paths: z2.array(z2.string()),
+  planned_at: z2.string(),
+  estimated_size: z2.object({ files: z2.number(), lines: z2.number() }).optional(),
+  size_approval: lane_plan_approval.approval_schema.optional(),
+  // `--single`: the plan is one deliverable with no separately-mergeable part, so a files-axis overrun
+  // is noted for the pre-gate `run:cut` to verify rather than refused (joshuafolkken/kit#6647).
+  single: z2.boolean().optional(),
+  cleared: z2.boolean().optional(),
+  // The plan met the size bar (`lane-plan-size.ts`), whatever the overlap check answered after it.
+  sized: z2.boolean().optional(),
+  // The lane gave its lane back on this plan (`lane-yield.ts`), so the plan outlives the lane.
+  yielded: z2.boolean().optional(),
+  // When the lane's bounded wait on a later-dispatched holder ends (`lane-plan-wait.ts`), ISO time.
+  waits_until: z2.string().optional(),
+  // Every path an earlier cleared plan of this lane held (joshuafolkken/kit#5672), so a re-plan that
+  // narrows `paths` keeps the files the lane already cleared and edited planned for the hunks axis.
+  cleared_paths: z2.array(z2.string()).optional()
+});
+function plan_path(repository, issue) {
+  return durable_state.path(durable_state.PREFIX.LANE_PLAN, repository, `-${String(issue)}.json`);
+}
+function read2(issue, directory) {
+  const repository = git_common_directory.repository(directory);
+  const text = repository === void 0 ? void 0 : stamp_file.read_stamp_text(plan_path(repository, issue));
+  return text === void 0 ? void 0 : json_value.parse_with(text, lane_plan_schema);
+}
+function cleared_history(prior) {
+  const latest = prior?.cleared === true ? prior.paths : [];
+  return [.../* @__PURE__ */ new Set([...prior?.cleared_paths ?? [], ...latest])];
+}
+function with_history(plan, prior) {
+  const cleared_paths = cleared_history(prior);
+  return cleared_paths.length === 0 ? plan : { ...plan, cleared_paths };
+}
+function record(plan, directory) {
+  const repository = git_common_directory.repository(directory);
+  if (repository === void 0) return false;
+  const recorded = with_history(plan, read2(plan.issue, directory));
+  stamp_file.replace_stamp(plan_path(repository, plan.issue), recorded);
+  return true;
+}
+function remove(issue, directory) {
+  const repository = git_common_directory.repository(directory);
+  if (repository !== void 0) stamp_file.remove_stamp(plan_path(repository, issue));
+}
+function is_uncleared(issue, directory) {
+  return git_common_directory.repository(directory) !== void 0 && read2(issue, directory)?.cleared !== true;
+}
+function is_sized(plan) {
+  return plan?.sized === true || plan?.cleared === true;
+}
+function release(issue, directory) {
+  if (read2(issue, directory)?.yielded !== true) remove(issue, directory);
+}
+function recorded_ms(issue, directory) {
+  const repository = git_common_directory.repository(directory);
+  const stats = repository === void 0 ? void 0 : fs.statSync(plan_path(repository, issue), { throwIfNoEntry: false });
+  return stats?.mtimeMs ?? NaN;
+}
+function is_after(commented_at, recorded) {
+  return commented_at !== void 0 && Date.parse(commented_at) > recorded;
+}
+function plan_or(issue, paths, commented_at, directory) {
+  const recorded = read2(issue, directory);
+  if (recorded === void 0 || is_after(commented_at, recorded_ms(issue, directory))) return paths;
+  return new Set(recorded.paths);
+}
+function with_plans(declared, directory, commented = /* @__PURE__ */ new Map()) {
+  const replaced = [...declared].map(([issue, paths]) => [
+    issue,
+    plan_or(issue, paths, commented.get(issue), directory)
+  ]);
+  return new Map(replaced);
+}
+function with_holder_plans(declared, holders, directory) {
+  const added = holders.filter((issue) => !declared.has(issue)).flatMap((issue) => {
+    const recorded = read2(issue, directory);
+    return recorded === void 0 ? [] : [[issue, new Set(recorded.paths)]];
+  });
+  return new Map([...declared, ...added]);
+}
+function goes_before(other, plan) {
+  return other.cleared === true || other.planned_at < plan.planned_at;
+}
+function earlier_holders(plan, holders, directory) {
+  return holders.filter((holder) => {
+    const other = holder === plan.issue ? void 0 : read2(holder, directory);
+    return other !== void 0 && goes_before(other, plan);
+  });
+}
+function clash_of2(plan, declared, directory) {
+  const holders = earlier_holders(plan, [...declared.keys()], directory);
+  return backlog_overlap.path_clash(new Set(plan.paths), declared, holders);
+}
+function is_yielded(issue, directory) {
+  return read2(issue, directory)?.yielded === true;
+}
+function is_yield_held(issue, declared, directory, scope) {
+  const plan = read2(issue, directory);
+  if (plan?.yielded !== true) return false;
+  const held = scope === void 0 ? plan : { ...plan, paths: [...scope] };
+  return clash_of2(held, declared, directory) !== void 0;
+}
+var lane_plan = {
+  clash_of: clash_of2,
+  earlier_holders,
+  is_sized,
+  is_uncleared,
+  is_yield_held,
+  is_yielded,
+  read: read2,
+  record,
+  release,
+  remove,
+  with_holder_plans,
+  with_plans
+};
+
+export {
+  backlog_overlap,
+  lane_plan_approval,
+  lane_plan
+};

package/dist/commands/chunk-MDKRTUE4.js

@@ -0,0 +1,288 @@
+import {
+  timed_fetch
+} from "./chunk-5HVYOIIK.js";
+import {
+  gh_spawn
+} from "./chunk-BFKTUD3V.js";
+import {
+  token_shape
+} from "./chunk-AQ3PMSXK.js";
+import {
+  session_language
+} from "./chunk-OKYFQJW3.js";
+
+// scripts/notify/telegram-notify.ts
+import { z } from "zod";
+
+// scripts/notify/confirmation-options.ts
+var JAPANESE_HEADINGS = {
+  recommended: "\u63A8\u5968:",
+  alternatives: "\u4ED6\u306E\u9078\u629E\u80A2:",
+  none: "\u306A\u3057"
+};
+var ENGLISH_HEADINGS = {
+  recommended: "Recommended:",
+  alternatives: "Alternatives:",
+  none: "none"
+};
+function headings() {
+  const { lang } = session_language.resolve_session_lang();
+  return session_language.is_japanese(lang) ? JAPANESE_HEADINGS : ENGLISH_HEADINGS;
+}
+function alternatives_block(options, labels) {
+  if (options.alternatives.length === 0) return `${labels.alternatives} ${labels.none}`;
+  const lines = options.alternatives.map((alternative) => `- ${alternative}`);
+  return [labels.alternatives, ...lines].join("\n");
+}
+function block(options) {
+  const labels = headings();
+  return `${labels.recommended} ${options.recommended}
+${alternatives_block(options, labels)}`;
+}
+var confirmation_options = { block };
+
+// scripts/notify/notify-opt-in.ts
+var OPT_IN_KEY = "JOSH_NOTIFY_OPT_IN";
+var OPTIONAL_TASK_TYPES = /* @__PURE__ */ new Set(["planning", "completion"]);
+var LIST_SEPARATOR = ",";
+function opted_in_types() {
+  return (process.env[OPT_IN_KEY] ?? "").split(LIST_SEPARATOR).map((entry) => entry.trim().toLowerCase()).filter((entry) => entry.length > 0);
+}
+function is_skipped(task_type) {
+  if (!OPTIONAL_TASK_TYPES.has(task_type)) return false;
+  return !opted_in_types().includes(task_type);
+}
+function skip_line(task_type) {
+  return `\u{1F515} ${task_type} notifications are not opted in (${OPT_IN_KEY}).`;
+}
+var notify_opt_in = { is_skipped, skip_line };
+
+// scripts/notify/telegram-notify.ts
+var TELEGRAM_API_BASE = "https://api.telegram.org";
+var TELEGRAM_TEXT_LIMIT = 4096;
+var BODY_TRUNCATION_MARK = "\n...";
+var TRAILING_HIGH_SURROGATE = /[\uD800-\uDBFF]$/u;
+var telegram_environment_schema = z.object({
+  telegram_bot_token: z.string().min(1, { message: "TELEGRAM_BOT_TOKEN is required" }),
+  telegram_chat_id: z.string().min(1, { message: "TELEGRAM_CHAT_ID is required" })
+});
+var TASK_DEFINITIONS = {
+  planning: { icon: "\u{1F4CB}", label: "Planning" },
+  completion: { icon: "\u2705", label: "Completion" },
+  failure: { icon: "\u274C", label: "Failure" },
+  warning: { icon: "\u26A0\uFE0F", label: "Completed with a warning" },
+  kickoff_retry: { icon: "\u{1F504}", label: "Kickoff retry" },
+  confirmation: { icon: "\u23F8\uFE0F", label: "Confirmation required" },
+  idle: { icon: "\u{1F4A4}", label: "Backlog run idle \u2014 nothing left to dispatch" },
+  stranded: { icon: "\u{1F6A8}", label: "Run stranded \u2014 nobody is driving it" },
+  progress: { icon: "\u{1F4CA}", label: "Progress" },
+  decision: { icon: "\u{1F916}", label: "Decided by the run \u2014 override with a later decision comment" }
+};
+var NOTIFY_SWITCH_KEY = "JOSH_NOTIFY";
+var NOTIFY_OFF_VALUE = "off";
+var NOT_CONFIGURED_PREFIX = "Telegram is not configured";
+var SEND_FAILED_PREFIX = "Telegram notification failed";
+var REDACTED = "<redacted>";
+var UNKNOWN_ERROR_TEXT = "unknown error";
+function parse_environment_string(value) {
+  return value?.trim() ?? "";
+}
+function join_cause(error) {
+  const { cause } = error;
+  if (!(cause instanceof Error) || cause.message.length === 0) return error.message;
+  return `${error.message}: ${cause.message}`;
+}
+function describe_non_error(error) {
+  return typeof error === "string" ? error : UNKNOWN_ERROR_TEXT;
+}
+function describe_error(error) {
+  if (error instanceof Error) return join_cause(error);
+  return describe_non_error(error);
+}
+function describe_symptom(error) {
+  return error instanceof Error ? error.message : describe_non_error(error);
+}
+function redact_credentials(text, config) {
+  return text.split(config.bot_token).join(REDACTED).split(config.chat_id).join(REDACTED);
+}
+function load_config() {
+  const result = telegram_environment_schema.safeParse({
+    telegram_bot_token: parse_environment_string(process.env["TELEGRAM_BOT_TOKEN"]),
+    telegram_chat_id: parse_environment_string(process.env["TELEGRAM_CHAT_ID"])
+  });
+  if (!result.success) {
+    const error_list = result.error.issues.map((issue) => issue.message).join(", ");
+    throw new Error(`${NOT_CONFIGURED_PREFIX}: ${error_list}`);
+  }
+  return { bot_token: result.data.telegram_bot_token, chat_id: result.data.telegram_chat_id };
+}
+function is_notify_disabled() {
+  return parse_environment_string(process.env[NOTIFY_SWITCH_KEY]).toLowerCase() === NOTIFY_OFF_VALUE;
+}
+function skip_line2(task_type) {
+  if (is_notify_disabled()) {
+    return `\u{1F515} Telegram notifications are disabled (${NOTIFY_SWITCH_KEY}=${NOTIFY_OFF_VALUE}).`;
+  }
+  return notify_opt_in.is_skipped(task_type) ? notify_opt_in.skip_line(task_type) : void 0;
+}
+function build_header(task_type, repo_name) {
+  const { icon, label } = TASK_DEFINITIONS[task_type];
+  if (repo_name === void 0 || repo_name.length === 0) return `${icon} ${label}`;
+  return `${icon} ${repo_name}: ${label}`;
+}
+function push_if_present(target, value) {
+  if (value !== void 0 && value.length > 0) target.push(value);
+}
+function build_title_block(input) {
+  const lines = [build_header(input.task_type, input.repo_name)];
+  push_if_present(lines, input.issue_title);
+  return lines.join("\n");
+}
+function append_url(parts, label, value) {
+  if (value !== void 0 && value.length > 0) parts.push(`${label}: ${value}`);
+}
+function build_url_parts(input) {
+  const parts = [];
+  append_url(parts, "Issue", input.issue_url);
+  append_url(parts, "PR", input.pr_url);
+  return parts;
+}
+function build_blocks(input) {
+  const blocks = [build_title_block(input)];
+  push_if_present(blocks, input.body);
+  push_if_present(blocks, input.choices);
+  blocks.push(...build_url_parts(input));
+  return blocks;
+}
+function join_blocks(input) {
+  return build_blocks(input).join("\n\n");
+}
+function head_of(body, kept) {
+  const head = body.slice(0, kept);
+  return TRAILING_HIGH_SURROGATE.test(head) ? head.slice(0, -1) : head;
+}
+function build_text(input) {
+  const text = join_blocks(input);
+  const overflow = text.length - TELEGRAM_TEXT_LIMIT;
+  if (overflow <= 0 || input.body === void 0) return text;
+  const kept = Math.max(0, input.body.length - overflow - BODY_TRUNCATION_MARK.length);
+  return join_blocks({ ...input, body: `${head_of(input.body, kept)}${BODY_TRUNCATION_MARK}` });
+}
+function outbound_text(input) {
+  token_shape.refuse(join_blocks(input), "The Telegram message");
+  return build_text(input);
+}
+async function post_message(config, text) {
+  const url = `${TELEGRAM_API_BASE}/bot${config.bot_token}/sendMessage`;
+  const response = await timed_fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ chat_id: config.chat_id, text })
+  });
+  if (!response.ok) {
+    throw new Error(`Telegram API error: ${String(response.status)} ${response.statusText}`);
+  }
+}
+function build_send_failure(error, config) {
+  const reason = redact_credentials(describe_error(error), config);
+  return new Error(`${SEND_FAILED_PREFIX}: ${reason}`, { cause: new Error(reason) });
+}
+async function send(input) {
+  const skipped = skip_line2(input.task_type);
+  if (skipped !== void 0) {
+    console.info(skipped);
+    return;
+  }
+  const config = load_config();
+  const text = outbound_text(input);
+  try {
+    await post_message(config, text);
+  } catch (error) {
+    throw build_send_failure(error, config);
+  }
+  console.info("\u{1F4F1} Telegram notification sent.");
+}
+function report_send_failure(error, recovery) {
+  console.error("");
+  console.error(`\u2757 ${describe_symptom(error)}`);
+  console.error("   Nobody was notified, and the run carried on.");
+  if (recovery !== void 0) console.error(`   Recovery: ${recovery}`);
+  console.error("");
+}
+async function send_or_report(input, recovery) {
+  try {
+    await send(input);
+    return true;
+  } catch (error) {
+    report_send_failure(error, recovery);
+    return false;
+  }
+}
+var REPO_LOOKUP_TIMEOUT_MS = 5e3;
+async function warn(input) {
+  return await send_or_report(
+    {
+      task_type: "warning",
+      repo_name: gh_spawn.get_repo_name_with_owner_within(REPO_LOOKUP_TIMEOUT_MS),
+      issue_title: input.issue_title,
+      body: input.body,
+      issue_url: void 0,
+      pr_url: void 0
+    },
+    input.recovery
+  );
+}
+async function confirm(input) {
+  return await send_or_report(
+    {
+      task_type: "confirmation",
+      repo_name: gh_spawn.get_repo_name_with_owner_within(REPO_LOOKUP_TIMEOUT_MS),
+      issue_title: input.issue_title,
+      body: input.body,
+      choices: confirmation_options.block(input),
+      issue_url: void 0,
+      pr_url: void 0
+    },
+    input.recovery
+  );
+}
+async function headline(task_type, input) {
+  return await send_or_report(
+    {
+      task_type,
+      repo_name: gh_spawn.get_repo_name_with_owner_within(REPO_LOOKUP_TIMEOUT_MS),
+      issue_title: void 0,
+      body: input.body,
+      issue_url: void 0,
+      pr_url: void 0
+    },
+    input.recovery
+  );
+}
+async function idle(input) {
+  return await headline("idle", input);
+}
+async function stranded(input) {
+  return await headline("stranded", input);
+}
+async function progress(body) {
+  return await headline("progress", { body, recovery: "pnpm josh run:board --chat" });
+}
+async function decided(input) {
+  return await headline("decision", input);
+}
+var telegram_notify = {
+  confirm,
+  decided,
+  idle,
+  progress,
+  send,
+  send_or_report,
+  stranded,
+  warn
+};
+
+export {
+  confirmation_options,
+  telegram_notify
+};

package/dist/commands/chunk-MFZVRWRS.js

@@ -0,0 +1,34 @@
+import {
+  run_event_scope
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+
+// scripts/run/event/run-event-retry.ts
+var RETRY_PREFIX = "retry #";
+function text_of(issue) {
+  return `${RETRY_PREFIX}${String(issue)}`;
+}
+function is_retry(event) {
+  return event.kind === run_event_stream.EVENT_KIND.ADD && event.text.startsWith(RETRY_PREFIX);
+}
+function current_attempts(events) {
+  const boundaries = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (is_retry(event)) boundaries.set(run_event_scope.issue_named(event), event.pos);
+  }
+  return events.filter(
+    (event) => event.pos >= (boundaries.get(run_event_scope.issue_named(event)) ?? 0)
+  );
+}
+function count_of(events, issue) {
+  return events.filter(
+    (event) => is_retry(event) && run_event_scope.issue_named(event) === String(issue)
+  ).length;
+}
+var run_event_retry = { count_of, current_attempts, is_retry, text_of };
+
+export {
+  run_event_retry
+};