@joshuafolkken/kit 1.1178.0 → 1.1240.0

package/dist/hooks/{chunk-G6KRCKEC.js → chunk-4TZVB44A.js}

@@ -1,3 +1,6 @@
+import {
+  duplicate_read_outcome
+} from "./chunk-QVSWU24O.js";
 import {
   ALREADY_DONE_LABEL,
   CONTEXT_CUT_THRESHOLD,
@@ -8,7 +11,6 @@ import {
   agent_role_profile,
   bash_triggers,
   cli_flags,
-  error_text,
   filing_cap,
   git_command,
   git_common_directory,
@@ -31,35 +33,35 @@ import {
   run_cut_handoff,
   run_headless,
   run_hold,
-  run_tail,
+  run_tail_rule,
   shell_segments,
   tail_commands
-} from "./chunk-GDS5N2KB.js";
+} from "./chunk-KHX4U3BG.js";
 import {
+  ancestor_directories,
   find_local_bin_upwards
-} from "./chunk-3V37IID6.js";
+} from "./chunk-JBBMAPC4.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
 import {
   batch_outcome
-} from "./chunk-VQLLNFNT.js";
+} from "./chunk-F3ELQ2AF.js";
 import {
   investigation_refusal
-} from "./chunk-VESKRQOF.js";
-import {
-  duplicate_read_outcome
-} from "./chunk-DO6NWWHU.js";
+} from "./chunk-KRBERBBI.js";
 import {
   investigation_reads
-} from "./chunk-ZAL3NRGL.js";
+} from "./chunk-XZYKEM6J.js";
 import {
   lane_guard_policy
-} from "./chunk-I4XSL4TT.js";
+} from "./chunk-GPTFMK5E.js";
 import {
   hook_decision,
   lane_child_marker,
   run_issue_number
-} from "./chunk-32GQTL4F.js";
+} from "./chunk-ZQGD4GBY.js";
 import {
-  PLATFORM_TEMP_ROOT,
   cost_attribute,
   cost_blocks,
   cost_transcript,
@@ -68,13 +70,18 @@ import {
   json_value,
   lane_paths,
   open_issue_schema,
-  stamp_file,
   time_batch_guard,
+  time_density_hook,
   time_shell
-} from "./chunk-S6X6WYKR.js";
+} from "./chunk-WK2XSHSI.js";
+import {
+  PLATFORM_TEMP_ROOT,
+  PROBE_TIMEOUT_MS,
+  stamp_file
+} from "./chunk-ELCN5LCH.js";
 
 // scripts/rules/direct-filing.ts
-var DIRECT_FILING_REASON = '\u26D4 direct filing: an Issue is filed with `pnpm josh issue:file "<title>" --body-file <path> --depth <0|1|2> [--route <route>] [--label <name>] [--repo <owner/repo>]`, never with `gh api \u2026/issues` or `gh issue create`. The command runs every filing step in order \u2014 the duplicate scout, the body lint and its classification labels, the depth and `route:` labels, the `## Origin` check when filing into another repository, and `epic:bundle` after the create \u2014 so none of them is a step to remember. When the scout prints candidates it holds the filing: read each, then reissue with `--distinct <N,\u2026>` for the ones that are separate deliverables. Reference: `docs/josh-commands-automation.md` \u2192 "`josh issue:file`". **This rule fires on every occurrence, not once per run.**';
+var DIRECT_FILING_REASON = '\u26D4 direct filing: an Issue is filed with `pnpm josh issue:file "<title>" --body-file <path> --depth <0|1|2> [--route <route>] [--label <name>] [--repo <owner/repo>]`, never with `gh api \u2026/issues` or `gh issue create`. The command runs every filing step in order \u2014 the duplicate scout, the body lint and its classification labels, the depth and `route:` labels, the `## Origin` check when filing into another repository, and `epic:bundle` after the create \u2014 so none of them is a step to remember. When the scout prints candidates it holds the filing: read each, then reissue with `--distinct <N,\u2026>` for the ones that are separate deliverables. Reference: `docs/josh-commands-backlog.md` \u2192 "`josh issue:file`". **This rule fires on every occurrence, not once per run.**';
 function is_any_filing(command) {
   return bash_triggers.is_direct_filing(command) || bash_triggers.is_issue_filing(command);
 }
@@ -88,7 +95,7 @@ var ROW = {
 };
 var direct_filing = { DIRECT_FILING_REASON, ROW };
 
-// scripts/run/run-progress.ts
+// scripts/run/progress/run-progress.ts
 var DEFAULT_INTERVAL_MINUTES = 20;
 var INTERVAL_KEY = "JOSH_PROGRESS_INTERVAL_MINUTES";
 var MS_PER_MINUTE = 6e4;
@@ -207,7 +214,7 @@ var run_progress = {
   observation_key
 };
 
-// scripts/run/run-progress-clock.ts
+// scripts/run/progress/run-progress-clock.ts
 import { z } from "zod";
 var PROGRESS_PREFIX = "josh-run-progress-";
 var LIFE_PREFIX = "josh-run-progress-life-";
@@ -333,24 +340,14 @@ var run_progress_clock = {
   stamp_target_of
 };
 
-// scripts/run/run-progress-config.ts
+// scripts/run/progress/run-progress-config.ts
 import { readFileSync } from "node:fs";
 import path from "node:path";
 import { z as z2 } from "zod";
 var PACKAGE_FILE = "package.json";
-var MAX_DEPTH = 10;
 var package_schema = z2.object({
   josh: z2.object({ progress_interval_minutes: z2.number().positive() }).optional()
 });
