@joshuafolkken/kit 1.887.0 → 1.921.0

package/dist/hooks/{chunk-4OXFU3MK.js → chunk-O2FBZPSW.js}

@@ -1,6 +1,9 @@
 import {
   ALREADY_DONE_LABEL,
+  BREAKING_CHANGE_LABEL,
+  BUG_LABEL,
   CONTEXT_CUT_THRESHOLD,
+  ENHANCEMENT_LABEL,
   FULL_PAGE_QUERY,
   IN_PROGRESS_LABEL,
   NEEDS_DECISION_LABEL,
@@ -15,6 +18,7 @@ import {
   git_gh_api_path,
   git_gh_exec,
   has_any_label,
+  has_label_name,
   has_stderr_field,
   lane_park,
   lane_registry,
@@ -29,28 +33,31 @@ import {
   run_watcher_guard,
   shell_segments,
   tail_commands
-} from "./chunk-VGYSA2NT.js";
+} from "./chunk-LC765SUA.js";
+import {
+  find_local_bin_upwards
+} from "./chunk-3V37IID6.js";
 import {
   batch_outcome
-} from "./chunk-FRJKVSK3.js";
+} from "./chunk-77RLKZ5V.js";
 import {
   investigation_refusal
-} from "./chunk-ZBK4XRAS.js";
+} from "./chunk-NWD47MW3.js";
 import {
   duplicate_read_outcome
-} from "./chunk-PRDCNGA6.js";
+} from "./chunk-UANRLZV7.js";
 import {
   investigation_reads
-} from "./chunk-Y5OYCU2F.js";
+} from "./chunk-XMR3BS35.js";
 import {
   lane_guard_policy,
   time_batch_guard
-} from "./chunk-36UE53LS.js";
+} from "./chunk-3HZ5MJIW.js";
 import {
   hook_decision,
   lane_child_marker,
   run_issue_number
-} from "./chunk-FNFOLFFV.js";
+} from "./chunk-OYU6KPRA.js";
 import {
   PLATFORM_TEMP_ROOT,
   cost_attribute,
@@ -60,12 +67,13 @@ import {
   json_value,
   lane_paths,
   stamp_file,
+  time_density_hook,
   time_shell
-} from "./chunk-264QY6KS.js";
+} from "./chunk-UULARQ5Q.js";
 
 // scripts/hooks/pretool-guard.ts
 import { text } from "node:stream/consumers";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // scripts/run/run-progress.ts
 var DEFAULT_INTERVAL_MINUTES = 20;
