@joshuafolkken/kit 1.1455.0 → 1.1514.0

package/dist/hooks/{chunk-HHI6FO3R.js → chunk-RT27QRJW.js}

@@ -1,102 +1,110 @@
 import {
   duplicate_read_outcome
-} from "./chunk-HFGWYGUV.js";
+} from "./chunk-PF2NZL2A.js";
 import {
   ALREADY_DONE_LABEL,
   CONTEXT_CUT_THRESHOLD,
   IN_PROGRESS_LABEL,
   NEEDS_DECISION_LABEL,
-  NEEDS_HUMAN_REVIEW_LABEL,
   bash_triggers,
+  cost_cli,
+  cost_verdict,
   filing_cap,
-  git_gh_api_path,
   git_gh_command,
-  git_gh_exec,
   git_gh_issue_read,
-  git_gh_pr_read,
   has_any_label,
-  has_stdout_field,
+  interactive_ask,
   issue_watch_diff,
   lane_background,
   lane_park,
-  parse_json_object_or_undefined,
-  read_json_listing,
+  pre_gate_cut,
   repo_party,
   run_cut,
   run_cut_handoff,
-  run_hold,
+  run_liveness,
   run_tail_rule,
-  session_cite,
   shell_segments,
   tail_commands
-} from "./chunk-7WQBPLUN.js";
+} from "./chunk-SYOTDYCI.js";
 import {
-  ancestor_directories,
   find_local_bin_upwards,
   json_object_schema,
   string_array_schema,
   string_record_schema,
   vscode_settings_schema
-} from "./chunk-IX6TTTI6.js";
+} from "./chunk-EFXE6C37.js";
+import {
+  distributed_paths
+} from "./chunk-M4HGZV7U.js";
 import {
-  agent_role_profile,
-  agent_session_role,
   git_common_directory,
+  git_gh_api_path,
+  git_gh_exec,
+  has_stdout_field,
   issue_cite,
   lane_registry,
+  read_json_listing,
   repo_origin,
   run_event_scope,
   run_event_stream,
   run_event_stream_emit,
   run_headless,
+  run_hold,
+  run_preflight,
+  session_cite,
   session_language
-} from "./chunk-Z4XI7CZS.js";
+} from "./chunk-WK6SMBIC.js";
+import {
+  ancestor_directories
+} from "./chunk-GP4IEC4O.js";
 import {
   error_text
 } from "./chunk-CDY4NFQG.js";
 import {
   batch_outcome
-} from "./chunk-5H4SSDSD.js";
+} from "./chunk-A65Y4YOR.js";
 import {
-  investigation_refusal
-} from "./chunk-D5QBTOCZ.js";
+  investigation_outcome
+} from "./chunk-7DSBJVFH.js";
 import {
   investigation_reads
-} from "./chunk-WNLVGT7E.js";
+} from "./chunk-PTICX4OL.js";
+import {
+  agent_role_profile,
+  agent_session_role
+} from "./chunk-UPUZF3AN.js";
 import {
   lane_guard_policy
-} from "./chunk-UT7YC3N2.js";
+} from "./chunk-JP45SOCJ.js";
 import {
   hook_decision
-} from "./chunk-GPLGZ6IC.js";
+} from "./chunk-6TS2JD6D.js";
 import {
-  cost_attribute,
   cost_blocks,
-  open_issue_schema,
   time_batch_guard,
   time_density_hook,
-  time_shell
-} from "./chunk-LIAFCXL7.js";
+  time_hook_transcript,
+  time_shell,
+  time_spans
+} from "./chunk-TNUMY6NL.js";
 import {
   lane_child_marker
-} from "./chunk-OLMO72ON.js";
+} from "./chunk-LAOV7NLM.js";
 import {
   GIT_LOCATION_VARIABLES,
   PORCELAIN_FLAG,
-  cli_flags,
-  cost_transcript,
-  cost_usage,
+  UNTRACKED_FILES_FLAG,
   file_reader,
   git_command,
+  git_diff_reads,
   git_spawn_sync,
   issue_number_shape,
   json_value,
   lane_paths,
-  own_session,
+  open_issue_schema,
   run_carry
-} from "./chunk-3C4XRYG6.js";
+} from "./chunk-APUO6U4J.js";
 import {
-  PLATFORM_TEMP_ROOT,
   PROBE_TIMEOUT_MS,
   PROJECT_ROOT,
   package_path,
@@ -114,9 +122,9 @@ var HEADER_BODY_SEPARATOR = /\r?\n\r?\n/u;
 var ETAG_HEADER = /^etag: *(?<etag>[^\r\n]+)/imu;
 var UNCHANGED = { kind: "unchanged" };
 var UNREADABLE = { kind: "unreadable" };
-function to_args(path16, etag) {
+function to_args(path13, etag) {
   const header = etag === void 0 ? [] : [HEADER_FLAG, `${IF_NONE_MATCH}${etag}`];
-  return ["api", INCLUDE_FLAG, ...header, path16];
+  return ["api", INCLUDE_FLAG, ...header, path13];
 }
 function to_changed(output) {
   const [headers = "", ...rest] = output.split(HEADER_BODY_SEPARATOR);
@@ -130,9 +138,9 @@ function failure_status(error) {
   const cause = error instanceof Error ? error.cause : void 0;
   return has_stdout_field(cause) ? git_gh_exec.parse_status_line(cause.stdout) : void 0;
 }
-async function read_conditional(path16, etag, timeout_ms) {
+async function read_conditional(path13, etag, timeout_ms) {
   try {
-    return to_read(await git_gh_exec.exec_gh_command(to_args(path16, etag), timeout_ms));
+    return to_read(await git_gh_exec.exec_gh_command(to_args(path13, etag), timeout_ms));
   } catch (error) {
     return failure_status(error) === NOT_MODIFIED_STATUS ? UNCHANGED : UNREADABLE;
   }
@@ -162,9 +170,9 @@ function read_record(root) {
   const raw = stamp_file.read_stamp_text(record_path(root));
   return raw === void 0 ? void 0 : json_value.parse_with(raw, record_schema);
 }
-function write_record(record, root) {
-  stamp_file.replace_stamp(record_path(root), record);
-  return record;
+function write_record(record2, root) {
+  stamp_file.replace_stamp(record_path(root), record2);
+  return record2;
 }
 function clear(root) {
   stamp_file.remove_stamp(record_path(root));
@@ -204,44 +212,44 @@ async function record_baseline_here(issue) {
 async function clear_here() {
   clear(await git_command.repository_root());
 }
-function with_fetched(record, fetched, checked_at) {
-  if (fetched.kind !== "read") return { ...record, checked_at };
-  const pending = issue_watch_diff.unread_diff(record, fetched.snapshot);
-  return { ...record, checked_at, etag: fetched.etag, pending };
+function with_fetched(record2, fetched, checked_at) {
+  if (fetched.kind !== "read") return { ...record2, checked_at };
+  const pending = issue_watch_diff.unread_diff(record2, fetched.snapshot);
+  return { ...record2, checked_at, etag: fetched.etag, pending };
 }
-function is_due(record, options, now) {
-  return now.getTime() - Date.parse(record.checked_at) >= options.interval_ms;
+function is_due(record2, options, now) {
+  return now.getTime() - Date.parse(record2.checked_at) >= options.interval_ms;
 }
-async function refresh(record, options, now, root) {
+async function refresh(record2, options, now, root) {
   const fetched = await fetch_issue({
-    issue: record.issue,
-    etag: record.etag,
+    issue: record2.issue,
+    etag: record2.etag,
     timeout_ms: options.timeout_ms
   });
   if (fetched.kind === "closed") {
     clear(root);
     return void 0;
   }
-  return write_record(with_fetched(record, fetched, now.toISOString()), root);
+  return write_record(with_fetched(record2, fetched, now.toISOString()), root);
 }
 async function poll(options, root) {
-  const record = read_record(root);
+  const record2 = read_record(root);
   const now = options.now ?? /* @__PURE__ */ new Date();
-  if (record === void 0 || !is_due(record, options, now)) return record;
-  return await refresh(record, options, now, root);
+  if (record2 === void 0 || !is_due(record2, options, now)) return record2;
+  return await refresh(record2, options, now, root);
 }
-function mark_shown(record, root) {
-  return write_record({ ...record, shown: record.pending }, root);
+function mark_shown(record2, root) {
+  return write_record({ ...record2, shown: record2.pending }, root);
 }
 async function acknowledge(root, now = /* @__PURE__ */ new Date()) {
-  const record = read_record(root);
-  if (record === void 0) return void 0;
-  const fetched = await fetch_issue({ issue: record.issue });
+  const record2 = read_record(root);
+  if (record2 === void 0) return void 0;
+  const fetched = await fetch_issue({ issue: record2.issue });
   if (fetched.kind !== "read") return void 0;
-  const diff = issue_watch_diff.unread_diff(record, fetched.snapshot);
-  const acknowledged_at = diff === void 0 ? record.acknowledged_at : now.toISOString();
-  write_record(fresh_record(record.issue, fetched, now, acknowledged_at), root);
-  return { issue: record.issue, diff };
+  const diff = issue_watch_diff.unread_diff(record2, fetched.snapshot);
+  const acknowledged_at = diff === void 0 ? record2.acknowledged_at : now.toISOString();
+  write_record(fresh_record(record2.issue, fetched, now, acknowledged_at), root);
+  return { issue: record2.issue, diff };
 }
 var issue_watch = {
   acknowledge,
@@ -444,16 +452,16 @@ var EVERY_CALL_MS = 0;
 function ack_command(issue) {
   return `pnpm josh issue:ack ${issue}`;
 }
-function unread_message(record) {
+function unread_message(record2) {
   return [
-    `A person updated issue ${session_cite.issue(record.issue)} after this run read it, and the run has not taken the update in:`,
-    record.pending ?? "",
-    `Read it, compare it with the acceptance criteria, fix what it changes, then run \`${ack_command(record.issue)}\` to record that it was read.`
+    `A person updated issue ${session_cite.issue(record2.issue)} after this run read it, and the run has not taken the update in:`,
+    record2.pending ?? "",
+    `Read it, compare it with the acceptance criteria, fix what it changes, then run \`${ack_command(record2.issue)}\` to record that it was read.`
   ].join("\n\n");
 }
-function review_message(record, briefed_at) {
+function review_message(record2, briefed_at) {
   return [
-    `Issue ${session_cite.issue(record.issue)} was updated after the review was briefed (taken in at ${record.acknowledged_at}, briefed at ${briefed_at}), so the review read the earlier specification.`,
+    `Issue ${session_cite.issue(record2.issue)} was updated after the review was briefed (taken in at ${record2.acknowledged_at}, briefed at ${briefed_at}), so the review read the earlier specification.`,
     "Re-run `/code-review` with a fresh `pnpm josh review:brief`, so the review reads the change against the updated issue."
   ].join("\n");
 }
@@ -461,16 +469,16 @@ async function polled(root) {
   return await issue_watch.poll({ interval_ms: EVERY_CALL_MS }, root);
 }
 async function unread_refusal(root) {
-  const record = await polled(root);
-  return record?.pending === void 0 ? void 0 : unread_message(record);
+  const record2 = await polled(root);
+  return record2?.pending === void 0 ? void 0 : unread_message(record2);
 }
 async function review_refusal(root) {
-  const record = await polled(root);
-  if (record === void 0) return void 0;
-  if (record.pending !== void 0) return unread_message(record);
+  const record2 = await polled(root);
+  if (record2 === void 0) return void 0;
+  if (record2.pending !== void 0) return unread_message(record2);
   const pointer = review_attest.read_pointer(root);
-  if (pointer === void 0 || record.acknowledged_at <= pointer.taken_at) return void 0;
-  return review_message(record, pointer.taken_at);
+  if (pointer === void 0 || record2.acknowledged_at <= pointer.taken_at) return void 0;
+  return review_message(record2, pointer.taken_at);
 }
 async function review_refusal_here() {
   return await review_refusal(await git_command.repository_root());
@@ -490,18 +498,18 @@ var issue_watch_gate = {
 // scripts/issue/issue-watch-hook.ts
 var POLL_INTERVAL_MS = 18e4;
 var POLL_TIMEOUT_MS = 5e3;
-function is_new_to_run(record) {
-  return record?.pending !== void 0 && record.pending !== record.shown;
+function is_new_to_run(record2) {
+  return record2?.pending !== void 0 && record2.pending !== record2.shown;
 }
 async function new_update_reason(now) {
-  const record = await issue_watch.poll({
+  const record2 = await issue_watch.poll({
     interval_ms: POLL_INTERVAL_MS,
     timeout_ms: POLL_TIMEOUT_MS,
     now
   });
-  if (!is_new_to_run(record)) return void 0;
-  issue_watch.mark_shown(record);
-  return issue_watch_gate.unread_message(record);
+  if (!is_new_to_run(record2)) return void 0;
+  issue_watch.mark_shown(record2);
+  return issue_watch_gate.unread_message(record2);
 }
 async function watch_reason(now = /* @__PURE__ */ new Date()) {
   try {
@@ -540,12 +548,41 @@ async function mark_implement(directory = process.cwd(), source = process.env) {
 }
 var lane_phase = { mark_implement };
 
+// scripts/rules/agent-model.ts
+var SUBAGENT_TOOLS = /* @__PURE__ */ new Set(["Agent", "Task"]);
+var GENERAL_PURPOSE = "general-purpose";
+function is_general_purpose(call) {
+  if (!SUBAGENT_TOOLS.has(call.name) || !json_value.is_record(call.input)) return false;
+  const type = call.input["subagent_type"];
+  return type === void 0 || type === GENERAL_PURPOSE;
+}
+function names_model(call) {
+  const model = json_value.is_record(call.input) ? call.input["model"] : void 0;
+  return typeof model === "string" && model.length > 0;
+}
+function is_unnamed_model(call) {
+  return is_general_purpose(call) && !names_model(call);
+}
+function keeps_model(call) {
+  return is_general_purpose(call) && names_model(call);
+}
+var AGENT_MODEL_REASON = "\u26D4 agent model: a `general-purpose` subagent with no `model` inherits the parent model. Reissue the call with `model` set \u2014 `sonnet` for routine work, `opus` for judgment such as a review. It fires on every occurrence (`.claude/skills/workflow-commands/delegation.md`).";
+var ROW = {
+  id: "agent-model",
+  is_trigger: is_unnamed_model,
+  reason: AGENT_MODEL_REASON,
+  decide: () => true,
+  keeps: keeps_model,
+  reaches: is_general_purpose
+};
+var agent_model = { AGENT_MODEL_REASON, ROW, is_unnamed_model };
+
 // 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-backlog.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>`, never with `gh api \u2026/issues` or `gh issue create` \u2014 it runs the scout, the lint, the labels and `epic:bundle` itself. It fires on every occurrence (`docs/josh-commands-backlog.md` \u2192 "`josh issue:file`").';
 function is_any_filing(command) {
   return bash_triggers.is_direct_filing(command) || bash_triggers.is_issue_filing(command);
 }
-var ROW = {
+var ROW2 = {
   id: "direct-filing",
   is_trigger: bash_triggers.on_bash_command(bash_triggers.is_direct_filing),
   reason: DIRECT_FILING_REASON,
@@ -553,7 +590,7 @@ var ROW = {
   keeps: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
   reaches: bash_triggers.on_bash_command(is_any_filing)
 };
-var direct_filing = { DIRECT_FILING_REASON, ROW };
+var direct_filing = { DIRECT_FILING_REASON, ROW: ROW2 };
 
 // scripts/run/progress/run-progress.ts
 var DEFAULT_INTERVAL_MINUTES = 20;
@@ -890,17 +927,17 @@ function landing_ms(command, now_ms, last_report_ms) {
   const lands_ms = now_ms + duration_ms;
   return run_progress.is_due(last_report_ms, lands_ms, interval_ms) ? lands_ms : void 0;
 }
-function decide(call, run2, can_record) {
+function decide(call, run, can_record) {
   const last_report_ms = run_progress_clock.read_last_report_sync();
   if (last_report_ms === void 0) return false;
-  const target = ARM_RECORD.path(run2.transcript);
-  if (is_armed(target, run2.now_ms)) return true;
-  const lands_ms = landing_ms(time_shell.bash_command(call.input), run2.now_ms, last_report_ms);
+  const target = ARM_RECORD.path(run.transcript);
+  if (is_armed(target, run.now_ms)) return true;
+  const lands_ms = landing_ms(time_shell.bash_command(call.input), run.now_ms, last_report_ms);
   if (lands_ms === void 0) return true;
   if (can_record) ARM_RECORD.record(target, lands_ms);
   return false;
 }
-var EARLY_HEARTBEAT_REASON = "\u26D4 early heartbeat: this call arms a wait timer of its own, and the progress clock is not yours to keep. `pnpm josh run:progress --wait` keeps it for you (`JOSH_PROGRESS_INTERVAL_MINUTES`, or `josh.progress_interval_minutes` in `package.json`, default 20 minutes): start it once in the background and it reports the five labelled lines to the run's event stream on its own, without waking you \u2014 relay nothing, and start it again only after it exits, which it does when newly runnable work arrives. Two timers armed at once is what produced reports 3\u20135 minutes apart on a 15-minute setting (joshuafolkken/kit#1570): a new one was armed on the turn a timer fired and again on the turn a child's completion woke the run, and `--mark` recorded each report without anything refusing the early ones. **An explicit ask is not a heartbeat**: if the person asked for progress now, run `pnpm josh run:progress --once`, which prints the five labelled lines whatever the clock says \u2014 under `backlogrun`, `pnpm josh run:board --chat` instead. If you are waiting on something rather than on a clock, wait on the thing itself \u2014 `pnpm josh followup` waits for CI. The procedure is `.claude/skills/workflow-commands/backlogrun.md` \u2192 \"Progress while the run is quiet\". **This rule fires on every early arm, not once per run**, so reissuing the same sleep will be refused again.";
+var EARLY_HEARTBEAT_REASON = "\u26D4 early heartbeat: this call arms a wait timer of its own. Start `pnpm josh run:progress --wait` once in the background: it reports to the run's event stream on its own \u2014 relay nothing. When asked, `pnpm josh run:progress --once` \u2014 under `backlogrun`, `pnpm josh run:board --chat`; for CI, `pnpm josh followup`. It fires on every occurrence (`.claude/skills/workflow-commands/progress-watcher.md`).";
 var PROGRESS_NAMES = /* @__PURE__ */ new Set(["run:progress"]);
 var WATCH_FLAG = /(?:^|\s)--(?:wait|once)(?=\s|$)/u;
 function is_progress_watch_segment(segment) {
@@ -998,8 +1035,8 @@ function carries_a_file_body(command, has_file = existsSync) {
     (line) => is_heredoc_write(line, has_file) || has_body_interpreter(line)
   );
 }
-var FILE_BODY_REASON = "\u26D4 file body in a shell command: this carries a file's new text inline \u2014 a heredoc rewriting an existing file, an interpreter (`python3 - <<`, `node -e`) whose body writes, a script file (`cat > edit.py <<EOF`) whose body writes, or an in-place `perl -0pi -e`. `CLAUDE.md` forbids it because the command body is re-read on every later request of the run, so an editing script written early is billed for the rest of it (`file-edits.md` measured one run at ~2m45s spent retyping existing lines). Edit a region with the Edit tool (old / new); a change scattered so widely that the partial edits would carry more than the file is rewritten whole with the Write tool, never a heredoc. Pass a body by path (`--field body=@<path>`, `--body-file <path>`). A new-file creation (`cat > <new-file> <<EOF`), a read-only heredoc (`cat <<EOF`), and a short `sed -i` stay allowed. **This rule fires on every occurrence, not once per run.**";
-var ROW2 = {
+var FILE_BODY_REASON = "\u26D4 file body in a shell command: this carries a file's new text inline, which is re-read on every later request. Edit a region with the Edit tool, rewrite a whole file with the Write tool, and pass a body by path (`--body-file <path>`); a new-file `cat > <new-file> <<EOF` stays allowed. This rule fires on every occurrence (`prompts/collaboration-workflow/file-edits.md`).";
+var ROW3 = {
   id: "file-body",
   is_trigger: bash_triggers.on_bash_command((command) => carries_a_file_body(command)),
   reason: FILE_BODY_REASON,
@@ -1007,7 +1044,7 @@ var ROW2 = {
 };
 var file_body = {
   FILE_BODY_REASON,
-  ROW: ROW2,
+  ROW: ROW3,
   carries_a_file_body
 };
 
@@ -1109,8 +1146,8 @@ function is_destructive_segment(segment) {
 function is_force_or_delete(command) {
   return shell_segments.segments_of(command).some((segment) => is_destructive_segment(segment));
 }
-var GIT_FORCE_REASON = "\u26D4 force push or branch delete: this rewrites or removes shared history, which is Tier C and needs explicit current-turn user instruction \u2014 never an AI decision, even to fix a problem you caused (`prompts/collaboration-workflow/operating-rules.md`). The `.claude/settings.json` deny list matches globs, so it misses this spelling: a combined short cluster (`git push -uf`), a `git -C <path>` prefix, and the colon-form delete (`git push origin :branch`) all pass it. This row reads the argv instead, so the spelling does not matter. For an ordinary push use `pnpm josh git`; a force push, a `git push --delete` / `:branch`, or a `git branch -d` / `-D` is the user's to run in their own terminal. **This rule fires on every occurrence, not once per run.**";
-var ROW3 = {
+var GIT_FORCE_REASON = "\u26D4 force push or branch delete: this rewrites or removes shared history, which is Tier C and needs explicit current-turn user instruction. Push with `pnpm josh git`; leave a force push or branch delete to the user's own terminal. This rule fires on every occurrence (`prompts/collaboration-workflow/operating-rules.md`).";
+var ROW4 = {
   id: "git-force",
   is_trigger: bash_triggers.on_bash_command(is_force_or_delete),
   reason: GIT_FORCE_REASON,
@@ -1118,376 +1155,10 @@ var ROW3 = {
 };
 var git_force = {
   GIT_FORCE_REASON,
-  ROW: ROW3,
+  ROW: ROW4,
   is_force_or_delete
 };
 
-// scripts/cost-runtime/cost-cli.ts
-import { fileURLToPath } from "node:url";
-
-// scripts/cost-runtime/codex-usage.ts
-import { globSync, readFileSync as readFileSync2 } from "node:fs";
-import path2 from "node:path";
-import { z as z4 } from "zod";
-var THREAD_ID_PATTERN = /^[A-Za-z0-9-]+$/u;
-var SESSION_META_SCHEMA = z4.looseObject({
-  type: z4.literal("session_meta"),
-  payload: z4.looseObject({ id: z4.string(), cwd: z4.string() })
-});
-var TOTAL_USAGE_SCHEMA = z4.looseObject({ input_tokens: z4.number().nonnegative() });
-var TOKEN_COUNT_SCHEMA = z4.looseObject({
-  type: z4.literal("event_msg"),
-  payload: z4.looseObject({
-    type: z4.literal("token_count"),
-    info: z4.looseObject({
-      total_token_usage: TOTAL_USAGE_SCHEMA,
-      last_token_usage: TOTAL_USAGE_SCHEMA
-    })
-  })
-});
-function same_project(cwd, target) {
-  return cost_transcript.session_cwd(cwd) === cost_transcript.session_cwd(target);
-}
-function billed_per_request(usages) {
-  return usages.map((usage) => usage.last_token_usage.input_tokens);
-}
-function measurement_from(content, target, thread_id) {
-  const values = content.split("\n").map((line) => json_value.parse_or_undefined(line));
-  const metadata = values.flatMap((value) => {
-    const parsed = SESSION_META_SCHEMA.safeParse(value);
-    return parsed.success ? [parsed.data] : [];
-  });
-  const usages = values.flatMap((value) => {
-    const parsed = TOKEN_COUNT_SCHEMA.safeParse(value);
-    return parsed.success ? [parsed.data.payload.info] : [];
-  });
-  const session = metadata.find((entry) => entry.payload.id === thread_id);
-  if (session === void 0 || usages.length === 0) return void 0;
-  if (!same_project(session.payload.cwd, target)) return void 0;
-  return { billed_input_per_request: billed_per_request(usages) };
-}
-function rollout_files(home, thread_id) {
-  if (!THREAD_ID_PATTERN.test(thread_id)) return [];
-  return globSync(`sessions/**/*${thread_id}.jsonl`, { cwd: home }).map(
-    (file) => path2.join(home, file)
-  );
-}
-function read_measurement(file, target, thread_id) {
-  try {
-    return measurement_from(readFileSync2(file, "utf8"), target, thread_id);
-  } catch {
-    return void 0;
-  }
-}
-function latest_measurement(files, target, thread_id) {
-  for (const file of files.toReversed()) {
-    const measured = read_measurement(file, target, thread_id);
-    if (measured !== void 0) return measured;
-  }
-  return void 0;
-}
-function measurement(target, default_home, environment = process.env) {
-  const thread_id = environment["CODEX_THREAD_ID"];
-  if (thread_id === void 0) return void 0;
-  const home = environment["CODEX_HOME"] ?? path2.join(default_home, ".codex");
-  return latest_measurement(rollout_files(home, thread_id), target, thread_id);
-}
-var codex_usage = { measurement };
-
-// scripts/cost-runtime/cost-corpus.ts
-function accumulate_missing(sessions) {
-  return {
-    no_usage_lines: sessions.reduce((sum, session) => sum + session.no_usage_lines, 0),
-    malformed_lines: sessions.reduce((sum, session) => sum + session.malformed_lines, 0),
-    unreadable_sessions: sessions.filter((session) => !session.is_readable).length,
-    // Filled by the attribution, which is the only step that knows a unit could not follow its
-    // parent; a per-session tally cannot see it, so it is zero here and set for an issue scope below.
-    unattributed_sessions: 0
-  };
-}
-function load_corpus(cwd) {
-  const files = cost_transcript.list_sessions_across(cost_transcript.transcript_directories(cwd));
-  const sessions = files.map((file) => cost_transcript.read_session(file));
-  return { sessions, files, missing: accumulate_missing(sessions) };
-}
-function session_meta(corpus) {
-  return new Map(
-    corpus.files.map((file) => [
-      file.session_id,
-      { is_delegated: file.is_delegated, owner: cost_transcript.owning_session_id(file) }
-    ])
-  );
-}
-function issue_set(records) {
-  const issues = cost_attribute.group_by_issue(records).map((group) => group.issue).filter((issue) => issue !== cost_attribute.UNATTRIBUTED_KEY);
-  return new Set(issues);
-}
-function sole_of(issues) {
-  if (issues.size !== 1) return cost_attribute.UNATTRIBUTED_KEY;
-  return [...issues][0] ?? cost_attribute.UNATTRIBUTED_KEY;
-}
-function owner_sets(corpus, meta) {
-  const own = corpus.sessions.filter(
-    (session) => meta.get(session.session_id)?.is_delegated !== true
-  );
-  return new Map(own.map((session) => [session.session_id, issue_set(session.records)]));
-}
-function pairs_with_inherited(session, inherited, is_delegated) {
-  return cost_attribute.group_by_issue(session.records).flatMap(
-    (group) => group.records.map((record) => ({
-      record,
-      issue: group.issue === cost_attribute.UNATTRIBUTED_KEY ? inherited : group.issue,
-      baseline_tokens: session.baseline_tokens,
-      session_id: session.session_id,
-      is_delegated
-    }))
-  );
-}
-var NO_ISSUES = /* @__PURE__ */ new Set();
-function parent_issues(session, meta, owners) {
-  const entry = meta.get(session.session_id);
-  if (entry?.is_delegated !== true) return NO_ISSUES;
-  return owners.get(entry.owner) ?? NO_ISSUES;
-}
-function pairs_of_session(session, meta, owners) {
-  const is_delegated = meta.get(session.session_id)?.is_delegated === true;
-  const candidates = parent_issues(session, meta, owners);
-  const inherited = is_delegated ? sole_of(candidates) : cost_attribute.UNATTRIBUTED_KEY;
-  const pairs = pairs_with_inherited(session, inherited, is_delegated);
-  const has_unattributed = pairs.some((pair) => pair.issue === cost_attribute.UNATTRIBUTED_KEY);
-  if (!is_delegated || !has_unattributed) return { pairs };
-  return { pairs, unattributed_candidates: candidates };
-}
-function attribute_corpus(corpus) {
-  const meta = session_meta(corpus);
-  const owners = owner_sets(corpus, meta);
-  const per_session = corpus.sessions.map((session) => pairs_of_session(session, meta, owners));
-  return {
-    pairs: per_session.flatMap((one) => one.pairs),
-    unattributed: per_session.flatMap(
-      (one) => one.unattributed_candidates === void 0 ? [] : [one.unattributed_candidates]
-    )
-  };
-}
-function floor_for_issue(unattributed, issue_number) {
-  return unattributed.filter((set) => set.size === 0 || set.has(issue_number)).length;
-}
-function is_better(candidate, existing) {
-  const { UNATTRIBUTED_KEY } = cost_attribute;
-  return existing.issue === UNATTRIBUTED_KEY && candidate.issue !== UNATTRIBUTED_KEY;
-}
-function values_of(best) {
-  const collected = [];
-  for (const [, pair] of best) collected.push(pair);
-  return collected;
-}
-function dedupe_across_sessions(pairs) {
-  const best = /* @__PURE__ */ new Map();
-  for (const pair of pairs) {
-    const existing = best.get(pair.record.request_id);
-    if (existing === void 0 || is_better(pair, existing)) {
-      best.set(pair.record.request_id, pair);
-    }
-  }
-  return values_of(best);
-}
-function attributed(corpus) {
-  return dedupe_across_sessions(attribute_corpus(corpus).pairs);
-}
-function mainline_records(pairs) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const pair of pairs) {
-    if (pair.is_delegated) continue;
-    groups.set(pair.session_id, [...groups.get(pair.session_id) ?? [], pair.record]);
-  }
-  return [...groups.values()];
-}
-var cost_corpus = {
-  load_corpus,
-  attribute_corpus,
-  floor_for_issue,
-  attributed,
-  mainline_records
-};
-
-// scripts/cost-runtime/cost-verdict.ts
-var FAILURE_EXIT_CODE = 1;
-var OVER_VERDICT = "over";
-var UNDER_VERDICT = "under";
-function per_request_cost(measurement2) {
-  return measurement2.billed_input_per_request.at(-1) ?? 0;
-}
-function classify(measurement2, limit) {
-  return per_request_cost(measurement2) > limit ? OVER_VERDICT : UNDER_VERDICT;
-}
-function over_summary(measurement2, limit) {
-  const total = measurement2.billed_input_per_request.length;
-  return `${String(per_request_cost(measurement2))} billed input tokens per request, on the newest of ${String(total)} request(s); limit ${String(limit)}`;
-}
-function report_over(measurement2, limit) {
-  if (measurement2 === void 0 || measurement2.billed_input_per_request.length === 0) {
-    console.error("No requests in this session; there is nothing to hand off.");
-    return FAILURE_EXIT_CODE;
-  }
-  console.info(classify(measurement2, limit));
-  console.error(over_summary(measurement2, limit));
-  return 0;
-}
-var cost_verdict = {
-  OVER_VERDICT,
-  UNDER_VERDICT,
-  classify,
-  per_request_cost,
-  report_over
-};
-
-// scripts/cost-runtime/transcript-cwd.ts
-import path3 from "node:path";
-function resolve(target, cwd) {
-  return target === void 0 ? cwd : path3.resolve(target);
-}
-var transcript_cwd = { resolve };
-
-// scripts/cost-runtime/cost-cli.ts
-var ARGV_OFFSET = 2;
-var FAILURE_EXIT_CODE2 = 1;
-var USAGE = "Usage: josh cost (--cut | --over <tokens-per-request>) [--path <dir>]";
-var UNMEASURABLE_VERDICT = "unmeasurable";
-function to_threshold(raw) {
-  if (raw === void 0) return void 0;
-  if (raw.trim() === "") return void 0;
-  const parsed = Number(raw);
-  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
-}
-function is_unparsed(raw, parsed) {
-  return parsed === void 0 && raw !== void 0;
-}
-function selected_threshold(values) {
-  if (values.cut === true) return CONTEXT_CUT_THRESHOLD;
-  return to_threshold(values.over);
-}
-function threshold_option(over) {
-  return over === void 0 ? {} : { over };
-}
-function path_option(path16) {
-  return path16 === void 0 ? {} : { path: path16 };
-}
-function to_options(values) {
-  if (values.cut === true && values.over !== void 0) return void 0;
-  const over = selected_threshold(values);
-  if (is_unparsed(values.over, over)) return void 0;
-  return { ...threshold_option(over), ...path_option(values.path) };
-}
-var PARSE_ARGS_OPTIONS = {
-  cut: { type: "boolean" },
-  over: { type: "string" },
-  path: { type: "string" }
-};
-function parse_options(argv) {
-  const values = cli_flags.values_of(argv, PARSE_ARGS_OPTIONS);
-  return values === void 0 ? void 0 : to_options(values);
-}
-function report_empty(cwd, session_id) {
-  const searched = cost_transcript.searched_directories(cost_transcript.transcript_directories(cwd));
-  for (const line of cost_transcript.missing_message(searched, session_id)) console.error(line);
-  return FAILURE_EXIT_CODE2;
-}
-function provider_of(environment) {
-  const resolved = agent_role_profile.resolve_provider(environment);
-  if (resolved.kind !== "provider" || resolved.is_default === true) return void 0;
-  return resolved.provider;
-}
-function measurement_of(session) {
-  return {
-    billed_input_per_request: session.records.map(
-      (record) => cost_usage.billed_input(record.totals)
-    )
-  };
-}
-function anthropic_own(target, environment) {
-  const corpus = cost_corpus.load_corpus(target);
-  const selection = own_session.select_own_session(corpus.files, environment);
-  if (selection.kind === "absent") return { kind: "absent", session_id: selection.session_id };
-  const session = corpus.sessions[selection.index];
-  if (session === void 0) return { kind: "empty" };
-  return { kind: "measured", measurement: measurement_of(session) };
-}
-function anthropic_measurement(target, environment) {
-  const own = anthropic_own(target, environment);
-  return own.kind === "measured" ? own.measurement : void 0;
-}
-function same_openai_project(target, cwd) {
-  return cost_transcript.session_cwd(target) === cost_transcript.session_cwd(cwd);
-}
-function reject_openai_cross_project(context, target, cwd) {
-  if (context.provider !== "openai" || context.path === void 0 || same_openai_project(target, cwd)) {
-    return false;
-  }
-  console.error(
-    "OpenAI --path cannot select a thread from another project; run josh cost in that project."
-  );
-  return true;
-}
-function measure(target, provider, environment) {
-  return provider === "openai" ? codex_usage.measurement(target, cost_transcript.home_directory(), environment) : anthropic_measurement(target, environment);
-}
-function run_over_anthropic(own, target, limit) {
-  if (own.kind === "measured") return cost_verdict.report_over(own.measurement, limit);
-  return report_empty(target, own.kind === "absent" ? own.session_id : void 0);
-}
-function run_over_codex(target, limit, environment) {
-  const measurement2 = measure(target, "openai", environment);
-  if (measurement2 !== void 0) return cost_verdict.report_over(measurement2, limit);
-  console.error(`No Codex usage found for the current OpenAI thread under ${target}.`);
-  return FAILURE_EXIT_CODE2;
-}
-function run_over(target, limit, provider, environment) {
-  if (provider === "anthropic") {
-    return run_over_anthropic(anthropic_own(target, environment), target, limit);
-  }
-  return run_over_codex(target, limit, environment);
-}
-function verdict_of(measurement2) {
-  if (measurement2 === void 0 || measurement2.billed_input_per_request.length === 0) {
-    return UNMEASURABLE_VERDICT;
-  }
-  return cost_verdict.classify(measurement2, CONTEXT_CUT_THRESHOLD);
-}
-function session_verdict(cwd = process.cwd(), environment = process.env) {
-  const provider = provider_of(environment);
-  if (provider === void 0) return UNMEASURABLE_VERDICT;
-  return verdict_of(measure(cwd, provider, environment));
-}
-function run_context(argv, environment) {
-  const options = parse_options(argv);
-  if (options?.over === void 0) return void 0;
-  const provider = provider_of(environment);
-  if (provider === void 0) return void 0;
-  return { over: options.over, path: options.path, provider };
-}
-function run(argv, cwd = process.cwd(), environment = process.env) {
-  const context = run_context(argv, environment);
-  if (context === void 0) {
-    console.error(USAGE);
-    return FAILURE_EXIT_CODE2;
-  }
-  const target = transcript_cwd.resolve(context.path, cwd);
-  if (reject_openai_cross_project(context, target, cwd)) return FAILURE_EXIT_CODE2;
-  return run_over(target, context.over, context.provider, environment);
-}
-function main(argv) {
-  process.exitCode = run(argv);
-}
-var cost_cli = {
-  UNMEASURABLE_VERDICT,
-  USAGE,
-  parse_options,
-  to_threshold,
-  run,
-  session_verdict
-};
-if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(ARGV_OFFSET));
-
 // scripts/cost-runtime/cost-format.ts
 var USD_DECIMALS = 4;
 var PERCENT_SCALE = 100;
@@ -1508,6 +1179,69 @@ var cost_format = {
   format_share
 };
 
+// scripts/run/cut/run-cut-decline.ts
+import { z as z4 } from "zod";
+var DECLINE_PREFIX = "josh-run-cut-decline-";
+var decline_schema = z4.object({ issue: z4.string(), hold_taken_at: z4.string().optional() });
+function decline_path(git_directory) {
+  return stamp_file.stamp_path(DECLINE_PREFIX, git_directory);
+}
+function record(git_directory, decline) {
+  stamp_file.replace_stamp(decline_path(git_directory), decline);
+}
+function read(git_directory) {
+  const raw = stamp_file.read_stamp_text(decline_path(git_directory));
+  return raw === void 0 ? void 0 : json_value.parse_with(raw, decline_schema);
+}
+function matches(recorded, current) {
+  return recorded?.issue === current.issue && recorded.hold_taken_at === current.hold_taken_at;
+}
+function is_declined_sync(issue, directory = run_cut.worktree_git_directory_sync()) {
+  if (directory === void 0) return false;
+  const hold_taken_at = run_cut.hold_of(directory)?.taken_at;
+  return matches(read(directory), { issue, hold_taken_at });
+}
+async function declined(request2, state, code) {
+  if (request2.phase !== run_cut.IMPLEMENTATION_PHASE) return code;
+  const directory = await run_cut.worktree_directory();
+  if (directory !== void 0) {
+    record(directory, { issue: request2.issue, hold_taken_at: state.hold_taken_at });
+  }
+  return code;
+}
+var run_cut_decline = { decline_path, declined, is_declined_sync, read, record };
+
+// scripts/run/cut/run-cut-ready.ts
+function is_ready(tree) {
+  return tree.branch !== tree.default_branch && tree.is_dirty;
+}
+async function is_lane_branch(state) {
+  const default_branch = await git_command.get_default_branch();
+  return is_ready({ branch: state.branch, default_branch, is_dirty: state.is_dirty });
+}
+var STATUS_ARGUMENTS = ["status", "--porcelain=v2", "--branch", UNTRACKED_FILES_FLAG];
+var HEADER_PREFIX = "#";
+var BRANCH_HEADER = "# branch.head ";
+function tree_of(status, default_branch) {
+  const lines = status.split("\n").filter((line) => line !== "");
+  const header = lines.find((line) => line.startsWith(BRANCH_HEADER));
+  if (header === void 0) return void 0;
+  const branch = header.slice(BRANCH_HEADER.length);
+  const is_dirty = lines.some((line) => !line.startsWith(HEADER_PREFIX));
+  return { branch, default_branch, is_dirty };
+}
+function read_tree_sync() {
+  const status = git_spawn_sync.read(STATUS_ARGUMENTS);
+  if (status === void 0) return void 0;
+  const reference = git_spawn_sync.read(git_diff_reads.DEFAULT_BRANCH_ARGUMENTS);
+  return tree_of(status, git_diff_reads.default_branch_of(reference));
+}
+function is_ready_sync(read2 = read_tree_sync) {
+  const tree = read2();
+  return tree === void 0 || is_ready(tree);
+}
+var run_cut_ready = { is_lane_branch, is_ready, is_ready_sync, tree_of };
+
 // scripts/rules/implementation-cut-verdict.ts
 import { z as z5 } from "zod";
 var VERDICT_CACHE_PREFIX = "josh-impl-cut-verdict-";
@@ -1555,6 +1289,9 @@ function is_impl_cut_segment(segment) {
 function takes_the_impl_cut(command) {
   return shell_segments.segments_of(command).some((segment) => is_impl_cut_segment(segment));
 }
+function can_cut_sync(issue) {
+  return !run_cut_decline.is_declined_sync(issue) && run_cut_ready.is_ready_sync();
+}
 function current_state() {
   return {
     directory: process.cwd(),
@@ -1564,7 +1301,8 @@ function current_state() {
     // **Read through the short reuse window**. The row now fires per
     // threshold crossing rather than once per run, so this predicate is a candidate on every edit;
     // the window collapses one turn's burst of edits to a single whole-transcript price.
-    verdict: () => implementation_cut_verdict.reused_verdict(() => cost_cli.session_verdict())
+    verdict: () => implementation_cut_verdict.reused_verdict(() => cost_cli.session_verdict()),
+    can_cut: can_cut_sync
   };
 }
 function lane_child_issue(state) {
@@ -1590,29 +1328,36 @@ function warrants_the_cut(state) {
   return verdict !== cost_verdict.UNDER_VERDICT;
 }
 function is_over_threshold_edit(call, state = current_state()) {
-  if (!is_edit_tool(call.name) || uncut_run_issue(state) === void 0) return false;
-  return warrants_the_cut(state);
+  if (!is_edit_tool(call.name)) return false;
+  const issue = uncut_run_issue(state);
+  if (issue === void 0) return false;
+  return warrants_the_cut(state) && state.can_cut(issue);
 }
 var THRESHOLD_TEXT = `${cost_format.format_tokens(CONTEXT_CUT_THRESHOLD)}-token`;
-var IMPLEMENTATION_CUT_REASON = `\u26D4 implementation-phase cut: this checkout is a lane dispatched for this issue, or a run holds it for this issue (joshuafolkken/kit#2760), and its recent-context cost has crossed the shared ${THRESHOLD_TEXT} threshold mid-implementation, so the thinking accumulated so far is now re-read on every later request. Take the cut before this edit. First write a handoff file at \`${run_cut_handoff.HANDOFF_PATH}\` (ignored, so it is never committed) with the Write tool \u2014 the user\u2019s instruction verbatim, what you have completed, what remains, and what you deliberately did not touch, as ${run_cut_handoff.HANDOFF_FORMAT} (Markdown is refused) \u2014 and pass it as \`--handoff <path>\`, so the fresh process resumes on the original instruction rather than the working tree alone (joshuafolkken/kit#2354); a resume that finds no instruction is refused \`incomplete\` rather than continuing blind. \`pnpm josh run:cut --impl <N> --handoff <path>\` ends this process and relaunches a fresh one that resumes back into implementation (\`resume-impl\`), dropping the accumulated context rather than carrying it \u2014 joshuafolkken/kit#1933 built the boundary and joshuafolkken/kit#2310 measured it firing 0 times because the verdict was only ever read at session entry, where the context has not yet grown. The verdict is \`pnpm josh cost --cut\`'s exactly \u2014 the same per-request billed-input statistic against the same threshold, never a second measurement. Issue \`pnpm josh run:cut --impl <N> --handoff <path>\` now and read the verdict: on \`cut\`, read what the command printed. Where it relaunched a fresh process, **end the turn immediately** \u2014 that process owns the run and continues implementing, so it must not be waited for, and **no Telegram is owed**: a cut that resumes itself leaves a person nothing to act on. Where it printed that nothing was relaunched, do what it prints, then end the turn; on \`not-a-lane\`, \`unready\`, \`busy\`, \`failed\` or \`unknown\`, this process carries the run on and the edit is simply the next call. Never relaunch a second process after \`busy\`. This fired because the dispatch mark names this lane or the run hold names this issue; a person working here carries no mark and holds no run, so sees no refusal, so there is no human-or-child judgement left to make. The procedure is \`.claude/skills/workflow-commands/pre-gate-cut.md\`. Reissue this edit once the cut has answered \u2014 an edit reissued right after this refusal passes, so \`busy\` / \`failed\` cannot wedge the run edit after edit; this fires again on the next threshold crossing rather than once per run.`;
+var IMPLEMENTATION_CUT_REASON = `\u26D4 implementation-phase cut: refused on every edit past the ${THRESHOLD_TEXT} line. Write \`${run_cut_handoff.HANDOFF_PATH}\` as ${run_cut_handoff.HANDOFF_FORMAT}, run \`pnpm josh run:cut --impl <N> --handoff <path>\`; \`cut\`: end the turn immediately, no Telegram is owed; else reissue the edit (\`.claude/skills/workflow-commands/pre-gate-cut.md\`).`;
 var REISSUE_WINDOW_MS = 9e4;
 function is_reissued_refusal(now_ms, delivered_at_ms) {
   return now_ms - delivered_at_ms < REISSUE_WINDOW_MS;
 }
-function decide2(_call, run2, _can_record, delivered_at_ms) {
-  return !is_reissued_refusal(run2.now_ms, delivered_at_ms);
+function decide2(_call, run, _can_record, delivered_at_ms) {
+  return !is_reissued_refusal(run.now_ms, delivered_at_ms);
 }
-var ROW4 = {
+var ROW5 = {
   id: "implementation-cut",
   is_trigger: is_over_threshold_edit,
   reason: IMPLEMENTATION_CUT_REASON,
   decide: decide2,
-  keeps: bash_triggers.on_bash_command(takes_the_impl_cut)
+  keeps: bash_triggers.on_bash_command(takes_the_impl_cut),
+  // The opening the reason carried before it was cut to the action and the next command.
+  former_reasons: [
+    "\u26D4 implementation-phase cut: this checkout is a lane dispatched",
+    "\u26D4 implementation-phase cut: this run's context crossed the"
+  ]
 };
 var implementation_cut = {
   IMPLEMENTATION_CUT_REASON,
   REISSUE_WINDOW_MS,
-  ROW: ROW4,
+  ROW: ROW5,
   decide: decide2,
   is_over_threshold_edit,
   is_reissued_refusal,
@@ -1665,10 +1410,10 @@ var gh_api = {
 // 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 ISSUE_READ_ARGUMENTS = /\b(?:issue:read|run:entry|run:prep)\b([\s\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;
+var ISSUE_READ_COMMAND = /\b(?:issue:read|run:entry|run:prep)\b/u;
 function add_issue_read_numbers(command, numbers) {
   const match = ISSUE_READ_ARGUMENTS.exec(command);
   if (match === null) return;
@@ -1739,19 +1484,48 @@ function is_body_only_issue_read(command) {
 function reads_issue_comments(command) {
   return shell_segments.segments_of(command).some((segment) => fetches_issue_comments(segment));
 }
-var ISSUE_COMMENTS_REASON = "\u26D4 issue comments: pnpm josh issue:read <N>\nRun that in place of this read: <N> is the Issue it names, and an Issue's comments are part of the Issue, so the body and every comment come back together. Without josh, add `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.\nWhy: 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. 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 = {
+var RULE_DOC = "`.claude/skills/workflow-commands/issue-comments.md`";
+var COMMENTS_FALLBACK = "gh api repos/{owner}/{repo}/issues/<N>/comments";
+var ISSUE_COMMENTS_REASON = `\u26D4 issue comments: pnpm josh issue:read <N>
+Run that in place of this read \u2014 an Issue's comments are part of it, and a later comment supersedes the body it contradicts; refused until that command is on the transcript. Without josh, read \`${COMMENTS_FALLBACK}\` beside the body (${RULE_DOC}).`;
+var COMMENTS_JQ = String.raw`'.[] | "— \(.user.login) \(.created_at)\n\(.body)\n"'`;
+var COMMENTS_NOTE = `\u21BB issue comments: this read returned only the Issue's body, so the Issue's comments were fetched on the same line \u2014 a later comment supersedes the body it contradicts (${RULE_DOC}).`;
+function rewritable_path(command) {
+  const read2 = shell_segments.first_of(command);
+  if (read2 === void 0 || ISSUE_VIEW_COMMAND.test(read2)) return void 0;
+  return is_body_read_segment(read2) ? ISSUE_BODY_PATH.exec(read2)?.[0] : void 0;
+}
+function comments_command(command) {
+  if (!is_body_only_issue_read(command)) return void 0;
+  const path13 = rewritable_path(command);
+  if (path13 === void 0) return void 0;
+  return `gh api --paginate ${path13}/comments --jq ${COMMENTS_JQ}
+${command}`;
+}
+function comments_input(call, tail) {
+  if (call.name !== cost_blocks.BASH_TOOL || !json_value.is_record(call.input)) return void 0;
+  const command = comments_command(time_shell.bash_command(call.input));
+  if (command === void 0 || prior_comment_read.already_read_for_call(tail(), call)) {
+    return void 0;
+  }
+  return { ...call.input, command };
+}
+var ROW6 = {
   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),
+  rewrite: comments_input,
+  rewrite_note: COMMENTS_NOTE,
   // The opening the reason carried before it led with the command.
   former_reasons: ["\u26D4 an Issue's comments are part of the Issue: read them before implementing"]
 };
 var issue_comments = {
+  COMMENTS_NOTE,
   ISSUE_COMMENTS_REASON,
-  ROW: ROW5,
+  ROW: ROW6,
+  comments_input,
   is_body_only_issue_read
 };
 
@@ -1768,8 +1542,8 @@ function is_bare_segment(segment) {
 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 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. Run `pnpm josh git -y "<title> #<N>"`, or `pnpm josh git -y --skip-commit --skip-push` to open the PR for a push that already landed. It fires on every occurrence.';
+var ROW7 = {
   id: "josh-git-bare",
   is_trigger: bash_triggers.on_bash_command(is_bare_josh_git),
   reason: JOSH_GIT_BARE_REASON,
@@ -1777,7 +1551,7 @@ var ROW6 = {
 };
 var josh_git_bare = {
   JOSH_GIT_BARE_REASON,
-  ROW: ROW6,
+  ROW: ROW7,
   is_bare_josh_git
 };
 
@@ -1801,8 +1575,8 @@ function is_carry_conflict(command, is_lane_child = lane_child_marker.is_child_o
   if (!invokes_budget_command(command)) return false;
   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". Live evidence of `run:carry` is taken with a fresh `JOSH_TEMP_ROOT` prefixed to the call, which this rule lets through (joshuafolkken/kit#3458); `run:merge` is refused under any root, because it also syncs main, closes lanes and writes to GitHub. This rule fires on every occurrence, not once per run.';
-var ROW7 = {
+var LANE_CARRY_CONFLICT_REASON = "\u26D4 lane child carry conflict: this session is a dispatched lane child, and `run:merge` / `run:carry` are the parent budget commands; the live record belongs to the parent, not to a competing run. Continue implementing this Issue: no `needs-decision`, no Telegram. Live `run:carry` evidence takes a fresh `JOSH_TEMP_ROOT`; `run:merge` is refused under any root, on every occurrence.";
+var ROW8 = {
   id: "lane-carry-conflict",
   is_trigger: bash_triggers.on_bash_command(is_carry_conflict),
   reason: LANE_CARRY_CONFLICT_REASON,
@@ -1810,66 +1584,24 @@ var ROW7 = {
 };
 var lane_carry_conflict = {
   LANE_CARRY_CONFLICT_REASON,
-  ROW: ROW7,
+  ROW: ROW8,
   invokes_budget_command,
   is_carry_conflict
 };
 
-// scripts/agent/interactive-ask.ts
-import { z as z6 } from "zod";
-var INTERACTIVE_TOOLS = /* @__PURE__ */ new Set(["AskUserQuestion"]);
-function is_interactive_tool(name) {
-  return INTERACTIVE_TOOLS.has(name);
-}
-var OPTION_SCHEMA = z6.looseObject({ label: z6.string().optional() });
-var QUESTION_SCHEMA = z6.looseObject({
-  question: z6.string().optional(),
-  options: z6.array(OPTION_SCHEMA).optional()
-});
-var ASK_INPUT_SCHEMA = z6.looseObject({ questions: z6.array(QUESTION_SCHEMA).optional() });
-var DENIAL_SCHEMA = z6.looseObject({
-  tool_name: z6.string().optional(),
-  tool_input: z6.unknown().optional()
-});
-var UNKNOWN_QUESTION = "(question text unavailable)";
-var OPTION_SEPARATOR = " / ";
-var QUESTION_SEPARATOR = "; ";
-function labels_of(question) {
-  return (question.options ?? []).map((option) => option.label ?? "").filter((label) => label !== "");
-}
-function render_question(question) {
-  const labels = labels_of(question);
-  const text = question.question ?? UNKNOWN_QUESTION;
-  return labels.length === 0 ? text : `${text} [${labels.join(OPTION_SEPARATOR)}]`;
-}
-function interactive_input(raw) {
-  const denial = DENIAL_SCHEMA.safeParse(raw);
-  if (!denial.success || !is_interactive_tool(denial.data.tool_name ?? "")) return void 0;
-  const input = ASK_INPUT_SCHEMA.safeParse(denial.data.tool_input);
-  return input.success ? input.data : void 0;
-}
-function refused_ask_of(permission_denials) {
-  if (!Array.isArray(permission_denials)) return void 0;
-  const input = permission_denials.map((raw) => interactive_input(raw)).find((one) => one !== void 0);
-  const questions = input?.questions ?? [];
-  if (questions.length === 0) return void 0;
-  return questions.map((question) => render_question(question)).join(QUESTION_SEPARATOR);
-}
-var interactive_ask = { is_interactive_tool, refused_ask_of };
-
 // scripts/rules/lane-interactive-ask.ts
 function is_interactive_ask(call, is_lane_child = lane_child_marker.is_child_of(process.cwd())) {
   if (!interactive_ask.is_interactive_tool(call.name)) return false;
   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 LANE_INTERACTIVE_ASK_REASON = "\u26D4 lane child interactive ask: this session is a dispatched lane child and cannot ask a person, so park instead: `gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=needs-decision'`, `pnpm josh issue:comment <N> --body-file <path>`, the `confirmation` Telegram, stop. It fires on every occurrence (`.claude/skills/workflow-commands/pre-gate-cut.md`, `backlogrun-park.md`).";
+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"]);
@@ -1913,13 +1645,13 @@ function is_candidate(command) {
   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) {
+function decide3(_call, run) {
   const issue = lane_child_marker.marked_issue();
-  const commands = tail_commands.prior_bash_commands(time_density_hook.read_tail(run2.transcript));
+  const commands = tail_commands.prior_bash_commands(time_density_hook.read_tail(run.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 ROW9 = {
+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: no `needs-decision` on the epic, no `confirmation` Telegram, on every occurrence. Park a child issue if the rest needs a person, else end the turn (`.claude/skills/workflow-commands/backlogrun-park.md` \u2192 "Splitting a child mid-run").';
+var ROW10 = {
   id: "lane-split-park",
   is_trigger: bash_triggers.on_bash_command(is_candidate),
   reason: LANE_SPLIT_PARK_REASON,
@@ -1927,7 +1659,7 @@ var ROW9 = {
 };
 var lane_split_park = {
   LANE_SPLIT_PARK_REASON,
-  ROW: ROW9,
+  ROW: ROW10,
   promoted_issues
 };
 
@@ -1944,8 +1676,9 @@ var NON_COLLIDING_FLAGS = /* @__PURE__ */ new Set([
 var FLAG_PREFIX2 = "-";
 function switch_target(segment) {
   const call = git_argv.parse(segment);
-  if (call?.subcommand !== SWITCH_SUBCOMMAND) return void 0;
-  if (call.args.some((argument) => NON_COLLIDING_FLAGS.has(argument))) return void 0;
+  if (call?.subcommand !== SWITCH_SUBCOMMAND || call.args.some((argument) => NON_COLLIDING_FLAGS.has(argument))) {
+    return void 0;
+  }
   return call.args.find((argument) => !argument.startsWith(FLAG_PREFIX2));
 }
 function switch_targets(command) {
@@ -1959,8 +1692,8 @@ function is_switch_away_from_lane(command, is_lane_child = lane_child_marker.is_
   if (!is_lane_child || own_branch === void 0) return false;
   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 `pnpm josh ms` 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 ROW10 = {
+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 (`already used by worktree`: the primary checkout holds it). Skip this step and keep implementing on the current branch; `pnpm josh main:merge` brings the default in during the gate. Refused on every occurrence (`backlogrun-lanes.md`, `backlogrun-child.md`).";
+var ROW11 = {
   id: "lane-switch-main",
   is_trigger: bash_triggers.on_bash_command(is_switch_away_from_lane),
   reason: LANE_SWITCH_MAIN_REASON,
@@ -1968,7 +1701,7 @@ var ROW10 = {
 };
 var lane_switch_main = {
   LANE_SWITCH_MAIN_REASON,
-  ROW: ROW10,
+  ROW: ROW11,
   is_switch_away_from_lane,
   switch_target,
   switch_targets
@@ -2471,7 +2204,7 @@ function command_line(oracle) {
   return oracle.args ? `pnpm josh ${command} ${oracle.args}` : `pnpm josh ${command}`;
 }
 function reason_for(oracle, firing_point) {
-  return `\u26D4 decision oracle not consulted: this is ${firing_point.describes}, but the run has not run \`${command_line(oracle)}\` first \u2014 the oracle that decides ${oracle.decision.toLowerCase()}. It answers ${oracle.vocabulary.join(" | ")}; single source ${oracle.single_source}. Reissue after running it and reading its verdict. Every such call is refused until that command is on the transcript.`;
+  return `\u26D4 decision oracle not consulted: this is ${firing_point.describes}. Run \`${command_line(oracle)}\` first \u2014 it decides ${oracle.decision.toLowerCase()} and answers ${oracle.vocabulary.join(" | ")} (${oracle.single_source}). Every such call is refused until that command is on the transcript.`;
 }
 function row_for(oracle, firing_point) {
   const names = command_names(oracle);
@@ -2537,14 +2270,16 @@ function is_destructive_segment2(segment) {
 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 ROW11 = {
+var DESTRUCTIVE_COMMAND_REASON = "\u26D4 destructive command: a recursive forced `rm`, a `gh repo delete` / `archive` / visibility edit, `gh pr close` or a `gh api -X DELETE` cannot be undone, which is Tier C. Remove one path at a time without `-f`, or ask the user to run it. It fires on every occurrence (`prompts/collaboration-workflow/operating-rules.md`).";
+var ROW12 = {
   id: "destructive-command",
   is_trigger: bash_triggers.on_bash_command(is_destructive_command),
   reason: DESTRUCTIVE_COMMAND_REASON,
-  decide: () => true
+  decide: () => true,
+  // The opening the reason carried before it was cut to the action and the next command.
+  former_reasons: ["\u26D4 destructive command: a recursive forced `rm` (`rm -rf`"]
 };
-var destructive_command = { DESTRUCTIVE_COMMAND_REASON, ROW: ROW11, is_destructive_command };
+var destructive_command = { DESTRUCTIVE_COMMAND_REASON, ROW: ROW12, is_destructive_command };
 
 // scripts/rules/direct-pr-create.ts
 var GH_COMMAND2 = "gh";
@@ -2599,13 +2334,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 ROW12 = {
+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: ROW12, 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";
@@ -2666,15 +2401,15 @@ function is_unauthorized_segment(segment) {
 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. A plan that restores a handed-over stash with `git stash apply` / `git stash pop` is read as `pnpm josh stash:pop "<message>"`: apply it that way, continue, and record the substitution on the Issue \u2014 Tier A, never a `needs-decision` park unless the plan says why the owner keeps the stash: then stop and confirm (`operating-rules.md` \u2192 "no-self-staging"). **This rule fires on every occurrence, not once per run.**';
-var ROW13 = {
+var WORKTREE_MUTATION_REASON = '\u26D4 unauthorized working-tree change: `git checkout --`, `git restore`, `git clean -f`, `git stash`. A documented flow stashes with `git stash push -u -m "<message>"`; a handed-over stash is `pnpm josh stash:pop "<message>"`; record the substitution on the Issue (Tier A) unless the plan says why the owner keeps the stash: then stop and confirm. It fires on every occurrence (`operating-rules.md`).';
+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: ROW13,
+  ROW: ROW14,
   WORKTREE_MUTATION_REASON,
   is_unauthorized_worktree_change,
   touches_worktree
@@ -2702,46 +2437,46 @@ 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 "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 ROW14 = {
+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. Commit with `pnpm josh git -y`; any other staging is the user's, on explicit instruction. It fires on every occurrence (`prompts/collaboration-workflow/operating-rules.md` \u2192 \"no-self-staging\").";
+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: ROW14, is_index_mutation };
+var index_guard = { INDEX_MUTATION_REASON, ROW: ROW15, is_index_mutation };
 
 // scripts/rules/protected-files.ts
-import path5 from "node:path";
+import path3 from "node:path";
 
 // scripts/doctor/doctor-consumer.ts
 import { existsSync as existsSync2 } from "node:fs";
-import path4 from "node:path";
+import path2 from "node:path";
 
 // scripts/version/kit-descriptor.ts
 var KIT_PACKAGE_NAME = "@joshuafolkken/kit";
 
 // scripts/doctor/doctor-consumer.ts
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 var NODE_MODULES = "node_modules";
-var SETTINGS_PATH = path4.join(".claude", "settings.json");
+var SETTINGS_PATH = path2.join(".claude", "settings.json");
 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 manifest_schema = z7.object({
-  name: z7.string().optional(),
-  dependencies: z7.record(z7.string(), z7.string()).optional(),
-  devDependencies: z7.record(z7.string(), z7.string()).optional()
+var SECRETLINT_BIN = path2.join(NODE_MODULES, ".bin", "secretlint");
+var manifest_schema = z6.object({
+  name: z6.string().optional(),
+  dependencies: z6.record(z6.string(), z6.string()).optional(),
+  devDependencies: z6.record(z6.string(), z6.string()).optional()
 });
-var settings_schema = z7.object({
-  enabledPlugins: z7.record(z7.string(), z7.boolean()).optional()
+var settings_schema = z6.object({
+  enabledPlugins: z6.record(z6.string(), z6.boolean()).optional()
 });
 var STATE_OK = "ok";
 var STATE_TARGET_MISSING = "target-missing";
 var STATE_MISSING = "missing";
 function parse_manifest(root) {
-  const content = file_reader.read_if_readable(path4.join(root, "package.json"));
+  const content = file_reader.read_if_readable(path2.join(root, "package.json"));
   if (content === void 0) return void 0;
   const parsed = manifest_schema.safeParse(json_value.parse_or_undefined(content));
   return parsed.success ? parsed.data : void 0;
@@ -2753,10 +2488,10 @@ function lists_kit_dependency(manifest) {
 function is_kit_consumer(root) {
   const manifest = parse_manifest(root);
   if (manifest?.name === KIT_PACKAGE_NAME) return false;
-  return lists_kit_dependency(manifest) || existsSync2(path4.join(root, NODE_MODULES, KIT_PACKAGE_NAME));
+  return lists_kit_dependency(manifest) || existsSync2(path2.join(root, NODE_MODULES, KIT_PACKAGE_NAME));
 }
 function is_plugin_declared(root) {
-  const content = file_reader.read_if_readable(path4.join(root, SETTINGS_PATH));
+  const content = file_reader.read_if_readable(path2.join(root, SETTINGS_PATH));
   if (content === void 0) return false;
   const parsed = settings_schema.safeParse(json_value.parse_or_undefined(content));
   return parsed.success && parsed.data.enabledPlugins?.[PLUGIN_ID] === true;
@@ -2768,13 +2503,13 @@ function configured_hooks_path(root) {
   return value === "" ? void 0 : value;
 }
 function claude_md_state(root) {
-  const content = file_reader.read_if_readable(path4.join(root, CLAUDE_MD));
+  const content = file_reader.read_if_readable(path2.join(root, CLAUDE_MD));
   if (content === void 0) return STATE_MISSING;
   if (!content.includes(CLAUDE_MD_POINTER)) return STATE_OK;
-  return existsSync2(path4.join(root, NODE_MODULES, KIT_PACKAGE_NAME, "dist", CLAUDE_MD)) ? STATE_OK : STATE_TARGET_MISSING;
+  return existsSync2(path2.join(root, NODE_MODULES, KIT_PACKAGE_NAME, "dist", CLAUDE_MD)) ? STATE_OK : STATE_TARGET_MISSING;
 }
 function is_secretlint_runnable(root) {
-  return existsSync2(path4.join(root, SECRETLINT_BIN));
+  return existsSync2(path2.join(root, SECRETLINT_BIN));
 }
 function status_line(is_ok, ok_text, warn_text) {
   return is_ok ? `  \u2713 ${ok_text}` : `  \u26A0 ${warn_text}`;
@@ -2840,7 +2575,7 @@ var EDIT_TOOLS2 = /* @__PURE__ */ new Set(["Edit", "Write"]);
 var SECRET_FILES = /* @__PURE__ */ new Set([".env", ".dev.vars"]);
 var ENVIRONMENT_VARIANT_PREFIX = ".env.";
 var TRACKED_VARIANTS = /* @__PURE__ */ new Set([".env.example", ".env.test"]);
-var SETTINGS_FILE = path5.join(".claude", "settings.json");
+var SETTINGS_FILE = path3.join(".claude", "settings.json");
 var WHITESPACE3 = /\s+/u;
 var TOKEN_QUOTES = /["']/gu;
 var INPUT_REDIRECT = "<";
@@ -2870,7 +2605,7 @@ function file_path_of(call) {
   return typeof value === "string" ? value : "";
 }
 function is_environment_path(token) {
-  const name = path5.basename(token.replaceAll(TOKEN_QUOTES, ""));
+  const name = path3.basename(token.replaceAll(TOKEN_QUOTES, ""));
   if (TRACKED_VARIANTS.has(name)) return false;
   return SECRET_FILES.has(name) || name.startsWith(ENVIRONMENT_VARIANT_PREFIX);
 }
@@ -2891,21 +2626,23 @@ function is_environment_read(call) {
 }
 function is_consumer_settings_edit(call, is_kit_consumer2) {
   if (!EDIT_TOOLS2.has(call.name)) return false;
-  const file_path = path5.resolve(file_path_of(call));
-  if (!file_path.endsWith(`${path5.sep}${SETTINGS_FILE}`)) return false;
-  return is_kit_consumer2(path5.dirname(path5.dirname(file_path)));
+  const file_path = path3.resolve(file_path_of(call));
+  if (!file_path.endsWith(`${path3.sep}${SETTINGS_FILE}`)) return false;
+  return is_kit_consumer2(path3.dirname(path3.dirname(file_path)));
 }
 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, and a `.env.*` variant or `.dev.vars` holds the same kind of secret, so reading one \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 (the tracked `.env.example` and `.env.test` stay readable). `.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 these files alone, or ask the user. **This rule fires on every occurrence, not once per run.**';
-var ROW15 = {
+var PROTECTED_FILE_REASON = "\u26D4 protected file: `.env`, a `.env.*` variant and `.dev.vars` hold secrets, and a consumer `.claude/settings.json` is owned by `josh sync` (a change belongs upstream in kit). Leave these files alone, or ask the user. It fires on every occurrence.";
+var ROW16 = {
   id: "protected-file",
   is_trigger: is_protected_file_call,
   reason: PROTECTED_FILE_REASON,
-  decide: () => true
+  decide: () => true,
+  // The opening the reason carried before it was cut to the action and the next command.
+  former_reasons: ["\u26D4 protected file: `.env` holds the Telegram bot token"]
 };
-var protected_files = { ROW: ROW15, is_protected_file_call };
+var protected_files = { ROW: ROW16, is_protected_file_call };
 
 // scripts/rules/permission-guards.ts
 var ROWS2 = [
@@ -2940,7 +2677,7 @@ function is_verification_command(segment) {
 function is_masked_verification(command) {
   return time_shell.discarded_commands(command).some((segment) => is_verification_command(segment));
 }
-var PIPED_VERIFICATION_REASON = "\u26D4 piped verification: a pipeline exits with its last command's status, so `pnpm josh gate | tail` reports success on a gate that failed, and the verdict is discarded before anything reads it. Run the check without the pipe \u2014 josh prints its verdict line last, so the harness output cap keeps it even when the middle is elided. Where the output genuinely has to be narrowed, redirect it to a file and read ranges from that file, or prefix `set -o pipefail` so the pipeline carries the check's status. Read the printed verdict either way, never the exit code alone. Read-only listings are untouched \u2014 this fires only on a command whose result means pass or fail. The rule is in `prompts/collaboration-workflow/output-bounds.md`. Reissue this call with no pipe \u2014 it fires once per run and cannot repeat on the call in hand.";
+var PIPED_VERIFICATION_REASON = "\u26D4 piped verification: a pipeline exits with its last command's status, so `pnpm josh gate | tail` reports success on a gate that failed. Reissue this call with no pipe (josh prints its verdict last), or redirect it to a file and read ranges from that file, or prefix `set -o pipefail`; read the verdict line, never the exit code alone (`prompts/collaboration-workflow/output-bounds.md`).";
 function pipelines_of(command) {
   return shell_segments.segments_of(time_shell.unquoted(command)).map((segment) => segment.split("|").map((piece) => piece.trim()));
 }
@@ -2953,12 +2690,15 @@ function runs_verification(command) {
 function keeps_verdict_intact(command) {
   return runs_verification(command) && !is_masked_verification(command);
 }
-var PIPEFAIL_PREFIX = "set -o pipefail; ";
-var FULL_READING_FILTER = /^(?:tail|grep)\b/u;
+var PIPEFAIL_OPEN = "(set -o pipefail; ";
+var PIPEFAIL_CLOSE = ")";
+var COMMENT_START = /(?:^|\s)#/u;
+var FULL_READING_FILTER = /^(?:tail|grep|cut|sort|uniq|wc)\b/u;
 var EARLY_EXIT_GREP = /^grep\b.*\s(?:-[a-zA-Z]*[lLmq]|--(?:quiet|silent|max-count|files-with(?:out)?-match))/u;
 var ALLOWED_OPERATORS = /2>&1|&&/gu;
 var SIDE_EFFECT_SYNTAX = /[&<>`]|\$\(/u;
-var PIPEFAIL_NOTE = "\u21BB piped verification: the josh check was piped, so `set -o pipefail;` was prefixed and the call ran with the check's status carried to the exit code. Read the printed verdict, never the exit code alone \u2014 `prompts/collaboration-workflow/output-bounds.md` (joshuafolkken/kit#3570).";
+var GROUP_SYNTAX = /[()]/u;
+var PIPEFAIL_NOTE = "\u21BB piped verification: the josh check was piped, so its pipeline was wrapped in `(set -o pipefail; \u2026)` to carry the check's status, and the rest of the line ran as typed. Read the printed verdict, never the exit code alone \u2014 `prompts/collaboration-workflow/output-bounds.md`.";
 function reads_to_the_end(piece) {
   return FULL_READING_FILTER.test(piece) && !EARLY_EXIT_GREP.test(piece);
 }
@@ -2969,14 +2709,40 @@ function is_filtered_check(pipeline) {
 function has_side_effect_syntax(command) {
   return SIDE_EFFECT_SYNTAX.test(command.replaceAll(ALLOWED_OPERATORS, " "));
 }
-function is_pipefail_rewritable(command) {
-  return is_masked_verification(command) && !has_side_effect_syntax(command) && pipelines_of(command).every((pipeline) => is_filtered_check(pipeline));
+function is_rewritable_part(raw, judged) {
+  const pipeline = judged.split("|").map((piece) => piece.trim());
+  return !has_side_effect_syntax(raw) && !GROUP_SYNTAX.test(judged) && is_filtered_check(pipeline);
+}
+function code_end(judged) {
+  const comment = COMMENT_START.exec(judged);
+  return comment === null ? judged.length : comment.index;
+}
+function wrapped(raw, judged) {
+  const code = raw.slice(0, code_end(judged));
+  const core = code.trim();
+  const lead = code.slice(0, code.indexOf(core));
+  return `${lead}${PIPEFAIL_OPEN}${core}${PIPEFAIL_CLOSE}${raw.slice(lead.length + core.length)}`;
+}
+function rewritten_part(raw, judged) {
+  if (!is_masked_verification(judged)) return raw;
+  return is_rewritable_part(raw, judged) ? wrapped(raw, judged) : void 0;
+}
+function pipefail_command(command) {
+  const judged = time_shell.blanked(command);
+  if (judged === void 0 || !is_masked_verification(command)) return void 0;
+  const offset = { at: 0 };
+  const parts = shell_segments.parts_of(judged).map((part) => {
+    const raw = command.slice(offset.at, offset.at + part.length);
+    offset.at += part.length;
+    return rewritten_part(raw, part);
+  });
+  const rewritten = parts.includes(void 0) ? void 0 : parts.join("");
+  return rewritten === command ? void 0 : rewritten;
 }
 function pipefail_input(call) {
   if (call.name !== cost_blocks.BASH_TOOL || !json_value.is_record(call.input)) return void 0;
-  const command = time_shell.bash_command(call.input);
-  if (!is_pipefail_rewritable(command)) return void 0;
-  return { ...call.input, command: `${PIPEFAIL_PREFIX}${command}` };
+  const command = pipefail_command(time_shell.bash_command(call.input));
+  return command === void 0 ? void 0 : { ...call.input, command };
 }
 var piped_verification = {
   PIPED_VERIFICATION_REASON,
@@ -3013,8 +2779,8 @@ function is_poll_loop(command) {
   if (is_state_wait(plain)) return true;
   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 ROW16 = {
+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, and the loop does not know when the command finished. Issue the long command with `run_in_background` set and end the turn \u2014 its exit re-invokes you; for CI, `pnpm josh followup` (`.claude/skills/workflow-commands/background-commands.md`). It fires on every occurrence.";
+var ROW17 = {
   id: "poll-loop",
   is_trigger: bash_triggers.on_bash_command(is_poll_loop),
   reason: POLL_LOOP_REASON,
@@ -3022,87 +2788,23 @@ var ROW16 = {
 };
 var poll_loop = {
   POLL_LOOP_REASON,
-  ROW: ROW16,
+  ROW: ROW17,
   is_poll_loop
 };
 
-// scripts/rules/pre-gate-cut.ts
-var GATE_COMMANDS = /* @__PURE__ */ new Set(["gate"]);
-var CUT_COMMANDS2 = /* @__PURE__ */ new Set(["run:cut"]);
-var CUT_MODE_FLAG = /(?:^|\s)--(?:resume|end|json)(?:[=\s]|$)/u;
-var HOLD_COMMANDS = /* @__PURE__ */ new Set(["run:hold"]);
-var HOLD_MODE_FLAG = /(?:^|\s)--release(?:[=\s]|$)/u;
-function invokes_josh(command, names, mode_flag) {
-  return shell_segments.segments_of(command).some(
-    (segment) => shell_segments.is_josh_command(segment, names) && mode_flag?.test(segment) !== true
-  );
-}
-function runs_the_gate(command) {
-  return invokes_josh(command, GATE_COMMANDS);
-}
-function takes_the_cut(command) {
-  return invokes_josh(command, CUT_COMMANDS2, CUT_MODE_FLAG);
-}
-function claims_the_hold(command) {
-  return invokes_josh(command, HOLD_COMMANDS, HOLD_MODE_FLAG);
-}
-function asks_about_the_cut(command) {
-  return invokes_josh(command, CUT_COMMANDS2);
-}
-function current_state2() {
-  return {
-    directory: process.cwd(),
-    carried: run_cut.carried_cut_sync,
-    marked_issue: lane_child_marker.marked_issue(),
-    is_reviewer: agent_session_role.is_reviewer(),
-    context_verdict: cost_cli.session_verdict
-  };
-}
-function dispatched_issue(state) {
-  return state.is_reviewer ? void 0 : state.marked_issue;
-}
-function uncut_lane_issue(state) {
-  const issue = lane_paths.lane_issue_of(state.directory);
-  if (issue === void 0) return void 0;
-  if (dispatched_issue(state) !== issue) return void 0;
-  return state.carried()?.issue === issue ? void 0 : issue;
-}
-function warrants_the_cut2(verdict) {
-  return verdict !== cost_verdict.UNDER_VERDICT;
-}
-function is_uncut_gate(command, state = current_state2()) {
-  if (!runs_the_gate(command) || uncut_lane_issue(state) === void 0) return false;
-  return warrants_the_cut2(state.context_verdict());
-}
-var PRE_GATE_CUT_REASON = "\u26D4 pre-gate cut: this checkout is a lane dispatched for this issue and the gate is the boundary to cut at, so take the cut before running it. `pnpm josh run:cut <N>` ends this process and relaunches a fresh one that resumes from the gate, dropping the thinking built up while implementing rather than carrying it on every later request \u2014 joshuafolkken/kit#1839 measured 176K of 204K output riding across that boundary, and joshuafolkken/kit#1864 measured the step itself firing 0 times in 6 lane children while it was carried as prose. Issue `pnpm josh run:cut <N>` now, and read the verdict: on `cut`, **end the turn immediately** \u2014 the fresh process owns the run from there and must not be waited for, and **no Telegram is owed** for a cut that resumes itself; on `not-a-lane`, `unready`, `busy`, `failed` or `unknown`, this process carries the run on and the gate is simply the next call. Never relaunch a second process after `busy`. This fired because the dispatch mark names this lane; a person working here carries no mark and sees no refusal, so there is no human-or-child judgement left to make. The procedure is `.claude/skills/workflow-commands/pre-gate-cut.md`. Reissue the gate once the cut has answered \u2014 this fires once per run, so it cannot repeat on the call in hand.";
-function reaches_the_pre_gate_boundary(call, _turn, run2) {
-  if (!bash_triggers.on_bash_command(asks_about_the_cut)(call)) return false;
-  return run2.some((issued) => bash_triggers.on_bash_command(claims_the_hold)(issued));
-}
-var pre_gate_cut = {
-  PRE_GATE_CUT_REASON,
-  asks_about_the_cut,
-  claims_the_hold,
-  is_uncut_gate,
-  reaches_the_pre_gate_boundary,
-  runs_the_gate,
-  takes_the_cut,
-  uncut_lane_issue
-};
-
 // 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 ROW17 = {
+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 posts the string `@<path>` rather than the file. Post the comment with `pnpm josh issue:comment <N> --body-file <path>`; this rule fires on every occurrence (`prompts/collaboration-workflow/shell-body.md`).";
+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: ROW17, 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";
@@ -3154,7 +2856,7 @@ function writes_rule_prose(call, read2 = read_existing) {
   const { old_text, new_text } = texts_of(call.name, input, read2);
   return adds_rule_prose(old_text, new_text);
 }
-var RULE_BODY_REASON = "\u26D4 rule written into prose: this edit adds rule text to CLAUDE.md, a `prompts/**` doc or a skill body. Before it lands, run the residency questions the addition skips. A rule whose answer is computable from mechanically readable inputs should be a decision oracle, not prose \u2014 question 0; `pnpm josh oracle:list` lists the existing oracles a new one joins (single source `scripts/rules/decision-oracle.ts`). A rule that decides *when* or *in what order* to act belongs in the run driver, not prose \u2014 the ordering question; `pnpm josh run:step` is the state machine a sequencing rule moves into. Only a rule that is neither \u2014 not computable, not ordering \u2014 stays prose, and then as a trigger-plus-pointer line rather than a second copy of its procedure. The criterion is `prompts/collaboration-workflow/residency.md` (question 0 and the ordering question); the delivery enumeration is `prompts/collaboration-workflow/rule-delivery.md`. Every such edit is refused until both commands are on the transcript \u2014 run them, confirm the rule can be neither an oracle nor an ordering step, then reissue this edit.";
+var RULE_BODY_REASON = "\u26D4 rule written into prose: this edit adds rule text to CLAUDE.md, a `prompts/**` doc or a skill body. Answer question 0 (`pnpm josh oracle:list`) and the ordering question (`pnpm josh run:step`) of `prompts/collaboration-workflow/residency.md`; refused until both commands are on the transcript, then reissue this as a trigger-plus-pointer line (`prompts/collaboration-workflow/rule-delivery.md`).";
 var PLACEMENT_ORACLES = [
   /* @__PURE__ */ new Set(["oracle:list"]),
   /* @__PURE__ */ new Set(["run:step", "run:next"])
@@ -3173,7 +2875,7 @@ function runs_placement_oracle(command) {
     (names) => shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, names))
   );
 }
-var ROW18 = {
+var ROW19 = {
   id: "rule-body",
   is_trigger: writes_rule_prose,
   reason: RULE_BODY_REASON,
@@ -3182,7 +2884,7 @@ var ROW18 = {
 };
 var rule_body_guard = {
   RULE_BODY_REASON,
-  ROW: ROW18,
+  ROW: ROW19,
   answered_placement,
   is_rule_document,
   writes_rule_prose
@@ -3250,7 +2952,7 @@ function carries_a_body(command) {
   if (BODY_FLAG.test(command.replaceAll(QUOTED_SPAN, " "))) return true;
   return inline_body_literals(command).length > 0;
 }
-var SHELL_BODY_REASON = "\u26D4 shell-evaluated body: this command carries a body inline in double quotes, and that body contains a backtick or a `$`, so the shell runs it \u2014 the text is executed rather than merely mangled (joshuafolkken/kit#1198). Write the body to a file and pass it by path: `pnpm josh issue:comment <N> --body-file <path>`, `pnpm josh followup --notify-message-file <path>`, or `--body-file <path>` wherever offered. `$'\u2026'` quoting is the other safe form; the rule and the trigger's blind spots are in `prompts/collaboration-workflow/shell-body.md`. Reissue this call once the body is in a file \u2014 it fires once per run and cannot repeat on the call in hand.";
+var SHELL_BODY_REASON = "\u26D4 shell-evaluated body: this command carries a body inline in double quotes, and that body contains a backtick or a `$`, so the shell executes it. Reissue this call once the body is in a file, passed by path (`pnpm josh issue:comment <N> --body-file <path>`, `--notify-message-file <path>`), or use `$'\u2026'` quoting (`prompts/collaboration-workflow/shell-body.md`).";
 var shell_body_trigger = {
   SHELL_BODY_REASON,
   carries_a_body,
@@ -3259,12 +2961,12 @@ var shell_body_trigger = {
 };
 
 // scripts/gate/project-checks.ts
-import { existsSync as existsSync7, globSync as globSync2, readFileSync as readFileSync6 } from "node:fs";
-import path13 from "node:path";
+import { existsSync as existsSync7, globSync, readFileSync as readFileSync5 } from "node:fs";
+import path11 from "node:path";
 
 // scripts/init/own-formatter.ts
 import { existsSync as existsSync3 } from "node:fs";
-import path6 from "node:path";
+import path4 from "node:path";
 var OWN_FORMATTER_CONFIGS = [
   "biome.json",
   "biome.jsonc",
@@ -3274,18 +2976,18 @@ var OWN_FORMATTER_CONFIGS = [
   ".dprint.jsonc"
 ];
 function find_config(root) {
-  return OWN_FORMATTER_CONFIGS.find((name) => existsSync3(path6.join(root, name)));
+  return OWN_FORMATTER_CONFIGS.find((name) => existsSync3(path4.join(root, name)));
 }
 var own_formatter = { find_config };
 
 // scripts/init/project-profile.ts
-import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync5 } from "node:fs";
-import path12 from "node:path";
+import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync4 } from "node:fs";
+import path10 from "node:path";
 
 // scripts/safe-chain/pack-hook.ts
-import { z as z8 } from "zod";
+import { z as z7 } from "zod";
 var PACK_HOOK_FILE = ".pnpmfile.mjs";
-var manifest_schema2 = z8.looseObject({ private: z8.boolean().optional() });
+var manifest_schema2 = z7.looseObject({ private: z7.boolean().optional() });
 var MESSAGES = {
   written: `  \u2714 synced    ${PACK_HOOK_FILE} (run \`pnpm install\` to refresh pnpmfileChecksum)`,
   unchanged: `  \u2714 unchanged ${PACK_HOOK_FILE}`,
@@ -3321,15 +3023,15 @@ var yaml_document = { is_mapping_document, parse_yaml, parse_yaml_documents };
 
 // scripts/version/release-age.ts
 import semver from "semver";
-import { z as z9 } from "zod";
-var workspace_age_schema = z9.object({ minimumReleaseAge: z9.number().int().nonnegative() });
-var release_times_schema = z9.record(z9.string(), z9.string());
+import { z as z8 } from "zod";
+var workspace_age_schema = z8.object({ minimumReleaseAge: z8.number().int().nonnegative() });
+var release_times_schema = z8.record(z8.string(), z8.string());
 
 // scripts/safe-chain/project-config.ts
 import { dump } from "js-yaml";
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 var PROJECT_CONFIG_FILE = ".aikido";
-var workspace_schema = z10.object({ minimumReleaseAgeExclude: z10.array(z10.string()).optional() });
+var workspace_schema = z9.object({ minimumReleaseAgeExclude: z9.array(z9.string()).optional() });
 
 // scripts/config-merge/json-format.ts
 var PRINT_WIDTH = 100;
@@ -3374,9 +3076,9 @@ function inline_short_arrays(text) {
   const output = [];
   let index = 0;
   while (index < lines.length) {
-    const rewrite = rewrite_at(lines, index, lines[index] ?? "");
-    output.push(...rewrite.lines);
-    index = rewrite.next;
+    const rewrite3 = rewrite_at(lines, index, lines[index] ?? "");
+    output.push(...rewrite3.lines);
+    index = rewrite3.next;
   }
   return output.join("\n");
 }
@@ -3411,86 +3113,6 @@ var safe_chain_preinstall = {
   migrate_preinstall
 };
 
-// scripts/init/distributed-paths.ts
-var KIT_PACKAGE_PATH_PREFIX = "node_modules/@joshuafolkken/kit/";
-var PROMPTS_PACKAGE_PREFIX = `${KIT_PACKAGE_PATH_PREFIX}prompts/`;
-var ESLINT_PACKAGE_PREFIX = `${KIT_PACKAGE_PATH_PREFIX}eslint/`;
-var GITHUB_REPO_BLOB_BASE = "https://github.com/joshuafolkken/kit/blob/main/";
-var GITHUB_REPO_TREE_BASE = "https://github.com/joshuafolkken/kit/tree/main/";
-var CLAUDE_MD_IMPORT_LINE = "@node_modules/@joshuafolkken/kit/dist/CLAUDE.md";
-var OLD_CLAUDE_MD_BOOTSTRAP = "> Fresh checkout: if kit is not installed, run `pnpm install` first, then reread this file before doing any other work.";
-var CLAUDE_MD_BOOTSTRAP = '> Fresh checkout: before `pnpm install`, run `pnpm config get "@joshuafolkken:registry"` from the project root to check the effective registry, including user-level settings. If it points to GitHub Packages, [set up authentication](https://github.com/joshuafolkken/kit/blob/main/docs/authentication.md#1-get-a-token-from-the-gh-cli) first. Then run `pnpm install` and reread this file before doing any other work.';
-function transform_prompt_paths(content) {
-  return content.replaceAll(
-    /`prompts\/([^`*]+)`/gu,
-    (_match, prompt_path) => `\`${PROMPTS_PACKAGE_PREFIX}${prompt_path}\``
-  );
-}
-function transform_eslint_paths(content) {
-  return content.replaceAll(
-    /`eslint\/([^`*]+)`/gu,
-    (_match, eslint_path) => `\`${ESLINT_PACKAGE_PREFIX}${eslint_path}\``
-  );
-}
-function transform_test_file_paths(content) {
-  return content.replaceAll(
-    /`([^`*]+\.(?:test|spec)\.ts)`/gu,
-    (_match, test_path) => `\`${GITHUB_REPO_BLOB_BASE}${test_path}\``
-  );
-}
-function github_url_base(reference_path) {
-  return reference_path.endsWith("/") ? GITHUB_REPO_TREE_BASE : GITHUB_REPO_BLOB_BASE;
-}
-function transform_documentation_paths(content) {
-  return content.replaceAll(
-    /`(docs\/[^`*]*)`/gu,
-    (_match, documentation_path) => `\`${github_url_base(documentation_path)}${documentation_path}\``
-  );
-}
-function transform_distributed_paths(content) {
-  const with_prompts = transform_prompt_paths(content);
-  const with_eslint = transform_eslint_paths(with_prompts);
-  const with_tests = transform_test_file_paths(with_eslint);
-  return transform_documentation_paths(with_tests);
-}
-function ensure_claude_md_import(existing) {
-  if (existing === void 0) return `${CLAUDE_MD_BOOTSTRAP}
-
-${CLAUDE_MD_IMPORT_LINE}
-`;
-  const updated = existing.replace(OLD_CLAUDE_MD_BOOTSTRAP, () => CLAUDE_MD_BOOTSTRAP);
-  if (updated.includes(CLAUDE_MD_IMPORT_LINE)) {
-    if (updated.includes(CLAUDE_MD_BOOTSTRAP)) return updated;
-    return `${CLAUDE_MD_BOOTSTRAP}
-
-${updated}`;
-  }
-  return `${CLAUDE_MD_BOOTSTRAP}
-
-${CLAUDE_MD_IMPORT_LINE}
-
-${updated}`;
-}
-var FULL_CLAUDE_MD_LINES = /* @__PURE__ */ new Set([
-  CLAUDE_MD_BOOTSTRAP,
-  OLD_CLAUDE_MD_BOOTSTRAP,
-  CLAUDE_MD_IMPORT_LINE
-]);
-function remove_claude_md_import(content) {
-  const lines = content.split("\n");
-  return lines.filter((line, index) => {
-    if (FULL_CLAUDE_MD_LINES.has(line)) return false;
-    return line !== "" || !FULL_CLAUDE_MD_LINES.has(lines[index - 1] ?? "");
-  }).join("\n");
-}
-var distributed_paths = {
-  transform_prompt_paths,
-  transform_distributed_paths,
-  ensure_claude_md_import,
-  remove_claude_md_import,
-  CLAUDE_MD_IMPORT_LINE
-};
-
 // scripts/init/init-logic-deploy-vps.ts
 import semver2 from "semver";
 var PNPM_INSTALL_PATTERN = /npm install -g pnpm@\d[\d.]{0,19}/gu;
@@ -3518,8 +3140,9 @@ function patch_deploy_vps_pnpm(content) {
     PNPM_INSTALL_PATTERN,
     (command) => replace_outdated_install(command)
   );
-  if (with_pnpm12.includes(VERSION_CHECK_MARKER)) return with_pnpm12;
-  if (!OLD_PNPM_CHECK_PATTERN.test(with_pnpm12)) return with_pnpm12;
+  if (with_pnpm12.includes(VERSION_CHECK_MARKER) || !OLD_PNPM_CHECK_PATTERN.test(with_pnpm12)) {
+    return with_pnpm12;
+  }
   return with_pnpm12.replace(OLD_MAJOR_LINE_PATTERN, "").replace(OLD_PNPM_CHECK_PATTERN, (_, indent) => build_version_check(indent));
 }
 var init_logic_deploy_vps = { patch_deploy_vps_pnpm };
@@ -3771,10 +3394,10 @@ function set_json_key(content, key, value) {
   const indented = fit_value(content, value_text, line_indent(content, existing.offset));
   return with_trailing_newline(replace_range(content, existing, indented));
 }
-function resolve_parent(content, path16) {
+function resolve_parent(content, path13) {
   const root = parse_root(content);
   if (root === void 0) return void 0;
-  const parent = path16.length > 1 ? findNodeAtLocation(root, path16.slice(0, -1)) : root;
+  const parent = path13.length > 1 ? findNodeAtLocation(root, path13.slice(0, -1)) : root;
   return parent?.type === "object" ? parent : void 0;
 }
 function cut_ranges(content, parent, ranges) {
@@ -3785,24 +3408,24 @@ function cut_ranges(content, parent, ranges) {
   }
   return next;
 }
-function rebalance_new_last(content, path16) {
-  const parent = resolve_parent(content, path16);
+function rebalance_new_last(content, path13) {
+  const parent = resolve_parent(content, path13);
   const last = parent?.children?.at(-1);
   if (parent === void 0 || last === void 0) return content;
   return rebalance(content, last, has_separator_after(content, parent.offset, parent.offset));
 }
-function cut_property(content, parent, path16) {
-  const index = property_index(parent, path16.at(-1) ?? "");
+function cut_property(content, parent, path13) {
+  const index = property_index(parent, path13.at(-1) ?? "");
   const ranges = removal_ranges(content, parent, index);
   if (ranges.length === 0) return content;
   const cut = cut_ranges(content, parent, ranges);
   const did_end_object = index === (parent.children ?? []).length - 1;
-  return did_end_object ? rebalance_new_last(cut, path16) : cut;
+  return did_end_object ? rebalance_new_last(cut, path13) : cut;
 }
-function remove_json_path(content, path16) {
-  const parent = resolve_parent(content, path16);
+function remove_json_path(content, path13) {
+  const parent = resolve_parent(content, path13);
   if (parent === void 0) return content;
-  const next = cut_property(content, parent, path16);
+  const next = cut_property(content, parent, path13);
   return next === content ? content : with_trailing_newline(next);
 }
 function remove_json_key(content, key) {
@@ -4033,13 +3656,13 @@ var kit_base_preset = {
 
 // scripts/init/tsconfig-preset-migration.ts
 import { existsSync as existsSync4 } from "node:fs";
-import path7 from "node:path";
+import path5 from "node:path";
 var LEGACY_PRESET_ENTRY = /@joshuafolkken\/[^/]+\/tsconfig\/[^/]+\.jsonc$/u;
 var LEGACY_SUFFIX = ".jsonc";
 var CURRENT_SUFFIX = ".json";
 var EXTENDS_FIELD = "extends";
 function is_migration_target_present(base_directory, entry) {
-  return existsSync4(path7.resolve(base_directory, entry));
+  return existsSync4(path5.resolve(base_directory, entry));
 }
 function migrate_entry(base_directory, entry) {
   if (!LEGACY_PRESET_ENTRY.test(entry)) return entry;
@@ -4271,15 +3894,15 @@ var init_logic_json_merge = {
 };
 
 // scripts/init/kit-development-versions.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-import { z as z11 } from "zod";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { z as z10 } from "zod";
 var PACKAGE_JSON = "package.json";
-var kit_manifest_schema = z11.object({
-  peerDependencies: z11.record(z11.string(), z11.string()).default({}),
-  devDependencies: z11.record(z11.string(), z11.string())
+var kit_manifest_schema = z10.object({
+  peerDependencies: z10.record(z10.string(), z10.string()).default({}),
+  devDependencies: z10.record(z10.string(), z10.string())
 });
 function read_kit_manifest() {
-  const content = readFileSync3(package_path(PACKAGE_JSON), "utf8");
+  const content = readFileSync2(package_path(PACKAGE_JSON), "utf8");
   return kit_manifest_schema.parse(JSON.parse(content));
 }
 function versions_of(names) {
@@ -4440,9 +4063,9 @@ function merge_sonar_properties(existing, template_content) {
     return key !== void 0 && !existing_keys.has(key);
   });
   if (lines_to_add.length === 0) return merged_existing;
-  const normalized2 = merged_existing.endsWith("\n") ? merged_existing : `${merged_existing}
+  const normalized = merged_existing.endsWith("\n") ? merged_existing : `${merged_existing}
 `;
-  return `${normalized2}
+  return `${normalized}
 ${lines_to_add.join("\n")}
 `;
 }
@@ -4455,8 +4078,8 @@ var init_logic_sonar = {
 };
 
 // scripts/init/init-logic-templates.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
-import path8 from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
+import path6 from "node:path";
 var ESLINT_VANILLA = `import { create_vanilla_config } from '@joshuafolkken/kit/eslint/vanilla'
 
 export default create_vanilla_config({
@@ -4541,7 +4164,7 @@ function merge_eslint_config(existing) {
   return apply_rules_template(rules_blocks.join(",\n"));
 }
 function detect_tailwind_stylesheet(project_root2) {
-  return existsSync5(path8.join(project_root2, DEFAULT_TAILWIND_STYLESHEET)) ? DEFAULT_TAILWIND_STYLESHEET : void 0;
+  return existsSync5(path6.join(project_root2, DEFAULT_TAILWIND_STYLESHEET)) ? DEFAULT_TAILWIND_STYLESHEET : void 0;
 }
 function generate_prettier_config(stylesheet) {
   const stylesheet_line = stylesheet === void 0 ? "" : `	tailwindStylesheet: '${stylesheet}',
@@ -4555,14 +4178,14 @@ ${stylesheet_line}}
 }
 function existing_stylesheet(existing, project_root2) {
   const named = TAILWIND_STYLESHEET_PATTERN.exec(existing)?.[1];
-  return named !== void 0 && existsSync5(path8.resolve(project_root2, named)) ? named : void 0;
+  return named !== void 0 && existsSync5(path6.resolve(project_root2, named)) ? named : void 0;
 }
 function merge_prettier_config(existing, project_root2) {
   const stylesheet = existing_stylesheet(existing, project_root2) ?? detect_tailwind_stylesheet(project_root2);
   return generate_prettier_config(stylesheet);
 }
 function generate_playwright_config() {
-  return readFileSync4(PLAYWRIGHT_TEMPLATE_PATH, "utf8");
+  return readFileSync3(PLAYWRIGHT_TEMPLATE_PATH, "utf8");
 }
 var init_logic_templates = {
   generate_eslint_config,
@@ -4634,9 +4257,9 @@ function extract_yaml_block(content, key) {
 }
 function append_user_blocks(base, user_keys, existing) {
   const user_blocks = user_keys.map((k) => extract_yaml_block(existing, k)).filter(Boolean).join("\n");
-  const normalized2 = base.endsWith("\n") ? base : `${base}
+  const normalized = base.endsWith("\n") ? base : `${base}
 `;
-  return `${normalized2}
+  return `${normalized}
 ${user_blocks}
 `;
 }
@@ -4729,9 +4352,9 @@ function carry_npmrc_settings(template, npmrc) {
 }
 function merge_workspace_yaml(existing, template) {
   if (!existing.trim()) return template;
-  const normalized2 = existing.endsWith("\n") ? existing : `${existing}
+  const normalized = existing.endsWith("\n") ? existing : `${existing}
 `;
-  const answered = answer_build_placeholders(remove_deprecated_yaml_keys(normalized2), template);
+  const answered = answer_build_placeholders(remove_deprecated_yaml_keys(normalized), template);
   const cleaned = add_missing_build_entries(answered, template);
   if (!cleaned.trim()) return template;
   const existing_keys = new Set(extract_yaml_top_level_keys(cleaned));
@@ -5070,23 +4693,23 @@ var AI_COPY_DIRECTORIES_LIST = "AI_COPY_DIRECTORIES";
 var SYNCED_PATHS_LIST = "SYNCED_PATHS";
 var PLUGIN_SKILL_DIRECTORIES_LIST = "PLUGIN_SKILL_DIRECTORIES";
 var PATH_SEPARATOR = "/";
-function is_inside(path16, directory) {
-  return path16 === directory || path16.startsWith(`${directory}${PATH_SEPARATOR}`);
+function is_inside(path13, directory) {
+  return path13 === directory || path13.startsWith(`${directory}${PATH_SEPARATOR}`);
 }
-function matches_file(path16) {
-  return init_logic.get_ai_copy_files().includes(path16);
+function matches_file(path13) {
+  return init_logic.get_ai_copy_files().includes(path13);
 }
-function matches_mapping(path16) {
-  return init_logic.get_ai_copy_file_mappings().some((mapping) => mapping.src === path16 || mapping.dest === path16);
+function matches_mapping(path13) {
+  return init_logic.get_ai_copy_file_mappings().some((mapping) => mapping.src === path13 || mapping.dest === path13);
 }
-function matches_directory(path16) {
-  return init_logic.get_ai_copy_directories().some((directory) => is_inside(path16, directory));
+function matches_directory(path13) {
+  return init_logic.get_ai_copy_directories().some((directory) => is_inside(path13, directory));
 }
-function matches_plugin_skill(path16) {
-  return PLUGIN_SKILL_DIRECTORIES.some((directory) => is_inside(path16, directory));
+function matches_plugin_skill(path13) {
+  return PLUGIN_SKILL_DIRECTORIES.some((directory) => is_inside(path13, directory));
 }
-function matches_synced_path(path16) {
-  return synced_paths.get_synced_paths().includes(path16);
+function matches_synced_path(path13) {
+  return synced_paths.get_synced_paths().includes(path13);
 }
 var MATCHERS = [
   { list: AI_COPY_FILES_LIST, matches: matches_file },
@@ -5095,18 +4718,18 @@ var MATCHERS = [
   { list: PLUGIN_SKILL_DIRECTORIES_LIST, matches: matches_plugin_skill },
   { list: SYNCED_PATHS_LIST, matches: matches_synced_path }
 ];
-function find_list(path16) {
-  return MATCHERS.find((matcher) => matcher.matches(path16))?.list;
+function find_list(path13) {
+  return MATCHERS.find((matcher) => matcher.matches(path13))?.list;
 }
-function to_hit(path16) {
-  const list = find_list(path16);
-  return list === void 0 ? void 0 : { path: path16, list };
+function to_hit(path13) {
+  const list = find_list(path13);
+  return list === void 0 ? void 0 : { path: path13, list };
 }
 function find_managed_paths(paths) {
-  return paths.flatMap((path16) => to_hit(path16) ?? []);
+  return paths.flatMap((path13) => to_hit(path13) ?? []);
 }
 function has_managed_path(paths) {
-  return paths.some((path16) => find_list(path16) !== void 0);
+  return paths.some((path13) => find_list(path13) !== void 0);
 }
 function format_hit(hit) {
   return `${hit.path} (${hit.list})`;
@@ -5122,8 +4745,8 @@ var managed_config_scope = {
 };
 
 // scripts/init/session-language-environment.ts
-import path9 from "node:path";
-var CLAUDE_SETTINGS_PATH = path9.join(".claude", "settings.json");
+import path7 from "node:path";
+var CLAUDE_SETTINGS_PATH = path7.join(".claude", "settings.json");
 var KEY_LINE_PATTERN = new RegExp(
   String.raw`^\s*(?:export\s+)?${session_language.ENV_KEY}\s*=`,
   "mu"
@@ -5133,8 +4756,8 @@ var KEY_LINE_PATTERN = new RegExp(
 import { findNodeAtLocation as findNodeAtLocation2, getNodeValue as getNodeValue2, parseTree as parseTree3 } from "jsonc-parser";
 
 // scripts/init/vscode-tasks.ts
-import { z as z12 } from "zod";
-var task_array_schema = z12.array(json_object_schema);
+import { z as z11 } from "zod";
+var task_array_schema = z11.array(json_object_schema);
 
 // scripts/init/init-actions.ts
 var BASIC_PRETTIER_CONFIG = "prettier.config.mjs";
@@ -5144,11 +4767,11 @@ var MARKER_TOKEN = "josh-managed-workflow:";
 var MARKER_PREFIX = `# ${MARKER_TOKEN}`;
 
 // scripts/init/claude-plugin-config.ts
-import path10 from "node:path";
+import path8 from "node:path";
 var MARKETPLACE_NAME = "kit";
 var PLUGIN_ID2 = "kit@kit";
 var MARKETPLACE_PATH = "./node_modules/@joshuafolkken/kit";
-var CLAUDE_SETTINGS_DESTINATION = path10.join(".claude", "settings.json");
+var CLAUDE_SETTINGS_DESTINATION = path8.join(".claude", "settings.json");
 var PLUGIN_SETTINGS = {
   extraKnownMarketplaces: {
     [MARKETPLACE_NAME]: { source: { source: "directory", path: MARKETPLACE_PATH } }
@@ -5172,9 +4795,9 @@ var claude_plugin_config = {
 // scripts/init/hook-launch.ts
 var HOOK_DIST_DIR = "dist/hooks";
 var RUN_HOOK_SCRIPT = "scripts/hooks/run-hook.sh";
-var UNSET_OPTIONS = GIT_LOCATION_VARIABLES.map((name) => `-u ${name}`).join(" ");
+var LOCATION_VARIABLES = GIT_LOCATION_VARIABLES.join(" ");
 var ROOT_LOOKUP = "git rev-parse --show-toplevel";
-var PROJECT_ROOT_PREFIX = `project_root="$(env ${UNSET_OPTIONS} ${ROOT_LOOKUP} 2>/dev/null || ${ROOT_LOOKUP})" && cd "$project_root" && `;
+var PROJECT_ROOT_PREFIX = `if project_root="$(unset ${LOCATION_VARIABLES}; ${ROOT_LOOKUP} 2>/dev/null)"; then unset ${LOCATION_VARIABLES}; else project_root="$(${ROOT_LOOKUP})"; fi && cd "$project_root" && `;
 function hook_launch_command(name) {
   return `${PROJECT_ROOT_PREFIX}sh ${RUN_HOOK_SCRIPT} ${name}`;
 }
@@ -5210,7 +4833,7 @@ var PLAIN_KIT_COMMANDS = new Set(
 var PROJECT_ROOT_PREFIX2 = JSON.stringify(hook_launch.PROJECT_ROOT_PREFIX).slice(1, -1);
 
 // scripts/init/security-policy.ts
-import path11 from "node:path";
+import path9 from "node:path";
 var SECURITY_MD = "SECURITY.md";
 var SECURITY_TEMPLATE = "templates/SECURITY.md";
 var REPOSITORY_PLACEHOLDER = "{{REPOSITORY}}";
@@ -5226,15 +4849,15 @@ function apply_repository(content, repository) {
   return content.replaceAll(REPOSITORY_PLACEHOLDER, () => repository);
 }
 function apply_repository_for_destination(destination_path, content) {
-  if (path11.basename(destination_path) !== SECURITY_MD) return content;
-  const repository = repository_at(path11.dirname(destination_path));
+  if (path9.basename(destination_path) !== SECURITY_MD) return content;
+  const repository = repository_at(path9.dirname(destination_path));
   if (repository === void 0) {
     throw new Error(`${SECURITY_MD} needs a GitHub origin to name the repository it reports to`);
   }
   return apply_repository(content, repository);
 }
 function does_report_to_kit(root) {
-  const existing = file_reader.read_if_readable(path11.join(root, SECURITY_MD)) ?? "";
+  const existing = file_reader.read_if_readable(path9.join(root, SECURITY_MD)) ?? "";
   return new Set(existing.split(LINK_DELIMITER)).has(KIT_ADVISORY_URL);
 }
 function unresolved_warning(root) {
@@ -5354,9 +4977,9 @@ function requested_profile(args, usage = "josh init [--profile basic|full]") {
   throw new Error("Profile must be basic or full");
 }
 function read_manifest(root) {
-  const filename = path12.join(root, "package.json");
+  const filename = path10.join(root, "package.json");
   if (!existsSync6(filename)) return void 0;
-  const parsed = JSON.parse(readFileSync5(filename, "utf8"));
+  const parsed = JSON.parse(readFileSync4(filename, "utf8"));
   if (!json_value.is_record(parsed)) throw new Error("package.json must contain an object");
   return parsed;
 }
@@ -5397,12 +5020,12 @@ function should_visit(entry) {
 function scan_directory(directory, pending) {
   const entries = readdirSync(directory, { withFileTypes: true });
   pending.push(
-    ...entries.filter((entry) => should_visit(entry)).map((entry) => path12.join(directory, entry.name))
+    ...entries.filter((entry) => should_visit(entry)).map((entry) => path10.join(directory, entry.name))
   );
-  return entries.filter((entry) => entry.isFile()).map((entry) => path12.join(directory, entry.name));
+  return entries.filter((entry) => entry.isFile()).map((entry) => path10.join(directory, entry.name));
 }
 function is_project_file(root, file) {
-  const relative_path = path12.relative(root, file).split(path12.sep).join(path12.posix.sep);
+  const relative_path = path10.relative(root, file).split(path10.sep).join(path10.posix.sep);
   return !kit_written_paths.is_kit_written(relative_path);
 }
 function list_files(root) {
@@ -5414,7 +5037,7 @@ function list_files(root) {
   return files;
 }
 function file_extensions(root) {
-  return list_files(root).filter((file) => is_project_file(root, file)).map((file) => path12.extname(file));
+  return list_files(root).filter((file) => is_project_file(root, file)).map((file) => path10.extname(file));
 }
 function scan_files(root) {
   const extensions = file_extensions(root);
@@ -5428,7 +5051,7 @@ function has_github_remote(root) {
   return url !== void 0 && repo_origin.parse_origin_url(url) !== void 0;
 }
 function has_git(root) {
-  return existsSync6(path12.join(root, ".git"));
+  return existsSync6(path10.join(root, ".git"));
 }
 function has_workflow(root) {
   return workflow_mark.is_requested() || workflow_mark.is_recorded(read_manifest(root));
@@ -5461,7 +5084,7 @@ var SKIP_MARKER = "\u2014 skipping";
 var NOT_USED_MARKER = "which this project does not use";
 
 // scripts/gate/project-checks.ts
-import { z as z13 } from "zod";
+import { z as z12 } from "zod";
 var PACKAGE_JSON2 = "package.json";
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -5496,11 +5119,11 @@ var CSPELL_CONFIGS = [
 ];
 var TYPE_CONFIGS = ["tsconfig.json", "jsconfig.json"];
 var DEPENDENCY_FIELDS = ["dependencies", "devDependencies"];
-var object_schema = z13.record(z13.string(), z13.unknown());
+var object_schema = z12.record(z12.string(), z12.unknown());
 function project_root(directory) {
   return ancestor_directories.nearest(
     directory,
-    (candidate) => existsSync7(path13.join(candidate, PACKAGE_JSON2))
+    (candidate) => existsSync7(path11.join(candidate, PACKAGE_JSON2))
   ) ?? directory;
 }
 function is_kit_repository(directory) {
@@ -5510,10 +5133,10 @@ 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;
+  return globSync(pattern, { cwd: project_root(directory), exclude: is_ignored }).length > 0;
 }
 function has_config(directory, names) {
-  return names.some((name) => existsSync7(path13.join(project_root(directory), name)));
+  return names.some((name) => existsSync7(path11.join(project_root(directory), name)));
 }
 function has_bin(directory, bin_name) {
   return find_local_bin_upwards(directory, bin_name) !== void 0;
@@ -5528,8 +5151,8 @@ function is_basic_manifest(manifest) {
 }
 function read_manifest2(directory) {
   try {
-    const manifest_path = path13.join(project_root(directory), PACKAGE_JSON2);
-    return json_value.parse_or_undefined(readFileSync6(manifest_path, "utf8"));
+    const manifest_path = path11.join(project_root(directory), PACKAGE_JSON2);
+    return json_value.parse_or_undefined(readFileSync5(manifest_path, "utf8"));
   } catch {
     return void 0;
   }
@@ -5549,11 +5172,11 @@ function missing_tool_reason(directory, package_name, bin_name) {
   if (has_bin(directory, bin_name) || is_declared2(directory, package_name)) return void 0;
   return `${package_name} is not installed`;
 }
-function skip_notice(check5, reason) {
-  return `josh ${check5}: ${reason} ${SKIP_MARKER} ${check5}, ${NOT_USED_MARKER}.`;
+function skip_notice(check3, reason) {
+  return `josh ${check3}: ${reason} ${SKIP_MARKER} ${check3}, ${NOT_USED_MARKER}.`;
 }
-function ran_notice(check5) {
-  return `josh ${check5}: ran and reported no problems.`;
+function ran_notice(check3) {
+  return `josh ${check3}: ran and reported no problems.`;
 }
 function type_check_skip_reason(directory) {
   if (!is_basic(directory)) return void 0;
@@ -5617,40 +5240,40 @@ var BASIC_REQUIRED_SUFFIXES = [
   ".toml"
 ];
 function normalize(paths) {
-  return paths.map((path16) => path16.trim()).filter((path16) => path16 !== "");
+  return paths.map((path13) => path13.trim()).filter((path13) => path13 !== "");
 }
-function is_test_file(path16) {
-  return TEST_SUFFIXES.some((suffix) => path16.endsWith(suffix));
+function is_test_file(path13) {
+  return TEST_SUFFIXES.some((suffix) => path13.endsWith(suffix));
 }
-function is_basic_manual(path16, is_basic2) {
-  const lower = path16.toLowerCase();
+function is_basic_manual(path13, is_basic2) {
+  const lower = path13.toLowerCase();
   return is_basic2 && BASIC_REQUIRED_SUFFIXES.every((suffix) => !lower.endsWith(suffix));
 }
-function is_basic_visual(path16) {
-  const lower = path16.toLowerCase();
+function is_basic_visual(path13) {
+  const lower = path13.toLowerCase();
   return BASIC_VISUAL_SUFFIXES.some((suffix) => lower.endsWith(suffix));
 }
-function is_exempt(path16, is_basic2 = false) {
-  if (EXEMPT_PATHS.includes(path16) || is_basic_manual(path16, is_basic2)) return true;
-  return EXEMPT_SUFFIXES.some((suffix) => path16.endsWith(suffix)) || EXEMPT_PREFIXES.some((prefix) => path16.startsWith(prefix));
+function is_exempt(path13, is_basic2 = false) {
+  if (EXEMPT_PATHS.includes(path13) || is_basic_manual(path13, is_basic2)) return true;
+  return EXEMPT_SUFFIXES.some((suffix) => path13.endsWith(suffix)) || EXEMPT_PREFIXES.some((prefix) => path13.startsWith(prefix));
 }
-function is_runtime(path16, is_basic2 = false) {
-  return !is_test_file(path16) && !is_exempt(path16, is_basic2);
+function is_runtime(path13, is_basic2 = false) {
+  return !is_test_file(path13) && !is_exempt(path13, is_basic2);
 }
 function verdict_for2(paths, is_basic2 = false) {
   const changed = normalize(paths);
-  if (changed.some((path16) => is_test_file(path16))) return "satisfied";
-  if (changed.some((path16) => is_runtime(path16, is_basic2))) return "required";
+  if (changed.some((path13) => is_test_file(path13))) return "satisfied";
+  if (changed.some((path13) => is_runtime(path13, is_basic2))) return "required";
   return "exempt";
 }
 function runtime_files(paths, is_basic2 = false) {
-  return normalize(paths).filter((path16) => is_runtime(path16, is_basic2));
+  return normalize(paths).filter((path13) => is_runtime(path13, is_basic2));
 }
 function exempt_files(paths, is_basic2 = false) {
-  return normalize(paths).filter((path16) => is_exempt(path16, is_basic2));
+  return normalize(paths).filter((path13) => is_exempt(path13, is_basic2));
 }
 function manual_check_files(paths, is_basic2) {
-  return normalize(paths).filter((path16) => is_exempt(path16, is_basic2) && !is_exempt(path16));
+  return normalize(paths).filter((path13) => is_exempt(path13, is_basic2) && !is_exempt(path13));
 }
 var test_declared_logic = {
   EXEMPT_PATHS,
@@ -5709,9 +5332,9 @@ function is_untested_commit(call) {
   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 ROW19 = { id: "test-declared", is_trigger: is_untested_commit, reason: REASON };
-var test_declared_commit = { REASON, ROW: ROW19 };
+var REASON = "\u26D4 test declared: this commits a runtime code change with no test beside it \u2014 `pnpm josh test:declared` reads it `required` and names the files. Tests are required for ALL code changes: add the test and reissue, or, for a change that touches no runtime path, declare the non-runtime exception in your Step 0 work summary and reissue. It fires once per run (`CLAUDE.md` \u2192 Code Change Rules).";
+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) {
@@ -5748,15 +5371,15 @@ 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 ROW20 = {
+var THIRD_PARTY_WRITE_REASON = "\u26D4 third-party write: this `gh api` call writes to a repository whose owner is not this session, which is Tier C and needs explicit current-turn user instruction. Check with `pnpm josh repo:party <owner/repo>`, then record the finding on our own Issue and draft the artifact for a person to post. This rule fires on every occurrence (`prompts/collaboration-workflow/upstream-interrupt.md`).";
+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: ROW20,
+  ROW: ROW21,
   THIRD_PARTY_WRITE_REASON,
   writes_third_party
 };
@@ -5788,7 +5411,8 @@ var DELIVERED_RULES = [
     reason: piped_verification.PIPED_VERIFICATION_REASON,
     keeps: on_bash_command(piped_verification.keeps_verdict_intact),
     reaches: on_bash_command(piped_verification.runs_verification),
-    // A `| tail` / `| grep` masking is rewritten under `pipefail` by `pretool-guard.ts`, never refused.
+    // A masking whose filter reads to the end is rewritten under `pipefail`, never refused.
+    rewrite: piped_verification.pipefail_input,
     rewrite_note: piped_verification.PIPEFAIL_NOTE
   },
   {
@@ -5827,6 +5451,7 @@ var DELIVERED_RULES = [
   lane_split_park.ROW,
   lane_park.ROW,
   lane_interactive_ask.ROW,
+  agent_model.ROW,
   lane_carry_conflict.ROW,
   lane_switch_main.ROW,
   // Disjoint from `run-tail` by the `-y` flag.
@@ -5866,22 +5491,22 @@ var MEASURED_RULES = [
 ];
 var BATCH_STAMP = hook_decision.create_refusal_stamp(time_batch_guard.STAMP_PREFIX);
 var BATCH_REFUSAL_WINDOW_MS = 1e4;
-function will_batch_guard_refuse(tail, call, run2) {
+function will_batch_guard_refuse(tail, call, run) {
   if (lane_guard_policy.mode_here("batching") !== "refuse") return false;
-  const refused_at_ms = BATCH_STAMP.last_ms(BATCH_STAMP.path(run2.transcript));
-  if (run2.now_ms - refused_at_ms < BATCH_REFUSAL_WINDOW_MS) return true;
+  const refused_at_ms = BATCH_STAMP.last_ms(BATCH_STAMP.path(run.transcript));
+  if (run.now_ms - refused_at_ms < BATCH_REFUSAL_WINDOW_MS) return true;
   return time_batch_guard.should_block(tail, call, refused_at_ms);
 }
-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 is_first_delivery(tail, call, delivered_at_ms, run) {
+  return delivered_at_ms === hook_decision.NEVER_MS && !will_batch_guard_refuse(tail, call, run);
 }
 function delivery_decision(rule) {
-  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) {
+  const { decide: decide5, already_satisfied } = rule;
+  if (decide5 === void 0 && already_satisfied === void 0) return is_first_delivery;
+  return function should_block(tail, call, delivered_at_ms, run) {
     if (already_satisfied?.(tail, call) === true) return false;
-    if (decide7 === void 0) return true;
-    return decide7(call, run2, !will_batch_guard_refuse(tail, call, run2), delivered_at_ms);
+    if (decide5 === void 0) return true;
+    return decide5(call, run, !will_batch_guard_refuse(tail, call, run), delivered_at_ms);
   };
 }
 function guard_of(rule) {
@@ -5934,6 +5559,144 @@ var delivered_rules = {
   is_issue_filing
 };
 
+// scripts/rules/guard-remedy.ts
+var REWRITTEN = "the hook makes the same call right itself; it refuses only a spelling it cannot rewrite";
+var ANOTHER_TOOL = "the right form is another tool, which `updatedInput` cannot switch to";
+var ANOTHER_COMMAND = "the right act is another command, whose arguments the call does not carry";
+var NO_RUN = "the call must not run at all, or only on a person's word \u2014 refusing is the remedy";
+var STOP_NOTIFY = "the hook sends the notify itself; it blocks only when the send fails";
+var HOLD_RELEASE = "the hook releases the hold itself; it blocks only when that release fails";
+var ISSUE_CITATION = "the hook prints the citation lines itself; it blocks only on a number it cannot cite";
+var FILING_OFFER = "the filing needs a title and a body only the model can write";
+function rewrite() {
+  return { remedy: "rewrite", why: REWRITTEN };
+}
+function judgment(why) {
+  return { remedy: "judgment", why };
+}
+var GUARD_REMEDIES = {
+  // The rewrites: each fix is the same call made right.
+  "piped-verification": rewrite(),
+  // wrapped in `(set -o pipefail; …)`
+  "issue-comments": rewrite(),
+  // the same Issue's comments read on the same line
+  "lane-background": rewrite(),
+  // a lane child's `ship` run in the foreground (`pretool-guard.ts`)
+  "file-body": judgment(ANOTHER_TOOL),
+  // Edit or Write
+  "shell-body": judgment(
+    "which part of the body the shell was meant to expand is the author's, not the hook's"
+  ),
+  "raw-field-body": judgment("the body moves to a file the call does not name"),
+  "rule-body": judgment("a trigger-plus-pointer line is written, not derived"),
+  "direct-filing": judgment(ANOTHER_COMMAND),
+  "direct-pr-create": judgment(ANOTHER_COMMAND),
+  "josh-git-bare": judgment(ANOTHER_COMMAND),
+  "run-tail": judgment(ANOTHER_COMMAND),
+  "pre-gate-cut": judgment(ANOTHER_COMMAND),
+  "implementation-cut": judgment(ANOTHER_COMMAND),
+  "early-heartbeat": judgment(ANOTHER_COMMAND),
+  "poll-loop": judgment(ANOTHER_COMMAND),
+  "lane-park": judgment(ANOTHER_COMMAND),
+  "lane-split-park": judgment(ANOTHER_COMMAND),
+  "lane-interactive-ask": judgment(ANOTHER_COMMAND),
+  "agent-model": judgment("which model fits the unit is the author's call"),
+  "lane-carry-conflict": judgment(ANOTHER_COMMAND),
+  "lane-switch-main": judgment(ANOTHER_COMMAND),
+  "oracle-consulted": judgment(ANOTHER_COMMAND),
+  "test-declared": judgment(ANOTHER_COMMAND),
+  batching: judgment(ANOTHER_COMMAND),
+  investigation: judgment(ANOTHER_COMMAND),
+  "duplicate-read": judgment(ANOTHER_COMMAND),
+  "run-watcher": judgment(ANOTHER_COMMAND),
+  "parent-cut": judgment(ANOTHER_COMMAND),
+  "issue-watch": judgment(ANOTHER_COMMAND),
+  "third-party-write": judgment(NO_RUN),
+  "filing-cap": judgment(NO_RUN),
+  "git-force": judgment(NO_RUN),
+  "worktree-mutation": judgment(NO_RUN),
+  "index-mutation": judgment(NO_RUN),
+  "destructive-command": judgment(NO_RUN),
+  "protected-file": judgment(NO_RUN),
+  // The `Stop` rows: the hook judges a finished reply, so it has no call to rewrite.
+  "stop-notify": judgment(STOP_NOTIFY),
+  "issue-citation": judgment(ISSUE_CITATION),
+  "filing-offer": judgment(FILING_OFFER),
+  "hold-release": judgment(HOLD_RELEASE)
+};
+var FAMILY_SEPARATOR = ":";
+function entry_of(id) {
+  return GUARD_REMEDIES[id] ?? GUARD_REMEDIES[id.split(FAMILY_SEPARATOR)[0] ?? ""];
+}
+function remedy_of(id) {
+  return entry_of(id)?.remedy;
+}
+function why_of(id) {
+  return entry_of(id)?.why;
+}
+function is_rewrite(id) {
+  return remedy_of(id) === "rewrite";
+}
+var guard_remedy = {
+  GUARD_REMEDIES,
+  is_rewrite,
+  remedy_of,
+  why_of
+};
+
+// scripts/rules/rule-rewrite.ts
+var REWRITING_RULES = delivered_rules.DELIVERED_RULES.filter(
+  (rule) => guard_remedy.is_rewrite(rule.id) && rule.rewrite !== void 0
+);
+var NOTE_SEPARATOR = "\n\n";
+function read_payload_tail(raw_payload) {
+  try {
+    const payload = hook_decision.parse_hook_payload(raw_payload);
+    return payload ? time_density_hook.read_tail(
+      time_hook_transcript.transcript_of(payload.transcript_path, payload.agent_id)
+    ) : "";
+  } catch {
+    return "";
+  }
+}
+function tail_reader(raw_payload) {
+  const cache = {};
+  return function tail() {
+    cache.tail ??= read_payload_tail(raw_payload);
+    return cache.tail;
+  };
+}
+function fold(name, typed, tail) {
+  const folded = { input: typed, notes: [] };
+  for (const rule of REWRITING_RULES) {
+    const input = rule.rewrite?.({ name, input: folded.input }, tail);
+    if (input === void 0) {
+      continue;
+    }
+    folded.input = input;
+    folded.notes = [...folded.notes, rule.rewrite_note ?? ""];
+  }
+  return folded;
+}
+function typed_payload(raw_payload) {
+  const fields = json_value.parse_or_undefined(raw_payload);
+  if (!json_value.is_record(fields)) return void 0;
+  const input = fields["tool_input"];
+  return json_value.is_record(input) ? { fields, name: String(fields["tool_name"]), input } : void 0;
+}
+function rewrite2(raw_payload) {
+  const typed = delivered_rules.is_enabled() ? typed_payload(raw_payload) : void 0;
+  if (typed === void 0) return void 0;
+  const { input, notes } = fold(typed.name, typed.input, tail_reader(raw_payload));
+  if (notes.length === 0) return void 0;
+  const note = notes.join(NOTE_SEPARATOR);
+  return { payload: JSON.stringify({ ...typed.fields, tool_input: input }), input, note };
+}
+var rule_rewrite = {
+  NOTE_SEPARATOR,
+  rewrite: rewrite2
+};
+
 // scripts/run/progress/run-progress-read.ts
 import { loadavg } from "node:os";
 
@@ -6004,411 +5767,16 @@ var epic_busy = {
   read_repository
 };
 
-// scripts/run/run-liveness.ts
-import { readFileSync as readFileSync7, realpathSync, statSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
-import path14 from "node:path";
-import { setTimeout as sleep } from "node:timers/promises";
-
-// scripts/agent/agent-event.ts
-import { z as z15 } from "zod";
-
-// scripts/agent/claude-result-event.ts
-import { z as z14 } from "zod";
-var RESULT_EVENT_SCHEMA = z14.looseObject({
-  type: z14.literal("result"),
-  is_error: z14.unknown().optional(),
-  subtype: z14.unknown().optional(),
-  num_turns: z14.unknown().optional(),
-  permission_denials: z14.unknown().optional(),
-  result: z14.unknown().optional(),
-  session_id: z14.unknown().optional(),
-  usage: z14.unknown().optional()
-});
-var USAGE_SCHEMA = z14.looseObject({
-  input_tokens: z14.unknown().optional(),
-  cache_read_input_tokens: z14.unknown().optional(),
-  output_tokens: z14.unknown().optional()
-});
-function usable_reason(value) {
-  return typeof value === "string" && value.trim() !== "" ? value : void 0;
-}
-function numeric_value(value) {
-  return typeof value === "number" ? value : void 0;
-}
-function denial_count(value) {
-  return Array.isArray(value) ? value.length : 0;
-}
-function usage_of(value) {
-  const parsed = USAGE_SCHEMA.safeParse(value);
-  if (!parsed.success) return void 0;
-  const usage = {
-    input_tokens: numeric_value(parsed.data.input_tokens),
-    cached_input_tokens: numeric_value(parsed.data.cache_read_input_tokens),
-    output_tokens: numeric_value(parsed.data.output_tokens)
-  };
-  return Object.values(usage).some((count) => count !== void 0) ? usage : void 0;
-}
-function decode(value) {
-  const parsed = RESULT_EVENT_SCHEMA.safeParse(value);
-  if (!parsed.success) return void 0;
-  const is_error = parsed.data.is_error === true;
-  return {
-    is_error,
-    subtype: usable_reason(parsed.data.subtype),
-    num_turns: numeric_value(parsed.data.num_turns),
-    permission_denials: denial_count(parsed.data.permission_denials),
-    refused_ask: interactive_ask.refused_ask_of(parsed.data.permission_denials),
-    reason: is_error ? usable_reason(parsed.data.result) ?? usable_reason(parsed.data.subtype) : void 0,
-    session_id: usable_reason(parsed.data.session_id),
-    usage: usage_of(parsed.data.usage)
-  };
-}
-var claude_result_event = { decode };
-
-// scripts/agent/agent-event.ts
-var TEXT_BLOCK_SCHEMA = z15.looseObject({ type: z15.literal("text"), text: z15.string() });
-var CLAUDE_MESSAGE_SCHEMA = z15.looseObject({ content: z15.array(z15.unknown()).optional() });
-var CLAUDE_INIT_SCHEMA = z15.looseObject({ type: z15.literal("system"), subtype: z15.literal("init") });
-var CLAUDE_ASSISTANT_SCHEMA = z15.looseObject({
-  type: z15.literal("assistant"),
-  message: CLAUDE_MESSAGE_SCHEMA
-});
-var USAGE_SCHEMA2 = z15.looseObject({
-  input_tokens: z15.number().optional(),
-  cached_input_tokens: z15.number().optional(),
-  output_tokens: z15.number().optional()
-});
-var CODEX_START_SCHEMA = z15.looseObject({ type: z15.enum(["thread.started", "turn.started"]) });
-var CODEX_PROGRESS_SCHEMA = z15.looseObject({
-  type: z15.enum(["item.started", "item.updated", "item.completed"]),
-  item: z15.looseObject({ type: z15.string(), text: z15.string().optional() }).optional()
-});
-var CODEX_COMPLETE_SCHEMA = z15.looseObject({
-  type: z15.literal("turn.completed"),
-  usage: USAGE_SCHEMA2.optional()
-});
-var CODEX_FAILURE_SCHEMA = z15.looseObject({
-  type: z15.enum(["turn.failed", "error"]),
-  error: z15.looseObject({ message: z15.string().optional() }).optional(),
-  message: z15.string().optional()
-});
-var EMPTY_STATE = {
-  provider: void 0,
-  launch: "pending",
-  progress: void 0,
-  result: "running",
-  reason: void 0,
-  usage: void 0
-};
-var LAUNCH_HEADER_PREFIX = "=== ";
-var LAUNCH_HEADER_MARKER = " \xB7 started by process ";
-function usable_text(value) {
-  return typeof value === "string" && value.trim() !== "" ? value : void 0;
-}
-function claude_progress(content) {
-  return content.map((block) => TEXT_BLOCK_SCHEMA.safeParse(block)).filter((parsed) => parsed.success).map((parsed) => parsed.data.text).findLast((text) => text.trim() !== "");
-}
-function claude_result(value, state) {
-  const result = claude_result_event.decode(value);
-  if (result === void 0) return void 0;
-  return {
-    ...state,
-    provider: "anthropic",
-    result: result.is_error ? "failed" : "completed",
-    reason: result.is_error ? result.reason ?? state.reason : state.reason,
-    usage: result.usage
-  };
-}
-function claude_assistant(value, state) {
-  const assistant = CLAUDE_ASSISTANT_SCHEMA.safeParse(value);
-  if (!assistant.success) return void 0;
-  const progress = claude_progress(assistant.data.message.content ?? []) ?? state.progress;
-  return { ...state, provider: "anthropic", progress };
-}
-function claude_terminal(value, state) {
-  return claude_result(value, state);
-}
-function claude_event(value, state) {
-  if (CLAUDE_INIT_SCHEMA.safeParse(value).success) {
-    return { ...state, provider: "anthropic", launch: "started" };
-  }
-  return claude_assistant(value, state) ?? claude_terminal(value, state);
-}
-function codex_progress(value, state) {
-  const parsed = CODEX_PROGRESS_SCHEMA.safeParse(value);
-  if (!parsed.success) return void 0;
-  const progress = usable_text(parsed.data.item?.text) ?? state.progress;
-  return { ...state, provider: "openai", progress };
-}
-function codex_completed(value, state) {
-  const completed = CODEX_COMPLETE_SCHEMA.safeParse(value);
-  if (!completed.success) return void 0;
-  return { ...state, provider: "openai", result: "completed", usage: completed.data.usage };
-}
-function codex_failed(value, state) {
-  const failed = CODEX_FAILURE_SCHEMA.safeParse(value);
-  if (!failed.success) return void 0;
-  const reason = usable_text(failed.data.error?.message) ?? usable_text(failed.data.message);
-  return { ...state, provider: "openai", result: "failed", reason: reason ?? state.reason };
-}
-function codex_terminal(value, state) {
-  return codex_completed(value, state) ?? codex_failed(value, state);
-}
-function codex_event(value, state) {
-  if (CODEX_START_SCHEMA.safeParse(value).success) {
-    return { ...state, provider: "openai", launch: "started" };
-  }
-  return codex_progress(value, state) ?? codex_terminal(value, state);
-}
-function normalized(value, state) {
-  return claude_event(value, state) ?? codex_event(value, state) ?? state;
-}
-function next_state2(line, state) {
-  const is_header = line.startsWith(LAUNCH_HEADER_PREFIX) && line.includes(LAUNCH_HEADER_MARKER);
-  if (is_header) return EMPTY_STATE;
-  return normalized(json_value.parse_or_undefined(line), state);
-}
-function read(transcript) {
-  let state = EMPTY_STATE;
-  for (const line of transcript.split("\n")) state = next_state2(line, state);
-  return state;
-}
-function describe(state) {
-  const progress = state.progress === void 0 ? "" : ` progress=${state.progress}`;
-  const reason = state.reason === void 0 ? "" : ` reason=${state.reason}`;
-  return `launch=${state.launch} result=${state.result}${progress}${reason}`;
-}
-var agent_event = { describe, read };
-
-// scripts/issue/issue-state.ts
-import { z as z16 } from "zod";
-var NO_LABELS = "(none)";
-var LABEL_SEPARATOR = ", ";
-var STATE_LABEL = "state: ";
-var LABELS_LABEL = "labels: ";
-var HUMAN_REVIEW_LABEL_LINE = "human_review: ";
-var YES = "yes";
-var NO = "no";
-var ISSUE_LABEL = "issue: ";
-var HUMAN_REVIEW_LABELS = /* @__PURE__ */ new Set([NEEDS_HUMAN_REVIEW_LABEL]);
-var label_schema = z16.looseObject({ name: z16.string() });
-var issue_state_schema = z16.looseObject({
-  state: z16.string(),
-  labels: label_schema.array().optional()
-});
-function parse_issue_state(json) {
-  try {
-    const parsed = parse_json_object_or_undefined(json, issue_state_schema);
-    if (parsed === void 0) return void 0;
-    const labels = parsed.labels ?? [];
-    return {
-      state: parsed.state,
-      labels: labels.map((label) => label.name),
-      is_human_review: has_any_label(labels, HUMAN_REVIEW_LABELS)
-    };
-  } catch {
-    return void 0;
-  }
-}
-function format_labels(labels) {
-  return labels.length === 0 ? NO_LABELS : labels.join(LABEL_SEPARATOR);
-}
-function format_issue_state(state) {
-  const human_review = `${HUMAN_REVIEW_LABEL_LINE}${state.is_human_review ? YES : NO}`;
-  return `${STATE_LABEL}${state.state}
-${LABELS_LABEL}${format_labels(state.labels)}
-${human_review}`;
-}
-function format_attributed_issue_state(issue_number, state) {
-  return `${ISSUE_LABEL}${issue_number}
-${format_issue_state(state)}`;
-}
-var issue_state = {
-  NO_LABELS,
-  parse_issue_state,
-  format_issue_state,
-  format_attributed_issue_state
-};
-
-// scripts/run/run-liveness.ts
-var ALIVE_VERDICT = "alive";
-var SETTLED_VERDICT = "settled";
-var STOPPED_VERDICT = "stopped";
-var UNDETERMINED_VERDICT = "undetermined";
-var PROCESS_ALIVE = "alive";
-var PROCESS_UNKNOWN = "unknown";
-var DEFAULT_SILENT_MINUTES = 30;
-var DEFAULT_GAP_SECONDS = 5;
-var MS_PER_MINUTE3 = 6e4;
-var MS_PER_SECOND2 = 1e3;
-var OPEN_STATE = "OPEN";
-var STATE_FIELDS = "state,labels";
-var REASONS = {
-  [ALIVE_VERDICT]: "The unit is still working: its output moved, or a process of the child is alive.",
-  [SETTLED_VERDICT]: "The child is closed, parked with `needs-decision`, or marked `already-done`, so there is nothing here to recover.",
-  [STOPPED_VERDICT]: "The output has been frozen past the silent window and no process of the child is alive in that checkout.",
-  [UNDETERMINED_VERDICT]: "A trace could not be read, so this says nothing about the unit. A trace that could not be read answers `undetermined`, never `stopped`."
-};
-var ALIVE_ADVICE = "Keep polling; do not touch the child.";
-var SETTLED_ADVICE = "Read the child with `pnpm josh issue:state <N>` and take the branch its state says.";
-var STOPPED_CLEAN_ADVICE = 'The unit ended \u2014 classify how before booking it. Run `pnpm josh run:merge <N> --output <path>` (add `--epic <E> --repo <owner/repo> --owner "$PPID"` for a named epic): it reads the child\'s exit record without waiting for the unit to return, re-dispatches a child that could not reach the API (counting the outage; a run of them trips the environment guard and stops the run), and parks an abandoned child with `needs-decision` against the consecutive-failure guard. The checkout is clean, so there is nothing to stash.';
-var STOPPED_DIRTY_ADVICE = 'Stash the half-finished work with `git stash push -u -m "backlogrun: stopped unit for #<N>"` and record it on the Issue, then classify how the unit ended with `pnpm josh run:merge <N> --output <path>` (add `--epic <E> --repo <owner/repo> --owner "$PPID"` for a named epic): it re-dispatches an API-outage child (counting the outage; a run of them trips the environment guard) and parks an abandoned child with `needs-decision` against the consecutive-failure guard, without waiting for the unit to return.';
-var UNDETERMINED_ADVICE = "Read the trace that failed and ask again. Where the process trace was given as `unknown`, leave `--process` out so the command reads it. Two of these in a row is a fault in the check itself rather than a slow unit: stop polling and report it.";
-function is_output_moving(traces) {
-  return traces.is_output_frozen === false;
-}
-function is_agent_state_finished(state) {
-  return state?.result === "completed" || state?.result === "failed";
-}
-function is_agent_finished(traces) {
-  return is_agent_state_finished(traces.agent_state);
-}
-function definitive_verdict(traces) {
-  if (traces.is_child_settled === true) return SETTLED_VERDICT;
-  if (is_agent_finished(traces)) return STOPPED_VERDICT;
-  if (is_output_moving(traces)) return ALIVE_VERDICT;
-  return void 0;
-}
-function is_check_running(traces) {
-  return traces.process_trace === PROCESS_ALIVE;
-}
-function has_unreadable_trace(traces) {
-  return traces.is_child_settled === void 0 || traces.is_output_frozen === void 0 || traces.process_trace === PROCESS_UNKNOWN;
-}
-function to_verdict(traces) {
-  const definitive = definitive_verdict(traces);
-  if (definitive !== void 0) return definitive;
-  if (has_unreadable_trace(traces)) return UNDETERMINED_VERDICT;
-  return is_check_running(traces) ? ALIVE_VERDICT : STOPPED_VERDICT;
-}
-function to_advice(verdict, has_work_to_stash) {
-  if (verdict === ALIVE_VERDICT) return ALIVE_ADVICE;
-  if (verdict === SETTLED_VERDICT) return SETTLED_ADVICE;
-  if (verdict === UNDETERMINED_VERDICT) return UNDETERMINED_ADVICE;
-  return has_work_to_stash ? STOPPED_DIRTY_ADVICE : STOPPED_CLEAN_ADVICE;
-}
-function decide5(traces) {
-  const verdict = to_verdict(traces);
-  const has_work_to_stash = verdict === STOPPED_VERDICT && traces.is_tree_dirty;
-  return {
-    advice: to_advice(verdict, has_work_to_stash),
-    has_work_to_stash,
-    reason: traces.agent_state?.reason ?? REASONS[verdict],
-    verdict
-  };
-}
-function to_resolved_root(root) {
-  try {
-    return realpathSync(root);
-  } catch {
-    return root;
-  }
-}
-var ALLOWED_ROOTS = [
-  ...new Set(
-    [homedir(), tmpdir(), PLATFORM_TEMP_ROOT].flatMap((root) => [root, to_resolved_root(root)])
-  )
-];
-function is_within(candidate, root) {
-  const relative = path14.relative(root, candidate);
-  return relative !== "" && !relative.startsWith("..") && !path14.isAbsolute(relative);
-}
-function to_safe_path(output_path) {
-  const normalized2 = path14.normalize(output_path);
-  if (!path14.isAbsolute(normalized2)) return void 0;
-  return ALLOWED_ROOTS.some((root) => is_within(normalized2, root)) ? normalized2 : void 0;
-}
-function sample_output(output_path) {
-  const safe_path = to_safe_path(output_path);
-  if (safe_path === void 0) return void 0;
-  const stats = statSync(safe_path, { throwIfNoEntry: false });
-  if (!stats?.isFile()) return void 0;
-  return { mtime_ms: stats.mtimeMs, size: stats.size };
-}
-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(readFileSync7(safe_path, "utf8"));
-    return state.provider === void 0 ? void 0 : state;
-  } catch {
-    return void 0;
-  }
-}
-function describe_agent_state(output_path) {
-  const state = read_agent_state(output_path);
-  return state === void 0 ? void 0 : `agent: ${state.provider ?? "unknown"} ${agent_event.describe(state)}`;
-}
-async function read_output_frozen(request2) {
-  const first = sample_output(request2.output_path);
-  if (first === void 0) return void 0;
-  if (request2.now_ms - first.mtime_ms < request2.silent_window_ms) return false;
-  await sleep(request2.gap_ms);
-  const second = sample_output(request2.output_path);
-  if (second === void 0) return void 0;
-  return second.mtime_ms === first.mtime_ms && second.size === first.size;
-}
-function carries_label(labels, wanted) {
-  return labels.some((label) => label.toLowerCase() === wanted);
-}
-var SETTLED_LABELS = [NEEDS_DECISION_LABEL, ALREADY_DONE_LABEL];
-function carries_settled_label(labels) {
-  return SETTLED_LABELS.some((label) => carries_label(labels, label));
-}
-async function read_child_settled(issue, repo) {
-  const json = await git_gh_issue_read.issue_view_json(issue, STATE_FIELDS, repo);
-  if (json === void 0) return void 0;
-  const state = issue_state.parse_issue_state(json);
-  if (state === void 0) return void 0;
-  return state.state !== OPEN_STATE || carries_settled_label(state.labels);
-}
-async function read_traces(request2) {
-  const [is_initial_child_settled, is_output_frozen, is_tree_dirty] = await Promise.all([
-    read_child_settled(request2.issue, request2.repo),
-    read_output_frozen({
-      gap_ms: request2.gap_ms ?? DEFAULT_GAP_SECONDS * MS_PER_SECOND2,
-      now_ms: Date.now(),
-      output_path: request2.output_path,
-      silent_window_ms: request2.silent_window_ms ?? DEFAULT_SILENT_MINUTES * MS_PER_MINUTE3
-    }),
-    run_hold.is_tree_dirty()
-  ]);
-  const agent_state = read_agent_state(request2.output_path);
-  const is_latest_child_settled = is_agent_state_finished(agent_state) ? await read_child_settled(request2.issue, request2.repo) : void 0;
-  const is_child_settled = is_latest_child_settled ?? is_initial_child_settled;
-  return {
-    agent_state,
-    is_child_settled,
-    is_output_frozen,
-    is_tree_dirty,
-    process_trace: request2.process_trace
-  };
-}
-async function check2(request2) {
-  issue_number_shape.require_issue_number(request2.issue);
-  return decide5(await read_traces(request2));
-}
-var run_liveness = {
-  check: check2,
-  decide: decide5,
-  describe_agent_state,
-  read_child_settled,
-  read_output_frozen,
-  sample_output,
-  to_safe_path
-};
-
 // scripts/lane/lane-report.ts
 var NO_LANES2 = "No lanes are open.";
-var OPEN_STATE2 = "open";
+var OPEN_STATE = "open";
 var STRANDED_STATE = "stranded";
 var UNREADABLE_STATE = "unreadable";
 var UNKNOWN_VALUE = "-";
 var COLUMN_SEPARATOR = "  ";
 function lane_state(lane) {
   if (lane.is_stranded) return STRANDED_STATE;
-  return lane.seat === void 0 ? UNREADABLE_STATE : OPEN_STATE2;
+  return lane.seat === void 0 ? UNREADABLE_STATE : OPEN_STATE;
 }
 function value_or_unknown(value) {
   return value === void 0 ? UNKNOWN_VALUE : String(value);
@@ -6452,7 +5820,7 @@ function describe_opened(lane) {
 }
 var lane_report = {
   NO_LANES: NO_LANES2,
-  OPEN_STATE: OPEN_STATE2,
+  OPEN_STATE,
   STRANDED_STATE,
   UNREADABLE_STATE,
   describe_lane,
@@ -6461,198 +5829,6 @@ var lane_report = {
   lane_state
 };
 
-// scripts/run/run-preflight.ts
-import { z as z17 } from "zod";
-var CLEAN_VERDICT = "clean";
-var RECLAIM_VERDICT = "reclaim";
-var RESUME_VERDICT = "resume";
-var PARK_VERDICT = "park";
-var NO_PR = "none";
-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_schema = z17.object({ state: z17.string().optional() });
-var GH_PR_STATES = /* @__PURE__ */ new Map([
-  ["CLOSED", CLOSED_PR],
-  ["MERGED", MERGED_PR],
-  ["OPEN", OPEN_PR]
-]);
-var CLEAN_REASON = "Nothing was left behind: the tree is clean, HEAD is on the default branch, and this issue has no pull request and no branch holding work.";
-var CLEAN_ADVICE = "Start the child.";
-var RESUME_ADVICE = "Reuse the branch and run the whole verification gate from the start \u2014 refactor, `pnpm josh gate`, `/code-review` \u2014 never only the part the interrupted run had not reached. Nobody verified what it already committed.";
-var PARK_ADVICE = "Park the child: add `needs-decision` and comment what was found. Do not delete the branch, do not reopen the pull request, and do not commit on top of it.";
-var STASH_LABEL_PREFIX = "run:hold reclaimed before #";
-var { require_issue_number } = issue_number_shape;
-var UNREADABLE_PR_MESSAGE = "The pull request could not be read for branch ";
-function needs_reclaim(tree) {
-  return tree.is_dirty || tree.branch !== tree.default_branch;
-}
-function is_pr_decided(state) {
-  return state === MERGED_PR || state === CLOSED_PR;
-}
-function has_leftover_work(child) {
-  return child.branch_name !== void 0 || child.pr_state === OPEN_PR;
-}
-function to_verdict2(tree, child) {
-  if (needs_reclaim(tree)) return RECLAIM_VERDICT;
-  if (is_pr_decided(child.pr_state)) return PARK_VERDICT;
-  if (has_leftover_work(child)) return RESUME_VERDICT;
-  return CLEAN_VERDICT;
-}
-function reclaim_reason(tree) {
-  const findings = [
-    tree.is_dirty ? "uncommitted changes" : void 0,
-    tree.branch === tree.default_branch ? void 0 : `HEAD on ${tree.branch}`
-  ].filter((entry) => entry !== void 0);
-  return `An earlier run left ${findings.join(" and ")} in this working tree.`;
-}
-function park_reason(state) {
-  return `The pull request for this issue is ${state}, so whether any work is still owed is a person's call.`;
-}
-function resume_reason(child) {
-  const branch_part = child.branch_name === void 0 ? "" : ` on branch ${child.branch_name}`;
-  const pr_part = child.pr_state === OPEN_PR ? ", and its pull request is still open" : "";
-  return `An earlier run left a partial implementation${branch_part}${pr_part}.`;
-}
-function to_reason(verdict, tree, child) {
-  if (verdict === RECLAIM_VERDICT) return reclaim_reason(tree);
-  if (verdict === PARK_VERDICT) return park_reason(child.pr_state);
-  if (verdict === RESUME_VERDICT) return resume_reason(child);
-  return CLEAN_REASON;
-}
-function reclaim_steps(tree, issue) {
-  if (!tree.is_dirty) return [];
-  return [
-    `git stash push -u -m "${STASH_LABEL_PREFIX}${issue}"`,
-    `Record the stash on ${session_cite.issue(issue)} \u2014 the comment is what gets it popped; nothing pops it for you.`
-  ];
-}
-function reclaim_advice(tree, issue) {
-  return [
-    ...reclaim_steps(tree, issue),
-    "pnpm josh ms",
-    "Then ask this command again: it is re-askable, and the clean tree gets its own answer."
-  ].join("\n");
-}
-function to_advice2(verdict, issue, tree) {
-  if (verdict === RECLAIM_VERDICT) return reclaim_advice(tree, issue);
-  if (verdict === RESUME_VERDICT) return RESUME_ADVICE;
-  if (verdict === PARK_VERDICT) return PARK_ADVICE;
-  return CLEAN_ADVICE;
-}
-function decide6(tree, child, issue) {
-  const verdict = to_verdict2(tree, child);
-  return {
-    advice: to_advice2(verdict, issue, tree),
-    reason: to_reason(verdict, tree, child),
-    verdict
-  };
-}
-function read_pr_field(raw) {
-  return json_value.parse_with(raw, pr_info_schema)?.state;
-}
-function to_pr_state(raw) {
-  const state = read_pr_field(raw);
-  return (state === void 0 ? void 0 : GH_PR_STATES.get(state)) ?? NO_PR;
-}
-async function read_tree_state() {
-  const [is_dirty, current, default_branch] = await Promise.all([
-    run_hold.is_tree_dirty(),
-    git_command.branch(),
-    git_command.get_default_branch()
-  ]);
-  return { branch: current, default_branch, is_dirty };
-}
-async function read_pr_state(branch_name) {
-  if (!await git_gh_pr_read.pr_exists(branch_name)) return NO_PR;
-  const raw = await git_gh_pr_read.pr_view(branch_name);
-  if (raw === "") throw new Error(`${UNREADABLE_PR_MESSAGE}${branch_name}`);
-  return to_pr_state(raw);
-}
-function is_pr_open(state) {
-  return state === OPEN_PR;
-}
-async function read_pr_of_branch(branch_name) {
-  return { branch_name, pr_state: await read_pr_state(branch_name) };
-}
-function pick_child_state(reads) {
-  const decided = reads.find((read2) => is_pr_decided(read2.pr_state));
-  const open = reads.find((read2) => is_pr_open(read2.pr_state));
-  return decided ?? open ?? { branch_name: reads[0]?.branch_name, pr_state: NO_PR };
-}
-var ISSUE_BRANCH_SUFFIX = "-*";
-var ANY_REMOTE_PREFIX = "*/";
-var REMOTE_SEPARATOR = "/";
-var NOT_FOUND_INDEX = -1;
-function to_head_branch(name) {
-  const separator_index = name.indexOf(REMOTE_SEPARATOR);
-  return separator_index === NOT_FOUND_INDEX ? name : name.slice(separator_index + 1);
-}
-function group_by_head(pairs) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const [name, reference] of pairs) groups.set(name, [...groups.get(name) ?? [], reference]);
-  return groups;
-}
-async function read_branch_candidates(issue) {
-  const pattern = `${issue}${ISSUE_BRANCH_SUFFIX}`;
-  const [local, remote] = await Promise.all([
-    git_command.branch_names(pattern),
-    git_command.branch_names_remote(`${ANY_REMOTE_PREFIX}${pattern}`)
-  ]);
-  return group_by_head([
-    ...local.map((name) => [name, name]),
-    ...remote.map((reference) => [to_head_branch(reference), reference])
-  ]);
-}
-async function has_commits_beyond(base, references) {
-  const counts = await Promise.all(
-    references.map(async (reference) => await git_command.commit_count_beyond(base, reference))
-  );
-  return counts.some((count) => count > 0);
-}
-async function is_held_dirty(name, lane) {
-  if (lane?.branch !== name || lane.is_stranded) return false;
-  return await run_hold.is_tree_dirty(lane.directory);
-}
-async function read_candidate(name, references, context) {
-  const state = await read_pr_of_branch(name);
-  if (state.pr_state !== NO_PR) return state;
-  if (await has_commits_beyond(context.base, references)) return state;
-  return await is_held_dirty(name, context.lane) ? state : void 0;
-}
-async function read_child_state(issue) {
-  const candidates = await read_branch_candidates(issue);
-  if (candidates.size === 0) return NO_CHILD_WORK;
-  const [base, lane] = await Promise.all([
-    git_command.default_branch_reference(),
-    lane_registry.find_open_lane(issue)
-  ]);
-  const reads = await Promise.all(
-    [...candidates].map(
-      async ([name, references]) => await read_candidate(name, references, { base, lane })
-    )
-  );
-  return pick_child_state(reads.filter((read2) => read2 !== void 0));
-}
-async function check3(issue) {
-  require_issue_number(issue);
-  const tree = await read_tree_state();
-  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,
-  RESUME_ADVICE,
-  MERGED_PR,
-  STASH_LABEL_PREFIX,
-  check: check3,
-  decide: decide6,
-  read_child_state,
-  read_pr_state,
-  to_pr_state
-};
-
 // 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;
@@ -6745,35 +5921,36 @@ var run_progress_read = {
 };
 
 // scripts/run/run-watcher-hook.ts
-import { z as z18 } from "zod";
+import { z as z13 } from "zod";
 
 // scripts/run/run-watcher-guard.ts
 var WATCHER_TICK_MS = 3e4;
 var TICK_MULTIPLIER = 3;
-var MS_PER_SECOND3 = 1e3;
+var MS_PER_SECOND2 = 1e3;
 var STALE_THRESHOLD_MS = WATCHER_TICK_MS * TICK_MULTIPLIER;
-var STALE_THRESHOLD_S = STALE_THRESHOLD_MS / MS_PER_SECOND3;
+var STALE_THRESHOLD_S = STALE_THRESHOLD_MS / MS_PER_SECOND2;
 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 (run_headless.is_headless() || !await run_headless.is_backlog_parent()) return false;
   return await lane_registry.has_lanes_in_flight();
 }
-async function check4(life_target) {
-  if (!await owes_watcher()) return OK_RESULT;
-  if (run_progress_clock.is_life_fresh(life_target, STALE_THRESHOLD_MS)) return OK_RESULT;
+async function check2(life_target) {
+  if (!await owes_watcher() || run_progress_clock.is_life_fresh(life_target, STALE_THRESHOLD_MS)) {
+    return OK_RESULT;
+  }
   return { kind: "stale", note: STALE_NOTE };
 }
 var run_watcher_guard = {
   STALE_NOTE,
   STALE_THRESHOLD_MS,
-  check: check4
+  check: check2
 };
 
 // scripts/run/run-watcher-hook.ts
 var SWITCH_ENV_KEY2 = "JOSH_WATCHER_GUARD";
 var STAMP_PREFIX2 = "josh-watcher-guard-";
-var payload_schema = z18.object({ transcript_path: z18.string().min(1) });
+var payload_schema = z13.object({ transcript_path: z13.string().min(1) });
 function transcript_of(raw_payload) {
   return json_value.parse_with(raw_payload, payload_schema)?.transcript_path;
 }
@@ -6803,14 +5980,14 @@ var run_watcher_hook = { transcript_of, watcher_hook_reason };
 var SWITCH_ENV_KEY3 = "JOSH_PARENT_CUT_GUARD";
 var STAMP_PREFIX3 = "josh-parent-cut-guard-";
 var QUIET_WINDOW_MS = 6e5;
-function current_state3() {
+function current_state2() {
   return {
     carry: async () => await run_headless.driving_carry(),
     verdict: () => implementation_cut_verdict.reused_verdict(() => cost_cli.session_verdict())
   };
 }
 var THRESHOLD_TEXT2 = `${cost_format.format_tokens(CONTEXT_CUT_THRESHOLD)}-token`;
-var PARENT_CUT_REASON = `\u26D4 backlogrun parent hand-off: this session drives a \`backlogrun\` (it owns the live carry record) and its recent-context cost has crossed the shared ${THRESHOLD_TEXT2} threshold between merges, so every later request re-reads the accumulated context (joshuafolkken/kit#2947). Take the hand-off now rather than at the next merge: follow \`.claude/skills/workflow-commands/backlogrun-progress.md\` \u2192 "The hand-off" from its \`over\` branch \u2014 open no new lane and take no new child, read \`pnpm josh lane:list\`, make sure every lane in flight records an output path, then run \`pnpm josh run:carry --cut --owner "$PPID"\` and, unless it answers \`capped\`, \`pnpm josh run:wake\`, post the progress comment and end the turn. A lane nobody can poll means the cut does not happen; carry on and this asks again later. Reissue this call when the hand-off is done or cannot be taken \u2014 the guard stays quiet for a while after it refuses, so the hand-off calls themselves are not refused.`;
+var PARENT_CUT_REASON = `\u26D4 backlogrun parent hand-off: this session drives a \`backlogrun\` and its recent-context cost crossed the ${THRESHOLD_TEXT2} threshold between merges. Take the hand-off now: open no new lane, follow \`backlogrun-progress.md\` \u2192 "The hand-off" (\`pnpm josh run:carry --cut --owner "$PPID"\`, then \`pnpm josh run:wake\` unless \`capped\`) and end the turn. Reissue this call once done or if it cannot be taken.`;
 async function is_due3(state) {
   const carry = await state.carry();
   if (carry === void 0 || run_headless.is_cut_capped(carry)) return false;
@@ -6837,7 +6014,7 @@ function is_unit_call(raw_payload) {
 function is_exempt2(raw_payload) {
   return !hook_decision.is_switch_enabled(SWITCH_ENV_KEY3) || is_unit_call(raw_payload);
 }
-async function parent_cut_reason(raw_payload, now_ms = Date.now(), state = current_state3()) {
+async function parent_cut_reason(raw_payload, now_ms = Date.now(), state = current_state2()) {
   if (is_exempt2(raw_payload)) return void 0;
   const transcript = run_watcher_hook.transcript_of(raw_payload);
   if (transcript === void 0) return void 0;
@@ -6850,8 +6027,95 @@ var run_parent_cut_hook = {
   parent_cut_reason
 };
 
+// scripts/run/run-poll-hook.ts
+var SWITCH_ENV_KEY4 = "JOSH_POLL_GUARD";
+var BASH_TOOL = "Bash";
+var STATE_READS = /* @__PURE__ */ new Set([
+  "josh lane:list",
+  "josh lane:output",
+  "josh run:board",
+  "josh run:carry",
+  "josh run:liveness",
+  "josh run:progress",
+  "josh run:wake"
+]);
+var POLL_REASON = '\u26D4 poll: this `backlogrun` session repeats a state read with nothing decided in between, on every occurrence. Wait on `pnpm josh backlog:drive`, or `pnpm josh lane:await <N...> --owner "$PPID"` in the background, and end the turn; its exit is the wake.';
+var WRITING_FLAGS = /* @__PURE__ */ new Set([
+  "--begin",
+  "--cut",
+  "--done",
+  "--end",
+  "--every",
+  "--filed",
+  "--loop",
+  "--mark",
+  "--merged",
+  "--resume",
+  "--retrospective",
+  "--start",
+  "--stop",
+  "--wait"
+]);
+var FLAG_PREFIX4 = "-";
+var NAME_WORDS = 2;
+var SIGNATURE_SEPARATOR = " ";
+function read_key(signature) {
+  const words = signature.split(SIGNATURE_SEPARATOR);
+  const name = words.slice(0, NAME_WORDS).join(SIGNATURE_SEPARATOR);
+  if (!STATE_READS.has(name) || words.some((word) => WRITING_FLAGS.has(word))) return void 0;
+  return words.filter((word) => !word.startsWith(FLAG_PREFIX4)).join(SIGNATURE_SEPARATOR);
+}
+function read_keys(signatures) {
+  return signatures.map((signature) => read_key(signature)).filter((key) => key !== void 0);
+}
+function state_reads_of(command) {
+  return read_keys(time_shell.josh_signatures_of(command));
+}
+function command_of(input) {
+  if (typeof input !== "object" || input === null || !("command" in input)) return "";
+  return typeof input.command === "string" ? input.command : "";
+}
+function candidate_reads(raw_payload) {
+  const payload = hook_decision.parse_hook_payload(raw_payload);
+  if (payload?.tool_name !== BASH_TOOL || (payload.agent_id ?? "") !== "") return [];
+  return state_reads_of(command_of(payload.tool_input));
+}
+function last_step(tail) {
+  return time_spans.parse_timeline(tail).spans.findLast((span) => span.category !== time_spans.MODEL_CATEGORY);
+}
+function repeats_last_call(tail, reads) {
+  const last = last_step(tail);
+  if (last?.category !== time_spans.TOOL_CATEGORY) return false;
+  const last_reads = read_keys(last.josh_signatures);
+  return reads.some((key) => last_reads.includes(key));
+}
+function is_repeat(raw_payload) {
+  const reads = hook_decision.is_switch_enabled(SWITCH_ENV_KEY4) ? candidate_reads(raw_payload) : [];
+  const transcript = reads.length === 0 ? void 0 : run_watcher_hook.transcript_of(raw_payload);
+  if (transcript === void 0) return false;
+  return repeats_last_call(time_density_hook.read_tail(transcript), reads);
+}
+async function poll_reason(raw_payload, is_parent = run_headless.is_backlog_parent) {
+  if (!is_repeat(raw_payload)) return void 0;
+  return await is_parent() ? POLL_REASON : void 0;
+}
+async function safe_poll_reason(raw_payload) {
+  try {
+    return await poll_reason(raw_payload);
+  } catch (error) {
+    error_text.trace_swallowed("run_poll_hook.poll_reason", error);
+    return void 0;
+  }
+}
+var run_poll_hook = {
+  POLL_REASON,
+  SWITCH_ENV_KEY: SWITCH_ENV_KEY4,
+  poll_reason,
+  safe_poll_reason
+};
+
 // scripts/hooks/step-zero-notice.ts
-import path15 from "node:path";
+import path12 from "node:path";
 var STAMP_PREFIX4 = "josh-step-zero-notice-";
 var EDIT_TOOLS3 = /* @__PURE__ */ new Set(["Edit", "Write"]);
 var PARENT_PREFIX = "..";
@@ -6866,9 +6130,9 @@ function edited_paths(tool_input) {
   );
 }
 function is_runtime_file(file_path, root) {
-  const relative = path15.relative(root, path15.resolve(root, file_path));
-  if (relative.startsWith(PARENT_PREFIX) || path15.isAbsolute(relative)) return false;
-  return !test_declared_logic.is_exempt(relative.split(path15.sep).join("/"));
+  const relative = path12.relative(root, path12.resolve(root, file_path));
+  if (relative.startsWith(PARENT_PREFIX) || path12.isAbsolute(relative)) return false;
+  return !test_declared_logic.is_exempt(relative.split(path12.sep).join("/"));
 }
 function is_candidate2(raw_payload, root) {
   const payload = hook_decision.parse_hook_payload(raw_payload);
@@ -6882,26 +6146,22 @@ function notice(raw_payload, root = process.cwd()) {
   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;
-  if (!STAMP.record(target, Date.now())) return void 0;
+  if (STAMP.last_ms(target) !== hook_decision.NEVER_MS || !STAMP.record(target, Date.now())) {
+    return void 0;
+  }
   return NOTICE;
 }
 var step_zero_notice = { NOTICE, notice, stamp_path: STAMP.path };
 
 // scripts/hooks/pretool-guard.ts
-function combine_outcomes(batch, extra_reason) {
-  if (batch.reason !== void 0) return batch;
-  if (extra_reason !== void 0) {
-    return { reason: extra_reason, notice: void 0, fault: void 0 };
-  }
-  return batch;
-}
+var CLEAR = { reason: void 0, notice: void 0, fault: void 0 };
 function is_clear(outcome) {
   return outcome.reason === void 0 && outcome.notice === void 0 && outcome.fault === void 0;
 }
-function with_duplicate_notice(combined, notice2) {
-  if (notice2 === void 0 || !is_clear(combined)) return combined;
-  return { reason: void 0, notice: notice2, fault: void 0 };
+function combine_outcomes(outcomes, rule_reason) {
+  const reason = outcomes.find((outcome) => outcome.reason !== void 0)?.reason ?? rule_reason;
+  if (reason !== void 0) return { reason, notice: void 0, fault: void 0 };
+  return outcomes.find((outcome) => !is_clear(outcome)) ?? CLEAR;
 }
 function with_step_zero_notice(outcome, raw_payload) {
   if (!is_clear(outcome)) return outcome;
@@ -6909,13 +6169,12 @@ function with_step_zero_notice(outcome, raw_payload) {
   return notice2 === void 0 ? outcome : { reason: void 0, notice: notice2, fault: void 0 };
 }
 function guard_outcome(raw_payload) {
-  const batch = batch_outcome(raw_payload);
-  const investigation = investigation_refusal(raw_payload);
-  const duplicate = duplicate_read_outcome(raw_payload);
-  const rule = delivered_rules.delivery(raw_payload);
-  const duplicate_refusal = duplicate.reason;
-  const combined = combine_outcomes(batch, investigation ?? duplicate_refusal ?? rule);
-  return with_duplicate_notice(combined, duplicate.notice);
+  const outcomes = [
+    batch_outcome(raw_payload),
+    investigation_outcome(raw_payload),
+    duplicate_read_outcome(raw_payload)
+  ];
+  return combine_outcomes(outcomes, delivered_rules.delivery(raw_payload));
 }
 function pretool_outcome(raw_payload) {
   return with_step_zero_notice(guard_outcome(raw_payload), raw_payload);
@@ -6926,7 +6185,8 @@ async function mark_phase(outcome) {
 async function async_reason(raw_payload) {
   const watcher = await run_watcher_hook.watcher_hook_reason(raw_payload);
   const cut = watcher ?? await run_parent_cut_hook.parent_cut_reason(raw_payload);
-  return cut ?? await issue_watch_hook.watch_reason();
+  const poll2 = cut ?? await run_poll_hook.safe_poll_reason(raw_payload);
+  return poll2 ?? await issue_watch_hook.watch_reason();
 }
 async function pretool_outcome_async(raw_payload) {
   const base = guard_outcome(raw_payload);
@@ -6958,38 +6218,26 @@ function foreground_rewrite(outcome, raw_payload, is_lane_child) {
     rewrite_context(lane_background.FOREGROUND_NOTE, outcome)
   );
 }
-function pipefail_rewrite(raw_payload) {
-  if (!delivered_rules.is_enabled()) return void 0;
-  const call = guarded_call(raw_payload);
-  const input = call === void 0 ? void 0 : piped_verification.pipefail_input(call);
-  const payload = json_value.parse_or_undefined(raw_payload);
-  if (input === void 0 || !json_value.is_record(payload)) return void 0;
-  return { payload: JSON.stringify({ ...payload, tool_input: input }), input };
-}
-function pipefail_envelope(outcome, input) {
-  if (input === void 0 || outcome.reason !== void 0) return void 0;
-  return hook_decision.rewrite_envelope(
-    input,
-    rewrite_context(piped_verification.PIPEFAIL_NOTE, outcome)
-  );
+function rule_envelope(outcome, rewrite3) {
+  if (rewrite3 === void 0 || outcome.reason !== void 0) return void 0;
+  return hook_decision.flow_rewrite_envelope(rewrite3.input, rewrite_context(rewrite3.note, outcome));
 }
-function emit(raw_payload, outcome, pipefail_input2) {
-  const rewrite = pipefail_envelope(outcome, pipefail_input2) ?? foreground_rewrite(outcome, raw_payload);
-  if (rewrite === void 0) hook_decision.emit_outcome(outcome);
-  else process.stdout.write(`${rewrite}
+function emit(raw_payload, outcome, rewrite3) {
+  const envelope = rule_envelope(outcome, rewrite3) ?? foreground_rewrite(outcome, raw_payload);
+  if (envelope === void 0) hook_decision.emit_outcome(outcome);
+  else process.stdout.write(`${envelope}
 `);
 }
 async function respond(raw_payload) {
-  const pipefail = pipefail_rewrite(raw_payload);
-  const judged = pipefail?.payload ?? raw_payload;
-  emit(judged, await pretool_outcome_async(judged), pipefail?.input);
+  const rewrite3 = rule_rewrite.rewrite(raw_payload);
+  const judged = rewrite3?.payload ?? raw_payload;
+  emit(judged, await pretool_outcome_async(judged), rewrite3);
 }
 var pretool_guard = {
   combine_outcomes,
   emit,
   foreground_rewrite,
   mark_phase,
-  pipefail_rewrite,
   pretool_outcome,
   respond
 };