-function ancestors_of(start) {
-  const directories = [];
-  let current = path.resolve(start);
-  while (directories.length < MAX_DEPTH && !directories.includes(current)) {
-    directories.push(current);
-    current = path.dirname(current);
-  }
-  return directories;
-}
 function read_declared_minutes(directory) {
   try {
     const raw = readFileSync(path.join(directory, PACKAGE_FILE), "utf8");
@@ -361,7 +358,7 @@ function read_declared_minutes(directory) {
   }
 }
 function read_package_minutes(start) {
-  for (const directory of ancestors_of(start)) {
+  for (const directory of ancestor_directories.list(start)) {
     const minutes = read_declared_minutes(directory);
     if (minutes !== void 0) return minutes;
   }
@@ -551,48 +548,6 @@ var file_body = {
   carries_a_file_body
 };
 
-// scripts/rules/gh-api.ts
-var GH_FLAGS = String.raw`(?:-{1,2}[\w-]+(?:[= ][^\s]+)?\s+)*`;
-var GH_API_COMMAND = new RegExp(String.raw`^gh\s+${GH_FLAGS}api\s`, "u");
-var API_METHOD = /(?:^|\s)(?:--method|-X)[= ]([A-Za-z]+)/u;
-var API_FIELD = /(?:^|\s)(?:--raw-field|--field|--input|-F|-f)(?:[= ]|$)/u;
-var READ_METHOD = "GET";
-var REPO_PATH = /repos\/([^/\s'"?]+)\/([^/\s'"?]+)/u;
-var OWNER_GROUP = 1;
-var REPO_GROUP = 2;
-var OWNER_PLACEHOLDERS = /* @__PURE__ */ new Set(["{owner}", ":owner"]);
-function is_gh_api(segment) {
-  return GH_API_COMMAND.test(segment);
-}
-function method_of(segment) {
-  return API_METHOD.exec(segment)?.[1]?.toUpperCase();
-}
-function is_read(segment) {
-  const method = method_of(segment);
-  if (method !== void 0) return method.toUpperCase() === READ_METHOD;
-  return !API_FIELD.test(segment);
-}
-function is_write(segment) {
-  return !is_read(segment);
-}
-function repo_target(segment) {
-  const match = REPO_PATH.exec(segment);
-  if (match === null) return void 0;
-  return { owner: match[OWNER_GROUP] ?? "", repo: match[REPO_GROUP] ?? "" };
-}
-function is_owner_placeholder(owner) {
-  return OWNER_PLACEHOLDERS.has(owner);
-}
-var gh_api = {
-  GH_FLAGS,
-  is_gh_api,
-  is_owner_placeholder,
-  is_read,
-  is_write,
-  method_of,
-  repo_target
-};
-
 // scripts/rules/git-argv.ts
 var ENV_ASSIGNMENT = /^[A-Za-z_]\w*=/u;
 var WRAPPER_WORDS = /* @__PURE__ */ new Set([
@@ -1200,7 +1155,141 @@ var implementation_cut = {
   uncut_run_issue
 };
 
-// scripts/rules/issue-fold.ts
+// scripts/rules/gh-api.ts
+var GH_FLAGS = String.raw`(?:-{1,2}[\w-]+(?:[= ][^\s]+)?\s+)*`;
+var GH_API_COMMAND = new RegExp(String.raw`^gh\s+${GH_FLAGS}api\s`, "u");
+var API_METHOD = /(?:^|\s)(?:--method|-X)[= ]([A-Za-z]+)/u;
+var API_FIELD = /(?:^|\s)(?:--raw-field|--field|--input|-F|-f)(?:[= ]|$)/u;
+var READ_METHOD = "GET";
+var REPO_PATH = /repos\/([^/\s'"?]+)\/([^/\s'"?]+)/u;
+var OWNER_GROUP = 1;
+var REPO_GROUP = 2;
+var OWNER_PLACEHOLDERS = /* @__PURE__ */ new Set(["{owner}", ":owner"]);
+function is_gh_api(segment) {
+  return GH_API_COMMAND.test(segment);
+}
+function method_of(segment) {
+  return API_METHOD.exec(segment)?.[1]?.toUpperCase();
+}
+function is_read(segment) {
+  const method = method_of(segment);
+  if (method !== void 0) return method.toUpperCase() === READ_METHOD;
+  return !API_FIELD.test(segment);
+}
+function is_write(segment) {
+  return !is_read(segment);
+}
+function repo_target(segment) {
+  const match = REPO_PATH.exec(segment);
+  if (match === null) return void 0;
+  return { owner: match[OWNER_GROUP] ?? "", repo: match[REPO_GROUP] ?? "" };
+}
+function is_owner_placeholder(owner) {
+  return OWNER_PLACEHOLDERS.has(owner);
+}
+var gh_api = {
+  GH_FLAGS,
+  is_gh_api,
+  is_owner_placeholder,
+  is_read,
+  is_write,
+  method_of,
+  repo_target
+};
+
+// scripts/rules/prior-comment-read.ts
+var ISSUE_PATH_NUMBER = /issues\/(\d+)/gu;
+var ISSUE_VIEW_NUMBER = /\bissue\s+view\s+(?:-{1,2}\S+\s+)*(\d+)/u;
+var ISSUE_READ_ARGUMENTS = /\bissue:read\b([\s\d]*)/u;
+var A_NUMBER = /^\d+$/u;
+var COMMENTS_ENDPOINT = /issues\/\d+\/comments\b/u;
+var VIEW_WITH_COMMENTS = /\bissue\s+view\b[^\n]*--comments\b/u;
+var ISSUE_READ_COMMAND = /\bissue:read\b/u;
+function add_issue_read_numbers(command, numbers) {
+  const match = ISSUE_READ_ARGUMENTS.exec(command);
+  if (match === null) return;
+  const tokens = (match[1] ?? "").split(/\s+/u);
+  for (const token of tokens) {
+    if (A_NUMBER.test(token)) numbers.add(Number(token));
+  }
+}
+function issue_numbers_of(command) {
+  const numbers = /* @__PURE__ */ new Set();
+  for (const match of command.matchAll(ISSUE_PATH_NUMBER)) numbers.add(Number(match[1]));
+  const view = ISSUE_VIEW_NUMBER.exec(command);
+  if (view !== null) numbers.add(Number(view[1]));
+  add_issue_read_numbers(command, numbers);
+  return numbers;
+}
+function fetches_comments(command) {
+  return COMMENTS_ENDPOINT.test(command) || VIEW_WITH_COMMENTS.test(command) || ISSUE_READ_COMMAND.test(command);
+}
+function reads_target_comments(command, target) {
+  if (!fetches_comments(command)) return false;
+  for (const number of issue_numbers_of(command)) {
+    if (target.has(number)) return true;
+  }
+  return false;
+}
+function already_read_comments_for(tail, command) {
+  const target = issue_numbers_of(command);
+  if (target.size === 0) return false;
+  return tail_commands.prior_bash_commands(tail).some((prior) => reads_target_comments(prior, target));
+}
+function already_read_for_call(tail, call) {
+  if (call.name !== cost_blocks.BASH_TOOL) return false;
+  return already_read_comments_for(tail, time_shell.bash_command(call.input));
+}
+var prior_comment_read = {
+  already_read_comments_for,
+  already_read_for_call,
+  fetches_comments,
+  issue_numbers_of
+};
+
+// scripts/rules/issue-comments.ts
+var ISSUE_VIEW_COMMAND = new RegExp(String.raw`^gh\s+${gh_api.GH_FLAGS}issue\s+view\s`, "u");
+var ISSUE_BODY_PATH = /repos\/[^\s'"]*\/issues\/\d+(?=$|["'\s])/u;
+var FETCHES_COMMENTS = /--comments\b|--json\s[\w,]*\bcomments\b|\/comments\b/u;
+var ISSUES_PATH = /repos\/[^\s'"]*\/issues\//u;
+var FIELD_PROJECTION = /(?:--jq|--json)[= ]\s*('[^']*'|"[^"]*"|\S+)/u;
+var NAMES_THE_BODY = /\bbody\b/u;
+function projects_away_body(segment) {
+  const projection = FIELD_PROJECTION.exec(segment);
+  return projection !== null && !NAMES_THE_BODY.test(projection[1] ?? "");
+}
+function is_body_read_segment(segment) {
+  if (projects_away_body(segment)) return false;
+  if (ISSUE_VIEW_COMMAND.test(segment)) return true;
+  return gh_api.is_gh_api(segment) && ISSUE_BODY_PATH.test(segment) && gh_api.is_read(segment);
+}
+function fetches_issue_comments(segment) {
+  if (!FETCHES_COMMENTS.test(segment)) return false;
+  return ISSUE_VIEW_COMMAND.test(segment) || gh_api.is_gh_api(segment) && ISSUES_PATH.test(segment);
+}
+function is_body_only_issue_read(command) {
+  const segments = shell_segments.segments_of(command);
+  if (segments.some((segment) => fetches_issue_comments(segment))) return false;
+  return segments.some((segment) => is_body_read_segment(segment));
+}
+function reads_issue_comments(command) {
+  return shell_segments.segments_of(command).some((segment) => fetches_issue_comments(segment));
+}
+var ISSUE_COMMENTS_REASON = "\u26D4 an Issue's comments are part of the Issue: read them before implementing, not only the body. A decision recorded after the body was written lives only in a comment \u2014 a corrected diagnosis (joshuafolkken/kit#1537), a changed default and an added acceptance criterion (joshuafolkken/kit#1520), a scope handed to another Issue (joshuafolkken/kit#1304) \u2014 and nothing in the body says it was superseded, so a body-only reader builds the wrong thing and sees no contradiction. Reissue this read with the comments included: `gh api repos/{owner}/{repo}/issues/<N>/comments --jq '.[] | {user: .user.login, created_at, body}'` beside the body read, or `gh issue view <N> --comments` where GraphQL is reachable. Then the later text is the agreement in force \u2014 a comment supersedes the body it contradicts \u2014 except for two answers that are not the run's to make: work a comment reassigns to another Issue is out of scope and is not implemented, and a comment saying the Issue no longer has a reason to exist stops the run with a `confirmation` Telegram. The procedure is `.claude/skills/workflow-commands/issue-comments.md`. Every body-only read is refused until the comments are read.";
+var ROW5 = {
+  id: "issue-comments",
+  is_trigger: bash_triggers.on_bash_command(is_body_only_issue_read),
+  reason: ISSUE_COMMENTS_REASON,
+  already_satisfied: prior_comment_read.already_read_for_call,
+  keeps: bash_triggers.on_bash_command(reads_issue_comments)
+};
+var issue_comments = {
+  ISSUE_COMMENTS_REASON,
+  ROW: ROW5,
+  is_body_only_issue_read
+};
+
+// scripts/rules/issue-fold-rule.ts
 var FOLD_NAMES = /* @__PURE__ */ new Set(["issue:fold"]);
 function runs_the_fold(command) {
   return shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, FOLD_NAMES));
@@ -1210,14 +1299,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". Every later filing is refused until the fold is on the transcript.';
-var ROW5 = {
+var ROW6 = {
   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: ROW5, already_folded, runs_the_fold };
+var issue_fold_rule = { ISSUE_FOLD_REASON, ROW: ROW6, already_folded, runs_the_fold };
 
 // scripts/rules/josh-git-bare.ts
 var GIT_COMMAND2 = /* @__PURE__ */ new Set(["git"]);
@@ -1233,7 +1322,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,
@@ -1241,7 +1330,7 @@ var ROW6 = {
 };
 var josh_git_bare = {
   JOSH_GIT_BARE_REASON,
-  ROW: ROW6,
+  ROW: ROW7,
   is_bare_josh_git
 };
 
@@ -1255,7 +1344,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,
@@ -1263,7 +1352,7 @@ var ROW7 = {
 };
 var lane_carry_conflict = {
   LANE_CARRY_CONFLICT_REASON,
-  ROW: ROW7,
+  ROW: ROW8,
   invokes_budget_command,
   is_carry_conflict
 };
@@ -1316,13 +1405,73 @@ 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-split-park.ts
+var EPIC_COMMANDS = /* @__PURE__ */ new Set(["epic"]);
+var PROMOTED_ISSUE = /--promote[=\s]+["']?(?<issue>\d+)\b/u;
+var LABEL_TARGETS = [
+  /\/issues\/(?<issue>\d+)\/labels\b/u,
+  /\bissue\s+edit\s+["']?(?<issue>\d+)\b/u
+];
+var ISSUE_URL = /--issue-url[=\s]+["']?([^\s"']+)/u;
+var URL_ISSUE = /\/issues\/(\d+)\b/u;
+function promoted_in(segment) {
+  if (!shell_segments.is_josh_command(segment, EPIC_COMMANDS)) return void 0;
+  return PROMOTED_ISSUE.exec(segment)?.groups?.["issue"];
+}
+function promoted_issues(commands) {
+  const segments = commands.flatMap((command) => shell_segments.segments_of(command));
+  const issues = segments.map((segment) => promoted_in(segment));
+  return new Set(issues.filter((issue) => issue !== void 0));
+}
+function label_target(command) {
+  for (const pattern of LABEL_TARGETS) {
+    const issue = pattern.exec(command)?.groups?.["issue"];
+    if (issue !== void 0) return issue;
+  }
+  return void 0;
+}
+function is_park_of(command, issue) {
+  return lane_park.records_the_park(command) && label_target(command) === issue;
+}
+function notified_issue(command) {
+  const [, url = ""] = ISSUE_URL.exec(command) ?? [];
+  const [, issue] = URL_ISSUE.exec(url) ?? [];
+  return issue;
+}
+function is_notify_of(command, issue) {
+  return lane_park.is_confirmation_notify(command) && notified_issue(command) === issue;
+}
+function is_candidate(command) {
+  const issue = lane_child_marker.marked_issue();
+  if (issue === void 0) return false;
+  if (!is_park_of(command, issue) && !is_notify_of(command, issue)) return false;
+  return lane_child_marker.is_child_of(process.cwd());
+}
+function decide3(_call, run2) {
+  const issue = lane_child_marker.marked_issue();
+  const commands = tail_commands.prior_bash_commands(time_density_hook.read_tail(run2.transcript));
+  return issue !== void 0 && promoted_issues(commands).has(issue);
+}
+var LANE_SPLIT_PARK_REASON = '\u26D4 lane split park: this session is a dispatched lane child that promoted its own Issue to an epic this run, and a split is not a park \u2014 do not apply `needs-decision` to the promoted epic and do not send a `confirmation` Telegram. The parent reads an open Issue carrying `epic` as a split and continues through its children; a question here has nobody to answer it (joshuafolkken/kit#3296, measured 2026-10-06 when the child for #3255 parked its promoted epic). If what remains of the original work needs a person, park that child issue instead, then end the turn. The procedure is `.claude/skills/workflow-commands/backlogrun-park.md` \u2192 "Splitting a child mid-run". This rule fires on every occurrence, not once per run.';
+var ROW10 = {
+  id: "lane-split-park",
+  is_trigger: bash_triggers.on_bash_command(is_candidate),
+  reason: LANE_SPLIT_PARK_REASON,
+  decide: decide3
+};
+var lane_split_park = {
+  LANE_SPLIT_PARK_REASON,
+  ROW: ROW10,
+  promoted_issues
+};
 
 // scripts/rules/lane-switch-main.ts
 var SWITCH_SUBCOMMAND = "switch";
@@ -1353,7 +1502,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 ROW11 = {
   id: "lane-switch-main",
   is_trigger: bash_triggers.on_bash_command(is_switch_away_from_lane),
   reason: LANE_SWITCH_MAIN_REASON,
@@ -1361,12 +1510,138 @@ var ROW9 = {
 };
 var lane_switch_main = {
   LANE_SWITCH_MAIN_REASON,
-  ROW: ROW9,
+  ROW: ROW11,
   is_switch_away_from_lane,
   switch_target,
   switch_targets
 };
 
+// scripts/rules/decision-oracle-tokens.ts
+var oracle_tokens = {
+  REQUIRED: "required",
+  SKIP: "skip",
+  STOP: "stop",
+  WAIT: "wait",
+  RETRY: "retry",
+  OVER: "over",
+  UNKNOWN: "unknown",
+  NONE: "none",
+  NOT_A_LANE: "not-a-lane",
+  BUSY: "busy",
+  HUMAN_REVIEW: "human-review",
+  ISSUE_N_ARG: "<N>",
+  EXCLUDE_ARG: "[--exclude <n>...]"
+};
+
+// scripts/rules/decision-oracle-batch.ts
+var {
+  BUSY,
+  EXCLUDE_ARG,
+  HUMAN_REVIEW,
+  ISSUE_N_ARG,
+  NONE,
+  NOT_A_LANE,
+  OVER,
+  RETRY,
+  STOP,
+  UNKNOWN,
+  WAIT
+} = oracle_tokens;
+var PRE_GATE_CUT_MD = ".claude/skills/workflow-commands/pre-gate-cut.md";
+var BACKLOGRUN_MD = ".claude/skills/workflow-commands/backlogrun.md";
+var RUN_MERGE_REFERENCE = "docs/josh-commands-run.md \u2192 `josh run:merge`";
+var EPIC_NEXT_REFERENCE = "docs/josh-commands-backlog.md \u2192 `josh epic:next`";
+var BACKLOG_BUDGET_REFERENCE = "docs/josh-commands-backlog.md \u2192 `josh backlog:budget`";
+var RUN_LIVENESS_REFERENCE = "docs/josh-commands-run.md \u2192 `josh run:liveness`";
+var AUTO_OK_NEXT_REFERENCE = "docs/josh-commands-backlog.md \u2192 `josh auto-ok:next`";
+var RUN_CUT_CMD = "run:cut";
+var BATCH_ORACLES = [
+  {
+    name: "run:cut:resume",
+    command: RUN_CUT_CMD,
+    decision: "Whether a lane child is resuming prior work or starting fresh",
+    args: `--resume ${ISSUE_N_ARG}`,
+    vocabulary: ["fresh", "resume", NOT_A_LANE],
+    single_source: PRE_GATE_CUT_MD
+  },
+  {
+    name: "run:cut:gate",
+    command: RUN_CUT_CMD,
+    decision: "Whether a lane child should take its pre-gate cut now",
+    args: ISSUE_N_ARG,
+    vocabulary: ["cut", NOT_A_LANE],
+    single_source: PRE_GATE_CUT_MD
+  },
+  {
+    name: "backlog:budget",
+    decision: "Whether a backlogrun may start more work, keep watching, or finish",
+    args: "",
+    vocabulary: ["run", "watch", STOP],
+    single_source: BACKLOG_BUDGET_REFERENCE
+  },
+  {
+    name: "run:liveness",
+    decision: "Whether a delegated unit is still working or has stopped without reporting",
+    args: `${ISSUE_N_ARG} --output <path>`,
+    vocabulary: ["alive", "stopped", "settled", "undetermined"],
+    single_source: RUN_LIVENESS_REFERENCE
+  },
+  {
+    name: "stash:pop",
+    decision: "Whether a named stash entry exists and can be applied",
+    args: "<message>",
+    vocabulary: ["popped", "conflicted", "no-match", "ambiguous"],
+    single_source: ".claude/skills/workflow-commands/prerequisite.md"
+  },
+  {
+    name: "backlog:next",
+    decision: "Which issue the backlog offers next, or whether to wait or stop",
+    args: EXCLUDE_ARG,
+    vocabulary: [WAIT, STOP, RETRY, "error", NONE],
+    single_source: BACKLOGRUN_MD
+  },
+  {
+    name: "auto-ok:next",
+    decision: "The next opted-in issue outside any epic, or none",
+    args: EXCLUDE_ARG,
+    vocabulary: [NONE],
+    single_source: AUTO_OK_NEXT_REFERENCE
+  },
+  {
+    name: "epic:next",
+    decision: "The next runnable child of an epic, or the epic's status",
+    args: "<epic>",
+    vocabulary: [WAIT, STOP, "complete"],
+    single_source: EPIC_NEXT_REFERENCE
+  },
+  {
+    name: "run:merge",
+    decision: "The post-merge batch step: confirm child, advance, or report a stop condition",
+    args: ISSUE_N_ARG,
+    vocabulary: [OVER, HUMAN_REVIEW, STOP, RETRY, BUSY],
+    single_source: RUN_MERGE_REFERENCE
+  },
+  {
+    name: "run:step",
+    decision: "The run\u2019s next single action, computed from the event stream, carry and issue state",
+    args: ISSUE_N_ARG,
+    // The non-command answers: `run:step` prints a runnable command for a phase with one to run, and
+    // one of these verdicts otherwise. A command line is not a vocabulary token, exactly as an issue
+    // number is not one for `backlog:next`.
+    vocabulary: [
+      "implement",
+      HUMAN_REVIEW,
+      "update-deps",
+      "already-done",
+      "keep-work",
+      WAIT,
+      STOP,
+      UNKNOWN
+    ],
+    single_source: BACKLOGRUN_MD
+  }
+];
+
 // scripts/run/run-stage.ts
 var KICKOFF = "kickoff";
 var HALFRUN = "halfrun";
@@ -1409,7 +1684,7 @@ function state_of(facts) {
   if (facts.is_halfrun_stopped) return HALFRUN_STOPPED;
   return facts.is_planned ? PLANNED : FRESH;
 }
-function decide3(state, command) {
+function decide4(state, command) {
   const is_reached = STATES.indexOf(state) > COMMANDS.indexOf(command);
   const start = is_reached ? REACHED : STARTS[state];
   return { state, command, start, end: ENDS[command], is_reached };
@@ -1426,7 +1701,7 @@ function format_decision(issue, decision) {
   return `stage #${issue} \u2014 ${fields.join(" \xB7 ")}`;
 }
 function cell(state, command) {
-  const decision = decide3(state, command);
+  const decision = decide4(state, command);
   return decision.is_reached ? REACHED_CELL : `${decision.start}${CELL_ARROW}${decision.end}`;
 }
 function table_rows() {
@@ -1451,7 +1726,7 @@ var run_stage = {
   REACHED,
   START_TOKENS,
   STATES,
-  decide: decide3,
+  decide: decide4,
   format_decision,
   next_commands,
   next_line,
@@ -1470,35 +1745,15 @@ var RUN_ENTRY_ORACLE = {
 };
 
 // scripts/rules/decision-oracle.ts
+var { BUSY: BUSY2, ISSUE_N_ARG: ISSUE_N_ARG2, NONE: NONE2, OVER: OVER2, REQUIRED, SKIP, UNKNOWN: UNKNOWN2 } = oracle_tokens;
 var CHAIN_RULE_MD = ".claude/skills/workflow-commands/chain-rule.md";
 var BACKLOGRUN_PROGRESS_MD = ".claude/skills/workflow-commands/backlogrun-progress.md";
 var SKILL_2E = ".claude/skills/workflow-commands/issue-scout.md";
 var SPLIT_ASSESSMENT_QUESTION = ".claude/skills/workflow-commands/split-assessment.md \u2192 The question";
-var PRE_GATE_CUT_MD = ".claude/skills/workflow-commands/pre-gate-cut.md";
-var BACKLOGRUN_MD = ".claude/skills/workflow-commands/backlogrun.md";
-var RUN_MERGE_REFERENCE = "docs/josh-commands-automation.md \u2192 `josh run:merge`";
-var EPIC_NEXT_REFERENCE = "docs/josh-commands-automation.md \u2192 `josh epic:next`";
-var BACKLOG_BUDGET_REFERENCE = "docs/josh-commands-automation.md \u2192 `josh backlog:budget`";
-var RUN_LIVENESS_REFERENCE = "docs/josh-commands-automation.md \u2192 `josh run:liveness`";
-var AUTO_OK_NEXT_REFERENCE = "docs/josh-commands-automation.md \u2192 `josh auto-ok:next`";
-var RUN_CUT_CMD = "run:cut";
-var REQUIRED = "required";
-var SKIP = "skip";
-var STOP = "stop";
-var WAIT = "wait";
-var RETRY = "retry";
-var OVER = "over";
-var UNKNOWN = "unknown";
-var NONE = "none";
-var NOT_A_LANE = "not-a-lane";
-var BUSY = "busy";
-var HUMAN_REVIEW = "human-review";
 var LIVE = "live";
 var STOPPED = "stopped";
 var RECONCILED = "reconciled";
 var NOTHING_TO_RECONCILE = "nothing to reconcile";
-var ISSUE_N_ARG = "<N>";
-var EXCLUDE_ARG = "[--exclude <n>...]";
 var DECISION_ORACLES = [
   {
     name: "delegate",
@@ -1546,8 +1801,8 @@ var DECISION_ORACLES = [
   {
     name: "run:hold",
     decision: "Whether this working tree is free for a run to claim",
-    args: `[${ISSUE_N_ARG}]`,
-    vocabulary: ["hold", BUSY, UNKNOWN],
+    args: `[${ISSUE_N_ARG2}]`,
+    vocabulary: ["hold", BUSY2, UNKNOWN2],
     single_source: ".claude/skills/workflow-commands/working-tree-hold.md"
   },
   {
@@ -1555,20 +1810,20 @@ var DECISION_ORACLES = [
     command: "cost",
     decision: "Whether the session cost exceeds the hand-off threshold",
     args: "--cut",
-    vocabulary: [OVER, "under"],
+    vocabulary: [OVER2, "under"],
     single_source: BACKLOGRUN_PROGRESS_MD
   },
   {
     name: "release:scope",
     decision: "Whether a release is owed after this merge",
     args: "",
-    vocabulary: [REQUIRED, SKIP, UNKNOWN],
+    vocabulary: [REQUIRED, SKIP, UNKNOWN2],
     single_source: ".claude/skills/workflow-commands/followup.md"
   },
   {
     name: "epic:bundle",
     decision: "Which epic a newly filed issue belongs to",
-    args: ISSUE_N_ARG,
+    args: ISSUE_N_ARG2,
     vocabulary: ["add_to_epic", "create_epic", "ask", "nothing_to_bundle"],
     single_source: SKILL_2E
   },
@@ -1604,100 +1859,17 @@ var DECISION_ORACLES = [
     name: "cases",
     decision: "Each boundary a change crosses (network, process, fs, time) and the abnormal cases it owes",
     args: "<path...>",
-    vocabulary: ["network", "process", "fs", "time", NONE],
+    vocabulary: ["network", "process", "fs", "time", NONE2],
     single_source: "prompts/collaboration-workflow/report-format.md \u2192 \u5909\u66F4\u3068\u30C6\u30B9\u30C8"
   },
   {
     name: "issue:state",
     decision: "An issue's state, labels, and human-review flag",
-    args: ISSUE_N_ARG,
+    args: ISSUE_N_ARG2,
     vocabulary: ["human_review: yes", "human_review: no"],
     single_source: ".claude/skills/workflow-commands/needs-human-review.md"
   },
-  {
-    name: "run:cut:resume",
-    command: RUN_CUT_CMD,
-    decision: "Whether a lane child is resuming prior work or starting fresh",
-    args: `--resume ${ISSUE_N_ARG}`,
-    vocabulary: ["fresh", "resume", NOT_A_LANE],
-    single_source: PRE_GATE_CUT_MD
-  },
-  {
-    name: "run:cut:gate",
-    command: RUN_CUT_CMD,
-    decision: "Whether a lane child should take its pre-gate cut now",
-    args: ISSUE_N_ARG,
-    vocabulary: ["cut", NOT_A_LANE],
-    single_source: PRE_GATE_CUT_MD
-  },
-  {
-    name: "backlog:budget",
-    decision: "Whether a backlogrun may start more work, keep watching, or finish",
-    args: "",
-    vocabulary: ["run", "watch", STOP],
-    single_source: BACKLOG_BUDGET_REFERENCE
-  },
-  {
-    name: "run:liveness",
-    decision: "Whether a delegated unit is still working or has stopped without reporting",
-    args: `${ISSUE_N_ARG} --output <path>`,
-    vocabulary: ["alive", "stopped", "settled", "undetermined"],
-    single_source: RUN_LIVENESS_REFERENCE
-  },
-  {
-    name: "stash:pop",
-    decision: "Whether a named stash entry exists and can be applied",
-    args: "<message>",
-    vocabulary: ["popped", "conflicted", "no-match", "ambiguous"],
-    single_source: ".claude/skills/workflow-commands/prerequisite.md"
-  },
-  {
-    name: "backlog:next",
-    decision: "Which issue the backlog offers next, or whether to wait or stop",
-    args: EXCLUDE_ARG,
-    vocabulary: [WAIT, STOP, RETRY, "error", NONE],
-    single_source: BACKLOGRUN_MD
-  },
-  {
-    name: "auto-ok:next",
-    decision: "The next opted-in issue outside any epic, or none",
-    args: EXCLUDE_ARG,
-    vocabulary: [NONE],
-    single_source: AUTO_OK_NEXT_REFERENCE
-  },
-  {
-    name: "epic:next",
-    decision: "The next runnable child of an epic, or the epic's status",
-    args: "<epic>",
-    vocabulary: [WAIT, STOP, "complete"],
-    single_source: EPIC_NEXT_REFERENCE
-  },
-  {
-    name: "run:merge",
-    decision: "The post-merge batch step: confirm child, advance, or report a stop condition",
-    args: ISSUE_N_ARG,
-    vocabulary: [OVER, HUMAN_REVIEW, STOP, RETRY, BUSY],
-    single_source: RUN_MERGE_REFERENCE
-  },
-  {
-    name: "run:step",
-    decision: "The run\u2019s next single action, computed from the event stream, carry and issue state",
-    args: ISSUE_N_ARG,
-    // The non-command answers: `run:step` prints a runnable command for a phase with one to run, and
-    // one of these verdicts otherwise. A command line is not a vocabulary token, exactly as an issue
-    // number is not one for `backlog:next`.
-    vocabulary: [
-      "implement",
-      HUMAN_REVIEW,
-      "update-deps",
-      "already-done",
-      "keep-work",
-      WAIT,
-      STOP,
-      UNKNOWN
-    ],
-    single_source: BACKLOGRUN_MD
-  },
+  ...BATCH_ORACLES,
   {
     name: "refactor:scan",
     decision: "Whether the refactoring scope still holds high- or medium-priority candidates",
@@ -1724,7 +1896,7 @@ var DECISION_ORACLES = [
     decision: "Whether cross-file or cross-repository code duplication exists",
     args: "",
     vocabulary: ["clean", "clones:"],
-    single_source: "prompts/collaboration-workflow/principles.md \u2192 \u30AF\u30ED\u30FC\u30F3\u7981\u6B62"
+    single_source: "prompts/collaboration-workflow/principles.md \u2192 no-clones"
   },
   {
     name: "epic:reconcile",
@@ -1732,14 +1904,14 @@ var DECISION_ORACLES = [
     decision: "Whether an epic's declaration matches its recorded relations, and the repair when it does not",
     args: "--reconcile <E>",
     vocabulary: [RECONCILED, NOTHING_TO_RECONCILE],
-    single_source: "docs/josh-commands-automation.md \u2192 `josh epic --reconcile`"
+    single_source: "docs/josh-commands-backlog.md \u2192 `josh epic --reconcile`"
   },
   {
     name: "lane:list",
     decision: "Whether each in-progress issue holds a live lane, and the two-directional difference",
     args: "",
-    vocabulary: [LIVE, STOPPED, UNKNOWN],
-    single_source: "docs/josh-commands-automation.md \u2192 The `in-progress` / lane difference"
+    vocabulary: [LIVE, STOPPED, UNKNOWN2],
+    single_source: "docs/josh-commands-run.md \u2192 The `in-progress` / lane difference"
   },
   RUN_ENTRY_ORACLE
 ];
@@ -1821,7 +1993,7 @@ function declaration_for(name) {
 function firing_oracles() {
   return decision_oracle.DECISION_ORACLES.flatMap((oracle) => {
     const firing_point = FIRING.get(oracle.name);
-    return firing_point === void 0 ? [] : [{ oracle, firing_point }];
+    return firing_point === void 0 ? [] : { oracle, firing_point };
   });
 }
 var oracle_firing = {
@@ -1911,13 +2083,13 @@ function is_destructive_command(command) {
   return shell_segments.segments_of(command).some((segment) => is_destructive_segment2(segment));
 }
 var DESTRUCTIVE_COMMAND_REASON = "\u26D4 destructive command: a recursive forced `rm` (`rm -rf`, `rm -fr`, `rm -r -f`, `rm --recursive --force`), `gh repo delete` / `archive`, `gh repo edit --visibility`, `gh pr close`, or a `gh api -X DELETE repos/\u2026` call deletes or closes something that cannot be restored, which is Tier C and needs explicit current-turn user instruction (`prompts/collaboration-workflow/operating-rules.md`). The `.claude/settings.json` deny list matches prefix globs, so it misses these spellings; this row reads the argv instead. Remove a file or directory one path at a time without `-f`, or ask the user to run the command in their own terminal. `gh issue close` and removing a label from an Issue (`DELETE repos/<o>/<r>/issues/<N>/labels/<name>`) are not refused. **This rule fires on every occurrence, not once per run.**";
-var ROW10 = {
+var ROW12 = {
   id: "destructive-command",
   is_trigger: bash_triggers.on_bash_command(is_destructive_command),
   reason: DESTRUCTIVE_COMMAND_REASON,
   decide: () => true
 };
-var destructive_command = { DESTRUCTIVE_COMMAND_REASON, ROW: ROW10, is_destructive_command };
+var destructive_command = { DESTRUCTIVE_COMMAND_REASON, ROW: ROW12, is_destructive_command };
 
 // scripts/rules/direct-pr-create.ts
 var GH_COMMAND2 = "gh";
@@ -1972,13 +2144,13 @@ function is_direct_pr_create(command) {
   return shell_segments.segments_of(command).some((segment) => is_pr_create_segment(segment));
 }
 var DIRECT_PR_CREATE_REASON = "\u26D4 direct PR creation: `gh pr create` (or a `gh api` POST to `repos/<o>/<r>/pulls`) bypasses `build_body`, which writes the `closes #N` line \u2014 the Issue would stay open after the merge (`CLAUDE.md` \u2192 Git Rules). Open the PR with `pnpm josh pr` instead; after a failed push, fix, push, then run `pnpm josh pr`. **This rule fires on every occurrence, not once per run.**";
-var ROW11 = {
+var ROW13 = {
   id: "direct-pr-create",
   is_trigger: bash_triggers.on_bash_command(is_direct_pr_create),
   reason: DIRECT_PR_CREATE_REASON,
   decide: () => true
 };
-var direct_pr_create = { DIRECT_PR_CREATE_REASON, ROW: ROW11, is_direct_pr_create };
+var direct_pr_create = { DIRECT_PR_CREATE_REASON, ROW: ROW13, is_direct_pr_create };
 
 // scripts/rules/worktree-guard.ts
 var CHECKOUT_SUBCOMMAND = "checkout";
@@ -2040,14 +2212,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>`, a forced `git clean` and an unauthorized `git stash` discard work or mutate 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 ROW12 = {
+var ROW14 = {
   id: "worktree-mutation",
   is_trigger: bash_triggers.on_bash_command(is_unauthorized_worktree_change),
   reason: WORKTREE_MUTATION_REASON,
   decide: () => true
 };
 var worktree_guard = {
-  ROW: ROW12,
+  ROW: ROW14,
   WORKTREE_MUTATION_REASON,
   is_unauthorized_worktree_change,
   touches_worktree
@@ -2075,14 +2247,14 @@ function is_index_segment(segment) {
 function is_index_mutation(command) {
   return shell_segments.segments_of(command).some((segment) => is_index_segment(segment));
 }
-var INDEX_MUTATION_REASON = '\u26D4 git index mutation: `git add` / `stage` / `commit` / `reset` / `rm` / `mv` and `git restore --staged` overwrite the user\'s staged snapshot, which `CLAUDE.md` \u2192 Git Rules forbids on your own judgement (`prompts/collaboration-workflow/operating-rules.md` \u2192 "git index \u3092\u52DD\u624B\u306B\u5909\u66F4\u3057\u306A\u3044"). The `.claude/settings.json` deny list matches prefix globs, so it misses `git -C . commit`, `git -c k=v commit` and `env git commit`; this row reads the argv instead, so the spelling does not matter. A commit goes through `pnpm josh git -y`; any other staging needs explicit current-turn user instruction, run by the user in their own terminal. **This rule fires on every occurrence, not once per run.**';
-var ROW13 = {
+var INDEX_MUTATION_REASON = '\u26D4 git index mutation: `git add` / `stage` / `commit` / `reset` / `rm` / `mv` and `git restore --staged` overwrite the user\'s staged snapshot, which `CLAUDE.md` \u2192 Git Rules forbids on your own judgement (`prompts/collaboration-workflow/operating-rules.md` \u2192 "no-self-staging"). The `.claude/settings.json` deny list matches prefix globs, so it misses `git -C . commit`, `git -c k=v commit` and `env git commit`; this row reads the argv instead, so the spelling does not matter. A commit goes through `pnpm josh git -y`; any other staging needs explicit current-turn user instruction, run by the user in their own terminal. **This rule fires on every occurrence, not once per run.**';
+var ROW15 = {
   id: "index-mutation",
   is_trigger: bash_triggers.on_bash_command(is_index_mutation),
   reason: INDEX_MUTATION_REASON,
   decide: () => true
 };
-var index_guard = { INDEX_MUTATION_REASON, ROW: ROW13, is_index_mutation };
+var index_guard = { INDEX_MUTATION_REASON, ROW: ROW15, is_index_mutation };
 
 // scripts/rules/protected-files.ts
 import path5 from "node:path";
@@ -2102,7 +2274,6 @@ var CLAUDE_MD = "CLAUDE.md";
 var PLUGIN_ID = "kit@kit";
 var CLAUDE_MD_POINTER = `@${NODE_MODULES}/${KIT_PACKAGE_NAME}/dist/${CLAUDE_MD}`;
 var SECRETLINT_BIN = path4.join(NODE_MODULES, ".bin", "secretlint");
-var GIT_TIMEOUT_MS = 2e3;
 var manifest_schema = z6.object({
   name: z6.string().optional(),
   dependencies: z6.record(z6.string(), z6.string()).optional(),
@@ -2137,7 +2308,7 @@ function is_plugin_declared(root) {
 }
 function configured_hooks_path(root) {
   const value = git_spawn_sync.read(["-C", root, "config", "--get", "core.hooksPath"], {
-    timeout: GIT_TIMEOUT_MS
+    timeout: PROBE_TIMEOUT_MS
   });
   return value === "" ? void 0 : value;
 }
@@ -2213,13 +2384,51 @@ var READ_TOOL = "Read";
 var EDIT_TOOLS2 = /* @__PURE__ */ new Set(["Edit", "Write"]);
 var ENVIRONMENT_FILE = ".env";
 var SETTINGS_FILE = path5.join(".claude", "settings.json");
+var WHITESPACE3 = /\s+/u;
+var TOKEN_QUOTES = /["']/gu;
+var INPUT_REDIRECT = "<";
+var SHELL_READERS = /* @__PURE__ */ new Set([
+  ".",
+  "awk",
+  "bat",
+  "cat",
+  "cut",
+  "grep",
+  "head",
+  "less",
+  "more",
+  "nl",
+  "od",
+  "rg",
+  "sed",
+  "sort",
+  "source",
+  "strings",
+  "tail",
+  "xxd"
+]);
 function file_path_of(call) {
   if (!json_value.is_record(call.input)) return "";
   const value = call.input["file_path"];
   return typeof value === "string" ? value : "";
 }
+function is_environment_path(token) {
+  return path5.basename(token.replaceAll(TOKEN_QUOTES, "")) === ENVIRONMENT_FILE;
+}
+function is_environment_read_segment(segment) {
+  const words = segment.replaceAll(INPUT_REDIRECT, " < ").split(WHITESPACE3).filter((word) => word !== "");
+  const is_redirected = words.some(
+    (word, index) => word === INPUT_REDIRECT && is_environment_path(words[index + 1] ?? "")
+  );
+  const [command = "", ...rest] = words;
+  return is_redirected || SHELL_READERS.has(command) && rest.some((word) => is_environment_path(word));
+}
+function is_environment_shell_read(command) {
+  return shell_segments.segments_of(command).some((segment) => is_environment_read_segment(segment));
+}
 function is_environment_read(call) {
-  return call.name === READ_TOOL && path5.basename(file_path_of(call)) === ENVIRONMENT_FILE;
+  if (call.name === READ_TOOL) return is_environment_path(file_path_of(call));
+  return bash_triggers.on_bash_command(is_environment_shell_read)(call);
 }
 function is_consumer_settings_edit(call, is_kit_consumer2) {
   if (!EDIT_TOOLS2.has(call.name)) return false;
@@ -2230,14 +2439,14 @@ function is_consumer_settings_edit(call, is_kit_consumer2) {
 function is_protected_file_call(call, is_kit_consumer2 = doctor_consumer.is_kit_consumer) {
   return is_environment_read(call) || is_consumer_settings_edit(call, is_kit_consumer2);
 }
-var PROTECTED_FILE_REASON = '\u26D4 protected file: `.env` holds the Telegram bot token, so reading it puts a secret in the transcript \u2014 the scripts that need it load it in their own process. `.claude/settings.json` in a consumer repository is the deny list and the hooks every other rule rests on, so a run must not rewrite it; `josh sync` owns it, and a change belongs upstream in kit (`CLAUDE.md` \u2192 "Route distributed-doc / config changes upstream to kit"). Leave both files alone, or ask the user. **This rule fires on every occurrence, not once per run.**';
-var ROW14 = {
+var PROTECTED_FILE_REASON = '\u26D4 protected file: `.env` holds the Telegram bot token, so reading it \u2014 with the Read tool or a shell reader such as `cat` / `grep` / `source` \u2014 puts a secret in the transcript \u2014 the scripts that need it load it in their own process. `.claude/settings.json` in a consumer repository is the deny list and the hooks every other rule rests on, so a run must not rewrite it; `josh sync` owns it, and a change belongs upstream in kit (`CLAUDE.md` \u2192 "Route distributed-doc / config changes upstream to kit"). Leave both files alone, or ask the user. **This rule fires on every occurrence, not once per run.**';
+var ROW16 = {
   id: "protected-file",
   is_trigger: is_protected_file_call,
   reason: PROTECTED_FILE_REASON,
   decide: () => true
 };
-var protected_files = { ROW: ROW14, is_protected_file_call };
+var protected_files = { ROW: ROW16, is_protected_file_call };
 
 // scripts/rules/permission-guards.ts
 var ROWS2 = [
@@ -2316,7 +2525,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 ROW15 = {
+var ROW17 = {
   id: "poll-loop",
   is_trigger: bash_triggers.on_bash_command(is_poll_loop),
   reason: POLL_LOOP_REASON,
@@ -2324,7 +2533,7 @@ var ROW15 = {
 };
 var poll_loop = {
   POLL_LOOP_REASON,
-  ROW: ROW15,
+  ROW: ROW17,
   is_poll_loop
 };
 
@@ -2388,69 +2597,19 @@ var pre_gate_cut = {
   uncut_lane_issue
 };
 
-// scripts/rules/prior-comment-read.ts
-var ISSUE_PATH_NUMBER = /issues\/(\d+)/gu;
-var ISSUE_VIEW_NUMBER = /\bissue\s+view\s+(?:-{1,2}\S+\s+)*(\d+)/u;
-var ISSUE_READ_ARGUMENTS = /\bissue:read\b([\s\d]*)/u;
-var A_NUMBER = /^\d+$/u;
-var COMMENTS_ENDPOINT = /issues\/\d+\/comments\b/u;
-var VIEW_WITH_COMMENTS = /\bissue\s+view\b[^\n]*--comments\b/u;
-var ISSUE_READ_COMMAND = /\bissue:read\b/u;
-function add_issue_read_numbers(command, numbers) {
-  const match = ISSUE_READ_ARGUMENTS.exec(command);
-  if (match === null) return;
-  const tokens = (match[1] ?? "").split(/\s+/u);
-  for (const token of tokens) {
-    if (A_NUMBER.test(token)) numbers.add(Number(token));
-  }
-}
-function issue_numbers_of(command) {
-  const numbers = /* @__PURE__ */ new Set();
-  for (const match of command.matchAll(ISSUE_PATH_NUMBER)) numbers.add(Number(match[1]));
-  const view = ISSUE_VIEW_NUMBER.exec(command);
-  if (view !== null) numbers.add(Number(view[1]));
-  add_issue_read_numbers(command, numbers);
-  return numbers;
-}
-function fetches_comments(command) {
-  return COMMENTS_ENDPOINT.test(command) || VIEW_WITH_COMMENTS.test(command) || ISSUE_READ_COMMAND.test(command);
-}
-function reads_target_comments(command, target) {
-  if (!fetches_comments(command)) return false;
-  for (const number of issue_numbers_of(command)) {
-    if (target.has(number)) return true;
-  }
-  return false;
-}
-function already_read_comments_for(tail, command) {
-  const target = issue_numbers_of(command);
-  if (target.size === 0) return false;
-  return tail_commands.prior_bash_commands(tail).some((prior) => reads_target_comments(prior, target));
-}
-function already_read_for_call(tail, call) {
-  if (call.name !== cost_blocks.BASH_TOOL) return false;
-  return already_read_comments_for(tail, time_shell.bash_command(call.input));
-}
-var prior_comment_read = {
-  already_read_comments_for,
-  already_read_for_call,
-  fetches_comments,
-  issue_numbers_of
-};
-
 // scripts/rules/raw-field-body.ts
 var RAW_FIELD_BODY_AT = /(?:^|\s)(?:-f|--raw-field)[\s=]+['"]?body=['"]?@/u;
 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 ROW16 = {
+var ROW18 = {
   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: ROW16, posts_at_path_literally };
+var raw_field_body = { RAW_FIELD_BODY_REASON, ROW: ROW18, posts_at_path_literally };
 
 // scripts/rules/rule-body-guard.ts
 var EDIT_TOOL = "Edit";
@@ -2521,7 +2680,7 @@ function runs_placement_oracle(command) {
     (names) => shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, names))
   );
 }
-var ROW17 = {
+var ROW19 = {
   id: "rule-body",
   is_trigger: writes_rule_prose,
   reason: RULE_BODY_REASON,
@@ -2530,7 +2689,7 @@ var ROW17 = {
 };
 var rule_body_guard = {
   RULE_BODY_REASON,
-  ROW: ROW17,
+  ROW: ROW19,
   answered_placement,
   is_rule_document,
   writes_rule_prose
@@ -2761,13 +2920,10 @@ var TYPE_CONFIGS = ["tsconfig.json", "jsconfig.json"];
 var DEPENDENCY_FIELDS = ["dependencies", "devDependencies"];
 var object_schema = z7.record(z7.string(), z7.unknown());
 function project_root(directory) {
-  let current = directory;
-  while (!existsSync4(path7.join(current, PACKAGE_JSON))) {
-    const parent = path7.dirname(current);
-    if (parent === current) return directory;
-    current = parent;
-  }
-  return current;
+  return ancestor_directories.nearest(
+    directory,
+    (candidate) => existsSync4(path7.join(candidate, PACKAGE_JSON))
+  ) ?? directory;
 }
 function is_ignored(entry) {
   return entry.split(/[/\\]/u).some((part) => IGNORED_DIRS.has(part));
@@ -2961,12 +3117,12 @@ var test_declared_changed = { current_verdict, path_of, read_changed_paths_sync,
 
 // scripts/rules/test-declared-commit.ts
 function is_untested_commit(call) {
-  if (!run_tail.is_push_step_call(call)) return false;
+  if (!run_tail_rule.is_push_step_call(call)) return false;
   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 ROW18 = { id: "test-declared", is_trigger: is_untested_commit, reason: REASON };
-var test_declared_commit = { REASON, ROW: ROW18 };
+var ROW20 = { id: "test-declared", is_trigger: is_untested_commit, reason: REASON };
+var test_declared_commit = { REASON, ROW: ROW20 };
 
 // scripts/rules/third-party-write.ts
 function is_third_party_write_segment(segment, session_owner, resolve_placeholder_owners) {
@@ -3004,50 +3160,21 @@ function writes_third_party(command, resolve_owner = repo_party.current_owner, r
   );
 }
 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 ROW19 = {
+var ROW21 = {
   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: ROW19,
+  ROW: ROW21,
   THIRD_PARTY_WRITE_REASON,
   writes_third_party
 };
 
-// scripts/rules/delivered-rules.ts
-var SWITCH_ENV_KEY = "JOSH_RULE_GUARD";
-var STAMP_PREFIX = "josh-rule-guard-";
-var { is_issue_filing, on_bash_command } = bash_triggers;
+// scripts/rules/wip-cap.ts
 var WIP_CAP = 30;
 var WIP_CAP_REASON = `\u26D4 backlog WIP cap: \`pnpm josh issue:file\` counts the target repository's open Issues before filing. With more than ${String(WIP_CAP)} open, close one first; nothing honestly closable means do not file \u2014 the command holds such a filing. Two filings are exempt and proceed while stating the overage \u2014 one the run is blocked by (\`--over-cap\`, or the \`tier-a\` / \`split\` route), and an interrupt (\`--route interrupt\`), decided by three tests rather than judgement: a verification answers wrongly, a documented workflow cannot complete, or data is lost or written outside the repository. Meeting none of the three, the finding is discretionary and waits. Both procedures are in \`prompts/collaboration-workflow/wip-cap.md\`. Reissue this call and let the command count \u2014 it fires once per run and cannot repeat on the call in hand.`;
-var ISSUE_VIEW_COMMAND = new RegExp(String.raw`^gh\s+${gh_api.GH_FLAGS}issue\s+view\s`, "u");
-var ISSUE_BODY_PATH = /repos\/[^\s'"]*\/issues\/\d+(?=$|["'\s])/u;
-var FETCHES_COMMENTS = /--comments\b|--json\s[\w,]*\bcomments\b|\/comments\b/u;
-var ISSUES_PATH = /repos\/[^\s'"]*\/issues\//u;
-var FIELD_PROJECTION = /(?:--jq|--json)[= ]\s*('[^']*'|"[^"]*"|\S+)/u;
-var NAMES_THE_BODY = /\bbody\b/u;
-function projects_away_body(segment) {
-  const projection = FIELD_PROJECTION.exec(segment);
-  return projection !== null && !NAMES_THE_BODY.test(projection[1] ?? "");
-}
-function is_body_read_segment(segment) {
-  if (projects_away_body(segment)) return false;
-  if (ISSUE_VIEW_COMMAND.test(segment)) return true;
-  return gh_api.is_gh_api(segment) && ISSUE_BODY_PATH.test(segment) && gh_api.is_read(segment);
-}
-function fetches_issue_comments(segment) {
-  if (!FETCHES_COMMENTS.test(segment)) return false;
-  return ISSUE_VIEW_COMMAND.test(segment) || gh_api.is_gh_api(segment) && ISSUES_PATH.test(segment);
-}
-function is_body_only_issue_read(command) {
-  const segments = shell_segments.segments_of(command);
-  if (segments.some((segment) => fetches_issue_comments(segment))) return false;
-  return segments.some((segment) => is_body_read_segment(segment));
-}
-var ISSUE_COMMENTS_REASON = "\u26D4 an Issue's comments are part of the Issue: read them before implementing, not only the body. A decision recorded after the body was written lives only in a comment \u2014 a corrected diagnosis (joshuafolkken/kit#1537), a changed default and an added acceptance criterion (joshuafolkken/kit#1520), a scope handed to another Issue (joshuafolkken/kit#1304) \u2014 and nothing in the body says it was superseded, so a body-only reader builds the wrong thing and sees no contradiction. Reissue this read with the comments included: `gh api repos/{owner}/{repo}/issues/<N>/comments --jq '.[] | {user: .user.login, created_at, body}'` beside the body read, or `gh issue view <N> --comments` where GraphQL is reachable. Then the later text is the agreement in force \u2014 a comment supersedes the body it contradicts \u2014 except for two answers that are not the run's to make: work a comment reassigns to another Issue is out of scope and is not implemented, and a comment saying the Issue no longer has a reason to exist stops the run with a `confirmation` Telegram. The procedure is `.claude/skills/workflow-commands/issue-comments.md`. Every body-only read is refused until the comments are read.";
-var { SHELL_BODY_REASON: SHELL_BODY_REASON2, carries_a_body: carries_a_body2, is_shell_evaluated_body: is_shell_evaluated_body2, keeps_body_safe: keeps_body_safe2 } = shell_body_trigger;
 var ISSUE_LISTING = /^gh\s+(?:-{1,2}[\w-]+(?:[= ]\S+)?\s+)*issue\s+list\b/u;
 var ISSUES_QUERY = /repos\/[^\s'"]*\/issues\?[^\s'"]*state=open/u;
 var OPEN_STATE = /--state[= ]open|state=open/u;
@@ -3058,9 +3185,19 @@ function counts_open_issues(command) {
     return ISSUE_LISTING.test(segment) && OPEN_STATE.test(segment) || ISSUES_QUERY.test(segment);
   });
 }
-function reads_issue_comments(command) {
-  return shell_segments.segments_of(command).some((segment) => fetches_issue_comments(segment));
-}
+var ROW22 = {
+  id: "wip-cap",
+  is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
+  reason: WIP_CAP_REASON,
+  keeps: bash_triggers.on_bash_command(counts_open_issues)
+};
+var wip_cap = { ROW: ROW22, WIP_CAP, WIP_CAP_REASON };
+
+// scripts/rules/delivered-rules.ts
+var SWITCH_ENV_KEY = "JOSH_RULE_GUARD";
+var STAMP_PREFIX = "josh-rule-guard-";
+var { is_issue_filing, on_bash_command } = bash_triggers;
+var { SHELL_BODY_REASON: SHELL_BODY_REASON2, carries_a_body: carries_a_body2, is_shell_evaluated_body: is_shell_evaluated_body2, keeps_body_safe: keeps_body_safe2 } = shell_body_trigger;
 var DELIVERED_RULES = [
   // **Listed first, ahead of the filing trigger it overlaps** (joshuafolkken/kit#2122). A `gh api`
   // that files an Issue into a repository we do not own trips both this row and `wip-cap` /
@@ -3075,12 +3212,7 @@ var DELIVERED_RULES = [
   // `epic:bundle` itself. It claims the direct call only, so the rows below — which trigger on the
   // `issue:file` call — never overlap it.
   direct_filing.ROW,
-  {
-    id: "wip-cap",
-    is_trigger: on_bash_command(is_issue_filing),
-    reason: WIP_CAP_REASON,
-    keeps: on_bash_command(counts_open_issues)
-  },
+  wip_cap.ROW,
   // **Two more rows share the filing trigger** (joshuafolkken/kit#2119, joshuafolkken/kit#2213), listed
   // after `wip-cap` so the backlog count still speaks first: `filing-cap` refuses every filing past
   // the per-run ceiling, and `issue-fold` refuses a *second* filing the run has not folded. Each is a
@@ -3088,14 +3220,8 @@ var DELIVERED_RULES = [
   // delivery is still correct one reissue later — so an unfolded, over-cap second filing is delivered
   // `wip-cap`, then `filing-cap`, then `issue-fold` across its reissues.
   filing_cap.ROW,
-  issue_fold.ROW,
-  {
-    id: "issue-comments",
-    is_trigger: on_bash_command(is_body_only_issue_read),
-    reason: ISSUE_COMMENTS_REASON,
-    already_satisfied: prior_comment_read.already_read_for_call,
-    keeps: on_bash_command(reads_issue_comments)
-  },
+  issue_fold_rule.ROW,
+  issue_comments.ROW,
   {
     id: "shell-body",
     is_trigger: on_bash_command(is_shell_evaluated_body2),
@@ -3150,11 +3276,11 @@ var DELIVERED_RULES = [
   // second inside one `fullrun` when round 2 fixes a finding in place.
   {
     id: "run-tail",
-    is_trigger: run_tail.is_foreground_push_step,
-    reason: run_tail.RUN_TAIL_REASON,
-    decide: run_tail.decide,
-    keeps: run_tail.is_backgrounded_push_step,
-    reaches: run_tail.is_push_step_call
+    is_trigger: run_tail_rule.is_foreground_push_step,
+    reason: run_tail_rule.RUN_TAIL_REASON,
+    decide: run_tail_rule.decide,
+    keeps: run_tail_rule.is_backgrounded_push_step,
+    reaches: run_tail_rule.is_push_step_call
   },
   // **The one row whose trigger consults the world beside the command**, because "is this a lane that
   // has not cut" is not readable from the call: it is the working directory's own name and the cut
@@ -3197,22 +3323,14 @@ var DELIVERED_RULES = [
   // "is this a dispatched lane child" is the dispatch mark against this checkout's own issue, read
   // synchronously by `lane_child_marker.is_child_of`, and the command match runs first so an ordinary
   // run pays nothing for it.
+  // Its once-per-run disposition is stated beside the row in `lane-park.ts`.
   //
-  // **Once per run rather than `decide`, and no `already_satisfied`.** The stop ends the turn, so it
-  // is not the recurring act joshuafolkken/kit#1570 wrote `decide` for. It carries no
-  // `already_satisfied` because the park it asks for is a GitHub label a synchronous guard cannot
-  // read, and the transcript-tail alternative would read a child that merely *read*
-  // `backlogrun-park.md` — whose prose carries the `labels[]=needs-decision` command — as compliant
-  // and fall silent on a real violation. `lane-park.ts` states why one wasted reissue on the compliant
-  // path is the safe direction. `keeps` reads an actual label-application `Bash` command, never the
-  // tail, so it is not fooled the same way; `reaches` stays `is_trigger`, since a compliant run issues
-  // the same confirmation notify and belongs in the denominator.
-  {
-    id: "lane-park",
-    is_trigger: on_bash_command(lane_park.is_unparked_stop),
-    reason: lane_park.LANE_PARK_REASON,
-    keeps: on_bash_command(lane_park.records_the_park)
-  },
+  // **A split child's park is refused first** (joshuafolkken/kit#3296): a lane child that promoted its
+  // own Issue to an epic this run has nothing to park, so `lane-split-park` refuses the label write
+  // and the confirmation notify onto that epic on every occurrence. It shares the notify with
+  // `lane-park` and is listed first; a run that promoted nothing falls through to `lane-park`.
+  lane_split_park.ROW,
+  lane_park.ROW,
   // **joshuafolkken/kit#2034's rule, one tool-call earlier** (joshuafolkken/kit#2201). `lane-park`
   // fires on the `confirmation` notify a routed child reaches; a child that reaches for
   // `AskUserQuestion` never gets there, because the harness ends its turn at the refused ask. This
@@ -3354,12 +3472,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 true;
-    return decide6(call, run2, !will_batch_guard_refuse(tail, call, run2), delivered_at_ms);
+    if (decide7 === void 0) return true;
+    return decide7(call, run2, !will_batch_guard_refuse(tail, call, run2), delivered_at_ms);
   };
 }
 function guard_of(rule) {
@@ -3392,8 +3510,8 @@ var delivered_rules = {
   DIRECT_FILING_REASON: direct_filing.DIRECT_FILING_REASON,
   FILING_CAP_REASON: filing_cap.FILING_CAP_REASON,
   GIT_FORCE_REASON: git_force.GIT_FORCE_REASON,
-  ISSUE_COMMENTS_REASON,
-  ISSUE_FOLD_REASON: issue_fold.ISSUE_FOLD_REASON,
+  ISSUE_COMMENTS_REASON: issue_comments.ISSUE_COMMENTS_REASON,
+  ISSUE_FOLD_REASON: issue_fold_rule.ISSUE_FOLD_REASON,
   LANE_INTERACTIVE_ASK_REASON: lane_interactive_ask.LANE_INTERACTIVE_ASK_REASON,
   LANE_PARK_REASON: lane_park.LANE_PARK_REASON,
   MEASURED_RULES,
@@ -3401,24 +3519,21 @@ var delivered_rules = {
   POLL_LOOP_REASON: poll_loop.POLL_LOOP_REASON,
   PRE_GATE_CUT_REASON: pre_gate_cut.PRE_GATE_CUT_REASON,
   RAW_FIELD_BODY_REASON: raw_field_body.RAW_FIELD_BODY_REASON,
-  RUN_TAIL_REASON: run_tail.RUN_TAIL_REASON,
+  RUN_TAIL_REASON: run_tail_rule.RUN_TAIL_REASON,
   SHELL_BODY_REASON: SHELL_BODY_REASON2,
   SWITCH_ENV_KEY,
   THIRD_PARTY_WRITE_REASON: third_party_write.THIRD_PARTY_WRITE_REASON,
-  WIP_CAP,
-  WIP_CAP_REASON,
+  WIP_CAP: wip_cap.WIP_CAP,
+  WIP_CAP_REASON: wip_cap.WIP_CAP_REASON,
   WORKTREE_MUTATION_REASON: worktree_guard.WORKTREE_MUTATION_REASON,
   delivery,
   delivery_path,
-  is_body_only_issue_read,
+  is_body_only_issue_read: issue_comments.is_body_only_issue_read,
   is_enabled,
   is_issue_filing
 };
 
-// scripts/run/run-watcher-hook.ts
-import { z as z12 } from "zod";
-
-// scripts/run/run-progress-read.ts
+// scripts/run/progress/run-progress-read.ts
 import { loadavg } from "node:os";
 
 // scripts/epic/epic-busy.ts
@@ -3766,7 +3881,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 {
@@ -3865,11 +3980,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_output_frozen,
@@ -4019,7 +4134,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),
@@ -4120,8 +4235,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_VERDICT,
@@ -4129,13 +4244,13 @@ var run_preflight = {
   MERGED_PR,
   STASH_LABEL_PREFIX,
   check: check2,
-  decide: decide5,
+  decide: decide6,
   read_child_state,
   read_pr_state,
   to_pr_state
 };
 
-// scripts/run/run-progress-read.ts
+// scripts/run/progress/run-progress-read.ts
 var { mark: mark2, parse_stamp: parse_stamp2, read_last_report: read_last_report2 } = run_progress_clock;
 var FIRST_LOAD_AVERAGE = 0;
 var IDLE_READ = { kind: "idle" };
@@ -4226,6 +4341,9 @@ var run_progress_read = {
   stamp_target
 };
 
+// scripts/run/run-watcher-hook.ts
+import { z as z12 } from "zod";
+
 // scripts/run/run-watcher-guard.ts
 var WATCHER_TICK_MS = 3e4;
 var TICK_MULTIPLIER = 3;
@@ -4235,7 +4353,7 @@ var STALE_THRESHOLD_S = STALE_THRESHOLD_MS / MS_PER_SECOND3;
 var STALE_NOTE = `Lane children are in-flight but the progress watcher has not pinged in the last ${String(STALE_THRESHOLD_S)}s \u2014 run \`pnpm josh run:progress --wait\` in the background before proceeding. It reports to the run event stream on its own and exits only when newly runnable work arrives, so start it once and relay nothing`;
 var OK_RESULT = { kind: "ok" };
 async function owes_watcher() {
-  if (!await run_headless.is_backlog_parent()) return false;
+  if (run_headless.is_headless() || !await run_headless.is_backlog_parent()) return false;
   return await lane_registry.has_lanes_in_flight();
 }
 async function check3(life_target) {
@@ -4354,7 +4472,7 @@ function is_runtime_file(file_path, root) {
   if (relative.startsWith(PARENT_PREFIX) || path9.isAbsolute(relative)) return false;
   return !test_declared_logic.is_exempt(relative.split(path9.sep).join("/"));
 }
-function is_candidate(raw_payload, root) {
+function is_candidate2(raw_payload, root) {
   const payload = hook_decision.parse_hook_payload(raw_payload);
   if (payload === void 0 || !EDIT_TOOLS3.has(payload.tool_name)) return void 0;
   const has_runtime_file = edited_paths(payload.tool_input).some(
@@ -4363,7 +4481,7 @@ function is_candidate(raw_payload, root) {
   return has_runtime_file ? payload.transcript_path : void 0;
 }
 function notice(raw_payload, root = process.cwd()) {
-  const transcript = is_candidate(raw_payload, root);
+  const transcript = is_candidate2(raw_payload, root);
   if (transcript === void 0) return void 0;
   const target = STAMP.path(transcript);
   if (STAMP.last_ms(target) !== hook_decision.NEVER_MS) return void 0;