@@ -803,8 +811,8 @@ function selected_threshold(values) {
 function threshold_option(over) {
   return over === void 0 ? {} : { over };
 }
-function path_option(path5) {
-  return path5 === void 0 ? {} : { path: path5 };
+function path_option(path7) {
+  return path7 === void 0 ? {} : { path: path7 };
 }
 function to_options(values) {
   if (values.cut === true && values.over !== void 0) return void 0;
@@ -1050,6 +1058,201 @@ var implementation_cut = {
   uncut_lane_child_issue
 };
 
+// scripts/rules/issue-bug-label.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import path4 from "node:path";
+
+// scripts/issue/markdown-section.ts
+var HEADING_PREFIX = "## ";
+function is_heading(line) {
+  return line.trimStart().startsWith(HEADING_PREFIX);
+}
+function is_the_heading(line, heading) {
+  return line.trim() === heading;
+}
+function next_fence(line, fence) {
+  const marker = /^ {0,3}(`{3,}|~{3,})/u.exec(line)?.[1];
+  if (fence === "") return marker;
+  const closing = new RegExp(
+    String.raw`^ {0,3}${fence.charAt(0)}{${String(fence.length)},}\s*$`,
+    "u"
+  );
+  if (closing.test(line)) return "";
+  return void 0;
+}
+function unfenced_lines(body) {
+  let fence = "";
+  const visible = [];
+  for (const line of body.split("\n")) {
+    const next = next_fence(line, fence);
+    const visible_line = line.replace(/^(?: {4}|\t).*/u, "");
+    visible.push(next === void 0 && fence === "" ? visible_line : "");
+    fence = next ?? fence;
+  }
+  return visible;
+}
+function has_unfenced_line(body, text2) {
+  return unfenced_lines(body).some((line) => line.trim() === text2);
+}
+function has_line(body, text2) {
+  return has_unfenced_line(body, text2);
+}
+function section_lines(body, heading) {
+  const lines = body.split("\n");
+  const visible = unfenced_lines(body);
+  const start = visible.findIndex((line) => is_the_heading(line, heading));
+  if (start === -1) return [];
+  const rest = lines.slice(start + 1);
+  const end = visible.slice(start + 1).findIndex((line) => is_heading(line));
+  return end === -1 ? rest : rest.slice(0, end);
+}
+var markdown_section = { section_lines, is_heading, has_line, has_unfenced_line };
+
+// scripts/issue/issue-bug-label.ts
+var BUG_DECLARATION_LINE = "- \u7A2E\u5225: \u4E0D\u5177\u5408";
+function is_bug_fix(body) {
+  const background = markdown_section.section_lines(body, "## \u80CC\u666F").join("\n");
+  return markdown_section.has_unfenced_line(background, BUG_DECLARATION_LINE);
+}
+var issue_bug_label = { BUG_DECLARATION_LINE, is_bug_fix };
+
+// scripts/issue/issue-classification.ts
+var FEATURE_DECLARATIONS = ["- \u76EE\u7684: \u6A5F\u80FD\u8FFD\u52A0", "- \u76EE\u7684: \u6A5F\u80FD\u6539\u5584"];
+var BREAKING_DECLARATION = "- \u4E92\u63DB\u6027: \u7834\u58CA\u7684\u5909\u66F4";
+var NON_BUG_DECLARATION = "- \u7A2E\u5225: \u975E\u4E0D\u5177\u5408";
+var CLASSIFICATION_LABELS = [BUG_LABEL, ENHANCEMENT_LABEL, BREAKING_CHANGE_LABEL];
+var CONFLICT = "bug and enhancement declarations cannot be combined";
+var MISSING_BUG_CLASSIFICATION = "missing bug classification";
+var CONFLICTING_BUG_CLASSIFICATIONS = "conflicting bug classifications";
+function required_labels(body) {
+  const labels = [];
+  const background = markdown_section.section_lines(body, "## \u80CC\u666F").join("\n");
+  if (issue_bug_label.is_bug_fix(body)) labels.push(BUG_LABEL);
+  if (FEATURE_DECLARATIONS.some((line) => markdown_section.has_unfenced_line(background, line))) {
+    labels.push(ENHANCEMENT_LABEL);
+  }
+  if (markdown_section.has_unfenced_line(background, BREAKING_DECLARATION)) {
+    labels.push(BREAKING_CHANGE_LABEL);
+  }
+  return labels;
+}
+function labels_for(body, existing) {
+  const missing = required_labels(body).filter((label) => !has_label_name(existing, label));
+  return [...existing, ...missing];
+}
+function bug_classification_problem(body) {
+  const background = markdown_section.section_lines(body, "## \u80CC\u666F").join("\n");
+  const has_bug = issue_bug_label.is_bug_fix(body);
+  const has_non_bug = markdown_section.has_unfenced_line(background, NON_BUG_DECLARATION);
+  if (!has_bug && !has_non_bug) return MISSING_BUG_CLASSIFICATION;
+  if (has_bug && has_non_bug) return CONFLICTING_BUG_CLASSIFICATIONS;
+  return void 0;
+}
+function problems(body) {
+  const classification_problem = bug_classification_problem(body);
+  const found = [];
+  if (classification_problem !== void 0) found.push(classification_problem);
+  const labels = required_labels(body);
+  if (labels.includes(BUG_LABEL) && labels.includes(ENHANCEMENT_LABEL)) found.push(CONFLICT);
+  return found;
+}
+var issue_classification = {
+  BREAKING_DECLARATION,
+  CLASSIFICATION_LABELS,
+  FEATURE_DECLARATIONS,
+  NON_BUG_DECLARATION,
+  labels_for,
+  problems,
+  required_labels
+};
+
+// scripts/rules/issue-filing-args.ts
+var SHELL_WORD = /(?:[^\s'"]|'[^']*'|"[^"]*")+/gu;
+var QUOTE = /['"]/gu;
+var RAW_FIELDS = /* @__PURE__ */ new Set(["-f", "--raw-field"]);
+var FILE_FIELDS = /* @__PURE__ */ new Set(["-F", "--field"]);
+var LABEL_OPTIONS = /* @__PURE__ */ new Set(["-l", "--label"]);
+var BODY_FILE_OPTIONS = /* @__PURE__ */ new Set(["--body-file"]);
+var INLINE_BODY_OPTIONS = /* @__PURE__ */ new Set(["-b", "--body"]);
+var BODY_FILE_PREFIX = "body=@";
+function words_of2(command) {
+  return [...command.matchAll(SHELL_WORD)].map((match) => match[0].replaceAll(QUOTE, ""));
+}
+function values_after(words, flags) {
+  return words.flatMap((word, index) => {
+    const value = words[index + 1];
+    return value !== void 0 && flags.has(word) ? [value] : [];
+  });
+}
+function has_inline_body(words) {
+  const has_raw = values_after(words, RAW_FIELDS).some((value) => value.startsWith("body="));
+  return has_raw || values_after(words, INLINE_BODY_OPTIONS).length > 0;
+}
+function body_file(command) {
+  const words = words_of2(command);
+  const fields = values_after(words, FILE_FIELDS).filter((value) => value.startsWith("body="));
+  const options = values_after(words, BODY_FILE_OPTIONS);
+  if (has_inline_body(words) || fields.length + options.length !== 1) return void 0;
+  return fields[0]?.startsWith(BODY_FILE_PREFIX) ? fields[0].slice(BODY_FILE_PREFIX.length) : options[0];
+}
+function has_label(command, label) {
+  const words = words_of2(command);
+  const fields = [...values_after(words, RAW_FIELDS), ...values_after(words, FILE_FIELDS)];
+  const options = values_after(words, LABEL_OPTIONS).flatMap((value) => value.split(","));
+  return fields.includes(`labels[]=${label}`) || options.includes(label);
+}
+var issue_filing_args = { body_file, has_label, words_of: words_of2 };
+
+// scripts/rules/issue-bug-label.ts
+var LINT_NAMES = /* @__PURE__ */ new Set(["issue:lint"]);
+var LINT_PATH = /\b(?:issue:lint|iln)\s+(?:'([^']+)'|"([^"]+)"|(\S+))/u;
+function lint_argument(segment) {
+  const [, single_quoted, double_quoted, bare] = LINT_PATH.exec(segment) ?? [];
+  return single_quoted ?? double_quoted ?? bare;
+}
+function latest_lint_path(tail) {
+  const segments = tail_commands.prior_bash_commands(tail).flatMap((command) => shell_segments.segments_of(command));
+  const lint = segments.findLast((segment) => shell_segments.is_josh_command(segment, LINT_NAMES));
+  return lint === void 0 ? void 0 : lint_argument(lint);
+}
+function linted_body(body_path) {
+  try {
+    return readFileSync3(body_path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function matches_linted_file(command, lint_path) {
+  const filing_path = issue_filing_args.body_file(command);
+  return filing_path !== void 0 && path4.resolve(filing_path) === path4.resolve(lint_path);
+}
+function needs_classification_labels(command, tail) {
+  const lint_path = latest_lint_path(tail);
+  if (lint_path === void 0) return false;
+  const body = linted_body(lint_path);
+  if (body === void 0) return false;
+  if (!matches_linted_file(command, lint_path) || issue_classification.problems(body).length > 0) {
+    return true;
+  }
+  const expected = issue_classification.required_labels(body);
+  return issue_classification.CLASSIFICATION_LABELS.some(
+    (label) => expected.includes(label) !== issue_filing_args.has_label(command, label)
+  );
+}
+function decide3(call, run2) {
+  const command = time_shell.bash_command(call.input);
+  const tail = time_density_hook.read_tail(run2.transcript);
+  return needs_classification_labels(command, tail);
+}
+var ISSUE_CLASSIFICATION_REASON = "\u26D4 issue classification mismatch: use the exact body file checked by `pnpm josh issue:lint` in this creation call (`-F body=@<path>` or `gh issue create --body-file <path>`) and apply exactly the `labels:` it reports (`bug`, `enhancement`, `breaking-change`). See `prompts/collaboration-workflow/issue-template.md`.";
+var ROW4 = {
+  id: "issue-bug-label",
+  is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
+  reason: ISSUE_CLASSIFICATION_REASON,
+  decide: decide3
+};
+var issue_bug_label_rule = { ROW: ROW4, latest_lint_path, needs_classification_labels };
+
 // scripts/rules/issue-fold.ts
 var FOLD_NAMES = /* @__PURE__ */ new Set(["issue:fold"]);
 function runs_the_fold(command) {
@@ -1060,14 +1263,14 @@ function already_folded(tail, _call) {
   return tail_commands.prior_bash_commands(tail).some((command) => runs_the_fold(command));
 }
 var ISSUE_FOLD_REASON = '\u26D4 issue fold: this run has filed an Issue before and is filing another with no `pnpm josh issue:fold` between them. Several findings from one session fold into one Issue by default \u2014 the filing-time counterpart to the split assessment, whose two questions it reuses: are the findings separable, and does the whole clearly exceed one verification gate (the size half is `split:assess`, called not recomputed). Reissue after folding: `pnpm josh issue:fold "<title>" "<title>" \u2026` \u2014 `fold` means file one Issue covering them, `separate` means file them apart (separable findings whose combined size clears the split guide), and the default is `fold`. Add `--not-separable` when they are really one deliverable. The procedure is `.claude/skills/workflow-commands/split-assessment.md` \u2192 "The question". It fires once per run and cannot repeat on the call in hand.';
-var ROW4 = {
+var ROW5 = {
   id: "issue-fold",
   is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
   reason: ISSUE_FOLD_REASON,
   already_satisfied: already_folded,
   keeps: bash_triggers.on_bash_command(runs_the_fold)
 };
-var issue_fold = { ISSUE_FOLD_REASON, ROW: ROW4, already_folded, runs_the_fold };
+var issue_fold = { ISSUE_FOLD_REASON, ROW: ROW5, already_folded, runs_the_fold };
 
 // scripts/rules/issue-scout.ts
 var SCOUT_NAMES = /* @__PURE__ */ new Set(["issue:scout"]);
@@ -1078,14 +1281,14 @@ function already_scouted(tail, _call) {
   return tail_commands.prior_bash_commands(tail).some((command) => runs_the_scout(command));
 }
 var ISSUE_SCOUT_REASON = '\u26D4 issue scout: this files an Issue with no `pnpm josh issue:scout` earlier in the run. A duplicate is likeliest for the work that just finished, which is exactly where self-restraint is weakest. Reissue after scouting: `pnpm josh issue:scout "<title>"` (add `--body "<one-line summary, citing #N where the work follows one>"` so the epic half can answer), then read its `Duplicates:` \u2014 an **open** candidate covering the same work stops the run rather than filing a second Issue, and a `(closed)` one means the work is already done \u2014 before reissuing this filing. The procedure is `.claude/skills/workflow-commands/SKILL.md` \u2192 \xA72e. It fires once per run and cannot repeat on the call in hand.';
-var ROW5 = {
+var ROW6 = {
   id: "issue-scout",
   is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
   reason: ISSUE_SCOUT_REASON,
   already_satisfied: already_scouted,
   keeps: bash_triggers.on_bash_command(runs_the_scout)
 };
-var issue_scout = { ISSUE_SCOUT_REASON, ROW: ROW5, already_scouted, runs_the_scout };
+var issue_scout = { ISSUE_SCOUT_REASON, ROW: ROW6, already_scouted, runs_the_scout };
 
 // scripts/rules/josh-git-bare.ts
 var GIT_COMMAND2 = /* @__PURE__ */ new Set(["git"]);
@@ -1101,7 +1304,7 @@ function is_bare_josh_git(command) {
   return shell_segments.segments_of(command).some((segment) => is_bare_segment(segment));
 }
 var JOSH_GIT_BARE_REASON = '\u26D4 bare `pnpm josh git`: this prompts to confirm the staging, and with no TTY the prompt falls to its cancel branch \u2014 `Checking unstaged files... Found` then `Operation cancelled.` \u2014 so the call throws away the time it takes to fail (about 31 seconds in one measured lane) and you reissue it with `-y` anyway (joshuafolkken/kit#2297). Run it unattended from the start: `pnpm josh git -y "<title> #<N>"`. The recovery form that opens the PR for a push that already landed is `pnpm josh git -y --skip-commit --skip-push`. This rule fires on every occurrence, not once per run.';
-var ROW6 = {
+var ROW7 = {
   id: "josh-git-bare",
   is_trigger: bash_triggers.on_bash_command(is_bare_josh_git),
   reason: JOSH_GIT_BARE_REASON,
@@ -1109,7 +1312,7 @@ var ROW6 = {
 };
 var josh_git_bare = {
   JOSH_GIT_BARE_REASON,
-  ROW: ROW6,
+  ROW: ROW7,
   is_bare_josh_git
 };
 
@@ -1123,7 +1326,7 @@ function is_carry_conflict(command, is_lane_child = lane_child_marker.is_child_o
   return is_lane_child;
 }
 var LANE_CARRY_CONFLICT_REASON = '\u26D4 lane child carry conflict: this session is a dispatched lane child, and `pnpm josh run:merge` / `pnpm josh run:carry` are the parent backlogrun budget commands \u2014 a child must never run them. The live carry record here belongs to the parent that launched this child, not to a competing run: the parent holds the one run budget for the repository, and every lane shares the common git directory it is keyed on, so a live owner a lane child reads is always its parent (joshuafolkken/kit#2267, measured 2026-09-21 in backlogrun #2252 \u2014 a child read run:merge `busy` as a competitor and parked #2258 unimplemented). Do not run this command, and do not treat it as a conflict: no `needs-decision`, no `confirmation` Telegram, no question to a person \u2014 a dispatched child cannot ask, and there is nothing to decide. Continue implementing this Issue; the parent owns the budget and counts the outcome at the return. The procedure is `.claude/skills/workflow-commands/pre-gate-cut.md` and `backlogrun-progress.md` \u2192 "The hand-off". This rule fires on every occurrence, not once per run.';
-var ROW7 = {
+var ROW8 = {
   id: "lane-carry-conflict",
   is_trigger: bash_triggers.on_bash_command(is_carry_conflict),
   reason: LANE_CARRY_CONFLICT_REASON,
@@ -1131,7 +1334,7 @@ var ROW7 = {
 };
 var lane_carry_conflict = {
   LANE_CARRY_CONFLICT_REASON,
-  ROW: ROW7,
+  ROW: ROW8,
   invokes_budget_command,
   is_carry_conflict
 };
@@ -1184,13 +1387,13 @@ function is_interactive_ask(call, is_lane_child = lane_child_marker.is_child_of(
   return is_lane_child;
 }
 var LANE_INTERACTIVE_ASK_REASON = '\u26D4 lane child interactive ask: this session is a dispatched lane child and cannot ask a person, so this call is refused. Left to run it would end the turn with nothing on the Issue \u2014 the parent then finds an OPEN Issue with `in-progress` and no question (joshuafolkken/kit#2201; joshuafolkken/kit#2034 placed the same rule one tool-call too late). Do not ask: park the decision instead. Apply `needs-decision` and post a comment carrying the question, the options and whether work was stashed \u2014 `gh api repos/{owner}/{repo}/issues/<N>/labels -f \'labels[]=needs-decision\'` then `pnpm josh issue:comment <N> --body-file <path>` \u2014 then send the `confirmation` Telegram and stop. The procedure is `.claude/skills/workflow-commands/pre-gate-cut.md` \u2192 "A lane child records its park before it stops", and the park itself is `backlogrun-park.md` \u2192 "park and continue". This rule fires on every occurrence, not once per run.';
-var ROW8 = {
+var ROW9 = {
   id: "lane-interactive-ask",
   is_trigger: is_interactive_ask,
   reason: LANE_INTERACTIVE_ASK_REASON,
   decide: () => true
 };
-var lane_interactive_ask = { LANE_INTERACTIVE_ASK_REASON, ROW: ROW8, is_interactive_ask };
+var lane_interactive_ask = { LANE_INTERACTIVE_ASK_REASON, ROW: ROW9, is_interactive_ask };
 
 // scripts/rules/lane-switch-main.ts
 var SWITCH_SUBCOMMAND = "switch";
@@ -1221,7 +1424,7 @@ function is_switch_away_from_lane(command, is_lane_child = lane_child_marker.is_
   return switch_targets(command).some((target) => target !== own_branch);
 }
 var LANE_SWITCH_MAIN_REASON = "\u26D4 lane child on `git switch main`: this session is a dispatched lane child, and switching to the default branch here always fails \u2014 a lane is a linked work tree, the primary checkout holds the default branch, and git allows one branch in one work tree at a time (`fatal: main is already used by worktree at <the primary checkout>`, measured 11 times in the 2026-09-21 backlogrun). Do not switch: the lane is already on its own issue branch, branched from a fresh default before it opened, and the latest default is brought in during the gate by `pnpm josh main:merge`. So skip this step and keep implementing on the current branch \u2014 no `git switch`, no `git pull`. `pnpm josh main:sync` (`josh ms`) is refused in a lane for the same reason, and a lane is finished with `pnpm josh lane:close <issue-number>`. The parent runs `git switch main && git pull` in the primary checkout before each lane opens, never the child \u2014 `backlogrun-lanes.md` and `backlogrun-child.md` are the single sources. This rule fires on every occurrence, not once per run.";
-var ROW9 = {
+var ROW10 = {
   id: "lane-switch-main",
   is_trigger: bash_triggers.on_bash_command(is_switch_away_from_lane),
   reason: LANE_SWITCH_MAIN_REASON,
@@ -1229,7 +1432,7 @@ var ROW9 = {
 };
 var lane_switch_main = {
   LANE_SWITCH_MAIN_REASON,
-  ROW: ROW9,
+  ROW: ROW10,
   is_switch_away_from_lane,
   switch_target,
   switch_targets
@@ -1697,7 +1900,7 @@ function is_poll_loop(command) {
   return LOOP_KEYWORD2.test(plain) && SLEEP_COMMAND.test(plain);
 }
 var POLL_LOOP_REASON = '\u26D4 output poll loop: this hand-writes a `while`/`until` wait loop over a command\'s output, a marker file or a process \u2014 with a `sleep` or, worse, without one \u2014 and the loop does not know when the command finished. A regex that never matches waits to the harness block limit; one that matches a mid-run line exits too early \u2014 either way the command exit is not what ends the wait, and each pass spends a full-context round trip (joshuafolkken/kit#2371 measured about 45 minutes, 13% of six lanes, lost to exactly this). Do not poll the output file. A command known to take minutes \u2014 `pnpm josh gate`, `pnpm josh followup`, `pnpm josh format` \u2014 is started detached from the first with `run_in_background` set, and the harness re-invokes you when it exits: its completion notification is what ends the wait, on the task exit rather than a regex or the block limit. So issue the long command in the background and end the turn \u2014 do not arm a loop; the wake-up brings you back. To glance at interim output, `Read` the output file once, never in a sleep loop. If you are waiting on CI, `pnpm josh followup` waits on it for you. The procedure is `.claude/skills/workflow-commands/background-commands.md`, "A command that can take minutes is issued in the background". **This rule fires on every occurrence, not once per run.**';
-var ROW10 = {
+var ROW11 = {
   id: "poll-loop",
   is_trigger: bash_triggers.on_bash_command(is_poll_loop),
   reason: POLL_LOOP_REASON,
@@ -1705,7 +1908,7 @@ var ROW10 = {
 };
 var poll_loop = {
   POLL_LOOP_REASON,
-  ROW: ROW10,
+  ROW: ROW11,
   is_poll_loop
 };
 
@@ -1825,16 +2028,16 @@ function posts_at_path_literally(command) {
   return RAW_FIELD_BODY_AT.test(command);
 }
 var RAW_FIELD_BODY_REASON = "\u26D4 literal @path body: this passes `body=@<path>` to `gh api` with a raw field flag (`-f` / `--raw-field`), which sends the value verbatim \u2014 the string `@<path>` is posted as the comment, not the file it points at. `-F` / `--field` is the flag that reads the file, and the two spellings differ by one character while `gh` exits 0 and returns a comment URL either way, so the break is invisible until a person reads the issue (joshuafolkken/kit#2304 lost two park comments this way). Post an issue or PR comment with `pnpm josh issue:comment <N> --body-file <path>` \u2014 the one spelling, which cannot take the wrong flag. The rule and the safe forms are in `prompts/collaboration-workflow/shell-body.md`. This rule fires on every occurrence, not once per run.";
-var ROW11 = {
+var ROW12 = {
   id: "raw-field-body",
   is_trigger: bash_triggers.on_bash_command(posts_at_path_literally),
   reason: RAW_FIELD_BODY_REASON,
   decide: () => true
 };
-var raw_field_body = { RAW_FIELD_BODY_REASON, ROW: ROW11, posts_at_path_literally };
+var raw_field_body = { RAW_FIELD_BODY_REASON, ROW: ROW12, posts_at_path_literally };
 
 // scripts/rules/rule-body-guard.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync4 } from "node:fs";
 var EDIT_TOOL = "Edit";
 var WRITE_TOOL = "Write";
 var CLAUDE_DOCUMENT = /(?:^|\/)CLAUDE\.md$/u;
@@ -1857,7 +2060,7 @@ function string_field(input, key) {
   return typeof value === "string" ? value : "";
 }
 function read_existing(file_path) {
-  return existsSync2(file_path) ? readFileSync3(file_path, "utf8") : "";
+  return existsSync2(file_path) ? readFileSync4(file_path, "utf8") : "";
 }
 function texts_of(name, input, read2) {
   if (name === WRITE_TOOL) {
@@ -1903,7 +2106,7 @@ function runs_placement_oracle(command) {
     (names) => shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, names))
   );
 }
-var ROW12 = {
+var ROW13 = {
   id: "rule-body",
   is_trigger: writes_rule_prose,
   reason: RULE_BODY_REASON,
@@ -1912,7 +2115,7 @@ var ROW12 = {
 };
 var rule_body_guard = {
   RULE_BODY_REASON,
-  ROW: ROW12,
+  ROW: ROW13,
   adds_rule_prose,
   answered_placement,
   is_rule_document,
@@ -1957,13 +2160,13 @@ function is_foreground_push_step(call) {
   if (is_backgrounded(call.input)) return false;
   return is_push_step_call(call);
 }
-function decide3() {
+function decide4() {
   return true;
 }
 var RUN_TAIL_REASON = '\u26D4 run tail: this issues the commit-push-PR step in the foreground, where the harness decides when to stop waiting. Reissue it with `run_in_background` set. In `fullrun #1501` this call was given a 900-second timeout, the harness detached it at its own 600-second cap, and nothing read the output for a further 6m28s \u2014 45m03s of wall clock on about 17 minutes of work (joshuafolkken/kit#1510). **Never give a foreground call a timeout above the harness cap**: the cap decides, not the number. A backgrounded call re-invokes you when it exits, so the completion notification is what resumes the run. **When it arrives, the turn that reads it goes straight through any branch-2 filing and `pnpm josh epic:bundle` to `pnpm josh followup` \u2014 the turn never ends at the push.** CI went green 6m06s before the merge started in that run, and it started only because the person asked; joshuafolkken/kit#1333 had already settled that the merge is issued in the turn the review closes. While the push runs, do the work that writes nothing \u2014 drafting the completion body to a file, deciding the branch-2 disposition. `pnpm josh followup` itself stays in the **foreground** \u2014 nearly every step after it reads its result. But a tail does follow the merge, measured at 3.0 min and 5.9% of a run (joshuafolkken/kit#1462), so empty it beforehand: the steps that read the merge result stay after `followup`, and the rest are composed in the turn that issues it, bar the one exception background-commands.md names. The procedure is `.claude/skills/workflow-commands/background-commands.md`, "A command that can take minutes is issued in the background". **This rule fires on every foreground push, not once per run**, so reissuing the same call in the foreground will be refused again.';
 var run_tail = {
   RUN_TAIL_REASON,
-  decide: decide3,
+  decide: decide4,
   is_backgrounded_push_step,
   is_foreground_push_step,
   is_push_step,
@@ -2044,35 +2247,145 @@ var shell_body_trigger = {
 // scripts/test/test-declared-changed.ts
 import { execFileSync } from "node:child_process";
 
+// scripts/gate/project-checks.ts
+import { existsSync as existsSync3, globSync as globSync2, readFileSync as readFileSync5 } from "node:fs";
+import path5 from "node:path";
+
+// scripts/test/skip-marker.ts
+var SKIP_MARKER = "\u2014 skipping";
+
+// scripts/gate/project-checks.ts
+var PACKAGE_JSON = "package.json";
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".venv",
+  "venv",
+  "target",
+  "dist",
+  "build",
+  ".svelte-kit"
+]);
+var WEB_FILES = "**/*.{html,css,js,jsx,mjs,cjs}";
+var SCRIPT_FILES = "**/*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}";
+var TYPE_FILES = "**/*.{ts,tsx,mts,cts}";
+var ESLINT_CONFIGS = [
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.cjs",
+  "eslint.config.ts",
+  "eslint.config.mts",
+  "eslint.config.cts"
+];
+var CSPELL_CONFIGS = [
+  "cspell.config.yaml",
+  "cspell.config.yml",
+  "cspell.config.json",
+  "cspell.config.js",
+  "cspell.config.cjs",
+  "cspell.config.mjs",
+  "cspell.json",
+  "cspell.yaml"
+];
+var TYPE_CONFIGS = ["tsconfig.json", "jsconfig.json"];
+function project_root(directory) {
+  let current = directory;
+  while (!existsSync3(path5.join(current, PACKAGE_JSON))) {
+    const parent = path5.dirname(current);
+    if (parent === current) return directory;
+    current = parent;
+  }
+  return current;
+}
+function is_ignored(entry) {
+  return entry.split(/[/\\]/u).some((part) => IGNORED_DIRS.has(part));
+}
+function has_files(directory, pattern) {
+  return globSync2(pattern, { cwd: project_root(directory), exclude: is_ignored }).length > 0;
+}
+function has_config(directory, names) {
+  return names.some((name) => existsSync3(path5.join(project_root(directory), name)));
+}
+function has_bin(directory, bin_name) {
+  return find_local_bin_upwards(directory, bin_name) !== void 0;
+}
+function josh_settings(manifest) {
+  if (typeof manifest !== "object" || manifest === null || !("josh" in manifest)) return void 0;
+  return manifest.josh;
+}
+function is_static_manifest(manifest) {
+  const josh = josh_settings(manifest);
+  if (typeof josh !== "object" || josh === null || !("profile" in josh)) return false;
+  return josh.profile === "static";
+}
+function is_static(directory) {
+  try {
+    const manifest_path = path5.join(project_root(directory), PACKAGE_JSON);
+    const manifest = JSON.parse(readFileSync5(manifest_path, "utf8"));
+    return is_static_manifest(manifest);
+  } catch {
+    return false;
+  }
+}
+function skip_notice(check3, reason) {
+  return `josh ${check3}: ${reason} ${SKIP_MARKER} ${check3}.`;
+}
+function type_check_skip_reason(directory) {
+  if (!is_static(directory)) return void 0;
+  if (!has_files(directory, TYPE_FILES)) return "no TypeScript files were found";
+  if (!has_config(directory, TYPE_CONFIGS)) return "no TypeScript configuration was found";
+  if (!has_bin(directory, "tsc")) return "typescript is not installed";
+  return void 0;
+}
+var project_checks = {
+  CSPELL_CONFIGS,
+  ESLINT_CONFIGS,
+  SCRIPT_FILES,
+  TYPE_CONFIGS,
+  TYPE_FILES,
+  WEB_FILES,
+  has_bin,
+  has_config,
+  has_files,
+  is_static,
+  project_root,
+  skip_notice,
+  type_check_skip_reason
+};
+
 // scripts/test/test-declared-logic.ts
 var TEST_SUFFIXES = [".e2e.ts", ".test.ts"];
 var EXEMPT_PATHS = [".editorconfig"];
 var EXEMPT_PREFIXES = [".idea/", ".vscode/", "prompts/"];
 var EXEMPT_SUFFIXES = [".md"];
+var STATIC_VISUAL_SUFFIXES = [".html", ".css"];
 function normalize(paths) {
-  return paths.map((path5) => path5.trim()).filter((path5) => path5 !== "");
+  return paths.map((path7) => path7.trim()).filter((path7) => path7 !== "");
 }
-function is_test_file(path5) {
-  return TEST_SUFFIXES.some((suffix) => path5.endsWith(suffix));
+function is_test_file(path7) {
+  return TEST_SUFFIXES.some((suffix) => path7.endsWith(suffix));
 }
-function is_exempt(path5) {
-  if (EXEMPT_PATHS.includes(path5)) return true;
-  return EXEMPT_SUFFIXES.some((suffix) => path5.endsWith(suffix)) || EXEMPT_PREFIXES.some((prefix) => path5.startsWith(prefix));
+function is_static_visual(path7, is_static2) {
+  return is_static2 && STATIC_VISUAL_SUFFIXES.some((suffix) => path7.endsWith(suffix));
 }
-function is_runtime(path5) {
-  return !is_test_file(path5) && !is_exempt(path5);
+function is_exempt(path7, is_static2 = false) {
+  if (EXEMPT_PATHS.includes(path7) || is_static_visual(path7, is_static2)) return true;
+  return EXEMPT_SUFFIXES.some((suffix) => path7.endsWith(suffix)) || EXEMPT_PREFIXES.some((prefix) => path7.startsWith(prefix));
 }
-function verdict_for(paths) {
+function is_runtime(path7, is_static2 = false) {
+  return !is_test_file(path7) && !is_exempt(path7, is_static2);
+}
+function verdict_for(paths, is_static2 = false) {
   const changed = normalize(paths);
-  if (changed.some((path5) => is_test_file(path5))) return "satisfied";
-  if (changed.some((path5) => is_runtime(path5))) return "required";
+  if (changed.some((path7) => is_test_file(path7))) return "satisfied";
+  if (changed.some((path7) => is_runtime(path7, is_static2))) return "required";
   return "exempt";
 }
-function runtime_files(paths) {
-  return normalize(paths).filter((path5) => is_runtime(path5));
+function runtime_files(paths, is_static2 = false) {
+  return normalize(paths).filter((path7) => is_runtime(path7, is_static2));
 }
-function exempt_files(paths) {
-  return normalize(paths).filter((path5) => is_exempt(path5));
+function exempt_files(paths, is_static2 = false) {
+  return normalize(paths).filter((path7) => is_exempt(path7, is_static2));
 }
 var test_declared_logic = {
   EXEMPT_PATHS,
@@ -2111,7 +2424,7 @@ function source_paths() {
   return injected.paths ?? read_changed_paths_sync();
 }
 function current_verdict(paths = source_paths()) {
-  return test_declared_logic.verdict_for(paths);
+  return test_declared_logic.verdict_for(paths, project_checks.is_static(process.cwd()));
 }
 function restore_injection(previous) {
   if (previous === void 0) {
@@ -2137,8 +2450,8 @@ function is_untested_commit(call) {
   return test_declared_changed.current_verdict() === "required";
 }
 var REASON = '\u26D4 test declared: this commits a runtime code change with no test beside it \u2014 `pnpm josh test:declared` reads the working tree as `required` (a changed file that is neither a test \u2014 `*.test.ts` / `*.e2e.ts` \u2014 nor a mechanically-exempt non-runtime path). `CLAUDE.md` \u2192 Code Change Rules requires a test for ALL code changes: a bug fix gets a regression test, a refactor gets tests pinning behavior first, logic gets a unit test, an observable UI/timing change gets an E2E. Add the declared test and reissue this commit. **If the change genuinely touches no executable runtime path** it is the pre-approved non-runtime exception \u2014 declare it in your Step 0 work summary with the reason it is exempt (non-executable config, a cosmetic asset swap) and reissue; the exception is a presentation, not a stop. Run `pnpm josh test:declared` to see the files it names. The procedure is `prompts/collaboration-workflow/rule-delivery.md` \u2192 "\u914D\u9001\u3055\u308C\u3066\u3044\u308B\u898F\u5247". This fires once per run, so reissuing will not repeat on the call in hand.';
-var ROW13 = { id: "test-declared", is_trigger: is_untested_commit, reason: REASON };
-var test_declared_commit = { REASON, ROW: ROW13, is_untested_commit };
+var ROW14 = { id: "test-declared", is_trigger: is_untested_commit, reason: REASON };
+var test_declared_commit = { REASON, ROW: ROW14, is_untested_commit };
 
 // scripts/rules/third-party-write.ts
 function is_third_party_write_segment(segment, session_owner) {
@@ -2154,14 +2467,14 @@ function writes_third_party(command, resolve_owner = repo_party.current_owner) {
   return targets.some((segment) => is_third_party_write_segment(segment, session_owner));
 }
 var THIRD_PARTY_WRITE_REASON = '\u26D4 third-party write: this `gh api` call writes to a repository whose owner is not this session \u2014 a tracker we do not own is Tier C, and every write there (Issue, comment, PR, Discussion, review) needs explicit current-turn user instruction; typing the target, or holding a correct diagnosis, is not that instruction (`CLAUDE.md` \u2192 "Third-party repositories are Tier C", `prompts/collaboration-workflow/upstream-interrupt.md`). Confirm the party with `pnpm josh repo:party <owner/repo>` \u2014 owner equality, computed not judged. A read (`-X GET`, or no field flag) passes untouched; only a write (`-f`/`-F`/`--field`/`--raw-field`/`--input`, or `-X POST|PATCH|PUT|DELETE`) is refused. Record the finding on our own Issue and draft the artifact for a person to post \u2014 do not publish it yourself. **This rule fires on every occurrence, not once per run.**';
-var ROW14 = {
+var ROW15 = {
   id: "third-party-write",
   is_trigger: bash_triggers.on_bash_command((command) => writes_third_party(command)),
   reason: THIRD_PARTY_WRITE_REASON,
   decide: () => true
 };
 var third_party_write = {
-  ROW: ROW14,
+  ROW: ROW15,
   THIRD_PARTY_WRITE_REASON,
   is_third_party_write_segment,
   writes_third_party
@@ -2215,14 +2528,14 @@ function is_unauthorized_worktree_change(command) {
   return shell_segments.segments_of(command).some((segment) => is_unauthorized_segment(segment));
 }
 var WORKTREE_MUTATION_REASON = '\u26D4 unauthorized working-tree change: `git checkout -- <path>`, `git restore <path>` and an unauthorized `git stash` mutate the working tree or the repository-wide stash every work tree shares, and none is on the `.claude/settings.json` deny list (`operating-rules.md`). Do not run them on your own judgement. A commit goes through `pnpm josh git`; a stash pop goes through `pnpm josh stash:pop "<message>"`, never a positional `git stash pop` a shared stack lets another lane divert. A stash push is authorized only inside a documented flow and only with a findable message \u2014 `git stash push -u -m "<message>"` \u2014 which this row allows; a bare `git stash`, a message-less push, or `pop` / `apply` / `drop` is refused. **This rule fires on every occurrence, not once per run.**';
-var ROW15 = {
+var ROW16 = {
   id: "worktree-mutation",
   is_trigger: bash_triggers.on_bash_command(is_unauthorized_worktree_change),
   reason: WORKTREE_MUTATION_REASON,
   decide: () => true
 };
 var worktree_guard = {
-  ROW: ROW15,
+  ROW: ROW16,
   WORKTREE_MUTATION_REASON,
   is_unauthorized_stash,
   is_unauthorized_worktree_change,
@@ -2525,7 +2838,8 @@ var DELIVERED_RULES = [
   // (`issue:lint`) delivers on the reissue, after `wip-cap` / `issue-scout` / `filing-cap` /
   // `issue-fold` have each had their turn. The non-overlapping firing point (`pkg:scout` on a package
   // add) claims a command no row above matches.
-  ...oracle_consulted.ROWS
+  ...oracle_consulted.ROWS,
+  issue_bug_label_rule.ROW
 ];
 var ALONE_IN_TURN = 1;
 function batches_the_turn(call, turn) {
@@ -2559,12 +2873,12 @@ function is_first_delivery(tail, call, delivered_at_ms, run2) {
   return delivered_at_ms === hook_decision.NEVER_MS && !will_batch_guard_refuse(tail, call, run2);
 }
 function delivery_decision(rule) {
-  const { decide: decide6, already_satisfied } = rule;
-  if (decide6 === void 0 && already_satisfied === void 0) return is_first_delivery;
+  const { decide: decide7, already_satisfied } = rule;
+  if (decide7 === void 0 && already_satisfied === void 0) return is_first_delivery;
   return function should_block(tail, call, delivered_at_ms, run2) {
     if (already_satisfied?.(tail, call) === true) return false;
-    if (decide6 === void 0) return is_first_delivery(tail, call, delivered_at_ms, run2);
-    return decide6(call, run2, !will_batch_guard_refuse(tail, call, run2), delivered_at_ms);
+    if (decide7 === void 0) return is_first_delivery(tail, call, delivered_at_ms, run2);
+    return decide7(call, run2, !will_batch_guard_refuse(tail, call, run2), delivered_at_ms);
   };
 }
 function guard_of(rule) {
@@ -2620,7 +2934,7 @@ var delivered_rules = {
 };
 
 // scripts/run/run-watcher-hook.ts
-import { z as z14 } from "zod";
+import { z as z16 } from "zod";
 
 // scripts/run/run-progress-read.ts
 import { loadavg } from "node:os";
@@ -2949,9 +3263,9 @@ async function issue_get_labels_and_body(issue_number) {
   return await issue_view_json(issue_number, "number,state,labels,body");
 }
 async function issue_list_comments(issue_number) {
-  const path5 = `${git_gh_api_path.issue_comments_api_path(issue_number)}${git_gh_api_path.FULL_PAGE_QUERY}`;
+  const path7 = `${git_gh_api_path.issue_comments_api_path(issue_number)}${git_gh_api_path.FULL_PAGE_QUERY}`;
   try {
-    return await git_gh_exec.exec_gh_api({ path: path5, should_paginate: true });
+    return await git_gh_exec.exec_gh_api({ path: path7, should_paginate: true });
   } catch {
     return void 0;
   }
@@ -3026,8 +3340,8 @@ function is_selected(rest, request) {
   return !git_gh_issue_rest.is_pull_request(rest) && matches_body(rest, request.body_term);
 }
 async function fetch_page(request, page) {
-  const path5 = listing_path(request, page);
-  const rows = git_gh_issue_rest.parse_rest_issues(await git_gh_exec.exec_gh_api({ path: path5 }));
+  const path7 = listing_path(request, page);
+  const rows = git_gh_issue_rest.parse_rest_issues(await git_gh_exec.exec_gh_api({ path: path7 }));
   return {
     selected: rows.filter((row) => is_selected(row, request)),
     is_full: rows.length >= PER_PAGE
@@ -3267,6 +3581,92 @@ var git_gh_issue = {
   issue_list_recently_closed
 };
 
+// scripts/ci/pr-classification.ts
+import { readFileSync as readFileSync6 } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { z as z7 } from "zod";
+var BUGFIX = "bugfix";
+var BREAKING = "breaking-change";
+var CLASSIFICATION_LABELS2 = [
+  BREAKING,
+  "enhancement",
+  BUGFIX,
+  "other-change",
+  "ignore-for-release"
+];
+var CLASSIFICATION_SET = new Set(CLASSIFICATION_LABELS2);
+var ISSUE_BUG_LABEL = "bug";
+var DECLARATION = /^- リリース分類: (.+)$/gmu;
+var LEGACY_LABELS = /* @__PURE__ */ new Set(["semver-major", "semver-minor"]);
+var LABEL = z7.object({ name: z7.string() });
+var USER = z7.object({ login: z7.string() });
+var PULL_REQUEST = z7.object({ user: USER, labels: z7.array(LABEL) });
+var EVENT = z7.object({
+  pull_request: PULL_REQUEST
+});
+function classification_error(labels, author) {
+  const legacy = labels.filter((label) => LEGACY_LABELS.has(label.toLowerCase()));
+  if (legacy.length > 0) return `Remove legacy release labels: ${legacy.join(", ")}`;
+  const selected = labels.filter((label) => CLASSIFICATION_SET.has(label.toLowerCase()));
+  if (selected.length > 1) {
+    return `Choose exactly one release classification; found: ${selected.join(", ")}`;
+  }
+  if (selected.length === 1 || author.endsWith("[bot]")) return void 0;
+  return `Choose one release classification: ${CLASSIFICATION_LABELS2.join(", ")}`;
+}
+function is_classification(value) {
+  return CLASSIFICATION_SET.has(value);
+}
+function release_candidates(candidates) {
+  if (!candidates.includes(BREAKING)) return candidates;
+  return candidates.filter((candidate) => candidate !== "enhancement");
+}
+function issue_candidates(issue_json) {
+  const issue = z7.object({ labels: z7.array(LABEL), body: z7.string().nullable() }).parse(JSON.parse(issue_json));
+  const names = issue.labels.map((label) => label.name.toLowerCase());
+  const declared = [...(issue.body ?? "").matchAll(DECLARATION)].map((match) => match[1] ?? "");
+  const candidates = [...release_candidates([...names, ...declared].filter(is_classification))];
+  const unknown = declared.filter((value) => !is_classification(value));
+  if (unknown.length > 0) throw new Error(`Unknown release classification: ${unknown.join(", ")}`);
+  if (names.includes(ISSUE_BUG_LABEL) && !candidates.includes(BREAKING)) {
+    candidates.push(BUGFIX);
+  }
+  return candidates;
+}
+function select_issue_classification(issue_json) {
+  const candidates = issue_candidates(issue_json);
+  const selected = [...new Set(candidates)];
+  const [label] = selected;
+  if (label === void 0 || selected.length > 1) {
+    throw new Error(
+      `Choose one release classification before opening the PR: ${CLASSIFICATION_LABELS2.join(", ")}; found: ${selected.join(", ") || "none"}. Add "- \u30EA\u30EA\u30FC\u30B9\u5206\u985E: <label>" to the Issue body.`
+    );
+  }
+  return label;
+}
+function check_event(event_path) {
+  const event = EVENT.parse(JSON.parse(readFileSync6(event_path, "utf8")));
+  return classification_error(
+    event.pull_request.labels.map((label) => label.name),
+    event.pull_request.user.login
+  );
+}
+if (process.argv[1] === fileURLToPath2(import.meta.url)) {
+  const event_path = process.env["GITHUB_EVENT_PATH"];
+  if (!event_path) throw new Error("GITHUB_EVENT_PATH is required");
+  const error = check_event(event_path);
+  if (error) {
+    console.error(`::error::${error}`);
+    process.exitCode = 1;
+  }
+}
+var pr_classification = {
+  classification_error,
+  check_event,
+  is_classification,
+  select_issue_classification
+};
+
 // scripts/lib/poll.ts
 async function sleep(duration_ms) {
   await new Promise((resolve2) => {
@@ -3286,29 +3686,32 @@ async function poll_until(is_done, options) {
 }
 var poll = { poll_until, sleep };
 
+// scripts/git/git-gh-pr.ts
+import { z as z11 } from "zod";
+
 // scripts/git/git-gh-pr-rest.ts
-import { z as z7 } from "zod";
-var rest_repo_schema = z7.looseObject({ full_name: z7.string().optional() }).nullish();
-var rest_pull_side_schema = z7.looseObject({ repo: rest_repo_schema });
-var rest_pull_schema = z7.looseObject({
-  number: z7.number(),
-  html_url: z7.string().optional(),
-  body: z7.string().nullish(),
-  state: z7.string().optional(),
-  merged: z7.boolean().nullish(),
-  merged_at: z7.string().nullish(),
-  mergeable: z7.boolean().nullish(),
-  mergeable_state: z7.string().optional(),
+import { z as z8 } from "zod";
+var rest_repo_schema = z8.looseObject({ full_name: z8.string().optional() }).nullish();
+var rest_pull_side_schema = z8.looseObject({ repo: rest_repo_schema });
+var rest_pull_schema = z8.looseObject({
+  number: z8.number(),
+  html_url: z8.string().optional(),
+  body: z8.string().nullish(),
+  state: z8.string().optional(),
+  merged: z8.boolean().nullish(),
+  merged_at: z8.string().nullish(),
+  mergeable: z8.boolean().nullish(),
+  mergeable_state: z8.string().optional(),
   // `sha` is the head commit, which is what both halves of the merge-gate rollup are keyed by —
   // REST hangs the check runs and the status contexts off the commit rather than off the pull
   // request (joshuafolkken/kit#1028).
-  head: z7.looseObject({ ref: z7.string().optional(), sha: z7.string().optional(), repo: rest_repo_schema }).nullish(),
+  head: z8.looseObject({ ref: z8.string().optional(), sha: z8.string().optional(), repo: rest_repo_schema }).nullish(),
   base: rest_pull_side_schema.nullish(),
   // `node_id` is what the GraphQL auto-merge mutation addresses a pull request by, and `auto_merge`
   // is `null` until auto-merge is enabled — both read by `git-gh-pr-auto-merge.ts`
   // (joshuafolkken/kit#2497).
-  node_id: z7.string().optional(),
-  auto_merge: z7.looseObject({}).nullish()
+  node_id: z8.string().optional(),
+  auto_merge: z8.looseObject({}).nullish()
 });
 var NOT_A_PULL_MESSAGE = "gh api answered something other than a pull request object";
 var NOT_A_PULL_LISTING_MESSAGE = "gh api answered something other than a pull request listing";
@@ -3477,9 +3880,9 @@ async function pr_head_reference(pr_number) {
 async function read_comments(branch_name, to_path, to_json) {
   const pr_number = await resolve_pr_number(branch_name);
   if (pr_number === void 0) return void 0;
-  const path5 = `${to_path(String(pr_number))}${COMMENTS_QUERY}`;
+  const path7 = `${to_path(String(pr_number))}${COMMENTS_QUERY}`;
   try {
-    return to_json(await git_gh_exec.exec_gh_api({ path: path5, should_paginate: true }));
+    return to_json(await git_gh_exec.exec_gh_api({ path: path7, should_paginate: true }));
   } catch {
     return void 0;
   }
@@ -3508,14 +3911,14 @@ var git_gh_pr_read = {
 };
 
 // scripts/git/git-gh-pr-review.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var REVIEW_APPROVED = "APPROVED";
 var REVIEW_CHANGES_REQUESTED = "CHANGES_REQUESTED";
 var REVIEW_NONE = "";
 var STATE_CHANGING_REVIEWS = /* @__PURE__ */ new Set([REVIEW_APPROVED, REVIEW_CHANGES_REQUESTED]);
-var rest_review_schema = z8.looseObject({
-  state: z8.string().optional(),
-  user: z8.looseObject({ login: z8.string().optional() }).nullish()
+var rest_review_schema = z9.looseObject({
+  state: z9.string().optional(),
+  user: z9.looseObject({ login: z9.string().optional() }).nullish()
 });
 var NOT_A_REVIEW_LISTING = "gh api answered something other than a review listing";
 function parse_rest_reviews(reviews_json) {
@@ -3548,17 +3951,18 @@ function to_review_decision(reviews_json) {
 var git_gh_pr_review = { to_review_decision, parse_rest_reviews };
 
 // scripts/git/git-gh-pr-rollup.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var STATUS_CONTEXT_TYPE_NAME = "StatusContext";
 var TYPE_NAME_KEY = "__typename";
-var rollup_element_schema = z9.looseObject({});
-var check_runs_page_schema = z9.looseObject({
+var rollup_element_schema = z10.looseObject({});
+var check_runs_page_schema = z10.looseObject({
   // Required, not optional: GitHub always names the key, and accepting a page without one would
   // answer an empty rollup — which `git-pr-followup.ts` reports as "this branch has no checks".
-  check_runs: z9.array(rollup_element_schema)
+  check_runs: z10.array(rollup_element_schema)
 });
-var status_page_schema = z9.looseObject({
-  statuses: z9.array(rollup_element_schema)
+var check_run_app_schema = z10.object({ id: z10.number() });
+var status_page_schema = z10.looseObject({
+  statuses: z10.array(rollup_element_schema)
 });
 var NOT_A_CHECK_RUNS_LISTING = "gh api answered something other than a check run listing";
 var NOT_A_STATUS_LISTING = "gh api answered something other than a commit status listing";
@@ -3567,9 +3971,31 @@ function read_pages(raw_json, schema, message) {
   if (pages === void 0) throw new Error(message);
   return pages;
 }
+function check_run_group_key(run2) {
+  const { name, app: raw_app } = run2;
+  if (typeof name !== "string") return void 0;
+  const app = check_run_app_schema.safeParse(raw_app);
+  return JSON.stringify([name, app.success ? app.data.id : void 0]);
+}
+function remember_newest_run(run2, latest_ids) {
+  const key = check_run_group_key(run2);
+  const { id } = run2;
+  if (key === void 0 || typeof id !== "number") return;
+  const previous_id = latest_ids.get(key);
+  if (previous_id === void 0 || id > previous_id) latest_ids.set(key, id);
+}
+function is_newest_run(run2, latest_ids) {
+  const key = check_run_group_key(run2);
+  const { id } = run2;
+  if (key === void 0 || typeof id !== "number") return true;
+  return id === latest_ids.get(key);
+}
 function to_check_run_items(check_runs_json) {
   const pages = read_pages(check_runs_json, check_runs_page_schema, NOT_A_CHECK_RUNS_LISTING);
-  return pages.flatMap((page) => page.check_runs);
+  const runs = pages.flatMap((page) => page.check_runs);
+  const latest_ids = /* @__PURE__ */ new Map();
+  for (const run2 of runs) remember_newest_run(run2, latest_ids);
+  return runs.filter((run2) => is_newest_run(run2, latest_ids));
 }
 function to_status_context_items(status_json) {
   const pages = read_pages(status_json, status_page_schema, NOT_A_STATUS_LISTING);
@@ -3589,16 +4015,16 @@ var git_gh_pr_rollup = {
 
 // scripts/git/git-gh-pr-snapshot.ts
 var NO_HEAD_SHA_MESSAGE = "gh api answered a pull request with no head commit";
-async function read_object_pages(path5) {
+async function read_object_pages(path7) {
   return await git_gh_exec.exec_gh_api({
-    path: `${path5}${FULL_PAGE_QUERY}`,
+    path: `${path7}${FULL_PAGE_QUERY}`,
     should_paginate: true,
     should_slurp: true
   });
 }
-async function read_array_pages(path5) {
+async function read_array_pages(path7) {
   return await git_gh_exec.exec_gh_api({
-    path: `${path5}${FULL_PAGE_QUERY}`,
+    path: `${path7}${FULL_PAGE_QUERY}`,
     should_paginate: true
   });
 }
@@ -3615,8 +4041,8 @@ async function read_status_check_rollup(commit_sha) {
   return git_gh_pr_rollup.to_status_check_rollup({ check_runs_json, status_json });
 }
 async function pr_get_review_decision(pr_number) {
-  const path5 = git_gh_api_path.pull_reviews_api_path(String(pr_number));
-  return git_gh_pr_review.to_review_decision(await read_array_pages(path5));
+  const path7 = git_gh_api_path.pull_reviews_api_path(String(pr_number));
+  return git_gh_pr_review.to_review_decision(await read_array_pages(path7));
 }
 async function build_checks_fields(pull) {
   return {
@@ -3655,7 +4081,33 @@ var MERGE_REQUEST_TIMEOUT_MS = 18e4;
 var MERGE_UNCONFIRMED_MESSAGE = "gh api could not read the pull request back after the merge request failed";
 var MERGE_READ_BACK_ATTEMPTS = 3;
 var MERGE_READ_BACK_INTERVAL_MS = 1e3;
-async function pr_create(title, body) {
+var PR_NUMBER_PATTERN = /\/pull\/([1-9]\d*)$/u;
+var LABELS_SEGMENT2 = "/labels";
+var PR_LABELS = z11.array(z11.object({ name: z11.string() }));
+async function add_pr_classification(number, label) {
+  await git_gh_exec.exec_gh_api({
+    path: `${git_gh_api_path.issue_api_path(number)}${LABELS_SEGMENT2}`,
+    body: JSON.stringify({ labels: [label] })
+  });
+}
+async function pr_get_classification(branch_name) {
+  const number = await require_pr_number(branch_name);
+  const response = await git_gh_exec.exec_gh_api({
+    path: `${git_gh_api_path.issue_api_path(String(number))}${LABELS_SEGMENT2}`
+  });
+  const names = PR_LABELS.parse(JSON.parse(response)).map((label) => label.name.toLowerCase());
+  const selected = names.filter((name) => pr_classification.is_classification(name));
+  if (selected.length === 0) return void 0;
+  const error = pr_classification.classification_error(names, "human");
+  if (error !== void 0) throw new Error(error);
+  return selected[0];
+}
+async function pr_ensure_classification(branch_name, label) {
+  if (await pr_get_classification(branch_name) !== void 0) return;
+  const number = await require_pr_number(branch_name);
+  await add_pr_classification(String(number), label);
+}
+async function post_pull_request(title, body) {
   const base = await git_command.get_default_branch();
   const head = await git_command.branch();
   forget_pr_numbers();
@@ -3669,6 +4121,15 @@ async function pr_create(title, body) {
     return git_gh_helpers.handle_pr_create_error(error);
   }
 }
+async function pr_create(title, body, label) {
+  const classification_error2 = pr_classification.classification_error([label], "human");
+  if (classification_error2 !== void 0) throw new Error(classification_error2);
+  const url = await post_pull_request(title, body);
+  const number = PR_NUMBER_PATTERN.exec(url)?.[1];
+  if (number === void 0) throw new Error(`Could not identify the created pull request: ${url}`);
+  await add_pr_classification(number, label);
+  return url;
+}
 async function pr_checkout(pr_number) {
   const branch_name = await git_gh_pr_read.pr_head_reference(pr_number);
   await git_command.fetch_branch(branch_name);
@@ -3726,6 +4187,8 @@ var git_gh_pr = {
   ...git_gh_pr_read,
   ...git_gh_pr_snapshot,
   pr_create,
+  pr_get_classification,
+  pr_ensure_classification,
   pr_checkout,
   pr_comment,
   pr_merge,
@@ -4204,30 +4667,30 @@ var epic_busy = {
 };
 
 // scripts/run/run-liveness.ts
-import { readFileSync as readFileSync4, realpathSync, statSync } from "node:fs";
+import { readFileSync as readFileSync7, realpathSync, statSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import path4 from "node:path";
+import path6 from "node:path";
 import { setTimeout as sleep2 } from "node:timers/promises";
 
 // scripts/agent/agent-event.ts
-import { z as z11 } from "zod";
+import { z as z13 } from "zod";
 
 // scripts/agent/claude-result-event.ts
-import { z as z10 } from "zod";
-var RESULT_EVENT_SCHEMA = z10.looseObject({
-  type: z10.literal("result"),
-  is_error: z10.unknown().optional(),
-  subtype: z10.unknown().optional(),
-  num_turns: z10.unknown().optional(),
-  permission_denials: z10.unknown().optional(),
-  result: z10.unknown().optional(),
-  session_id: z10.unknown().optional(),
-  usage: z10.unknown().optional()
+import { z as z12 } from "zod";
+var RESULT_EVENT_SCHEMA = z12.looseObject({
+  type: z12.literal("result"),
+  is_error: z12.unknown().optional(),
+  subtype: z12.unknown().optional(),
+  num_turns: z12.unknown().optional(),
+  permission_denials: z12.unknown().optional(),
+  result: z12.unknown().optional(),
+  session_id: z12.unknown().optional(),
+  usage: z12.unknown().optional()
 });
-var USAGE_SCHEMA = z10.looseObject({
-  input_tokens: z10.unknown().optional(),
-  cache_read_input_tokens: z10.unknown().optional(),
-  output_tokens: z10.unknown().optional()
+var USAGE_SCHEMA = z12.looseObject({
+  input_tokens: z12.unknown().optional(),
+  cache_read_input_tokens: z12.unknown().optional(),
+  output_tokens: z12.unknown().optional()
 });
 function usable_reason(value) {
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
@@ -4266,31 +4729,31 @@ function decode2(value) {
 var claude_result_event = { decode: decode2 };
 
 // scripts/agent/agent-event.ts
-var TEXT_BLOCK_SCHEMA = z11.looseObject({ type: z11.literal("text"), text: z11.string() });
-var CLAUDE_MESSAGE_SCHEMA = z11.looseObject({ content: z11.array(z11.unknown()).optional() });
-var CLAUDE_INIT_SCHEMA = z11.looseObject({ type: z11.literal("system"), subtype: z11.literal("init") });
-var CLAUDE_ASSISTANT_SCHEMA = z11.looseObject({
-  type: z11.literal("assistant"),
+var TEXT_BLOCK_SCHEMA = z13.looseObject({ type: z13.literal("text"), text: z13.string() });
+var CLAUDE_MESSAGE_SCHEMA = z13.looseObject({ content: z13.array(z13.unknown()).optional() });
+var CLAUDE_INIT_SCHEMA = z13.looseObject({ type: z13.literal("system"), subtype: z13.literal("init") });
+var CLAUDE_ASSISTANT_SCHEMA = z13.looseObject({
+  type: z13.literal("assistant"),
   message: CLAUDE_MESSAGE_SCHEMA
 });
-var USAGE_SCHEMA2 = z11.looseObject({
-  input_tokens: z11.number().optional(),
-  cached_input_tokens: z11.number().optional(),
-  output_tokens: z11.number().optional()
+var USAGE_SCHEMA2 = z13.looseObject({
+  input_tokens: z13.number().optional(),
+  cached_input_tokens: z13.number().optional(),
+  output_tokens: z13.number().optional()
 });
-var CODEX_START_SCHEMA = z11.looseObject({ type: z11.enum(["thread.started", "turn.started"]) });
-var CODEX_PROGRESS_SCHEMA = z11.looseObject({
-  type: z11.enum(["item.started", "item.updated", "item.completed"]),
-  item: z11.looseObject({ type: z11.string(), text: z11.string().optional() }).optional()
+var CODEX_START_SCHEMA = z13.looseObject({ type: z13.enum(["thread.started", "turn.started"]) });
+var CODEX_PROGRESS_SCHEMA = z13.looseObject({
+  type: z13.enum(["item.started", "item.updated", "item.completed"]),
+  item: z13.looseObject({ type: z13.string(), text: z13.string().optional() }).optional()
 });
-var CODEX_COMPLETE_SCHEMA = z11.looseObject({
-  type: z11.literal("turn.completed"),
+var CODEX_COMPLETE_SCHEMA = z13.looseObject({
+  type: z13.literal("turn.completed"),
   usage: USAGE_SCHEMA2.optional()
 });
-var CODEX_FAILURE_SCHEMA = z11.looseObject({
-  type: z11.enum(["turn.failed", "error"]),
-  error: z11.looseObject({ message: z11.string().optional() }).optional(),
-  message: z11.string().optional()
+var CODEX_FAILURE_SCHEMA = z13.looseObject({
+  type: z13.enum(["turn.failed", "error"]),
+  error: z13.looseObject({ message: z13.string().optional() }).optional(),
+  message: z13.string().optional()
 });
 var EMPTY_STATE = {
   provider: void 0,
@@ -4388,7 +4851,7 @@ function describe(state) {
 var agent_event = { describe, read };
 
 // scripts/issue/issue-state.ts
-import { z as z12 } from "zod";
+import { z as z14 } from "zod";
 var NO_LABELS = "(none)";
 var LABEL_SEPARATOR = ", ";
 var STATE_LABEL = "state: ";
@@ -4398,9 +4861,9 @@ var YES = "yes";
 var NO = "no";
 var ISSUE_LABEL = "issue: ";
 var HUMAN_REVIEW_LABELS = /* @__PURE__ */ new Set([NEEDS_HUMAN_REVIEW_LABEL]);
-var label_schema = z12.looseObject({ name: z12.string() });
-var issue_state_schema = z12.looseObject({
-  state: z12.string(),
+var label_schema = z14.looseObject({ name: z14.string() });
+var issue_state_schema = z14.looseObject({
+  state: z14.string(),
   labels: label_schema.array().optional()
 });
 function parse_issue_state(json) {
@@ -4498,7 +4961,7 @@ function to_advice(verdict, has_work_to_stash) {
   if (verdict === UNDETERMINED_VERDICT) return UNDETERMINED_ADVICE;
   return has_work_to_stash ? STOPPED_DIRTY_ADVICE : STOPPED_CLEAN_ADVICE;
 }
-function decide4(traces) {
+function decide5(traces) {
   const verdict = to_verdict(traces);
   const has_work_to_stash = verdict === STOPPED_VERDICT && traces.is_tree_dirty;
   return {
@@ -4521,12 +4984,12 @@ var ALLOWED_ROOTS = [
   )
 ];
 function is_within(candidate, root) {
-  const relative = path4.relative(root, candidate);
-  return relative !== "" && !relative.startsWith("..") && !path4.isAbsolute(relative);
+  const relative = path6.relative(root, candidate);
+  return relative !== "" && !relative.startsWith("..") && !path6.isAbsolute(relative);
 }
 function to_safe_path(output_path) {
-  const normalized2 = path4.normalize(output_path);
-  if (!path4.isAbsolute(normalized2)) return void 0;
+  const normalized2 = path6.normalize(output_path);
+  if (!path6.isAbsolute(normalized2)) return void 0;
   return ALLOWED_ROOTS.some((root) => is_within(normalized2, root)) ? normalized2 : void 0;
 }
 function sample_output(output_path) {
@@ -4540,7 +5003,7 @@ function read_agent_state(output_path) {
   const safe_path = to_safe_path(output_path);
   if (safe_path === void 0) return void 0;
   try {
-    const state = agent_event.read(readFileSync4(safe_path, "utf8"));
+    const state = agent_event.read(readFileSync7(safe_path, "utf8"));
     return state.provider === void 0 ? void 0 : state;
   } catch {
     return void 0;
@@ -4597,11 +5060,11 @@ async function read_traces(request) {
 }
 async function check(request) {
   run_issue_number.require_issue_number(request.issue);
-  return decide4(await read_traces(request));
+  return decide5(await read_traces(request));
 }
 var run_liveness = {
   check,
-  decide: decide4,
+  decide: decide5,
   describe_agent_state,
   read_child_settled,
   read_agent_state,
@@ -4672,7 +5135,7 @@ var lane_report = {
 };
 
 // scripts/run/run-preflight.ts
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 var CLEAN_VERDICT = "clean";
 var RECLAIM_VERDICT = "reclaim";
 var RESUME_VERDICT = "resume";
@@ -4682,7 +5145,7 @@ var OPEN_PR = "open";
 var MERGED_PR = "merged";
 var CLOSED_PR = "closed";
 var NO_CHILD_WORK = { branch_name: void 0, pr_state: NO_PR };
-var pr_info_schema2 = z13.object({ state: z13.string().optional() });
+var pr_info_schema2 = z15.object({ state: z15.string().optional() });
 var GH_PR_STATES = /* @__PURE__ */ new Map([
   ["CLOSED", CLOSED_PR],
   ["MERGED", MERGED_PR],
@@ -4751,7 +5214,7 @@ function to_advice2(verdict, issue, tree) {
   if (verdict === PARK_VERDICT) return PARK_ADVICE;
   return CLEAN_ADVICE;
 }
-function decide5(tree, child, issue) {
+function decide6(tree, child, issue) {
   const verdict = to_verdict2(tree, child);
   return {
     advice: to_advice2(verdict, issue, tree),
@@ -4820,8 +5283,8 @@ async function read_child_state(issue) {
 async function check2(issue) {
   require_issue_number(issue);
   const tree = await read_tree_state();
-  if (needs_reclaim(tree)) return decide5(tree, NO_CHILD_WORK, issue);
-  return decide5(tree, await read_child_state(issue), issue);
+  if (needs_reclaim(tree)) return decide6(tree, NO_CHILD_WORK, issue);
+  return decide6(tree, await read_child_state(issue), issue);
 }
 var run_preflight = {
   CLEAN_ADVICE,
@@ -4836,7 +5299,7 @@ var run_preflight = {
   MERGED_PR,
   STASH_LABEL_PREFIX,
   check: check2,
-  decide: decide5,
+  decide: decide6,
   read_child_state,
   read_pr_state: read_pr_state2,
   to_pr_state: to_pr_state2
@@ -4936,7 +5399,7 @@ var run_progress_read = {
 // scripts/run/run-watcher-hook.ts
 var SWITCH_ENV_KEY2 = "JOSH_WATCHER_GUARD";
 var STAMP_PREFIX2 = "josh-watcher-guard-";
-var payload_schema = z14.object({ transcript_path: z14.string().min(1) });
+var payload_schema = z16.object({ transcript_path: z16.string().min(1) });
 function transcript_of(raw_payload) {
   try {
     const parsed = payload_schema.safeParse(JSON.parse(raw_payload));
@@ -4998,7 +5461,7 @@ async function pretool_outcome_async(raw_payload) {
   return reason === void 0 ? base : { reason, notice: void 0, fault: void 0 };
 }
 var pretool_guard = { combine_outcomes, pretool_outcome, pretool_outcome_async };
-if (process.argv[1] === fileURLToPath2(import.meta.url)) {
+if (process.argv[1] === fileURLToPath3(import.meta.url)) {
   if (process.stdin.isTTY) hook_decision.report_no_payload("pretool:guard");
   else {
     const raw_payload = await text(process.stdin);