@joshuafolkken/kit 1.1514.0 → 1.1784.0

package/dist/hooks/chunk-O2YBIDSI.js

@@ -0,0 +1,4306 @@
+import {
+  CONTEXT_CUT_THRESHOLD,
+  bash_triggers,
+  cost_cli,
+  cost_verdict,
+  doctor_consumer,
+  epic_busy,
+  filing_cap,
+  git_argv,
+  hook_decision,
+  interactive_ask,
+  lane_background,
+  lane_park,
+  pre_gate_cut,
+  project_checks,
+  repo_party,
+  run_cut,
+  run_cut_handoff,
+  run_liveness,
+  run_stage,
+  run_tail_rule,
+  shell_segments,
+  tail_commands
+} from "./chunk-CWMBGKYW.js";
+import {
+  core_weights,
+  cost_blocks,
+  time_batch_guard,
+  time_bundle_call,
+  time_density_hook,
+  time_hook_transcript,
+  time_shell,
+  time_spans
+} from "./chunk-PT5R6UJD.js";
+import {
+  agent_role_profile,
+  agent_session_role,
+  issue_watch,
+  issue_watch_gate,
+  lane_child_marker,
+  lane_registry,
+  run_headless,
+  run_hold,
+  run_preflight
+} from "./chunk-YCDOIR3I.js";
+import {
+  PACKAGE_JSON,
+  PORCELAIN_FLAG,
+  UNTRACKED_FILES_FLAG,
+  ancestor_directories,
+  cost_transcript,
+  figure_format,
+  file_reader,
+  git_command,
+  git_common_directory,
+  git_diff_reads,
+  git_spawn_sync,
+  issue_cite,
+  issue_number_shape,
+  json_value,
+  lane_paths,
+  package_manifest,
+  run_carry,
+  run_event_scope,
+  run_event_stream,
+  run_event_stream_emit,
+  session_cite
+} from "./chunk-WR2KQAYZ.js";
+import {
+  MS_PER_MINUTE,
+  MS_PER_SECOND,
+  error_text,
+  platform_temporary,
+  stamp_file
+} from "./chunk-AZX4FGQ3.js";
+
+// scripts/delegation/duplicate-read-guard.ts
+import { statSync } from "node:fs";
+
+// scripts/lane/lane-guard-policy.ts
+var DEFAULT_MODE = "refuse";
+var OFF_MODE = "off";
+var LANE_GUARD_POLICY = [
+  {
+    id: "investigation",
+    mode_in_lane_child: "refuse",
+    because: "the notice was measured not to move the reading \u2014 52% of lane cost stayed in main-line exploration \u2014 and the refusal fires once per accumulation, a round trip the child survives as it survives the rule row, so the child is refused like the main line"
+  },
+  {
+    id: "batching",
+    mode_in_lane_child: "off",
+    because: "a refusal ends a child turn and every advisory notice was measured not to move the call density, so the guard is off and the density stays readable through `josh time:density`"
+  },
+  {
+    id: "duplicate-read",
+    mode_in_lane_child: "notice",
+    because: "a refusal ends a child turn, yet unchanged re-reads are measured in lane children above all, so the child is nudged to scroll up to the earlier read by a notice rather than killed"
+  },
+  {
+    id: "rule",
+    mode_in_lane_child: "refuse",
+    because: "it carries the lane-only rules a child depends on (`pre-gate-cut`, `implementation-cut`, `lane-park`) and the safety rules it must still obey, and a notice was rejected despite the collateral a refusal costs a batched sibling, because a cut carried as prose was measured never to fire"
+  }
+];
+var KNOWN_GUARD_IDS = LANE_GUARD_POLICY.map((entry) => entry.id);
+function entry_for(id) {
+  return LANE_GUARD_POLICY.find((entry) => entry.id === id.trim());
+}
+function mode_in_lane_child(id) {
+  return entry_for(id)?.mode_in_lane_child ?? DEFAULT_MODE;
+}
+function mode_here(id, directory = process.cwd(), source = process.env) {
+  const lane_mode = mode_in_lane_child(id);
+  if (lane_mode === DEFAULT_MODE) return DEFAULT_MODE;
+  return lane_child_marker.is_child_of(directory, source) ? lane_mode : DEFAULT_MODE;
+}
+function is_suppressed_here(id, directory = process.cwd(), source = process.env) {
+  return mode_here(id, directory, source) === OFF_MODE;
+}
+var lane_guard_policy = {
+  LANE_GUARD_POLICY,
+  KNOWN_GUARD_IDS,
+  entry_for,
+  mode_in_lane_child,
+  mode_here,
+  is_suppressed_here
+};
+
+// scripts/delegation/investigation-reads.ts
+import path2 from "node:path";
+
+// scripts/document/capped-print-part.ts
+import path from "node:path";
+var DIRECTORY_PREFIX = "josh-capped-print-";
+var PART_PREFIX = "part-";
+var PART_SUFFIX = ".md";
+var PART_PATTERN = /^part-[1-9]\d*\.md$/u;
+function part_name(index) {
+  return `${PART_PREFIX}${String(index + 1)}${PART_SUFFIX}`;
+}
+function is_part_file(absolute) {
+  const parent = path.basename(path.dirname(absolute));
+  return parent.startsWith(DIRECTORY_PREFIX) && PART_PATTERN.test(path.basename(absolute));
+}
+var capped_print_part = { DIRECTORY_PREFIX, part_name, is_part_file };
+
+// scripts/delegation/delegation-policy.ts
+var DELEGATE_VERDICT = "delegate";
+var KEEP_VERDICT = "keep";
+var INVESTIGATION_FILE_THRESHOLD = 3;
+var INVESTIGATION_SEARCH_TURN_THRESHOLD = 3;
+var INVESTIGATOR_AGENT = "investigator";
+var INVESTIGATION_LIMIT = `${String(INVESTIGATION_FILE_THRESHOLD)} files read and not edited, or ${String(INVESTIGATION_SEARCH_TURN_THRESHOLD)} search turns, since the last delegated unit`;
+var INVESTIGATION_STEP = `Dispatch the \`${INVESTIGATOR_AGENT}\` agent (\`kit:${INVESTIGATOR_AGENT}\` in a consumer); it returns \`file:line\` citations, never the file text.`;
+var DELEGATABLE_STEPS = [
+  {
+    name: "gate-fix",
+    does: "apply the fixes the verification gate already named \u2014 a lint rule, a type error, a spelling the dictionary rejects",
+    verifier: "`pnpm josh gate` is re-run; a wrong fix fails it again, and the failure names the file"
+  },
+  {
+    name: "epic-child",
+    // One row, two entry points: an epic's child and one named issue of a `backlogrun` are the same
+    // unit — same brief, same summary, same verifier. A second row for the batch would be the clone
+    // `CLAUDE.md` prohibits.
+    does: "run one child of a batch end to end in an isolated unit \u2014 an epic's child or one named issue of a `backlogrun` alike \u2014 plan, verification gate, PR, merge \u2014 and return only its summary to the parent loop",
+    verifier: "the parent reads the child's state from GitHub with `pnpm josh issue:state`, not from the summary; a child reported done but not merged is still open, which is the failure showing rather than a run continuing, and its own gate, `/code-review` and CI ran inside the unit before `followup` would touch the PR"
+  },
+  {
+    name: "followup-filing",
+    // The late-run follow-up filing chain — `issue:file` (which scouts, lints, labels and runs
+    // epic:bundle itself) → epic --add — is a dependency chain the batching guard
+    // correctly keeps one call per step, and what makes it expensive is the ~340k context it runs in
+    // at the tail of a run, not the step count. A fresh unit runs the same
+    // chain at a small context, and the review round cap already composed the finding text, so what
+    // the unit is handed is mechanical: run the commands and act on their deterministic answers. This
+    // is not the batching guard's business — delegation only moves the chain to a cheaper context.
+    does: "run the late-run follow-up filing chain in an isolated unit \u2014 issue:file (scout, lint, labels, epic:bundle), then epic --add \u2014 given the finding text the parent already composed, and return the new Issue number and the epic:bundle answer",
+    verifier: "the parent reads the filed Issue from GitHub with `pnpm josh issue:state <new>`, not the unit's summary; a follow-up reported filed but not created is still absent, the way `epic-child`'s reported-done-but-not-merged child is still open. The finding text came from the parent and `issue:file`'s steps are deterministic, so the unit's work is the mechanical execution `issue:state` confirms"
+  },
+  {
+    name: "implementation-unit",
+    // The Step 0 change list already decided *what* to change — that design stays in the main line,
+    // which is why `design` is rejected below. What is delegated is the *writing* of one unit of that
+    // list, and only a unit whose files are disjoint from every other dispatched unit: two subagents
+    // editing one file in parallel race on it. `pnpm josh fanout` confirms that disjointness
+    // mechanically, so the split is read off the file sets rather than judged.
+    does: "implement one file-disjoint unit of the Step 0 change list in an isolated subagent \u2014 the files it edits shared with no other dispatched unit, confirmed by `pnpm josh fanout` \u2014 and return the edited files, never a summary standing in for the diff; the main line keeps integration and the verification gate. Units that share a file, or an Issue that will not split, stay serial",
+    verifier: "the parent runs the whole integrated change through `pnpm josh gate` and a `/code-review` subagent it would run anyway \u2014 a unit's mistake fails the same gate and review a serial edit passes through, so delegating writes nothing the backstop does not already catch, and the `pnpm josh fanout` disjointness removes the one failure parallelism adds, two units colliding on a file"
+  },
+  {
+    name: "survey",
+    does: "read across many files and report where something appears \u2014 every reference to a symbol, which documents carry a marker",
+    verifier: "the reported locations are checked directly; a fabricated or missed location does not survive one `grep` of what it claimed"
+  },
+  {
+    name: "investigation",
+    // Not `survey`: that row reports *where* something appears and is checked by one `grep`, while
+    // this one reports *how the subject works* and is checked by opening the lines it cited. The two
+    // verifiers differ, so widening `survey` would put both in one field and lose the boundary below.
+    // **No ordinal.** `${N}rd` would print `1rd` for any other threshold, past a test that only looks
+    // for the numeral, so the count is phrased as a plain "N or more".
+    does: `read the Issue's subject to find out how it currently works \u2014 once ${String(INVESTIGATION_FILE_THRESHOLD)} or more files the run will not edit have to be read, or ${String(INVESTIGATION_SEARCH_TURN_THRESHOLD)} or more search turns run without an edit \u2014 and return the conclusion plus the \`file:line\` citations that support it, never the file text, which would put the cost back where it was. A throwaway probe script is written, run and deleted inside the unit, which returns its output alone`,
+    verifier: "the parent opens the cited lines; a conclusion those lines do not support fails there, and reading a handful of cited regions costs far less than redoing the reading. The unit reports what the code does and never what to change \u2014 deciding that is `diagnosis`, which stays kept, so a unit returning a root cause would be delegating the rejected row under this name"
+  },
+  {
+    name: "lane-failure-investigation",
+    // The `backlogrun` parent's counterpart of `investigation`. The parent
+    // orchestrates and never implements, yet it read a failed lane's logs, records and sources in its
+    // own context — about 150 grep / cat / sed calls on 2026-10-02 — and every later request of the
+    // batch re-read them. The verifier is `investigation`'s, and so is the boundary: the unit reports
+    // what happened, and what the parent does about it (park, re-dispatch, file) stays its own call.
+    does: "find out why a lane's child stopped, failed or conflicted \u2014 its output log, run records, PR checks and the files they name \u2014 and return the conclusion plus the `file:line` or log-line citations that support it, never the text read, so the batch parent's context stays the size its orchestration needs",
+    verifier: "the parent opens the cited lines and re-reads the child with `pnpm josh issue:state`; a conclusion those do not support fails there. The unit reports what happened and never what to do \u2014 parking, re-dispatching or filing stays with the parent, so a wrong account is caught before it is acted on"
+  }
+];
+var REJECTED_STEPS = [
+  {
+    name: "notify-body",
+    because: "no verifier. A notification with a wrong body is sent and read as though it were right; nothing in the run disagrees with it afterwards"
+  },
+  {
+    name: "issue-comment",
+    because: "no verifier. A decision log or completion comment that says the wrong thing is the record, so there is nothing left to check it against"
+  },
+  {
+    name: "status-read",
+    because: "a misread routes the run to the wrong child, and no later step disagrees. Running the status command is already cheap; what is expensive is acting on it, which is not this step"
+  },
+  {
+    name: "diagnosis",
+    because: "a wrong root cause produces a fix that passes the gate and leaves the defect"
+  },
+  {
+    name: "design",
+    because: "the cost of a wrong design is paid by every step after it"
+  },
+  {
+    name: "split-assessment",
+    because: "a missed split widens one Issue into a batch nobody authorized"
+  },
+  {
+    name: "review",
+    because: "the review is the last thing between a defect and a merge; a cheaper one finds less"
+  }
+];
+function find_step(name) {
+  return DELEGATABLE_STEPS.find((step) => step.name === name.trim());
+}
+function verdict_for(name) {
+  return find_step(name) === void 0 ? KEEP_VERDICT : DELEGATE_VERDICT;
+}
+function rejection_for(name) {
+  return REJECTED_STEPS.find((step) => step.name === name.trim());
+}
+function reason_for(name) {
+  const step = find_step(name);
+  if (step !== void 0) return `delegatable: ${step.verifier}`;
+  const rejected = rejection_for(name);
+  if (rejected !== void 0) return `kept deliberately: ${rejected.because}`;
+  return "kept by default: not on the delegatable list, and the list is the whole of it";
+}
+var delegation_policy = {
+  DELEGATE_VERDICT,
+  INVESTIGATION_FILE_THRESHOLD,
+  INVESTIGATION_LIMIT,
+  INVESTIGATION_SEARCH_TURN_THRESHOLD,
+  INVESTIGATION_STEP,
+  INVESTIGATOR_AGENT,
+  KEEP_VERDICT,
+  DELEGATABLE_STEPS,
+  REJECTED_STEPS,
+  find_step,
+  verdict_for,
+  reason_for
+};
+
+// scripts/delegation/investigation-reads.ts
+var READ_TOOLS = /* @__PURE__ */ new Set(["Read"]);
+var DELEGATION_TOOLS = /* @__PURE__ */ new Set(["Agent", "Task"]);
+var CONTENT_READ_COMMANDS = [
+  "bat",
+  "cat",
+  "head",
+  "less",
+  "more",
+  "nl",
+  "sed",
+  "tail"
+];
+var CONTENT_READ_LABELS = new Set(
+  CONTENT_READ_COMMANDS.map((command) => time_shell.bash_label(command))
+);
+var SEARCH_COMMANDS = ["fd", "find", "grep", "rg"];
+var SEARCH_LABELS = new Set(
+  SEARCH_COMMANDS.map((command) => time_shell.bash_label(command))
+);
+var { INVESTIGATOR_AGENT: INVESTIGATOR_AGENT2 } = delegation_policy;
+var REASON = `\u26D4 investigation: ${delegation_policy.INVESTIGATION_LIMIT}. ${delegation_policy.INVESTIGATION_STEP} Keep main-line reads to files you will edit; every read-only search turn counts. \`.claude/skills/workflow-commands/delegation.md\``;
+var INSTRUCTION_PATHS = ["prompts", ".claude/skills"];
+var INSTRUCTION_FILES = /* @__PURE__ */ new Set(["CLAUDE.md", "AGENTS.md", "GEMINI.md"]);
+var REPOSITORY_ROOT = process.cwd();
+function resolved(target) {
+  return path2.resolve(REPOSITORY_ROOT, target);
+}
+function repository_relative(absolute) {
+  return path2.relative(REPOSITORY_ROOT, absolute);
+}
+function is_instruction_document(target) {
+  const relative = repository_relative(resolved(target));
+  const segments = relative.split(path2.sep);
+  return INSTRUCTION_FILES.has(segments.at(-1) ?? "") || INSTRUCTION_PATHS.some((prefix) => relative.startsWith(`${prefix}${path2.sep}`));
+}
+var SESSION_TEMP_SEGMENT = /^claude-\d+$/u;
+var SESSION_STATE_SEGMENTS = cost_transcript.TRANSCRIPT_ROOT.split(path2.sep);
+var HARNESS_OUTPUT_DIRECTORY = "tasks";
+var HARNESS_OUTPUT_EXTENSION = ".output";
+var FILE_SEGMENT_INDEX = -1;
+var PARENT_SEGMENT_INDEX = -2;
+function has_state_root(segments, index) {
+  return SESSION_STATE_SEGMENTS.every((segment, offset) => segments[index + offset] === segment);
+}
+function is_harness_output(segments) {
+  return segments.some((segment) => SESSION_TEMP_SEGMENT.test(segment)) && segments.at(PARENT_SEGMENT_INDEX) === HARNESS_OUTPUT_DIRECTORY && (segments.at(FILE_SEGMENT_INDEX) ?? "").endsWith(HARNESS_OUTPUT_EXTENSION);
+}
+function is_outside_repository(absolute) {
+  return repository_relative(absolute).startsWith("..");
+}
+function is_session_artifact(target) {
+  const absolute = resolved(target);
+  const segments = absolute.split(path2.sep);
+  if (!is_outside_repository(absolute)) return false;
+  return segments.some((_segment, index) => has_state_root(segments, index)) || is_harness_output(segments) || capped_print_part.is_part_file(absolute);
+}
+function is_subject_file(target) {
+  return !is_instruction_document(target) && !is_session_artifact(target);
+}
+function is_nameable_file(target) {
+  return !target.includes("*") && !target.includes("?");
+}
+function is_content_read(label) {
+  return READ_TOOLS.has(label) || CONTENT_READ_LABELS.has(label);
+}
+function subject_targets(targets) {
+  return targets.filter((target) => is_nameable_file(target) && is_subject_file(target)).map((target) => resolved(target));
+}
+function call_targets(call) {
+  return subject_targets(time_bundle_call.call_facts(call.name, call.input).targets);
+}
+function delegation_instant(span) {
+  return span === void 0 ? hook_decision.NEVER_MS : span.ended_ms;
+}
+function is_failed_outcome(span) {
+  return span.outcome === time_spans.FAILED_OUTCOME;
+}
+function edited_files(spans) {
+  const written = spans.filter((span) => !is_failed_outcome(span)).flatMap((span) => subject_targets(span.writes));
+  return new Set(written);
+}
+function add_all(pending, targets, at_ms) {
+  for (const target of targets) if (!pending.has(target)) pending.set(target, at_ms);
+}
+function is_read_only_search(span) {
+  return SEARCH_LABELS.has(span.label) && span.is_bundleable && !span.may_write;
+}
+function search_turn_key(searches, span) {
+  if (span.message_id !== time_spans.NO_MESSAGE_ID) return span.message_id;
+  return `${time_spans.NO_MESSAGE_ID}#${String(searches.size)}`;
+}
+function apply_search(searches, span) {
+  if (span.is_writing) {
+    searches.clear();
+    return;
+  }
+  const turn = search_turn_key(searches, span);
+  if (is_read_only_search(span) && !searches.has(turn)) searches.set(turn, span.ended_ms);
+}
+function apply_span(accumulation, span, edited) {
+  if (DELEGATION_TOOLS.has(span.label)) {
+    accumulation.pending.clear();
+    accumulation.searches.clear();
+    return;
+  }
+  if (is_failed_outcome(span)) return;
+  apply_search(accumulation.searches, span);
+  if (!is_content_read(span.label)) return;
+  const fresh = subject_targets(span.targets).filter((target) => !edited.has(target));
+  add_all(accumulation.pending, fresh, span.ended_ms);
+}
+function last_delegation_ms(spans) {
+  return delegation_instant(spans.findLast((span) => DELEGATION_TOOLS.has(span.label)));
+}
+function pending_after(pending, since_ms) {
+  return [...pending.values()].filter((at_ms) => at_ms > since_ms).length;
+}
+function tally_of(text, since_ms = hook_decision.NEVER_MS) {
+  const { spans, started_ms } = time_spans.parse_timeline(text);
+  const edited = edited_files(spans);
+  const accumulation = { pending: /* @__PURE__ */ new Map(), searches: /* @__PURE__ */ new Map() };
+  for (const span of spans) apply_span(accumulation, span, edited);
+  return {
+    pending: [...accumulation.pending.keys()],
+    pending_since: pending_after(accumulation.pending, since_ms),
+    reset_ms: last_delegation_ms(spans),
+    window_start_ms: started_ms,
+    searches: accumulation.searches.size,
+    searches_since: pending_after(accumulation.searches, since_ms),
+    edited
+  };
+}
+function projected_count(pending, call, edited = /* @__PURE__ */ new Set()) {
+  return (/* @__PURE__ */ new Set([...pending, ...call_targets(call).filter((target) => !edited.has(target))])).size;
+}
+function is_at_threshold(pending_count) {
+  return pending_count + 1 >= delegation_policy.INVESTIGATION_FILE_THRESHOLD;
+}
+function is_at_search_threshold(search_count) {
+  return search_count + 1 >= delegation_policy.INVESTIGATION_SEARCH_TURN_THRESHOLD;
+}
+function has_cleared_the_disarm(tally, refused_at_ms) {
+  return tally.reset_ms > refused_at_ms || refused_at_ms < tally.window_start_ms;
+}
+function is_rearmed(tally, refused_at_ms) {
+  if (refused_at_ms === hook_decision.NEVER_MS || has_cleared_the_disarm(tally, refused_at_ms)) {
+    return true;
+  }
+  return is_at_threshold(tally.pending_since) || is_at_search_threshold(tally.searches_since);
+}
+function is_unit_transcript(transcript) {
+  return transcript.split(path2.sep).includes(cost_transcript.UNIT_DIRECTORY);
+}
+function is_unit_run(run) {
+  return run !== void 0 && is_unit_transcript(run.transcript);
+}
+function is_read_only_command(call, labels) {
+  if (call.name !== cost_blocks.BASH_TOOL) return false;
+  const label = time_shell.bash_label(time_shell.bash_command(call.input));
+  return labels.has(label) && time_batch_guard.is_read_only_call(call);
+}
+function is_search_call(call) {
+  return is_read_only_command(call, SEARCH_LABELS);
+}
+function is_refusable_call(call) {
+  if (is_search_call(call)) return true;
+  if (call_targets(call).length === 0) return false;
+  if (READ_TOOLS.has(call.name)) return true;
+  return is_read_only_command(call, CONTENT_READ_LABELS);
+}
+function is_growing_past_threshold(tally, call) {
+  if (is_search_call(call)) return is_at_search_threshold(tally.searches);
+  if (!is_at_threshold(tally.pending.length)) return false;
+  return projected_count(tally.pending, call, tally.edited) > tally.pending.length;
+}
+function should_block(text, call, refused_at_ms, run) {
+  if (!is_refusable_call(call) || is_unit_run(run)) return false;
+  const tally = tally_of(text, refused_at_ms);
+  return is_growing_past_threshold(tally, call) && is_rearmed(tally, refused_at_ms);
+}
+var investigation_reads = {
+  DELEGATION_TOOLS,
+  INVESTIGATOR_AGENT: INVESTIGATOR_AGENT2,
+  READ_TOOLS,
+  REASON,
+  is_at_threshold,
+  is_instruction_document,
+  is_rearmed,
+  is_refusable_call,
+  is_session_artifact,
+  is_subject_file,
+  projected_count,
+  resolved,
+  should_block,
+  tally_of
+};
+
+// scripts/delegation/duplicate-read-guard.ts
+var SWITCH_ENV_KEY = "JOSH_DUPLICATE_READ_GUARD";
+var LANE_GUARD_ID = "duplicate-read";
+var STAMP_PREFIX = "josh-duplicate-read-guard-";
+var NOTICE_STAMP_PREFIX = "josh-duplicate-read-notice-";
+var READ_TOOL = "Read";
+var GLOB_CHARACTERS = /[*?]/u;
+var REASON2 = `\u26D4 duplicate read: this file was already read in this session and has not changed since (its mtime predates that read), so reading it again returns nothing new. Scroll up to the earlier result instead of re-reading it. A read with a new offset/limit, or of a file that has since changed, is allowed; set \`JOSH_DUPLICATE_READ_GUARD=off\` to disable this guard.`;
+var NOTICE = `\u26A0 duplicate read: this file was already read in this session and has not changed since, so re-reading it returns nothing new \u2014 scroll up to the earlier result instead of re-reading it. Set \`JOSH_DUPLICATE_READ_GUARD=off\` to silence this.`;
+function is_paginated(input) {
+  return input["offset"] !== void 0 || input["limit"] !== void 0;
+}
+function names_one_file(file_path) {
+  return typeof file_path === "string" && file_path !== "" && !GLOB_CHARACTERS.test(file_path);
+}
+function read_target(call) {
+  if (call.name !== READ_TOOL || !json_value.is_record(call.input)) return void 0;
+  const { input } = call;
+  if (is_paginated(input) || !names_one_file(input["file_path"])) return void 0;
+  return investigation_reads.resolved(input["file_path"]);
+}
+function is_refusable_call2(call) {
+  return read_target(call) !== void 0;
+}
+function is_successful_read(span) {
+  const is_read2 = investigation_reads.READ_TOOLS.has(span.label);
+  return is_read2 && span.outcome !== time_spans.FAILED_OUTCOME;
+}
+function reads_target(span, target) {
+  return span.targets.some((one) => investigation_reads.resolved(one) === target);
+}
+function last_read_ms(spans, target) {
+  const times = spans.filter((span) => is_successful_read(span) && reads_target(span, target)).map((span) => span.ended_ms);
+  return times.length === 0 ? hook_decision.NEVER_MS : Math.max(...times);
+}
+function file_mtime_ms(target) {
+  try {
+    return statSync(target).mtimeMs;
+  } catch {
+    return void 0;
+  }
+}
+function read_window(tail, target) {
+  const { spans, started_ms } = time_spans.parse_timeline(tail);
+  return { last_ms: last_read_ms(spans, target), window_start_ms: started_ms };
+}
+function is_unchanged_reread(last_ms, mtime) {
+  if (mtime === void 0 || last_ms === hook_decision.NEVER_MS) return false;
+  return mtime < last_ms;
+}
+function is_rearmed2(window, fired_at_ms) {
+  if (fired_at_ms === hook_decision.NEVER_MS || fired_at_ms < window.window_start_ms) return true;
+  return window.last_ms > fired_at_ms;
+}
+function is_redundant_reread(tail, call, fired_at_ms) {
+  const target = read_target(call);
+  if (target === void 0) return false;
+  const window = read_window(tail, target);
+  if (!is_unchanged_reread(window.last_ms, file_mtime_ms(target))) return false;
+  return is_rearmed2(window, fired_at_ms);
+}
+function duplicate_mode() {
+  return lane_guard_policy.mode_here(LANE_GUARD_ID);
+}
+function is_candidate(call) {
+  return is_refusable_call2(call) && duplicate_mode() !== "off";
+}
+function should_block_here(tail, call, refused_at_ms) {
+  if (duplicate_mode() !== "refuse") return false;
+  return is_redundant_reread(tail, call, refused_at_ms);
+}
+function should_notify_here(tail, call, notified_at_ms) {
+  if (duplicate_mode() !== "notice") return false;
+  return is_redundant_reread(tail, call, notified_at_ms);
+}
+var GUARD = hook_decision.create_transcript_guard({
+  prefix: STAMP_PREFIX,
+  switch_key: SWITCH_ENV_KEY,
+  is_candidate,
+  should_block: should_block_here,
+  reason: REASON2,
+  notify: {
+    prefix: NOTICE_STAMP_PREFIX,
+    should_notify: should_notify_here,
+    text: () => NOTICE
+  }
+});
+var duplicate_read_refusal = GUARD.refusal;
+var duplicate_read_outcome = GUARD.outcome;
+var { is_enabled, refusal_path } = GUARD;
+var notice_refusal_path = hook_decision.create_refusal_stamp(NOTICE_STAMP_PREFIX).path;
+var { deny_envelope, DISABLED_VALUES } = hook_decision;
+
+// scripts/delegation/investigation-guard.ts
+var SWITCH_ENV_KEY2 = "JOSH_INVESTIGATION_GUARD";
+var STAMP_PREFIX2 = "josh-investigation-guard-";
+function should_block2(tail, call, refused_at_ms, run) {
+  if (agent_session_role.is_reviewer() || lane_guard_policy.mode_here("investigation") !== "refuse") {
+    return false;
+  }
+  return investigation_reads.should_block(tail, call, refused_at_ms, run);
+}
+var GUARD2 = hook_decision.create_transcript_guard({
+  prefix: STAMP_PREFIX2,
+  switch_key: SWITCH_ENV_KEY2,
+  is_candidate: investigation_reads.is_refusable_call,
+  should_block: should_block2,
+  reason: investigation_reads.REASON
+});
+var investigation_refusal = GUARD2.refusal;
+var investigation_outcome = GUARD2.outcome;
+var { is_enabled: is_enabled2, refusal_path: refusal_path2 } = GUARD2;
+var { deny_envelope: deny_envelope2, load_environment_file, DISABLED_VALUES: DISABLED_VALUES2 } = hook_decision;
+
+// scripts/issue/issue-watch-hook.ts
+var POLL_INTERVAL_MS = 18e4;
+var POLL_TIMEOUT_MS = 5e3;
+function is_new_to_run(record2) {
+  return record2?.pending !== void 0 && record2.pending !== record2.shown;
+}
+async function new_update_reason(now) {
+  const record2 = await issue_watch.poll({
+    interval_ms: POLL_INTERVAL_MS,
+    timeout_ms: POLL_TIMEOUT_MS,
+    now
+  });
+  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 {
+    return await new_update_reason(now);
+  } catch (error) {
+    error_text.trace_swallowed("issue_watch_hook.watch_reason", error);
+    return void 0;
+  }
+}
+var issue_watch_hook = { POLL_INTERVAL_MS, watch_reason };
+
+// scripts/run/event/run-event-plan.ts
+var KIND = run_event_stream.EVENT_KIND.PLAN;
+var PLAN_VERB = "planned";
+function plan_text(issue) {
+  return `${PLAN_VERB} ${issue_cite.plain(issue)}`;
+}
+function has_plan(events, issue) {
+  return run_event_scope.since_own_launch(events, issue).some((event) => event.kind === KIND && run_event_scope.issue_named(event) === issue);
+}
+async function emit_plan(issue) {
+  if (has_plan(await run_event_stream_emit.invocation_or_all_events(), issue)) return;
+  await run_event_stream_emit.emit(KIND, plan_text(issue));
+}
+var run_event_plan = { emit_plan, plan_text };
+
+// scripts/lane/lane-phase.ts
+async function mark_implement(directory = process.cwd(), source = process.env) {
+  const issue = lane_child_marker.marked_issue(source);
+  if (issue === void 0 || !lane_child_marker.is_child_of(directory, source)) return;
+  await run_event_plan.emit_plan(issue);
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.LANE_PHASE,
+    `${issue_cite.plain(issue)} implement`
+  );
+}
+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,
+  about: {
+    title: "Subagent model named",
+    topic: '`.claude/skills/workflow-commands/delegation.md` \u2192 "A `general-purpose` subagent names its model"',
+    fires: "an `Agent` / `Task` call of the `general-purpose` type with no `model`. Every occurrence",
+    quiet: "a named agent type, or a `model` set"
+  }
+};
+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>`, 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 ROW2 = {
+  id: "direct-filing",
+  is_trigger: bash_triggers.on_bash_command(bash_triggers.is_direct_filing),
+  reason: DIRECT_FILING_REASON,
+  decide: () => true,
+  keeps: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
+  reaches: bash_triggers.on_bash_command(is_any_filing),
+  about: {
+    title: "Direct filing",
+    topic: "`docs/josh-commands-backlog.md` \u2192 `josh issue:file`",
+    fires: "a `Bash` that creates an Issue outside `josh issue:file` (`gh issue create`, or a POST with `title` to `\u2026/issues`); the refusal hands over the `pnpm josh issue:file` form. Every occurrence",
+    quiet: "filing through `pnpm josh issue:file` \u2014 the duplicate scan, the body check and `epic:bundle` all run"
+  }
+};
+var direct_filing = { DIRECT_FILING_REASON, ROW: ROW2 };
+
+// scripts/rules/gh-api.ts
+var GH_FLAGS = String.raw`(?:-{1,2}[\w-]+(?:[= ][^\s]+)?\s+)*`;
+var GH_API_COMMAND = new RegExp(String.raw`^gh\s+${GH_FLAGS}api\s`, "u");
+var API_METHOD = /(?:^|\s)(?:--method|-X)[= ]([A-Za-z]+)/u;
+var API_FIELD = /(?:^|\s)(?:--raw-field|--field|--input|-F|-f)(?:[= ]|$)/u;
+var READ_METHOD = "GET";
+var REPO_PATH = /repos\/([^/\s'"?]+)\/([^/\s'"?]+)/u;
+var OWNER_GROUP = 1;
+var REPO_GROUP = 2;
+var OWNER_PLACEHOLDERS = /* @__PURE__ */ new Set(["{owner}", ":owner"]);
+function is_gh_api(segment) {
+  return GH_API_COMMAND.test(segment);
+}
+function method_of(segment) {
+  return API_METHOD.exec(segment)?.[1]?.toUpperCase();
+}
+function is_read(segment) {
+  const method = method_of(segment);
+  if (method !== void 0) return method.toUpperCase() === READ_METHOD;
+  return !API_FIELD.test(segment);
+}
+function is_write(segment) {
+  return !is_read(segment);
+}
+function repo_target(segment) {
+  const match = REPO_PATH.exec(segment);
+  if (match === null) return void 0;
+  return { owner: match[OWNER_GROUP] ?? "", repo: match[REPO_GROUP] ?? "" };
+}
+function is_owner_placeholder(owner) {
+  return OWNER_PLACEHOLDERS.has(owner);
+}
+var gh_api = {
+  GH_FLAGS,
+  is_gh_api,
+  is_owner_placeholder,
+  is_read,
+  is_write,
+  method_of,
+  repo_target
+};
+
+// scripts/rules/direct-pr-create.ts
+var GH_COMMAND = "gh";
+var PR_GROUP = "pr";
+var PR_CREATE_ACTIONS = /* @__PURE__ */ new Set(["create", "new"]);
+var FLAG_PREFIX = "-";
+var HELP_FLAGS = /* @__PURE__ */ new Set(["-h", "--help"]);
+var VALUE_TAKING_FLAGS = /* @__PURE__ */ new Set(["-R", "--repo"]);
+var API_VALUE_TAKING_FLAGS = /* @__PURE__ */ new Set([
+  ...VALUE_TAKING_FLAGS,
+  "-X",
+  "--method",
+  "-f",
+  "--raw-field",
+  "-F",
+  "--field",
+  "-H",
+  "--header",
+  "--input",
+  "-q",
+  "--jq",
+  "-t",
+  "--template",
+  "--hostname",
+  "-p",
+  "--preview",
+  "--cache"
+]);
+var API_SUBCOMMAND = "api";
+var PULLS_PATH = /^['"]?(?:https:\/\/api\.github\.com)?\/?repos\/[^/\s'"]+\/[^/\s'"]+\/pulls\/?['"]?$/u;
+function positional_words(args, value_taking_flags) {
+  return args.filter((argument, index) => {
+    if (argument.startsWith(FLAG_PREFIX)) return false;
+    return !value_taking_flags.has(args[index - 1] ?? "");
+  });
+}
+function is_pr_create_api_call(args) {
+  const call = [GH_COMMAND, ...args].join(" ");
+  if (!gh_api.is_gh_api(call) || !gh_api.is_write(call)) return false;
+  const [subcommand, endpoint = ""] = positional_words(args, API_VALUE_TAKING_FLAGS);
+  return subcommand === API_SUBCOMMAND && PULLS_PATH.test(endpoint);
+}
+function is_pr_create_cli_call(args) {
+  const [group, action = ""] = positional_words(args, VALUE_TAKING_FLAGS);
+  return group === PR_GROUP && PR_CREATE_ACTIONS.has(action);
+}
+function is_help_call(args) {
+  return args.some(
+    (argument, index) => HELP_FLAGS.has(argument) && !(args[index - 1] ?? "").startsWith(FLAG_PREFIX)
+  );
+}
+function is_pr_create_segment(segment) {
+  const args = git_argv.arguments_of(segment, GH_COMMAND);
+  if (args === void 0 || is_help_call(args)) return false;
+  return is_pr_create_cli_call(args) || is_pr_create_api_call(args);
+}
+var RUNS_QUOTED_TEXT = /\$\(|`/u;
+var QUOTED_TEXT_RUNNERS = /* @__PURE__ */ new Set(["ssh", "eval"]);
+var SHELL_DASH_C = /\b(?:ba|da|k|z)?sh\s+(?:-\S+\s+)*-[A-Za-z]*c\b/u;
+var COMMENT_MARKER = /(?:^|\s)#/mu;
+var LINE_BREAK = "\n";
+function is_run_by_shell(segment) {
+  if (RUNS_QUOTED_TEXT.test(segment) || SHELL_DASH_C.test(segment)) return true;
+  return QUOTED_TEXT_RUNNERS.has(git_argv.program_of(segment)?.name ?? "");
+}
+function is_runs_quoted_text(segment) {
+  if (is_run_by_shell(segment)) return true;
+  return segment.includes(LINE_BREAK) && COMMENT_MARKER.test(segment);
+}
+function judged_segments(segment) {
+  return is_runs_quoted_text(segment) ? shell_segments.commands_of(segment) : [segment];
+}
+function has_run_segment(command, is_match) {
+  return shell_segments.quote_aware_commands_of(command).flatMap((segment) => judged_segments(segment)).some((segment) => is_match(segment));
+}
+function is_direct_pr_create(command) {
+  return has_run_segment(command, is_pr_create_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 ROW3 = {
+  id: "direct-pr-create",
+  is_trigger: bash_triggers.on_bash_command(is_direct_pr_create),
+  reason: DIRECT_PR_CREATE_REASON,
+  decide: () => true,
+  about: {
+    title: "Direct PR creation",
+    topic: "`CLAUDE.md` \u2192 Git Rules",
+    fires: "`gh pr create`, or a `gh api` write to `repos/<o>/<r>/pulls`; it points at `pnpm josh pr`. Every occurrence",
+    quiet: "`pnpm josh pr`, or reading a PR \u2014 the path that writes `closes #N`"
+  }
+};
+var direct_pr_create = {
+  API_VALUE_TAKING_FLAGS,
+  DIRECT_PR_CREATE_REASON,
+  GH_COMMAND,
+  ROW: ROW3,
+  VALUE_TAKING_FLAGS,
+  has_run_segment,
+  is_direct_pr_create,
+  is_help_call,
+  positional_words
+};
+
+// scripts/rules/direct-issue-comment.ts
+var ISSUE_GROUP = "issue";
+var COMMENT_ACTION = "comment";
+var API_SUBCOMMAND2 = "api";
+var REPO_SELECTOR = /^(?:-R|--repo)(?:=|$)/u;
+var SEGMENT = String.raw`[^/\s'"]+`;
+var QUOTE = `['"]?`;
+var API_ORIGIN = String.raw`(?:https://api\.github\.com)?/?`;
+var COMMENTS_PATH = new RegExp(
+  `^${QUOTE}${API_ORIGIN}repos/${SEGMENT}/${SEGMENT}/issues/${SEGMENT}/comments/?${QUOTE}$`,
+  "u"
+);
+function is_comment_cli_call(args) {
+  if (args.some((argument) => REPO_SELECTOR.test(argument))) return false;
+  const [group, action] = direct_pr_create.positional_words(
+    args,
+    direct_pr_create.VALUE_TAKING_FLAGS
+  );
+  return group === ISSUE_GROUP && action === COMMENT_ACTION;
+}
+function is_own_comments_endpoint(endpoint) {
+  const owner = gh_api.repo_target(endpoint)?.owner ?? "";
+  return gh_api.is_owner_placeholder(owner) && COMMENTS_PATH.test(endpoint);
+}
+function is_comment_api_call(args) {
+  const call = [direct_pr_create.GH_COMMAND, ...args].join(" ");
+  if (!gh_api.is_gh_api(call) || !gh_api.is_write(call)) return false;
+  const [subcommand, endpoint = ""] = direct_pr_create.positional_words(
+    args,
+    direct_pr_create.API_VALUE_TAKING_FLAGS
+  );
+  return subcommand === API_SUBCOMMAND2 && is_own_comments_endpoint(endpoint);
+}
+function is_comment_segment(segment) {
+  const args = git_argv.arguments_of(segment, direct_pr_create.GH_COMMAND);
+  if (args === void 0 || direct_pr_create.is_help_call(args)) return false;
+  return is_comment_cli_call(args) || is_comment_api_call(args);
+}
+function is_direct_issue_comment(command) {
+  return direct_pr_create.has_run_segment(command, is_comment_segment);
+}
+var COMMENT_NAMES = /* @__PURE__ */ new Set(["issue:comment"]);
+function is_josh_comment(command) {
+  return shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, COMMENT_NAMES));
+}
+function is_any_comment(command) {
+  return is_direct_issue_comment(command) || is_josh_comment(command);
+}
+var DIRECT_ISSUE_COMMENT_REASON = "\u26D4 direct issue comment: `gh issue comment` (or a `gh api` write to `\u2026/issues/<N>/comments`) posts without the run marker, so the run reads its own comment as a person updating the issue \u2014 the review goes stale and `pnpm josh followup` refuses the merge. Post with `pnpm josh issue:comment <N> --body-file <path>` instead (`shell-body.md`). **This rule fires on every occurrence, not once per run.**";
+var ROW4 = {
+  id: "direct-issue-comment",
+  is_trigger: bash_triggers.on_bash_command(is_direct_issue_comment),
+  reason: DIRECT_ISSUE_COMMENT_REASON,
+  decide: () => true,
+  keeps: bash_triggers.on_bash_command(is_josh_comment),
+  reaches: bash_triggers.on_bash_command(is_any_comment),
+  about: {
+    title: "Direct issue comment",
+    topic: "`shell-body.md`",
+    fires: "a comment to the checkout's own repository outside `josh issue:comment` (`gh issue comment` with no `--repo`, or a `gh api` write to `repos/{owner}/<r>/issues/<N>/comments`); it points at `pnpm josh issue:comment`. Every occurrence",
+    quiet: "`pnpm josh issue:comment`, or reading the comments \u2014 the path that writes the run marker"
+  }
+};
+var direct_issue_comment = { DIRECT_ISSUE_COMMENT_REASON, ROW: ROW4, is_direct_issue_comment };
+
+// scripts/run/progress/run-progress.ts
+var DEFAULT_INTERVAL_MINUTES = 20;
+var INTERVAL_KEY = "JOSH_PROGRESS_INTERVAL_MINUTES";
+var DEFAULT_INTERVAL_MS = DEFAULT_INTERVAL_MINUTES * MS_PER_MINUTE;
+var DISABLED_KEY = "JOSH_PROGRESS";
+var DISABLED_VALUE = "0";
+var NO_LANES = "none";
+var NO_CHILD_YET = "no in-progress child yet";
+var NO_NEXT = "none";
+var QUIET_MARKER = "\u23F3";
+var STAMP_END = 16;
+var PAD_WIDTH = 2;
+var MINUTES_PER_HOUR = 60;
+function to_minutes(elapsed_ms) {
+  return Math.floor(elapsed_ms / MS_PER_MINUTE);
+}
+function format_minutes(elapsed_ms) {
+  return `${String(to_minutes(elapsed_ms))}m`;
+}
+function pad(value) {
+  return String(value).padStart(PAD_WIDTH, "0");
+}
+function offset_minutes(date) {
+  return Math.round(-date.getTimezoneOffset());
+}
+function format_offset(total_minutes) {
+  const sign = total_minutes < 0 ? "-" : "+";
+  const absolute = Math.abs(total_minutes);
+  return `${sign}${pad(Math.floor(absolute / MINUTES_PER_HOUR))}:${pad(absolute % MINUTES_PER_HOUR)}`;
+}
+function format_observed_at(now_ms) {
+  const minutes = offset_minutes(new Date(now_ms));
+  const local = new Date(now_ms + minutes * MS_PER_MINUTE);
+  const day = `${String(local.getUTCFullYear())}-${pad(local.getUTCMonth() + 1)}-${pad(local.getUTCDate())}`;
+  const clock = `${pad(local.getUTCHours())}:${pad(local.getUTCMinutes())}${format_offset(minutes)}`;
+  return `${day} ${clock} / ${new Date(now_ms).toISOString().slice(0, STAMP_END)}Z`;
+}
+function observation_key(observations) {
+  return JSON.stringify({ children: observations.children, lanes: observations.lanes });
+}
+function next_state(previous, key, now_ms) {
+  if (previous?.key === key) return previous;
+  return { key, unchanged_since_ms: now_ms };
+}
+function format_child(child, cite) {
+  const labels = child.labels.length > 0 ? child.labels.join(",") : "(no labels)";
+  return `${cite(child.issue)} ${labels} PR:${child.pr_state}`;
+}
+function format_children(children, repo) {
+  if (children.length === 0) return NO_CHILD_YET;
+  const cite = issue_cite.citer(repo, new Map(children.map((child) => [child.issue, child.title])));
+  return children.map((child) => format_child(child, cite)).join(" \xB7 ");
+}
+function format_lanes(lanes, repo) {
+  if (lanes.length === 0) return NO_LANES;
+  const cite = issue_cite.citer(repo, /* @__PURE__ */ new Map());
+  return lanes.map((lane) => `${cite(lane.issue)}:${lane.state}`).join(" ");
+}
+function format_record(record_age_ms) {
+  return record_age_ms === void 0 ? "unread" : `+${format_minutes(record_age_ms)}`;
+}
+function format_next_report(now_ms, interval_ms) {
+  return format_observed_at(now_ms + interval_ms);
+}
+function format_next_line(next) {
+  return `next ${next ?? NO_NEXT}`;
+}
+function format_report(fields) {
+  return [
+    `${QUIET_MARKER} at ${fields.observed_at}`,
+    `quiet ${fields.quiet} \xB7 unchanged ${fields.unchanged}`,
+    `children ${fields.children}`,
+    `lanes ${fields.lanes} \xB7 load ${fields.load} \xB7 record ${fields.record}`,
+    format_next_line(fields.next)
+  ].join("\n");
+}
+function format_line(observations, timing) {
+  return format_report({
+    observed_at: format_observed_at(timing.now_ms),
+    quiet: format_minutes(timing.now_ms - timing.quiet_since_ms),
+    unchanged: format_minutes(timing.now_ms - timing.unchanged_since_ms),
+    children: format_children(observations.children, observations.repo),
+    lanes: format_lanes(observations.lanes, observations.repo),
+    load: observations.load_average.toFixed(1),
+    record: format_record(observations.record_age_ms),
+    next: format_next_report(timing.now_ms, timing.interval_ms)
+  });
+}
+function is_due(last_report_ms, now_ms, interval_ms) {
+  return now_ms - last_report_ms >= interval_ms;
+}
+function minutes_from(raw) {
+  const minutes = Number(raw);
+  if (raw === void 0 || raw.trim() === "" || !Number.isFinite(minutes) || minutes <= 0) {
+    return void 0;
+  }
+  return minutes;
+}
+function is_disabled() {
+  return process.env[DISABLED_KEY] === DISABLED_VALUE;
+}
+var run_progress = {
+  DEFAULT_INTERVAL_MINUTES,
+  DEFAULT_INTERVAL_MS,
+  DISABLED_KEY,
+  DISABLED_VALUE,
+  INTERVAL_KEY,
+  NO_CHILD_YET,
+  NO_NEXT,
+  format_child,
+  format_children,
+  format_lanes,
+  format_line,
+  format_next_line,
+  format_next_report,
+  format_report,
+  is_disabled,
+  is_due,
+  minutes_from,
+  next_state,
+  observation_key
+};
+
+// scripts/run/progress/run-progress-clock.ts
+import { z } from "zod";
+var PROGRESS_PREFIX = "josh-run-progress-";
+var LIFE_PREFIX = "josh-run-progress-life-";
+var LOG_SUFFIX = ".log";
+var LOG_KEEP = 12;
+var LOG_STALE_MINUTES = 90;
+var LOG_STALE_MS = LOG_STALE_MINUTES * MS_PER_MINUTE;
+var BLOCK_SEPARATOR = "\n\n";
+var report_stamp_schema = z.object({ reported_at: z.string(), line: z.string().optional() });
+function parse_stamp(raw) {
+  const parsed = report_stamp_schema.safeParse(JSON.parse(raw));
+  if (!parsed.success) return void 0;
+  const reported_at = Date.parse(parsed.data.reported_at);
+  return Number.isNaN(reported_at) ? void 0 : reported_at;
+}
+function read_last_line(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return void 0;
+  return json_value.parse_with(raw, report_stamp_schema)?.line;
+}
+function read_last_report(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return void 0;
+  try {
+    return parse_stamp(raw);
+  } catch {
+    return void 0;
+  }
+}
+function log_path_of(target) {
+  return `${target}${LOG_SUFFIX}`;
+}
+function is_log_stale(target, now_ms) {
+  const previous_ms = read_last_report(target);
+  return previous_ms === void 0 || now_ms - previous_ms > LOG_STALE_MS;
+}
+function recent_blocks(log_target2, is_fresh) {
+  if (is_fresh) return [];
+  const raw = stamp_file.read_stamp_text(log_target2);
+  if (raw === void 0) return [];
+  return raw.split(BLOCK_SEPARATOR).map((block) => block.trimEnd()).filter((block) => block.length > 0);
+}
+function append_line(log_target2, reported_at, line, is_fresh) {
+  const block = `${reported_at}
+${line}`;
+  const blocks = [...recent_blocks(log_target2, is_fresh), block].slice(-LOG_KEEP);
+  stamp_file.write_text_stamp(log_target2, `${blocks.join(BLOCK_SEPARATOR)}
+`);
+}
+function mark(target, now_ms, line) {
+  const reported_at = new Date(now_ms).toISOString();
+  const kept = line ?? read_last_line(target);
+  if (line !== void 0) {
+    append_line(log_path_of(target), reported_at, line, is_log_stale(target, now_ms));
+  }
+  stamp_file.write_stamp(target, kept === void 0 ? { reported_at } : { reported_at, line: kept });
+}
+function stamp_target_of(git_directory) {
+  return stamp_file.stamp_path(PROGRESS_PREFIX, git_directory);
+}
+function life_target_of(git_directory) {
+  return stamp_file.stamp_path(LIFE_PREFIX, git_directory);
+}
+var life_schema = z.object({ alive: z.literal(true), pinged_at: z.string().optional() });
+function begin_life(target) {
+  stamp_file.write_stamp(target, { alive: true, pinged_at: (/* @__PURE__ */ new Date()).toISOString() });
+}
+function ping_life(target) {
+  begin_life(target);
+}
+function parse_pinged_at(raw) {
+  const parsed = life_schema.safeParse(JSON.parse(raw));
+  if (!parsed.success || parsed.data.pinged_at === void 0) return void 0;
+  const pinged_ms = Date.parse(parsed.data.pinged_at);
+  return Number.isNaN(pinged_ms) ? void 0 : pinged_ms;
+}
+function is_life_fresh(target, threshold_ms) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return false;
+  try {
+    const pinged_ms = parse_pinged_at(raw);
+    return pinged_ms !== void 0 && Date.now() - pinged_ms < threshold_ms;
+  } catch (error) {
+    error_text.trace_swallowed("run_progress_clock.is_life_fresh", error);
+    return false;
+  }
+}
+function is_life_ended(target) {
+  return stamp_file.read_stamp_text(target) === void 0;
+}
+function end_life(target) {
+  stamp_file.remove_stamp(target);
+}
+function stamp_target_sync() {
+  const directory = git_common_directory.own();
+  return directory === void 0 ? void 0 : stamp_target_of(directory);
+}
+function read_last_report_sync() {
+  const target = stamp_target_sync();
+  return target === void 0 ? void 0 : read_last_report(target);
+}
+var run_progress_clock = {
+  LIFE_PREFIX,
+  LOG_KEEP,
+  LOG_STALE_MS,
+  begin_life,
+  end_life,
+  is_life_ended,
+  is_life_fresh,
+  life_target_of,
+  log_path_of,
+  mark,
+  parse_stamp,
+  ping_life,
+  read_last_line,
+  read_last_report,
+  read_last_report_sync,
+  stamp_target_of
+};
+
+// scripts/run/progress/run-progress-config.ts
+import { z as z2 } from "zod";
+var package_schema = z2.object({
+  josh: z2.object({ progress_interval_minutes: z2.number().positive() }).optional()
+});
+function read_declared_minutes(directory) {
+  return package_manifest.read_manifest_if_valid(directory, package_schema)?.josh?.progress_interval_minutes;
+}
+function read_package_minutes(start) {
+  for (const directory of ancestor_directories.list(start)) {
+    const minutes = read_declared_minutes(directory);
+    if (minutes !== void 0) return minutes;
+  }
+  return void 0;
+}
+function to_ms(minutes) {
+  return minutes === void 0 ? void 0 : minutes * MS_PER_MINUTE;
+}
+function resolve_interval_ms(raw, directory = process.cwd()) {
+  return to_ms(run_progress.minutes_from(raw)) ?? to_ms(run_progress.minutes_from(process.env[run_progress.INTERVAL_KEY])) ?? to_ms(read_package_minutes(directory)) ?? run_progress.DEFAULT_INTERVAL_MS;
+}
+function configured_interval_ms(directory = process.cwd()) {
+  return resolve_interval_ms(void 0, directory);
+}
+var run_progress_config = {
+  PACKAGE_FILE: PACKAGE_JSON,
+  configured_interval_ms,
+  read_package_minutes,
+  resolve_interval_ms
+};
+
+// scripts/rules/early-heartbeat.ts
+var ARM_PREFIX = "josh-heartbeat-arm-";
+var SEGMENT_SEPARATOR = /&&|\|\||;|&|\n/u;
+var SLEEP_SEGMENT = /^sleep\s+(\d+(?:\.\d+)?)([smhd]?)$/u;
+var INERT_SEGMENT = /^(?::|true|(?:echo|printf|date)\b.*)$/u;
+var LOOP_KEYWORD = /\b(?:while|until|for|do|done)\b/u;
+var SECONDS_PER_UNIT = { d: 86400, h: 3600, m: 60, s: 1 };
+var BARE_NUMBER_SECONDS = 1;
+var AMOUNT_GROUP = 1;
+var UNIT_GROUP = 2;
+var NO_SECONDS = 0;
+var ARM_RECORD = hook_decision.create_refusal_stamp(ARM_PREFIX);
+function segments_of(command) {
+  return command.split(SEGMENT_SEPARATOR).map((segment) => segment.trim()).filter((segment) => segment !== "");
+}
+function sleep_seconds(segment) {
+  const matched = SLEEP_SEGMENT.exec(segment);
+  if (matched === null) return void 0;
+  const unit = matched[UNIT_GROUP] ?? "";
+  return Number(matched[AMOUNT_GROUP]) * (SECONDS_PER_UNIT[unit] ?? BARE_NUMBER_SECONDS);
+}
+function is_wait_or_inert(segment) {
+  return sleep_seconds(segment) !== void 0 || INERT_SEGMENT.test(segment);
+}
+function is_wait_timer(command) {
+  if (LOOP_KEYWORD.test(command)) return false;
+  const segments = segments_of(command);
+  if (segments.every((segment) => sleep_seconds(segment) === void 0)) return false;
+  return segments.every((segment) => is_wait_or_inert(segment));
+}
+function wait_duration_ms(command) {
+  const seconds = segments_of(command).reduce(
+    (total, segment) => total + (sleep_seconds(segment) ?? NO_SECONDS),
+    NO_SECONDS
+  );
+  return seconds * MS_PER_SECOND;
+}
+function is_armed(target, now_ms) {
+  return now_ms < ARM_RECORD.last_ms(target);
+}
+function landing_ms(command, now_ms, last_report_ms) {
+  const interval_ms = run_progress_config.configured_interval_ms();
+  const duration_ms = wait_duration_ms(command);
+  if (duration_ms > interval_ms) return void 0;
+  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, 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(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. 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) {
+  return shell_segments.is_josh_command(segment, PROGRESS_NAMES) && WATCH_FLAG.test(segment);
+}
+function is_progress_watch(command) {
+  return segments_of(time_shell.unquoted(command)).some(
+    (segment) => is_progress_watch_segment(segment)
+  );
+}
+function waits_for_progress(command) {
+  return is_wait_timer(command) || is_progress_watch(command);
+}
+var early_heartbeat = {
+  ARM_PREFIX,
+  EARLY_HEARTBEAT_REASON,
+  decide,
+  is_progress_watch,
+  is_wait_timer,
+  wait_duration_ms,
+  waits_for_progress
+};
+
+// scripts/rules/file-body.ts
+import { existsSync } from "node:fs";
+var HEREDOC = /(?<!<)<<(?!<)-?\s*['"]?([A-Z_a-z]\w*)/u;
+var LINE_BREAK2 = "\n";
+function has_heredoc(command) {
+  return HEREDOC.test(command);
+}
+function with_body_line(lines, line) {
+  const opener = lines.at(-1);
+  if (opener === void 0) return [...lines];
+  return [...lines.slice(0, -1), { ...opener, body: `${opener.body}${line}${LINE_BREAK2}` }];
+}
+function scan_line(scan, line) {
+  if (scan.delimiter === void 0) {
+    return { lines: [...scan.lines, { text: line, body: "" }], delimiter: HEREDOC.exec(line)?.[1] };
+  }
+  if (line.trim() === scan.delimiter) return { ...scan, delimiter: void 0 };
+  return { ...scan, lines: with_body_line(scan.lines, line) };
+}
+function command_lines(command) {
+  let scan = { lines: [], delimiter: void 0 };
+  for (const line of command.split(LINE_BREAK2)) scan = scan_line(scan, line);
+  return scan.lines;
+}
+var FILE_REDIRECT = /(?:^|\s)>>?\s*(?!&)("[^"]+"|'[^']+'|\S+)/u;
+var TEE_TARGET = /\btee\s+(?:-a\s+)?(?!-)("[^"]+"|'[^']+'|\S+)/u;
+var QUOTES = /^['"]|['"]$/gu;
+function redirect_target(line) {
+  const target = FILE_REDIRECT.exec(line)?.[1] ?? TEE_TARGET.exec(line)?.[1];
+  return target === void 0 ? void 0 : target.replaceAll(QUOTES, "");
+}
+var BODY_INTERPRETERS = /* @__PURE__ */ new Set([
+  "python",
+  "python3",
+  "ruby",
+  "perl",
+  "php",
+  "node"
+]);
+var NODE = "node";
+var NODE_EVAL = /(?:^|\s)(?:-e|--eval)\b/u;
+var WRITE_CALL = /writeFile|appendFile|createWriteStream|\.write(?:lines|_text|_bytes)?\s*\(/u;
+var WRITE_MODE = /open\s*\([^)]*['"][rbt+]*[wax]|os\.replace|shutil\.(?:copy|move)/u;
+function body_writes(body) {
+  return WRITE_CALL.test(body) || WRITE_MODE.test(body);
+}
+var SCRIPT_FILE = /\.(?:py|rb|pl|php|js|mjs|cjs)$/u;
+function is_heredoc_write(line, has_file) {
+  const target = has_heredoc(line.text) ? redirect_target(line.text) : void 0;
+  if (target === void 0) return false;
+  if (has_file(target)) return true;
+  return SCRIPT_FILE.test(target) && body_writes(line.body);
+}
+function is_interpreter_write(segment, body) {
+  const leading = time_shell.leading_word(segment);
+  if (!BODY_INTERPRETERS.has(leading)) return false;
+  if (has_heredoc(segment)) return body_writes(body);
+  return leading === NODE && NODE_EVAL.test(segment) && body_writes(segment);
+}
+var PERL = "perl";
+var PERL_IN_PLACE = /^-[A-Za-z0-9]*i/u;
+var WHITESPACE = /\s+/u;
+function is_in_place_perl(segment) {
+  if (time_shell.leading_word(segment) !== PERL) return false;
+  return segment.split(WHITESPACE).some((word) => PERL_IN_PLACE.test(word));
+}
+function has_body_interpreter(line) {
+  return shell_segments.segments_of(line.text).some((segment) => is_interpreter_write(segment, line.body) || is_in_place_perl(segment));
+}
+function carries_a_file_body(command, has_file = existsSync) {
+  return command_lines(command).some(
+    (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, 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 ROW5 = {
+  id: "file-body",
+  is_trigger: bash_triggers.on_bash_command((command) => carries_a_file_body(command)),
+  reason: FILE_BODY_REASON,
+  decide: () => true,
+  about: {
+    title: "No file body on the shell",
+    topic: "`file-edits.md`",
+    fires: "a heredoc write to an existing file, a writing `node -e` / interpreter heredoc, or `perl -0pi -e`. Every occurrence",
+    quiet: "a new file, a read-only heredoc, or a short `sed -i`"
+  }
+};
+var file_body = {
+  FILE_BODY_REASON,
+  ROW: ROW5,
+  carries_a_file_body
+};
+
+// scripts/rules/git-force.ts
+var FORCE_LONG_PREFIX = "--force";
+var DELETE_LONG = "--delete";
+var DESTRUCTIVE_PUSH_LONG = /* @__PURE__ */ new Set([DELETE_LONG, "--mirror", "--prune"]);
+var PUSH_SHORT_LETTERS = "fd";
+var FORCE_OR_DELETE_REFSPEC = /^[+:]/u;
+function is_force_or_delete_push(args) {
+  return args.some(
+    (argument) => argument.startsWith(FORCE_LONG_PREFIX) || DESTRUCTIVE_PUSH_LONG.has(argument) || git_argv.short_cluster_has(argument, PUSH_SHORT_LETTERS) || FORCE_OR_DELETE_REFSPEC.test(argument)
+  );
+}
+var BRANCH_DELETE_LETTERS = "dD";
+function is_branch_delete(args) {
+  return args.some(
+    (argument) => argument === DELETE_LONG || git_argv.short_cluster_has(argument, BRANCH_DELETE_LETTERS)
+  );
+}
+var PUSH_SUBCOMMAND = "push";
+var BRANCH_SUBCOMMAND = "branch";
+function is_destructive_segment(segment) {
+  const call = git_argv.parse(segment);
+  if (call === void 0) return false;
+  if (call.subcommand === PUSH_SUBCOMMAND) return is_force_or_delete_push(call.args);
+  return call.subcommand === BRANCH_SUBCOMMAND && is_branch_delete(call.args);
+}
+function is_force_or_delete(command) {
+  return shell_segments.commands_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. 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 ROW6 = {
+  id: "git-force",
+  is_trigger: bash_triggers.on_bash_command(is_force_or_delete),
+  reason: GIT_FORCE_REASON,
+  decide: () => true,
+  about: {
+    title: "Force push / branch delete",
+    topic: "`operating-rules.md`",
+    fires: "a `git push` / `git branch` read as force (`--force` / `-f` / `-uf` \u2026) or delete (`--delete` / `-d` / `-D` / `:branch`) in any spelling. Every occurrence",
+    quiet: "a plain `git push` / `git branch`"
+  }
+};
+var git_force = {
+  GIT_FORCE_REASON,
+  ROW: ROW6,
+  is_force_or_delete
+};
+
+// scripts/run/cut/run-cut-decline.ts
+import { z as z3 } from "zod";
+var DECLINE_PREFIX = "josh-run-cut-decline-";
+var decline_schema = z3.object({ issue: z3.string(), hold_taken_at: z3.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(request, state, code) {
+  if (request.phase !== run_cut.IMPLEMENTATION_PHASE) return code;
+  const directory = await run_cut.worktree_directory();
+  if (directory !== void 0) {
+    record(directory, { issue: request.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 z4 } from "zod";
+var VERDICT_CACHE_PREFIX = "josh-impl-cut-verdict-";
+var VERDICT_REUSE_MS = 5e3;
+var VERDICT_VALUES = [
+  "over",
+  "under",
+  "unmeasurable"
+];
+var cache_schema = z4.object({ read_at_ms: z4.number(), verdict: z4.enum(VERDICT_VALUES) });
+function cache_path(directory) {
+  return stamp_file.stamp_path(VERDICT_CACHE_PREFIX, directory);
+}
+function cached_verdict(target, now_ms) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return void 0;
+  const cached = json_value.parse_with(raw, cache_schema);
+  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()) {
+  const target = cache_path(directory);
+  const cached = cached_verdict(target, now_ms);
+  if (cached !== void 0) return cached;
+  const value = read2();
+  stamp_file.replace_stamp(target, { read_at_ms: now_ms, verdict: value });
+  return value;
+}
+var implementation_cut_verdict = {
+  VERDICT_REUSE_MS,
+  cache_path,
+  reused_verdict
+};
+
+// scripts/rules/implementation-cut.ts
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write"]);
+function is_edit_tool(name) {
+  return EDIT_TOOLS.has(name);
+}
+var CUT_COMMANDS = /* @__PURE__ */ new Set(["run:cut"]);
+var IMPL_FLAG = /(?:^|\s)--impl(?:[=\s]|$)/u;
+function is_impl_cut_segment(segment) {
+  return shell_segments.is_josh_command(segment, CUT_COMMANDS) && IMPL_FLAG.test(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(),
+    source: process.env,
+    carried: run_cut.carried_cut_sync,
+    held_issue: run_cut.held_issue_sync,
+    // **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()),
+    can_cut: can_cut_sync
+  };
+}
+function lane_child_issue(state) {
+  if (!lane_child_marker.is_child_of(state.directory, state.source)) return void 0;
+  return lane_paths.lane_issue_of(state.directory, { ...state.source });
+}
+function held_run_issue(state) {
+  if (lane_paths.lane_issue_of(state.directory, { ...state.source }) !== void 0) return void 0;
+  return state.held_issue();
+}
+function implementing_run_issue(state) {
+  if (agent_session_role.is_reviewer(state.source)) return void 0;
+  return lane_child_issue(state) ?? held_run_issue(state);
+}
+function uncut_run_issue(state) {
+  const issue = implementing_run_issue(state);
+  if (issue === void 0) return void 0;
+  return state.carried()?.issue === issue ? void 0 : issue;
+}
+function warrants_the_cut(state) {
+  const verdict = state.verdict();
+  if (lane_child_issue(state) === void 0) return verdict === cost_verdict.OVER_VERDICT;
+  return verdict !== cost_verdict.UNDER_VERDICT;
+}
+function is_over_threshold_edit(call, state = current_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 = `${figure_format.format_tokens(CONTEXT_CUT_THRESHOLD)}-token`;
+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, run, _can_record, delivered_at_ms) {
+  return !is_reissued_refusal(run.now_ms, delivered_at_ms);
+}
+var ROW7 = {
+  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),
+  // 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"
+  ],
+  about: {
+    title: "The implementation-phase cut",
+    topic: '`.claude/skills/workflow-commands/pre-gate-cut.md` \u2192 "It is a guard, fired at the edit that crosses the threshold"',
+    fires: "an `Edit` / `Write` by an uncut lane child whose recent context is over the `pnpm josh cost --cut` threshold; it hands over `pnpm josh run:cut --impl <N> --handoff <path>`. At each threshold crossing",
+    quiet: "not a lane child, a non-editing tool, already cut, or under the threshold"
+  }
+};
+var implementation_cut = {
+  IMPLEMENTATION_CUT_REASON,
+  REISSUE_WINDOW_MS,
+  ROW: ROW7,
+  decide: decide2,
+  is_over_threshold_edit,
+  is_reissued_refusal,
+  takes_the_impl_cut,
+  uncut_run_issue
+};
+
+// scripts/rules/prior-comment-read.ts
+var ISSUE_PATH_NUMBER = /issues\/(\d+)/gu;
+var ISSUE_VIEW_NUMBER = /\bissue\s+view\s+(?:-{1,2}\S+\s+)*(\d+)/u;
+var ISSUE_READ_ARGUMENTS = /\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 = /\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;
+  const tokens = (match[1] ?? "").split(/\s+/u);
+  for (const token of tokens) {
+    if (issue_number_shape.ISSUE_NUMBER_PATTERN.test(token)) numbers.add(Number(token));
+  }
+}
+function issue_numbers_of(command) {
+  const numbers = /* @__PURE__ */ new Set();
+  for (const match of command.matchAll(ISSUE_PATH_NUMBER)) numbers.add(Number(match[1]));
+  const view = ISSUE_VIEW_NUMBER.exec(command);
+  if (view !== null) numbers.add(Number(view[1]));
+  add_issue_read_numbers(command, numbers);
+  return numbers;
+}
+function fetches_comments(command) {
+  return COMMENTS_ENDPOINT.test(command) || VIEW_WITH_COMMENTS.test(command) || ISSUE_READ_COMMAND.test(command);
+}
+function reads_target_comments(command, target) {
+  if (!fetches_comments(command)) return false;
+  for (const number of issue_numbers_of(command)) {
+    if (target.has(number)) return true;
+  }
+  return false;
+}
+function already_read_comments_for(tail, command) {
+  const target = issue_numbers_of(command);
+  if (target.size === 0) return false;
+  return tail_commands.prior_bash_commands(tail).some((prior) => reads_target_comments(prior, target));
+}
+function already_read_for_call(tail, call) {
+  if (call.name !== cost_blocks.BASH_TOOL) return false;
+  return already_read_comments_for(tail, time_shell.bash_command(call.input));
+}
+var prior_comment_read = {
+  already_read_comments_for,
+  already_read_for_call,
+  fetches_comments,
+  issue_numbers_of
+};
+
+// scripts/rules/issue-comments.ts
+var ISSUE_VIEW_COMMAND = new RegExp(String.raw`^gh\s+${gh_api.GH_FLAGS}issue\s+view\s`, "u");
+var ISSUE_BODY_PATH = /repos\/[^\s'"]*\/issues\/\d+(?=$|["'\s])/u;
+var FETCHES_COMMENTS = /--comments\b|--json\s[\w,]*\bcomments\b|\/comments\b/u;
+var ISSUES_PATH = /repos\/[^\s'"]*\/issues\//u;
+var FIELD_PROJECTION = /(?:--jq|--json)[= ]\s*('[^']*'|"[^"]*"|\S+)/u;
+var NAMES_THE_BODY = /\bbody\b/u;
+function projects_away_body(segment) {
+  const projection = FIELD_PROJECTION.exec(segment);
+  return projection !== null && !NAMES_THE_BODY.test(projection[1] ?? "");
+}
+function is_body_read_segment(segment) {
+  if (projects_away_body(segment)) return false;
+  if (ISSUE_VIEW_COMMAND.test(segment)) return true;
+  return gh_api.is_gh_api(segment) && ISSUE_BODY_PATH.test(segment) && gh_api.is_read(segment);
+}
+function fetches_issue_comments(segment) {
+  if (!FETCHES_COMMENTS.test(segment)) return false;
+  return ISSUE_VIEW_COMMAND.test(segment) || gh_api.is_gh_api(segment) && ISSUES_PATH.test(segment);
+}
+function is_body_only_issue_read(command) {
+  const segments = shell_segments.segments_of(command);
+  if (segments.some((segment) => fetches_issue_comments(segment))) return false;
+  return segments.some((segment) => is_body_read_segment(segment));
+}
+function reads_issue_comments(command) {
+  return shell_segments.segments_of(command).some((segment) => fetches_issue_comments(segment));
+}
+var 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 path5 = rewritable_path(command);
+  if (path5 === void 0) return void 0;
+  return `gh api --paginate ${path5}/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 ROW8 = {
+  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"],
+  about: {
+    title: "Reading Issue comments",
+    topic: "`issue-comments.md`",
+    fires: "a `Bash` that reads only the Issue body (`gh issue view <N>`, or a GET ending in `\u2026/issues/<N>`). Refused until it is re-read with the comments",
+    quiet: "no Issue read, or a read with `--comments` / `--json comments` / `\u2026/comments` from the start"
+  }
+};
+var issue_comments = {
+  COMMENTS_NOTE,
+  ISSUE_COMMENTS_REASON,
+  ROW: ROW8,
+  comments_input,
+  is_body_only_issue_read
+};
+
+// scripts/rules/josh-git-bare.ts
+var GIT_COMMAND = /* @__PURE__ */ new Set(["git"]);
+var CONFIRM_FLAGS = /* @__PURE__ */ new Set(["-y", "--yes"]);
+function has_confirm_flag(args) {
+  return args.some((argument) => CONFIRM_FLAGS.has(argument));
+}
+function is_bare_segment(segment) {
+  if (!shell_segments.is_josh_command(segment, GIT_COMMAND)) return false;
+  return !has_confirm_flag(time_shell.josh_arguments(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. 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 ROW9 = {
+  id: "josh-git-bare",
+  is_trigger: bash_triggers.on_bash_command(is_bare_josh_git),
+  reason: JOSH_GIT_BARE_REASON,
+  decide: () => true,
+  about: {
+    title: "Bare `pnpm josh git`",
+    topic: "`CLAUDE.md` \u2192 Git Rules",
+    fires: "`pnpm josh git` without `-y`, whose staging prompt cancels with no TTY. Every occurrence",
+    quiet: "`pnpm josh git -y`"
+  }
+};
+var josh_git_bare = {
+  JOSH_GIT_BARE_REASON,
+  ROW: ROW9,
+  is_bare_josh_git
+};
+
+// scripts/rules/lane-carry-conflict.ts
+var RUN_BUDGET_COMMANDS = /* @__PURE__ */ new Set(["run:merge", "run:carry"]);
+var LEADING_ASSIGNMENT = String.raw`[A-Za-z_]\w*=(?:"[^"]*"|'[^']*'|\$\((?:[^()]|\([^()]*\))*\)|[^\s"'])*\s+`;
+var REDIRECTED_PREFIX = new RegExp(
+  String.raw`^(?:${LEADING_ASSIGNMENT})*${platform_temporary.TEMP_ROOT_KEY}=(?!""|''|\s|$|"?\$\{?[A-Za-z_])`,
+  "u"
+);
+var SHARED_STATE_COMMANDS = /* @__PURE__ */ new Set(["run:merge"]);
+var LEADING_ASSIGNMENTS = new RegExp(`^(?:${LEADING_ASSIGNMENT})*`, "u");
+function is_budget_segment(segment) {
+  const commands = REDIRECTED_PREFIX.test(segment) ? SHARED_STATE_COMMANDS : RUN_BUDGET_COMMANDS;
+  return shell_segments.is_josh_command(segment.replace(LEADING_ASSIGNMENTS, ""), commands);
+}
+function invokes_budget_command(command) {
+  return shell_segments.segments_of(command).some((segment) => is_budget_segment(segment));
+}
+function is_carry_conflict(command, is_lane_child = lane_child_marker.is_child_of(process.cwd())) {
+  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 `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 ROW10 = {
+  id: "lane-carry-conflict",
+  is_trigger: bash_triggers.on_bash_command(is_carry_conflict),
+  reason: LANE_CARRY_CONFLICT_REASON,
+  decide: () => true,
+  about: {
+    title: "Lane child carry commands",
+    topic: "`.claude/skills/workflow-commands/backlogrun-lanes.md`",
+    fires: "a dispatched lane child running `pnpm josh run:merge` / `run:carry`. Every occurrence",
+    quiet: "not a lane child \u2014 the parent owns the run budget"
+  }
+};
+var lane_carry_conflict = {
+  LANE_CARRY_CONFLICT_REASON,
+  ROW: ROW10,
+  invokes_budget_command,
+  is_carry_conflict
+};
+
+// scripts/gate/command-memory.ts
+import os from "node:os";
+var JOSH_PROGRAM = "josh";
+var RESERVED_RUN = "reserved-run";
+var COMMAND_SEPARATOR = "--";
+var ESLINT = "eslint";
+var VITEST = "vitest";
+var AUTO_WORKERS = "auto";
+var LINE_BREAK3 = "\n";
+var SHELL_HEREDOC = /\b(?:ba|z|da|k)?sh(?:\s+-\w+)*\s*<<-?\s*(['"]?)(\w+)\1/u;
+var HEREDOC_DELIMITER_GROUP = 2;
+var AUTO_CORE_SHARE = 2;
+var SINGLE_WORKER = 1;
+var WORKER_FLAGS = {
+  [ESLINT]: "--concurrency",
+  [VITEST]: "--maxWorkers"
+};
+function wrapped_command_of(call) {
+  if (call.name !== JOSH_PROGRAM || call.args[0] !== RESERVED_RUN) return void 0;
+  const separator = call.args.indexOf(COMMAND_SEPARATOR);
+  return separator === -1 ? void 0 : call.args.slice(separator + 1).join(" ");
+}
+function reading_of(segment, is_reserved) {
+  const call = git_argv.program_of(segment);
+  const wrapped2 = call === void 0 ? void 0 : wrapped_command_of(call);
+  if (wrapped2 !== void 0) return { line: wrapped2, is_reserved: true };
+  const script = bash_triggers.shell_script_of(segment);
+  if (script !== void 0) return { line: script, is_reserved };
+  return call === void 0 ? void 0 : { ...call, is_reserved };
+}
+function body_until(lines, delimiter) {
+  const end = lines.findIndex((body_line) => body_line.trim() === delimiter);
+  return (end === -1 ? lines : lines.slice(0, end)).join(LINE_BREAK3);
+}
+function shell_heredoc_bodies(line) {
+  const lines = line.split(LINE_BREAK3);
+  return lines.flatMap((opening, index) => {
+    const delimiter = SHELL_HEREDOC.exec(opening)?.[HEREDOC_DELIMITER_GROUP];
+    return delimiter === void 0 ? [] : body_until(lines.slice(index + 1), delimiter);
+  });
+}
+function is_tool_call(reading) {
+  return "name" in reading;
+}
+function is_pending_line(reading) {
+  return !is_tool_call(reading);
+}
+function tool_calls_of(line) {
+  const pending = [{ line, is_reserved: false }];
+  const calls = [];
+  for (let next = pending.shift(); next !== void 0; next = pending.shift()) {
+    const { is_reserved } = next;
+    const readings = shell_segments.quote_aware_commands_of(time_shell.without_heredoc_bodies(next.line)).flatMap((segment) => reading_of(segment, is_reserved) ?? []);
+    const bodies = shell_heredoc_bodies(next.line).map((body) => ({ line: body, is_reserved }));
+    calls.push(...readings.filter((reading) => is_tool_call(reading)));
+    pending.push(...readings.filter((reading) => is_pending_line(reading)), ...bodies);
+  }
+  return calls;
+}
+function flag_value(args, flag) {
+  const prefix = `${flag}=`;
+  const index = args.findIndex((argument2) => argument2 === flag || argument2.startsWith(prefix));
+  const argument = args[index];
+  if (argument === void 0) return void 0;
+  return argument === flag ? args[index + 1] : argument.slice(prefix.length);
+}
+function default_workers(name, cores) {
+  return name === VITEST ? Math.max(SINGLE_WORKER, cores - 1) : SINGLE_WORKER;
+}
+function count_of(value, cores) {
+  if (value === AUTO_WORKERS) return Math.max(SINGLE_WORKER, Math.floor(cores / AUTO_CORE_SHARE));
+  const count = Number(value);
+  return Number.isSafeInteger(count) && count > SINGLE_WORKER ? count : SINGLE_WORKER;
+}
+function workers_of(call, cores = os.availableParallelism()) {
+  const flag = WORKER_FLAGS[call.name];
+  const value = flag === void 0 ? void 0 : flag_value(call.args, flag);
+  return value === void 0 ? default_workers(call.name, cores) : count_of(value, cores);
+}
+function memory_of(call, cores) {
+  const row = core_weights.TOOL_MEMORY[call.name];
+  return row === void 0 ? void 0 : core_weights.MEMORY_MB[row] * workers_of(call, cores);
+}
+function estimated_memory_mb(line, cores = os.availableParallelism()) {
+  const amounts = tool_calls_of(line).flatMap((call) => memory_of(call, cores) ?? []);
+  return amounts.length === 0 ? void 0 : Math.max(...amounts);
+}
+function runs_multi_worker_eslint(line, cores = os.availableParallelism()) {
+  return tool_calls_of(line).some(
+    (call) => call.name === ESLINT && workers_of(call, cores) > SINGLE_WORKER
+  );
+}
+var command_memory = { estimated_memory_mb, runs_multi_worker_eslint, tool_calls_of };
+
+// scripts/rules/lane-direct-tool.ts
+var HEAVY_TOOLS = /* @__PURE__ */ new Set(["eslint", "vitest", "cspell", "tsc"]);
+function runs_heavy_tool(command) {
+  return command_memory.tool_calls_of(command).some((call) => !call.is_reserved && HEAVY_TOOLS.has(call.name));
+}
+function is_lane_direct_tool(command, is_lane_child = lane_child_marker.is_child_of(process.cwd())) {
+  if (!is_lane_child) return false;
+  return runs_heavy_tool(command) || command_memory.runs_multi_worker_eslint(command);
+}
+var LANE_DIRECT_TOOL_REASON = "\u26D4 lane child running `eslint` / `vitest` / `cspell` / `tsc` directly, or multi-worker eslint: it overlaps the other lanes. Run `pnpm josh lint:related`, `pnpm josh test:related`, `pnpm josh cspell:dot` or `pnpm josh reserved-run <weight> -- <command>`, eslint at `--concurrency off`; measure concurrency outside a lane. Refused on every occurrence.";
+var ROW11 = {
+  id: "lane-direct-tool",
+  is_trigger: bash_triggers.on_bash_command(is_lane_direct_tool),
+  reason: LANE_DIRECT_TOOL_REASON,
+  decide: () => true,
+  about: {
+    title: "Lane child running a heavy tool directly",
+    topic: "`docs/josh-commands-automation.md` \u2192 `josh reserved-run`",
+    fires: "a dispatched lane child launching `eslint` / `vitest` / `cspell` / `tsc` (bare, `pnpm exec`, `npx`, inside `sh -c`), or eslint with `--concurrency` other than `off` / `1` by any path, `reserved-run` included. Every occurrence",
+    quiet: "not a lane child, or the run goes through `pnpm josh` with single-worker eslint"
+  }
+};
+var lane_direct_tool = {
+  LANE_DIRECT_TOOL_REASON,
+  ROW: ROW11,
+  is_lane_direct_tool,
+  runs_heavy_tool
+};
+
+// 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 park instead: `pnpm josh run:park <N> --body-file <path>` (it applies `needs-decision`), the `confirmation` Telegram, stop. It fires on every occurrence (`.claude/skills/workflow-commands/pre-gate-cut.md`, `backlogrun-park.md`).";
+var ROW12 = {
+  id: "lane-interactive-ask",
+  is_trigger: is_interactive_ask,
+  reason: LANE_INTERACTIVE_ASK_REASON,
+  decide: () => true,
+  about: {
+    title: "Lane child interactive ask",
+    topic: '`.claude/skills/workflow-commands/pre-gate-cut.md` \u2192 "The interactive ask is refused one call earlier"',
+    fires: "a dispatched lane child's `AskUserQuestion`; it hands over the park procedure. Every occurrence",
+    quiet: "not a lane child, or not an interactive tool"
+  }
+};
+var lane_interactive_ask = { LANE_INTERACTIVE_ASK_REASON, ROW: ROW12, is_interactive_ask };
+
+// scripts/rules/lane-split-park.ts
+var EPIC_COMMANDS = /* @__PURE__ */ new Set(["epic"]);
+var PROMOTED_ISSUE = /--promote[=\s]+["']?(?<issue>\d+)\b/u;
+var LABEL_TARGETS = [
+  /\/issues\/(?<issue>\d+)\/labels\b/u,
+  /\bissue\s+edit\s+["']?(?<issue>\d+)\b/u,
+  /\brun:park\s+["']?(?<issue>\d+)\b/u
+];
+var ISSUE_URL = /--issue-url[=\s]+["']?([^\s"']+)/u;
+var URL_ISSUE = /\/issues\/(\d+)\b/u;
+function promoted_in(segment) {
+  if (!shell_segments.is_josh_command(segment, EPIC_COMMANDS)) return void 0;
+  return PROMOTED_ISSUE.exec(segment)?.groups?.["issue"];
+}
+function promoted_issues(commands) {
+  const segments = commands.flatMap((command) => shell_segments.segments_of(command));
+  const issues = segments.map((segment) => promoted_in(segment));
+  return new Set(issues.filter((issue) => issue !== void 0));
+}
+function label_target(command) {
+  for (const pattern of LABEL_TARGETS) {
+    const issue = pattern.exec(command)?.groups?.["issue"];
+    if (issue !== void 0) return issue;
+  }
+  return void 0;
+}
+function is_park_of(command, issue) {
+  return lane_park.records_the_park(command) && label_target(command) === issue;
+}
+function notified_issue(command) {
+  const [, url = ""] = ISSUE_URL.exec(command) ?? [];
+  const [, issue] = URL_ISSUE.exec(url) ?? [];
+  return issue;
+}
+function is_notify_of(command, issue) {
+  return lane_park.is_confirmation_notify(command) && notified_issue(command) === issue;
+}
+function is_candidate2(command) {
+  const issue = lane_child_marker.marked_issue();
+  if (issue === void 0) return false;
+  if (!is_park_of(command, issue) && !is_notify_of(command, issue)) return false;
+  return lane_child_marker.is_child_of(process.cwd());
+}
+function decide3(_call, run) {
+  const issue = lane_child_marker.marked_issue();
+  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: 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 ROW13 = {
+  id: "lane-split-park",
+  is_trigger: bash_triggers.on_bash_command(is_candidate2),
+  reason: LANE_SPLIT_PARK_REASON,
+  decide: decide3,
+  about: {
+    title: "A split is not a park",
+    topic: '`.claude/skills/workflow-commands/backlogrun-park.md` \u2192 "Splitting a child mid-run"',
+    fires: "a lane child that promoted its Issue to an epic this run parking it (`needs-decision`, `confirmation` notify). Every occurrence",
+    quiet: "no promotion this run"
+  }
+};
+var lane_split_park = {
+  LANE_SPLIT_PARK_REASON,
+  ROW: ROW13,
+  promoted_issues
+};
+
+// scripts/rules/lane-switch-main.ts
+var SWITCH_SUBCOMMAND = "switch";
+var NON_COLLIDING_FLAGS = /* @__PURE__ */ new Set([
+  "-c",
+  "-C",
+  "--create",
+  "--force-create",
+  "-d",
+  "--detach"
+]);
+var FLAG_PREFIX2 = "-";
+function switch_target(segment) {
+  const call = git_argv.parse(segment);
+  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) {
+  return shell_segments.segments_of(command).map((segment) => switch_target(segment)).filter((target) => target !== void 0);
+}
+function own_lane_branch(directory) {
+  const issue = lane_paths.lane_issue_of(directory);
+  return issue === void 0 ? void 0 : lane_paths.lane_branch(issue);
+}
+function is_switch_away_from_lane(command, is_lane_child = lane_child_marker.is_child_of(process.cwd()), own_branch = own_lane_branch(process.cwd())) {
+  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 (`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 ROW14 = {
+  id: "lane-switch-main",
+  is_trigger: bash_triggers.on_bash_command(is_switch_away_from_lane),
+  reason: LANE_SWITCH_MAIN_REASON,
+  decide: () => true,
+  about: {
+    title: "Lane child on `git switch main`",
+    topic: "`.claude/skills/workflow-commands/backlogrun-lanes.md`",
+    fires: "a dispatched lane child switching to the default branch or running `josh main:sync`. Every occurrence",
+    quiet: "not a lane child \u2014 `pnpm josh main:merge` brings the default in at the gate"
+  }
+};
+var lane_switch_main = {
+  LANE_SWITCH_MAIN_REASON,
+  ROW: ROW14,
+  is_switch_away_from_lane,
+  switch_target,
+  switch_targets
+};
+
+// scripts/rules/decision-oracle-tokens.ts
+var oracle_tokens = {
+  REQUIRED: "required",
+  SKIP: "skip",
+  STOP: "stop",
+  WAIT: "wait",
+  RETRY: "retry",
+  OVER: "over",
+  UNKNOWN: "unknown",
+  NONE: "none",
+  NOT_A_LANE: "not-a-lane",
+  BUSY: "busy",
+  HUMAN_REVIEW: "human-review",
+  ISSUE_N_ARG: "<N>",
+  EXCLUDE_ARG: "[--exclude <n>...]"
+};
+
+// scripts/rules/decision-oracle-batch.ts
+var {
+  BUSY,
+  EXCLUDE_ARG,
+  HUMAN_REVIEW,
+  ISSUE_N_ARG,
+  NONE,
+  NOT_A_LANE,
+  OVER,
+  RETRY,
+  STOP,
+  UNKNOWN,
+  WAIT
+} = oracle_tokens;
+var PRE_GATE_CUT_MD = ".claude/skills/workflow-commands/pre-gate-cut.md";
+var BACKLOGRUN_MD = ".claude/skills/workflow-commands/backlogrun.md";
+var RUN_MERGE_REFERENCE = "docs/josh-commands-run.md \u2192 `josh run:merge`";
+var EPIC_NEXT_REFERENCE = "docs/josh-commands-backlog.md \u2192 `josh epic:next`";
+var BACKLOG_BUDGET_REFERENCE = "docs/josh-commands-backlog.md \u2192 `josh backlog:budget`";
+var RUN_LIVENESS_REFERENCE = "docs/josh-commands-run.md \u2192 `josh run:liveness`";
+var AUTO_OK_NEXT_REFERENCE = "docs/josh-commands-backlog.md \u2192 `josh auto-ok:next`";
+var STASH_PUSH_REFERENCE = "docs/josh-commands-backlog.md \u2192 `josh stash:push`";
+var RUN_CUT_CMD = "run:cut";
+var BATCH_ORACLES = [
+  {
+    name: "run:cut:resume",
+    command: RUN_CUT_CMD,
+    decision: "Whether a lane child is resuming prior work or starting fresh",
+    args: `--resume ${ISSUE_N_ARG}`,
+    vocabulary: ["fresh", "resume", NOT_A_LANE],
+    single_source: PRE_GATE_CUT_MD
+  },
+  {
+    name: "run:cut:gate",
+    command: RUN_CUT_CMD,
+    decision: "Whether a lane child should take its pre-gate cut now",
+    args: ISSUE_N_ARG,
+    vocabulary: ["cut", NOT_A_LANE],
+    single_source: PRE_GATE_CUT_MD
+  },
+  {
+    name: "backlog:budget",
+    decision: "Whether a backlogrun may start more work, keep watching, or finish",
+    args: "",
+    vocabulary: ["run", "watch", STOP],
+    single_source: BACKLOG_BUDGET_REFERENCE
+  },
+  {
+    name: "run:liveness",
+    decision: "Whether a delegated unit is still working or has stopped without reporting",
+    args: `${ISSUE_N_ARG} --output <path>`,
+    vocabulary: ["alive", "paused", "stopped", "settled", "undetermined"],
+    single_source: RUN_LIVENESS_REFERENCE
+  },
+  {
+    name: "stash:push",
+    decision: "Whether the working tree had anything outside the observation ledger to set aside",
+    args: "<message>",
+    vocabulary: ["stashed", "clean"],
+    single_source: STASH_PUSH_REFERENCE
+  },
+  {
+    name: "stash:pop",
+    decision: "Whether a named stash entry exists and can be applied",
+    args: "<message>",
+    vocabulary: ["popped", "conflicted", "no-match", "ambiguous"],
+    single_source: ".claude/skills/workflow-commands/prerequisite.md"
+  },
+  {
+    name: "backlog:next",
+    decision: "Which issue the backlog offers next, or whether to wait or stop",
+    args: EXCLUDE_ARG,
+    vocabulary: [WAIT, STOP, RETRY, "error", NONE],
+    single_source: BACKLOGRUN_MD
+  },
+  {
+    name: "auto-ok:next",
+    decision: "The next opted-in issue outside any epic, or none",
+    args: EXCLUDE_ARG,
+    vocabulary: [NONE],
+    single_source: AUTO_OK_NEXT_REFERENCE
+  },
+  {
+    name: "epic:next",
+    decision: "The next runnable child of an epic, or the epic's status",
+    args: "<epic>",
+    vocabulary: [WAIT, STOP, "complete"],
+    single_source: EPIC_NEXT_REFERENCE
+  },
+  {
+    name: "run:merge",
+    decision: "The post-merge batch step: confirm child, advance, or report a stop condition",
+    args: ISSUE_N_ARG,
+    vocabulary: [OVER, HUMAN_REVIEW, STOP, RETRY, BUSY],
+    single_source: RUN_MERGE_REFERENCE
+  },
+  {
+    name: "run:step",
+    decision: "The run\u2019s next single action, computed from the event stream, carry and issue state",
+    args: `[${ISSUE_N_ARG}]`,
+    // The non-command answers: `run:step` prints a runnable command for a phase with one to run, and
+    // one of these verdicts otherwise. A command line is not a vocabulary token, exactly as an issue
+    // number is not one for `backlog:next`.
+    vocabulary: [
+      "implement",
+      HUMAN_REVIEW,
+      "update-deps",
+      "already-done",
+      "keep-work",
+      WAIT,
+      STOP,
+      UNKNOWN
+    ],
+    single_source: BACKLOGRUN_MD
+  }
+];
+
+// scripts/rules/decision-oracle-stage.ts
+var RUN_ENTRY_ORACLE = {
+  name: "run:entry",
+  decision: "Where a run on an issue starts, and whether the typed command has already been reached",
+  args: "<N> [--to kickoff|halfrun|prrun|fullrun]",
+  vocabulary: run_stage.START_TOKENS,
+  single_source: "docs/how-to/run-issues.md"
+};
+
+// scripts/rules/decision-oracle.ts
+var { BUSY: BUSY2, ISSUE_N_ARG: ISSUE_N_ARG2, NONE: NONE2, OVER: OVER2, REQUIRED, SKIP, UNKNOWN: UNKNOWN2 } = oracle_tokens;
+var CHAIN_RULE_MD = ".claude/skills/workflow-commands/chain-rule.md";
+var BACKLOGRUN_PROGRESS_MD = ".claude/skills/workflow-commands/backlogrun-progress.md";
+var SKILL_2E = ".claude/skills/workflow-commands/issue-scout.md";
+var SPLIT_ASSESSMENT_QUESTION = ".claude/skills/workflow-commands/split-assessment.md \u2192 The question";
+var LIVE = "live";
+var STOPPED = "stopped";
+var RECONCILED = "reconciled";
+var NOTHING_TO_RECONCILE = "nothing to reconcile";
+var DECISION_ORACLES = [
+  {
+    name: "delegate",
+    decision: "Whether a run step may be delegated to a cheaper execution tier",
+    args: "<step>",
+    vocabulary: ["delegate", "keep"],
+    single_source: ".claude/skills/workflow-commands/delegation.md"
+  },
+  {
+    name: "review:level",
+    decision: "The code-review level for the changed paths",
+    command: "review:brief",
+    args: "--level-only",
+    vocabulary: ["low", "medium", "high", "max"],
+    single_source: "prompts/review.md"
+  },
+  {
+    name: "review:round2",
+    decision: "Whether the second /code-review round is due",
+    args: "[--round-1-closed]",
+    vocabulary: [REQUIRED, SKIP],
+    single_source: CHAIN_RULE_MD
+  },
+  {
+    name: "disposition",
+    decision: "Whether a review finding reaches a runtime path, so it may be filed",
+    args: "<path...>",
+    vocabulary: ["runtime", "non-runtime"],
+    single_source: "prompts/review.md \u2192 Three-way disposition after the cap"
+  },
+  {
+    name: "review:attest",
+    decision: "Whether a /code-review attested the briefed checkout",
+    args: "--check",
+    vocabulary: ["ok", "missing", "mismatch", "not-required"],
+    single_source: CHAIN_RULE_MD
+  },
+  {
+    name: "latest:scope",
+    decision: "Whether this run has to update dependencies first",
+    args: "",
+    vocabulary: [REQUIRED, SKIP],
+    single_source: ".claude/skills/workflow-commands/latest-gate.md"
+  },
+  {
+    name: "run:hold",
+    decision: "Whether this working tree is free for a run to claim",
+    args: `[${ISSUE_N_ARG2}]`,
+    vocabulary: ["hold", BUSY2, UNKNOWN2],
+    single_source: ".claude/skills/workflow-commands/working-tree-hold.md"
+  },
+  {
+    name: "cost:cut",
+    command: "cost",
+    decision: "Whether the session cost exceeds the hand-off threshold",
+    args: "--cut",
+    vocabulary: [OVER2, "under"],
+    single_source: BACKLOGRUN_PROGRESS_MD
+  },
+  {
+    name: "release:scope",
+    decision: "Whether a release is owed after this merge",
+    args: "",
+    vocabulary: [REQUIRED, SKIP, UNKNOWN2],
+    single_source: ".claude/skills/workflow-commands/followup.md"
+  },
+  {
+    name: "epic:bundle",
+    decision: "Which epic a newly filed issue belongs to",
+    args: ISSUE_N_ARG2,
+    vocabulary: ["add_to_epic", "create_epic", "ask", "nothing_to_bundle"],
+    single_source: SKILL_2E
+  },
+  {
+    name: "issue:scout",
+    decision: "Whether a matching open issue already exists before filing",
+    args: "<title>",
+    vocabulary: ["Duplicates:", "Epic:"],
+    single_source: SKILL_2E
+  },
+  {
+    name: "issue:fold",
+    decision: "Whether findings filed from one session fold into one issue or stay separate",
+    args: "<title...>",
+    vocabulary: ["fold", "separate", "no-fold-needed", "undetermined"],
+    single_source: SPLIT_ASSESSMENT_QUESTION
+  },
+  {
+    name: "pkg:scout",
+    decision: "Whether the top package candidate is clearly best (Tier A) or a near-tie (Tier B)",
+    args: "<keywords>",
+    vocabulary: ["clear", "close"],
+    single_source: "CLAUDE.md \u2192 Package-First Development"
+  },
+  {
+    name: "issue:lint",
+    decision: "Whether a behavior-change issue declares a deliverable firing point and a re-runnable baseline",
+    args: "<path>",
+    vocabulary: ["ok", "\u2716 missing heading", "\u2716 firing point", "\u2716 baseline"],
+    single_source: "prompts/collaboration-workflow/issue-template.md"
+  },
+  {
+    name: "cases",
+    decision: "Each boundary a change crosses (network, process, fs, time, shared state, environment) and the abnormal cases it owes",
+    args: "<path...>",
+    vocabulary: ["network", "process", "fs", "time", "state", "env", NONE2],
+    single_source: "prompts/collaboration-workflow/report-format.md \u2192 \u5909\u66F4\u3068\u30C6\u30B9\u30C8"
+  },
+  {
+    name: "issue:state",
+    decision: "An issue's state, labels, and human-review flag",
+    args: ISSUE_N_ARG2,
+    vocabulary: ["human_review: yes", "human_review: no"],
+    single_source: ".claude/skills/workflow-commands/needs-human-review.md"
+  },
+  ...BATCH_ORACLES,
+  {
+    name: "refactor:scan",
+    decision: "Whether the refactoring scope still holds high- or medium-priority candidates",
+    args: "",
+    vocabulary: ["clear", "candidates", "error"],
+    single_source: "prompts/refactoring.md"
+  },
+  {
+    name: "split:assess",
+    decision: "Whether a change size clears the split guide (the split assessment size question)",
+    args: "[--json]",
+    vocabulary: ["split", "single"],
+    single_source: SPLIT_ASSESSMENT_QUESTION
+  },
+  {
+    name: "sonar:hotspots",
+    decision: "The Step B disposition for each SonarCloud hotspot on a pull request",
+    args: "<PR>",
+    vocabulary: ["excluded", "local", "fix", "defer", "unreadable"],
+    single_source: "prompts/sonar-hotspot-handling.md"
+  },
+  {
+    name: "clone:scan",
+    decision: "Whether cross-file or cross-repository code duplication exists",
+    args: "",
+    vocabulary: ["clean", "clones:"],
+    single_source: "prompts/collaboration-workflow/principles.md \u2192 no-clones"
+  },
+  {
+    name: "epic:reconcile",
+    command: "epic",
+    decision: "Whether an epic's declaration matches its recorded relations, and the repair when it does not",
+    args: "--reconcile <E>",
+    vocabulary: [RECONCILED, NOTHING_TO_RECONCILE],
+    single_source: "docs/josh-commands-backlog.md \u2192 `josh epic --reconcile`"
+  },
+  {
+    name: "lane:list",
+    decision: "Whether each in-progress issue holds a live lane, and the two-directional difference",
+    args: "",
+    vocabulary: [LIVE, STOPPED, UNKNOWN2],
+    single_source: "docs/josh-commands-run.md \u2192 The `in-progress` / lane difference"
+  },
+  RUN_ENTRY_ORACLE
+];
+function get_command(oracle) {
+  return oracle.command ?? oracle.name;
+}
+function find_oracle(name) {
+  return DECISION_ORACLES.find((oracle) => oracle.name === name.trim());
+}
+var decision_oracle = {
+  DECISION_ORACLES,
+  find_oracle,
+  get_command
+};
+
+// scripts/rules/oracle-firing.ts
+var PACKAGE_ADD = /^(?:pnpm|yarn|bun)\s+add\s+\S|^npm\s+(?:install|i)\s+[^-\s]/u;
+function is_package_add(command) {
+  return shell_segments.segments_of(command).some((segment) => PACKAGE_ADD.test(segment));
+}
+var FIRING = /* @__PURE__ */ new Map([
+  [
+    "pkg:scout",
+    {
+      describes: "a package-add command (`pnpm add \u2026`, `npm install <pkg>`)",
+      governs: is_package_add
+    }
+  ]
+]);
+var PHASE = "the act it governs is a phase of a run, not a single shell call a trigger can anchor on";
+var READ = "it answers a status question and governs no action of its own to gate before";
+var SELF = "the command is itself the governed act; there is no earlier call to gate before it";
+var LATEST_SCOPE_REASON = "the run it governs (`pnpm josh latest`) is already gated at its point of use by the latest-gate; a firing here would double-gate it";
+var FILING_STEP_REASON = "`pnpm josh issue:file` runs it as one of its filing steps, and a direct filing is refused by the `direct-filing` delivered rule; there is no separate call left to gate";
+var RELEASE_SCOPE_REASON = "it reads the release owed *after* `pnpm josh followup` has merged (`git_followup_pending`), so it trails the merge rather than gating it; a firing on `followup` would gate a check that must run once the merge is done, reading a pre-merge state that has not yet arrived";
+var NOT_NAMED = /* @__PURE__ */ new Map([
+  ["release:scope", RELEASE_SCOPE_REASON],
+  ["delegate", PHASE],
+  ["review:level", READ],
+  ["review:round2", READ],
+  ["disposition", READ],
+  ["review:attest", READ],
+  ["latest:scope", LATEST_SCOPE_REASON],
+  ["run:hold", SELF],
+  ["cost:cut", READ],
+  ["epic:bundle", FILING_STEP_REASON],
+  ["issue:scout", FILING_STEP_REASON],
+  ["issue:lint", FILING_STEP_REASON],
+  ["issue:fold", "`issue:file` asks the fold question itself on the second filing it governs"],
+  ["cases", READ],
+  ["issue:state", READ],
+  ["run:cut:resume", SELF],
+  ["run:cut:gate", SELF],
+  ["backlog:budget", READ],
+  ["run:liveness", READ],
+  ["stash:push", SELF],
+  ["stash:pop", SELF],
+  ["backlog:next", READ],
+  ["auto-ok:next", READ],
+  ["epic:next", READ],
+  ["run:merge", PHASE],
+  ["run:step", SELF],
+  ["run:entry", SELF],
+  ["refactor:scan", PHASE],
+  ["split:assess", PHASE],
+  ["sonar:hotspots", READ],
+  ["clone:scan", PHASE],
+  ["epic:reconcile", SELF],
+  ["lane:list", READ]
+]);
+function declaration_for(name) {
+  const firing_point = FIRING.get(name);
+  if (firing_point !== void 0) return { firing_point };
+  const not_firing_reason = NOT_NAMED.get(name);
+  return not_firing_reason === void 0 ? {} : { not_firing_reason };
+}
+function firing_oracles() {
+  return decision_oracle.DECISION_ORACLES.flatMap((oracle) => {
+    const firing_point = FIRING.get(oracle.name);
+    return firing_point === void 0 ? [] : { oracle, firing_point };
+  });
+}
+var oracle_firing = {
+  FIRING,
+  NOT_NAMED,
+  declaration_for,
+  firing_oracles,
+  is_package_add
+};
+
+// scripts/rules/oracle-consulted.ts
+function command_names(oracle) {
+  return /* @__PURE__ */ new Set([decision_oracle.get_command(oracle)]);
+}
+function runs_the_oracle(command, names) {
+  return shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, names));
+}
+function command_line(oracle) {
+  const command = decision_oracle.get_command(oracle);
+  return oracle.args ? `pnpm josh ${command} ${oracle.args}` : `pnpm josh ${command}`;
+}
+function reason_for2(oracle, firing_point) {
+  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.`;
+}
+var ABOUT = {
+  title: "An act its oracle was not asked about",
+  topic: "`decision-oracle.ts`",
+  fires: "a `Bash` governed by an oracle that declared a firing point (`pkg:scout` governs `pnpm add`), issued without that `pnpm josh <command>`. Refused until it ran",
+  quiet: "no governed act, or the oracle already ran"
+};
+function row_for(oracle, firing_point) {
+  const names = command_names(oracle);
+  return {
+    id: `oracle-consulted:${oracle.name}`,
+    is_trigger: bash_triggers.on_bash_command(firing_point.governs),
+    reason: reason_for2(oracle, firing_point),
+    already_satisfied: (tail, _call) => tail_commands.prior_bash_commands(tail).some((command) => runs_the_oracle(command, names)),
+    keeps: bash_triggers.on_bash_command((command) => runs_the_oracle(command, names)),
+    about: ABOUT
+  };
+}
+var ROWS = oracle_firing.firing_oracles().map(({ oracle, firing_point }) => row_for(oracle, firing_point));
+var oracle_consulted = { ROWS, reason_for: reason_for2 };
+
+// scripts/rules/destructive-command.ts
+var RM_COMMAND = "rm";
+var RECURSIVE_LONG = "--recursive";
+var RECURSIVE_LETTERS = "rR";
+var FORCE_LONG = "--force";
+var FORCE_LETTER = "f";
+function has_flag(args, long, letters) {
+  return args.some((argument) => argument === long || git_argv.short_cluster_has(argument, letters));
+}
+function is_recursive_forced_rm(segment) {
+  const args = git_argv.arguments_of(segment, RM_COMMAND);
+  if (args === void 0) return false;
+  return has_flag(args, RECURSIVE_LONG, RECURSIVE_LETTERS) && has_flag(args, FORCE_LONG, FORCE_LETTER);
+}
+var GH_COMMAND2 = "gh";
+var REPO_GROUP2 = "repo";
+var REPO_REMOVALS = /* @__PURE__ */ new Set(["delete", "archive"]);
+var REPO_EDIT = "edit";
+var VISIBILITY_FLAG = "--visibility";
+var PR_GROUP2 = "pr";
+var PR_CLOSE = "close";
+function is_destructive_repo_action(action, args) {
+  if (REPO_REMOVALS.has(action)) return true;
+  return action === REPO_EDIT && args.some((argument) => argument.startsWith(VISIBILITY_FLAG));
+}
+function is_destructive_gh_command(args) {
+  const [group, action = ""] = args;
+  if (group === PR_GROUP2) return action === PR_CLOSE;
+  return group === REPO_GROUP2 && is_destructive_repo_action(action, args);
+}
+var DELETE_METHOD = "DELETE";
+var REPOSITORY_PATH = "repos/";
+var ISSUE_LABEL_PATH = /^['"]?\/?repos\/[^/\s'"]+\/[^/\s'"]+\/issues\/\d+\/labels\/[^/\s'"]+['"]?$/u;
+function is_destructive_api_call(args) {
+  const call = [GH_COMMAND2, ...args].join(" ");
+  if (!gh_api.is_gh_api(call) || gh_api.method_of(call) !== DELETE_METHOD) return false;
+  return args.some(
+    (argument) => argument.includes(REPOSITORY_PATH) && !ISSUE_LABEL_PATH.test(argument)
+  );
+}
+function is_destructive_gh(segment) {
+  const args = git_argv.arguments_of(segment, GH_COMMAND2);
+  if (args === void 0) return false;
+  return is_destructive_gh_command(args) || is_destructive_api_call(args);
+}
+function is_destructive_segment2(segment) {
+  return is_recursive_forced_rm(segment) || is_destructive_gh(segment);
+}
+function is_destructive_command(command) {
+  return shell_segments.commands_of(command).some((segment) => is_destructive_segment2(segment));
+}
+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 ROW15 = {
+  id: "destructive-command",
+  is_trigger: bash_triggers.on_bash_command(is_destructive_command),
+  reason: DESTRUCTIVE_COMMAND_REASON,
+  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`"],
+  about: {
+    title: "Destructive command",
+    topic: "`operating-rules.md`",
+    fires: "`rm -rf` (any spelling), `gh repo delete` / `archive`, `gh pr close`, `gh api -X DELETE`. Every occurrence",
+    quiet: "`gh issue close` or removing an Issue label \u2014 the workflow's own steps"
+  }
+};
+var destructive_command = { DESTRUCTIVE_COMMAND_REASON, ROW: ROW15, is_destructive_command };
+
+// scripts/rules/worktree-guard.ts
+var CHECKOUT_SUBCOMMAND = "checkout";
+var RESTORE_SUBCOMMAND = "restore";
+var STASH_SUBCOMMAND = "stash";
+var PATHSPEC_SEPARATOR = "--";
+function is_worktree_checkout(args) {
+  return args.includes(PATHSPEC_SEPARATOR);
+}
+var STAGED_LONG = "--staged";
+var STAGED_LETTER = "S";
+var WORKTREE_LONG = "--worktree";
+var WORKTREE_LETTER = "W";
+function touches_worktree(args) {
+  const is_staged = args.some(
+    (argument) => argument === STAGED_LONG || git_argv.short_cluster_has(argument, STAGED_LETTER)
+  );
+  const is_worktree = args.some(
+    (argument) => argument === WORKTREE_LONG || git_argv.short_cluster_has(argument, WORKTREE_LETTER)
+  );
+  return !is_staged || is_worktree;
+}
+var PUSH_STASH = "push";
+var MESSAGE_LONG = "--message";
+var MESSAGE_SHORT_LETTER = "m";
+var READ_ONLY_STASH = /* @__PURE__ */ new Set(["list", "show"]);
+function has_message(args) {
+  return args.some(
+    (argument) => argument === MESSAGE_LONG || argument.startsWith(`${MESSAGE_LONG}=`) || git_argv.short_cluster_has(argument, MESSAGE_SHORT_LETTER)
+  );
+}
+function is_unauthorized_stash(args) {
+  const [stash_subcommand, ...rest] = args;
+  if (stash_subcommand === void 0) return true;
+  if (READ_ONLY_STASH.has(stash_subcommand)) return false;
+  if (stash_subcommand === PUSH_STASH) return !has_message(rest);
+  return true;
+}
+var CLEAN_SUBCOMMAND = "clean";
+var FORCE_LONG2 = "--force";
+var FORCE_LETTER2 = "f";
+function is_forced_clean(args) {
+  return args.some(
+    (argument) => argument === FORCE_LONG2 || git_argv.short_cluster_has(argument, FORCE_LETTER2)
+  );
+}
+var JUDGED_SUBCOMMANDS = /* @__PURE__ */ new Map([
+  [CHECKOUT_SUBCOMMAND, is_worktree_checkout],
+  [RESTORE_SUBCOMMAND, touches_worktree],
+  [CLEAN_SUBCOMMAND, is_forced_clean],
+  [STASH_SUBCOMMAND, is_unauthorized_stash]
+]);
+function is_unauthorized_segment(segment) {
+  const call = git_argv.parse(segment);
+  if (call === void 0) return false;
+  return JUDGED_SUBCOMMANDS.get(call.subcommand ?? "")?.(call.args) === true;
+}
+function is_unauthorized_worktree_change(command) {
+  return shell_segments.commands_of(command).some((segment) => is_unauthorized_segment(segment));
+}
+var WORKTREE_MUTATION_REASON = '\u26D4 unauthorized working-tree change: `git checkout --`, `git restore`, `git clean -f`, `git stash`. A documented flow stashes with `pnpm josh stash:push "<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 ROW16 = {
+  id: "worktree-mutation",
+  is_trigger: bash_triggers.on_bash_command(is_unauthorized_worktree_change),
+  reason: WORKTREE_MUTATION_REASON,
+  decide: () => true,
+  about: {
+    title: "Unauthorized work-tree mutation",
+    topic: "`operating-rules.md`",
+    fires: "`git checkout -- <path>` / `git restore <path>` / forced `git clean -f` / an unauthorized `git stash` (bare, push without a message, positional pop). Every occurrence",
+    quiet: "`git stash push -m`, `git stash list`, `pnpm josh git`, `pnpm josh stash:push`, `pnpm josh stash:pop`"
+  }
+};
+var worktree_guard = {
+  ROW: ROW16,
+  WORKTREE_MUTATION_REASON,
+  is_unauthorized_worktree_change,
+  touches_worktree
+};
+
+// scripts/rules/index-guard.ts
+var INDEX_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "add",
+  "commit",
+  "mv",
+  "reset",
+  "rm",
+  "stage"
+]);
+var RESTORE_SUBCOMMAND2 = "restore";
+function is_index_restore(args) {
+  return !worktree_guard.touches_worktree(args);
+}
+function is_index_segment(segment) {
+  const call = git_argv.parse(segment);
+  if (call === void 0) return false;
+  if (INDEX_SUBCOMMANDS.has(call.subcommand ?? "")) return true;
+  return call.subcommand === RESTORE_SUBCOMMAND2 && is_index_restore(call.args);
+}
+function is_index_mutation(command) {
+  return shell_segments.commands_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. 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 ROW17 = {
+  id: "index-mutation",
+  is_trigger: bash_triggers.on_bash_command(is_index_mutation),
+  reason: INDEX_MUTATION_REASON,
+  decide: () => true,
+  about: {
+    title: "Index mutation",
+    topic: "`operating-rules.md`",
+    fires: "`git add` / `commit` / `reset` / `rm` / `mv` / `restore --staged` in any spelling. Every occurrence",
+    quiet: "`pnpm josh git` \u2014 the approved commit flow"
+  }
+};
+var index_guard = { INDEX_MUTATION_REASON, ROW: ROW17, is_index_mutation };
+
+// scripts/rules/pr-merge.ts
+var GH_COMMAND3 = "gh";
+var CURL_COMMAND = "curl";
+var PR_GROUP3 = "pr";
+var MERGE_ACTION = "merge";
+var API_SUBCOMMAND3 = "api";
+var GRAPHQL_ENDPOINT = "graphql";
+var MERGE_PATH = /pulls\/[^/\s'"]+\/merge(?![\w-])/u;
+var MERGE_MUTATIONS = /\b(?:mergePullRequest|enablePullRequestAutoMerge)\b/u;
+var GRAPHQL_URL = /\/graphql\b/u;
+var FILE_BODY_VALUE = /^(?:-[A-Za-z]|[^=\s]*=)?['"]?@/u;
+var FILE_BODY_FLAGS = /* @__PURE__ */ new Set(["--input", "-T", "--upload-file"]);
+var SUBSTITUTED_BODY = /\$\(|`/u;
+function positional_words2(args) {
+  return direct_pr_create.positional_words(args, direct_pr_create.API_VALUE_TAKING_FLAGS);
+}
+function is_pr_merge_cli_call(args) {
+  const [group, action] = positional_words2(args);
+  return group === PR_GROUP3 && action === MERGE_ACTION;
+}
+function is_github_api_call(name, args) {
+  if (name === CURL_COMMAND) return true;
+  return name === GH_COMMAND3 && positional_words2(args)[0] === API_SUBCOMMAND3;
+}
+function is_graphql_call(name, args) {
+  if (args.some((argument) => GRAPHQL_URL.test(argument))) return true;
+  return name === GH_COMMAND3 && positional_words2(args)[1] === GRAPHQL_ENDPOINT;
+}
+function is_unreadable_body(argument) {
+  if (FILE_BODY_FLAGS.has(argument)) return true;
+  return FILE_BODY_VALUE.test(argument) || SUBSTITUTED_BODY.test(argument);
+}
+function is_graphql_merge(command, name, args) {
+  if (!is_graphql_call(name, args)) return false;
+  return MERGE_MUTATIONS.test(command) || args.some((argument) => is_unreadable_body(argument));
+}
+function is_api_merge(command, segment, call) {
+  if (MERGE_PATH.test(segment) || MERGE_MUTATIONS.test(segment)) return true;
+  return is_graphql_merge(command, call.name, call.args);
+}
+function is_pr_merge_segment(command, segment) {
+  const call = git_argv.program_of(segment);
+  if (call === void 0) return false;
+  if (call.name === GH_COMMAND3 && is_pr_merge_cli_call(call.args)) return true;
+  return is_github_api_call(call.name, call.args) && is_api_merge(command, segment, call);
+}
+function is_pr_merge(command) {
+  return shell_segments.commands_of(command).some((segment) => is_pr_merge_segment(command, segment));
+}
+var PR_MERGE_REASON = "\u26D4 direct PR merge: `gh pr merge`, a `gh api` / `curl` call to `\u2026/pulls/<N>/merge`, a `mergePullRequest` / `enablePullRequestAutoMerge` mutation, or a GraphQL body read from a file merges outside the verified route, and a merge is Tier C. Merge with `pnpm josh followup` when the run authorizes it; otherwise leave it to the user (`CLAUDE.md` \u2192 Git Rules). This rule fires on every occurrence.";
+var ROW18 = {
+  id: "pr-merge",
+  is_trigger: bash_triggers.on_bash_command(is_pr_merge),
+  reason: PR_MERGE_REASON,
+  decide: () => true,
+  about: {
+    title: "Direct PR merge",
+    topic: "`CLAUDE.md` \u2192 Git Rules",
+    fires: "`gh pr merge`, a `gh api` / `curl` call to `\u2026/pulls/<N>/merge`, a `mergePullRequest` / `enablePullRequestAutoMerge` mutation, or a GraphQL body read from a file. Every occurrence",
+    quiet: "`pnpm josh followup` and `pnpm josh observations:flush`, which merge in their own process"
+  }
+};
+var pr_merge = { PR_MERGE_REASON, ROW: ROW18, is_pr_merge };
+
+// scripts/rules/protected-files.ts
+import path3 from "node:path";
+var READ_TOOL2 = "Read";
+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 = path3.join(".claude", "settings.json");
+var WHITESPACE2 = /\s+/u;
+var TOKEN_QUOTES = /["']/gu;
+var INPUT_REDIRECT = "<";
+var SHELL_READERS = /* @__PURE__ */ new Set([
+  ".",
+  "awk",
+  "base64",
+  "bat",
+  "cat",
+  "cmp",
+  "column",
+  "comm",
+  "cut",
+  "diff",
+  "fold",
+  "grep",
+  "head",
+  "hexdump",
+  "jq",
+  "less",
+  "more",
+  "nl",
+  "od",
+  "paste",
+  "perl",
+  "python",
+  "python3",
+  "rev",
+  "rg",
+  "ruby",
+  "sed",
+  "sort",
+  "source",
+  "strings",
+  "tac",
+  "tail",
+  "uniq",
+  "xxd",
+  "yq"
+]);
+function file_path_of(call) {
+  if (!json_value.is_record(call.input)) return "";
+  const value = call.input["file_path"];
+  return typeof value === "string" ? value : "";
+}
+function is_environment_path(token) {
+  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);
+}
+function is_environment_read_segment(segment) {
+  const words = segment.replaceAll(INPUT_REDIRECT, " < ").split(WHITESPACE2).filter((word) => word !== "");
+  const is_redirected = words.some(
+    (word, index) => word === INPUT_REDIRECT && is_environment_path(words[index + 1] ?? "")
+  );
+  const call = git_argv.program_of(segment);
+  if (is_redirected || call === void 0) return is_redirected;
+  return SHELL_READERS.has(call.name) && call.args.some((word) => is_environment_path(word));
+}
+function is_environment_shell_read(command) {
+  return shell_segments.commands_of(command).some((segment) => is_environment_read_segment(segment));
+}
+function is_environment_read(call) {
+  if (call.name === READ_TOOL2) return is_environment_path(file_path_of(call));
+  return bash_triggers.on_bash_command(is_environment_shell_read)(call);
+}
+function is_consumer_settings_edit(call, is_kit_consumer) {
+  if (!EDIT_TOOLS2.has(call.name)) return false;
+  const file_path = path3.resolve(file_path_of(call));
+  if (!file_path.endsWith(`${path3.sep}${SETTINGS_FILE}`)) return false;
+  return is_kit_consumer(path3.dirname(path3.dirname(file_path)));
+}
+function is_protected_file_call(call, is_kit_consumer = doctor_consumer.is_kit_consumer) {
+  return is_environment_read(call) || is_consumer_settings_edit(call, is_kit_consumer);
+}
+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 ROW19 = {
+  id: "protected-file",
+  is_trigger: is_protected_file_call,
+  reason: PROTECTED_FILE_REASON,
+  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"],
+  about: {
+    title: "Protected file",
+    topic: "`operating-rules.md`",
+    fires: "a `Read` of `.env`, or an `Edit` / `Write` of `.claude/settings.json` outside kit. Every occurrence",
+    quiet: "kit itself, or the user's `~/.claude/settings.json`"
+  }
+};
+var protected_files = { ROW: ROW19, is_protected_file_call };
+
+// scripts/rules/permission-guards.ts
+var ROWS2 = [
+  index_guard.ROW,
+  destructive_command.ROW,
+  protected_files.ROW,
+  direct_pr_create.ROW,
+  pr_merge.ROW
+];
+var permission_guards = { ROWS: ROWS2 };
+
+// scripts/rules/piped-verification.ts
+var VERIFICATION_COMMANDS = /* @__PURE__ */ new Set([
+  "check",
+  "cspell",
+  "cspell:dot",
+  "eval",
+  "gate",
+  "lint",
+  "lint:eslint",
+  "lint:prettier",
+  "lint:related",
+  "overrides",
+  "ranges",
+  "test",
+  "test:e2e",
+  "test:related",
+  "test:unit"
+]);
+function is_verification_command(segment) {
+  return shell_segments.is_josh_command(segment, VERIFICATION_COMMANDS);
+}
+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. 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()));
+}
+function command_pieces(command) {
+  return pipelines_of(command).flat();
+}
+function runs_verification(command) {
+  return command_pieces(command).some((piece) => is_verification_command(piece));
+}
+function keeps_verdict_intact(command) {
+  return runs_verification(command) && !is_masked_verification(command);
+}
+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 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);
+}
+function is_filtered_check(pipeline) {
+  const [head = "", ...filters] = pipeline;
+  return is_verification_command(head) && filters.every((piece) => reads_to_the_end(piece));
+}
+function has_side_effect_syntax(command) {
+  return SIDE_EFFECT_SYNTAX.test(command.replaceAll(ALLOWED_OPERATORS, " "));
+}
+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 = pipefail_command(time_shell.bash_command(call.input));
+  return command === void 0 ? void 0 : { ...call.input, command };
+}
+var piped_verification = {
+  PIPED_VERIFICATION_REASON,
+  PIPEFAIL_NOTE,
+  VERIFICATION_COMMANDS,
+  is_masked_verification,
+  keeps_verdict_intact,
+  pipefail_input,
+  runs_verification
+};
+
+// scripts/rules/poll-loop.ts
+var LOOP_KEYWORD2 = /\b(?:while|until)\s/u;
+var SLEEP_COMMAND = /\bsleep\s+\S/u;
+var COMMAND_POSITION = String.raw`(?:^|[;&|({\n]|\b(?:do|then|else)\s)\s*`;
+var UNTIL_HEADER = new RegExp(String.raw`${COMMAND_POSITION}until\s`, "u");
+var WHILE_HEADER = String.raw`${COMMAND_POSITION}while\s+(?:!\s*)?`;
+var PROBE_HEADERS = [
+  String.raw`\[\[?\s+(?:!\s*)?-[defs]\s`,
+  String.raw`test\s+(?:!\s*)?-[defs]\s`,
+  String.raw`(?:kill\s+-0|pgrep)\b`,
+  String.raw`grep\s+-[A-Za-z]*q`
+].map((probe) => new RegExp(`${WHILE_HEADER}${probe}`, "u"));
+function is_state_wait(plain) {
+  return UNTIL_HEADER.test(plain) || PROBE_HEADERS.some((header) => header.test(plain));
+}
+var STREAM_READER = /\bwhile\s+read\b/u;
+function is_stream_reader(plain) {
+  return STREAM_READER.test(plain);
+}
+function is_poll_loop(command) {
+  const plain = time_shell.unquoted(command);
+  if (is_stream_reader(plain)) return false;
+  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, 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 ROW20 = {
+  id: "poll-loop",
+  is_trigger: bash_triggers.on_bash_command(is_poll_loop),
+  reason: POLL_LOOP_REASON,
+  decide: () => true,
+  about: {
+    title: "Output poll loop",
+    topic: "`.claude/skills/workflow-commands/background-commands.md`",
+    fires: "a hand-written `while` / `until` wait loop over a command's output, a marker file or a process. Every occurrence",
+    quiet: "the command started with `run_in_background` \u2014 its exit ends the wait"
+  }
+};
+var poll_loop = {
+  POLL_LOOP_REASON,
+  ROW: ROW20,
+  is_poll_loop
+};
+
+// 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 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 ROW21 = {
+  id: "raw-field-body",
+  is_trigger: bash_triggers.on_bash_command(posts_at_path_literally),
+  reason: RAW_FIELD_BODY_REASON,
+  decide: () => true,
+  about: {
+    title: "Posting `@path` literally",
+    topic: "`shell-body.md`",
+    fires: "a raw field (`-f` / `--raw-field`) passing `body=@<path>`. Every occurrence",
+    quiet: "`-F` / `--field body=@`, a body without `@`, or `pnpm josh issue:comment`"
+  }
+};
+var raw_field_body = { RAW_FIELD_BODY_REASON, ROW: ROW21, posts_at_path_literally };
+
+// scripts/rules/rule-body-guard.ts
+var EDIT_TOOL = "Edit";
+var WRITE_TOOL = "Write";
+var CLAUDE_DOCUMENT = /(?:^|\/)CLAUDE\.md$/u;
+var PROMPT_DOCUMENT = /(?:^|\/)prompts\/.+\.md$/u;
+var SKILL_DOCUMENT = /(?:^|\/)\.claude\/skills\/.+\.md$/u;
+function is_rule_document(file_path) {
+  return CLAUDE_DOCUMENT.test(file_path) || PROMPT_DOCUMENT.test(file_path) || SKILL_DOCUMENT.test(file_path);
+}
+var LINK_TARGET = /\]\([^)]*\)/gu;
+var BARE_URL = /https?:\/\/\S+/gu;
+function prose_of(text) {
+  return text.replaceAll(LINK_TARGET, "]()").replaceAll(BARE_URL, "");
+}
+var MIN_APPENDED_PROSE = 120;
+function adds_rule_prose(old_text, new_text) {
+  return prose_of(new_text).length - prose_of(old_text).length >= MIN_APPENDED_PROSE;
+}
+function string_field(input, key) {
+  const value = input[key];
+  return typeof value === "string" ? value : "";
+}
+function read_existing(file_path) {
+  return file_reader.read_file_or_empty(file_path);
+}
+function texts_of(name, input, read2) {
+  if (name === WRITE_TOOL) {
+    return {
+      old_text: read2(string_field(input, "file_path")),
+      new_text: string_field(input, "content")
+    };
+  }
+  return {
+    old_text: string_field(input, "old_string"),
+    new_text: string_field(input, "new_string")
+  };
+}
+function is_edit_tool2(name) {
+  return name === EDIT_TOOL || name === WRITE_TOOL;
+}
+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_field(call.input, "file_path")) ? call.input : void 0;
+}
+function writes_rule_prose(call, read2 = 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);
+  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. 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"])
+];
+function ran_oracle(tail_commands_run, names) {
+  return tail_commands_run.some(
+    (command) => shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, names))
+  );
+}
+function answered_placement(tail, _call) {
+  const commands = tail_commands.prior_bash_commands(tail);
+  return PLACEMENT_ORACLES.every((names) => ran_oracle(commands, names));
+}
+function runs_placement_oracle(command) {
+  return PLACEMENT_ORACLES.some(
+    (names) => shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, names))
+  );
+}
+var ROW22 = {
+  id: "rule-body",
+  is_trigger: writes_rule_prose,
+  reason: RULE_BODY_REASON,
+  already_satisfied: answered_placement,
+  keeps: bash_triggers.on_bash_command(runs_placement_oracle),
+  about: {
+    title: "Question 0 and the ordering question before writing a rule into prose",
+    topic: "`residency.md`",
+    fires: "an `Edit` / `Write` to `CLAUDE.md` / `prompts/**/*.md` / `.claude/skills/**/*.md` appending at least the threshold. Refused until both `pnpm josh oracle:list` and `pnpm josh run:step` ran",
+    quiet: "not a rule document, an append under the threshold (typo, link swap, deletion), or both commands ran"
+  }
+};
+var rule_body_guard = {
+  RULE_BODY_REASON,
+  ROW: ROW22,
+  answered_placement,
+  is_rule_document,
+  writes_rule_prose
+};
+
+// scripts/rules/shell-body-trigger.ts
+var FIELD_FLAGS = "(?:-f|-F|--field|--raw-field)";
+var MESSAGE_FLAGS = "(?:--body|--notify-message|--recommended|--alternative)";
+var FIELD_OPENING = String.raw`${FIELD_FLAGS}[\s=]*(?:'?body="|"body=)`;
+var MESSAGE_OPENING = String.raw`${MESSAGE_FLAGS}[\s=]+"`;
+var NESTED_SUBSTITUTION = String.raw`\$\([^()]*\)`;
+var SUBSTITUTION = String.raw`\$\((?:[^()$]|\$(?!\()|${NESTED_SUBSTITUTION})*\)`;
+var QUOTED_VALUE = String.raw`(?:[^"\\$]|\\.|\$(?!\()|${SUBSTITUTION})*`;
+var INLINE_BODY_VALUE = new RegExp(
+  `(?:${FIELD_OPENING}|${MESSAGE_OPENING})(${QUOTED_VALUE})"`,
+  "gu"
+);
+var SHELL_EVALUATED = /[`$]/u;
+var WHOLE_VALUE_SUBSTITUTION = new RegExp(`^${SUBSTITUTION}$`, "u");
+var BACKTICK = "`";
+var WHOLE_VALUE_FILE_REFERENCE = /^@\S+$/u;
+var ESCAPED_PAIR = /\\./gu;
+function is_whole_value_substitution(literal) {
+  return WHOLE_VALUE_SUBSTITUTION.test(literal) && !literal.includes(BACKTICK);
+}
+function is_body_already_in_a_file(literal) {
+  return WHOLE_VALUE_FILE_REFERENCE.test(literal) || is_whole_value_substitution(literal);
+}
+function is_evaluated_value(raw_value) {
+  const literal = raw_value.replaceAll(ESCAPED_PAIR, "");
+  if (is_body_already_in_a_file(literal)) return false;
+  return SHELL_EVALUATED.test(literal);
+}
+function is_shell_evaluated_body(command) {
+  for (const match of command.matchAll(INLINE_BODY_VALUE)) {
+    if (is_evaluated_value(match[1] ?? "")) return true;
+  }
+  return false;
+}
+var FILE_FLAG = /(?:--body-file|--notify-message-file)(?:[\s=]|$)/u;
+var FIELD_FILE_REFERENCE = new RegExp(String.raw`${FIELD_FLAGS}[\s=]*body=@\S`, "u");
+var ANSI_C_BODY = /(?:(?:--body|--notify-message)[\s=]+|body=)\$'/u;
+var DOUBLE_QUOTED_SPAN = /"[^"]*"/gu;
+var BODY_FLAG = new RegExp(
+  String.raw`${FIELD_FLAGS}[\s=]*'?"?body=|${MESSAGE_FLAGS}[\s=]|--body-file[\s=]|--notify-message-file[\s=]`,
+  "u"
+);
+var QUOTED_SPAN = /"[^"]*"|'[^']*'/gu;
+function inline_body_literals(command) {
+  return Array.from(
+    command.matchAll(INLINE_BODY_VALUE),
+    (match) => (match[1] ?? "").replaceAll(ESCAPED_PAIR, "")
+  );
+}
+function is_safe_body_form(command) {
+  if (ANSI_C_BODY.test(command.replaceAll(DOUBLE_QUOTED_SPAN, " "))) return true;
+  const flags = command.replaceAll(QUOTED_SPAN, " ");
+  if (FILE_FLAG.test(flags) || FIELD_FILE_REFERENCE.test(flags)) return true;
+  return inline_body_literals(command).some((literal) => is_body_already_in_a_file(literal));
+}
+function keeps_body_safe(command) {
+  return is_safe_body_form(command) && !is_shell_evaluated_body(command);
+}
+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 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,
+  is_shell_evaluated_body,
+  keeps_body_safe
+};
+
+// scripts/test/test-declared-logic.ts
+var TEST_SUFFIXES = [".e2e.ts", ".test.ts"];
+var EXEMPT_PATHS = [".editorconfig"];
+var EXEMPT_PREFIXES = [".idea/", ".vscode/", "prompts/"];
+var EXEMPT_SUFFIXES = [".md"];
+var BASIC_VISUAL_SUFFIXES = [".html", ".css"];
+var BASIC_REQUIRED_SUFFIXES = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".svelte",
+  ".json",
+  ".jsonc",
+  ".json5",
+  ".yaml",
+  ".yml",
+  ".toml"
+];
+function normalize(paths) {
+  return paths.map((path5) => path5.trim()).filter((path5) => path5 !== "");
+}
+function is_test_file(path5) {
+  return TEST_SUFFIXES.some((suffix) => path5.endsWith(suffix));
+}
+function is_basic_manual(path5, is_basic) {
+  const lower = path5.toLowerCase();
+  return is_basic && BASIC_REQUIRED_SUFFIXES.every((suffix) => !lower.endsWith(suffix));
+}
+function is_basic_visual(path5) {
+  const lower = path5.toLowerCase();
+  return BASIC_VISUAL_SUFFIXES.some((suffix) => lower.endsWith(suffix));
+}
+function is_exempt(path5, is_basic = false) {
+  if (EXEMPT_PATHS.includes(path5) || is_basic_manual(path5, is_basic)) return true;
+  return EXEMPT_SUFFIXES.some((suffix) => path5.endsWith(suffix)) || EXEMPT_PREFIXES.some((prefix) => path5.startsWith(prefix));
+}
+function is_runtime(path5, is_basic = false) {
+  return !is_test_file(path5) && !is_exempt(path5, is_basic);
+}
+function verdict_for2(paths, is_basic = false) {
+  const changed = normalize(paths);
+  if (changed.some((path5) => is_test_file(path5))) return "satisfied";
+  if (changed.some((path5) => is_runtime(path5, is_basic))) return "required";
+  return "exempt";
+}
+function runtime_files(paths, is_basic = false) {
+  return normalize(paths).filter((path5) => is_runtime(path5, is_basic));
+}
+function exempt_files(paths, is_basic = false) {
+  return normalize(paths).filter((path5) => is_exempt(path5, is_basic));
+}
+function manual_check_files(paths, is_basic) {
+  return normalize(paths).filter((path5) => is_exempt(path5, is_basic) && !is_exempt(path5));
+}
+var test_declared_logic = {
+  EXEMPT_PATHS,
+  EXEMPT_PREFIXES,
+  EXEMPT_SUFFIXES,
+  exempt_files,
+  is_basic_visual,
+  is_exempt,
+  is_runtime,
+  is_test_file,
+  manual_check_files,
+  runtime_files,
+  verdict_for: verdict_for2
+};
+
+// scripts/test/test-declared-changed.ts
+var RENAME_ARROW = " -> ";
+var STATUS_PREFIX_LENGTH = 3;
+function path_of(line) {
+  const body = line.slice(STATUS_PREFIX_LENGTH);
+  const arrow = body.indexOf(RENAME_ARROW);
+  return arrow === -1 ? body : body.slice(arrow + RENAME_ARROW.length);
+}
+function read_changed_paths_sync() {
+  const output = git_spawn_sync.run(["status", PORCELAIN_FLAG], { timeout: 0 });
+  if (output.exit_code !== 0) return [];
+  return output.stdout.split("\n").filter((line) => line.length > STATUS_PREFIX_LENGTH).map((line) => path_of(line));
+}
+var injected = {};
+function source_paths() {
+  return injected.paths ?? read_changed_paths_sync();
+}
+function current_verdict(paths = source_paths()) {
+  return test_declared_logic.verdict_for(paths, project_checks.is_basic(process.cwd()));
+}
+function restore_injection(previous) {
+  if (previous === void 0) {
+    delete injected.paths;
+    return;
+  }
+  injected.paths = previous;
+}
+function with_paths(paths, body) {
+  const previous = injected.paths;
+  injected.paths = paths;
+  try {
+    return body();
+  } finally {
+    restore_injection(previous);
+  }
+}
+var test_declared_changed = { current_verdict, path_of, read_changed_paths_sync, with_paths };
+
+// scripts/rules/test-declared-commit.ts
+function is_untested_commit(call) {
+  if (!run_tail_rule.is_push_step_call(call)) return false;
+  return test_declared_changed.current_verdict() === "required";
+}
+var REASON3 = "\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 ROW23 = {
+  id: "test-declared",
+  is_trigger: is_untested_commit,
+  reason: REASON3,
+  about: {
+    title: "Test declaration",
+    topic: "`CLAUDE.md` \u2192 Code Change Rules",
+    fires: "`pnpm josh git -y` (`josh g`) while `pnpm josh test:declared` answers `required`",
+    quiet: "`exempt` (non-runtime only) or `satisfied` (tests included)"
+  }
+};
+var test_declared_commit = { REASON: REASON3, ROW: ROW23 };
+
+// scripts/rules/third-party-write.ts
+function is_third_party_write_segment(segment, session_owner, resolve_placeholder_owners) {
+  if (!gh_api.is_gh_api(segment) || !gh_api.is_write(segment)) return false;
+  const target = gh_api.repo_target(segment);
+  if (target === void 0) return false;
+  if (!gh_api.is_owner_placeholder(target.owner)) {
+    return repo_party.classify(session_owner, target.owner) === repo_party.THIRD_PARTY;
+  }
+  return resolve_placeholder_owners().some(
+    (owner) => owner === void 0 || repo_party.classify(session_owner, owner) === repo_party.THIRD_PARTY
+  );
+}
+var GH_CONTEXT_CHANGE = /(?:^|\s)(?:cd|pushd)(?:\s|$)|(?:^|\s)(?:export\s+)?GH_REPO=/u;
+function unreadable_candidates() {
+  return [void 0];
+}
+function candidates_at(segments, index, resolve_placeholder_owners) {
+  const has_moved = segments.slice(0, index).some((segment) => GH_CONTEXT_CHANGE.test(segment));
+  return has_moved ? unreadable_candidates : resolve_placeholder_owners;
+}
+function writes_third_party(command, resolve_owner = repo_party.current_owner, resolve_placeholder_owners = repo_party.placeholder_owners) {
+  const segments = shell_segments.segments_of(command);
+  const has_write = segments.some(
+    (segment) => gh_api.is_gh_api(segment) && gh_api.is_write(segment)
+  );
+  if (!has_write) return false;
+  const session_owner = resolve_owner();
+  return segments.some(
+    (segment, index) => is_third_party_write_segment(
+      segment,
+      session_owner,
+      candidates_at(segments, index, resolve_placeholder_owners)
+    )
+  );
+}
+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 ROW24 = {
+  id: "third-party-write",
+  is_trigger: bash_triggers.on_bash_command((command) => writes_third_party(command)),
+  reason: THIRD_PARTY_WRITE_REASON,
+  decide: () => true,
+  about: {
+    title: "Third-party write",
+    topic: "`upstream-interrupt.md`",
+    fires: "a `gh api` write (field flag or a write method) to a repository whose owner is not this session. Every occurrence",
+    quiet: "a read, or a first-party owner (`pnpm josh repo:party`)"
+  }
+};
+var third_party_write = {
+  ROW: ROW24,
+  THIRD_PARTY_WRITE_REASON,
+  writes_third_party
+};
+
+// scripts/rules/timed-rerun.ts
+var TIMED_SEGMENT = /^\s*(?:[A-Za-z_]\w*=\S*\s+)*(?:\S*\/)?(?:time|hyperfine)\s/u;
+function is_timed_run(command) {
+  return shell_segments.quote_aware_commands_of(command).some((segment) => TIMED_SEGMENT.test(segment));
+}
+var RECORD_READ = /\bgh\s+api\b.*\/actions\/runs\b|\bjosh\s+(?:lane:stats|lst)\b/u;
+function reads_the_record(command) {
+  return RECORD_READ.test(command);
+}
+function measures_duration(command) {
+  return reads_the_record(command) || is_timed_run(command);
+}
+var TIMED_RERUN_REASON = "\u26D4 timed re-run: a CI or gate duration is already on record \u2014 read the Actions jobs with `gh api \u2026/actions/runs/<run_id>/jobs` or the gate timings with `pnpm josh lane:stats`. Re-run only when the record cannot answer: reissue the same command once, and post the result on the Issue (`prompts/collaboration-workflow/measurement.md`).";
+var ROW25 = {
+  id: "timed-rerun",
+  is_trigger: bash_triggers.on_bash_command(is_timed_run),
+  reason: TIMED_RERUN_REASON,
+  keeps: bash_triggers.on_bash_command(reads_the_record),
+  reaches: bash_triggers.on_bash_command(measures_duration),
+  about: {
+    title: "Timed re-run",
+    topic: "`measurement.md`",
+    fires: "a command timed with `time` / `/usr/bin/time` / `hyperfine`",
+    quiet: "the duration is read from the Actions jobs or `pnpm josh lane:stats`"
+  }
+};
+var timed_rerun = {
+  ROW: ROW25,
+  TIMED_RERUN_REASON,
+  is_timed_run,
+  reads_the_record
+};
+
+// scripts/rules/delivered-rules.ts
+var SWITCH_ENV_KEY3 = "JOSH_RULE_GUARD";
+var PRETOOL_GUARD = "pnpm josh pretool:guard";
+var STAMP_PREFIX3 = "josh-rule-guard-";
+var { is_issue_filing, on_bash_command } = bash_triggers;
+var { SHELL_BODY_REASON: SHELL_BODY_REASON2, carries_a_body: carries_a_body2, is_shell_evaluated_body: is_shell_evaluated_body2, keeps_body_safe: keeps_body_safe2 } = shell_body_trigger;
+var DELIVERED_RULES = [
+  // First: a third-party write is stopped before the first-party filing rows count anything.
+  third_party_write.ROW,
+  // The direct call only; `filing-cap` below triggers on `issue:file`. The WIP cap and the fold
+  // question are `issue:file`'s own steps, so no row gates them.
+  direct_filing.ROW,
+  // Before the body rows: a comment posted by hand is refused whatever its body, and the command it
+  // points at takes the body by path, so the body rows have nothing left to say.
+  direct_issue_comment.ROW,
+  filing_cap.ROW,
+  issue_comments.ROW,
+  {
+    id: "shell-body",
+    is_trigger: on_bash_command(is_shell_evaluated_body2),
+    reason: SHELL_BODY_REASON2,
+    keeps: on_bash_command(keeps_body_safe2),
+    reaches: on_bash_command(carries_a_body2),
+    about: {
+      title: "No body on the shell",
+      topic: "`shell-body.md`",
+      fires: 'a double-quoted body value (`-f body="\u2026"` / `-f "body=\u2026"` / `--body "\u2026"` / `--notify-message "\u2026"`) carrying a backtick or `$`',
+      quiet: "the shell does not evaluate the body"
+    }
+  },
+  raw_field_body.ROW,
+  {
+    id: "piped-verification",
+    is_trigger: on_bash_command(piped_verification.is_masked_verification),
+    reason: piped_verification.PIPED_VERIFICATION_REASON,
+    keeps: on_bash_command(piped_verification.keeps_verdict_intact),
+    reaches: on_bash_command(piped_verification.runs_verification),
+    // 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,
+    about: {
+      title: "Piped verification",
+      topic: "`output-bounds.md`",
+      fires: "a pass/fail josh check (`gate` / `check` / `lint*` / `cspell*` / `test*` / `eval` / `overrides` / `ranges`) in front of a pipe \u2014 rewritten under `set -o pipefail` when every filter is `tail` or a full-reading `grep`, refused otherwise",
+      quiet: "the exit code reaches the caller \u2014 a failure reads as a failure"
+    }
+  },
+  {
+    id: "early-heartbeat",
+    is_trigger: on_bash_command(early_heartbeat.is_wait_timer),
+    reason: early_heartbeat.EARLY_HEARTBEAT_REASON,
+    decide: early_heartbeat.decide,
+    keeps: on_bash_command(early_heartbeat.is_progress_watch),
+    reaches: on_bash_command(early_heartbeat.waits_for_progress),
+    about: {
+      title: "Early progress report",
+      topic: '`.claude/skills/workflow-commands/progress-watcher.md` \u2192 "Progress while the run is quiet"',
+      fires: "a `Bash` whose only purpose is waiting (`sleep` alone, or `echo` / `:` / `date`) while a timer is live or before the interval. Every occurrence",
+      quiet: "no hand-made wait timer \u2014 `run:progress` holds the one clock"
+    }
+  },
+  // Before `run-tail`: whether to commit at all is decided before how to push.
+  test_declared_commit.ROW,
+  // Before `run-tail`, so a lane child goes straight to `ship --detach` instead of through both.
+  lane_background.ROW,
+  // Reads `run_in_background` beside the command; `decide`, since a push recurs.
+  {
+    id: "run-tail",
+    is_trigger: run_tail_rule.is_foreground_push_step,
+    reason: run_tail_rule.RUN_TAIL_REASON,
+    decide: run_tail_rule.decide,
+    keeps: run_tail_rule.is_backgrounded_push_step,
+    reaches: run_tail_rule.is_push_step_call,
+    about: {
+      title: "Idle run tail",
+      topic: "`.claude/skills/workflow-commands/background-commands.md`",
+      fires: "`pnpm josh git -y` (`josh g`, `--yes` alike) issued in the **foreground**. Every occurrence",
+      quiet: "issued in the background \u2014 its completion resumes the run"
+    }
+  },
+  // Reads the lane name and the cut record. Once per run, not `decide`: taking the cut ends the
+  // process, and the verdicts that leave a run at the gate all need the reissue through. `reaches`
+  // tells the cutting run from the resumed one by the run's calls. Overlaps `piped-verification`
+  // safely: that row speaks first and this one delivers on the reissue.
+  {
+    id: "pre-gate-cut",
+    is_trigger: on_bash_command(pre_gate_cut.is_uncut_gate),
+    reason: pre_gate_cut.PRE_GATE_CUT_REASON,
+    keeps: on_bash_command(pre_gate_cut.takes_the_cut),
+    reaches: pre_gate_cut.reaches_the_pre_gate_boundary,
+    about: {
+      title: "The cut before the gate",
+      topic: "`.claude/skills/workflow-commands/pre-gate-cut.md`",
+      fires: "`pnpm josh gate` (`josh ga`) in a lane work tree whose `JOSH_LANE_CHILD` names the Issue and has no cut record",
+      quiet: "outside a lane, no marker (a person in the lane), or already cut"
+    }
+  },
+  // A split child's park is refused before `lane-park` sees it.
+  lane_split_park.ROW,
+  lane_park.ROW,
+  lane_interactive_ask.ROW,
+  agent_model.ROW,
+  lane_carry_conflict.ROW,
+  lane_switch_main.ROW,
+  // Before `lane-direct-tool`, its one overlap (a timed tool in a lane): the record is the right first
+  // act, and `lane-direct-tool` delivers on the reissue of a `time`-prefixed tool.
+  timed_rerun.ROW,
+  lane_direct_tool.ROW,
+  // Disjoint from `run-tail` by the `-y` flag.
+  josh_git_bare.ROW,
+  // The Bash-string gaps the deny glob cannot express, read by argv; `delivered-rules-bash.test.ts`
+  // pins that no two rows claim one command.
+  git_force.ROW,
+  worktree_guard.ROW,
+  file_body.ROW,
+  ...permission_guards.ROWS,
+  poll_loop.ROW,
+  // Before `rule-body`, its one overlap: the cut is the right first act, and `rule-body` delivers on
+  // the reissue in the fresh process.
+  implementation_cut.ROW,
+  rule_body_guard.ROW,
+  ...oracle_consulted.ROWS
+];
+var ALONE_IN_TURN = 1;
+function batches_the_turn(call, turn) {
+  return time_batch_guard.is_guarded_call(call) && turn.length > ALONE_IN_TURN;
+}
+var BATCHING_RULE = {
+  id: "batching",
+  reason: time_batch_guard.REASON,
+  keeps: batches_the_turn,
+  reaches: time_batch_guard.is_guarded_call,
+  about: {
+    title: "Turn batching",
+    topic: "`turn-batching.md`",
+    fires: "the `Bash` / `Edit` / `Read` after three single-call turns in a row; fires **again** every three more such turns",
+    quiet: "calls per round trip above the floor"
+  }
+};
+var INVESTIGATION_RULE = {
+  id: "investigation",
+  reason: investigation_reads.REASON,
+  reaches: investigation_reads.is_refusable_call,
+  about: {
+    title: "Investigation delegation threshold",
+    topic: "`delegation.md`",
+    fires: "the `Read` / `Bash` that makes the third read of a file the run will not edit; fires **again** once reads pile up to the threshold again",
+    quiet: "reads under the threshold \u2014 nothing to delegate yet"
+  }
+};
+var MEASURED_RULES = [
+  ...DELIVERED_RULES,
+  BATCHING_RULE,
+  INVESTIGATION_RULE
+];
+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, run) {
+  if (lane_guard_policy.mode_here("batching") !== "refuse") return false;
+  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, run) {
+  return delivered_at_ms === hook_decision.NEVER_MS && !will_batch_guard_refuse(tail, call, run);
+}
+function delivery_decision(rule) {
+  const { decide: decide4, already_satisfied } = rule;
+  if (decide4 === void 0 && already_satisfied === void 0) return is_first_delivery;
+  return function should_block3(tail, call, delivered_at_ms, run) {
+    if (already_satisfied?.(tail, call) === true) return false;
+    if (decide4 === void 0) return true;
+    return decide4(call, run, !will_batch_guard_refuse(tail, call, run), delivered_at_ms);
+  };
+}
+function guard_of(rule) {
+  return hook_decision.create_transcript_guard({
+    prefix: `${STAMP_PREFIX3}${rule.id}-`,
+    switch_key: SWITCH_ENV_KEY3,
+    is_candidate: rule.is_trigger,
+    should_block: delivery_decision(rule),
+    reason: rule.reason
+  });
+}
+var GUARDS = new Map(DELIVERED_RULES.map((rule) => [rule.id, guard_of(rule)]));
+function delivery_path(rule_id, transcript_path) {
+  return GUARDS.get(rule_id)?.refusal_path(transcript_path) ?? "";
+}
+function delivery(raw_payload, now_ms = Date.now()) {
+  for (const guard of GUARDS.values()) {
+    const reason = guard.refusal(raw_payload, now_ms);
+    if (reason !== void 0) return reason;
+  }
+  return void 0;
+}
+function is_enabled3() {
+  return hook_decision.is_switch_enabled(SWITCH_ENV_KEY3);
+}
+var delivered_rules = {
+  DELIVERED_RULES,
+  EARLY_HEARTBEAT_REASON: early_heartbeat.EARLY_HEARTBEAT_REASON,
+  FILE_BODY_REASON: file_body.FILE_BODY_REASON,
+  DIRECT_FILING_REASON: direct_filing.DIRECT_FILING_REASON,
+  FILING_CAP_REASON: filing_cap.FILING_CAP_REASON,
+  GIT_FORCE_REASON: git_force.GIT_FORCE_REASON,
+  ISSUE_COMMENTS_REASON: issue_comments.ISSUE_COMMENTS_REASON,
+  LANE_INTERACTIVE_ASK_REASON: lane_interactive_ask.LANE_INTERACTIVE_ASK_REASON,
+  LANE_PARK_REASON: lane_park.LANE_PARK_REASON,
+  MEASURED_RULES,
+  PIPED_VERIFICATION_REASON: piped_verification.PIPED_VERIFICATION_REASON,
+  POLL_LOOP_REASON: poll_loop.POLL_LOOP_REASON,
+  PRE_GATE_CUT_REASON: pre_gate_cut.PRE_GATE_CUT_REASON,
+  PRETOOL_GUARD,
+  RAW_FIELD_BODY_REASON: raw_field_body.RAW_FIELD_BODY_REASON,
+  RUN_TAIL_REASON: run_tail_rule.RUN_TAIL_REASON,
+  SHELL_BODY_REASON: SHELL_BODY_REASON2,
+  SWITCH_ENV_KEY: SWITCH_ENV_KEY3,
+  THIRD_PARTY_WRITE_REASON: third_party_write.THIRD_PARTY_WRITE_REASON,
+  WORKTREE_MUTATION_REASON: worktree_guard.WORKTREE_MUTATION_REASON,
+  delivery,
+  delivery_path,
+  is_body_only_issue_read: issue_comments.is_body_only_issue_read,
+  is_enabled: is_enabled3,
+  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-issue-comment": judgment(ANOTHER_COMMAND),
+  "direct-pr-create": judgment(ANOTHER_COMMAND),
+  "pr-merge": 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),
+  "lane-direct-tool": judgment(ANOTHER_COMMAND),
+  "timed-rerun": 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";
+
+// scripts/lane/lane-report.ts
+var NO_LANES2 = "No lanes are 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_STATE;
+}
+function value_or_unknown(value) {
+  return value === void 0 ? UNKNOWN_VALUE : String(value);
+}
+function output_column(output) {
+  return `output ${output ?? UNKNOWN_VALUE}`;
+}
+function profile_column(lane) {
+  return `profile ${lane.profile === void 0 ? UNKNOWN_VALUE : agent_role_profile.describe(lane.profile)}`;
+}
+function event_column(lane) {
+  if (lane.output === void 0) return "agent -";
+  const state = run_liveness.describe_agent_state(lane.output);
+  return state ?? "agent -";
+}
+var PLAIN_CITE = issue_cite.citer(void 0, /* @__PURE__ */ new Map());
+function describe_lane(lane, cite = PLAIN_CITE) {
+  return [
+    cite(lane.issue),
+    `seat ${value_or_unknown(lane.seat)}`,
+    `dev ${value_or_unknown(lane.development_port)}`,
+    `preview ${value_or_unknown(lane.preview_port)}`,
+    lane.branch,
+    lane_state(lane),
+    lane.directory,
+    output_column(lane.output),
+    profile_column(lane),
+    event_column(lane)
+  ].join(COLUMN_SEPARATOR);
+}
+function describe_lanes(lanes, cite = PLAIN_CITE) {
+  if (lanes.length === 0) return NO_LANES2;
+  return lanes.map((lane) => describe_lane(lane, cite)).join("\n");
+}
+function describe_ports(lane) {
+  if (lane.seat === void 0) return "no lane seat could be read";
+  return `seat ${String(lane.seat)}, dev ${value_or_unknown(lane.development_port)}, preview ${value_or_unknown(lane.preview_port)}`;
+}
+function describe_opened(lane) {
+  return `Opened a lane for ${session_cite.issue(lane.issue)} on ${lane.branch}: ${describe_ports(lane)}.`;
+}
+var lane_report = {
+  NO_LANES: NO_LANES2,
+  OPEN_STATE,
+  STRANDED_STATE,
+  UNREADABLE_STATE,
+  describe_lane,
+  describe_lanes,
+  describe_opened,
+  lane_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;
+var IDLE_READ = { kind: "idle" };
+var UNREADABLE_READ = { kind: "unreadable" };
+async function worktree_git_directory() {
+  const [git_directory] = await git_command.git_directories();
+  return git_directory;
+}
+async function stamp_target() {
+  return run_progress_clock.stamp_target_of(await worktree_git_directory());
+}
+async function log_target() {
+  return run_progress_clock.log_path_of(await stamp_target());
+}
+async function live_target() {
+  return run_progress_clock.life_target_of(await worktree_git_directory());
+}
+function to_labels(issue) {
+  return (issue.labels ?? []).map((label) => label.name);
+}
+async function to_child(issue) {
+  const number = String(issue.number);
+  const child = await run_preflight.read_child_state(number);
+  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)));
+}
+async function read_lanes() {
+  const lanes = await lane_registry.list_lanes();
+  return lanes.map((lane) => ({ issue: lane.issue, state: lane_report.lane_state(lane) }));
+}
+function is_mtime(value) {
+  return value !== void 0;
+}
+function read_record_age(paths, now_ms) {
+  const times = paths.map((output_path) => run_liveness.sample_output(output_path)?.mtime_ms).filter(is_mtime);
+  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_carry_present(read2) {
+  return read2.kind === "carried";
+}
+function hold_present(worktree) {
+  return worktree !== void 0 && is_hold_present(run_hold.read_hold(run_hold.hold_path(worktree)));
+}
+function carry_present(repository) {
+  if (repository === void 0) return false;
+  return is_carry_present(run_carry.read_carry(run_carry.carry_path(repository)));
+}
+async function has_run_record() {
+  const [worktree, repository] = await git_command.git_directories();
+  return hold_present(worktree) || carry_present(repository);
+}
+async function has_run_started(lanes) {
+  return lanes.length > 0 || await has_run_record();
+}
+async function read_observations(request) {
+  const [children, lanes] = await Promise.all([read_children(request.repo), read_lanes()]);
+  if (children === void 0) return UNREADABLE_READ;
+  if (children.length === 0 && !await has_run_started(lanes)) return IDLE_READ;
+  const observations = {
+    repo: request.repo,
+    children,
+    lanes,
+    load_average: loadavg()[FIRST_LOAD_AVERAGE] ?? 0,
+    record_age_ms: read_record_age(request.output_paths, request.now_ms)
+  };
+  return { kind: "observed", observations };
+}
+var run_progress_read = {
+  has_run_started,
+  live_target,
+  log_target,
+  mark: mark2,
+  parse_stamp: parse_stamp2,
+  read_children,
+  read_last_report: read_last_report2,
+  read_lanes,
+  read_observations,
+  read_record_age,
+  stamp_target
+};
+
+// scripts/run/run-watcher-hook.ts
+import { z as z5 } from "zod";
+
+// scripts/run/run-watcher-guard.ts
+var WATCHER_TICK_MS = 3e4;
+var TICK_MULTIPLIER = 3;
+var STALE_THRESHOLD_MS = WATCHER_TICK_MS * TICK_MULTIPLIER;
+var STALE_THRESHOLD_S = STALE_THRESHOLD_MS / MS_PER_SECOND;
+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 check(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
+};
+
+// scripts/run/run-watcher-hook.ts
+var SWITCH_ENV_KEY4 = "JOSH_WATCHER_GUARD";
+var STAMP_PREFIX4 = "josh-watcher-guard-";
+var payload_schema = z5.object({ transcript_path: z5.string().min(1) });
+function transcript_of(raw_payload) {
+  return json_value.parse_with(raw_payload, payload_schema)?.transcript_path;
+}
+function fires_once(transcript, now_ms) {
+  const stamp = hook_decision.create_refusal_stamp(STAMP_PREFIX4);
+  const target = stamp.path(transcript);
+  if (stamp.last_ms(target) !== hook_decision.NEVER_MS) return false;
+  return stamp.record(target, now_ms);
+}
+function is_active() {
+  return hook_decision.is_switch_enabled(SWITCH_ENV_KEY4) && lane_child_marker.marked_issue() === void 0;
+}
+async function stale_reason(transcript, now_ms) {
+  const result = await run_watcher_guard.check(await run_progress_read.live_target());
+  if (result.kind === "ok") return void 0;
+  return fires_once(transcript, now_ms) ? result.note : void 0;
+}
+async function watcher_hook_reason(raw_payload, now_ms = Date.now()) {
+  if (!is_active()) return void 0;
+  const transcript = transcript_of(raw_payload);
+  if (transcript === void 0) return void 0;
+  return await stale_reason(transcript, now_ms);
+}
+var run_watcher_hook = { transcript_of, watcher_hook_reason };
+
+// scripts/run/run-parent-cut-hook.ts
+var SWITCH_ENV_KEY5 = "JOSH_PARENT_CUT_GUARD";
+var STAMP_PREFIX5 = "josh-parent-cut-guard-";
+var QUIET_WINDOW_MS = 6e5;
+function current_state2() {
+  return {
+    carry: async () => await run_headless.driving_carry(),
+    verdict: () => implementation_cut_verdict.reused_verdict(() => cost_cli.session_verdict())
+  };
+}
+var THRESHOLD_TEXT2 = `${figure_format.format_tokens(CONTEXT_CUT_THRESHOLD)}-token`;
+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_due2(state) {
+  const carry = await state.carry();
+  if (carry === void 0 || run_headless.is_cut_capped(carry)) return false;
+  return state.verdict() === cost_verdict.OVER_VERDICT;
+}
+function is_quiet(target, now_ms) {
+  const last_ms = hook_decision.create_refusal_stamp(STAMP_PREFIX5).last_ms(target);
+  return last_ms !== hook_decision.NEVER_MS && now_ms - last_ms < QUIET_WINDOW_MS;
+}
+async function refusal_for(transcript, now_ms, state) {
+  const stamp = hook_decision.create_refusal_stamp(STAMP_PREFIX5);
+  const target = stamp.path(transcript);
+  if (is_quiet(target, now_ms) || !await is_due2(state)) return void 0;
+  return stamp.record(target, now_ms) ? PARENT_CUT_REASON : void 0;
+}
+function is_unit_call(raw_payload) {
+  try {
+    return (hook_decision.parse_hook_payload(raw_payload)?.agent_id ?? "") !== "";
+  } catch (error) {
+    error_text.trace_swallowed("run_parent_cut_hook.is_unit_call", error);
+    return false;
+  }
+}
+function is_exempt2(raw_payload) {
+  return !hook_decision.is_switch_enabled(SWITCH_ENV_KEY5) || is_unit_call(raw_payload);
+}
+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;
+  return await refusal_for(transcript, now_ms, state);
+}
+var run_parent_cut_hook = {
+  PARENT_CUT_REASON,
+  QUIET_WINDOW_MS,
+  SWITCH_ENV_KEY: SWITCH_ENV_KEY5,
+  parent_cut_reason
+};
+
+// scripts/run/run-poll-hook.ts
+var SWITCH_ENV_KEY6 = "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_PREFIX3 = "-";
+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_PREFIX3)).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_KEY6) ? 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_KEY6,
+  poll_reason,
+  safe_poll_reason
+};
+
+// scripts/hooks/batch-guard.ts
+var SWITCH_ENV_KEY7 = "JOSH_BATCH_GUARD";
+function is_batch_candidate(call) {
+  return time_batch_guard.is_guarded_call(call) || time_batch_guard.is_notice_call(call);
+}
+function batching_mode() {
+  return lane_guard_policy.mode_here("batching");
+}
+function is_candidate3(call) {
+  return is_batch_candidate(call) && batching_mode() !== "off";
+}
+function should_block_here2(tail, call, refused_at_ms) {
+  if (batching_mode() !== "refuse") return false;
+  return time_batch_guard.should_block(tail, call, refused_at_ms);
+}
+function should_notify_here2(tail, call, notified_at_ms) {
+  if (time_batch_guard.should_notify(tail, call, notified_at_ms)) return true;
+  if (batching_mode() !== "notice") return false;
+  return time_batch_guard.should_block(
+    tail,
+    call,
+    notified_at_ms,
+    time_batch_guard.NOTICE_REFIRE_EVERY
+  );
+}
+function notice_text(call, tail) {
+  const base = time_batch_guard.is_notice_call(call) ? time_batch_guard.NOTICE : time_batch_guard.LANE_NOTICE;
+  return `${base}${time_batch_guard.recent_candidates(tail)}`;
+}
+var GUARD3 = hook_decision.create_transcript_guard({
+  prefix: time_batch_guard.STAMP_PREFIX,
+  switch_key: SWITCH_ENV_KEY7,
+  is_candidate: is_candidate3,
+  should_block: should_block_here2,
+  reason: time_batch_guard.REASON,
+  // The whole-file write is notified rather than refused, on a record of its own so it never spends
+  // the refusal's stamp; the lane-child refusable-call notice kit#2164 added
+  // here fires again since kit#2276 restored batching to `notice` in a lane child.
+  notify: {
+    prefix: time_batch_guard.NOTICE_STAMP_PREFIX,
+    should_notify: should_notify_here2,
+    text: notice_text
+  }
+});
+var batch_refusal = GUARD3.refusal;
+var batch_outcome = GUARD3.outcome;
+var { is_enabled: is_enabled4, refusal_path: refusal_path3 } = GUARD3;
+var notice_refusal_path2 = hook_decision.create_refusal_stamp(
+  time_batch_guard.NOTICE_STAMP_PREFIX
+).path;
+var { deny_envelope: deny_envelope3, load_environment_file: load_environment_file2, DISABLED_VALUES: DISABLED_VALUES3 } = hook_decision;
+
+// scripts/hooks/shell-rules-notice.ts
+var STAMP_PREFIX6 = "josh-shell-rules-notice-";
+var NOTICE2 = "Shell rules: change an existing file with Edit or Write, never a script or heredoc that writes it (file-edits.md); run a josh check with no pipe or under `set -o pipefail`, never `| head` (output-bounds.md).";
+var STAMP = hook_decision.create_refusal_stamp(STAMP_PREFIX6);
+function notice(raw_payload) {
+  const payload = hook_decision.parse_hook_payload(raw_payload);
+  if (payload?.tool_name !== cost_blocks.BASH_TOOL) return void 0;
+  const target = STAMP.path(payload.transcript_path);
+  if (STAMP.last_ms(target) !== hook_decision.NEVER_MS || !STAMP.record(target, Date.now())) {
+    return void 0;
+  }
+  return NOTICE2;
+}
+var shell_rules_notice = { NOTICE: NOTICE2, notice, stamp_path: STAMP.path };
+
+// scripts/hooks/step-zero-notice.ts
+import path4 from "node:path";
+var STAMP_PREFIX7 = "josh-step-zero-notice-";
+var EDIT_TOOLS3 = /* @__PURE__ */ new Set(["Edit", "Write"]);
+var PARENT_PREFIX = "..";
+var NOTICE3 = "Before writing any implementation code: present the two-layer work summary (Now / Change / Check, then every change with its test) once per Issue. Full rule: Code Change Rules Step 0 in CLAUDE.md.";
+var STAMP2 = hook_decision.create_refusal_stamp(STAMP_PREFIX7);
+function edited_paths(tool_input) {
+  if (!json_value.is_record(tool_input)) return [];
+  const { file_path, file_paths } = tool_input;
+  const listed = Array.isArray(file_paths) ? file_paths : [];
+  return [file_path, ...listed].filter(
+    (entry) => typeof entry === "string" && entry.length > 0
+  );
+}
+function is_runtime_file(file_path, root) {
+  const relative = path4.relative(root, path4.resolve(root, file_path));
+  if (relative.startsWith(PARENT_PREFIX) || path4.isAbsolute(relative)) return false;
+  return !test_declared_logic.is_exempt(relative.split(path4.sep).join("/"));
+}
+function is_candidate4(raw_payload, root) {
+  const payload = hook_decision.parse_hook_payload(raw_payload);
+  if (payload === void 0 || !EDIT_TOOLS3.has(payload.tool_name)) return void 0;
+  const has_runtime_file = edited_paths(payload.tool_input).some(
+    (file_path) => is_runtime_file(file_path, root)
+  );
+  return has_runtime_file ? payload.transcript_path : void 0;
+}
+function notice2(raw_payload, root = process.cwd()) {
+  const transcript = is_candidate4(raw_payload, root);
+  if (transcript === void 0) return void 0;
+  const target = STAMP2.path(transcript);
+  if (STAMP2.last_ms(target) !== hook_decision.NEVER_MS || !STAMP2.record(target, Date.now())) {
+    return void 0;
+  }
+  return NOTICE3;
+}
+var step_zero_notice = { NOTICE: NOTICE3, notice: notice2, stamp_path: STAMP2.path };
+
+// scripts/hooks/pretool-guard.ts
+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 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_session_notice(outcome, raw_payload) {
+  if (!is_clear(outcome)) return outcome;
+  const notice3 = step_zero_notice.notice(raw_payload) ?? shell_rules_notice.notice(raw_payload);
+  return notice3 === void 0 ? outcome : { reason: void 0, notice: notice3, fault: void 0 };
+}
+function guard_outcome(raw_payload) {
+  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_session_notice(guard_outcome(raw_payload), raw_payload);
+}
+async function mark_phase(outcome) {
+  if (outcome.notice === step_zero_notice.NOTICE) await lane_phase.mark_implement();
+}
+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);
+  const poll = cut ?? await run_poll_hook.safe_poll_reason(raw_payload);
+  return poll ?? await issue_watch_hook.watch_reason();
+}
+async function pretool_outcome_async(raw_payload) {
+  const base = guard_outcome(raw_payload);
+  if (!is_clear(base)) return base;
+  const reason = await async_reason(raw_payload);
+  if (reason !== void 0) return { reason, notice: void 0, fault: void 0 };
+  const outcome = with_session_notice(base, raw_payload);
+  await mark_phase(outcome);
+  return outcome;
+}
+function guarded_call(raw_payload) {
+  try {
+    const payload = hook_decision.parse_hook_payload(raw_payload);
+    return payload === void 0 ? void 0 : { name: payload.tool_name, input: payload.tool_input };
+  } catch {
+    return void 0;
+  }
+}
+function rewrite_context(note, outcome) {
+  return [note, outcome.notice ?? outcome.fault].filter(Boolean).join("\n\n");
+}
+function foreground_input_of(raw_payload, is_lane_child) {
+  const call = guarded_call(raw_payload);
+  return call === void 0 ? void 0 : lane_background.foreground_input(call, is_lane_child);
+}
+function foreground_rewrite(outcome, raw_payload, is_lane_child, rewrite3) {
+  const input = outcome.reason === void 0 ? foreground_input_of(raw_payload, is_lane_child) : void 0;
+  if (input === void 0) return void 0;
+  const note = [rewrite3?.note, lane_background.FOREGROUND_NOTE].filter(Boolean).join("\n\n");
+  const envelope_of = rewrite3 === void 0 ? hook_decision.rewrite_envelope : hook_decision.flow_rewrite_envelope;
+  return envelope_of(input, rewrite_context(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, rewrite3) {
+  const envelope = foreground_rewrite(outcome, raw_payload, void 0, rewrite3) ?? rule_envelope(outcome, rewrite3);
+  if (envelope === void 0) hook_decision.emit_outcome(outcome);
+  else process.stdout.write(`${envelope}
+`);
+}
+async function respond(raw_payload) {
+  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,
+  pretool_outcome,
+  respond
+};
+
+export {
+  pretool_guard
+};