@joshuafolkken/kit 1.1455.0 → 1.1471.0

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

@@ -1,6 +1,6 @@
 import {
   duplicate_read_outcome
-} from "./chunk-HFGWYGUV.js";
+} from "./chunk-YYPI7SJZ.js";
 import {
   ALREADY_DONE_LABEL,
   CONTEXT_CUT_THRESHOLD,
@@ -29,7 +29,7 @@ import {
   session_cite,
   shell_segments,
   tail_commands
-} from "./chunk-7WQBPLUN.js";
+} from "./chunk-43ZHT22P.js";
 import {
   ancestor_directories,
   find_local_bin_upwards,
@@ -50,25 +50,25 @@ import {
   run_event_stream_emit,
   run_headless,
   session_language
-} from "./chunk-Z4XI7CZS.js";
+} from "./chunk-EUMACUK2.js";
 import {
   error_text
 } from "./chunk-CDY4NFQG.js";
 import {
   batch_outcome
-} from "./chunk-5H4SSDSD.js";
+} from "./chunk-YHBZAJSV.js";
 import {
-  investigation_refusal
-} from "./chunk-D5QBTOCZ.js";
+  investigation_outcome
+} from "./chunk-K4LMBQC2.js";
 import {
   investigation_reads
-} from "./chunk-WNLVGT7E.js";
+} from "./chunk-H5HVWYXK.js";
 import {
   lane_guard_policy
-} from "./chunk-UT7YC3N2.js";
+} from "./chunk-SHGPANFB.js";
 import {
   hook_decision
-} from "./chunk-GPLGZ6IC.js";
+} from "./chunk-J47HU5H5.js";
 import {
   cost_attribute,
   cost_blocks,
@@ -76,25 +76,27 @@ import {
   time_batch_guard,
   time_density_hook,
   time_shell
-} from "./chunk-LIAFCXL7.js";
+} from "./chunk-AS74OU3D.js";
 import {
   lane_child_marker
-} from "./chunk-OLMO72ON.js";
+} from "./chunk-K4EOONYM.js";
 import {
   GIT_LOCATION_VARIABLES,
   PORCELAIN_FLAG,
+  UNTRACKED_FILES_FLAG,
   cli_flags,
   cost_transcript,
   cost_usage,
   file_reader,
   git_command,
+  git_diff_reads,
   git_spawn_sync,
   issue_number_shape,
   json_value,
   lane_paths,
   own_session,
   run_carry
-} from "./chunk-3C4XRYG6.js";
+} from "./chunk-E7OIKX5Z.js";
 import {
   PLATFORM_TEMP_ROOT,
   PROBE_TIMEOUT_MS,
@@ -162,9 +164,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));
@@ -176,16 +178,16 @@ async function read_snapshot(request2, body, etag) {
   return comments === void 0 ? UNREADABLE2 : { kind: "read", snapshot: { body, comments }, etag };
 }
 async function fetch_issue(request2) {
-  const read2 = await git_gh_conditional.read_conditional(
+  const read3 = await git_gh_conditional.read_conditional(
     git_gh_api_path.issue_api_path(request2.issue),
     request2.etag,
     request2.timeout_ms
   );
-  if (read2.kind !== "changed") return read2;
-  const fields = json_value.parse_with(read2.body, issue_schema);
+  if (read3.kind !== "changed") return read3;
+  const fields = json_value.parse_with(read3.body, issue_schema);
   if (fields === void 0) return UNREADABLE2;
   if (fields.state === CLOSED_STATE) return { kind: "closed" };
-  return await read_snapshot(request2, fields.body ?? "", read2.etag);
+  return await read_snapshot(request2, fields.body ?? "", read3.etag);
 }
 function fresh_record(issue, fetched, now, acknowledged_at = now.toISOString()) {
   const baseline = issue_watch_diff.baseline_of(fetched.snapshot);
@@ -204,44 +206,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 +446,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 +463,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 +492,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 {
@@ -541,7 +543,7 @@ async function mark_implement(directory = process.cwd(), source = process.env) {
 var lane_phase = { mark_implement };
 
 // 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);
 }
@@ -900,7 +902,7 @@ function decide(call, run2, can_record) {
   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,7 +1000,7 @@ 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 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 ROW2 = {
   id: "file-body",
   is_trigger: bash_triggers.on_bash_command((command) => carries_a_file_body(command)),
@@ -1109,7 +1111,7 @@ 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 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 ROW3 = {
   id: "git-force",
   is_trigger: bash_triggers.on_bash_command(is_force_or_delete),
@@ -1162,8 +1164,9 @@ function measurement_from(content, target, thread_id) {
     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;
+  if (session === void 0 || usages.length === 0 || !same_project(session.payload.cwd, target)) {
+    return void 0;
+  }
   return { billed_input_per_request: billed_per_request(usages) };
 }
 function rollout_files(home, thread_id) {
@@ -1234,8 +1237,8 @@ function owner_sets(corpus, meta) {
 }
 function pairs_with_inherited(session, inherited, is_delegated) {
   return cost_attribute.group_by_issue(session.records).flatMap(
-    (group) => group.records.map((record) => ({
-      record,
+    (group) => group.records.map((record2) => ({
+      record: record2,
       issue: group.issue === cost_attribute.UNATTRIBUTED_KEY ? inherited : group.issue,
       baseline_tokens: session.baseline_tokens,
       session_id: session.session_id,
@@ -1354,8 +1357,7 @@ 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;
+  if (raw === void 0 || raw.trim() === "") return void 0;
   const parsed = Number(raw);
   return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
 }
@@ -1400,7 +1402,7 @@ function provider_of(environment) {
 function measurement_of(session) {
   return {
     billed_input_per_request: session.records.map(
-      (record) => cost_usage.billed_input(record.totals)
+      (record2) => cost_usage.billed_input(record2.totals)
     )
   };
 }
@@ -1508,8 +1510,71 @@ var cost_format = {
   format_share
 };
 
-// scripts/rules/implementation-cut-verdict.ts
+// scripts/run/cut/run-cut-decline.ts
 import { z as z5 } from "zod";
+var DECLINE_PREFIX = "josh-run-cut-decline-";
+var decline_schema = z5.object({ issue: z5.string(), hold_taken_at: z5.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(read3 = read_tree_sync) {
+  const tree = read3();
+  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 z6 } from "zod";
 var VERDICT_CACHE_PREFIX = "josh-impl-cut-verdict-";
 var VERDICT_REUSE_MS = 5e3;
 var VERDICT_VALUES = [
@@ -1517,7 +1582,7 @@ var VERDICT_VALUES = [
   "under",
   "unmeasurable"
 ];
-var cache_schema = z5.object({ read_at_ms: z5.number(), verdict: z5.enum(VERDICT_VALUES) });
+var cache_schema = z6.object({ read_at_ms: z6.number(), verdict: z6.enum(VERDICT_VALUES) });
 function cache_path(directory) {
   return stamp_file.stamp_path(VERDICT_CACHE_PREFIX, directory);
 }
@@ -1528,11 +1593,11 @@ function cached_verdict(target, now_ms) {
   if (cached === void 0) return void 0;
   return now_ms - cached.read_at_ms < VERDICT_REUSE_MS ? cached.verdict : void 0;
 }
-function reused_verdict(read2, directory = process.cwd(), now_ms = Date.now()) {
+function reused_verdict(read3, directory = process.cwd(), now_ms = Date.now()) {
   const target = cache_path(directory);
   const cached = cached_verdict(target, now_ms);
   if (cached !== void 0) return cached;
-  const value = read2();
+  const value = read3();
   stamp_file.replace_stamp(target, { read_at_ms: now_ms, verdict: value });
   return value;
 }
@@ -1555,6 +1620,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 +1632,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,11 +1659,13 @@ 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;
@@ -1607,7 +1678,12 @@ var ROW4 = {
   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,
@@ -1665,10 +1741,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,7 +1815,7 @@ 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 ISSUE_COMMENTS_REASON = "\u26D4 issue comments: pnpm josh issue:read <N>\nRun 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 `gh api repos/{owner}/{repo}/issues/<N>/comments` beside the body (`.claude/skills/workflow-commands/issue-comments.md`).";
 var ROW5 = {
   id: "issue-comments",
   is_trigger: bash_triggers.on_bash_command(is_body_only_issue_read),
@@ -1768,7 +1844,7 @@ 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 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 ROW6 = {
   id: "josh-git-bare",
   is_trigger: bash_triggers.on_bash_command(is_bare_josh_git),
@@ -1801,7 +1877,7 @@ 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 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 ROW7 = {
   id: "lane-carry-conflict",
   is_trigger: bash_triggers.on_bash_command(is_carry_conflict),
@@ -1816,20 +1892,20 @@ var lane_carry_conflict = {
 };
 
 // scripts/agent/interactive-ask.ts
-import { z as z6 } from "zod";
+import { z as z7 } 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 OPTION_SCHEMA = z7.looseObject({ label: z7.string().optional() });
+var QUESTION_SCHEMA = z7.looseObject({
+  question: z7.string().optional(),
+  options: z7.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 ASK_INPUT_SCHEMA = z7.looseObject({ questions: z7.array(QUESTION_SCHEMA).optional() });
+var DENIAL_SCHEMA = z7.looseObject({
+  tool_name: z7.string().optional(),
+  tool_input: z7.unknown().optional()
 });
 var UNKNOWN_QUESTION = "(question text unavailable)";
 var OPTION_SEPARATOR = " / ";
@@ -1862,7 +1938,7 @@ function is_interactive_ask(call, is_lane_child = lane_child_marker.is_child_of(
   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 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 ROW8 = {
   id: "lane-interactive-ask",
   is_trigger: is_interactive_ask,
@@ -1918,7 +1994,7 @@ function decide3(_call, run2) {
   const commands = tail_commands.prior_bash_commands(time_density_hook.read_tail(run2.transcript));
   return issue !== void 0 && promoted_issues(commands).has(issue);
 }
-var LANE_SPLIT_PARK_REASON = '\u26D4 lane split park: this session is a dispatched lane child that promoted its own Issue to an epic this run, and a split is not a park \u2014 do not apply `needs-decision` to the promoted epic and do not send a `confirmation` Telegram. The parent reads an open Issue carrying `epic` as a split and continues through its children; a question here has nobody to answer it (joshuafolkken/kit#3296, measured 2026-10-06 when the child for #3255 parked its promoted epic). If what remains of the original work needs a person, park that child issue instead, then end the turn. The procedure is `.claude/skills/workflow-commands/backlogrun-park.md` \u2192 "Splitting a child mid-run". This rule fires on every occurrence, not once per run.';
+var 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 ROW9 = {
   id: "lane-split-park",
   is_trigger: bash_triggers.on_bash_command(is_candidate),
@@ -1944,8 +2020,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,7 +2036,7 @@ 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 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 ROW10 = {
   id: "lane-switch-main",
   is_trigger: bash_triggers.on_bash_command(is_switch_away_from_lane),
@@ -2471,7 +2548,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,12 +2614,14 @@ 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 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 ROW11 = {
   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 };
 
@@ -2666,7 +2745,7 @@ 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 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 ROW13 = {
   id: "worktree-mutation",
   is_trigger: bash_triggers.on_bash_command(is_unauthorized_worktree_change),
@@ -2702,7 +2781,7 @@ 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 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 ROW14 = {
   id: "index-mutation",
   is_trigger: bash_triggers.on_bash_command(is_index_mutation),
@@ -2722,20 +2801,20 @@ import path4 from "node:path";
 var KIT_PACKAGE_NAME = "@joshuafolkken/kit";
 
 // scripts/doctor/doctor-consumer.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var NODE_MODULES = "node_modules";
 var SETTINGS_PATH = path4.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 manifest_schema = z8.object({
+  name: z8.string().optional(),
+  dependencies: z8.record(z8.string(), z8.string()).optional(),
+  devDependencies: z8.record(z8.string(), z8.string()).optional()
 });
-var settings_schema = z7.object({
-  enabledPlugins: z7.record(z7.string(), z7.boolean()).optional()
+var settings_schema = z8.object({
+  enabledPlugins: z8.record(z8.string(), z8.boolean()).optional()
 });
 var STATE_OK = "ok";
 var STATE_TARGET_MISSING = "target-missing";
@@ -2898,12 +2977,14 @@ function is_consumer_settings_edit(call, is_kit_consumer2) {
 function is_protected_file_call(call, is_kit_consumer2 = doctor_consumer.is_kit_consumer) {
   return is_environment_read(call) || is_consumer_settings_edit(call, is_kit_consumer2);
 }
-var PROTECTED_FILE_REASON = '\u26D4 protected file: `.env` holds the Telegram bot token, 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 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 ROW15 = {
   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 };
 
@@ -2940,7 +3021,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 +3034,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 PIPEFAIL_OPEN = "(set -o pipefail; ";
+var PIPEFAIL_CLOSE = ")";
+var COMMENT_START = /(?:^|\s)#/u;
 var FULL_READING_FILTER = /^(?:tail|grep)\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 +3053,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,7 +3123,7 @@ 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 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 ROW16 = {
   id: "poll-loop",
   is_trigger: bash_triggers.on_bash_command(is_poll_loop),
@@ -3063,8 +3173,7 @@ function dispatched_issue(state) {
 }
 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;
+  if (issue === void 0 || dispatched_issue(state) !== issue) return void 0;
   return state.carried()?.issue === issue ? void 0 : issue;
 }
 function warrants_the_cut2(verdict) {
@@ -3074,7 +3183,7 @@ 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.";
+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. Issue `pnpm josh run:cut <N>`: on `cut`, end the turn immediately \u2014 no Telegram is owed; on any other verdict (`not-a-lane`, `busy`, \u2026), reissue the gate \u2014 this fires once per run (`.claude/skills/workflow-commands/pre-gate-cut.md`).";
 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));
@@ -3095,7 +3204,7 @@ 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 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 ROW17 = {
   id: "raw-field-body",
   is_trigger: bash_triggers.on_bash_command(posts_at_path_literally),
@@ -3129,10 +3238,10 @@ function string_field2(input, key) {
 function read_existing(file_path) {
   return file_reader.read_file_or_empty(file_path);
 }
-function texts_of(name, input, read2) {
+function texts_of(name, input, read3) {
   if (name === WRITE_TOOL) {
     return {
-      old_text: read2(string_field2(input, "file_path")),
+      old_text: read3(string_field2(input, "file_path")),
       new_text: string_field2(input, "content")
     };
   }
@@ -3148,13 +3257,13 @@ function rule_document_input(call) {
   if (!is_edit_tool2(call.name) || !json_value.is_record(call.input)) return void 0;
   return is_rule_document(string_field2(call.input, "file_path")) ? call.input : void 0;
 }
-function writes_rule_prose(call, read2 = read_existing) {
+function writes_rule_prose(call, read3 = read_existing) {
   const input = rule_document_input(call);
   if (input === void 0) return false;
-  const { old_text, new_text } = texts_of(call.name, input, read2);
+  const { old_text, new_text } = texts_of(call.name, input, read3);
   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"])
@@ -3250,7 +3359,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,
@@ -3283,9 +3392,9 @@ import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync5 }
 import path12 from "node:path";
 
 // scripts/safe-chain/pack-hook.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var PACK_HOOK_FILE = ".pnpmfile.mjs";
-var manifest_schema2 = z8.looseObject({ private: z8.boolean().optional() });
+var manifest_schema2 = z9.looseObject({ private: z9.boolean().optional() });
 var MESSAGES = {
   written: `  \u2714 synced    ${PACK_HOOK_FILE} (run \`pnpm install\` to refresh pnpmfileChecksum)`,
   unchanged: `  \u2714 unchanged ${PACK_HOOK_FILE}`,
@@ -3321,15 +3430,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 z10 } from "zod";
+var workspace_age_schema = z10.object({ minimumReleaseAge: z10.number().int().nonnegative() });
+var release_times_schema = z10.record(z10.string(), z10.string());
 
 // scripts/safe-chain/project-config.ts
 import { dump } from "js-yaml";
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var PROJECT_CONFIG_FILE = ".aikido";
-var workspace_schema = z10.object({ minimumReleaseAgeExclude: z10.array(z10.string()).optional() });
+var workspace_schema = z11.object({ minimumReleaseAgeExclude: z11.array(z11.string()).optional() });
 
 // scripts/config-merge/json-format.ts
 var PRINT_WIDTH = 100;
@@ -3518,8 +3627,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 };
@@ -4272,11 +4382,11 @@ 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 { z as z12 } 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 = z12.object({
+  peerDependencies: z12.record(z12.string(), z12.string()).default({}),
+  devDependencies: z12.record(z12.string(), z12.string())
 });
 function read_kit_manifest() {
   const content = readFileSync3(package_path(PACKAGE_JSON), "utf8");
@@ -5133,8 +5243,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 z13 } from "zod";
+var task_array_schema = z13.array(json_object_schema);
 
 // scripts/init/init-actions.ts
 var BASIC_PRETTIER_CONFIG = "prettier.config.mjs";
@@ -5461,7 +5571,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 z14 } from "zod";
 var PACKAGE_JSON2 = "package.json";
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -5496,7 +5606,7 @@ 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 = z14.record(z14.string(), z14.unknown());
 function project_root(directory) {
   return ancestor_directories.nearest(
     directory,
@@ -5709,7 +5819,7 @@ 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 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 ROW19 = { id: "test-declared", is_trigger: is_untested_commit, reason: REASON };
 var test_declared_commit = { REASON, ROW: ROW19 };
 
@@ -5748,7 +5858,7 @@ 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 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 ROW20 = {
   id: "third-party-write",
   is_trigger: bash_triggers.on_bash_command((command) => writes_third_party(command)),
@@ -5949,8 +6059,8 @@ function format_holder(issue, repo, ages) {
 function format_holders(issues, repo, ages) {
   return issues.map((issue) => format_holder(issue, repo, ages)).join(", ");
 }
-function occupied_lanes(read2) {
-  return read2.kind === "busy" ? read2.issues.length : 0;
+function occupied_lanes(read3) {
+  return read3.kind === "busy" ? read3.issues.length : 0;
 }
 function occupancy_message(issues, repo, limit, ages = NO_AGES) {
   return `${String(issues.length)} of ${String(limit)} lanes in use in ${repo}: ${format_holders(issues, repo, ages)}.`;
@@ -5968,18 +6078,18 @@ var BUSY_REASONS = {
   unreadable: unreadable_message,
   truncated: truncated_message
 };
-function busy_reason(read2, repo, limit, ages = NO_AGES) {
-  if (read2.kind === "busy") return lanes_full_message(read2.issues, repo, limit, ages);
-  if (read2.kind === "idle") return "";
-  return BUSY_REASONS[read2.kind](repo);
+function busy_reason(read3, repo, limit, ages = NO_AGES) {
+  if (read3.kind === "busy") return lanes_full_message(read3.issues, repo, limit, ages);
+  if (read3.kind === "idle") return "";
+  return BUSY_REASONS[read3.kind](repo);
 }
 function is_parked(issue) {
   return has_any_label(issue.labels, PARKED_LABELS);
 }
 function parse_listing(raw, is_capped) {
-  const read2 = read_json_listing(raw, open_issue_schema);
-  if (read2.kind !== "read") return { kind: "unreadable" };
-  const holders = read2.rows.filter((row) => !is_parked(row));
+  const read3 = read_json_listing(raw, open_issue_schema);
+  if (read3.kind !== "read") return { kind: "unreadable" };
+  const holders = read3.rows.filter((row) => !is_parked(row));
   if (holders.length > 0) return { kind: "busy", issues: holders };
   return { kind: is_capped ? "truncated" : "idle" };
 }
@@ -6011,24 +6121,24 @@ import path14 from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 
 // scripts/agent/agent-event.ts
-import { z as z15 } from "zod";
+import { z as z16 } 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()
+import { z as z15 } from "zod";
+var RESULT_EVENT_SCHEMA = z15.looseObject({
+  type: z15.literal("result"),
+  is_error: z15.unknown().optional(),
+  subtype: z15.unknown().optional(),
+  num_turns: z15.unknown().optional(),
+  permission_denials: z15.unknown().optional(),
+  result: z15.unknown().optional(),
+  session_id: z15.unknown().optional(),
+  usage: z15.unknown().optional()
 });
-var USAGE_SCHEMA = z14.looseObject({
-  input_tokens: z14.unknown().optional(),
-  cache_read_input_tokens: z14.unknown().optional(),
-  output_tokens: z14.unknown().optional()
+var USAGE_SCHEMA = z15.looseObject({
+  input_tokens: z15.unknown().optional(),
+  cache_read_input_tokens: z15.unknown().optional(),
+  output_tokens: z15.unknown().optional()
 });
 function usable_reason(value) {
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
@@ -6067,31 +6177,31 @@ function decode(value) {
 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"),
+var TEXT_BLOCK_SCHEMA = z16.looseObject({ type: z16.literal("text"), text: z16.string() });
+var CLAUDE_MESSAGE_SCHEMA = z16.looseObject({ content: z16.array(z16.unknown()).optional() });
+var CLAUDE_INIT_SCHEMA = z16.looseObject({ type: z16.literal("system"), subtype: z16.literal("init") });
+var CLAUDE_ASSISTANT_SCHEMA = z16.looseObject({
+  type: z16.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 USAGE_SCHEMA2 = z16.looseObject({
+  input_tokens: z16.number().optional(),
+  cached_input_tokens: z16.number().optional(),
+  output_tokens: z16.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_START_SCHEMA = z16.looseObject({ type: z16.enum(["thread.started", "turn.started"]) });
+var CODEX_PROGRESS_SCHEMA = z16.looseObject({
+  type: z16.enum(["item.started", "item.updated", "item.completed"]),
+  item: z16.looseObject({ type: z16.string(), text: z16.string().optional() }).optional()
 });
-var CODEX_COMPLETE_SCHEMA = z15.looseObject({
-  type: z15.literal("turn.completed"),
+var CODEX_COMPLETE_SCHEMA = z16.looseObject({
+  type: z16.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 CODEX_FAILURE_SCHEMA = z16.looseObject({
+  type: z16.enum(["turn.failed", "error"]),
+  error: z16.looseObject({ message: z16.string().optional() }).optional(),
+  message: z16.string().optional()
 });
 var EMPTY_STATE = {
   provider: void 0,
@@ -6169,7 +6279,7 @@ function next_state2(line, state) {
   if (is_header) return EMPTY_STATE;
   return normalized(json_value.parse_or_undefined(line), state);
 }
-function read(transcript) {
+function read2(transcript) {
   let state = EMPTY_STATE;
   for (const line of transcript.split("\n")) state = next_state2(line, state);
   return state;
@@ -6179,10 +6289,10 @@ function describe(state) {
   const reason = state.reason === void 0 ? "" : ` reason=${state.reason}`;
   return `launch=${state.launch} result=${state.result}${progress}${reason}`;
 }
-var agent_event = { describe, read };
+var agent_event = { describe, read: read2 };
 
 // scripts/issue/issue-state.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var NO_LABELS = "(none)";
 var LABEL_SEPARATOR = ", ";
 var STATE_LABEL = "state: ";
@@ -6192,9 +6302,9 @@ var YES = "yes";
 var NO = "no";
 var ISSUE_LABEL = "issue: ";
 var HUMAN_REVIEW_LABELS = /* @__PURE__ */ new Set([NEEDS_HUMAN_REVIEW_LABEL]);
-var label_schema = z16.looseObject({ name: z16.string() });
-var issue_state_schema = z16.looseObject({
-  state: z16.string(),
+var label_schema = z17.looseObject({ name: z17.string() });
+var issue_state_schema = z17.looseObject({
+  state: z17.string(),
   labels: label_schema.array().optional()
 });
 function parse_issue_state(json) {
@@ -6462,7 +6572,7 @@ var lane_report = {
 };
 
 // scripts/run/run-preflight.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var CLEAN_VERDICT = "clean";
 var RECLAIM_VERDICT = "reclaim";
 var RESUME_VERDICT = "resume";
@@ -6472,7 +6582,7 @@ var OPEN_PR = "open";
 var MERGED_PR = "merged";
 var CLOSED_PR = "closed";
 var NO_CHILD_WORK = { branch_name: void 0, pr_state: NO_PR };
-var pr_info_schema = z17.object({ state: z17.string().optional() });
+var pr_info_schema = z18.object({ state: z18.string().optional() });
 var GH_PR_STATES = /* @__PURE__ */ new Map([
   ["CLOSED", CLOSED_PR],
   ["MERGED", MERGED_PR],
@@ -6577,8 +6687,8 @@ 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));
+  const decided = reads.find((read3) => is_pr_decided(read3.pr_state));
+  const open = reads.find((read3) => is_pr_open(read3.pr_state));
   return decided ?? open ?? { branch_name: reads[0]?.branch_name, pr_state: NO_PR };
 }
 var ISSUE_BRANCH_SUFFIX = "-*";
@@ -6617,8 +6727,7 @@ async function is_held_dirty(name, lane) {
 }
 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;
+  if (state.pr_state !== NO_PR || 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) {
@@ -6633,7 +6742,7 @@ async function read_child_state(issue) {
       async ([name, references]) => await read_candidate(name, references, { base, lane })
     )
   );
-  return pick_child_state(reads.filter((read2) => read2 !== void 0));
+  return pick_child_state(reads.filter((read3) => read3 !== void 0));
 }
 async function check3(issue) {
   require_issue_number(issue);
@@ -6680,10 +6789,10 @@ async function to_child(issue) {
   return { issue: number, title: issue.title, labels: to_labels(issue), pr_state: child.pr_state };
 }
 async function read_children(repo) {
-  const read2 = await epic_busy.read_repository(repo);
-  if (read2.kind === "idle") return [];
-  if (read2.kind !== "busy") return void 0;
-  return await Promise.all(read2.issues.map(async (issue) => await to_child(issue)));
+  const read3 = await epic_busy.read_repository(repo);
+  if (read3.kind === "idle") return [];
+  if (read3.kind !== "busy") return void 0;
+  return await Promise.all(read3.issues.map(async (issue) => await to_child(issue)));
 }
 async function read_lanes() {
   const lanes = await lane_registry.list_lanes();
@@ -6697,11 +6806,11 @@ function read_record_age(paths, now_ms) {
   if (times.length === 0) return void 0;
   return now_ms - Math.max(...times);
 }
-function is_hold_present(read2) {
-  return read2.kind === "held" || read2.kind === "stale";
+function is_hold_present(read3) {
+  return read3.kind === "held" || read3.kind === "stale";
 }
-function is_carry_present(read2) {
-  return read2.kind === "carried";
+function is_carry_present(read3) {
+  return read3.kind === "carried";
 }
 function hold_present(worktree) {
   return worktree !== void 0 && is_hold_present(run_hold.read_hold(run_hold.hold_path(worktree)));
@@ -6745,7 +6854,7 @@ var run_progress_read = {
 };
 
 // scripts/run/run-watcher-hook.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // scripts/run/run-watcher-guard.ts
 var WATCHER_TICK_MS = 3e4;
@@ -6760,8 +6869,9 @@ async function owes_watcher() {
   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;
+  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 = {
@@ -6773,7 +6883,7 @@ var run_watcher_guard = {
 // 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 = z19.object({ transcript_path: z19.string().min(1) });
 function transcript_of(raw_payload) {
   return json_value.parse_with(raw_payload, payload_schema)?.transcript_path;
 }
@@ -6810,7 +6920,7 @@ function current_state3() {
   };
 }
 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;
@@ -6882,26 +6992,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 +7015,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);
@@ -6968,7 +7073,7 @@ function pipefail_rewrite(raw_payload) {
 }
 function pipefail_envelope(outcome, input) {
   if (input === void 0 || outcome.reason !== void 0) return void 0;
-  return hook_decision.rewrite_envelope(
+  return hook_decision.flow_rewrite_envelope(
     input,
     rewrite_context(piped_verification.PIPEFAIL_NOTE, outcome)
   );