@joshuafolkken/kit 1.1471.0 → 1.1514.0

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

@@ -1,92 +1,99 @@
 import {
   duplicate_read_outcome
-} from "./chunk-YYPI7SJZ.js";
+} from "./chunk-PF2NZL2A.js";
 import {
   ALREADY_DONE_LABEL,
   CONTEXT_CUT_THRESHOLD,
   IN_PROGRESS_LABEL,
   NEEDS_DECISION_LABEL,
-  NEEDS_HUMAN_REVIEW_LABEL,
   bash_triggers,
+  cost_cli,
+  cost_verdict,
   filing_cap,
-  git_gh_api_path,
   git_gh_command,
-  git_gh_exec,
   git_gh_issue_read,
-  git_gh_pr_read,
   has_any_label,
-  has_stdout_field,
+  interactive_ask,
   issue_watch_diff,
   lane_background,
   lane_park,
-  parse_json_object_or_undefined,
-  read_json_listing,
+  pre_gate_cut,
   repo_party,
   run_cut,
   run_cut_handoff,
-  run_hold,
+  run_liveness,
   run_tail_rule,
-  session_cite,
   shell_segments,
   tail_commands
-} from "./chunk-43ZHT22P.js";
+} from "./chunk-SYOTDYCI.js";
 import {
-  ancestor_directories,
   find_local_bin_upwards,
   json_object_schema,
   string_array_schema,
   string_record_schema,
   vscode_settings_schema
-} from "./chunk-IX6TTTI6.js";
+} from "./chunk-EFXE6C37.js";
+import {
+  distributed_paths
+} from "./chunk-M4HGZV7U.js";
 import {
-  agent_role_profile,
-  agent_session_role,
   git_common_directory,
+  git_gh_api_path,
+  git_gh_exec,
+  has_stdout_field,
   issue_cite,
   lane_registry,
+  read_json_listing,
   repo_origin,
   run_event_scope,
   run_event_stream,
   run_event_stream_emit,
   run_headless,
+  run_hold,
+  run_preflight,
+  session_cite,
   session_language
-} from "./chunk-EUMACUK2.js";
+} from "./chunk-WK6SMBIC.js";
+import {
+  ancestor_directories
+} from "./chunk-GP4IEC4O.js";
 import {
   error_text
 } from "./chunk-CDY4NFQG.js";
 import {
   batch_outcome
-} from "./chunk-YHBZAJSV.js";
+} from "./chunk-A65Y4YOR.js";
 import {
   investigation_outcome
-} from "./chunk-K4LMBQC2.js";
+} from "./chunk-7DSBJVFH.js";
 import {
   investigation_reads
-} from "./chunk-H5HVWYXK.js";
+} from "./chunk-PTICX4OL.js";
+import {
+  agent_role_profile,
+  agent_session_role
+} from "./chunk-UPUZF3AN.js";
 import {
   lane_guard_policy
-} from "./chunk-SHGPANFB.js";
+} from "./chunk-JP45SOCJ.js";
 import {
   hook_decision
-} from "./chunk-J47HU5H5.js";
+} from "./chunk-6TS2JD6D.js";
 import {
-  cost_attribute,
   cost_blocks,
-  open_issue_schema,
   time_batch_guard,
   time_density_hook,
-  time_shell
-} from "./chunk-AS74OU3D.js";
+  time_hook_transcript,
+  time_shell,
+  time_spans
+} from "./chunk-TNUMY6NL.js";
 import {
   lane_child_marker
-} from "./chunk-K4EOONYM.js";
+} from "./chunk-LAOV7NLM.js";
 import {
   GIT_LOCATION_VARIABLES,
   PORCELAIN_FLAG,
   UNTRACKED_FILES_FLAG,
-  cli_flags,
-  cost_transcript,
-  cost_usage,
   file_reader,
   git_command,
   git_diff_reads,
@@ -94,11 +101,10 @@ import {
   issue_number_shape,
   json_value,
   lane_paths,
-  own_session,
+  open_issue_schema,
   run_carry
-} from "./chunk-E7OIKX5Z.js";
+} from "./chunk-APUO6U4J.js";
 import {
-  PLATFORM_TEMP_ROOT,
   PROBE_TIMEOUT_MS,
   PROJECT_ROOT,
   package_path,
@@ -116,9 +122,9 @@ var HEADER_BODY_SEPARATOR = /\r?\n\r?\n/u;
 var ETAG_HEADER = /^etag: *(?<etag>[^\r\n]+)/imu;
 var UNCHANGED = { kind: "unchanged" };
 var UNREADABLE = { kind: "unreadable" };
-function to_args(path16, etag) {
+function to_args(path13, etag) {
   const header = etag === void 0 ? [] : [HEADER_FLAG, `${IF_NONE_MATCH}${etag}`];
-  return ["api", INCLUDE_FLAG, ...header, path16];
+  return ["api", INCLUDE_FLAG, ...header, path13];
 }
 function to_changed(output) {
   const [headers = "", ...rest] = output.split(HEADER_BODY_SEPARATOR);
@@ -132,9 +138,9 @@ function failure_status(error) {
   const cause = error instanceof Error ? error.cause : void 0;
   return has_stdout_field(cause) ? git_gh_exec.parse_status_line(cause.stdout) : void 0;
 }
-async function read_conditional(path16, etag, timeout_ms) {
+async function read_conditional(path13, etag, timeout_ms) {
   try {
-    return to_read(await git_gh_exec.exec_gh_command(to_args(path16, etag), timeout_ms));
+    return to_read(await git_gh_exec.exec_gh_command(to_args(path13, etag), timeout_ms));
   } catch (error) {
     return failure_status(error) === NOT_MODIFIED_STATUS ? UNCHANGED : UNREADABLE;
   }
@@ -178,16 +184,16 @@ async function read_snapshot(request2, body, etag) {
   return comments === void 0 ? UNREADABLE2 : { kind: "read", snapshot: { body, comments }, etag };
 }
 async function fetch_issue(request2) {
-  const read3 = await git_gh_conditional.read_conditional(
+  const read2 = await git_gh_conditional.read_conditional(
     git_gh_api_path.issue_api_path(request2.issue),
     request2.etag,
     request2.timeout_ms
   );
-  if (read3.kind !== "changed") return read3;
-  const fields = json_value.parse_with(read3.body, issue_schema);
+  if (read2.kind !== "changed") return read2;
+  const fields = json_value.parse_with(read2.body, issue_schema);
   if (fields === void 0) return UNREADABLE2;
   if (fields.state === CLOSED_STATE) return { kind: "closed" };
-  return await read_snapshot(request2, fields.body ?? "", read3.etag);
+  return await read_snapshot(request2, fields.body ?? "", read2.etag);
 }
 function fresh_record(issue, fetched, now, acknowledged_at = now.toISOString()) {
   const baseline = issue_watch_diff.baseline_of(fetched.snapshot);
@@ -542,12 +548,41 @@ async function mark_implement(directory = process.cwd(), source = process.env) {
 }
 var lane_phase = { mark_implement };
 
+// scripts/rules/agent-model.ts
+var SUBAGENT_TOOLS = /* @__PURE__ */ new Set(["Agent", "Task"]);
+var GENERAL_PURPOSE = "general-purpose";
+function is_general_purpose(call) {
+  if (!SUBAGENT_TOOLS.has(call.name) || !json_value.is_record(call.input)) return false;
+  const type = call.input["subagent_type"];
+  return type === void 0 || type === GENERAL_PURPOSE;
+}
+function names_model(call) {
+  const model = json_value.is_record(call.input) ? call.input["model"] : void 0;
+  return typeof model === "string" && model.length > 0;
+}
+function is_unnamed_model(call) {
+  return is_general_purpose(call) && !names_model(call);
+}
+function keeps_model(call) {
+  return is_general_purpose(call) && names_model(call);
+}
+var AGENT_MODEL_REASON = "\u26D4 agent model: a `general-purpose` subagent with no `model` inherits the parent model. Reissue the call with `model` set \u2014 `sonnet` for routine work, `opus` for judgment such as a review. It fires on every occurrence (`.claude/skills/workflow-commands/delegation.md`).";
+var ROW = {
+  id: "agent-model",
+  is_trigger: is_unnamed_model,
+  reason: AGENT_MODEL_REASON,
+  decide: () => true,
+  keeps: keeps_model,
+  reaches: is_general_purpose
+};
+var agent_model = { AGENT_MODEL_REASON, ROW, is_unnamed_model };
+
 // scripts/rules/direct-filing.ts
 var DIRECT_FILING_REASON = '\u26D4 direct filing: an Issue is filed with `pnpm josh issue:file "<title>" --body-file <path> --depth <0|1|2>`, never with `gh api \u2026/issues` or `gh issue create` \u2014 it runs the scout, the lint, the labels and `epic:bundle` itself. It fires on every occurrence (`docs/josh-commands-backlog.md` \u2192 "`josh issue:file`").';
 function is_any_filing(command) {
   return bash_triggers.is_direct_filing(command) || bash_triggers.is_issue_filing(command);
 }
-var ROW = {
+var ROW2 = {
   id: "direct-filing",
   is_trigger: bash_triggers.on_bash_command(bash_triggers.is_direct_filing),
   reason: DIRECT_FILING_REASON,
@@ -555,7 +590,7 @@ var ROW = {
   keeps: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
   reaches: bash_triggers.on_bash_command(is_any_filing)
 };
-var direct_filing = { DIRECT_FILING_REASON, ROW };
+var direct_filing = { DIRECT_FILING_REASON, ROW: ROW2 };
 
 // scripts/run/progress/run-progress.ts
 var DEFAULT_INTERVAL_MINUTES = 20;
@@ -892,12 +927,12 @@ function landing_ms(command, now_ms, last_report_ms) {
   const lands_ms = now_ms + duration_ms;
   return run_progress.is_due(last_report_ms, lands_ms, interval_ms) ? lands_ms : void 0;
 }
-function decide(call, run2, can_record) {
+function decide(call, run, can_record) {
   const last_report_ms = run_progress_clock.read_last_report_sync();
   if (last_report_ms === void 0) return false;
-  const target = ARM_RECORD.path(run2.transcript);
-  if (is_armed(target, run2.now_ms)) return true;
-  const lands_ms = landing_ms(time_shell.bash_command(call.input), run2.now_ms, last_report_ms);
+  const target = ARM_RECORD.path(run.transcript);
+  if (is_armed(target, run.now_ms)) return true;
+  const lands_ms = landing_ms(time_shell.bash_command(call.input), run.now_ms, last_report_ms);
   if (lands_ms === void 0) return true;
   if (can_record) ARM_RECORD.record(target, lands_ms);
   return false;
@@ -1001,7 +1036,7 @@ function carries_a_file_body(command, has_file = existsSync) {
   );
 }
 var FILE_BODY_REASON = "\u26D4 file body in a shell command: this carries a file's new text inline, which is re-read on every later request. Edit a region with the Edit tool, rewrite a whole file with the Write tool, and pass a body by path (`--body-file <path>`); a new-file `cat > <new-file> <<EOF` stays allowed. This rule fires on every occurrence (`prompts/collaboration-workflow/file-edits.md`).";
-var ROW2 = {
+var ROW3 = {
   id: "file-body",
   is_trigger: bash_triggers.on_bash_command((command) => carries_a_file_body(command)),
   reason: FILE_BODY_REASON,
@@ -1009,7 +1044,7 @@ var ROW2 = {
 };
 var file_body = {
   FILE_BODY_REASON,
-  ROW: ROW2,
+  ROW: ROW3,
   carries_a_file_body
 };
 
@@ -1112,7 +1147,7 @@ function is_force_or_delete(command) {
   return shell_segments.segments_of(command).some((segment) => is_destructive_segment(segment));
 }
 var GIT_FORCE_REASON = "\u26D4 force push or branch delete: this rewrites or removes shared history, which is Tier C and needs explicit current-turn user instruction. Push with `pnpm josh git`; leave a force push or branch delete to the user's own terminal. This rule fires on every occurrence (`prompts/collaboration-workflow/operating-rules.md`).";
-var ROW3 = {
+var ROW4 = {
   id: "git-force",
   is_trigger: bash_triggers.on_bash_command(is_force_or_delete),
   reason: GIT_FORCE_REASON,
@@ -1120,376 +1155,10 @@ var ROW3 = {
 };
 var git_force = {
   GIT_FORCE_REASON,
-  ROW: ROW3,
+  ROW: ROW4,
   is_force_or_delete
 };
 
-// scripts/cost-runtime/cost-cli.ts
-import { fileURLToPath } from "node:url";
-
-// scripts/cost-runtime/codex-usage.ts
-import { globSync, readFileSync as readFileSync2 } from "node:fs";
-import path2 from "node:path";
-import { z as z4 } from "zod";
-var THREAD_ID_PATTERN = /^[A-Za-z0-9-]+$/u;
-var SESSION_META_SCHEMA = z4.looseObject({
-  type: z4.literal("session_meta"),
-  payload: z4.looseObject({ id: z4.string(), cwd: z4.string() })
-});
-var TOTAL_USAGE_SCHEMA = z4.looseObject({ input_tokens: z4.number().nonnegative() });
-var TOKEN_COUNT_SCHEMA = z4.looseObject({
-  type: z4.literal("event_msg"),
-  payload: z4.looseObject({
-    type: z4.literal("token_count"),
-    info: z4.looseObject({
-      total_token_usage: TOTAL_USAGE_SCHEMA,
-      last_token_usage: TOTAL_USAGE_SCHEMA
-    })
-  })
-});
-function same_project(cwd, target) {
-  return cost_transcript.session_cwd(cwd) === cost_transcript.session_cwd(target);
-}
-function billed_per_request(usages) {
-  return usages.map((usage) => usage.last_token_usage.input_tokens);
-}
-function measurement_from(content, target, thread_id) {
-  const values = content.split("\n").map((line) => json_value.parse_or_undefined(line));
-  const metadata = values.flatMap((value) => {
-    const parsed = SESSION_META_SCHEMA.safeParse(value);
-    return parsed.success ? [parsed.data] : [];
-  });
-  const usages = values.flatMap((value) => {
-    const parsed = TOKEN_COUNT_SCHEMA.safeParse(value);
-    return parsed.success ? [parsed.data.payload.info] : [];
-  });
-  const session = metadata.find((entry) => entry.payload.id === thread_id);
-  if (session === void 0 || usages.length === 0 || !same_project(session.payload.cwd, target)) {
-    return void 0;
-  }
-  return { billed_input_per_request: billed_per_request(usages) };
-}
-function rollout_files(home, thread_id) {
-  if (!THREAD_ID_PATTERN.test(thread_id)) return [];
-  return globSync(`sessions/**/*${thread_id}.jsonl`, { cwd: home }).map(
-    (file) => path2.join(home, file)
-  );
-}
-function read_measurement(file, target, thread_id) {
-  try {
-    return measurement_from(readFileSync2(file, "utf8"), target, thread_id);
-  } catch {
-    return void 0;
-  }
-}
-function latest_measurement(files, target, thread_id) {
-  for (const file of files.toReversed()) {
-    const measured = read_measurement(file, target, thread_id);
-    if (measured !== void 0) return measured;
-  }
-  return void 0;
-}
-function measurement(target, default_home, environment = process.env) {
-  const thread_id = environment["CODEX_THREAD_ID"];
-  if (thread_id === void 0) return void 0;
-  const home = environment["CODEX_HOME"] ?? path2.join(default_home, ".codex");
-  return latest_measurement(rollout_files(home, thread_id), target, thread_id);
-}
-var codex_usage = { measurement };
-
-// scripts/cost-runtime/cost-corpus.ts
-function accumulate_missing(sessions) {
-  return {
-    no_usage_lines: sessions.reduce((sum, session) => sum + session.no_usage_lines, 0),
-    malformed_lines: sessions.reduce((sum, session) => sum + session.malformed_lines, 0),
-    unreadable_sessions: sessions.filter((session) => !session.is_readable).length,
-    // Filled by the attribution, which is the only step that knows a unit could not follow its
-    // parent; a per-session tally cannot see it, so it is zero here and set for an issue scope below.
-    unattributed_sessions: 0
-  };
-}
-function load_corpus(cwd) {
-  const files = cost_transcript.list_sessions_across(cost_transcript.transcript_directories(cwd));
-  const sessions = files.map((file) => cost_transcript.read_session(file));
-  return { sessions, files, missing: accumulate_missing(sessions) };
-}
-function session_meta(corpus) {
-  return new Map(
-    corpus.files.map((file) => [
-      file.session_id,
-      { is_delegated: file.is_delegated, owner: cost_transcript.owning_session_id(file) }
-    ])
-  );
-}
-function issue_set(records) {
-  const issues = cost_attribute.group_by_issue(records).map((group) => group.issue).filter((issue) => issue !== cost_attribute.UNATTRIBUTED_KEY);
-  return new Set(issues);
-}
-function sole_of(issues) {
-  if (issues.size !== 1) return cost_attribute.UNATTRIBUTED_KEY;
-  return [...issues][0] ?? cost_attribute.UNATTRIBUTED_KEY;
-}
-function owner_sets(corpus, meta) {
-  const own = corpus.sessions.filter(
-    (session) => meta.get(session.session_id)?.is_delegated !== true
-  );
-  return new Map(own.map((session) => [session.session_id, issue_set(session.records)]));
-}
-function pairs_with_inherited(session, inherited, is_delegated) {
-  return cost_attribute.group_by_issue(session.records).flatMap(
-    (group) => group.records.map((record2) => ({
-      record: record2,
-      issue: group.issue === cost_attribute.UNATTRIBUTED_KEY ? inherited : group.issue,
-      baseline_tokens: session.baseline_tokens,
-      session_id: session.session_id,
-      is_delegated
-    }))
-  );
-}
-var NO_ISSUES = /* @__PURE__ */ new Set();
-function parent_issues(session, meta, owners) {
-  const entry = meta.get(session.session_id);
-  if (entry?.is_delegated !== true) return NO_ISSUES;
-  return owners.get(entry.owner) ?? NO_ISSUES;
-}
-function pairs_of_session(session, meta, owners) {
-  const is_delegated = meta.get(session.session_id)?.is_delegated === true;
-  const candidates = parent_issues(session, meta, owners);
-  const inherited = is_delegated ? sole_of(candidates) : cost_attribute.UNATTRIBUTED_KEY;
-  const pairs = pairs_with_inherited(session, inherited, is_delegated);
-  const has_unattributed = pairs.some((pair) => pair.issue === cost_attribute.UNATTRIBUTED_KEY);
-  if (!is_delegated || !has_unattributed) return { pairs };
-  return { pairs, unattributed_candidates: candidates };
-}
-function attribute_corpus(corpus) {
-  const meta = session_meta(corpus);
-  const owners = owner_sets(corpus, meta);
-  const per_session = corpus.sessions.map((session) => pairs_of_session(session, meta, owners));
-  return {
-    pairs: per_session.flatMap((one) => one.pairs),
-    unattributed: per_session.flatMap(
-      (one) => one.unattributed_candidates === void 0 ? [] : [one.unattributed_candidates]
-    )
-  };
-}
-function floor_for_issue(unattributed, issue_number) {
-  return unattributed.filter((set) => set.size === 0 || set.has(issue_number)).length;
-}
-function is_better(candidate, existing) {
-  const { UNATTRIBUTED_KEY } = cost_attribute;
-  return existing.issue === UNATTRIBUTED_KEY && candidate.issue !== UNATTRIBUTED_KEY;
-}
-function values_of(best) {
-  const collected = [];
-  for (const [, pair] of best) collected.push(pair);
-  return collected;
-}
-function dedupe_across_sessions(pairs) {
-  const best = /* @__PURE__ */ new Map();
-  for (const pair of pairs) {
-    const existing = best.get(pair.record.request_id);
-    if (existing === void 0 || is_better(pair, existing)) {
-      best.set(pair.record.request_id, pair);
-    }
-  }
-  return values_of(best);
-}
-function attributed(corpus) {
-  return dedupe_across_sessions(attribute_corpus(corpus).pairs);
-}
-function mainline_records(pairs) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const pair of pairs) {
-    if (pair.is_delegated) continue;
-    groups.set(pair.session_id, [...groups.get(pair.session_id) ?? [], pair.record]);
-  }
-  return [...groups.values()];
-}
-var cost_corpus = {
-  load_corpus,
-  attribute_corpus,
-  floor_for_issue,
-  attributed,
-  mainline_records
-};
-
-// scripts/cost-runtime/cost-verdict.ts
-var FAILURE_EXIT_CODE = 1;
-var OVER_VERDICT = "over";
-var UNDER_VERDICT = "under";
-function per_request_cost(measurement2) {
-  return measurement2.billed_input_per_request.at(-1) ?? 0;
-}
-function classify(measurement2, limit) {
-  return per_request_cost(measurement2) > limit ? OVER_VERDICT : UNDER_VERDICT;
-}
-function over_summary(measurement2, limit) {
-  const total = measurement2.billed_input_per_request.length;
-  return `${String(per_request_cost(measurement2))} billed input tokens per request, on the newest of ${String(total)} request(s); limit ${String(limit)}`;
-}
-function report_over(measurement2, limit) {
-  if (measurement2 === void 0 || measurement2.billed_input_per_request.length === 0) {
-    console.error("No requests in this session; there is nothing to hand off.");
-    return FAILURE_EXIT_CODE;
-  }
-  console.info(classify(measurement2, limit));
-  console.error(over_summary(measurement2, limit));
-  return 0;
-}
-var cost_verdict = {
-  OVER_VERDICT,
-  UNDER_VERDICT,
-  classify,
-  per_request_cost,
-  report_over
-};
-
-// scripts/cost-runtime/transcript-cwd.ts
-import path3 from "node:path";
-function resolve(target, cwd) {
-  return target === void 0 ? cwd : path3.resolve(target);
-}
-var transcript_cwd = { resolve };
-
-// scripts/cost-runtime/cost-cli.ts
-var ARGV_OFFSET = 2;
-var FAILURE_EXIT_CODE2 = 1;
-var USAGE = "Usage: josh cost (--cut | --over <tokens-per-request>) [--path <dir>]";
-var UNMEASURABLE_VERDICT = "unmeasurable";
-function to_threshold(raw) {
-  if (raw === void 0 || raw.trim() === "") return void 0;
-  const parsed = Number(raw);
-  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
-}
-function is_unparsed(raw, parsed) {
-  return parsed === void 0 && raw !== void 0;
-}
-function selected_threshold(values) {
-  if (values.cut === true) return CONTEXT_CUT_THRESHOLD;
-  return to_threshold(values.over);
-}
-function threshold_option(over) {
-  return over === void 0 ? {} : { over };
-}
-function path_option(path16) {
-  return path16 === void 0 ? {} : { path: path16 };
-}
-function to_options(values) {
-  if (values.cut === true && values.over !== void 0) return void 0;
-  const over = selected_threshold(values);
-  if (is_unparsed(values.over, over)) return void 0;
-  return { ...threshold_option(over), ...path_option(values.path) };
-}
-var PARSE_ARGS_OPTIONS = {
-  cut: { type: "boolean" },
-  over: { type: "string" },
-  path: { type: "string" }
-};
-function parse_options(argv) {
-  const values = cli_flags.values_of(argv, PARSE_ARGS_OPTIONS);
-  return values === void 0 ? void 0 : to_options(values);
-}
-function report_empty(cwd, session_id) {
-  const searched = cost_transcript.searched_directories(cost_transcript.transcript_directories(cwd));
-  for (const line of cost_transcript.missing_message(searched, session_id)) console.error(line);
-  return FAILURE_EXIT_CODE2;
-}
-function provider_of(environment) {
-  const resolved = agent_role_profile.resolve_provider(environment);
-  if (resolved.kind !== "provider" || resolved.is_default === true) return void 0;
-  return resolved.provider;
-}
-function measurement_of(session) {
-  return {
-    billed_input_per_request: session.records.map(
-      (record2) => cost_usage.billed_input(record2.totals)
-    )
-  };
-}
-function anthropic_own(target, environment) {
-  const corpus = cost_corpus.load_corpus(target);
-  const selection = own_session.select_own_session(corpus.files, environment);
-  if (selection.kind === "absent") return { kind: "absent", session_id: selection.session_id };
-  const session = corpus.sessions[selection.index];
-  if (session === void 0) return { kind: "empty" };
-  return { kind: "measured", measurement: measurement_of(session) };
-}
-function anthropic_measurement(target, environment) {
-  const own = anthropic_own(target, environment);
-  return own.kind === "measured" ? own.measurement : void 0;
-}
-function same_openai_project(target, cwd) {
-  return cost_transcript.session_cwd(target) === cost_transcript.session_cwd(cwd);
-}
-function reject_openai_cross_project(context, target, cwd) {
-  if (context.provider !== "openai" || context.path === void 0 || same_openai_project(target, cwd)) {
-    return false;
-  }
-  console.error(
-    "OpenAI --path cannot select a thread from another project; run josh cost in that project."
-  );
-  return true;
-}
-function measure(target, provider, environment) {
-  return provider === "openai" ? codex_usage.measurement(target, cost_transcript.home_directory(), environment) : anthropic_measurement(target, environment);
-}
-function run_over_anthropic(own, target, limit) {
-  if (own.kind === "measured") return cost_verdict.report_over(own.measurement, limit);
-  return report_empty(target, own.kind === "absent" ? own.session_id : void 0);
-}
-function run_over_codex(target, limit, environment) {
-  const measurement2 = measure(target, "openai", environment);
-  if (measurement2 !== void 0) return cost_verdict.report_over(measurement2, limit);
-  console.error(`No Codex usage found for the current OpenAI thread under ${target}.`);
-  return FAILURE_EXIT_CODE2;
-}
-function run_over(target, limit, provider, environment) {
-  if (provider === "anthropic") {
-    return run_over_anthropic(anthropic_own(target, environment), target, limit);
-  }
-  return run_over_codex(target, limit, environment);
-}
-function verdict_of(measurement2) {
-  if (measurement2 === void 0 || measurement2.billed_input_per_request.length === 0) {
-    return UNMEASURABLE_VERDICT;
-  }
-  return cost_verdict.classify(measurement2, CONTEXT_CUT_THRESHOLD);
-}
-function session_verdict(cwd = process.cwd(), environment = process.env) {
-  const provider = provider_of(environment);
-  if (provider === void 0) return UNMEASURABLE_VERDICT;
-  return verdict_of(measure(cwd, provider, environment));
-}
-function run_context(argv, environment) {
-  const options = parse_options(argv);
-  if (options?.over === void 0) return void 0;
-  const provider = provider_of(environment);
-  if (provider === void 0) return void 0;
-  return { over: options.over, path: options.path, provider };
-}
-function run(argv, cwd = process.cwd(), environment = process.env) {
-  const context = run_context(argv, environment);
-  if (context === void 0) {
-    console.error(USAGE);
-    return FAILURE_EXIT_CODE2;
-  }
-  const target = transcript_cwd.resolve(context.path, cwd);
-  if (reject_openai_cross_project(context, target, cwd)) return FAILURE_EXIT_CODE2;
-  return run_over(target, context.over, context.provider, environment);
-}
-function main(argv) {
-  process.exitCode = run(argv);
-}
-var cost_cli = {
-  UNMEASURABLE_VERDICT,
-  USAGE,
-  parse_options,
-  to_threshold,
-  run,
-  session_verdict
-};
-if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(ARGV_OFFSET));
-
 // scripts/cost-runtime/cost-format.ts
 var USD_DECIMALS = 4;
 var PERCENT_SCALE = 100;
@@ -1511,9 +1180,9 @@ var cost_format = {
 };
 
 // scripts/run/cut/run-cut-decline.ts
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 var DECLINE_PREFIX = "josh-run-cut-decline-";
-var decline_schema = z5.object({ issue: z5.string(), hold_taken_at: z5.string().optional() });
+var decline_schema = z4.object({ issue: z4.string(), hold_taken_at: z4.string().optional() });
 function decline_path(git_directory) {
   return stamp_file.stamp_path(DECLINE_PREFIX, git_directory);
 }
@@ -1567,14 +1236,14 @@ function read_tree_sync() {
   const reference = git_spawn_sync.read(git_diff_reads.DEFAULT_BRANCH_ARGUMENTS);
   return tree_of(status, git_diff_reads.default_branch_of(reference));
 }
-function is_ready_sync(read3 = read_tree_sync) {
-  const tree = read3();
+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 z6 } from "zod";
+import { z as z5 } from "zod";
 var VERDICT_CACHE_PREFIX = "josh-impl-cut-verdict-";
 var VERDICT_REUSE_MS = 5e3;
 var VERDICT_VALUES = [
@@ -1582,7 +1251,7 @@ var VERDICT_VALUES = [
   "under",
   "unmeasurable"
 ];
-var cache_schema = z6.object({ read_at_ms: z6.number(), verdict: z6.enum(VERDICT_VALUES) });
+var cache_schema = z5.object({ read_at_ms: z5.number(), verdict: z5.enum(VERDICT_VALUES) });
 function cache_path(directory) {
   return stamp_file.stamp_path(VERDICT_CACHE_PREFIX, directory);
 }
@@ -1593,11 +1262,11 @@ function cached_verdict(target, now_ms) {
   if (cached === void 0) return void 0;
   return now_ms - cached.read_at_ms < VERDICT_REUSE_MS ? cached.verdict : void 0;
 }
-function reused_verdict(read3, directory = process.cwd(), now_ms = Date.now()) {
+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 = read3();
+  const value = read2();
   stamp_file.replace_stamp(target, { read_at_ms: now_ms, verdict: value });
   return value;
 }
@@ -1670,10 +1339,10 @@ var REISSUE_WINDOW_MS = 9e4;
 function is_reissued_refusal(now_ms, delivered_at_ms) {
   return now_ms - delivered_at_ms < REISSUE_WINDOW_MS;
 }
-function decide2(_call, run2, _can_record, delivered_at_ms) {
-  return !is_reissued_refusal(run2.now_ms, delivered_at_ms);
+function decide2(_call, run, _can_record, delivered_at_ms) {
+  return !is_reissued_refusal(run.now_ms, delivered_at_ms);
 }
-var ROW4 = {
+var ROW5 = {
   id: "implementation-cut",
   is_trigger: is_over_threshold_edit,
   reason: IMPLEMENTATION_CUT_REASON,
@@ -1688,7 +1357,7 @@ var ROW4 = {
 var implementation_cut = {
   IMPLEMENTATION_CUT_REASON,
   REISSUE_WINDOW_MS,
-  ROW: ROW4,
+  ROW: ROW5,
   decide: decide2,
   is_over_threshold_edit,
   is_reissued_refusal,
@@ -1815,19 +1484,48 @@ function is_body_only_issue_read(command) {
 function reads_issue_comments(command) {
   return shell_segments.segments_of(command).some((segment) => fetches_issue_comments(segment));
 }
-var ISSUE_COMMENTS_REASON = "\u26D4 issue comments: pnpm josh issue:read <N>\nRun that in place of this read \u2014 an Issue's comments are part of it, and a later comment supersedes the body it contradicts; refused until that command is on the transcript. Without josh, read `gh api repos/{owner}/{repo}/issues/<N>/comments` beside the body (`.claude/skills/workflow-commands/issue-comments.md`).";
-var ROW5 = {
+var RULE_DOC = "`.claude/skills/workflow-commands/issue-comments.md`";
+var COMMENTS_FALLBACK = "gh api repos/{owner}/{repo}/issues/<N>/comments";
+var ISSUE_COMMENTS_REASON = `\u26D4 issue comments: pnpm josh issue:read <N>
+Run that in place of this read \u2014 an Issue's comments are part of it, and a later comment supersedes the body it contradicts; refused until that command is on the transcript. Without josh, read \`${COMMENTS_FALLBACK}\` beside the body (${RULE_DOC}).`;
+var COMMENTS_JQ = String.raw`'.[] | "— \(.user.login) \(.created_at)\n\(.body)\n"'`;
+var COMMENTS_NOTE = `\u21BB issue comments: this read returned only the Issue's body, so the Issue's comments were fetched on the same line \u2014 a later comment supersedes the body it contradicts (${RULE_DOC}).`;
+function rewritable_path(command) {
+  const read2 = shell_segments.first_of(command);
+  if (read2 === void 0 || ISSUE_VIEW_COMMAND.test(read2)) return void 0;
+  return is_body_read_segment(read2) ? ISSUE_BODY_PATH.exec(read2)?.[0] : void 0;
+}
+function comments_command(command) {
+  if (!is_body_only_issue_read(command)) return void 0;
+  const path13 = rewritable_path(command);
+  if (path13 === void 0) return void 0;
+  return `gh api --paginate ${path13}/comments --jq ${COMMENTS_JQ}
+${command}`;
+}
+function comments_input(call, tail) {
+  if (call.name !== cost_blocks.BASH_TOOL || !json_value.is_record(call.input)) return void 0;
+  const command = comments_command(time_shell.bash_command(call.input));
+  if (command === void 0 || prior_comment_read.already_read_for_call(tail(), call)) {
+    return void 0;
+  }
+  return { ...call.input, command };
+}
+var ROW6 = {
   id: "issue-comments",
   is_trigger: bash_triggers.on_bash_command(is_body_only_issue_read),
   reason: ISSUE_COMMENTS_REASON,
   already_satisfied: prior_comment_read.already_read_for_call,
   keeps: bash_triggers.on_bash_command(reads_issue_comments),
+  rewrite: comments_input,
+  rewrite_note: COMMENTS_NOTE,
   // The opening the reason carried before it led with the command.
   former_reasons: ["\u26D4 an Issue's comments are part of the Issue: read them before implementing"]
 };
 var issue_comments = {
+  COMMENTS_NOTE,
   ISSUE_COMMENTS_REASON,
-  ROW: ROW5,
+  ROW: ROW6,
+  comments_input,
   is_body_only_issue_read
 };
 
@@ -1845,7 +1543,7 @@ function is_bare_josh_git(command) {
   return shell_segments.segments_of(command).some((segment) => is_bare_segment(segment));
 }
 var JOSH_GIT_BARE_REASON = '\u26D4 bare `pnpm josh git`: this prompts to confirm the staging, and with no TTY the prompt falls to its cancel branch. Run `pnpm josh git -y "<title> #<N>"`, or `pnpm josh git -y --skip-commit --skip-push` to open the PR for a push that already landed. It fires on every occurrence.';
-var ROW6 = {
+var ROW7 = {
   id: "josh-git-bare",
   is_trigger: bash_triggers.on_bash_command(is_bare_josh_git),
   reason: JOSH_GIT_BARE_REASON,
@@ -1853,7 +1551,7 @@ var ROW6 = {
 };
 var josh_git_bare = {
   JOSH_GIT_BARE_REASON,
-  ROW: ROW6,
+  ROW: ROW7,
   is_bare_josh_git
 };
 
@@ -1878,7 +1576,7 @@ function is_carry_conflict(command, is_lane_child = lane_child_marker.is_child_o
   return is_lane_child;
 }
 var LANE_CARRY_CONFLICT_REASON = "\u26D4 lane child carry conflict: this session is a dispatched lane child, and `run:merge` / `run:carry` are the parent budget commands; the live record belongs to the parent, not to a competing run. Continue implementing this Issue: no `needs-decision`, no Telegram. Live `run:carry` evidence takes a fresh `JOSH_TEMP_ROOT`; `run:merge` is refused under any root, on every occurrence.";
-var ROW7 = {
+var ROW8 = {
   id: "lane-carry-conflict",
   is_trigger: bash_triggers.on_bash_command(is_carry_conflict),
   reason: LANE_CARRY_CONFLICT_REASON,
@@ -1886,66 +1584,24 @@ var ROW7 = {
 };
 var lane_carry_conflict = {
   LANE_CARRY_CONFLICT_REASON,
-  ROW: ROW7,
+  ROW: ROW8,
   invokes_budget_command,
   is_carry_conflict
 };
 
-// scripts/agent/interactive-ask.ts
-import { z as z7 } from "zod";
-var INTERACTIVE_TOOLS = /* @__PURE__ */ new Set(["AskUserQuestion"]);
-function is_interactive_tool(name) {
-  return INTERACTIVE_TOOLS.has(name);
-}
-var OPTION_SCHEMA = z7.looseObject({ label: z7.string().optional() });
-var QUESTION_SCHEMA = z7.looseObject({
-  question: z7.string().optional(),
-  options: z7.array(OPTION_SCHEMA).optional()
-});
-var ASK_INPUT_SCHEMA = z7.looseObject({ questions: z7.array(QUESTION_SCHEMA).optional() });
-var DENIAL_SCHEMA = z7.looseObject({
-  tool_name: z7.string().optional(),
-  tool_input: z7.unknown().optional()
-});
-var UNKNOWN_QUESTION = "(question text unavailable)";
-var OPTION_SEPARATOR = " / ";
-var QUESTION_SEPARATOR = "; ";
-function labels_of(question) {
-  return (question.options ?? []).map((option) => option.label ?? "").filter((label) => label !== "");
-}
-function render_question(question) {
-  const labels = labels_of(question);
-  const text = question.question ?? UNKNOWN_QUESTION;
-  return labels.length === 0 ? text : `${text} [${labels.join(OPTION_SEPARATOR)}]`;
-}
-function interactive_input(raw) {
-  const denial = DENIAL_SCHEMA.safeParse(raw);
-  if (!denial.success || !is_interactive_tool(denial.data.tool_name ?? "")) return void 0;
-  const input = ASK_INPUT_SCHEMA.safeParse(denial.data.tool_input);
-  return input.success ? input.data : void 0;
-}
-function refused_ask_of(permission_denials) {
-  if (!Array.isArray(permission_denials)) return void 0;
-  const input = permission_denials.map((raw) => interactive_input(raw)).find((one) => one !== void 0);
-  const questions = input?.questions ?? [];
-  if (questions.length === 0) return void 0;
-  return questions.map((question) => render_question(question)).join(QUESTION_SEPARATOR);
-}
-var interactive_ask = { is_interactive_tool, refused_ask_of };
-
 // scripts/rules/lane-interactive-ask.ts
 function is_interactive_ask(call, is_lane_child = lane_child_marker.is_child_of(process.cwd())) {
   if (!interactive_ask.is_interactive_tool(call.name)) return false;
   return is_lane_child;
 }
 var LANE_INTERACTIVE_ASK_REASON = "\u26D4 lane child interactive ask: this session is a dispatched lane child and cannot ask a person, so park instead: `gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=needs-decision'`, `pnpm josh issue:comment <N> --body-file <path>`, the `confirmation` Telegram, stop. It fires on every occurrence (`.claude/skills/workflow-commands/pre-gate-cut.md`, `backlogrun-park.md`).";
-var ROW8 = {
+var ROW9 = {
   id: "lane-interactive-ask",
   is_trigger: is_interactive_ask,
   reason: LANE_INTERACTIVE_ASK_REASON,
   decide: () => true
 };
-var lane_interactive_ask = { LANE_INTERACTIVE_ASK_REASON, ROW: ROW8, is_interactive_ask };
+var lane_interactive_ask = { LANE_INTERACTIVE_ASK_REASON, ROW: ROW9, is_interactive_ask };
 
 // scripts/rules/lane-split-park.ts
 var EPIC_COMMANDS = /* @__PURE__ */ new Set(["epic"]);
@@ -1989,13 +1645,13 @@ function is_candidate(command) {
   if (!is_park_of(command, issue) && !is_notify_of(command, issue)) return false;
   return lane_child_marker.is_child_of(process.cwd());
 }
-function decide3(_call, run2) {
+function decide3(_call, run) {
   const issue = lane_child_marker.marked_issue();
-  const commands = tail_commands.prior_bash_commands(time_density_hook.read_tail(run2.transcript));
+  const commands = tail_commands.prior_bash_commands(time_density_hook.read_tail(run.transcript));
   return issue !== void 0 && promoted_issues(commands).has(issue);
 }
 var LANE_SPLIT_PARK_REASON = '\u26D4 lane split park: this session is a dispatched lane child that promoted its own Issue to an epic this run, and a split is not a park: no `needs-decision` on the epic, no `confirmation` Telegram, on every occurrence. Park a child issue if the rest needs a person, else end the turn (`.claude/skills/workflow-commands/backlogrun-park.md` \u2192 "Splitting a child mid-run").';
-var ROW9 = {
+var ROW10 = {
   id: "lane-split-park",
   is_trigger: bash_triggers.on_bash_command(is_candidate),
   reason: LANE_SPLIT_PARK_REASON,
@@ -2003,7 +1659,7 @@ var ROW9 = {
 };
 var lane_split_park = {
   LANE_SPLIT_PARK_REASON,
-  ROW: ROW9,
+  ROW: ROW10,
   promoted_issues
 };
 
@@ -2037,7 +1693,7 @@ function is_switch_away_from_lane(command, is_lane_child = lane_child_marker.is_
   return switch_targets(command).some((target) => target !== own_branch);
 }
 var LANE_SWITCH_MAIN_REASON = "\u26D4 lane child on `git switch main`: this session is a dispatched lane child, and switching to the default branch here always fails (`already used by worktree`: the primary checkout holds it). Skip this step and keep implementing on the current branch; `pnpm josh main:merge` brings the default in during the gate. Refused on every occurrence (`backlogrun-lanes.md`, `backlogrun-child.md`).";
-var ROW10 = {
+var ROW11 = {
   id: "lane-switch-main",
   is_trigger: bash_triggers.on_bash_command(is_switch_away_from_lane),
   reason: LANE_SWITCH_MAIN_REASON,
@@ -2045,7 +1701,7 @@ var ROW10 = {
 };
 var lane_switch_main = {
   LANE_SWITCH_MAIN_REASON,
-  ROW: ROW10,
+  ROW: ROW11,
   is_switch_away_from_lane,
   switch_target,
   switch_targets
@@ -2615,7 +2271,7 @@ function is_destructive_command(command) {
   return shell_segments.segments_of(command).some((segment) => is_destructive_segment2(segment));
 }
 var DESTRUCTIVE_COMMAND_REASON = "\u26D4 destructive command: a recursive forced `rm`, a `gh repo delete` / `archive` / visibility edit, `gh pr close` or a `gh api -X DELETE` cannot be undone, which is Tier C. Remove one path at a time without `-f`, or ask the user to run it. It fires on every occurrence (`prompts/collaboration-workflow/operating-rules.md`).";
-var ROW11 = {
+var ROW12 = {
   id: "destructive-command",
   is_trigger: bash_triggers.on_bash_command(is_destructive_command),
   reason: DESTRUCTIVE_COMMAND_REASON,
@@ -2623,7 +2279,7 @@ var ROW11 = {
   // The opening the reason carried before it was cut to the action and the next command.
   former_reasons: ["\u26D4 destructive command: a recursive forced `rm` (`rm -rf`"]
 };
-var destructive_command = { DESTRUCTIVE_COMMAND_REASON, ROW: ROW11, is_destructive_command };
+var destructive_command = { DESTRUCTIVE_COMMAND_REASON, ROW: ROW12, is_destructive_command };
 
 // scripts/rules/direct-pr-create.ts
 var GH_COMMAND2 = "gh";
@@ -2678,13 +2334,13 @@ function is_direct_pr_create(command) {
   return shell_segments.segments_of(command).some((segment) => is_pr_create_segment(segment));
 }
 var DIRECT_PR_CREATE_REASON = "\u26D4 direct PR creation: `gh pr create` (or a `gh api` POST to `repos/<o>/<r>/pulls`) bypasses `build_body`, which writes the `closes #N` line \u2014 the Issue would stay open after the merge (`CLAUDE.md` \u2192 Git Rules). Open the PR with `pnpm josh pr` instead; after a failed push, fix, push, then run `pnpm josh pr`. **This rule fires on every occurrence, not once per run.**";
-var ROW12 = {
+var ROW13 = {
   id: "direct-pr-create",
   is_trigger: bash_triggers.on_bash_command(is_direct_pr_create),
   reason: DIRECT_PR_CREATE_REASON,
   decide: () => true
 };
-var direct_pr_create = { DIRECT_PR_CREATE_REASON, ROW: ROW12, is_direct_pr_create };
+var direct_pr_create = { DIRECT_PR_CREATE_REASON, ROW: ROW13, is_direct_pr_create };
 
 // scripts/rules/worktree-guard.ts
 var CHECKOUT_SUBCOMMAND = "checkout";
@@ -2746,14 +2402,14 @@ function is_unauthorized_worktree_change(command) {
   return shell_segments.segments_of(command).some((segment) => is_unauthorized_segment(segment));
 }
 var WORKTREE_MUTATION_REASON = '\u26D4 unauthorized working-tree change: `git checkout --`, `git restore`, `git clean -f`, `git stash`. A documented flow stashes with `git stash push -u -m "<message>"`; a handed-over stash is `pnpm josh stash:pop "<message>"`; record the substitution on the Issue (Tier A) unless the plan says why the owner keeps the stash: then stop and confirm. It fires on every occurrence (`operating-rules.md`).';
-var ROW13 = {
+var ROW14 = {
   id: "worktree-mutation",
   is_trigger: bash_triggers.on_bash_command(is_unauthorized_worktree_change),
   reason: WORKTREE_MUTATION_REASON,
   decide: () => true
 };
 var worktree_guard = {
-  ROW: ROW13,
+  ROW: ROW14,
   WORKTREE_MUTATION_REASON,
   is_unauthorized_worktree_change,
   touches_worktree
@@ -2782,45 +2438,45 @@ function is_index_mutation(command) {
   return shell_segments.segments_of(command).some((segment) => is_index_segment(segment));
 }
 var INDEX_MUTATION_REASON = "\u26D4 git index mutation: `git add` / `stage` / `commit` / `reset` / `rm` / `mv` and `git restore --staged` overwrite the user's staged snapshot. Commit with `pnpm josh git -y`; any other staging is the user's, on explicit instruction. It fires on every occurrence (`prompts/collaboration-workflow/operating-rules.md` \u2192 \"no-self-staging\").";
-var ROW14 = {
+var ROW15 = {
   id: "index-mutation",
   is_trigger: bash_triggers.on_bash_command(is_index_mutation),
   reason: INDEX_MUTATION_REASON,
   decide: () => true
 };
-var index_guard = { INDEX_MUTATION_REASON, ROW: ROW14, is_index_mutation };
+var index_guard = { INDEX_MUTATION_REASON, ROW: ROW15, is_index_mutation };
 
 // scripts/rules/protected-files.ts
-import path5 from "node:path";
+import path3 from "node:path";
 
 // scripts/doctor/doctor-consumer.ts
 import { existsSync as existsSync2 } from "node:fs";
-import path4 from "node:path";
+import path2 from "node:path";
 
 // scripts/version/kit-descriptor.ts
 var KIT_PACKAGE_NAME = "@joshuafolkken/kit";
 
 // scripts/doctor/doctor-consumer.ts
-import { z as z8 } from "zod";
+import { z as z6 } from "zod";
 var NODE_MODULES = "node_modules";
-var SETTINGS_PATH = path4.join(".claude", "settings.json");
+var SETTINGS_PATH = path2.join(".claude", "settings.json");
 var CLAUDE_MD = "CLAUDE.md";
 var PLUGIN_ID = "kit@kit";
 var CLAUDE_MD_POINTER = `@${NODE_MODULES}/${KIT_PACKAGE_NAME}/dist/${CLAUDE_MD}`;
-var SECRETLINT_BIN = path4.join(NODE_MODULES, ".bin", "secretlint");
-var manifest_schema = z8.object({
-  name: z8.string().optional(),
-  dependencies: z8.record(z8.string(), z8.string()).optional(),
-  devDependencies: z8.record(z8.string(), z8.string()).optional()
+var SECRETLINT_BIN = path2.join(NODE_MODULES, ".bin", "secretlint");
+var manifest_schema = z6.object({
+  name: z6.string().optional(),
+  dependencies: z6.record(z6.string(), z6.string()).optional(),
+  devDependencies: z6.record(z6.string(), z6.string()).optional()
 });
-var settings_schema = z8.object({
-  enabledPlugins: z8.record(z8.string(), z8.boolean()).optional()
+var settings_schema = z6.object({
+  enabledPlugins: z6.record(z6.string(), z6.boolean()).optional()
 });
 var STATE_OK = "ok";
 var STATE_TARGET_MISSING = "target-missing";
 var STATE_MISSING = "missing";
 function parse_manifest(root) {
-  const content = file_reader.read_if_readable(path4.join(root, "package.json"));
+  const content = file_reader.read_if_readable(path2.join(root, "package.json"));
   if (content === void 0) return void 0;
   const parsed = manifest_schema.safeParse(json_value.parse_or_undefined(content));
   return parsed.success ? parsed.data : void 0;
@@ -2832,10 +2488,10 @@ function lists_kit_dependency(manifest) {
 function is_kit_consumer(root) {
   const manifest = parse_manifest(root);
   if (manifest?.name === KIT_PACKAGE_NAME) return false;
-  return lists_kit_dependency(manifest) || existsSync2(path4.join(root, NODE_MODULES, KIT_PACKAGE_NAME));
+  return lists_kit_dependency(manifest) || existsSync2(path2.join(root, NODE_MODULES, KIT_PACKAGE_NAME));
 }
 function is_plugin_declared(root) {
-  const content = file_reader.read_if_readable(path4.join(root, SETTINGS_PATH));
+  const content = file_reader.read_if_readable(path2.join(root, SETTINGS_PATH));
   if (content === void 0) return false;
   const parsed = settings_schema.safeParse(json_value.parse_or_undefined(content));
   return parsed.success && parsed.data.enabledPlugins?.[PLUGIN_ID] === true;
@@ -2847,13 +2503,13 @@ function configured_hooks_path(root) {
   return value === "" ? void 0 : value;
 }
 function claude_md_state(root) {
-  const content = file_reader.read_if_readable(path4.join(root, CLAUDE_MD));
+  const content = file_reader.read_if_readable(path2.join(root, CLAUDE_MD));
   if (content === void 0) return STATE_MISSING;
   if (!content.includes(CLAUDE_MD_POINTER)) return STATE_OK;
-  return existsSync2(path4.join(root, NODE_MODULES, KIT_PACKAGE_NAME, "dist", CLAUDE_MD)) ? STATE_OK : STATE_TARGET_MISSING;
+  return existsSync2(path2.join(root, NODE_MODULES, KIT_PACKAGE_NAME, "dist", CLAUDE_MD)) ? STATE_OK : STATE_TARGET_MISSING;
 }
 function is_secretlint_runnable(root) {
-  return existsSync2(path4.join(root, SECRETLINT_BIN));
+  return existsSync2(path2.join(root, SECRETLINT_BIN));
 }
 function status_line(is_ok, ok_text, warn_text) {
   return is_ok ? `  \u2713 ${ok_text}` : `  \u26A0 ${warn_text}`;
@@ -2919,7 +2575,7 @@ var EDIT_TOOLS2 = /* @__PURE__ */ new Set(["Edit", "Write"]);
 var SECRET_FILES = /* @__PURE__ */ new Set([".env", ".dev.vars"]);
 var ENVIRONMENT_VARIANT_PREFIX = ".env.";
 var TRACKED_VARIANTS = /* @__PURE__ */ new Set([".env.example", ".env.test"]);
-var SETTINGS_FILE = path5.join(".claude", "settings.json");
+var SETTINGS_FILE = path3.join(".claude", "settings.json");
 var WHITESPACE3 = /\s+/u;
 var TOKEN_QUOTES = /["']/gu;
 var INPUT_REDIRECT = "<";
@@ -2949,7 +2605,7 @@ function file_path_of(call) {
   return typeof value === "string" ? value : "";
 }
 function is_environment_path(token) {
-  const name = path5.basename(token.replaceAll(TOKEN_QUOTES, ""));
+  const name = path3.basename(token.replaceAll(TOKEN_QUOTES, ""));
   if (TRACKED_VARIANTS.has(name)) return false;
   return SECRET_FILES.has(name) || name.startsWith(ENVIRONMENT_VARIANT_PREFIX);
 }
@@ -2970,15 +2626,15 @@ function is_environment_read(call) {
 }
 function is_consumer_settings_edit(call, is_kit_consumer2) {
   if (!EDIT_TOOLS2.has(call.name)) return false;
-  const file_path = path5.resolve(file_path_of(call));
-  if (!file_path.endsWith(`${path5.sep}${SETTINGS_FILE}`)) return false;
-  return is_kit_consumer2(path5.dirname(path5.dirname(file_path)));
+  const file_path = path3.resolve(file_path_of(call));
+  if (!file_path.endsWith(`${path3.sep}${SETTINGS_FILE}`)) return false;
+  return is_kit_consumer2(path3.dirname(path3.dirname(file_path)));
 }
 function is_protected_file_call(call, is_kit_consumer2 = doctor_consumer.is_kit_consumer) {
   return is_environment_read(call) || is_consumer_settings_edit(call, is_kit_consumer2);
 }
 var PROTECTED_FILE_REASON = "\u26D4 protected file: `.env`, a `.env.*` variant and `.dev.vars` hold secrets, and a consumer `.claude/settings.json` is owned by `josh sync` (a change belongs upstream in kit). Leave these files alone, or ask the user. It fires on every occurrence.";
-var ROW15 = {
+var ROW16 = {
   id: "protected-file",
   is_trigger: is_protected_file_call,
   reason: PROTECTED_FILE_REASON,
@@ -2986,7 +2642,7 @@ var ROW15 = {
   // The opening the reason carried before it was cut to the action and the next command.
   former_reasons: ["\u26D4 protected file: `.env` holds the Telegram bot token"]
 };
-var protected_files = { ROW: ROW15, is_protected_file_call };
+var protected_files = { ROW: ROW16, is_protected_file_call };
 
 // scripts/rules/permission-guards.ts
 var ROWS2 = [
@@ -3037,7 +2693,7 @@ function keeps_verdict_intact(command) {
 var PIPEFAIL_OPEN = "(set -o pipefail; ";
 var PIPEFAIL_CLOSE = ")";
 var COMMENT_START = /(?:^|\s)#/u;
-var FULL_READING_FILTER = /^(?:tail|grep)\b/u;
+var FULL_READING_FILTER = /^(?:tail|grep|cut|sort|uniq|wc)\b/u;
 var EARLY_EXIT_GREP = /^grep\b.*\s(?:-[a-zA-Z]*[lLmq]|--(?:quiet|silent|max-count|files-with(?:out)?-match))/u;
 var ALLOWED_OPERATORS = /2>&1|&&/gu;
 var SIDE_EFFECT_SYNTAX = /[&<>`]|\$\(/u;
@@ -3124,7 +2780,7 @@ function is_poll_loop(command) {
   return LOOP_KEYWORD2.test(plain) && SLEEP_COMMAND.test(plain);
 }
 var POLL_LOOP_REASON = "\u26D4 output poll loop: this hand-writes a `while`/`until` wait loop over a command's output, a marker file or a process, and the loop does not know when the command finished. Issue the long command with `run_in_background` set and end the turn \u2014 its exit re-invokes you; for CI, `pnpm josh followup` (`.claude/skills/workflow-commands/background-commands.md`). It fires on every occurrence.";
-var ROW16 = {
+var ROW17 = {
   id: "poll-loop",
   is_trigger: bash_triggers.on_bash_command(is_poll_loop),
   reason: POLL_LOOP_REASON,
@@ -3132,86 +2788,23 @@ var ROW16 = {
 };
 var poll_loop = {
   POLL_LOOP_REASON,
-  ROW: ROW16,
+  ROW: ROW17,
   is_poll_loop
 };
 
-// scripts/rules/pre-gate-cut.ts
-var GATE_COMMANDS = /* @__PURE__ */ new Set(["gate"]);
-var CUT_COMMANDS2 = /* @__PURE__ */ new Set(["run:cut"]);
-var CUT_MODE_FLAG = /(?:^|\s)--(?:resume|end|json)(?:[=\s]|$)/u;
-var HOLD_COMMANDS = /* @__PURE__ */ new Set(["run:hold"]);
-var HOLD_MODE_FLAG = /(?:^|\s)--release(?:[=\s]|$)/u;
-function invokes_josh(command, names, mode_flag) {
-  return shell_segments.segments_of(command).some(
-    (segment) => shell_segments.is_josh_command(segment, names) && mode_flag?.test(segment) !== true
-  );
-}
-function runs_the_gate(command) {
-  return invokes_josh(command, GATE_COMMANDS);
-}
-function takes_the_cut(command) {
-  return invokes_josh(command, CUT_COMMANDS2, CUT_MODE_FLAG);
-}
-function claims_the_hold(command) {
-  return invokes_josh(command, HOLD_COMMANDS, HOLD_MODE_FLAG);
-}
-function asks_about_the_cut(command) {
-  return invokes_josh(command, CUT_COMMANDS2);
-}
-function current_state2() {
-  return {
-    directory: process.cwd(),
-    carried: run_cut.carried_cut_sync,
-    marked_issue: lane_child_marker.marked_issue(),
-    is_reviewer: agent_session_role.is_reviewer(),
-    context_verdict: cost_cli.session_verdict
-  };
-}
-function dispatched_issue(state) {
-  return state.is_reviewer ? void 0 : state.marked_issue;
-}
-function uncut_lane_issue(state) {
-  const issue = lane_paths.lane_issue_of(state.directory);
-  if (issue === void 0 || dispatched_issue(state) !== issue) return void 0;
-  return state.carried()?.issue === issue ? void 0 : issue;
-}
-function warrants_the_cut2(verdict) {
-  return verdict !== cost_verdict.UNDER_VERDICT;
-}
-function is_uncut_gate(command, state = current_state2()) {
-  if (!runs_the_gate(command) || uncut_lane_issue(state) === void 0) return false;
-  return warrants_the_cut2(state.context_verdict());
-}
-var PRE_GATE_CUT_REASON = "\u26D4 pre-gate cut: this checkout is a lane dispatched for this issue and the gate is the boundary to cut at. Issue `pnpm josh run:cut <N>`: on `cut`, end the turn immediately \u2014 no Telegram is owed; on any other verdict (`not-a-lane`, `busy`, \u2026), reissue the gate \u2014 this fires once per run (`.claude/skills/workflow-commands/pre-gate-cut.md`).";
-function reaches_the_pre_gate_boundary(call, _turn, run2) {
-  if (!bash_triggers.on_bash_command(asks_about_the_cut)(call)) return false;
-  return run2.some((issued) => bash_triggers.on_bash_command(claims_the_hold)(issued));
-}
-var pre_gate_cut = {
-  PRE_GATE_CUT_REASON,
-  asks_about_the_cut,
-  claims_the_hold,
-  is_uncut_gate,
-  reaches_the_pre_gate_boundary,
-  runs_the_gate,
-  takes_the_cut,
-  uncut_lane_issue
-};
-
 // scripts/rules/raw-field-body.ts
 var RAW_FIELD_BODY_AT = /(?:^|\s)(?:-f|--raw-field)[\s=]+['"]?body=['"]?@/u;
 function posts_at_path_literally(command) {
   return RAW_FIELD_BODY_AT.test(command);
 }
 var RAW_FIELD_BODY_REASON = "\u26D4 literal @path body: this passes `body=@<path>` to `gh api` with a raw field flag (`-f` / `--raw-field`), which posts the string `@<path>` rather than the file. Post the comment with `pnpm josh issue:comment <N> --body-file <path>`; this rule fires on every occurrence (`prompts/collaboration-workflow/shell-body.md`).";
-var ROW17 = {
+var ROW18 = {
   id: "raw-field-body",
   is_trigger: bash_triggers.on_bash_command(posts_at_path_literally),
   reason: RAW_FIELD_BODY_REASON,
   decide: () => true
 };
-var raw_field_body = { RAW_FIELD_BODY_REASON, ROW: ROW17, posts_at_path_literally };
+var raw_field_body = { RAW_FIELD_BODY_REASON, ROW: ROW18, posts_at_path_literally };
 
 // scripts/rules/rule-body-guard.ts
 var EDIT_TOOL = "Edit";
@@ -3238,10 +2831,10 @@ function string_field2(input, key) {
 function read_existing(file_path) {
   return file_reader.read_file_or_empty(file_path);
 }
-function texts_of(name, input, read3) {
+function texts_of(name, input, read2) {
   if (name === WRITE_TOOL) {
     return {
-      old_text: read3(string_field2(input, "file_path")),
+      old_text: read2(string_field2(input, "file_path")),
       new_text: string_field2(input, "content")
     };
   }
@@ -3257,10 +2850,10 @@ function rule_document_input(call) {
   if (!is_edit_tool2(call.name) || !json_value.is_record(call.input)) return void 0;
   return is_rule_document(string_field2(call.input, "file_path")) ? call.input : void 0;
 }
-function writes_rule_prose(call, read3 = read_existing) {
+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, read3);
+  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`).";
@@ -3282,7 +2875,7 @@ function runs_placement_oracle(command) {
     (names) => shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, names))
   );
 }
-var ROW18 = {
+var ROW19 = {
   id: "rule-body",
   is_trigger: writes_rule_prose,
   reason: RULE_BODY_REASON,
@@ -3291,7 +2884,7 @@ var ROW18 = {
 };
 var rule_body_guard = {
   RULE_BODY_REASON,
-  ROW: ROW18,
+  ROW: ROW19,
   answered_placement,
   is_rule_document,
   writes_rule_prose
@@ -3368,12 +2961,12 @@ var shell_body_trigger = {
 };
 
 // scripts/gate/project-checks.ts
-import { existsSync as existsSync7, globSync as globSync2, readFileSync as readFileSync6 } from "node:fs";
-import path13 from "node:path";
+import { existsSync as existsSync7, globSync, readFileSync as readFileSync5 } from "node:fs";
+import path11 from "node:path";
 
 // scripts/init/own-formatter.ts
 import { existsSync as existsSync3 } from "node:fs";
-import path6 from "node:path";
+import path4 from "node:path";
 var OWN_FORMATTER_CONFIGS = [
   "biome.json",
   "biome.jsonc",
@@ -3383,18 +2976,18 @@ var OWN_FORMATTER_CONFIGS = [
   ".dprint.jsonc"
 ];
 function find_config(root) {
-  return OWN_FORMATTER_CONFIGS.find((name) => existsSync3(path6.join(root, name)));
+  return OWN_FORMATTER_CONFIGS.find((name) => existsSync3(path4.join(root, name)));
 }
 var own_formatter = { find_config };
 
 // scripts/init/project-profile.ts
-import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync5 } from "node:fs";
-import path12 from "node:path";
+import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync4 } from "node:fs";
+import path10 from "node:path";
 
 // scripts/safe-chain/pack-hook.ts
-import { z as z9 } from "zod";
+import { z as z7 } from "zod";
 var PACK_HOOK_FILE = ".pnpmfile.mjs";
-var manifest_schema2 = z9.looseObject({ private: z9.boolean().optional() });
+var manifest_schema2 = z7.looseObject({ private: z7.boolean().optional() });
 var MESSAGES = {
   written: `  \u2714 synced    ${PACK_HOOK_FILE} (run \`pnpm install\` to refresh pnpmfileChecksum)`,
   unchanged: `  \u2714 unchanged ${PACK_HOOK_FILE}`,
@@ -3430,15 +3023,15 @@ var yaml_document = { is_mapping_document, parse_yaml, parse_yaml_documents };
 
 // scripts/version/release-age.ts
 import semver from "semver";
-import { z as z10 } from "zod";
-var workspace_age_schema = z10.object({ minimumReleaseAge: z10.number().int().nonnegative() });
-var release_times_schema = z10.record(z10.string(), z10.string());
+import { z as z8 } from "zod";
+var workspace_age_schema = z8.object({ minimumReleaseAge: z8.number().int().nonnegative() });
+var release_times_schema = z8.record(z8.string(), z8.string());
 
 // scripts/safe-chain/project-config.ts
 import { dump } from "js-yaml";
-import { z as z11 } from "zod";
+import { z as z9 } from "zod";
 var PROJECT_CONFIG_FILE = ".aikido";
-var workspace_schema = z11.object({ minimumReleaseAgeExclude: z11.array(z11.string()).optional() });
+var workspace_schema = z9.object({ minimumReleaseAgeExclude: z9.array(z9.string()).optional() });
 
 // scripts/config-merge/json-format.ts
 var PRINT_WIDTH = 100;
@@ -3483,9 +3076,9 @@ function inline_short_arrays(text) {
   const output = [];
   let index = 0;
   while (index < lines.length) {
-    const rewrite = rewrite_at(lines, index, lines[index] ?? "");
-    output.push(...rewrite.lines);
-    index = rewrite.next;
+    const rewrite3 = rewrite_at(lines, index, lines[index] ?? "");
+    output.push(...rewrite3.lines);
+    index = rewrite3.next;
   }
   return output.join("\n");
 }
@@ -3520,86 +3113,6 @@ var safe_chain_preinstall = {
   migrate_preinstall
 };
 
-// scripts/init/distributed-paths.ts
-var KIT_PACKAGE_PATH_PREFIX = "node_modules/@joshuafolkken/kit/";
-var PROMPTS_PACKAGE_PREFIX = `${KIT_PACKAGE_PATH_PREFIX}prompts/`;
-var ESLINT_PACKAGE_PREFIX = `${KIT_PACKAGE_PATH_PREFIX}eslint/`;
-var GITHUB_REPO_BLOB_BASE = "https://github.com/joshuafolkken/kit/blob/main/";
-var GITHUB_REPO_TREE_BASE = "https://github.com/joshuafolkken/kit/tree/main/";
-var CLAUDE_MD_IMPORT_LINE = "@node_modules/@joshuafolkken/kit/dist/CLAUDE.md";
-var OLD_CLAUDE_MD_BOOTSTRAP = "> Fresh checkout: if kit is not installed, run `pnpm install` first, then reread this file before doing any other work.";
-var CLAUDE_MD_BOOTSTRAP = '> Fresh checkout: before `pnpm install`, run `pnpm config get "@joshuafolkken:registry"` from the project root to check the effective registry, including user-level settings. If it points to GitHub Packages, [set up authentication](https://github.com/joshuafolkken/kit/blob/main/docs/authentication.md#1-get-a-token-from-the-gh-cli) first. Then run `pnpm install` and reread this file before doing any other work.';
-function transform_prompt_paths(content) {
-  return content.replaceAll(
-    /`prompts\/([^`*]+)`/gu,
-    (_match, prompt_path) => `\`${PROMPTS_PACKAGE_PREFIX}${prompt_path}\``
-  );
-}
-function transform_eslint_paths(content) {
-  return content.replaceAll(
-    /`eslint\/([^`*]+)`/gu,
-    (_match, eslint_path) => `\`${ESLINT_PACKAGE_PREFIX}${eslint_path}\``
-  );
-}
-function transform_test_file_paths(content) {
-  return content.replaceAll(
-    /`([^`*]+\.(?:test|spec)\.ts)`/gu,
-    (_match, test_path) => `\`${GITHUB_REPO_BLOB_BASE}${test_path}\``
-  );
-}
-function github_url_base(reference_path) {
-  return reference_path.endsWith("/") ? GITHUB_REPO_TREE_BASE : GITHUB_REPO_BLOB_BASE;
-}
-function transform_documentation_paths(content) {
-  return content.replaceAll(
-    /`(docs\/[^`*]*)`/gu,
-    (_match, documentation_path) => `\`${github_url_base(documentation_path)}${documentation_path}\``
-  );
-}
-function transform_distributed_paths(content) {
-  const with_prompts = transform_prompt_paths(content);
-  const with_eslint = transform_eslint_paths(with_prompts);
-  const with_tests = transform_test_file_paths(with_eslint);
-  return transform_documentation_paths(with_tests);
-}
-function ensure_claude_md_import(existing) {
-  if (existing === void 0) return `${CLAUDE_MD_BOOTSTRAP}
-
-${CLAUDE_MD_IMPORT_LINE}
-`;
-  const updated = existing.replace(OLD_CLAUDE_MD_BOOTSTRAP, () => CLAUDE_MD_BOOTSTRAP);
-  if (updated.includes(CLAUDE_MD_IMPORT_LINE)) {
-    if (updated.includes(CLAUDE_MD_BOOTSTRAP)) return updated;
-    return `${CLAUDE_MD_BOOTSTRAP}
-
-${updated}`;
-  }
-  return `${CLAUDE_MD_BOOTSTRAP}
-
-${CLAUDE_MD_IMPORT_LINE}
-
-${updated}`;
-}
-var FULL_CLAUDE_MD_LINES = /* @__PURE__ */ new Set([
-  CLAUDE_MD_BOOTSTRAP,
-  OLD_CLAUDE_MD_BOOTSTRAP,
-  CLAUDE_MD_IMPORT_LINE
-]);
-function remove_claude_md_import(content) {
-  const lines = content.split("\n");
-  return lines.filter((line, index) => {
-    if (FULL_CLAUDE_MD_LINES.has(line)) return false;
-    return line !== "" || !FULL_CLAUDE_MD_LINES.has(lines[index - 1] ?? "");
-  }).join("\n");
-}
-var distributed_paths = {
-  transform_prompt_paths,
-  transform_distributed_paths,
-  ensure_claude_md_import,
-  remove_claude_md_import,
-  CLAUDE_MD_IMPORT_LINE
-};
-
 // scripts/init/init-logic-deploy-vps.ts
 import semver2 from "semver";
 var PNPM_INSTALL_PATTERN = /npm install -g pnpm@\d[\d.]{0,19}/gu;
@@ -3881,10 +3394,10 @@ function set_json_key(content, key, value) {
   const indented = fit_value(content, value_text, line_indent(content, existing.offset));
   return with_trailing_newline(replace_range(content, existing, indented));
 }
-function resolve_parent(content, path16) {
+function resolve_parent(content, path13) {
   const root = parse_root(content);
   if (root === void 0) return void 0;
-  const parent = path16.length > 1 ? findNodeAtLocation(root, path16.slice(0, -1)) : root;
+  const parent = path13.length > 1 ? findNodeAtLocation(root, path13.slice(0, -1)) : root;
   return parent?.type === "object" ? parent : void 0;
 }
 function cut_ranges(content, parent, ranges) {
@@ -3895,24 +3408,24 @@ function cut_ranges(content, parent, ranges) {
   }
   return next;
 }
-function rebalance_new_last(content, path16) {
-  const parent = resolve_parent(content, path16);
+function rebalance_new_last(content, path13) {
+  const parent = resolve_parent(content, path13);
   const last = parent?.children?.at(-1);
   if (parent === void 0 || last === void 0) return content;
   return rebalance(content, last, has_separator_after(content, parent.offset, parent.offset));
 }
-function cut_property(content, parent, path16) {
-  const index = property_index(parent, path16.at(-1) ?? "");
+function cut_property(content, parent, path13) {
+  const index = property_index(parent, path13.at(-1) ?? "");
   const ranges = removal_ranges(content, parent, index);
   if (ranges.length === 0) return content;
   const cut = cut_ranges(content, parent, ranges);
   const did_end_object = index === (parent.children ?? []).length - 1;
-  return did_end_object ? rebalance_new_last(cut, path16) : cut;
+  return did_end_object ? rebalance_new_last(cut, path13) : cut;
 }
-function remove_json_path(content, path16) {
-  const parent = resolve_parent(content, path16);
+function remove_json_path(content, path13) {
+  const parent = resolve_parent(content, path13);
   if (parent === void 0) return content;
-  const next = cut_property(content, parent, path16);
+  const next = cut_property(content, parent, path13);
   return next === content ? content : with_trailing_newline(next);
 }
 function remove_json_key(content, key) {
@@ -4143,13 +3656,13 @@ var kit_base_preset = {
 
 // scripts/init/tsconfig-preset-migration.ts
 import { existsSync as existsSync4 } from "node:fs";
-import path7 from "node:path";
+import path5 from "node:path";
 var LEGACY_PRESET_ENTRY = /@joshuafolkken\/[^/]+\/tsconfig\/[^/]+\.jsonc$/u;
 var LEGACY_SUFFIX = ".jsonc";
 var CURRENT_SUFFIX = ".json";
 var EXTENDS_FIELD = "extends";
 function is_migration_target_present(base_directory, entry) {
-  return existsSync4(path7.resolve(base_directory, entry));
+  return existsSync4(path5.resolve(base_directory, entry));
 }
 function migrate_entry(base_directory, entry) {
   if (!LEGACY_PRESET_ENTRY.test(entry)) return entry;
@@ -4381,15 +3894,15 @@ var init_logic_json_merge = {
 };
 
 // scripts/init/kit-development-versions.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-import { z as z12 } from "zod";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { z as z10 } from "zod";
 var PACKAGE_JSON = "package.json";
-var kit_manifest_schema = z12.object({
-  peerDependencies: z12.record(z12.string(), z12.string()).default({}),
-  devDependencies: z12.record(z12.string(), z12.string())
+var kit_manifest_schema = z10.object({
+  peerDependencies: z10.record(z10.string(), z10.string()).default({}),
+  devDependencies: z10.record(z10.string(), z10.string())
 });
 function read_kit_manifest() {
-  const content = readFileSync3(package_path(PACKAGE_JSON), "utf8");
+  const content = readFileSync2(package_path(PACKAGE_JSON), "utf8");
   return kit_manifest_schema.parse(JSON.parse(content));
 }
 function versions_of(names) {
@@ -4550,9 +4063,9 @@ function merge_sonar_properties(existing, template_content) {
     return key !== void 0 && !existing_keys.has(key);
   });
   if (lines_to_add.length === 0) return merged_existing;
-  const normalized2 = merged_existing.endsWith("\n") ? merged_existing : `${merged_existing}
+  const normalized = merged_existing.endsWith("\n") ? merged_existing : `${merged_existing}
 `;
-  return `${normalized2}
+  return `${normalized}
 ${lines_to_add.join("\n")}
 `;
 }
@@ -4565,8 +4078,8 @@ var init_logic_sonar = {
 };
 
 // scripts/init/init-logic-templates.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
-import path8 from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
+import path6 from "node:path";
 var ESLINT_VANILLA = `import { create_vanilla_config } from '@joshuafolkken/kit/eslint/vanilla'
 
 export default create_vanilla_config({
@@ -4651,7 +4164,7 @@ function merge_eslint_config(existing) {
   return apply_rules_template(rules_blocks.join(",\n"));
 }
 function detect_tailwind_stylesheet(project_root2) {
-  return existsSync5(path8.join(project_root2, DEFAULT_TAILWIND_STYLESHEET)) ? DEFAULT_TAILWIND_STYLESHEET : void 0;
+  return existsSync5(path6.join(project_root2, DEFAULT_TAILWIND_STYLESHEET)) ? DEFAULT_TAILWIND_STYLESHEET : void 0;
 }
 function generate_prettier_config(stylesheet) {
   const stylesheet_line = stylesheet === void 0 ? "" : `	tailwindStylesheet: '${stylesheet}',
@@ -4665,14 +4178,14 @@ ${stylesheet_line}}
 }
 function existing_stylesheet(existing, project_root2) {
   const named = TAILWIND_STYLESHEET_PATTERN.exec(existing)?.[1];
-  return named !== void 0 && existsSync5(path8.resolve(project_root2, named)) ? named : void 0;
+  return named !== void 0 && existsSync5(path6.resolve(project_root2, named)) ? named : void 0;
 }
 function merge_prettier_config(existing, project_root2) {
   const stylesheet = existing_stylesheet(existing, project_root2) ?? detect_tailwind_stylesheet(project_root2);
   return generate_prettier_config(stylesheet);
 }
 function generate_playwright_config() {
-  return readFileSync4(PLAYWRIGHT_TEMPLATE_PATH, "utf8");
+  return readFileSync3(PLAYWRIGHT_TEMPLATE_PATH, "utf8");
 }
 var init_logic_templates = {
   generate_eslint_config,
@@ -4744,9 +4257,9 @@ function extract_yaml_block(content, key) {
 }
 function append_user_blocks(base, user_keys, existing) {
   const user_blocks = user_keys.map((k) => extract_yaml_block(existing, k)).filter(Boolean).join("\n");
-  const normalized2 = base.endsWith("\n") ? base : `${base}
+  const normalized = base.endsWith("\n") ? base : `${base}
 `;
-  return `${normalized2}
+  return `${normalized}
 ${user_blocks}
 `;
 }
@@ -4839,9 +4352,9 @@ function carry_npmrc_settings(template, npmrc) {
 }
 function merge_workspace_yaml(existing, template) {
   if (!existing.trim()) return template;
-  const normalized2 = existing.endsWith("\n") ? existing : `${existing}
+  const normalized = existing.endsWith("\n") ? existing : `${existing}
 `;
-  const answered = answer_build_placeholders(remove_deprecated_yaml_keys(normalized2), template);
+  const answered = answer_build_placeholders(remove_deprecated_yaml_keys(normalized), template);
   const cleaned = add_missing_build_entries(answered, template);
   if (!cleaned.trim()) return template;
   const existing_keys = new Set(extract_yaml_top_level_keys(cleaned));
@@ -5180,23 +4693,23 @@ var AI_COPY_DIRECTORIES_LIST = "AI_COPY_DIRECTORIES";
 var SYNCED_PATHS_LIST = "SYNCED_PATHS";
 var PLUGIN_SKILL_DIRECTORIES_LIST = "PLUGIN_SKILL_DIRECTORIES";
 var PATH_SEPARATOR = "/";
-function is_inside(path16, directory) {
-  return path16 === directory || path16.startsWith(`${directory}${PATH_SEPARATOR}`);
+function is_inside(path13, directory) {
+  return path13 === directory || path13.startsWith(`${directory}${PATH_SEPARATOR}`);
 }
-function matches_file(path16) {
-  return init_logic.get_ai_copy_files().includes(path16);
+function matches_file(path13) {
+  return init_logic.get_ai_copy_files().includes(path13);
 }
-function matches_mapping(path16) {
-  return init_logic.get_ai_copy_file_mappings().some((mapping) => mapping.src === path16 || mapping.dest === path16);
+function matches_mapping(path13) {
+  return init_logic.get_ai_copy_file_mappings().some((mapping) => mapping.src === path13 || mapping.dest === path13);
 }
-function matches_directory(path16) {
-  return init_logic.get_ai_copy_directories().some((directory) => is_inside(path16, directory));
+function matches_directory(path13) {
+  return init_logic.get_ai_copy_directories().some((directory) => is_inside(path13, directory));
 }
-function matches_plugin_skill(path16) {
-  return PLUGIN_SKILL_DIRECTORIES.some((directory) => is_inside(path16, directory));
+function matches_plugin_skill(path13) {
+  return PLUGIN_SKILL_DIRECTORIES.some((directory) => is_inside(path13, directory));
 }
-function matches_synced_path(path16) {
-  return synced_paths.get_synced_paths().includes(path16);
+function matches_synced_path(path13) {
+  return synced_paths.get_synced_paths().includes(path13);
 }
 var MATCHERS = [
   { list: AI_COPY_FILES_LIST, matches: matches_file },
@@ -5205,18 +4718,18 @@ var MATCHERS = [
   { list: PLUGIN_SKILL_DIRECTORIES_LIST, matches: matches_plugin_skill },
   { list: SYNCED_PATHS_LIST, matches: matches_synced_path }
 ];
-function find_list(path16) {
-  return MATCHERS.find((matcher) => matcher.matches(path16))?.list;
+function find_list(path13) {
+  return MATCHERS.find((matcher) => matcher.matches(path13))?.list;
 }
-function to_hit(path16) {
-  const list = find_list(path16);
-  return list === void 0 ? void 0 : { path: path16, list };
+function to_hit(path13) {
+  const list = find_list(path13);
+  return list === void 0 ? void 0 : { path: path13, list };
 }
 function find_managed_paths(paths) {
-  return paths.flatMap((path16) => to_hit(path16) ?? []);
+  return paths.flatMap((path13) => to_hit(path13) ?? []);
 }
 function has_managed_path(paths) {
-  return paths.some((path16) => find_list(path16) !== void 0);
+  return paths.some((path13) => find_list(path13) !== void 0);
 }
 function format_hit(hit) {
   return `${hit.path} (${hit.list})`;
@@ -5232,8 +4745,8 @@ var managed_config_scope = {
 };
 
 // scripts/init/session-language-environment.ts
-import path9 from "node:path";
-var CLAUDE_SETTINGS_PATH = path9.join(".claude", "settings.json");
+import path7 from "node:path";
+var CLAUDE_SETTINGS_PATH = path7.join(".claude", "settings.json");
 var KEY_LINE_PATTERN = new RegExp(
   String.raw`^\s*(?:export\s+)?${session_language.ENV_KEY}\s*=`,
   "mu"
@@ -5243,8 +4756,8 @@ var KEY_LINE_PATTERN = new RegExp(
 import { findNodeAtLocation as findNodeAtLocation2, getNodeValue as getNodeValue2, parseTree as parseTree3 } from "jsonc-parser";
 
 // scripts/init/vscode-tasks.ts
-import { z as z13 } from "zod";
-var task_array_schema = z13.array(json_object_schema);
+import { z as z11 } from "zod";
+var task_array_schema = z11.array(json_object_schema);
 
 // scripts/init/init-actions.ts
 var BASIC_PRETTIER_CONFIG = "prettier.config.mjs";
@@ -5254,11 +4767,11 @@ var MARKER_TOKEN = "josh-managed-workflow:";
 var MARKER_PREFIX = `# ${MARKER_TOKEN}`;
 
 // scripts/init/claude-plugin-config.ts
-import path10 from "node:path";
+import path8 from "node:path";
 var MARKETPLACE_NAME = "kit";
 var PLUGIN_ID2 = "kit@kit";
 var MARKETPLACE_PATH = "./node_modules/@joshuafolkken/kit";
-var CLAUDE_SETTINGS_DESTINATION = path10.join(".claude", "settings.json");
+var CLAUDE_SETTINGS_DESTINATION = path8.join(".claude", "settings.json");
 var PLUGIN_SETTINGS = {
   extraKnownMarketplaces: {
     [MARKETPLACE_NAME]: { source: { source: "directory", path: MARKETPLACE_PATH } }
@@ -5282,9 +4795,9 @@ var claude_plugin_config = {
 // scripts/init/hook-launch.ts
 var HOOK_DIST_DIR = "dist/hooks";
 var RUN_HOOK_SCRIPT = "scripts/hooks/run-hook.sh";
-var UNSET_OPTIONS = GIT_LOCATION_VARIABLES.map((name) => `-u ${name}`).join(" ");
+var LOCATION_VARIABLES = GIT_LOCATION_VARIABLES.join(" ");
 var ROOT_LOOKUP = "git rev-parse --show-toplevel";
-var PROJECT_ROOT_PREFIX = `project_root="$(env ${UNSET_OPTIONS} ${ROOT_LOOKUP} 2>/dev/null || ${ROOT_LOOKUP})" && cd "$project_root" && `;
+var PROJECT_ROOT_PREFIX = `if project_root="$(unset ${LOCATION_VARIABLES}; ${ROOT_LOOKUP} 2>/dev/null)"; then unset ${LOCATION_VARIABLES}; else project_root="$(${ROOT_LOOKUP})"; fi && cd "$project_root" && `;
 function hook_launch_command(name) {
   return `${PROJECT_ROOT_PREFIX}sh ${RUN_HOOK_SCRIPT} ${name}`;
 }
@@ -5320,7 +4833,7 @@ var PLAIN_KIT_COMMANDS = new Set(
 var PROJECT_ROOT_PREFIX2 = JSON.stringify(hook_launch.PROJECT_ROOT_PREFIX).slice(1, -1);
 
 // scripts/init/security-policy.ts
-import path11 from "node:path";
+import path9 from "node:path";
 var SECURITY_MD = "SECURITY.md";
 var SECURITY_TEMPLATE = "templates/SECURITY.md";
 var REPOSITORY_PLACEHOLDER = "{{REPOSITORY}}";
@@ -5336,15 +4849,15 @@ function apply_repository(content, repository) {
   return content.replaceAll(REPOSITORY_PLACEHOLDER, () => repository);
 }
 function apply_repository_for_destination(destination_path, content) {
-  if (path11.basename(destination_path) !== SECURITY_MD) return content;
-  const repository = repository_at(path11.dirname(destination_path));
+  if (path9.basename(destination_path) !== SECURITY_MD) return content;
+  const repository = repository_at(path9.dirname(destination_path));
   if (repository === void 0) {
     throw new Error(`${SECURITY_MD} needs a GitHub origin to name the repository it reports to`);
   }
   return apply_repository(content, repository);
 }
 function does_report_to_kit(root) {
-  const existing = file_reader.read_if_readable(path11.join(root, SECURITY_MD)) ?? "";
+  const existing = file_reader.read_if_readable(path9.join(root, SECURITY_MD)) ?? "";
   return new Set(existing.split(LINK_DELIMITER)).has(KIT_ADVISORY_URL);
 }
 function unresolved_warning(root) {
@@ -5464,9 +4977,9 @@ function requested_profile(args, usage = "josh init [--profile basic|full]") {
   throw new Error("Profile must be basic or full");
 }
 function read_manifest(root) {
-  const filename = path12.join(root, "package.json");
+  const filename = path10.join(root, "package.json");
   if (!existsSync6(filename)) return void 0;
-  const parsed = JSON.parse(readFileSync5(filename, "utf8"));
+  const parsed = JSON.parse(readFileSync4(filename, "utf8"));
   if (!json_value.is_record(parsed)) throw new Error("package.json must contain an object");
   return parsed;
 }
@@ -5507,12 +5020,12 @@ function should_visit(entry) {
 function scan_directory(directory, pending) {
   const entries = readdirSync(directory, { withFileTypes: true });
   pending.push(
-    ...entries.filter((entry) => should_visit(entry)).map((entry) => path12.join(directory, entry.name))
+    ...entries.filter((entry) => should_visit(entry)).map((entry) => path10.join(directory, entry.name))
   );
-  return entries.filter((entry) => entry.isFile()).map((entry) => path12.join(directory, entry.name));
+  return entries.filter((entry) => entry.isFile()).map((entry) => path10.join(directory, entry.name));
 }
 function is_project_file(root, file) {
-  const relative_path = path12.relative(root, file).split(path12.sep).join(path12.posix.sep);
+  const relative_path = path10.relative(root, file).split(path10.sep).join(path10.posix.sep);
   return !kit_written_paths.is_kit_written(relative_path);
 }
 function list_files(root) {
@@ -5524,7 +5037,7 @@ function list_files(root) {
   return files;
 }
 function file_extensions(root) {
-  return list_files(root).filter((file) => is_project_file(root, file)).map((file) => path12.extname(file));
+  return list_files(root).filter((file) => is_project_file(root, file)).map((file) => path10.extname(file));
 }
 function scan_files(root) {
   const extensions = file_extensions(root);
@@ -5538,7 +5051,7 @@ function has_github_remote(root) {
   return url !== void 0 && repo_origin.parse_origin_url(url) !== void 0;
 }
 function has_git(root) {
-  return existsSync6(path12.join(root, ".git"));
+  return existsSync6(path10.join(root, ".git"));
 }
 function has_workflow(root) {
   return workflow_mark.is_requested() || workflow_mark.is_recorded(read_manifest(root));
@@ -5571,7 +5084,7 @@ var SKIP_MARKER = "\u2014 skipping";
 var NOT_USED_MARKER = "which this project does not use";
 
 // scripts/gate/project-checks.ts
-import { z as z14 } from "zod";
+import { z as z12 } from "zod";
 var PACKAGE_JSON2 = "package.json";
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -5606,11 +5119,11 @@ var CSPELL_CONFIGS = [
 ];
 var TYPE_CONFIGS = ["tsconfig.json", "jsconfig.json"];
 var DEPENDENCY_FIELDS = ["dependencies", "devDependencies"];
-var object_schema = z14.record(z14.string(), z14.unknown());
+var object_schema = z12.record(z12.string(), z12.unknown());
 function project_root(directory) {
   return ancestor_directories.nearest(
     directory,
-    (candidate) => existsSync7(path13.join(candidate, PACKAGE_JSON2))
+    (candidate) => existsSync7(path11.join(candidate, PACKAGE_JSON2))
   ) ?? directory;
 }
 function is_kit_repository(directory) {
@@ -5620,10 +5133,10 @@ function is_ignored(entry) {
   return entry.split(/[/\\]/u).some((part) => IGNORED_DIRS.has(part));
 }
 function has_files(directory, pattern) {
-  return globSync2(pattern, { cwd: project_root(directory), exclude: is_ignored }).length > 0;
+  return globSync(pattern, { cwd: project_root(directory), exclude: is_ignored }).length > 0;
 }
 function has_config(directory, names) {
-  return names.some((name) => existsSync7(path13.join(project_root(directory), name)));
+  return names.some((name) => existsSync7(path11.join(project_root(directory), name)));
 }
 function has_bin(directory, bin_name) {
   return find_local_bin_upwards(directory, bin_name) !== void 0;
@@ -5638,8 +5151,8 @@ function is_basic_manifest(manifest) {
 }
 function read_manifest2(directory) {
   try {
-    const manifest_path = path13.join(project_root(directory), PACKAGE_JSON2);
-    return json_value.parse_or_undefined(readFileSync6(manifest_path, "utf8"));
+    const manifest_path = path11.join(project_root(directory), PACKAGE_JSON2);
+    return json_value.parse_or_undefined(readFileSync5(manifest_path, "utf8"));
   } catch {
     return void 0;
   }
@@ -5659,11 +5172,11 @@ function missing_tool_reason(directory, package_name, bin_name) {
   if (has_bin(directory, bin_name) || is_declared2(directory, package_name)) return void 0;
   return `${package_name} is not installed`;
 }
-function skip_notice(check5, reason) {
-  return `josh ${check5}: ${reason} ${SKIP_MARKER} ${check5}, ${NOT_USED_MARKER}.`;
+function skip_notice(check3, reason) {
+  return `josh ${check3}: ${reason} ${SKIP_MARKER} ${check3}, ${NOT_USED_MARKER}.`;
 }
-function ran_notice(check5) {
-  return `josh ${check5}: ran and reported no problems.`;
+function ran_notice(check3) {
+  return `josh ${check3}: ran and reported no problems.`;
 }
 function type_check_skip_reason(directory) {
   if (!is_basic(directory)) return void 0;
@@ -5727,40 +5240,40 @@ var BASIC_REQUIRED_SUFFIXES = [
   ".toml"
 ];
 function normalize(paths) {
-  return paths.map((path16) => path16.trim()).filter((path16) => path16 !== "");
+  return paths.map((path13) => path13.trim()).filter((path13) => path13 !== "");
 }
-function is_test_file(path16) {
-  return TEST_SUFFIXES.some((suffix) => path16.endsWith(suffix));
+function is_test_file(path13) {
+  return TEST_SUFFIXES.some((suffix) => path13.endsWith(suffix));
 }
-function is_basic_manual(path16, is_basic2) {
-  const lower = path16.toLowerCase();
+function is_basic_manual(path13, is_basic2) {
+  const lower = path13.toLowerCase();
   return is_basic2 && BASIC_REQUIRED_SUFFIXES.every((suffix) => !lower.endsWith(suffix));
 }
-function is_basic_visual(path16) {
-  const lower = path16.toLowerCase();
+function is_basic_visual(path13) {
+  const lower = path13.toLowerCase();
   return BASIC_VISUAL_SUFFIXES.some((suffix) => lower.endsWith(suffix));
 }
-function is_exempt(path16, is_basic2 = false) {
-  if (EXEMPT_PATHS.includes(path16) || is_basic_manual(path16, is_basic2)) return true;
-  return EXEMPT_SUFFIXES.some((suffix) => path16.endsWith(suffix)) || EXEMPT_PREFIXES.some((prefix) => path16.startsWith(prefix));
+function is_exempt(path13, is_basic2 = false) {
+  if (EXEMPT_PATHS.includes(path13) || is_basic_manual(path13, is_basic2)) return true;
+  return EXEMPT_SUFFIXES.some((suffix) => path13.endsWith(suffix)) || EXEMPT_PREFIXES.some((prefix) => path13.startsWith(prefix));
 }
-function is_runtime(path16, is_basic2 = false) {
-  return !is_test_file(path16) && !is_exempt(path16, is_basic2);
+function is_runtime(path13, is_basic2 = false) {
+  return !is_test_file(path13) && !is_exempt(path13, is_basic2);
 }
 function verdict_for2(paths, is_basic2 = false) {
   const changed = normalize(paths);
-  if (changed.some((path16) => is_test_file(path16))) return "satisfied";
-  if (changed.some((path16) => is_runtime(path16, is_basic2))) return "required";
+  if (changed.some((path13) => is_test_file(path13))) return "satisfied";
+  if (changed.some((path13) => is_runtime(path13, is_basic2))) return "required";
   return "exempt";
 }
 function runtime_files(paths, is_basic2 = false) {
-  return normalize(paths).filter((path16) => is_runtime(path16, is_basic2));
+  return normalize(paths).filter((path13) => is_runtime(path13, is_basic2));
 }
 function exempt_files(paths, is_basic2 = false) {
-  return normalize(paths).filter((path16) => is_exempt(path16, is_basic2));
+  return normalize(paths).filter((path13) => is_exempt(path13, is_basic2));
 }
 function manual_check_files(paths, is_basic2) {
-  return normalize(paths).filter((path16) => is_exempt(path16, is_basic2) && !is_exempt(path16));
+  return normalize(paths).filter((path13) => is_exempt(path13, is_basic2) && !is_exempt(path13));
 }
 var test_declared_logic = {
   EXEMPT_PATHS,
@@ -5820,8 +5333,8 @@ function is_untested_commit(call) {
   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 ROW19 = { id: "test-declared", is_trigger: is_untested_commit, reason: REASON };
-var test_declared_commit = { REASON, ROW: ROW19 };
+var ROW20 = { id: "test-declared", is_trigger: is_untested_commit, reason: REASON };
+var test_declared_commit = { REASON, ROW: ROW20 };
 
 // scripts/rules/third-party-write.ts
 function is_third_party_write_segment(segment, session_owner, resolve_placeholder_owners) {
@@ -5859,14 +5372,14 @@ function writes_third_party(command, resolve_owner = repo_party.current_owner, r
   );
 }
 var THIRD_PARTY_WRITE_REASON = "\u26D4 third-party write: this `gh api` call writes to a repository whose owner is not this session, which is Tier C and needs explicit current-turn user instruction. Check with `pnpm josh repo:party <owner/repo>`, then record the finding on our own Issue and draft the artifact for a person to post. This rule fires on every occurrence (`prompts/collaboration-workflow/upstream-interrupt.md`).";
-var ROW20 = {
+var ROW21 = {
   id: "third-party-write",
   is_trigger: bash_triggers.on_bash_command((command) => writes_third_party(command)),
   reason: THIRD_PARTY_WRITE_REASON,
   decide: () => true
 };
 var third_party_write = {
-  ROW: ROW20,
+  ROW: ROW21,
   THIRD_PARTY_WRITE_REASON,
   writes_third_party
 };
@@ -5898,7 +5411,8 @@ var DELIVERED_RULES = [
     reason: piped_verification.PIPED_VERIFICATION_REASON,
     keeps: on_bash_command(piped_verification.keeps_verdict_intact),
     reaches: on_bash_command(piped_verification.runs_verification),
-    // A `| tail` / `| grep` masking is rewritten under `pipefail` by `pretool-guard.ts`, never refused.
+    // A masking whose filter reads to the end is rewritten under `pipefail`, never refused.
+    rewrite: piped_verification.pipefail_input,
     rewrite_note: piped_verification.PIPEFAIL_NOTE
   },
   {
@@ -5937,6 +5451,7 @@ var DELIVERED_RULES = [
   lane_split_park.ROW,
   lane_park.ROW,
   lane_interactive_ask.ROW,
+  agent_model.ROW,
   lane_carry_conflict.ROW,
   lane_switch_main.ROW,
   // Disjoint from `run-tail` by the `-y` flag.
@@ -5976,22 +5491,22 @@ var MEASURED_RULES = [
 ];
 var BATCH_STAMP = hook_decision.create_refusal_stamp(time_batch_guard.STAMP_PREFIX);
 var BATCH_REFUSAL_WINDOW_MS = 1e4;
-function will_batch_guard_refuse(tail, call, run2) {
+function will_batch_guard_refuse(tail, call, run) {
   if (lane_guard_policy.mode_here("batching") !== "refuse") return false;
-  const refused_at_ms = BATCH_STAMP.last_ms(BATCH_STAMP.path(run2.transcript));
-  if (run2.now_ms - refused_at_ms < BATCH_REFUSAL_WINDOW_MS) return true;
+  const refused_at_ms = BATCH_STAMP.last_ms(BATCH_STAMP.path(run.transcript));
+  if (run.now_ms - refused_at_ms < BATCH_REFUSAL_WINDOW_MS) return true;
   return time_batch_guard.should_block(tail, call, refused_at_ms);
 }
-function is_first_delivery(tail, call, delivered_at_ms, run2) {
-  return delivered_at_ms === hook_decision.NEVER_MS && !will_batch_guard_refuse(tail, call, run2);
+function is_first_delivery(tail, call, delivered_at_ms, run) {
+  return delivered_at_ms === hook_decision.NEVER_MS && !will_batch_guard_refuse(tail, call, run);
 }
 function delivery_decision(rule) {
-  const { decide: decide7, already_satisfied } = rule;
-  if (decide7 === void 0 && already_satisfied === void 0) return is_first_delivery;
-  return function should_block(tail, call, delivered_at_ms, run2) {
+  const { decide: decide5, already_satisfied } = rule;
+  if (decide5 === void 0 && already_satisfied === void 0) return is_first_delivery;
+  return function should_block(tail, call, delivered_at_ms, run) {
     if (already_satisfied?.(tail, call) === true) return false;
-    if (decide7 === void 0) return true;
-    return decide7(call, run2, !will_batch_guard_refuse(tail, call, run2), delivered_at_ms);
+    if (decide5 === void 0) return true;
+    return decide5(call, run, !will_batch_guard_refuse(tail, call, run), delivered_at_ms);
   };
 }
 function guard_of(rule) {
@@ -6044,6 +5559,144 @@ var delivered_rules = {
   is_issue_filing
 };
 
+// scripts/rules/guard-remedy.ts
+var REWRITTEN = "the hook makes the same call right itself; it refuses only a spelling it cannot rewrite";
+var ANOTHER_TOOL = "the right form is another tool, which `updatedInput` cannot switch to";
+var ANOTHER_COMMAND = "the right act is another command, whose arguments the call does not carry";
+var NO_RUN = "the call must not run at all, or only on a person's word \u2014 refusing is the remedy";
+var STOP_NOTIFY = "the hook sends the notify itself; it blocks only when the send fails";
+var HOLD_RELEASE = "the hook releases the hold itself; it blocks only when that release fails";
+var ISSUE_CITATION = "the hook prints the citation lines itself; it blocks only on a number it cannot cite";
+var FILING_OFFER = "the filing needs a title and a body only the model can write";
+function rewrite() {
+  return { remedy: "rewrite", why: REWRITTEN };
+}
+function judgment(why) {
+  return { remedy: "judgment", why };
+}
+var GUARD_REMEDIES = {
+  // The rewrites: each fix is the same call made right.
+  "piped-verification": rewrite(),
+  // wrapped in `(set -o pipefail; …)`
+  "issue-comments": rewrite(),
+  // the same Issue's comments read on the same line
+  "lane-background": rewrite(),
+  // a lane child's `ship` run in the foreground (`pretool-guard.ts`)
+  "file-body": judgment(ANOTHER_TOOL),
+  // Edit or Write
+  "shell-body": judgment(
+    "which part of the body the shell was meant to expand is the author's, not the hook's"
+  ),
+  "raw-field-body": judgment("the body moves to a file the call does not name"),
+  "rule-body": judgment("a trigger-plus-pointer line is written, not derived"),
+  "direct-filing": judgment(ANOTHER_COMMAND),
+  "direct-pr-create": judgment(ANOTHER_COMMAND),
+  "josh-git-bare": judgment(ANOTHER_COMMAND),
+  "run-tail": judgment(ANOTHER_COMMAND),
+  "pre-gate-cut": judgment(ANOTHER_COMMAND),
+  "implementation-cut": judgment(ANOTHER_COMMAND),
+  "early-heartbeat": judgment(ANOTHER_COMMAND),
+  "poll-loop": judgment(ANOTHER_COMMAND),
+  "lane-park": judgment(ANOTHER_COMMAND),
+  "lane-split-park": judgment(ANOTHER_COMMAND),
+  "lane-interactive-ask": judgment(ANOTHER_COMMAND),
+  "agent-model": judgment("which model fits the unit is the author's call"),
+  "lane-carry-conflict": judgment(ANOTHER_COMMAND),
+  "lane-switch-main": judgment(ANOTHER_COMMAND),
+  "oracle-consulted": judgment(ANOTHER_COMMAND),
+  "test-declared": judgment(ANOTHER_COMMAND),
+  batching: judgment(ANOTHER_COMMAND),
+  investigation: judgment(ANOTHER_COMMAND),
+  "duplicate-read": judgment(ANOTHER_COMMAND),
+  "run-watcher": judgment(ANOTHER_COMMAND),
+  "parent-cut": judgment(ANOTHER_COMMAND),
+  "issue-watch": judgment(ANOTHER_COMMAND),
+  "third-party-write": judgment(NO_RUN),
+  "filing-cap": judgment(NO_RUN),
+  "git-force": judgment(NO_RUN),
+  "worktree-mutation": judgment(NO_RUN),
+  "index-mutation": judgment(NO_RUN),
+  "destructive-command": judgment(NO_RUN),
+  "protected-file": judgment(NO_RUN),
+  // The `Stop` rows: the hook judges a finished reply, so it has no call to rewrite.
+  "stop-notify": judgment(STOP_NOTIFY),
+  "issue-citation": judgment(ISSUE_CITATION),
+  "filing-offer": judgment(FILING_OFFER),
+  "hold-release": judgment(HOLD_RELEASE)
+};
+var FAMILY_SEPARATOR = ":";
+function entry_of(id) {
+  return GUARD_REMEDIES[id] ?? GUARD_REMEDIES[id.split(FAMILY_SEPARATOR)[0] ?? ""];
+}
+function remedy_of(id) {
+  return entry_of(id)?.remedy;
+}
+function why_of(id) {
+  return entry_of(id)?.why;
+}
+function is_rewrite(id) {
+  return remedy_of(id) === "rewrite";
+}
+var guard_remedy = {
+  GUARD_REMEDIES,
+  is_rewrite,
+  remedy_of,
+  why_of
+};
+
+// scripts/rules/rule-rewrite.ts
+var REWRITING_RULES = delivered_rules.DELIVERED_RULES.filter(
+  (rule) => guard_remedy.is_rewrite(rule.id) && rule.rewrite !== void 0
+);
+var NOTE_SEPARATOR = "\n\n";
+function read_payload_tail(raw_payload) {
+  try {
+    const payload = hook_decision.parse_hook_payload(raw_payload);
+    return payload ? time_density_hook.read_tail(
+      time_hook_transcript.transcript_of(payload.transcript_path, payload.agent_id)
+    ) : "";
+  } catch {
+    return "";
+  }
+}
+function tail_reader(raw_payload) {
+  const cache = {};
+  return function tail() {
+    cache.tail ??= read_payload_tail(raw_payload);
+    return cache.tail;
+  };
+}
+function fold(name, typed, tail) {
+  const folded = { input: typed, notes: [] };
+  for (const rule of REWRITING_RULES) {
+    const input = rule.rewrite?.({ name, input: folded.input }, tail);
+    if (input === void 0) {
+      continue;
+    }
+    folded.input = input;
+    folded.notes = [...folded.notes, rule.rewrite_note ?? ""];
+  }
+  return folded;
+}
+function typed_payload(raw_payload) {
+  const fields = json_value.parse_or_undefined(raw_payload);
+  if (!json_value.is_record(fields)) return void 0;
+  const input = fields["tool_input"];
+  return json_value.is_record(input) ? { fields, name: String(fields["tool_name"]), input } : void 0;
+}
+function rewrite2(raw_payload) {
+  const typed = delivered_rules.is_enabled() ? typed_payload(raw_payload) : void 0;
+  if (typed === void 0) return void 0;
+  const { input, notes } = fold(typed.name, typed.input, tail_reader(raw_payload));
+  if (notes.length === 0) return void 0;
+  const note = notes.join(NOTE_SEPARATOR);
+  return { payload: JSON.stringify({ ...typed.fields, tool_input: input }), input, note };
+}
+var rule_rewrite = {
+  NOTE_SEPARATOR,
+  rewrite: rewrite2
+};
+
 // scripts/run/progress/run-progress-read.ts
 import { loadavg } from "node:os";
 
@@ -6059,8 +5712,8 @@ function format_holder(issue, repo, ages) {
 function format_holders(issues, repo, ages) {
   return issues.map((issue) => format_holder(issue, repo, ages)).join(", ");
 }
-function occupied_lanes(read3) {
-  return read3.kind === "busy" ? read3.issues.length : 0;
+function occupied_lanes(read2) {
+  return read2.kind === "busy" ? read2.issues.length : 0;
 }
 function occupancy_message(issues, repo, limit, ages = NO_AGES) {
   return `${String(issues.length)} of ${String(limit)} lanes in use in ${repo}: ${format_holders(issues, repo, ages)}.`;
@@ -6078,18 +5731,18 @@ var BUSY_REASONS = {
   unreadable: unreadable_message,
   truncated: truncated_message
 };
-function busy_reason(read3, repo, limit, ages = NO_AGES) {
-  if (read3.kind === "busy") return lanes_full_message(read3.issues, repo, limit, ages);
-  if (read3.kind === "idle") return "";
-  return BUSY_REASONS[read3.kind](repo);
+function busy_reason(read2, repo, limit, ages = NO_AGES) {
+  if (read2.kind === "busy") return lanes_full_message(read2.issues, repo, limit, ages);
+  if (read2.kind === "idle") return "";
+  return BUSY_REASONS[read2.kind](repo);
 }
 function is_parked(issue) {
   return has_any_label(issue.labels, PARKED_LABELS);
 }
 function parse_listing(raw, is_capped) {
-  const read3 = read_json_listing(raw, open_issue_schema);
-  if (read3.kind !== "read") return { kind: "unreadable" };
-  const holders = read3.rows.filter((row) => !is_parked(row));
+  const read2 = read_json_listing(raw, open_issue_schema);
+  if (read2.kind !== "read") return { kind: "unreadable" };
+  const holders = read2.rows.filter((row) => !is_parked(row));
   if (holders.length > 0) return { kind: "busy", issues: holders };
   return { kind: is_capped ? "truncated" : "idle" };
 }
@@ -6114,411 +5767,16 @@ var epic_busy = {
   read_repository
 };
 
-// scripts/run/run-liveness.ts
-import { readFileSync as readFileSync7, realpathSync, statSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
-import path14 from "node:path";
-import { setTimeout as sleep } from "node:timers/promises";
-
-// scripts/agent/agent-event.ts
-import { z as z16 } from "zod";
-
-// scripts/agent/claude-result-event.ts
-import { z as z15 } from "zod";
-var RESULT_EVENT_SCHEMA = z15.looseObject({
-  type: z15.literal("result"),
-  is_error: z15.unknown().optional(),
-  subtype: z15.unknown().optional(),
-  num_turns: z15.unknown().optional(),
-  permission_denials: z15.unknown().optional(),
-  result: z15.unknown().optional(),
-  session_id: z15.unknown().optional(),
-  usage: z15.unknown().optional()
-});
-var USAGE_SCHEMA = z15.looseObject({
-  input_tokens: z15.unknown().optional(),
-  cache_read_input_tokens: z15.unknown().optional(),
-  output_tokens: z15.unknown().optional()
-});
-function usable_reason(value) {
-  return typeof value === "string" && value.trim() !== "" ? value : void 0;
-}
-function numeric_value(value) {
-  return typeof value === "number" ? value : void 0;
-}
-function denial_count(value) {
-  return Array.isArray(value) ? value.length : 0;
-}
-function usage_of(value) {
-  const parsed = USAGE_SCHEMA.safeParse(value);
-  if (!parsed.success) return void 0;
-  const usage = {
-    input_tokens: numeric_value(parsed.data.input_tokens),
-    cached_input_tokens: numeric_value(parsed.data.cache_read_input_tokens),
-    output_tokens: numeric_value(parsed.data.output_tokens)
-  };
-  return Object.values(usage).some((count) => count !== void 0) ? usage : void 0;
-}
-function decode(value) {
-  const parsed = RESULT_EVENT_SCHEMA.safeParse(value);
-  if (!parsed.success) return void 0;
-  const is_error = parsed.data.is_error === true;
-  return {
-    is_error,
-    subtype: usable_reason(parsed.data.subtype),
-    num_turns: numeric_value(parsed.data.num_turns),
-    permission_denials: denial_count(parsed.data.permission_denials),
-    refused_ask: interactive_ask.refused_ask_of(parsed.data.permission_denials),
-    reason: is_error ? usable_reason(parsed.data.result) ?? usable_reason(parsed.data.subtype) : void 0,
-    session_id: usable_reason(parsed.data.session_id),
-    usage: usage_of(parsed.data.usage)
-  };
-}
-var claude_result_event = { decode };
-
-// scripts/agent/agent-event.ts
-var TEXT_BLOCK_SCHEMA = z16.looseObject({ type: z16.literal("text"), text: z16.string() });
-var CLAUDE_MESSAGE_SCHEMA = z16.looseObject({ content: z16.array(z16.unknown()).optional() });
-var CLAUDE_INIT_SCHEMA = z16.looseObject({ type: z16.literal("system"), subtype: z16.literal("init") });
-var CLAUDE_ASSISTANT_SCHEMA = z16.looseObject({
-  type: z16.literal("assistant"),
-  message: CLAUDE_MESSAGE_SCHEMA
-});
-var USAGE_SCHEMA2 = z16.looseObject({
-  input_tokens: z16.number().optional(),
-  cached_input_tokens: z16.number().optional(),
-  output_tokens: z16.number().optional()
-});
-var CODEX_START_SCHEMA = z16.looseObject({ type: z16.enum(["thread.started", "turn.started"]) });
-var CODEX_PROGRESS_SCHEMA = z16.looseObject({
-  type: z16.enum(["item.started", "item.updated", "item.completed"]),
-  item: z16.looseObject({ type: z16.string(), text: z16.string().optional() }).optional()
-});
-var CODEX_COMPLETE_SCHEMA = z16.looseObject({
-  type: z16.literal("turn.completed"),
-  usage: USAGE_SCHEMA2.optional()
-});
-var CODEX_FAILURE_SCHEMA = z16.looseObject({
-  type: z16.enum(["turn.failed", "error"]),
-  error: z16.looseObject({ message: z16.string().optional() }).optional(),
-  message: z16.string().optional()
-});
-var EMPTY_STATE = {
-  provider: void 0,
-  launch: "pending",
-  progress: void 0,
-  result: "running",
-  reason: void 0,
-  usage: void 0
-};
-var LAUNCH_HEADER_PREFIX = "=== ";
-var LAUNCH_HEADER_MARKER = " \xB7 started by process ";
-function usable_text(value) {
-  return typeof value === "string" && value.trim() !== "" ? value : void 0;
-}
-function claude_progress(content) {
-  return content.map((block) => TEXT_BLOCK_SCHEMA.safeParse(block)).filter((parsed) => parsed.success).map((parsed) => parsed.data.text).findLast((text) => text.trim() !== "");
-}
-function claude_result(value, state) {
-  const result = claude_result_event.decode(value);
-  if (result === void 0) return void 0;
-  return {
-    ...state,
-    provider: "anthropic",
-    result: result.is_error ? "failed" : "completed",
-    reason: result.is_error ? result.reason ?? state.reason : state.reason,
-    usage: result.usage
-  };
-}
-function claude_assistant(value, state) {
-  const assistant = CLAUDE_ASSISTANT_SCHEMA.safeParse(value);
-  if (!assistant.success) return void 0;
-  const progress = claude_progress(assistant.data.message.content ?? []) ?? state.progress;
-  return { ...state, provider: "anthropic", progress };
-}
-function claude_terminal(value, state) {
-  return claude_result(value, state);
-}
-function claude_event(value, state) {
-  if (CLAUDE_INIT_SCHEMA.safeParse(value).success) {
-    return { ...state, provider: "anthropic", launch: "started" };
-  }
-  return claude_assistant(value, state) ?? claude_terminal(value, state);
-}
-function codex_progress(value, state) {
-  const parsed = CODEX_PROGRESS_SCHEMA.safeParse(value);
-  if (!parsed.success) return void 0;
-  const progress = usable_text(parsed.data.item?.text) ?? state.progress;
-  return { ...state, provider: "openai", progress };
-}
-function codex_completed(value, state) {
-  const completed = CODEX_COMPLETE_SCHEMA.safeParse(value);
-  if (!completed.success) return void 0;
-  return { ...state, provider: "openai", result: "completed", usage: completed.data.usage };
-}
-function codex_failed(value, state) {
-  const failed = CODEX_FAILURE_SCHEMA.safeParse(value);
-  if (!failed.success) return void 0;
-  const reason = usable_text(failed.data.error?.message) ?? usable_text(failed.data.message);
-  return { ...state, provider: "openai", result: "failed", reason: reason ?? state.reason };
-}
-function codex_terminal(value, state) {
-  return codex_completed(value, state) ?? codex_failed(value, state);
-}
-function codex_event(value, state) {
-  if (CODEX_START_SCHEMA.safeParse(value).success) {
-    return { ...state, provider: "openai", launch: "started" };
-  }
-  return codex_progress(value, state) ?? codex_terminal(value, state);
-}
-function normalized(value, state) {
-  return claude_event(value, state) ?? codex_event(value, state) ?? state;
-}
-function next_state2(line, state) {
-  const is_header = line.startsWith(LAUNCH_HEADER_PREFIX) && line.includes(LAUNCH_HEADER_MARKER);
-  if (is_header) return EMPTY_STATE;
-  return normalized(json_value.parse_or_undefined(line), state);
-}
-function read2(transcript) {
-  let state = EMPTY_STATE;
-  for (const line of transcript.split("\n")) state = next_state2(line, state);
-  return state;
-}
-function describe(state) {
-  const progress = state.progress === void 0 ? "" : ` progress=${state.progress}`;
-  const reason = state.reason === void 0 ? "" : ` reason=${state.reason}`;
-  return `launch=${state.launch} result=${state.result}${progress}${reason}`;
-}
-var agent_event = { describe, read: read2 };
-
-// scripts/issue/issue-state.ts
-import { z as z17 } from "zod";
-var NO_LABELS = "(none)";
-var LABEL_SEPARATOR = ", ";
-var STATE_LABEL = "state: ";
-var LABELS_LABEL = "labels: ";
-var HUMAN_REVIEW_LABEL_LINE = "human_review: ";
-var YES = "yes";
-var NO = "no";
-var ISSUE_LABEL = "issue: ";
-var HUMAN_REVIEW_LABELS = /* @__PURE__ */ new Set([NEEDS_HUMAN_REVIEW_LABEL]);
-var label_schema = z17.looseObject({ name: z17.string() });
-var issue_state_schema = z17.looseObject({
-  state: z17.string(),
-  labels: label_schema.array().optional()
-});
-function parse_issue_state(json) {
-  try {
-    const parsed = parse_json_object_or_undefined(json, issue_state_schema);
-    if (parsed === void 0) return void 0;
-    const labels = parsed.labels ?? [];
-    return {
-      state: parsed.state,
-      labels: labels.map((label) => label.name),
-      is_human_review: has_any_label(labels, HUMAN_REVIEW_LABELS)
-    };
-  } catch {
-    return void 0;
-  }
-}
-function format_labels(labels) {
-  return labels.length === 0 ? NO_LABELS : labels.join(LABEL_SEPARATOR);
-}
-function format_issue_state(state) {
-  const human_review = `${HUMAN_REVIEW_LABEL_LINE}${state.is_human_review ? YES : NO}`;
-  return `${STATE_LABEL}${state.state}
-${LABELS_LABEL}${format_labels(state.labels)}
-${human_review}`;
-}
-function format_attributed_issue_state(issue_number, state) {
-  return `${ISSUE_LABEL}${issue_number}
-${format_issue_state(state)}`;
-}
-var issue_state = {
-  NO_LABELS,
-  parse_issue_state,
-  format_issue_state,
-  format_attributed_issue_state
-};
-
-// scripts/run/run-liveness.ts
-var ALIVE_VERDICT = "alive";
-var SETTLED_VERDICT = "settled";
-var STOPPED_VERDICT = "stopped";
-var UNDETERMINED_VERDICT = "undetermined";
-var PROCESS_ALIVE = "alive";
-var PROCESS_UNKNOWN = "unknown";
-var DEFAULT_SILENT_MINUTES = 30;
-var DEFAULT_GAP_SECONDS = 5;
-var MS_PER_MINUTE3 = 6e4;
-var MS_PER_SECOND2 = 1e3;
-var OPEN_STATE = "OPEN";
-var STATE_FIELDS = "state,labels";
-var REASONS = {
-  [ALIVE_VERDICT]: "The unit is still working: its output moved, or a process of the child is alive.",
-  [SETTLED_VERDICT]: "The child is closed, parked with `needs-decision`, or marked `already-done`, so there is nothing here to recover.",
-  [STOPPED_VERDICT]: "The output has been frozen past the silent window and no process of the child is alive in that checkout.",
-  [UNDETERMINED_VERDICT]: "A trace could not be read, so this says nothing about the unit. A trace that could not be read answers `undetermined`, never `stopped`."
-};
-var ALIVE_ADVICE = "Keep polling; do not touch the child.";
-var SETTLED_ADVICE = "Read the child with `pnpm josh issue:state <N>` and take the branch its state says.";
-var STOPPED_CLEAN_ADVICE = 'The unit ended \u2014 classify how before booking it. Run `pnpm josh run:merge <N> --output <path>` (add `--epic <E> --repo <owner/repo> --owner "$PPID"` for a named epic): it reads the child\'s exit record without waiting for the unit to return, re-dispatches a child that could not reach the API (counting the outage; a run of them trips the environment guard and stops the run), and parks an abandoned child with `needs-decision` against the consecutive-failure guard. The checkout is clean, so there is nothing to stash.';
-var STOPPED_DIRTY_ADVICE = 'Stash the half-finished work with `git stash push -u -m "backlogrun: stopped unit for #<N>"` and record it on the Issue, then classify how the unit ended with `pnpm josh run:merge <N> --output <path>` (add `--epic <E> --repo <owner/repo> --owner "$PPID"` for a named epic): it re-dispatches an API-outage child (counting the outage; a run of them trips the environment guard) and parks an abandoned child with `needs-decision` against the consecutive-failure guard, without waiting for the unit to return.';
-var UNDETERMINED_ADVICE = "Read the trace that failed and ask again. Where the process trace was given as `unknown`, leave `--process` out so the command reads it. Two of these in a row is a fault in the check itself rather than a slow unit: stop polling and report it.";
-function is_output_moving(traces) {
-  return traces.is_output_frozen === false;
-}
-function is_agent_state_finished(state) {
-  return state?.result === "completed" || state?.result === "failed";
-}
-function is_agent_finished(traces) {
-  return is_agent_state_finished(traces.agent_state);
-}
-function definitive_verdict(traces) {
-  if (traces.is_child_settled === true) return SETTLED_VERDICT;
-  if (is_agent_finished(traces)) return STOPPED_VERDICT;
-  if (is_output_moving(traces)) return ALIVE_VERDICT;
-  return void 0;
-}
-function is_check_running(traces) {
-  return traces.process_trace === PROCESS_ALIVE;
-}
-function has_unreadable_trace(traces) {
-  return traces.is_child_settled === void 0 || traces.is_output_frozen === void 0 || traces.process_trace === PROCESS_UNKNOWN;
-}
-function to_verdict(traces) {
-  const definitive = definitive_verdict(traces);
-  if (definitive !== void 0) return definitive;
-  if (has_unreadable_trace(traces)) return UNDETERMINED_VERDICT;
-  return is_check_running(traces) ? ALIVE_VERDICT : STOPPED_VERDICT;
-}
-function to_advice(verdict, has_work_to_stash) {
-  if (verdict === ALIVE_VERDICT) return ALIVE_ADVICE;
-  if (verdict === SETTLED_VERDICT) return SETTLED_ADVICE;
-  if (verdict === UNDETERMINED_VERDICT) return UNDETERMINED_ADVICE;
-  return has_work_to_stash ? STOPPED_DIRTY_ADVICE : STOPPED_CLEAN_ADVICE;
-}
-function decide5(traces) {
-  const verdict = to_verdict(traces);
-  const has_work_to_stash = verdict === STOPPED_VERDICT && traces.is_tree_dirty;
-  return {
-    advice: to_advice(verdict, has_work_to_stash),
-    has_work_to_stash,
-    reason: traces.agent_state?.reason ?? REASONS[verdict],
-    verdict
-  };
-}
-function to_resolved_root(root) {
-  try {
-    return realpathSync(root);
-  } catch {
-    return root;
-  }
-}
-var ALLOWED_ROOTS = [
-  ...new Set(
-    [homedir(), tmpdir(), PLATFORM_TEMP_ROOT].flatMap((root) => [root, to_resolved_root(root)])
-  )
-];
-function is_within(candidate, root) {
-  const relative = path14.relative(root, candidate);
-  return relative !== "" && !relative.startsWith("..") && !path14.isAbsolute(relative);
-}
-function to_safe_path(output_path) {
-  const normalized2 = path14.normalize(output_path);
-  if (!path14.isAbsolute(normalized2)) return void 0;
-  return ALLOWED_ROOTS.some((root) => is_within(normalized2, root)) ? normalized2 : void 0;
-}
-function sample_output(output_path) {
-  const safe_path = to_safe_path(output_path);
-  if (safe_path === void 0) return void 0;
-  const stats = statSync(safe_path, { throwIfNoEntry: false });
-  if (!stats?.isFile()) return void 0;
-  return { mtime_ms: stats.mtimeMs, size: stats.size };
-}
-function read_agent_state(output_path) {
-  const safe_path = to_safe_path(output_path);
-  if (safe_path === void 0) return void 0;
-  try {
-    const state = agent_event.read(readFileSync7(safe_path, "utf8"));
-    return state.provider === void 0 ? void 0 : state;
-  } catch {
-    return void 0;
-  }
-}
-function describe_agent_state(output_path) {
-  const state = read_agent_state(output_path);
-  return state === void 0 ? void 0 : `agent: ${state.provider ?? "unknown"} ${agent_event.describe(state)}`;
-}
-async function read_output_frozen(request2) {
-  const first = sample_output(request2.output_path);
-  if (first === void 0) return void 0;
-  if (request2.now_ms - first.mtime_ms < request2.silent_window_ms) return false;
-  await sleep(request2.gap_ms);
-  const second = sample_output(request2.output_path);
-  if (second === void 0) return void 0;
-  return second.mtime_ms === first.mtime_ms && second.size === first.size;
-}
-function carries_label(labels, wanted) {
-  return labels.some((label) => label.toLowerCase() === wanted);
-}
-var SETTLED_LABELS = [NEEDS_DECISION_LABEL, ALREADY_DONE_LABEL];
-function carries_settled_label(labels) {
-  return SETTLED_LABELS.some((label) => carries_label(labels, label));
-}
-async function read_child_settled(issue, repo) {
-  const json = await git_gh_issue_read.issue_view_json(issue, STATE_FIELDS, repo);
-  if (json === void 0) return void 0;
-  const state = issue_state.parse_issue_state(json);
-  if (state === void 0) return void 0;
-  return state.state !== OPEN_STATE || carries_settled_label(state.labels);
-}
-async function read_traces(request2) {
-  const [is_initial_child_settled, is_output_frozen, is_tree_dirty] = await Promise.all([
-    read_child_settled(request2.issue, request2.repo),
-    read_output_frozen({
-      gap_ms: request2.gap_ms ?? DEFAULT_GAP_SECONDS * MS_PER_SECOND2,
-      now_ms: Date.now(),
-      output_path: request2.output_path,
-      silent_window_ms: request2.silent_window_ms ?? DEFAULT_SILENT_MINUTES * MS_PER_MINUTE3
-    }),
-    run_hold.is_tree_dirty()
-  ]);
-  const agent_state = read_agent_state(request2.output_path);
-  const is_latest_child_settled = is_agent_state_finished(agent_state) ? await read_child_settled(request2.issue, request2.repo) : void 0;
-  const is_child_settled = is_latest_child_settled ?? is_initial_child_settled;
-  return {
-    agent_state,
-    is_child_settled,
-    is_output_frozen,
-    is_tree_dirty,
-    process_trace: request2.process_trace
-  };
-}
-async function check2(request2) {
-  issue_number_shape.require_issue_number(request2.issue);
-  return decide5(await read_traces(request2));
-}
-var run_liveness = {
-  check: check2,
-  decide: decide5,
-  describe_agent_state,
-  read_child_settled,
-  read_output_frozen,
-  sample_output,
-  to_safe_path
-};
-
 // scripts/lane/lane-report.ts
 var NO_LANES2 = "No lanes are open.";
-var OPEN_STATE2 = "open";
+var OPEN_STATE = "open";
 var STRANDED_STATE = "stranded";
 var UNREADABLE_STATE = "unreadable";
 var UNKNOWN_VALUE = "-";
 var COLUMN_SEPARATOR = "  ";
 function lane_state(lane) {
   if (lane.is_stranded) return STRANDED_STATE;
-  return lane.seat === void 0 ? UNREADABLE_STATE : OPEN_STATE2;
+  return lane.seat === void 0 ? UNREADABLE_STATE : OPEN_STATE;
 }
 function value_or_unknown(value) {
   return value === void 0 ? UNKNOWN_VALUE : String(value);
@@ -6562,7 +5820,7 @@ function describe_opened(lane) {
 }
 var lane_report = {
   NO_LANES: NO_LANES2,
-  OPEN_STATE: OPEN_STATE2,
+  OPEN_STATE,
   STRANDED_STATE,
   UNREADABLE_STATE,
   describe_lane,
@@ -6571,197 +5829,6 @@ var lane_report = {
   lane_state
 };
 
-// scripts/run/run-preflight.ts
-import { z as z18 } from "zod";
-var CLEAN_VERDICT = "clean";
-var RECLAIM_VERDICT = "reclaim";
-var RESUME_VERDICT = "resume";
-var PARK_VERDICT = "park";
-var NO_PR = "none";
-var OPEN_PR = "open";
-var MERGED_PR = "merged";
-var CLOSED_PR = "closed";
-var NO_CHILD_WORK = { branch_name: void 0, pr_state: NO_PR };
-var pr_info_schema = z18.object({ state: z18.string().optional() });
-var GH_PR_STATES = /* @__PURE__ */ new Map([
-  ["CLOSED", CLOSED_PR],
-  ["MERGED", MERGED_PR],
-  ["OPEN", OPEN_PR]
-]);
-var CLEAN_REASON = "Nothing was left behind: the tree is clean, HEAD is on the default branch, and this issue has no pull request and no branch holding work.";
-var CLEAN_ADVICE = "Start the child.";
-var RESUME_ADVICE = "Reuse the branch and run the whole verification gate from the start \u2014 refactor, `pnpm josh gate`, `/code-review` \u2014 never only the part the interrupted run had not reached. Nobody verified what it already committed.";
-var PARK_ADVICE = "Park the child: add `needs-decision` and comment what was found. Do not delete the branch, do not reopen the pull request, and do not commit on top of it.";
-var STASH_LABEL_PREFIX = "run:hold reclaimed before #";
-var { require_issue_number } = issue_number_shape;
-var UNREADABLE_PR_MESSAGE = "The pull request could not be read for branch ";
-function needs_reclaim(tree) {
-  return tree.is_dirty || tree.branch !== tree.default_branch;
-}
-function is_pr_decided(state) {
-  return state === MERGED_PR || state === CLOSED_PR;
-}
-function has_leftover_work(child) {
-  return child.branch_name !== void 0 || child.pr_state === OPEN_PR;
-}
-function to_verdict2(tree, child) {
-  if (needs_reclaim(tree)) return RECLAIM_VERDICT;
-  if (is_pr_decided(child.pr_state)) return PARK_VERDICT;
-  if (has_leftover_work(child)) return RESUME_VERDICT;
-  return CLEAN_VERDICT;
-}
-function reclaim_reason(tree) {
-  const findings = [
-    tree.is_dirty ? "uncommitted changes" : void 0,
-    tree.branch === tree.default_branch ? void 0 : `HEAD on ${tree.branch}`
-  ].filter((entry) => entry !== void 0);
-  return `An earlier run left ${findings.join(" and ")} in this working tree.`;
-}
-function park_reason(state) {
-  return `The pull request for this issue is ${state}, so whether any work is still owed is a person's call.`;
-}
-function resume_reason(child) {
-  const branch_part = child.branch_name === void 0 ? "" : ` on branch ${child.branch_name}`;
-  const pr_part = child.pr_state === OPEN_PR ? ", and its pull request is still open" : "";
-  return `An earlier run left a partial implementation${branch_part}${pr_part}.`;
-}
-function to_reason(verdict, tree, child) {
-  if (verdict === RECLAIM_VERDICT) return reclaim_reason(tree);
-  if (verdict === PARK_VERDICT) return park_reason(child.pr_state);
-  if (verdict === RESUME_VERDICT) return resume_reason(child);
-  return CLEAN_REASON;
-}
-function reclaim_steps(tree, issue) {
-  if (!tree.is_dirty) return [];
-  return [
-    `git stash push -u -m "${STASH_LABEL_PREFIX}${issue}"`,
-    `Record the stash on ${session_cite.issue(issue)} \u2014 the comment is what gets it popped; nothing pops it for you.`
-  ];
-}
-function reclaim_advice(tree, issue) {
-  return [
-    ...reclaim_steps(tree, issue),
-    "pnpm josh ms",
-    "Then ask this command again: it is re-askable, and the clean tree gets its own answer."
-  ].join("\n");
-}
-function to_advice2(verdict, issue, tree) {
-  if (verdict === RECLAIM_VERDICT) return reclaim_advice(tree, issue);
-  if (verdict === RESUME_VERDICT) return RESUME_ADVICE;
-  if (verdict === PARK_VERDICT) return PARK_ADVICE;
-  return CLEAN_ADVICE;
-}
-function decide6(tree, child, issue) {
-  const verdict = to_verdict2(tree, child);
-  return {
-    advice: to_advice2(verdict, issue, tree),
-    reason: to_reason(verdict, tree, child),
-    verdict
-  };
-}
-function read_pr_field(raw) {
-  return json_value.parse_with(raw, pr_info_schema)?.state;
-}
-function to_pr_state(raw) {
-  const state = read_pr_field(raw);
-  return (state === void 0 ? void 0 : GH_PR_STATES.get(state)) ?? NO_PR;
-}
-async function read_tree_state() {
-  const [is_dirty, current, default_branch] = await Promise.all([
-    run_hold.is_tree_dirty(),
-    git_command.branch(),
-    git_command.get_default_branch()
-  ]);
-  return { branch: current, default_branch, is_dirty };
-}
-async function read_pr_state(branch_name) {
-  if (!await git_gh_pr_read.pr_exists(branch_name)) return NO_PR;
-  const raw = await git_gh_pr_read.pr_view(branch_name);
-  if (raw === "") throw new Error(`${UNREADABLE_PR_MESSAGE}${branch_name}`);
-  return to_pr_state(raw);
-}
-function is_pr_open(state) {
-  return state === OPEN_PR;
-}
-async function read_pr_of_branch(branch_name) {
-  return { branch_name, pr_state: await read_pr_state(branch_name) };
-}
-function pick_child_state(reads) {
-  const decided = reads.find((read3) => is_pr_decided(read3.pr_state));
-  const open = reads.find((read3) => is_pr_open(read3.pr_state));
-  return decided ?? open ?? { branch_name: reads[0]?.branch_name, pr_state: NO_PR };
-}
-var ISSUE_BRANCH_SUFFIX = "-*";
-var ANY_REMOTE_PREFIX = "*/";
-var REMOTE_SEPARATOR = "/";
-var NOT_FOUND_INDEX = -1;
-function to_head_branch(name) {
-  const separator_index = name.indexOf(REMOTE_SEPARATOR);
-  return separator_index === NOT_FOUND_INDEX ? name : name.slice(separator_index + 1);
-}
-function group_by_head(pairs) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const [name, reference] of pairs) groups.set(name, [...groups.get(name) ?? [], reference]);
-  return groups;
-}
-async function read_branch_candidates(issue) {
-  const pattern = `${issue}${ISSUE_BRANCH_SUFFIX}`;
-  const [local, remote] = await Promise.all([
-    git_command.branch_names(pattern),
-    git_command.branch_names_remote(`${ANY_REMOTE_PREFIX}${pattern}`)
-  ]);
-  return group_by_head([
-    ...local.map((name) => [name, name]),
-    ...remote.map((reference) => [to_head_branch(reference), reference])
-  ]);
-}
-async function has_commits_beyond(base, references) {
-  const counts = await Promise.all(
-    references.map(async (reference) => await git_command.commit_count_beyond(base, reference))
-  );
-  return counts.some((count) => count > 0);
-}
-async function is_held_dirty(name, lane) {
-  if (lane?.branch !== name || lane.is_stranded) return false;
-  return await run_hold.is_tree_dirty(lane.directory);
-}
-async function read_candidate(name, references, context) {
-  const state = await read_pr_of_branch(name);
-  if (state.pr_state !== NO_PR || await has_commits_beyond(context.base, references)) return state;
-  return await is_held_dirty(name, context.lane) ? state : void 0;
-}
-async function read_child_state(issue) {
-  const candidates = await read_branch_candidates(issue);
-  if (candidates.size === 0) return NO_CHILD_WORK;
-  const [base, lane] = await Promise.all([
-    git_command.default_branch_reference(),
-    lane_registry.find_open_lane(issue)
-  ]);
-  const reads = await Promise.all(
-    [...candidates].map(
-      async ([name, references]) => await read_candidate(name, references, { base, lane })
-    )
-  );
-  return pick_child_state(reads.filter((read3) => read3 !== void 0));
-}
-async function check3(issue) {
-  require_issue_number(issue);
-  const tree = await read_tree_state();
-  if (needs_reclaim(tree)) return decide6(tree, NO_CHILD_WORK, issue);
-  return decide6(tree, await read_child_state(issue), issue);
-}
-var run_preflight = {
-  CLEAN_VERDICT,
-  RESUME_ADVICE,
-  MERGED_PR,
-  STASH_LABEL_PREFIX,
-  check: check3,
-  decide: decide6,
-  read_child_state,
-  read_pr_state,
-  to_pr_state
-};
-
 // scripts/run/progress/run-progress-read.ts
 var { mark: mark2, parse_stamp: parse_stamp2, read_last_report: read_last_report2 } = run_progress_clock;
 var FIRST_LOAD_AVERAGE = 0;
@@ -6789,10 +5856,10 @@ async function to_child(issue) {
   return { issue: number, title: issue.title, labels: to_labels(issue), pr_state: child.pr_state };
 }
 async function read_children(repo) {
-  const read3 = await epic_busy.read_repository(repo);
-  if (read3.kind === "idle") return [];
-  if (read3.kind !== "busy") return void 0;
-  return await Promise.all(read3.issues.map(async (issue) => await to_child(issue)));
+  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();
@@ -6806,11 +5873,11 @@ function read_record_age(paths, now_ms) {
   if (times.length === 0) return void 0;
   return now_ms - Math.max(...times);
 }
-function is_hold_present(read3) {
-  return read3.kind === "held" || read3.kind === "stale";
+function is_hold_present(read2) {
+  return read2.kind === "held" || read2.kind === "stale";
 }
-function is_carry_present(read3) {
-  return read3.kind === "carried";
+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)));
@@ -6854,21 +5921,21 @@ var run_progress_read = {
 };
 
 // scripts/run/run-watcher-hook.ts
-import { z as z19 } from "zod";
+import { z as z13 } from "zod";
 
 // scripts/run/run-watcher-guard.ts
 var WATCHER_TICK_MS = 3e4;
 var TICK_MULTIPLIER = 3;
-var MS_PER_SECOND3 = 1e3;
+var MS_PER_SECOND2 = 1e3;
 var STALE_THRESHOLD_MS = WATCHER_TICK_MS * TICK_MULTIPLIER;
-var STALE_THRESHOLD_S = STALE_THRESHOLD_MS / MS_PER_SECOND3;
+var STALE_THRESHOLD_S = STALE_THRESHOLD_MS / MS_PER_SECOND2;
 var STALE_NOTE = `Lane children are in-flight but the progress watcher has not pinged in the last ${String(STALE_THRESHOLD_S)}s \u2014 run \`pnpm josh run:progress --wait\` in the background before proceeding. It reports to the run event stream on its own and exits only when newly runnable work arrives, so start it once and relay nothing`;
 var OK_RESULT = { kind: "ok" };
 async function owes_watcher() {
   if (run_headless.is_headless() || !await run_headless.is_backlog_parent()) return false;
   return await lane_registry.has_lanes_in_flight();
 }
-async function check4(life_target) {
+async function check2(life_target) {
   if (!await owes_watcher() || run_progress_clock.is_life_fresh(life_target, STALE_THRESHOLD_MS)) {
     return OK_RESULT;
   }
@@ -6877,13 +5944,13 @@ async function check4(life_target) {
 var run_watcher_guard = {
   STALE_NOTE,
   STALE_THRESHOLD_MS,
-  check: check4
+  check: check2
 };
 
 // scripts/run/run-watcher-hook.ts
 var SWITCH_ENV_KEY2 = "JOSH_WATCHER_GUARD";
 var STAMP_PREFIX2 = "josh-watcher-guard-";
-var payload_schema = z19.object({ transcript_path: z19.string().min(1) });
+var payload_schema = z13.object({ transcript_path: z13.string().min(1) });
 function transcript_of(raw_payload) {
   return json_value.parse_with(raw_payload, payload_schema)?.transcript_path;
 }
@@ -6913,7 +5980,7 @@ var run_watcher_hook = { transcript_of, watcher_hook_reason };
 var SWITCH_ENV_KEY3 = "JOSH_PARENT_CUT_GUARD";
 var STAMP_PREFIX3 = "josh-parent-cut-guard-";
 var QUIET_WINDOW_MS = 6e5;
-function current_state3() {
+function current_state2() {
   return {
     carry: async () => await run_headless.driving_carry(),
     verdict: () => implementation_cut_verdict.reused_verdict(() => cost_cli.session_verdict())
@@ -6947,7 +6014,7 @@ function is_unit_call(raw_payload) {
 function is_exempt2(raw_payload) {
   return !hook_decision.is_switch_enabled(SWITCH_ENV_KEY3) || is_unit_call(raw_payload);
 }
-async function parent_cut_reason(raw_payload, now_ms = Date.now(), state = current_state3()) {
+async function parent_cut_reason(raw_payload, now_ms = Date.now(), state = current_state2()) {
   if (is_exempt2(raw_payload)) return void 0;
   const transcript = run_watcher_hook.transcript_of(raw_payload);
   if (transcript === void 0) return void 0;
@@ -6960,8 +6027,95 @@ var run_parent_cut_hook = {
   parent_cut_reason
 };
 
+// scripts/run/run-poll-hook.ts
+var SWITCH_ENV_KEY4 = "JOSH_POLL_GUARD";
+var BASH_TOOL = "Bash";
+var STATE_READS = /* @__PURE__ */ new Set([
+  "josh lane:list",
+  "josh lane:output",
+  "josh run:board",
+  "josh run:carry",
+  "josh run:liveness",
+  "josh run:progress",
+  "josh run:wake"
+]);
+var POLL_REASON = '\u26D4 poll: this `backlogrun` session repeats a state read with nothing decided in between, on every occurrence. Wait on `pnpm josh backlog:drive`, or `pnpm josh lane:await <N...> --owner "$PPID"` in the background, and end the turn; its exit is the wake.';
+var WRITING_FLAGS = /* @__PURE__ */ new Set([
+  "--begin",
+  "--cut",
+  "--done",
+  "--end",
+  "--every",
+  "--filed",
+  "--loop",
+  "--mark",
+  "--merged",
+  "--resume",
+  "--retrospective",
+  "--start",
+  "--stop",
+  "--wait"
+]);
+var FLAG_PREFIX4 = "-";
+var NAME_WORDS = 2;
+var SIGNATURE_SEPARATOR = " ";
+function read_key(signature) {
+  const words = signature.split(SIGNATURE_SEPARATOR);
+  const name = words.slice(0, NAME_WORDS).join(SIGNATURE_SEPARATOR);
+  if (!STATE_READS.has(name) || words.some((word) => WRITING_FLAGS.has(word))) return void 0;
+  return words.filter((word) => !word.startsWith(FLAG_PREFIX4)).join(SIGNATURE_SEPARATOR);
+}
+function read_keys(signatures) {
+  return signatures.map((signature) => read_key(signature)).filter((key) => key !== void 0);
+}
+function state_reads_of(command) {
+  return read_keys(time_shell.josh_signatures_of(command));
+}
+function command_of(input) {
+  if (typeof input !== "object" || input === null || !("command" in input)) return "";
+  return typeof input.command === "string" ? input.command : "";
+}
+function candidate_reads(raw_payload) {
+  const payload = hook_decision.parse_hook_payload(raw_payload);
+  if (payload?.tool_name !== BASH_TOOL || (payload.agent_id ?? "") !== "") return [];
+  return state_reads_of(command_of(payload.tool_input));
+}
+function last_step(tail) {
+  return time_spans.parse_timeline(tail).spans.findLast((span) => span.category !== time_spans.MODEL_CATEGORY);
+}
+function repeats_last_call(tail, reads) {
+  const last = last_step(tail);
+  if (last?.category !== time_spans.TOOL_CATEGORY) return false;
+  const last_reads = read_keys(last.josh_signatures);
+  return reads.some((key) => last_reads.includes(key));
+}
+function is_repeat(raw_payload) {
+  const reads = hook_decision.is_switch_enabled(SWITCH_ENV_KEY4) ? candidate_reads(raw_payload) : [];
+  const transcript = reads.length === 0 ? void 0 : run_watcher_hook.transcript_of(raw_payload);
+  if (transcript === void 0) return false;
+  return repeats_last_call(time_density_hook.read_tail(transcript), reads);
+}
+async function poll_reason(raw_payload, is_parent = run_headless.is_backlog_parent) {
+  if (!is_repeat(raw_payload)) return void 0;
+  return await is_parent() ? POLL_REASON : void 0;
+}
+async function safe_poll_reason(raw_payload) {
+  try {
+    return await poll_reason(raw_payload);
+  } catch (error) {
+    error_text.trace_swallowed("run_poll_hook.poll_reason", error);
+    return void 0;
+  }
+}
+var run_poll_hook = {
+  POLL_REASON,
+  SWITCH_ENV_KEY: SWITCH_ENV_KEY4,
+  poll_reason,
+  safe_poll_reason
+};
+
 // scripts/hooks/step-zero-notice.ts
-import path15 from "node:path";
+import path12 from "node:path";
 var STAMP_PREFIX4 = "josh-step-zero-notice-";
 var EDIT_TOOLS3 = /* @__PURE__ */ new Set(["Edit", "Write"]);
 var PARENT_PREFIX = "..";
@@ -6976,9 +6130,9 @@ function edited_paths(tool_input) {
   );
 }
 function is_runtime_file(file_path, root) {
-  const relative = path15.relative(root, path15.resolve(root, file_path));
-  if (relative.startsWith(PARENT_PREFIX) || path15.isAbsolute(relative)) return false;
-  return !test_declared_logic.is_exempt(relative.split(path15.sep).join("/"));
+  const relative = path12.relative(root, path12.resolve(root, file_path));
+  if (relative.startsWith(PARENT_PREFIX) || path12.isAbsolute(relative)) return false;
+  return !test_declared_logic.is_exempt(relative.split(path12.sep).join("/"));
 }
 function is_candidate2(raw_payload, root) {
   const payload = hook_decision.parse_hook_payload(raw_payload);
@@ -7031,7 +6185,8 @@ async function mark_phase(outcome) {
 async function async_reason(raw_payload) {
   const watcher = await run_watcher_hook.watcher_hook_reason(raw_payload);
   const cut = watcher ?? await run_parent_cut_hook.parent_cut_reason(raw_payload);
-  return cut ?? await issue_watch_hook.watch_reason();
+  const poll2 = cut ?? await run_poll_hook.safe_poll_reason(raw_payload);
+  return poll2 ?? await issue_watch_hook.watch_reason();
 }
 async function pretool_outcome_async(raw_payload) {
   const base = guard_outcome(raw_payload);
@@ -7063,38 +6218,26 @@ function foreground_rewrite(outcome, raw_payload, is_lane_child) {
     rewrite_context(lane_background.FOREGROUND_NOTE, outcome)
   );
 }
-function pipefail_rewrite(raw_payload) {
-  if (!delivered_rules.is_enabled()) return void 0;
-  const call = guarded_call(raw_payload);
-  const input = call === void 0 ? void 0 : piped_verification.pipefail_input(call);
-  const payload = json_value.parse_or_undefined(raw_payload);
-  if (input === void 0 || !json_value.is_record(payload)) return void 0;
-  return { payload: JSON.stringify({ ...payload, tool_input: input }), input };
-}
-function pipefail_envelope(outcome, input) {
-  if (input === void 0 || outcome.reason !== void 0) return void 0;
-  return hook_decision.flow_rewrite_envelope(
-    input,
-    rewrite_context(piped_verification.PIPEFAIL_NOTE, outcome)
-  );
+function rule_envelope(outcome, rewrite3) {
+  if (rewrite3 === void 0 || outcome.reason !== void 0) return void 0;
+  return hook_decision.flow_rewrite_envelope(rewrite3.input, rewrite_context(rewrite3.note, outcome));
 }
-function emit(raw_payload, outcome, pipefail_input2) {
-  const rewrite = pipefail_envelope(outcome, pipefail_input2) ?? foreground_rewrite(outcome, raw_payload);
-  if (rewrite === void 0) hook_decision.emit_outcome(outcome);
-  else process.stdout.write(`${rewrite}
+function emit(raw_payload, outcome, rewrite3) {
+  const envelope = rule_envelope(outcome, rewrite3) ?? foreground_rewrite(outcome, raw_payload);
+  if (envelope === void 0) hook_decision.emit_outcome(outcome);
+  else process.stdout.write(`${envelope}
 `);
 }
 async function respond(raw_payload) {
-  const pipefail = pipefail_rewrite(raw_payload);
-  const judged = pipefail?.payload ?? raw_payload;
-  emit(judged, await pretool_outcome_async(judged), pipefail?.input);
+  const rewrite3 = rule_rewrite.rewrite(raw_payload);
+  const judged = rewrite3?.payload ?? raw_payload;
+  emit(judged, await pretool_outcome_async(judged), rewrite3);
 }
 var pretool_guard = {
   combine_outcomes,
   emit,
   foreground_rewrite,
   mark_phase,
-  pipefail_rewrite,
   pretool_outcome,
   respond
 };