@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/dist/hooks/chunk-CQD4LJE6.js

@@ -0,0 +1,4858 @@
+import {
+  bash_triggers,
+  concise_reply,
+  cost_cli,
+  cost_verdict,
+  delegation_policy,
+  doctor_consumer,
+  duplicate_read_outcome,
+  epic_busy,
+  git_argv,
+  hook_decision,
+  interactive_ask,
+  investigation_reads,
+  lane_background,
+  lane_guard_policy,
+  lane_park,
+  lane_plan,
+  pre_gate_cut,
+  project_checks,
+  repo_party,
+  run_cut,
+  run_cut_handoff,
+  run_liveness,
+  run_stage,
+  run_tail_rule,
+  shell_segments,
+  stop_rules,
+  tail_commands
+} from "./chunk-5PM2JRGV.js";
+import {
+  cost_blocks,
+  time_batch_guard,
+  time_density_hook,
+  time_hook_transcript,
+  time_markers,
+  time_shell,
+  time_spans,
+  time_transcript_line
+} from "./chunk-Z6DQJKH3.js";
+import {
+  agent_role_profile,
+  agent_session_role,
+  issue_watch,
+  issue_watch_gate,
+  lane_child_marker,
+  lane_registry,
+  run_headless,
+  run_hold,
+  run_preflight,
+  test_declared_logic,
+  token_shape
+} from "./chunk-3GKE653K.js";
+import {
+  PACKAGE_JSON,
+  ancestor_directories,
+  file_reader,
+  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-7SIUNQXK.js";
+import {
+  MS_PER_MINUTE,
+  MS_PER_SECOND,
+  PORCELAIN_FLAG,
+  UNTRACKED_FILES_FLAG,
+  error_text,
+  git_command,
+  git_common_directory,
+  git_diff_reads,
+  git_spawn_sync,
+  platform_temporary,
+  stamp_file
+} from "./chunk-45CJJOO7.js";
+
+// scripts/delegation/investigation-guard.ts
+var SWITCH_ENV_KEY = "JOSH_INVESTIGATION_GUARD";
+var STAMP_PREFIX = "josh-investigation-guard-";
+function should_block(tail, call, refused_at_ms2, 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_ms2, run);
+}
+var GUARD = hook_decision.create_transcript_guard({
+  prefix: STAMP_PREFIX,
+  switch_key: SWITCH_ENV_KEY,
+  is_candidate: investigation_reads.is_refusable_call,
+  should_block,
+  reason: investigation_reads.REASON
+});
+var investigation_refusal = GUARD.refusal;
+var investigation_outcome = GUARD.outcome;
+var { is_enabled, refusal_path } = GUARD;
+var { deny_envelope, load_environment_file, DISABLED_VALUES } = hook_decision;
+var STAMP = hook_decision.create_refusal_stamp(STAMP_PREFIX);
+function will_refuse(tail, call, run) {
+  if (!is_enabled() || !investigation_reads.is_refusable_call(call)) return false;
+  return should_block(tail, call, STAMP.last_ms(STAMP.path(run.transcript)), run);
+}
+
+// scripts/issue/issue-watch-hook.ts
+var POLL_INTERVAL_MS = 18e4;
+var POLL_TIMEOUT_MS = 5e3;
+function is_new_to_run(record2) {
+  const news = record2 === void 0 ? void 0 : issue_watch.news_of(record2);
+  return news !== void 0 && news !== record2?.shown;
+}
+function message_of(record2) {
+  return record2.pending === void 0 ? record2.notice ?? "" : issue_watch_gate.unread_message(record2);
+}
+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 message_of(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/hooks/batch-guard.ts
+var SWITCH_ENV_KEY2 = "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_search_refused_here() {
+  return lane_guard_policy.mode_here("search-batching") === "refuse";
+}
+function is_candidate(call) {
+  if (batching_mode() !== "off") return is_batch_candidate(call);
+  return is_search_refused_here() && time_batch_guard.is_search_chain_call(call);
+}
+function should_block_here(tail, call, refused_at_ms2, run) {
+  if (batching_mode() === "refuse") return time_batch_guard.should_block(tail, call, refused_at_ms2);
+  if (!is_search_refused_here() || will_refuse(tail, call, run)) return false;
+  return time_batch_guard.should_block_search_chain(tail, call, refused_at_ms2);
+}
+function should_notify_here(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 GUARD2 = hook_decision.create_transcript_guard({
+  prefix: time_batch_guard.STAMP_PREFIX,
+  switch_key: SWITCH_ENV_KEY2,
+  is_candidate,
+  should_block: should_block_here,
+  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 refusable-call notice fires only under a `notice`-mode batching row.
+  notify: {
+    prefix: time_batch_guard.NOTICE_STAMP_PREFIX,
+    should_notify: should_notify_here,
+    text: notice_text
+  }
+});
+var batch_refusal = GUARD2.refusal;
+var batch_outcome = GUARD2.outcome;
+var { is_enabled: is_enabled2, refusal_path: refusal_path2 } = GUARD2;
+var notice_refusal_path = hook_decision.create_refusal_stamp(
+  time_batch_guard.NOTICE_STAMP_PREFIX
+).path;
+var { deny_envelope: deny_envelope2, load_environment_file: load_environment_file2, DISABLED_VALUES: DISABLED_VALUES2 } = hook_decision;
+var STAMP2 = hook_decision.create_refusal_stamp(time_batch_guard.STAMP_PREFIX);
+function will_refuse2(tail, call, run) {
+  if (!is_enabled2() || !is_candidate(call)) return false;
+  return should_block_here(tail, call, STAMP2.last_ms(STAMP2.path(run.transcript)), run);
+}
+
+// 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, SUBAGENT_TOOLS, is_unnamed_model };
+
+// 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 GH_COMMAND = "gh";
+var METHOD_FLAGS = /* @__PURE__ */ new Set(["-X", "--method"]);
+var ATTACHED_METHOD = /^(?:-X=?|--method=)([A-Za-z]+)$/u;
+var FIELD_FLAGS = /* @__PURE__ */ new Set(["-f", "-F", "--field", "--raw-field", "--input"]);
+var ATTACHED_FIELD = /^(?:-[fF].|--(?:raw-field|field|input)=)/u;
+var QUOTES = /['"]/gu;
+var FLAG_PREFIX = "-";
+var NEXT = 1;
+var READ_METHOD = "GET";
+var API_VALUE_TAKING_FLAGS = /* @__PURE__ */ new Set([
+  "-R",
+  "--repo",
+  ...METHOD_FLAGS,
+  ...FIELD_FLAGS,
+  "-H",
+  "--header",
+  "-q",
+  "--jq",
+  "-t",
+  "--template",
+  "--hostname",
+  "-p",
+  "--preview",
+  "--cache"
+]);
+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 flags_of(segment) {
+  const words = git_argv.arguments_of(segment, GH_COMMAND) ?? [];
+  return words.map((word, index) => [word, words[index + NEXT] ?? ""]).filter(([word], index) => {
+    if (!word.startsWith(FLAG_PREFIX)) return false;
+    return !API_VALUE_TAKING_FLAGS.has(words[index - NEXT] ?? "");
+  });
+}
+function method_value(flag, next) {
+  if (METHOD_FLAGS.has(flag)) return next.replaceAll(QUOTES, "");
+  return ATTACHED_METHOD.exec(flag)?.[1];
+}
+function method_of(segment) {
+  const methods = flags_of(segment).map(([flag, next]) => method_value(flag, next));
+  return methods.findLast((method) => method !== void 0)?.toUpperCase();
+}
+function is_field_flag(flag) {
+  return FIELD_FLAGS.has(flag) || ATTACHED_FIELD.test(flag);
+}
+function is_read(segment) {
+  const method = method_of(segment);
+  if (method !== void 0) return method === READ_METHOD;
+  return flags_of(segment).every(([flag]) => !is_field_flag(flag));
+}
+function is_write(segment) {
+  return !is_read(segment);
+}
+var INPUT_FLAG = "--input";
+var READS_FILE_FLAGS = /* @__PURE__ */ new Set(["-F", "--field"]);
+var ATTACHED_PARTS = /^(-[fF]|--(?:raw-field|field|input))=?(.+)$/u;
+var ATTACHED_FLAG_GROUP = 1;
+var ATTACHED_VALUE_GROUP = 2;
+var FILE_PREFIX = "@";
+var STANDARD_INPUT = "-";
+var FIELD_KEY_END = "=";
+function field_parts(flag, next) {
+  if (FIELD_FLAGS.has(flag)) return [flag, next];
+  const match = ATTACHED_PARTS.exec(flag);
+  if (match === null) return void 0;
+  return [String(match[ATTACHED_FLAG_GROUP]), String(match[ATTACHED_VALUE_GROUP])];
+}
+function field_value(value) {
+  return value.slice(value.indexOf(FIELD_KEY_END) + NEXT);
+}
+function file_path(flag, value) {
+  if (flag === INPUT_FLAG) return value;
+  const sent = field_value(value);
+  if (!READS_FILE_FLAGS.has(flag) || !sent.startsWith(FILE_PREFIX)) return void 0;
+  return sent.slice(FILE_PREFIX.length);
+}
+function field_source(flag, raw) {
+  const value = raw.replaceAll(QUOTES, "");
+  const path4 = file_path(flag, value);
+  if (path4 === void 0) return { kind: "text", value: field_value(value) };
+  return path4 === STANDARD_INPUT ? void 0 : { kind: "file", value: path4 };
+}
+function field_sources(segment) {
+  return flags_of(segment).flatMap(([flag, next]) => {
+    const parts = field_parts(flag, next);
+    const source = parts === void 0 ? void 0 : field_source(...parts);
+    return source === void 0 ? [] : [source];
+  });
+}
+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 = {
+  API_VALUE_TAKING_FLAGS,
+  GH_FLAGS,
+  field_sources,
+  is_gh_api,
+  is_owner_placeholder,
+  is_read,
+  is_write,
+  method_of,
+  repo_target
+};
+
+// scripts/rules/direct-pr-create.ts
+var GH_COMMAND2 = "gh";
+var PR_GROUP = "pr";
+var PR_CREATE_ACTIONS = /* @__PURE__ */ new Set(["create", "new"]);
+var FLAG_PREFIX2 = "-";
+var HELP_FLAGS = /* @__PURE__ */ new Set(["-h", "--help"]);
+var VALUE_TAKING_FLAGS = /* @__PURE__ */ new Set(["-R", "--repo"]);
+var { API_VALUE_TAKING_FLAGS: API_VALUE_TAKING_FLAGS2 } = gh_api;
+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_PREFIX2)) return false;
+    return !value_taking_flags.has(args[index - 1] ?? "");
+  });
+}
+function is_pr_create_api_call(args) {
+  const call = [GH_COMMAND2, ...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_FLAGS2);
+  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_PREFIX2)
+  );
+}
+function is_pr_create_segment(segment) {
+  const args = git_argv.arguments_of(segment, GH_COMMAND2);
+  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 (`operating-rules.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 ROW2 = {
+  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: '`operating-rules.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: API_VALUE_TAKING_FLAGS2,
+  DIRECT_PR_CREATE_REASON,
+  GH_COMMAND: GH_COMMAND2,
+  ROW: ROW2,
+  VALUE_TAKING_FLAGS,
+  has_run_segment,
+  is_direct_pr_create,
+  is_help_call,
+  positional_words
+};
+
+// scripts/rules/credential-body.ts
+var TYPED_ESCAPE = /\\./gu;
+function sent_text(source) {
+  if (source.kind === "text") return source.value;
+  return token_shape.decoded(file_reader.read_if_readable(source.value) ?? "");
+}
+function holds_token(text) {
+  return [text, text.replaceAll(TYPED_ESCAPE, () => " ")].some(
+    (reading) => token_shape.holds(reading)
+  );
+}
+function is_credential_segment(segment) {
+  const args = git_argv.arguments_of(segment, direct_pr_create.GH_COMMAND);
+  if (args === void 0) return false;
+  const call = [direct_pr_create.GH_COMMAND, ...args].join(" ");
+  if (!gh_api.is_gh_api(call)) return false;
+  return gh_api.field_sources(call).some((source) => holds_token(sent_text(source)));
+}
+function sends_credential(command) {
+  return direct_pr_create.has_run_segment(command, is_credential_segment);
+}
+var CREDENTIAL_BODY_REASON = "\u26D4 credential in a gh api body: a field value, or the file `-F key=@<path>` / `--input <path>` names, holds a token-shaped string (`scripts/lib/token-shape.ts`), and the call would publish it. Remove the credential from the body and send it again. **This rule fires on every occurrence, not once per run.**";
+var ROW3 = {
+  id: "credential-body",
+  is_trigger: bash_triggers.on_bash_command(sends_credential),
+  reason: CREDENTIAL_BODY_REASON,
+  decide: () => true,
+  about: {
+    title: "Credential in a body",
+    topic: "`shell-body.md`",
+    fires: "a `gh api` call whose field value, or the file `-F key=@<path>` / `--input <path>` names, holds a token-shaped string (`token-shape.ts`). Every occurrence",
+    quiet: "a body with no credential, or a body sent through kit, which runs the same scan"
+  }
+};
+var credential_body = { CREDENTIAL_BODY_REASON, ROW: ROW3, sends_credential };
+
+// 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 ROW4 = {
+  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: ROW4 };
+
+// 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, resolve_own) {
+  const target = gh_api.repo_target(endpoint);
+  if (target === void 0 || !COMMENTS_PATH.test(endpoint)) return false;
+  return gh_api.is_owner_placeholder(target.owner) || repo_party.is_own_repository(target, resolve_own());
+}
+function is_comment_api_call(args, resolve_own) {
+  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, resolve_own);
+}
+function is_comment_segment(segment, resolve_own) {
+  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, resolve_own);
+}
+function is_direct_issue_comment(command, resolve_own = repo_party.current_repository) {
+  return direct_pr_create.has_run_segment(
+    command,
+    (segment) => is_comment_segment(segment, resolve_own)
+  );
+}
+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 ROW5 = {
+  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` whose owner is the `{owner}` placeholder or the checkout's own `owner/repo` spelled out); 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: ROW5, is_direct_issue_comment };
+
+// 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;
+var NAMES_A_FIELD = /(?:^|[.{,\s'"])[A-Za-z_]/u;
+function projects_away_body(segment) {
+  const value = FIELD_PROJECTION.exec(segment)?.[1];
+  return value !== void 0 && NAMES_A_FIELD.test(value) && !NAMES_THE_BODY.test(value);
+}
+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 path4 = rewritable_path(command);
+  if (path4 === void 0) return void 0;
+  return `gh api --paginate ${path4}/comments --jq ${COMMENTS_JQ}
+${command}`;
+}
+function comments_input(call, tail) {
+  if (call.name !== cost_blocks.BASH_TOOL || !json_value.is_record(call.input)) return void 0;
+  const command = comments_command(time_shell.bash_command(call.input));
+  if (command === void 0 || prior_comment_read.already_read_for_call(tail(), call)) {
+    return void 0;
+  }
+  return { ...call.input, command };
+}
+var ROW6 = {
+  id: "issue-comments",
+  is_trigger: bash_triggers.on_bash_command(is_body_only_issue_read),
+  reason: ISSUE_COMMENTS_REASON,
+  already_satisfied: prior_comment_read.already_read_for_call,
+  keeps: bash_triggers.on_bash_command(reads_issue_comments),
+  rewrite: comments_input,
+  rewrite_note: COMMENTS_NOTE,
+  // The opening the reason carried before it led with the command.
+  former_reasons: ["\u26D4 an Issue's comments are part of the Issue: read them before implementing"],
+  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: ROW6,
+  comments_input,
+  fetches_issue_comments,
+  is_body_only_issue_read,
+  projects_away_body
+};
+
+// scripts/rules/direct-issue-read.ts
+var API_SUBCOMMAND3 = "api";
+var ISSUE_GROUP2 = "issue";
+var VIEW_ACTION = "view";
+var WEB_FLAGS = /* @__PURE__ */ new Set(["-w", "--web"]);
+var VIEW_VALUE_TAKING_FLAGS = /* @__PURE__ */ new Set([
+  ...direct_pr_create.VALUE_TAKING_FLAGS,
+  "--json",
+  "-q",
+  "--jq",
+  "-t",
+  "--template"
+]);
+var REPO_EQUALS = "--repo=";
+var ISSUE_URL = /^https?:\/\/[^/\s]+\/(?<named>[^/\s]+\/[^/\s]+)\/issues\/\d+/u;
+var OWNER_REPO_PARTS = 2;
+var QUOTE2 = `['"]?`;
+var API_ORIGIN2 = String.raw`(?:https://api\.github\.com)?/?`;
+var SEGMENT2 = String.raw`[^/\s'"?]+`;
+var NUMBER = String.raw`(?:\d+|\$\{?\w+\}?)`;
+var ISSUE_READ_PATH = new RegExp(
+  String.raw`^${QUOTE2}${API_ORIGIN2}repos/${SEGMENT2}/${SEGMENT2}/issues/${NUMBER}(?:/comments|/timeline)?/?(?:\?[^\s'"]*)?${QUOTE2}$`,
+  "u"
+);
+function is_own_repository(owner, repo) {
+  if (gh_api.is_owner_placeholder(owner)) return true;
+  return `${owner}/${repo}`.toLowerCase() === session_cite.session_repo()?.toLowerCase();
+}
+function is_own_issue_endpoint(endpoint) {
+  const target = gh_api.repo_target(endpoint);
+  if (target === void 0) return false;
+  return is_own_repository(target.owner, target.repo) && ISSUE_READ_PATH.test(endpoint);
+}
+function is_body_api_read(call) {
+  return gh_api.is_gh_api(call) && gh_api.is_read(call) && !issue_comments.projects_away_body(call);
+}
+function is_api_issue_read(args, call) {
+  if (!is_body_api_read(call)) return false;
+  const [subcommand, endpoint = ""] = direct_pr_create.positional_words(
+    args,
+    direct_pr_create.API_VALUE_TAKING_FLAGS
+  );
+  return subcommand === API_SUBCOMMAND3 && is_own_issue_endpoint(endpoint);
+}
+function repo_flag(args) {
+  const index = args.findIndex((argument) => direct_pr_create.VALUE_TAKING_FLAGS.has(argument));
+  if (index !== -1) return args[index + 1];
+  return args.find((argument) => argument.startsWith(REPO_EQUALS))?.slice(REPO_EQUALS.length);
+}
+function named_repository(args, issue) {
+  return ISSUE_URL.exec(issue)?.groups?.["named"] ?? repo_flag(args);
+}
+function is_own_view_target(args, issue) {
+  const named = named_repository(args, issue);
+  if (named === void 0) return true;
+  const [owner = "", repo = ""] = named.split("/").slice(-OWNER_REPO_PARTS);
+  return is_own_repository(owner, repo);
+}
+function prints_body_or_comments(call) {
+  if (issue_comments.fetches_issue_comments(call)) return true;
+  return !issue_comments.projects_away_body(call);
+}
+function is_printed_view(args, issue, call) {
+  if (args.some((argument) => WEB_FLAGS.has(argument))) return false;
+  return is_own_view_target(args, issue) && prints_body_or_comments(call);
+}
+function is_issue_view_read(args, call) {
+  const [group, action, issue = ""] = direct_pr_create.positional_words(
+    args,
+    VIEW_VALUE_TAKING_FLAGS
+  );
+  const is_view = group === ISSUE_GROUP2 && action === VIEW_ACTION;
+  return is_view && is_printed_view(args, issue, call);
+}
+function is_issue_read_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;
+  const call = [direct_pr_create.GH_COMMAND, ...args].join(" ");
+  return is_api_issue_read(args, call) || is_issue_view_read(args, call);
+}
+function is_direct_issue_read(command) {
+  return direct_pr_create.has_run_segment(command, is_issue_read_segment);
+}
+var READ_NAMES = /* @__PURE__ */ new Set(["issue:read", "run:prep", "run:entry"]);
+function is_josh_read(command) {
+  return shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, READ_NAMES));
+}
+function is_any_read(command) {
+  return is_direct_issue_read(command) || is_josh_read(command);
+}
+var DIRECT_ISSUE_READ_REASON = "\u26D4 direct issue read: pnpm josh issue:read <N>\nRun that in place of this read of `\u2026/issues/<N>`, its comments or its timeline (`gh api` or `gh issue view`) \u2014 it withholds a comment from an author without write access and marks an untrusted body as a report, which a raw read prints whole as if it were an instruction (`issue-comments.md`). **This rule fires on every occurrence, not once per run.**";
+var ROW7 = {
+  id: "direct-issue-read",
+  is_trigger: bash_triggers.on_bash_command(is_direct_issue_read),
+  reason: DIRECT_ISSUE_READ_REASON,
+  decide: () => true,
+  keeps: bash_triggers.on_bash_command(is_josh_read),
+  reaches: bash_triggers.on_bash_command(is_any_read),
+  about: {
+    title: "Direct issue read",
+    topic: "`issue-comments.md`",
+    fires: "a `gh api` GET of the checkout's own `repos/<o>/<r>/issues/<N>`, `\u2026/comments` or `\u2026/timeline` (the `{owner}` placeholder or the origin spelled out), or a `gh issue view <N>` of it, with no projection or one naming the body (or, for the view, the comments); it points at `pnpm josh issue:read`. Every occurrence",
+    quiet: "`pnpm josh issue:read` / `run:prep` / `run:entry`, a `--jq` / `--json` projection without the body or the comments, `gh issue view --web`, or another repository named outright"
+  }
+};
+var direct_issue_read = { DIRECT_ISSUE_READ_REASON, ROW: ROW7, is_direct_issue_read };
+
+// 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_or_inert,
+  is_wait_timer,
+  sleep_seconds,
+  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 QUOTES2 = /^['"]|['"]$/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(QUOTES2, "");
+}
+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 ROW8 = {
+  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: ROW8,
+  carries_a_file_body
+};
+
+// scripts/rules/edit-tool.ts
+var EDIT = "Edit";
+var WRITE = "Write";
+var EDIT_TOOLS = /* @__PURE__ */ new Set([EDIT, WRITE]);
+function is_edit_tool(name) {
+  return EDIT_TOOLS.has(name);
+}
+function string_field(input, key) {
+  const value = input[key];
+  return typeof value === "string" ? value : "";
+}
+var edit_tool = {
+  EDIT,
+  WRITE,
+  is_edit_tool,
+  string_field
+};
+
+// scripts/rules/file-rewrite.ts
+var { WRITE: WRITE2, EDIT: EDIT2, is_edit_tool: is_edit_tool2, string_field: string_field2 } = edit_tool;
+var MAX_SHARED_RATIO = 0.5;
+var PERCENT = 100;
+var LINE_BREAK3 = "\n";
+var ISSUE_PLACEHOLDER = "<N>";
+var REGEX_SPECIALS = /[.*+?^${}()|[\]\\]/gu;
+var ISSUE_DIGITS = String.raw`\d+`;
+var HANDOFF_PATTERN = run_cut_handoff.HANDOFF_PATH.replaceAll(
+  REGEX_SPECIALS,
+  (special) => `\\${special}`
+).replace(ISSUE_PLACEHOLDER, () => ISSUE_DIGITS);
+var HANDOFF = new RegExp(`(?:^|/)${HANDOFF_PATTERN}$`, "u");
+function body_lines(text) {
+  return text.split(LINE_BREAK3).map((line) => line.trim()).filter((line) => line !== "");
+}
+function count_lines(lines) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const line of lines) counts.set(line, (counts.get(line) ?? 0) + 1);
+  return counts;
+}
+function take_line(counts, line) {
+  const left = counts.get(line) ?? 0;
+  if (left === 0) return false;
+  counts.set(line, left - 1);
+  return true;
+}
+function shared_ratio(old_text, new_text) {
+  const new_lines = body_lines(new_text);
+  if (new_lines.length === 0) return 0;
+  const old_counts = count_lines(body_lines(old_text));
+  const shared = new_lines.filter((line) => take_line(old_counts, line)).length;
+  return shared / new_lines.length;
+}
+function write_input(call) {
+  if (call.name !== WRITE2 || !json_value.is_record(call.input)) return void 0;
+  return HANDOFF.test(string_field2(call.input, "file_path")) ? void 0 : call.input;
+}
+function rewrite_ratio(call, read2) {
+  const input = write_input(call);
+  const old_text = input === void 0 ? void 0 : read2(string_field2(input, "file_path"));
+  if (input === void 0 || old_text === void 0) return void 0;
+  return shared_ratio(old_text, string_field2(input, "content"));
+}
+function rewrites_kept_body(call, read2 = file_reader.read_optional) {
+  return (rewrite_ratio(call, read2) ?? 0) > MAX_SHARED_RATIO;
+}
+function reaches_file_change(call) {
+  return is_edit_tool2(call.name);
+}
+function keeps_region_edit(call) {
+  return call.name === EDIT2;
+}
+var FILE_REWRITE_REASON = `\u26D4 whole-file Write of an existing file: the new body keeps more than ${String(MAX_SHARED_RATIO * PERCENT)}% of the old lines, so it is a region edit carried as a whole file and its diff cannot be read. Change the region with the Edit tool; a Write stays for a new file or a rebuild sharing almost nothing. This rule fires on every occurrence (\`prompts/collaboration-workflow/file-edits.md\`).`;
+var ROW9 = {
+  id: "file-rewrite",
+  is_trigger: (call) => rewrites_kept_body(call),
+  reason: FILE_REWRITE_REASON,
+  decide: () => true,
+  keeps: keeps_region_edit,
+  reaches: reaches_file_change,
+  about: {
+    title: "No whole-file Write that keeps most of the old body",
+    topic: "`file-edits.md`",
+    fires: "a `Write` over an existing file whose new body shares more than half its non-blank lines with the old one. Every occurrence",
+    quiet: "a new file, the run's handoff, a rebuild sharing half or less, or an `Edit`"
+  }
+};
+var file_rewrite = {
+  FILE_REWRITE_REASON,
+  MAX_SHARED_RATIO,
+  ROW: ROW9,
+  rewrites_kept_body,
+  shared_ratio
+};
+
+// scripts/rules/sed-in-place.ts
+var SED = "sed";
+var IN_PLACE_SHORT = /^-[A-Za-z]*i/u;
+var IN_PLACE_LONG = /^--in-place(?:=|$)/u;
+var IN_PLACE_CLUSTER = /^-[A-Za-z]*i$/u;
+var EXTENDED_SHORT = /^-[A-Za-z]*[Er]/u;
+var EXTENDED_LONG = "--regexp-extended";
+var PLAIN_FLAGS = /* @__PURE__ */ new Set(["", "g"]);
+var SCRIPT_FLAG = "-e";
+var FLAG_PREFIX3 = "-";
+var SURROUNDING_QUOTES = /^(['"])(.*)\1$/su;
+var QUOTED_BODY = 2;
+var META_CHARACTER = /[/&\\.*[\]^$]/u;
+var SUBSTITUTE = "s";
+var SUBSTITUTE_PARTS = 3;
+var ONE_MATCH = 1;
+function unquoted(word) {
+  return SURROUNDING_QUOTES.exec(word)?.[QUOTED_BODY] ?? word;
+}
+function is_in_place_flag(word) {
+  return IN_PLACE_LONG.test(word) || IN_PLACE_SHORT.test(word);
+}
+function without_suffix(words) {
+  const index = words.findIndex((word) => IN_PLACE_CLUSTER.test(word));
+  if (index === -1 || words[index + 1] !== "") return [...words];
+  return words.toSpliced(index + 1, 1);
+}
+function sed_words(segment) {
+  const words = git_argv.arguments_of(segment, SED)?.map((word) => unquoted(word));
+  return words?.some((word) => is_in_place_flag(word)) === true ? without_suffix(words) : void 0;
+}
+function is_script_value(words, index) {
+  return words[index - 1] === SCRIPT_FLAG;
+}
+function sed_call(words) {
+  const scripts = words.filter((_word, index) => is_script_value(words, index));
+  const operands = words.filter(
+    (word, index) => !word.startsWith(FLAG_PREFIX3) && !is_script_value(words, index)
+  );
+  if (scripts.length > 0) return { scripts, files: operands };
+  const [script, ...files] = operands;
+  return { scripts: script === void 0 ? [] : [script], files };
+}
+function substitute_parts(script) {
+  if (!script.startsWith(SUBSTITUTE)) return void 0;
+  const parts = script.slice(SUBSTITUTE.length + 1).split(script.charAt(SUBSTITUTE.length));
+  return parts.length === SUBSTITUTE_PARTS ? parts : void 0;
+}
+function has_plain_flags(parts) {
+  return PLAIN_FLAGS.has(parts.at(-1) ?? "");
+}
+function is_plain(parts) {
+  const [pattern = "", replacement = ""] = parts;
+  return pattern !== "" && has_plain_flags(parts) && !META_CHARACTER.test(pattern + replacement);
+}
+function is_extended(words) {
+  return words.some((word) => word === EXTENDED_LONG || EXTENDED_SHORT.test(word));
+}
+function single_script(words) {
+  if (is_extended(words)) return void 0;
+  const { scripts } = sed_call(words);
+  return scripts.length === 1 ? scripts[0] : void 0;
+}
+function plain_pattern(words) {
+  const script = single_script(words);
+  const parts = script === void 0 ? void 0 : substitute_parts(script);
+  return parts !== void 0 && is_plain(parts) ? parts[0] : void 0;
+}
+function match_count(text, pattern) {
+  return text.split(pattern).length - 1;
+}
+function is_unsafe_segment(segment, read2) {
+  const words = sed_words(segment);
+  if (words === void 0) return false;
+  const { files } = sed_call(words);
+  const pattern = plain_pattern(words);
+  if (pattern === void 0 || files.length === 0) return true;
+  return files.some((file) => match_count(read2(file), pattern) !== ONE_MATCH);
+}
+function is_unsafe_sed(command, read2 = file_reader.read_file_or_empty) {
+  return shell_segments.segments_of(command).some((segment) => is_unsafe_segment(segment, read2));
+}
+function is_in_place_sed(command) {
+  return shell_segments.segments_of(command).some((segment) => sed_words(segment) !== void 0);
+}
+function keeps_plain_sed(command) {
+  return shell_segments.segments_of(command).some((segment) => {
+    const words = sed_words(segment);
+    return words !== void 0 && plain_pattern(words) !== void 0;
+  });
+}
+var SED_IN_PLACE_REASON = "\u26D4 unsafe `sed -i`: its pattern or replacement carries a meta character (`/ & \\ . * [ ] ^ $`), it is not one plain `s` command (a flag other than `g`, or `-E`), or it does not match exactly once in each target file, so it can rewrite a line you did not mean to. Change the region with the Edit tool. This rule fires on every occurrence (`prompts/collaboration-workflow/file-edits.md`).";
+var ROW10 = {
+  id: "sed-in-place",
+  is_trigger: bash_triggers.on_bash_command((command) => is_unsafe_sed(command)),
+  reason: SED_IN_PLACE_REASON,
+  decide: () => true,
+  keeps: bash_triggers.on_bash_command(keeps_plain_sed),
+  reaches: bash_triggers.on_bash_command(is_in_place_sed),
+  about: {
+    title: "No `sed -i` its countable conditions do not clear",
+    topic: "`file-edits.md`",
+    fires: "a `sed -i` whose script is not one `s` command, whose pattern or replacement has a meta character, or which does not match exactly once in a target file. Every occurrence",
+    quiet: "not in place, or one plain `s` command matching once in each file"
+  }
+};
+var sed_in_place = {
+  ROW: ROW10,
+  is_in_place_sed,
+  is_unsafe_sed,
+  keeps_plain_sed
+};
+
+// scripts/rules/file-edit-rows.ts
+var SHELL_ROWS = [file_body.ROW, sed_in_place.ROW];
+var file_edit_rows = {
+  FILE_BODY_REASON: file_body.FILE_BODY_REASON,
+  REWRITE_ROW: file_rewrite.ROW,
+  SHELL_ROWS
+};
+
+// 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 ROW11 = {
+  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: ROW11,
+  is_force_or_delete
+};
+
+// scripts/rules/implementation-cut.ts
+import path from "node:path";
+
+// 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 { is_edit_tool: is_edit_tool3 } = edit_tool;
+var CUT_COMMANDS = /* @__PURE__ */ new Set(["run:cut"]);
+var IMPL_FLAG = /(?:^|\s)--impl(?:[=\s]|$)/u;
+var RESUME_FLAG = /(?:^|\s)--resume(?:[=\s]|$)/u;
+function calls_cut_with(command, flag) {
+  return shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, CUT_COMMANDS) && flag.test(segment));
+}
+function takes_the_impl_cut(command) {
+  return calls_cut_with(command, IMPL_FLAG);
+}
+function resumes_a_cut(command) {
+  return calls_cut_with(command, RESUME_FLAG);
+}
+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 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_handoff_write(call, directory, issue) {
+  const handoff = path.resolve(directory, run_cut_handoff.handoff_path_of(issue));
+  return path.resolve(directory, file_path_of(call)) === handoff;
+}
+function refusable_issue(call, state) {
+  const issue = uncut_run_issue(state);
+  if (issue === void 0) return void 0;
+  return is_handoff_write(call, state.directory, 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_tool3(call.name)) return false;
+  const issue = refusable_issue(call, state);
+  if (issue === void 0) return false;
+  return warrants_the_cut(state) && state.can_cut(issue);
+}
+var THRESHOLD_TEXT = "`pnpm josh cost --cut`";
+var IMPLEMENTATION_CUT_REASON = `\u26D4 implementation-phase cut: refused on every edit over ${THRESHOLD_TEXT}. Write \`${run_cut_handoff.HANDOFF_PATH}\`: ${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 ROW12 = {
+  id: "implementation-cut",
+  is_trigger: is_over_threshold_edit,
+  reason: IMPLEMENTATION_CUT_REASON,
+  decide: decide2,
+  // 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, the run's own handoff file, already cut, or under the threshold"
+  }
+};
+var implementation_cut = {
+  IMPLEMENTATION_CUT_REASON,
+  REISSUE_WINDOW_MS,
+  ROW: ROW12,
+  decide: decide2,
+  is_over_threshold_edit,
+  is_reissued_refusal,
+  resumes_a_cut,
+  takes_the_impl_cut,
+  uncut_run_issue
+};
+
+// scripts/rules/investigator-foreground.ts
+var INVESTIGATOR_FOREGROUND_REASON = "\u26D4 investigator foreground: a background `investigator` leaves its result queued until a later turn. Reissue the call with `run_in_background: false`, and put the reads of files this run will edit in the same message. It fires on every occurrence (`.claude/skills/workflow-commands/delegation.md`).";
+var BACKGROUND_FIELD = "run_in_background";
+var BODY_FIELDS = ["description", "prompt"];
+var GUARD_LABEL = time_transcript_line.guard_from_refusal(INVESTIGATOR_FOREGROUND_REASON);
+var NO_FIELD_STAMP = hook_decision.create_refusal_stamp("josh-investigator-no-field-");
+function is_investigator(call) {
+  if (!agent_model.SUBAGENT_TOOLS.has(call.name) || !json_value.is_record(call.input)) return false;
+  const type = call.input["subagent_type"];
+  return typeof type === "string" && type.split(":").at(-1) === delegation_policy.INVESTIGATOR_AGENT;
+}
+function field_of(input, key) {
+  return json_value.is_record(input) ? input[key] : void 0;
+}
+function is_foreground(call) {
+  return field_of(call.input, BACKGROUND_FIELD) === false;
+}
+function is_background_investigator(call) {
+  return is_investigator(call) && !is_foreground(call);
+}
+function keeps_foreground(call) {
+  return is_investigator(call) && is_foreground(call);
+}
+function is_untyped_field(name, input) {
+  if (!agent_model.SUBAGENT_TOOLS.has(name) || !json_value.is_record(input)) return false;
+  return typeof input[BACKGROUND_FIELD] === "string";
+}
+function placed_of(lines) {
+  return lines.flatMap(
+    (line) => line.blocks.map((block) => ({ block, message_id: line.message_id, at_ms: line.timestamp_ms }))
+  );
+}
+function results_of(placed) {
+  const results = placed.filter(({ block }) => block.result_id !== "");
+  const refused = results.filter(({ block }) => block.refusal_guard === GUARD_LABEL);
+  return {
+    answered: new Set(results.map(({ block }) => block.result_id)),
+    refused: new Map(refused.map(({ block, at_ms }) => [block.result_id, at_ms]))
+  };
+}
+function writes_foreground(block) {
+  return String(field_of(block.input, BACKGROUND_FIELD)) === "false";
+}
+function has_same_body(block, call) {
+  return BODY_FIELDS.every((key) => field_of(block.input, key) === field_of(call.input, key));
+}
+function is_pending_foreground(block, results) {
+  return !results.answered.has(block.id) && writes_foreground(block);
+}
+function is_same_dispatch(block, call, results) {
+  if (!is_investigator(block) || !has_same_body(block, call)) return false;
+  return results.refused.has(block.id) || is_pending_foreground(block, results);
+}
+function is_dropped_foreground(block, results) {
+  return results.refused.has(block.id) && is_investigator(block) && writes_foreground(block);
+}
+function refused_at_ms(dispatch, results) {
+  return results.refused.get(dispatch?.block.id ?? "") ?? hook_decision.NEVER_MS;
+}
+function is_alone(dispatch, dispatches) {
+  return dispatches.filter(({ message_id }) => message_id === dispatch.message_id).length === 1;
+}
+function is_reissue(placed, results, now_ms) {
+  const dispatches = placed.filter(({ block }) => is_investigator(block));
+  const last = dispatches.findLast(({ block }) => results.answered.has(block.id));
+  const at_ms = refused_at_ms(last, results);
+  if (last === void 0 || at_ms === hook_decision.NEVER_MS) return false;
+  return is_alone(last, dispatches) && now_ms - at_ms < implementation_cut.REISSUE_WINDOW_MS;
+}
+function tail_shows_no_field(tail, call, now_ms) {
+  const placed = placed_of(time_transcript_line.parse_text(tail));
+  const results = results_of(placed);
+  const has_block_tell = placed.some(
+    ({ block }) => is_untyped_field(block.name, block.input) || is_same_dispatch(block, call, results) || is_dropped_foreground(block, results)
+  );
+  return has_block_tell || is_reissue(placed, results, now_ms);
+}
+function remember_no_field(run) {
+  NO_FIELD_STAMP.record(NO_FIELD_STAMP.path(run.transcript), run.now_ms);
+  return true;
+}
+function is_remembered(run) {
+  return NO_FIELD_STAMP.last_ms(NO_FIELD_STAMP.path(run.transcript)) !== hook_decision.NEVER_MS;
+}
+function lacks_background_field(tail, call, run) {
+  if (field_of(call.input, BACKGROUND_FIELD) === true) return false;
+  if (is_remembered(run)) return true;
+  const has_tell = is_untyped_field(call.name, call.input) || tail_shows_no_field(tail, call, run.now_ms);
+  return has_tell && remember_no_field(run);
+}
+var ROW13 = {
+  id: "investigator-foreground",
+  is_trigger: is_background_investigator,
+  reason: INVESTIGATOR_FOREGROUND_REASON,
+  already_satisfied: lacks_background_field,
+  decide: () => true,
+  keeps: keeps_foreground,
+  reaches: is_investigator,
+  about: {
+    title: "Investigator dispatched in the foreground",
+    topic: '`.claude/skills/workflow-commands/delegation.md` \u2192 "The pre-implementation reading \u2014 what goes to a unit, and from which file"',
+    fires: "an `Agent` / `Task` call of the `investigator` type without `run_in_background: false`. Every occurrence",
+    quiet: "another agent type, `run_in_background: false` set, or a session whose subagent tool declares no `run_in_background` (the field written as a string, the tail holding the same description and prompt, a refused dispatch that wrote it `false`, or a reissue still without the field just after this row refused a lone dispatch) \u2014 remembered for the session"
+  }
+};
+var investigator_foreground = {
+  INVESTIGATOR_FOREGROUND_REASON,
+  ROW: ROW13,
+  is_background_investigator,
+  lacks_background_field
+};
+
+// 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 ROW14 = {
+  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: '`operating-rules.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: ROW14,
+  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 ROW15 = {
+  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: ROW15,
+  invokes_budget_command,
+  is_carry_conflict
+};
+
+// scripts/rules/lane-direct-tool.ts
+import os2 from "node:os";
+
+// scripts/gate/command-memory.ts
+import os from "node:os";
+
+// scripts/gate/core-weights.ts
+var MEASURED = {
+  lint: { cpu_s: 16.9, wall_s: 14 },
+  type_check: { cpu_s: 31.2, wall_s: 27.3 },
+  spell_check: { cpu_s: 5.7, wall_s: 6.2 },
+  eslint_scan: { cpu_s: 113, wall_s: 98 },
+  format: { cpu_s: 2.1, wall_s: 1.7 },
+  retrospective: { cpu_s: 16.5, wall_s: 19.8 },
+  install: { cpu_s: 1.9, wall_s: 6.1 }
+};
+function rounded_up(measurement) {
+  return Math.ceil(measurement.cpu_s / measurement.wall_s);
+}
+var CORE_WEIGHTS = {
+  lint: rounded_up(MEASURED.lint),
+  type_check: rounded_up(MEASURED.type_check),
+  spell_check: rounded_up(MEASURED.spell_check),
+  eslint_scan: rounded_up(MEASURED.eslint_scan),
+  format: rounded_up(MEASURED.format),
+  retrospective: rounded_up(MEASURED.retrospective),
+  install: rounded_up(MEASURED.install),
+  e2e: 2
+};
+var MEMORY_MB = {
+  lint: 2400,
+  metrics: 1900,
+  type_check: 1300,
+  spell_check: 350,
+  eslint_scan: 2400,
+  unit_worker: 400,
+  format: 300,
+  retrospective: 900,
+  install: 100
+};
+var TOOL_MEMORY = {
+  eslint: "lint",
+  tsc: "type_check",
+  cspell: "spell_check",
+  vitest: "unit_worker",
+  prettier: "format",
+  install: "install"
+};
+var core_weights = { CORE_WEIGHTS, MEASURED, MEMORY_MB, TOOL_MEMORY };
+
+// scripts/gate/command-memory.ts
+var JOSH_PROGRAM = "josh";
+var RESERVED_RUN = "reserved-run";
+var COMMAND_SEPARATOR = "--";
+var ESLINT = "eslint";
+var VITEST = "vitest";
+var AUTO_WORKERS = "auto";
+var LINE_BREAK4 = "\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_BREAK4);
+}
+function shell_heredoc_bodies(line) {
+  const lines = line.split(LINE_BREAK4);
+  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, workers_of };
+
+// 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 ROW16 = {
+  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: ROW16,
+  TIMED_RERUN_REASON,
+  is_timed_run,
+  reads_the_record
+};
+
+// scripts/rules/lane-direct-tool.ts
+var ESLINT2 = "eslint";
+var VITEST2 = "vitest";
+var HEAVY_TOOLS = /* @__PURE__ */ new Set([ESLINT2, VITEST2, "cspell", "tsc"]);
+var TOOL_WEIGHTS = {
+  [ESLINT2]: core_weights.CORE_WEIGHTS.lint,
+  tsc: core_weights.CORE_WEIGHTS.type_check,
+  cspell: core_weights.CORE_WEIGHTS.spell_check
+};
+var SINGLE_CORE = 1;
+var RESERVED_RUN2 = "pnpm josh reserved-run";
+var MULTI_COMMAND_SYNTAX = /[;|&<>()`#\n]|\$\(/u;
+var KEPT_REDIRECT = /2>&1/gu;
+var ENV_ASSIGNMENT = /^[A-Za-z_]\w*=/u;
+var RESERVED_NOTE = "\u21BB lane direct tool: a lane child ran a heavy tool directly, so the line was wrapped in `pnpm josh reserved-run <weight> --` to claim its cores beside the other lanes. Prefer `pnpm josh lint:related` / `test:related` / `cspell:dot` \u2014 `docs/josh-commands-automation.md`.";
+function direct_calls(command) {
+  return command_memory.tool_calls_of(command).filter((call) => !call.is_reserved && HEAVY_TOOLS.has(call.name));
+}
+function runs_heavy_tool(command) {
+  return direct_calls(command).length > 0;
+}
+function weight_of(call, cores) {
+  if (call.name === VITEST2) return command_memory.workers_of(call, cores);
+  return TOOL_WEIGHTS[call.name] ?? SINGLE_CORE;
+}
+function is_one_command(command) {
+  const judged = time_shell.blanked(command);
+  if (judged === void 0) return false;
+  return !MULTI_COMMAND_SYNTAX.test(judged.replaceAll(KEPT_REDIRECT, " ")) && !ENV_ASSIGNMENT.test(judged);
+}
+function can_wrap(line, cores) {
+  if (!is_one_command(line) || timed_rerun.is_timed_run(line)) return false;
+  return !command_memory.runs_multi_worker_eslint(line, cores);
+}
+function reserved_command(command, cores = os2.availableParallelism()) {
+  const line = command.trim();
+  const calls = direct_calls(line);
+  if (!can_wrap(line, cores) || calls.length === 0) return void 0;
+  const weight = Math.max(...calls.map((call) => weight_of(call, cores)));
+  return `${RESERVED_RUN2} ${String(weight)} -- ${line}`;
+}
+function is_lane_bash(call) {
+  return call.name === cost_blocks.BASH_TOOL && lane_child_marker.is_child_of(process.cwd());
+}
+function reserved_input(call) {
+  if (!is_lane_bash(call) || !json_value.is_record(call.input)) return void 0;
+  const command = reserved_command(time_shell.bash_command(call.input));
+  return command === void 0 ? void 0 : { ...call.input, command };
+}
+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`. Only a one-command line is wrapped for you. Refused on every occurrence.";
+var ROW17 = {
+  id: "lane-direct-tool",
+  is_trigger: bash_triggers.on_bash_command(is_lane_direct_tool),
+  reason: LANE_DIRECT_TOOL_REASON,
+  decide: () => true,
+  rewrite: reserved_input,
+  rewrite_note: RESERVED_NOTE,
+  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. A one-command line is rewritten behind `pnpm josh reserved-run <weight> --` at the gate's weight; a chained, piped, redirected or env-prefixed line and a multi-worker eslint are refused, 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,
+  RESERVED_NOTE,
+  ROW: ROW17,
+  is_lane_direct_tool,
+  reserved_command,
+  reserved_input,
+  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 ROW18 = {
+  id: "lane-interactive-ask",
+  is_trigger: is_interactive_ask,
+  reason: LANE_INTERACTIVE_ASK_REASON,
+  decide: () => true,
+  // A reply asking a person for the git index is the same ask, delivered by the Stop hook.
+  stop_reasons: [stop_rules.LANE_INDEX_REASON],
+  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; the Stop hook also blocks a reply asking a person for the git index. Every occurrence",
+    quiet: "not a lane child, or not an interactive tool"
+  }
+};
+var lane_interactive_ask = { LANE_INTERACTIVE_ASK_REASON, ROW: ROW18, is_interactive_ask };
+
+// scripts/rules/lane-spilled-read.ts
+var SPILLED_RESULT = /\/tool-results\/[^/]+\.txt$/u;
+function read_input(call) {
+  if (call.name !== "Read" || !json_value.is_record(call.input)) return void 0;
+  return call.input;
+}
+function reads_spilled_result(input) {
+  const { file_path: file_path2 } = input;
+  return typeof file_path2 === "string" && SPILLED_RESULT.test(file_path2);
+}
+function is_paginated(input) {
+  return input["offset"] !== void 0 || input["limit"] !== void 0;
+}
+function reaches_spilled_result(call) {
+  const input = read_input(call);
+  return input !== void 0 && reads_spilled_result(input);
+}
+function keeps_narrowed_read(call) {
+  const input = read_input(call);
+  return input !== void 0 && reads_spilled_result(input) && is_paginated(input);
+}
+function is_whole_spilled_read(call, is_lane_child = lane_child_marker.is_child_of(process.cwd())) {
+  if (!reaches_spilled_result(call) || keeps_narrowed_read(call)) return false;
+  return is_lane_child;
+}
+var LANE_SPILLED_READ_REASON = "\u26D4 lane child reading a spilled Bash result whole: `tool-results/<id>.txt` is the output that overflowed the cap, and reading it back whole fills the context the cut is measured on. Read only the lines you need: `grep -n <pattern> <path>` or `sed -n <from>,<to>p <path>`. Refused on every occurrence.";
+var ROW19 = {
+  id: "lane-spilled-read",
+  is_trigger: is_whole_spilled_read,
+  reason: LANE_SPILLED_READ_REASON,
+  decide: () => true,
+  keeps: keeps_narrowed_read,
+  reaches: reaches_spilled_result,
+  about: {
+    title: "Lane child reading a spilled Bash result whole",
+    topic: "`prompts/collaboration-workflow/output-bounds.md`",
+    fires: "a dispatched lane child's `Read` of a `tool-results/<id>.txt` file with no `offset` or `limit`. Every occurrence",
+    quiet: "not a lane child, another file, or a paginated `Read`"
+  }
+};
+var lane_spilled_read = {
+  LANE_SPILLED_READ_REASON,
+  ROW: ROW19,
+  is_whole_spilled_read,
+  keeps_narrowed_read,
+  reaches_spilled_result
+};
+
+// 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_URL2 = /--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_URL2.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 ROW20 = {
+  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: ROW20,
+  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_PREFIX4 = "-";
+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_PREFIX4));
+}
+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 ship`'s sync brings the default in before its gate. Refused on every occurrence (`backlogrun-lanes.md`, `backlogrun-child.md`).";
+var ROW21 = {
+  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: ROW21,
+  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: "[--record <N>]",
+    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_for(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_for(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 };
+
+// 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_COMMAND3 = "gh";
+var REPO_GROUP2 = "repo";
+var REPO_REMOVALS = /* @__PURE__ */ new Set(["delete", "archive"]);
+var PR_GROUP2 = "pr";
+var PR_CLOSE = "close";
+function is_destructive_gh_command(args) {
+  const [group, action = ""] = args;
+  if (group === PR_GROUP2) return action === PR_CLOSE;
+  return group === REPO_GROUP2 && REPO_REMOVALS.has(action);
+}
+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_COMMAND3, ...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_COMMAND3);
+  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`, `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 ROW22 = {
+  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: ROW22, 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 SINGLE_FILE_RESTORE = "git diff -- <path> | git apply -R";
+var WORKTREE_MUTATION_REASON = `\u26D4 unauthorized working-tree change: undo only this run's edit: \`${SINGLE_FILE_RESTORE}\`. 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 FORMER_OPENING = "\u26D4 unauthorized working-tree change: `git checkout --`, `git restore`";
+var ROW23 = {
+  id: "worktree-mutation",
+  is_trigger: bash_triggers.on_bash_command(is_unauthorized_worktree_change),
+  reason: WORKTREE_MUTATION_REASON,
+  former_reasons: [FORMER_OPENING],
+  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\`, \`${SINGLE_FILE_RESTORE}\``
+  }
+};
+var worktree_guard = {
+  ROW: ROW23,
+  SINGLE_FILE_RESTORE,
+  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 ROW24 = {
+  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: ROW24, is_index_mutation };
+
+// scripts/rules/pr-merge.ts
+var GH_COMMAND4 = "gh";
+var CURL_COMMAND = "curl";
+var PR_GROUP3 = "pr";
+var MERGE_ACTION = "merge";
+var API_SUBCOMMAND4 = "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_COMMAND4 && positional_words2(args)[0] === API_SUBCOMMAND4;
+}
+function is_graphql_call(name, args) {
+  if (args.some((argument) => GRAPHQL_URL.test(argument))) return true;
+  return name === GH_COMMAND4 && 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_COMMAND4 && 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` if the run authorizes it; otherwise leave it to the user (`operating-rules.md` \u2192 git-rules). This rule fires on every occurrence.";
+var ROW25 = {
+  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: '`operating-rules.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: ROW25, is_graphql_call, is_pr_merge };
+
+// scripts/rules/protected-files.ts
+import path2 from "node:path";
+var READ_TOOL = "Read";
+var { is_edit_tool: is_edit_tool4 } = edit_tool;
+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 = path2.join(".claude", "settings.json");
+var WHITESPACE2 = /\s+/u;
+var TOKEN_QUOTES = /["']/gu;
+var REDIRECT = />\||[<>]/gu;
+var REDIRECT_MARK = "<";
+var SHELLS = /* @__PURE__ */ new Set(["bash", "eval", "sh", "zsh"]);
+var SUBSTITUTION = /\$\((?<dollar>[^()]*)\)|`(?<backtick>[^`]*)`/gu;
+var SHELL_PROGRAMS = /* @__PURE__ */ new Set([
+  "cp",
+  "install",
+  "ln",
+  "mv",
+  "tee",
+  ".",
+  "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_of2(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 = path2.basename(token.replaceAll(TOKEN_QUOTES, ""));
+  if (TRACKED_VARIANTS.has(name)) return false;
+  return SECRET_FILES.has(name) || name.startsWith(ENVIRONMENT_VARIANT_PREFIX);
+}
+function redirect_marks_of(segment, program) {
+  if (program !== void 0 && SHELLS.has(program)) return segment;
+  return time_shell.blanked(segment) ?? segment;
+}
+function spaced_redirects(segment, program) {
+  const marks = redirect_marks_of(segment, program);
+  return segment.replaceAll(
+    REDIRECT,
+    (mark3, offset) => marks.startsWith(mark3, offset) ? ` ${REDIRECT_MARK} ` : mark3
+  );
+}
+function is_environment_shell_segment(segment) {
+  const call = git_argv.program_of(segment);
+  const words = spaced_redirects(segment, call?.name).split(WHITESPACE2).filter((word) => word !== "");
+  const is_redirected = words.some(
+    (word, index) => word === REDIRECT_MARK && is_environment_path(words[index + 1] ?? "")
+  );
+  if (is_redirected || call === void 0) return is_redirected;
+  return SHELL_PROGRAMS.has(call.name) && call.args.some((word) => is_environment_path(word));
+}
+function script_commands_of(segment) {
+  const program = git_argv.program_of(segment)?.name;
+  if (program === void 0 || !SHELLS.has(program)) return [];
+  return shell_segments.commands_of(segment);
+}
+function substitution_commands_of(segment) {
+  return [...segment.matchAll(SUBSTITUTION)].flatMap(
+    (match) => shell_segments.commands_of(match.groups?.["dollar"] ?? match.groups?.["backtick"] ?? "")
+  );
+}
+function segments_of2(command) {
+  return shell_segments.quote_aware_commands_of(command).flatMap((segment) => [
+    segment,
+    ...script_commands_of(segment),
+    ...substitution_commands_of(segment)
+  ]);
+}
+function is_environment_shell_access(command) {
+  return segments_of2(command).some((segment) => is_environment_shell_segment(segment));
+}
+function is_environment_access(call) {
+  if (call.name === READ_TOOL || is_edit_tool4(call.name)) {
+    return is_environment_path(file_path_of2(call));
+  }
+  return bash_triggers.on_bash_command(is_environment_shell_access)(call);
+}
+function is_consumer_settings_edit(call, is_kit_consumer) {
+  if (!is_edit_tool4(call.name)) return false;
+  const file_path2 = path2.resolve(file_path_of2(call));
+  if (!file_path2.endsWith(`${path2.sep}${SETTINGS_FILE}`)) return false;
+  return is_kit_consumer(path2.dirname(path2.dirname(file_path2)));
+}
+function is_protected_file_call(call, is_kit_consumer = doctor_consumer.is_kit_consumer) {
+  return is_environment_access(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 are written only by the person, 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 ROW26 = {
+  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`, `Edit` or `Write` of `.env` (or a shell read or write of it), 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: ROW26, is_protected_file_call };
+
+// scripts/rules/repo-admin.ts
+var GH_COMMAND5 = "gh";
+var DELETE_METHOD2 = "DELETE";
+var PATCH_METHOD = "PATCH";
+var REPOSITORY_PREFIX = String.raw`^['"]?(?:https?:\/\/[^/\s'"]+)?\/?repos\/[^/\s'"]+\/[^/\s'"]+`;
+var ADMIN_PATH = new RegExp(
+  REPOSITORY_PREFIX + String.raw`\/(?:rulesets|branches\/[^\s'"]+\/protection|collaborators|invitations|hooks|keys|` + String.raw`transfer|actions\/permissions|environments|` + String.raw`(?:actions|dependabot|codespaces)\/(?:secrets|variables))(?:[/?'"]|$)`,
+  "u"
+);
+var REPOSITORY_BODY = new RegExp(String.raw`${REPOSITORY_PREFIX}\/?['"]?$`, "u");
+var ADMIN_MUTATIONS = /\b(?:updateRepository|archiveRepository|(?:create|update|delete)(?:BranchProtectionRule|RepositoryRuleset|Environment))\b/u;
+function is_admin_target(argument, method) {
+  return ADMIN_PATH.test(argument) || method === PATCH_METHOD && REPOSITORY_BODY.test(argument);
+}
+function is_admin_graphql_call(command, args) {
+  return pr_merge.is_graphql_call(GH_COMMAND5, args) && ADMIN_MUTATIONS.test(command);
+}
+function is_admin_api_call(command, args) {
+  const call = [GH_COMMAND5, ...args].join(" ");
+  if (!gh_api.is_gh_api(call) || !gh_api.is_write(call)) return false;
+  if (is_admin_graphql_call(command, args)) return true;
+  const method = gh_api.method_of(call);
+  if (method === DELETE_METHOD2) return false;
+  return args.some((argument) => is_admin_target(argument, method));
+}
+var READ_ACTIONS = /* @__PURE__ */ new Set(["list", "ls", "get", "view"]);
+var ACTION_POSITION = 1;
+var SUB_ACTION_POSITION = 2;
+var VERB_POSITIONS = /* @__PURE__ */ new Map([
+  ["secret", ACTION_POSITION],
+  ["variable", ACTION_POSITION],
+  ["repo edit", ACTION_POSITION],
+  ["repo deploy-key", SUB_ACTION_POSITION]
+]);
+function admin_verb(args) {
+  const words = direct_pr_create.positional_words(args, direct_pr_create.API_VALUE_TAKING_FLAGS);
+  const position = VERB_POSITIONS.get(words[0] ?? "") ?? VERB_POSITIONS.get(words.slice(0, SUB_ACTION_POSITION).join(" "));
+  if (position === void 0) return void 0;
+  return words[position] ?? "";
+}
+function is_admin_cli_call(args) {
+  const verb = admin_verb(args);
+  return verb !== void 0 && !READ_ACTIONS.has(verb);
+}
+function is_admin_segment(command, segment) {
+  const args = git_argv.arguments_of(segment, GH_COMMAND5);
+  if (args === void 0) return false;
+  return is_admin_cli_call(args) || is_admin_api_call(command, args);
+}
+function is_repo_admin_write(command) {
+  return shell_segments.commands_of(command).some((segment) => is_admin_segment(command, segment));
+}
+var REPO_ADMIN_REASON = "\u26D4 repository administration: a write to the rulesets, branch protection, collaborators, invitations, secrets, variables, webhooks, deploy keys or repository settings moves the boundary an unattended run relies on, which is Tier C. Ask the user to run it. It fires on every occurrence (`prompts/collaboration-workflow/operating-rules.md`).";
+var ROW27 = {
+  id: "repo-admin",
+  is_trigger: bash_triggers.on_bash_command(is_repo_admin_write),
+  reason: REPO_ADMIN_REASON,
+  decide: () => true,
+  about: {
+    title: "Repository administration",
+    topic: "`operating-rules.md`",
+    fires: "a `gh api` POST / PUT / PATCH (path or URL) to the rulesets, branch protection, collaborators, invitations, secrets, variables, hooks, keys, environments, actions permissions or transfer, a `PATCH` of the repository, the matching GraphQL mutations, `gh secret` / `gh variable` writes, `gh repo edit` / `deploy-key` writes. Every occurrence",
+    quiet: "`gh secret list`, `gh variable get`, a `gh api` read \u2014 a `DELETE` is `destructive-command`"
+  }
+};
+var repo_admin = { REPO_ADMIN_REASON, ROW: ROW27, is_repo_admin_write };
+
+// scripts/rules/permission-guards.ts
+var ROWS2 = [
+  index_guard.ROW,
+  destructive_command.ROW,
+  protected_files.ROW,
+  direct_pr_create.ROW,
+  pr_merge.ROW,
+  repo_admin.ROW
+];
+var permission_guards = { ROWS: ROWS2 };
+
+// scripts/rules/piped-verification.ts
+var VERIFICATION_COMMANDS = /* @__PURE__ */ new Set([
+  "check",
+  "check:related",
+  "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 check_filters(command) {
+  return pipelines_of(command).flatMap(
+    ([head = "", ...filters]) => is_verification_command(head) ? filters : []
+  );
+}
+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|tee)(?=\s|$)/u;
+var EARLY_EXIT_GREP = /^grep\b.*\s(?:-[a-zA-Z]*[lLmq]|--(?:quiet|silent|max-count|files-with(?:out)?-match))/u;
+var AWK_PROGRAM = /^awk\s+(?:-F\s*\S+\s+)?'[^']*'$/u;
+var AWK_EARLY_EXIT = /\b(?:exit|nextfile|system|getline)\b|\|/u;
+var SED_TEXT = String.raw`(?:[^/\\']|\\.)*`;
+var SED_ADDRESS = String.raw`(?:\d+|\$|/${SED_TEXT}/)`;
+var SED_COMMAND = String.raw`(?:${SED_ADDRESS}(?:,${SED_ADDRESS})?)?!?(?:p|d|s/${SED_TEXT}/${SED_TEXT}/[gip\d]*)`;
+var SED_PROGRAM = new RegExp(
+  String.raw`^sed\s+(?:-[nEr]+\s+)*'${SED_COMMAND}(?:;\s*${SED_COMMAND})*'$`,
+  "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 is_full_reading_script(typed) {
+  if (AWK_PROGRAM.test(typed)) return !AWK_EARLY_EXIT.test(typed);
+  return SED_PROGRAM.test(typed);
+}
+function reads_to_the_end(piece, typed) {
+  if (FULL_READING_FILTER.test(piece)) return !EARLY_EXIT_GREP.test(piece);
+  return is_full_reading_script(typed);
+}
+function typed_slices(raw, pieces, gap) {
+  const offset = { at: 0 };
+  return pieces.map((piece) => {
+    const typed = raw.slice(offset.at, offset.at + piece.length);
+    offset.at += piece.length + gap;
+    return typed;
+  });
+}
+function is_filtered_check(pieces, typed) {
+  const [head = "", ...filters] = pieces.map((piece) => piece.trim());
+  return is_verification_command(head) && filters.every((piece, index) => reads_to_the_end(piece, typed[index + 1]?.trim() ?? ""));
+}
+function has_side_effect_syntax(command) {
+  return SIDE_EFFECT_SYNTAX.test(command.replaceAll(ALLOWED_OPERATORS, " "));
+}
+function is_rewritable_part(raw, judged) {
+  const pieces = judged.split("|");
+  return !has_side_effect_syntax(raw) && !GROUP_SYNTAX.test(judged) && is_filtered_check(pieces, typed_slices(raw, pieces, 1));
+}
+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 pieces = shell_segments.parts_of(judged);
+  const parts = typed_slices(command, pieces, 0).map(
+    (raw, index) => rewritten_part(raw, pieces[index] ?? "")
+  );
+  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 = {
+  EARLY_EXIT_GREP,
+  PIPED_VERIFICATION_REASON,
+  PIPEFAIL_NOTE,
+  VERIFICATION_COMMANDS,
+  check_filters,
+  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"));
+var COUNTED_FOR = new RegExp(
+  String.raw`${COMMAND_POSITION}for(?:\s*\(\(|\s+\w+\s+in\s+(?:\$\(\s*seq\b|\{\d+\.\.))`,
+  "u"
+);
+var THROUGH_FIRST_DONE = /^[\s\S]*?\bdone\b/u;
+var SETTLE_SECONDS = 10;
+var NO_SECONDS2 = 0;
+var READ_COMMAND = /^(?:tail|cat|head|ps|stat|grep|wc|ls|pgrep|test|kill\s+-0|\[\[?)(?=\s|$)/u;
+function slept_seconds(segments) {
+  return segments.reduce(
+    (total, segment) => total + (early_heartbeat.sleep_seconds(segment) ?? NO_SECONDS2),
+    NO_SECONDS2
+  );
+}
+function is_sleep_then_read(plain) {
+  const segments = shell_segments.commands_of(plain).filter((segment) => segment !== "");
+  const first_work = segments.findIndex((segment) => !early_heartbeat.is_wait_or_inert(segment));
+  const waited = first_work === -1 ? NO_SECONDS2 : slept_seconds(segments.slice(0, first_work));
+  if (waited < SETTLE_SECONDS) return false;
+  return segments.slice(first_work).every((segment) => early_heartbeat.is_wait_or_inert(segment) || READ_COMMAND.test(segment));
+}
+function is_state_wait(plain) {
+  return UNTIL_HEADER.test(plain) || PROBE_HEADERS.some((header) => header.test(plain));
+}
+function is_counted_sleep(plain) {
+  const header = COUNTED_FOR.exec(plain);
+  if (header === null) return false;
+  const rest = plain.slice(header.index);
+  return SLEEP_COMMAND.test(THROUGH_FIRST_DONE.exec(rest)?.[0] ?? rest);
+}
+function is_sleeping_loop(plain) {
+  return LOOP_KEYWORD2.test(plain) && SLEEP_COMMAND.test(plain) || is_counted_sleep(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 is_sleeping_loop(plain) || is_sleep_then_read(plain);
+}
+var POLL_LOOP_REASON = "\u26D4 output poll loop: a `while`/`until` or counted `for` loop, or a `sleep` chain before a read, does not know when the task finished. `run_in_background` and end the turn \u2014 its exit re-invokes you; a background `Agent` is waited on by its completion notification (lane child: bare `sleep 20`, `pnpm josh run:liveness`); CI by `pnpm josh followup` (`background-commands.md`). Fires on every occurrence.";
+var ROW28 = {
+  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, a counted `for` that sleeps, or a `sleep` chain of 10 s or more before a read of a file or process. Every occurrence",
+    quiet: "the command started with `run_in_background` \u2014 its exit ends the wait"
+  }
+};
+var poll_loop = {
+  POLL_LOOP_REASON,
+  ROW: ROW28,
+  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 ROW29 = {
+  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: ROW29, posts_at_path_literally };
+
+// scripts/rules/reviewer-foreground.ts
+var REVIEWER_AGENTS = /* @__PURE__ */ new Set(["reviewer", "reviewer-verification"]);
+var BACKGROUND_FIELD2 = "run_in_background";
+var CHAIN_RULE_STEP = '`.claude/skills/workflow-commands/chain-rule.md` \u2192 "A lane child"';
+var KILLED = "reviewer foreground: a lane child\u2019s turn end kills a background `reviewer`";
+var FOREGROUND = `\`${BACKGROUND_FIELD2}: false\``;
+var REVIEWER_FOREGROUND_NOTE = `\u21BB ${KILLED}, so the call ran with ${FOREGROUND} (${CHAIN_RULE_STEP}).`;
+var REVIEWER_FOREGROUND_REASON = `\u26D4 ${KILLED}. Reissue the call with ${FOREGROUND} (${CHAIN_RULE_STEP}). It fires on every occurrence.`;
+function is_reviewer(call) {
+  if (!agent_model.SUBAGENT_TOOLS.has(call.name) || !json_value.is_record(call.input)) return false;
+  const type = call.input["subagent_type"];
+  return typeof type === "string" && REVIEWER_AGENTS.has(type.split(":").at(-1) ?? "");
+}
+function is_foreground2(call) {
+  return json_value.is_record(call.input) && call.input[BACKGROUND_FIELD2] === false;
+}
+function is_background_reviewer(call, is_lane_child = lane_child_marker.is_child_of(process.cwd())) {
+  return is_lane_child && is_reviewer(call) && !is_foreground2(call);
+}
+function foreground_input(call, is_lane_child = lane_child_marker.is_child_of(process.cwd())) {
+  if (!is_background_reviewer(call, is_lane_child) || !json_value.is_record(call.input)) {
+    return void 0;
+  }
+  return { ...call.input, [BACKGROUND_FIELD2]: false };
+}
+var ROW30 = {
+  id: "reviewer-foreground",
+  is_trigger: (call) => is_background_reviewer(call),
+  reason: REVIEWER_FOREGROUND_REASON,
+  decide: () => true,
+  keeps: (call) => is_reviewer(call) && is_foreground2(call),
+  reaches: is_reviewer,
+  rewrite: (call) => foreground_input(call),
+  rewrite_note: REVIEWER_FOREGROUND_NOTE,
+  about: {
+    title: "Lane child reviewer dispatched in the foreground",
+    topic: CHAIN_RULE_STEP,
+    fires: "a dispatched lane child\u2019s `Agent` / `Task` call of the `reviewer` or `reviewer-verification` type without `run_in_background: false` \u2014 rewritten with it, every occurrence",
+    quiet: "not a lane child, another agent type, or `run_in_background: false` set"
+  }
+};
+var reviewer_foreground = {
+  REVIEWER_FOREGROUND_NOTE,
+  REVIEWER_FOREGROUND_REASON,
+  ROW: ROW30,
+  foreground_input,
+  is_background_reviewer
+};
+
+// scripts/rules/round-one-check-related.ts
+var CHECK_COMMANDS = /* @__PURE__ */ new Set(["check:related"]);
+var REVIEW_COMMANDS = /* @__PURE__ */ new Set(["run:review"]);
+var SHIP_COMMANDS = /* @__PURE__ */ new Set(["ship"]);
+var JOIN_FLAG = /(?:^|\s)--join(?:[=\s]|$)/u;
+var READING_MODE_FLAG = /(?:^|\s)--(?:pinned|push)(?:[=\s]|$)/u;
+var DETACH_FLAG = /(?:^|\s)--detach(?:[=\s]|$)/u;
+function review_event(segment) {
+  if (JOIN_FLAG.test(segment)) return "close";
+  return READING_MODE_FLAG.test(segment) ? "none" : "brief";
+}
+function segment_event(segment) {
+  if (shell_segments.is_josh_command(segment, REVIEW_COMMANDS)) return review_event(segment);
+  const is_detach = shell_segments.is_josh_command(segment, SHIP_COMMANDS) && DETACH_FLAG.test(segment);
+  return is_detach ? "close" : "none";
+}
+function block_events(block) {
+  if (tail_commands.is_bash_use(block)) {
+    const segments = shell_segments.segments_of(time_shell.bash_command(block.input));
+    return segments.map((segment) => segment_event(segment));
+  }
+  const is_edit = time_markers.tool_marker(block.name, block.input) === time_markers.EDIT_MARKER;
+  return is_edit ? ["edit"] : [];
+}
+function fixes_an_open_round(tail) {
+  const blocks = time_transcript_line.parse_text(tail).flatMap((line) => line.blocks);
+  const events = blocks.flatMap((block) => block_events(block));
+  const brief_at = events.lastIndexOf("brief");
+  if (brief_at === -1) return false;
+  const since_brief = new Set(events.slice(brief_at));
+  return since_brief.has("edit") && !since_brief.has("close");
+}
+function runs_check_related(command) {
+  return shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, CHECK_COMMANDS));
+}
+function is_candidate3(command) {
+  if (!runs_check_related(command)) return false;
+  return lane_child_marker.is_child_of(process.cwd());
+}
+function decide4(_call, run) {
+  return fixes_an_open_round(time_density_hook.read_tail(run.transcript));
+}
+var ROUND_ONE_CHECK_RELATED_REASON = "\u26D4 round-one check:related: round 1's fixes need no `check:related` \u2014 ship's pre-detach reruns the scoped pair on the fixed tree; refused on every occurrence. Go on to `pnpm josh run:review --join`; `--join --fixing` while round 1 has fixes to make (`.claude/skills/workflow-commands/chain-rule.md` \u2192 \"A lane child\").";
+var ROW31 = {
+  id: "round-one-check-related",
+  is_trigger: bash_triggers.on_bash_command(is_candidate3),
+  reason: ROUND_ONE_CHECK_RELATED_REASON,
+  decide: decide4,
+  about: {
+    title: "No check:related on round 1's fixes",
+    topic: '`.claude/skills/workflow-commands/chain-rule.md` \u2192 "A lane child"',
+    fires: "`pnpm josh check:related` (`josh cr`) in a lane child after an `Edit` / `Write` that follows `run:review`'s brief, before `run:review --join` or `ship --detach`. Every occurrence",
+    quiet: "no fix since the brief, already joined or detached, or not a lane child"
+  }
+};
+var round_one_check_related = {
+  ROUND_ONE_CHECK_RELATED_REASON,
+  ROW: ROW31,
+  fixes_an_open_round
+};
+
+// scripts/rules/rule-body-guard.ts
+var { WRITE: WRITE3, is_edit_tool: is_edit_tool5, string_field: string_field3 } = edit_tool;
+var CLAUDE_DOCUMENT = /(?:^|\/)CLAUDE\.md$/u;
+var PROMPT_DOCUMENT = /(?:^|\/)prompts\/.+\.md$/u;
+var SKILL_DOCUMENT = /(?:^|\/)\.claude\/skills\/.+\.md$/u;
+function is_rule_document(file_path2) {
+  return CLAUDE_DOCUMENT.test(file_path2) || PROMPT_DOCUMENT.test(file_path2) || SKILL_DOCUMENT.test(file_path2);
+}
+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 read_existing(file_path2) {
+  return file_reader.read_file_or_empty(file_path2);
+}
+function texts_of(name, input, read2) {
+  if (name === WRITE3) {
+    return {
+      old_text: read2(string_field3(input, "file_path")),
+      new_text: string_field3(input, "content")
+    };
+  }
+  return {
+    old_text: string_field3(input, "old_string"),
+    new_text: string_field3(input, "new_string")
+  };
+}
+function rule_document_input(call) {
+  if (!is_edit_tool5(call.name) || !json_value.is_record(call.input)) return void 0;
+  return is_rule_document(string_field3(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 ROW32 = {
+  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: ROW32,
+  answered_placement,
+  is_rule_document,
+  writes_rule_prose
+};
+
+// scripts/rules/shell-body-trigger.ts
+var FIELD_FLAGS2 = "(?:-f|-F|--field|--raw-field)";
+var MESSAGE_FLAGS = "(?:--body|--notify-message|--recommended|--alternative)";
+var FIELD_OPENING = String.raw`${FIELD_FLAGS2}[\s=]*(?:'?body="|"body=)`;
+var MESSAGE_OPENING = String.raw`${MESSAGE_FLAGS}[\s=]+"`;
+var NESTED_SUBSTITUTION = String.raw`\$\([^()]*\)`;
+var SUBSTITUTION2 = String.raw`\$\((?:[^()$]|\$(?!\()|${NESTED_SUBSTITUTION})*\)`;
+var QUOTED_VALUE = String.raw`(?:[^"\\$]|\\.|\$(?!\()|${SUBSTITUTION2})*`;
+var INLINE_BODY_VALUE = new RegExp(
+  `(?:${FIELD_OPENING}|${MESSAGE_OPENING})(${QUOTED_VALUE})"`,
+  "gu"
+);
+var SHELL_EVALUATED = /[`$]/u;
+var WHOLE_VALUE_SUBSTITUTION = new RegExp(`^${SUBSTITUTION2}$`, "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_FLAGS2}[\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_FLAGS2}[\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-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 REASON = "\u26D4 test declared: this commits a runtime code change with no test beside it \u2014 `pnpm josh test:declared` reads it `required` and names the files. Tests are required for ALL code changes: add the test and reissue, or, for a change that touches no runtime path, declare the non-runtime exception in your Step 0 work summary and reissue. It fires once per run (`CLAUDE.md` \u2192 Code Change Rules).";
+var ROW33 = {
+  id: "test-declared",
+  is_trigger: is_untested_commit,
+  reason: REASON,
+  about: {
+    title: "Test declaration",
+    topic: '`testing-guide.md` \u2192 "0. Per-Requirement Test Coverage (MANDATORY)"',
+    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, ROW: ROW33 };
+
+// scripts/rules/gh-repo-selector.ts
+var GH_COMMAND6 = "gh";
+var API_GROUP = "api";
+var SELECTOR_FLAGS = /* @__PURE__ */ new Set(["-R", "--repo"]);
+var ATTACHED_SELECTOR = /^(?:-R=?|--repo=)(.+)$/u;
+var QUOTES3 = /['"]/gu;
+var NEXT2 = 1;
+var READ_GROUPS = /* @__PURE__ */ new Set(["browse", "search", "status"]);
+var READ_ACTIONS2 = /* @__PURE__ */ new Set([
+  "check",
+  "checkout",
+  "checks",
+  "clone",
+  "diff",
+  "download",
+  "get",
+  "list",
+  "status",
+  "verify",
+  "verify-asset",
+  "view",
+  "watch"
+]);
+var GH_REPO_ASSIGNMENT = /(?:^|\s)GH_REPO=(\S+)/gu;
+var SELECTOR_GROUP = 1;
+function selector_value(word, next) {
+  if (SELECTOR_FLAGS.has(word)) return next;
+  return ATTACHED_SELECTOR.exec(word)?.[1];
+}
+function selectors_of(args) {
+  return args.map((word, index) => selector_value(word, args[index + NEXT2])).filter((value) => value !== void 0).map((value) => value.replaceAll(QUOTES3, ""));
+}
+function is_write_call(args) {
+  const [group = "", action = ""] = direct_pr_create.positional_words(args, SELECTOR_FLAGS);
+  if (group === API_GROUP || READ_GROUPS.has(group)) return false;
+  return !READ_ACTIONS2.has(action);
+}
+function assigned_selectors(segments) {
+  return segments.flatMap((segment) => [...segment.matchAll(GH_REPO_ASSIGNMENT)]).map((match) => (match[SELECTOR_GROUP] ?? "").replaceAll(QUOTES3, ""));
+}
+function write_selectors(segments, index) {
+  const args = git_argv.arguments_of(segments[index] ?? "", GH_COMMAND6);
+  if (args === void 0 || !is_write_call(args)) return [];
+  return [...selectors_of(args), ...assigned_selectors(segments.slice(0, index + NEXT2))];
+}
+var gh_repo_selector = { write_selectors };
+
+// 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 is_claimed_by_narrower_row(command) {
+  return pr_merge.is_pr_merge(command) || repo_admin.is_repo_admin_write(command);
+}
+var GRAPHQL_MUTATION = /\bmutation\b/u;
+var EXPANDED_QUERY = /^(?:-[fF])?"?query=(?!')[\s\S]*\$/u;
+function is_hidden_or_mutation(command, args) {
+  return GRAPHQL_MUTATION.test(command) || args.some((argument) => EXPANDED_QUERY.test(argument));
+}
+function graphql_args(segment) {
+  const call = git_argv.program_of(segment);
+  if (call === void 0 || !gh_api.is_gh_api(segment)) return void 0;
+  return pr_merge.is_graphql_call(call.name, call.args) ? call.args : void 0;
+}
+function is_graphql_mutation(command, segment) {
+  const args = graphql_args(segment);
+  if (args === void 0) return false;
+  return is_hidden_or_mutation(command, args) && !is_claimed_by_narrower_row(command);
+}
+function is_third_party_selector_write(command, segments, index, session_owner) {
+  const selectors = gh_repo_selector.write_selectors(segments, index);
+  const is_third_party = selectors.some((selector) => {
+    const owner = repo_party.selector_owner(selector);
+    return owner === void 0 || repo_party.classify(session_owner, owner) === repo_party.THIRD_PARTY;
+  });
+  return is_third_party && !is_claimed_by_narrower_row(command);
+}
+function is_owner_dependent_write(segments, index) {
+  const segment = segments[index] ?? "";
+  if (gh_api.is_gh_api(segment)) return gh_api.is_write(segment);
+  return gh_repo_selector.write_selectors(segments, index).length > 0;
+}
+function writes_to_third_party_owner(command, segments, resolve_owner, resolve_placeholder_owners) {
+  if (segments.every((_segment, index) => !is_owner_dependent_write(segments, index))) return false;
+  const session_owner = resolve_owner();
+  return segments.some(
+    (segment, index) => is_third_party_selector_write(command, segments, index, session_owner) || is_third_party_write_segment(
+      segment,
+      session_owner,
+      candidates_at(segments, index, 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.quote_aware_commands_of(
+    shell_segments.joined_continuations(command)
+  );
+  if (segments.some((segment) => is_graphql_mutation(command, segment))) return true;
+  return writes_to_third_party_owner(command, segments, resolve_owner, resolve_placeholder_owners);
+}
+var THIRD_PARTY_WRITE_REASON = "\u26D4 third-party write: this `gh` call writes to another owner's repository, or one it cannot read (a GraphQL mutation, an unreadable `-R`) \u2014 Tier C. Check `pnpm josh repo:party <owner/repo>`; first-party, use a REST `repos/<owner>/<repo>` path. Else record it on our Issue and draft it for a person to post. Fires on every occurrence (`upstream-interrupt.md`).";
+var ROW34 = {
+  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) or a `gh <group> <action>` write selected by `-R` / `GH_REPO` to a repository whose owner is not this session, or a `gh api graphql` call whose line names `mutation` or whose query the shell expands, outside the merge and administration rows. Every occurrence",
+    quiet: "a read, a GraphQL query, or a first-party owner (pinned at session start, `pnpm josh repo:party`)"
+  }
+};
+var third_party_write = {
+  ROW: ROW34,
+  THIRD_PARTY_WRITE_REASON,
+  writes_third_party
+};
+
+// scripts/rules/delivered-rules.ts
+var SWITCH_ENV_KEY3 = "JOSH_RULE_GUARD";
+var PRETOOL_GUARD = "pnpm josh pretool:guard";
+var STAMP_PREFIX2 = "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,
+  // Before every first-party row: a credential is refused whatever the call's other faults, and the
+  // commands those rows point at run the same scan in-process.
+  credential_body.ROW,
+  // The direct call only. The filing cap, 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,
+  // Before `issue-comments`, whose rewrite would add the unfiltered comments to the same read.
+  direct_issue_read.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,
+  // Before `piped-verification`, whose rewrite would run under `pipefail` a check that must not run.
+  round_one_check_related.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 reads to the end (`tail`, a full-reading `grep`, `cut`, `sort`, `uniq`, `wc`, `tee`, an `awk` / `sed` that cannot exit early and carries no `<` / `>` / `&`), 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,
+  investigator_foreground.ROW,
+  reviewer_foreground.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,
+  lane_spilled_read.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_edit_rows.SHELL_ROWS,
+  ...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,
+  // Before `rule-body`, its one overlap (a whole-file `Write` of a rule document): the right tool is
+  // chosen before the placement questions are asked of its text.
+  file_edit_rows.REWRITE_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,
+  // Delivered by `stop:guard`; listed here so `rule:value` counts its refusals.
+  concise_reply.ROW
+];
+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) {
+  const refused_at_ms2 = BATCH_STAMP.last_ms(BATCH_STAMP.path(run.transcript));
+  if (run.now_ms - refused_at_ms2 < BATCH_REFUSAL_WINDOW_MS) return true;
+  return will_refuse2(tail, call, run);
+}
+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: decide5, already_satisfied } = rule;
+  if (decide5 === void 0 && already_satisfied === void 0) return is_first_delivery;
+  return function should_block2(tail, call, delivered_at_ms, run) {
+    if (already_satisfied?.(tail, call, run) === true) return false;
+    if (decide5 === void 0) return true;
+    return decide5(call, run, !will_batch_guard_refuse(tail, call, run), delivered_at_ms);
+  };
+}
+function guard_of(rule) {
+  return hook_decision.create_transcript_guard({
+    prefix: `${STAMP_PREFIX2}${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 reason2 = guard.refusal(raw_payload, now_ms);
+    if (reason2 !== void 0) return reason2;
+  }
+  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_edit_rows.FILE_BODY_REASON,
+  DIRECT_FILING_REASON: direct_filing.DIRECT_FILING_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 FILING_OFFER = "the filing needs a title and a body only the model can write";
+var CONCISE_REPLY = "the shorter reply is prose 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`)
+  "reviewer-foreground": rewrite(),
+  // a lane child's `reviewer` given `run_in_background: false`
+  "file-body": judgment(ANOTHER_TOOL),
+  // Edit or Write
+  "file-rewrite": judgment(ANOTHER_TOOL),
+  // Edit
+  "sed-in-place": judgment(ANOTHER_TOOL),
+  // Edit
+  "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"),
+  "credential-body": judgment(
+    "which text is the credential, and what replaces it, is the author\u2019s"
+  ),
+  "rule-body": judgment("a trigger-plus-pointer line is written, not derived"),
+  "direct-filing": judgment(ANOTHER_COMMAND),
+  "direct-issue-comment": judgment(ANOTHER_COMMAND),
+  "direct-issue-read": 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),
+  "round-one-check-related": 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"),
+  "investigator-foreground": judgment("which reads go beside the dispatch is the author\u2019s call"),
+  "lane-carry-conflict": judgment(ANOTHER_COMMAND),
+  "lane-switch-main": judgment(ANOTHER_COMMAND),
+  "lane-direct-tool": rewrite(),
+  // a one-command line behind `pnpm josh reserved-run <weight> --`
+  "lane-spilled-read": 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),
+  "git-force": judgment(NO_RUN),
+  "worktree-mutation": judgment(NO_RUN),
+  "index-mutation": judgment(NO_RUN),
+  "destructive-command": judgment(NO_RUN),
+  "repo-admin": 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),
+  "filing-offer": judgment(FILING_OFFER),
+  "hold-release": judgment(HOLD_RELEASE),
+  "concise-reply": judgment(CONCISE_REPLY)
+};
+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_PREFIX3 = "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_PREFIX3);
+  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_PREFIX4 = "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 = "`pnpm josh cost --cut`";
+var PARENT_CUT_REASON = `\u26D4 backlogrun parent hand-off: this session drives a \`backlogrun\` and its recent context 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_PREFIX4).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_PREFIX4);
+  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_exempt(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_exempt(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_PREFIX5 = "-";
+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_PREFIX5)).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/step-zero-notice.ts
+import path3 from "node:path";
+var STAMP_PREFIX5 = "josh-step-zero-notice-";
+var EDIT_TOOLS2 = /* @__PURE__ */ new Set(["Edit", "Write"]);
+var PARENT_PREFIX = "..";
+var NOTICE = "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 STAMP3 = hook_decision.create_refusal_stamp(STAMP_PREFIX5);
+function edited_paths(tool_input) {
+  if (!json_value.is_record(tool_input)) return [];
+  const { file_path: file_path2, file_paths } = tool_input;
+  const listed = Array.isArray(file_paths) ? file_paths : [];
+  return [file_path2, ...listed].filter(
+    (entry) => typeof entry === "string" && entry.length > 0
+  );
+}
+function is_runtime_file(file_path2, root) {
+  const relative = path3.relative(root, path3.resolve(root, file_path2));
+  if (relative.startsWith(PARENT_PREFIX) || path3.isAbsolute(relative)) return false;
+  return !test_declared_logic.is_exempt(relative.split(path3.sep).join("/"));
+}
+function is_candidate4(raw_payload, root) {
+  const payload = hook_decision.parse_hook_payload(raw_payload);
+  if (payload === void 0 || !EDIT_TOOLS2.has(payload.tool_name)) return void 0;
+  const has_runtime_file = edited_paths(payload.tool_input).some(
+    (file_path2) => is_runtime_file(file_path2, root)
+  );
+  return has_runtime_file ? payload.transcript_path : void 0;
+}
+function is_runtime_edit(raw_payload, root = process.cwd()) {
+  return is_candidate4(raw_payload, root) !== void 0;
+}
+function notice(raw_payload, root = process.cwd()) {
+  const transcript = is_candidate4(raw_payload, root);
+  if (transcript === void 0) return void 0;
+  const target = STAMP3.path(transcript);
+  if (STAMP3.last_ms(target) !== hook_decision.NEVER_MS || !STAMP3.record(target, Date.now())) {
+    return void 0;
+  }
+  return NOTICE;
+}
+var step_zero_notice = { NOTICE, is_runtime_edit, notice, stamp_path: STAMP3.path };
+
+// scripts/hooks/lane-plan-guard.ts
+var COMMAND_DOC = '`docs/josh-commands-run.md` \u2192 "`josh lane:plan`"';
+var OUTCOMES = "on `yield` end the session with no edit (its lane is given back); on `wait` run it again";
+function reason_text(issue) {
+  const command = `\`pnpm josh lane:plan ${issue} <path>...\``;
+  return `\u26D4 lane plan: run ${command} naming every file the work summary changes before the first implementation edit \u2014 ${OUTCOMES} (${COMMAND_DOC}).`;
+}
+function lane_child_edit(raw_payload, directory, source) {
+  if (!lane_child_marker.is_child_of(directory, source)) return void 0;
+  return step_zero_notice.is_runtime_edit(raw_payload, directory) ? lane_child_marker.marked_issue(source) : void 0;
+}
+function reason(raw_payload, directory = process.cwd(), source = process.env) {
+  const issue = lane_child_edit(raw_payload, directory, source);
+  if (issue === void 0) return void 0;
+  return lane_plan.is_uncleared(Number(issue), directory) ? reason_text(issue) : void 0;
+}
+var lane_plan_guard = { reason };
+
+// 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 STAMP4 = hook_decision.create_refusal_stamp(STAMP_PREFIX6);
+function notice2(raw_payload) {
+  const payload = hook_decision.parse_hook_payload(raw_payload);
+  if (payload?.tool_name !== cost_blocks.BASH_TOOL) return void 0;
+  const target = STAMP4.path(payload.transcript_path);
+  if (STAMP4.last_ms(target) !== hook_decision.NEVER_MS || !STAMP4.record(target, Date.now())) {
+    return void 0;
+  }
+  return NOTICE2;
+}
+var shell_rules_notice = { NOTICE: NOTICE2, notice: notice2, stamp_path: STAMP4.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 reason2 = outcomes.find((outcome) => outcome.reason !== void 0)?.reason ?? rule_reason;
+  if (reason2 !== void 0) return { reason: reason2, 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),
+    { reason: lane_plan_guard.reason(raw_payload), notice: void 0, fault: void 0 }
+  ];
+  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 reason2 = await async_reason(raw_payload);
+  if (reason2 !== void 0) return { reason: reason2, 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
+};