@joshuafolkken/kit 1.1784.0 → 1.2114.0

package/dist/hooks/{chunk-CWMBGKYW.js → chunk-5PM2JRGV.js}

@@ -16,22 +16,30 @@ import {
   read_string,
   string_array_schema,
   string_record_schema,
+  time_batch_guard,
+  time_bundle_call,
   time_density_hook,
   time_hook_transcript,
+  time_search_call,
   time_shell,
+  time_spans,
   time_transcript_line,
   transcript_record,
   vscode_settings_schema
-} from "./chunk-PT5R6UJD.js";
+} from "./chunk-Z6DQJKH3.js";
 import {
   BLOCKED_BY_COUNT_FIELD,
   BLOCKED_BY_FIELD,
   FULL_PAGE_QUERY,
   agent_role_profile,
   agent_session_role,
+  changed_paths,
   detached_launch,
   distributed_paths,
+  document_section,
+  find_package_directory,
   forget_pr_numbers,
+  gh_author_association,
   gh_failure,
   git_gh_api_path,
   git_gh_conditional,
@@ -49,24 +57,24 @@ import {
   parse_json_object_or_undefined,
   read_blocked_by,
   read_json_listing,
+  read_listed_pull,
   read_pull,
+  read_pull_or_listed,
   require_pr_number,
   run_hold,
   session_language,
   stamp_record,
   to_gh_state
-} from "./chunk-YCDOIR3I.js";
+} from "./chunk-3GKE653K.js";
 import {
-  GIT_LOCATION_VARIABLES,
   PACKAGE_JSON,
   ancestor_directories,
   cli_flags,
   cost_transcript,
   cost_usage,
+  durable_state,
   file_reader,
-  git_command,
-  git_common_directory,
-  git_spawn_sync,
+  issue_citation,
   issue_cite,
   issue_number_shape,
   json_value,
@@ -76,15 +84,17 @@ import {
   own_session,
   package_manifest,
   process_identity,
-  repo_discovery,
-  repo_origin,
   run_carry,
   run_event_stream,
   run_event_stream_emit,
   run_ship_stage,
   session_cite
-} from "./chunk-WR2KQAYZ.js";
+} from "./chunk-7SIUNQXK.js";
 import {
+  session_owner_pin
+} from "./chunk-VVNYJWEI.js";
+import {
+  GIT_LOCATION_VARIABLES,
   MS_PER_MINUTE,
   MS_PER_SECOND,
   PACKAGE_DIR,
@@ -92,9 +102,16 @@ import {
   PROBE_TIMEOUT_MS,
   PROJECT_ROOT,
   error_text,
+  git_command,
+  git_common_directory,
+  git_diff_reads,
+  git_location_environment,
+  git_spawn_sync,
   package_path,
+  repo_discovery,
+  repo_origin,
   stamp_file
-} from "./chunk-AZX4FGQ3.js";
+} from "./chunk-45CJJOO7.js";
 
 // scripts/josh/hook-decision.ts
 import { text } from "node:stream/consumers";
@@ -186,10 +203,10 @@ function record_refusal(target, now_ms) {
   }
 }
 function create_refusal_stamp(prefix) {
-  function path15(transcript_path) {
+  function path19(transcript_path) {
     return stamp_file.stamp_path(prefix, transcript_path);
   }
-  return { path: path15, last_ms: last_refusal_ms, record: record_refusal };
+  return { path: path19, last_ms: last_refusal_ms, record: record_refusal };
 }
 var { load_environment_file } = josh_environment_file;
 var NO_OUTCOME = { reason: void 0, notice: void 0, fault: void 0 };
@@ -245,10 +262,10 @@ function create_transcript_guard(spec) {
   const stamp = create_refusal_stamp(spec.prefix);
   const notify_stamp = spec.notify ? create_refusal_stamp(spec.notify.prefix) : void 0;
   const parts = { spec, stamp, notify_stamp };
-  function is_enabled() {
+  function is_enabled3() {
     return is_switch_enabled(spec.switch_key);
   }
-  function refusal_path(transcript_path) {
+  function refusal_path2(transcript_path) {
     return stamp.path(transcript_path);
   }
   function outcome(raw_payload, now_ms = Date.now()) {
@@ -261,7 +278,7 @@ function create_transcript_guard(spec) {
   function refusal(raw_payload, now_ms = Date.now()) {
     return outcome(raw_payload, now_ms).reason;
   }
-  return { is_enabled, outcome, refusal, refusal_path };
+  return { is_enabled: is_enabled3, outcome, refusal, refusal_path: refusal_path2 };
 }
 function emit_outcome(outcome) {
   const { reason, notice, fault } = outcome;
@@ -356,273 +373,119 @@ async function bounded_map(items, limit, worker) {
 }
 var bounded_pool = { bounded_map, pool_width };
 
-// scripts/rules/tail-commands.ts
-function is_bash_use(block) {
-  return block.type === cost_blocks.TOOL_USE_TYPE && block.name === cost_blocks.BASH_TOOL;
-}
-function bash_commands_of(line) {
-  const parsed = time_transcript_line.parse_line(line);
-  if (parsed === void 0) return [];
-  return parsed.blocks.filter((block) => is_bash_use(block)).map((block) => time_shell.bash_command(block.input));
-}
-function prior_bash_commands(tail) {
-  return tail.split("\n").flatMap((line) => bash_commands_of(line));
-}
-function answered(text2, is_call, token) {
-  const blocks = time_transcript_line.parse_text(text2).flatMap((line) => line.blocks);
-  const call_ids = new Set(
-    blocks.filter((block) => is_call(time_shell.bash_command(block.input))).map((block) => block.id)
-  );
-  return blocks.some((block) => call_ids.has(block.result_id) && block.token_lines.includes(token));
-}
-var tail_commands = { answered, is_bash_use, prior_bash_commands };
+// scripts/rules/stop-decision.ts
+var RECOMMENDED_LABEL = /^recommended[*_]*:/iu;
+var ALTERNATIVE_LABEL = /^alternative[*_]*:/iu;
+var LEADING_EMPHASIS = /^[*_]+/u;
+var TRAILING_EMPHASIS = /(?<![*_])[*_]+$/u;
+var BULLET = /^[-*]\s+/u;
+var QUESTION_ENDING = /(?:[?？]|か|かな|かね)[\s。.]*$/u;
+function unwrapped(text2) {
+  return text2.trim().replace(LEADING_EMPHASIS, "").replace(TRAILING_EMPHASIS, "").trim();
+}
+function bare_line(line) {
+  return unwrapped(line.trim().replace(BULLET, ""));
+}
+function choice_of(message, label) {
+  const line = message.split("\n").map((one) => bare_line(one)).find((one) => label.test(one));
+  const choice = line === void 0 ? void 0 : unwrapped(line.replace(label, ""));
+  return choice === "" ? void 0 : choice;
+}
+function decision_of(message) {
+  const recommended = choice_of(message, RECOMMENDED_LABEL);
+  if (recommended === void 0) return void 0;
+  return { recommended, alternative: choice_of(message, ALTERNATIVE_LABEL) };
+}
+function is_question(prompt) {
+  return QUESTION_ENDING.test(prompt.trim());
+}
+var DECISION_REASON = "\u26D4 stop decision: this working tree is held by your run and your reply names no decision. If the run waits on a person, end the reply with a `Recommended: <choice>` line and, where there is one, an `Alternative: <choice>` line \u2014 the hook sends the `confirmation` Telegram from them. If it waits on nobody, continue the run, or say in one line that nothing is awaited. Do not repeat your previous reply.";
+var stop_decision = { DECISION_REASON, decision_of, is_question };
 
-// scripts/rules/git-argv.ts
-var ENV_ASSIGNMENT = /^[A-Za-z_]\w*=/u;
-var WRAPPER_WORDS = /* @__PURE__ */ new Set([
-  "pnpm",
-  "npx",
-  "exec",
-  "run",
-  "sudo",
-  "command",
-  "env",
-  "time"
-]);
-var FLAGGED_WRAPPERS = /* @__PURE__ */ new Set(["time"]);
-var WRAPPER_VALUE_FLAGS = /* @__PURE__ */ new Set(["-o", "-f", "--output", "--format"]);
-var SUBSHELL_OPEN = "(";
-var VALUE_TAKING_GLOBALS = /* @__PURE__ */ new Set([
-  "-C",
-  "-c",
-  "--git-dir",
-  "--work-tree",
-  "--namespace",
-  "--exec-path",
-  "--super-prefix"
-]);
-var FLAG_PREFIX = "-";
-var GIT_COMMAND = "git";
-var NEXT = 1;
-var AFTER_VALUE = 2;
-var WORD = /(?:\\.|'[^']*'|"(?:\\.|[^"\\])*"|\S)+/gsu;
-function words_of(segment) {
-  return segment.match(WORD) ?? [];
-}
-var PATH_SEPARATOR = "/";
-function program_name(word) {
-  return word.slice(word.lastIndexOf(PATH_SEPARATOR) + NEXT);
-}
-function is_wrapper_token(word) {
-  return word === SUBSHELL_OPEN || ENV_ASSIGNMENT.test(word) || WRAPPER_WORDS.has(program_name(word));
-}
-function wrapper_flag_width(word = "") {
-  if (!word.startsWith(FLAG_PREFIX)) return 0;
-  return WRAPPER_VALUE_FLAGS.has(word) ? AFTER_VALUE : NEXT;
-}
-function after_wrapper_word(words, index) {
-  let next = index + NEXT;
-  if (!FLAGGED_WRAPPERS.has(program_name(words[index] ?? ""))) return next;
-  let width = wrapper_flag_width(words[next]);
-  while (width > 0) {
-    next += width;
-    width = wrapper_flag_width(words[next]);
-  }
-  return next;
-}
-function after_wrapper(words) {
-  let index = 0;
-  while (index < words.length && is_wrapper_token(words[index] ?? "")) {
-    index = after_wrapper_word(words, index);
-  }
-  return index;
+// scripts/discovery/repo-party.ts
+var FIRST_PARTY = "first-party";
+var THIRD_PARTY = "third-party";
+var UNKNOWN = "unknown";
+var GH_REPO_ENV_KEY = "GH_REPO";
+var GH_REPO_PATH_SEGMENTS = 2;
+function classify(session_owner, target) {
+  if (session_owner === void 0 || target === void 0) return UNKNOWN;
+  return session_owner.toLowerCase() === target.toLowerCase() ? FIRST_PARTY : THIRD_PARTY;
 }
-function global_step(flag) {
-  return VALUE_TAKING_GLOBALS.has(flag) ? AFTER_VALUE : NEXT;
+function parse_owner_repo(owner_repo) {
+  return repo_origin.parse_origin_url(`https://${repo_origin.GITHUB_HOST}/${owner_repo}`);
 }
-function after_globals(words, start) {
-  let index = start;
-  while (index < words.length) {
-    const flag = words[index] ?? "";
-    if (!flag.startsWith(FLAG_PREFIX)) return index;
-    index += global_step(flag);
-  }
-  return index;
+function target_owner(owner_repo) {
+  return parse_owner_repo(owner_repo)?.owner;
 }
-function program_of(segment) {
-  const words = words_of(segment);
-  const command_index = after_wrapper(words);
-  const word = words[command_index];
-  if (word === void 0) return void 0;
-  return { name: program_name(word), args: words.slice(command_index + NEXT) };
+function current_owner(repository_path = process.cwd()) {
+  return session_owner_pin.pinned(repository_path) ?? repo_discovery.resolve_current_owner(repository_path);
 }
-function arguments_of(segment, command) {
-  const call = program_of(segment);
-  return call?.name === command ? call.args : void 0;
+function selector_repository(selector) {
+  return parse_owner_repo(selector.split("/").slice(-GH_REPO_PATH_SEGMENTS).join("/"));
 }
-function parse(segment) {
-  const words = arguments_of(segment, GIT_COMMAND);
-  if (words === void 0) return void 0;
-  const subcommand_index = after_globals(words, 0);
-  return { subcommand: words[subcommand_index], args: words.slice(subcommand_index + NEXT) };
+function selector_owner(selector) {
+  return selector_repository(selector)?.owner;
 }
-var SHORT_CLUSTER = /^-[A-Za-z]+$/u;
-function short_cluster_has(token, letters) {
-  if (!SHORT_CLUSTER.test(token)) return false;
-  const cluster = token.slice(FLAG_PREFIX.length);
-  for (let index = 0; index < letters.length; index += 1) {
-    if (cluster.includes(letters.charAt(index))) return true;
-  }
-  return false;
+function remote_repositories(repository_path) {
+  return repo_discovery.read_remote_urls(repository_path).map((url) => repo_origin.parse_origin_url(url));
 }
-var git_argv = { arguments_of, parse, program_of, short_cluster_has };
-
-// scripts/rules/shell-segments.ts
-var SEGMENT_SEPARATOR = /&&|\|\||;|\n/u;
-var SEGMENT_PARTS = new RegExp(`(${SEGMENT_SEPARATOR.source})`, "u");
-var COMMAND_SEPARATOR = /&&|\|\||;|\n|\|&?|(?<![<>])&(?!>)/u;
-function segments_of(command) {
-  return command.split(SEGMENT_SEPARATOR).map((segment) => segment.trim());
+function placeholder_repositories(repository_path, environment) {
+  const gh_repo = environment[GH_REPO_ENV_KEY];
+  return gh_repo === void 0 || gh_repo === "" ? remote_repositories(repository_path) : [selector_repository(gh_repo)];
 }
-function commands_of(command) {
-  return command.split(COMMAND_SEPARATOR).map((segment) => segment.trim());
+function placeholder_owners(repository_path = process.cwd(), environment = process.env) {
+  return placeholder_repositories(repository_path, environment).map((identity) => identity?.owner);
 }
-var COMMAND_SEPARATORS = new RegExp(COMMAND_SEPARATOR.source, "gu");
-function quote_aware_commands_of(command) {
-  const plain = time_shell.blanked(command);
-  if (plain === void 0) return commands_of(command);
-  const cuts = [...plain.matchAll(COMMAND_SEPARATORS)].map((match) => ({
-    begin: match.index,
-    end: match.index + match[0].length
-  }));
-  const starts = [0, ...cuts.map((cut) => cut.end)];
-  const stops = cuts.map((cut) => cut.begin);
-  return starts.map((start, index) => command.slice(start, stops[index] ?? command.length).trim());
+function is_same_repository(left, right) {
+  if (left === void 0 || classify(left.owner, right.owner) !== FIRST_PARTY) return false;
+  return left.repo.toLowerCase() === right.repo.toLowerCase();
 }
-function parts_of(command) {
-  return command.split(SEGMENT_PARTS);
+function sole_repository(candidates) {
+  const [first, ...rest] = candidates;
+  if (first === void 0) return void 0;
+  return rest.every((candidate) => is_same_repository(candidate, first)) ? first : void 0;
 }
-function first_of(command) {
-  const plain = time_shell.blanked(command);
-  if (plain === void 0) return void 0;
-  const cut = plain.search(SEGMENT_SEPARATOR);
-  return (cut === -1 ? command : command.slice(0, cut)).trim();
+function current_repository(repository_path = process.cwd(), environment = process.env) {
+  return sole_repository(placeholder_repositories(repository_path, environment));
 }
-function is_josh_command(segment, names) {
-  const named = time_shell.josh_command_of(segment);
-  if (!named.startsWith(time_shell.JOSH_PREFIX)) return false;
-  return names.has(named.slice(time_shell.JOSH_PREFIX.length));
+function is_own_repository(target, own) {
+  return is_same_repository(own, target);
 }
-var shell_segments = {
-  commands_of,
-  first_of,
-  is_josh_command,
-  parts_of,
-  quote_aware_commands_of,
-  segments_of
+var repo_party = {
+  FIRST_PARTY,
+  THIRD_PARTY,
+  UNKNOWN,
+  classify,
+  current_owner,
+  current_repository,
+  is_own_repository,
+  placeholder_owners,
+  selector_owner,
+  sole_repository,
+  target_owner
 };
 
-// scripts/rules/bash-triggers.ts
-function on_bash_command(is_match) {
-  return function is_trigger(call) {
-    if (call.name !== cost_blocks.BASH_TOOL) return false;
-    return is_match(time_shell.bash_command(call.input));
-  };
-}
-var ISSUE_CREATE_COMMAND = /\bgh\s+(?:\S+\s+)*?issue\s+create\b/u;
-var ISSUES_ENDPOINT = /repos\/[^\s'"]*\/issues(?=$|["'\s])/u;
-var TITLE_FIELD = /(?:-f|-F|--field|--raw-field)\s*'?title=/u;
-var GH_API_COMMAND = /\bgh\s+api\b/u;
-var SHELL_SCRIPT_RUNNER = /\b(?:(?:ba|z|da|k)?sh\s+(?:-\w+\s+)*-\w*c\b|eval\b)/u;
-function spoken_line(command) {
-  if (time_shell.has_heredoc(command)) return command;
-  const plain = time_shell.unquoted(command);
-  return SHELL_SCRIPT_RUNNER.test(plain) ? command : plain;
-}
-var LEADING_SHELL_SCRIPT_RUNNER = new RegExp(`^${SHELL_SCRIPT_RUNNER.source}`, "u");
-var QUOTE_MARK = /["']/gu;
-function shell_script_of(segment) {
-  const call = git_argv.program_of(segment);
-  if (call === void 0) return void 0;
-  const spoken = [call.name, ...call.args].join(" ");
-  const runner = LEADING_SHELL_SCRIPT_RUNNER.exec(spoken);
-  if (runner === null) return void 0;
-  return spoken.slice(runner[0].length).replaceAll(QUOTE_MARK, "").trim();
-}
-function is_direct_filing(command) {
-  const spoken = spoken_line(command);
-  if (ISSUE_CREATE_COMMAND.test(spoken)) return true;
-  return GH_API_COMMAND.test(spoken) && ISSUES_ENDPOINT.test(command) && TITLE_FIELD.test(command);
-}
-var FILING_NAMES = /* @__PURE__ */ new Set(["issue:file"]);
-function is_issue_filing(command) {
-  return shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, FILING_NAMES));
-}
-var bash_triggers = { is_direct_filing, is_issue_filing, on_bash_command, shell_script_of };
-
-// scripts/rules/filing-cap.ts
-var FILING_CAP = 10;
-var CAP_REACHED = FILING_CAP;
-function is_filing_use(block) {
-  if (!tail_commands.is_bash_use(block)) return false;
-  return bash_triggers.is_issue_filing(time_shell.bash_command(block.input));
-}
-function collect_block(block, found) {
-  if (block.result_id !== "" && block.is_error === true) found.failures.add(block.result_id);
-  if (is_filing_use(block)) found.filing_ids.push(block.id);
-}
-function collect_line(line, found) {
-  const parsed = time_transcript_line.parse_line(line);
-  if (parsed === void 0) return;
-  for (const block of parsed.blocks) collect_block(block, found);
-}
-function scan_tail(tail) {
-  const found = { filing_ids: [], failures: /* @__PURE__ */ new Set() };
-  for (const line of tail.split("\n")) collect_line(line, found);
-  return found;
-}
-function prior_filing_count(tail) {
-  const { filing_ids, failures } = scan_tail(tail);
-  return filing_ids.filter((id) => !failures.has(id)).length;
+// scripts/rules/tail-commands.ts
+function is_bash_use(block) {
+  return block.type === cost_blocks.TOOL_USE_TYPE && block.name === cost_blocks.BASH_TOOL;
 }
-function is_prompt_line(line) {
+function bash_commands_of(line) {
   const parsed = time_transcript_line.parse_line(line);
-  if (parsed?.type !== "user") return false;
-  return parsed.blocks.every((block) => block.result_id === "");
-}
-function current_turn(tail) {
-  const lines = tail.split("\n");
-  const start = lines.findLastIndex((line) => is_prompt_line(line));
-  return lines.slice(Math.max(start, 0)).join("\n");
+  if (parsed === void 0) return [];
+  return parsed.blocks.filter((block) => is_bash_use(block)).map((block) => time_shell.bash_command(block.input));
 }
-function turn_filing_count(tail) {
-  return prior_filing_count(current_turn(tail));
+function prior_bash_commands(tail) {
+  return tail.split("\n").flatMap((line) => bash_commands_of(line));
 }
-function decide(_call, run2) {
-  return prior_filing_count(time_density_hook.read_tail(run2.transcript)) >= CAP_REACHED;
+function answered(text2, is_call, token) {
+  const blocks = time_transcript_line.parse_text(text2).flatMap((line) => line.blocks);
+  const call_ids = new Set(
+    blocks.filter((block) => is_call(time_shell.bash_command(block.input))).map((block) => block.id)
+  );
+  return blocks.some((block) => call_ids.has(block.result_id) && block.token_lines.includes(token));
 }
-var FILING_CAP_REASON = `\u26D4 filing cap: this run has already filed ${String(FILING_CAP)} Issues, the per-run ceiling. Stop filing and report; a further Issue is a person's call. It fires on every occurrence (\`.claude/skills/workflow-commands/observation-filing.md\`).`;
-var ROW = {
-  id: "filing-cap",
-  is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
-  reason: FILING_CAP_REASON,
-  decide,
-  about: {
-    title: "The 10-Issue filing cap per run",
-    topic: "`.claude/skills/workflow-commands/prerequisite.md`, `observation-filing.md`",
-    fires: "the 11th `pnpm josh issue:file` in a run that already has 10 filings not refused; failed calls do not count. Every occurrence",
-    quiet: "fewer than 10 filings not refused"
-  }
-};
-var filing_cap = {
-  FILING_CAP,
-  FILING_CAP_REASON,
-  ROW,
-  current_turn,
-  is_prompt_line,
-  prior_filing_count,
-  turn_filing_count
-};
+var tail_commands = { answered, is_bash_use, prior_bash_commands };
 
 // scripts/backlog/backlog-budget.ts
 var MINUTES_PER_HOUR = 60;
@@ -707,7 +570,7 @@ function answer_decision(input) {
   if (input.answer === "candidates") return { verdict: RUN_VERDICT, reason: run_reason(input) };
   return FIXED_DECISIONS[input.answer] ?? idle_decision(input);
 }
-function decide2(input) {
+function decide(input) {
   return max_decision(input) ?? answer_decision(input);
 }
 var backlog_budget = {
@@ -723,7 +586,7 @@ var backlog_budget = {
   TRIAGE_VERDICT,
   WAITING_ON,
   WATCH_VERDICT,
-  decide: decide2,
+  decide,
   draining_reason,
   idle_expired_reason,
   idle_watch_reason,
@@ -735,171 +598,660 @@ var backlog_budget = {
   taken_by
 };
 
-// scripts/cost-runtime/cost-pricing.ts
-var CACHE_WRITE_5M_MULTIPLIER = 1.25;
-var CACHE_WRITE_1H_MULTIPLIER = 2;
-var DEFAULT_CACHE_READ_MULTIPLIER = 0.1;
-var HALVED_CACHE_READ_MULTIPLIER = 0.05;
-var QUARTERED_CACHE_READ_MULTIPLIER = 0.025;
-var TOKENS_PER_MILLION = 1e6;
-var LONG_PROMPT_SUFFIX = ":long-prompt";
-var LONG_PROMPT_THRESHOLD = 1e5;
-var MODEL_PRICES = {
-  "claude-fable-5-1": {
-    input: 10,
-    output: 50,
-    cache_read_multiplier: QUARTERED_CACHE_READ_MULTIPLIER
+// scripts/run/cut/run-cut.ts
+import { z as z4 } from "zod";
+
+// scripts/run/cut/run-cut-digest.ts
+import path3 from "node:path";
+
+// scripts/delegation/duplicate-read-guard.ts
+import { statSync } from "node:fs";
+
+// scripts/lane/lane-guard-policy.ts
+var DEFAULT_MODE = "refuse";
+var OFF_MODE = "off";
+var LANE_GUARD_POLICY = [
+  {
+    id: "investigation",
+    mode_in_lane_child: "refuse",
+    because: "the notice was measured not to move the reading \u2014 52% of lane cost stayed in main-line exploration \u2014 and the refusal fires once per accumulation, a round trip the child survives as it survives the rule row, so the child is refused like the main line"
   },
-  "claude-mythos-5-1": {
-    input: 10,
-    output: 50,
-    cache_read_multiplier: QUARTERED_CACHE_READ_MULTIPLIER
+  {
+    id: "batching",
+    mode_in_lane_child: "off",
+    because: "a refusal ends a child turn and every advisory notice was measured not to move the call density, so the guard is off and the density stays readable through `josh time:density`"
   },
-  "claude-fable-5": { input: 10, output: 50 },
-  "claude-mythos-5": { input: 10, output: 50 },
-  "claude-opus-5-5": { input: 4, output: 20, cache_read_multiplier: HALVED_CACHE_READ_MULTIPLIER },
-  "claude-opus-5": { input: 5, output: 25 },
-  "claude-opus-4-8": { input: 5, output: 25 },
-  "claude-opus-4-7": { input: 5, output: 25 },
-  "claude-opus-4-6": { input: 5, output: 25 },
-  "claude-sonnet-5-5": {
-    input: 2,
-    output: 10,
-    cache_read_multiplier: HALVED_CACHE_READ_MULTIPLIER
+  {
+    id: "search-batching",
+    mode_in_lane_child: "refuse",
+    because: "the largest share of single-call pairs in lane children is a search chain (`grep` / `sed` issued one per turn, about 10,600 pairs in 14 days), and a refusal re-fires only every third single-call search turn, so one refused round trip (about $0.036) is repaid once it folds two later searches into one turn"
   },
-  "claude-sonnet-5": { input: 2, output: 10 },
-  "claude-sonnet-4-6": { input: 3, output: 15 },
-  "claude-haiku-5-5": { input: 0.1, output: 0.5 },
-  [`claude-haiku-5-5${LONG_PROMPT_SUFFIX}`]: { input: 0.5, output: 2.5 },
-  "claude-haiku-4-5": { input: 1, output: 5 }
+  {
+    id: "duplicate-read",
+    mode_in_lane_child: "notice",
+    because: "a refusal ends a child turn, yet unchanged re-reads are measured in lane children above all, so the child is nudged to scroll up to the earlier read by a notice rather than killed"
+  },
+  {
+    id: "rule",
+    mode_in_lane_child: "refuse",
+    because: "it carries the lane-only rules a child depends on (`pre-gate-cut`, `implementation-cut`, `lane-park`) and the safety rules it must still obey, and a notice was rejected despite the collateral a refusal costs a batched sibling, because a cut carried as prose was measured never to fire"
+  }
+];
+var KNOWN_GUARD_IDS = LANE_GUARD_POLICY.map((entry) => entry.id);
+function entry_for(id) {
+  return LANE_GUARD_POLICY.find((entry) => entry.id === id.trim());
+}
+function mode_in_lane_child(id) {
+  return entry_for(id)?.mode_in_lane_child ?? DEFAULT_MODE;
+}
+function mode_here(id, directory = process.cwd(), source = process.env) {
+  const lane_mode = mode_in_lane_child(id);
+  if (lane_mode === DEFAULT_MODE) return DEFAULT_MODE;
+  return lane_child_marker.is_child_of(directory, source) ? lane_mode : DEFAULT_MODE;
+}
+function is_suppressed_here(id, directory = process.cwd(), source = process.env) {
+  return mode_here(id, directory, source) === OFF_MODE;
+}
+var lane_guard_policy = {
+  LANE_GUARD_POLICY,
+  KNOWN_GUARD_IDS,
+  entry_for,
+  mode_in_lane_child,
+  mode_here,
+  is_suppressed_here
 };
-var CONTEXT_MARKER = "[";
-var DATE_SUFFIX = /-\d{8}$/u;
-function known_id(model) {
-  const base = model.split(CONTEXT_MARKER)[0] ?? model;
-  return [base, base.replace(DATE_SUFFIX, "")].find((id) => Object.hasOwn(MODEL_PRICES, id));
-}
-function resolve_price(model) {
-  const id = known_id(model);
-  return id === void 0 ? void 0 : MODEL_PRICES[id];
-}
-function cache_read_multiplier(price) {
-  return price.cache_read_multiplier ?? DEFAULT_CACHE_READ_MULTIPLIER;
+
+// scripts/delegation/investigation-reads.ts
+import path2 from "node:path";
+
+// scripts/document/capped-print-part.ts
+import path from "node:path";
+var DIRECTORY_PREFIX = "josh-capped-print-";
+var PART_PREFIX = "part-";
+var PART_SUFFIX = ".md";
+var PART_PATTERN = /^part-[1-9]\d*\.md$/u;
+function part_name(index) {
+  return `${PART_PREFIX}${String(index + 1)}${PART_SUFFIX}`;
+}
+function is_part_file(absolute) {
+  const parent = path.basename(path.dirname(absolute));
+  return parent.startsWith(DIRECTORY_PREFIX) && PART_PATTERN.test(path.basename(absolute));
+}
+var capped_print_part = { DIRECTORY_PREFIX, part_name, is_part_file };
+
+// scripts/git/changed-paths-sync.ts
+function options_of(cwd) {
+  if (cwd === void 0) return {};
+  return { cwd, env: git_location_environment.location_free_environment() };
+}
+function default_branch_reference(options) {
+  const output = git_spawn_sync.read([...git_diff_reads.DEFAULT_BRANCH_ARGUMENTS], options);
+  const default_branch = git_diff_reads.default_branch_of(output);
+  const remote_reference = git_diff_reads.remote_reference_of(default_branch);
+  const check2 = git_diff_reads.reference_check_arguments(remote_reference);
+  return git_spawn_sync.read(check2, options) === void 0 ? default_branch : remote_reference;
+}
+function through_merge(base, reference, options) {
+  const incoming = git_spawn_sync.read(git_diff_reads.incoming_base_arguments(reference), options);
+  if (incoming === void 0) return base;
+  const kept = git_spawn_sync.read(git_diff_reads.later_base_arguments(base, incoming), options);
+  return git_diff_reads.later_base_of(kept, base);
+}
+function change_base(options) {
+  const reference = default_branch_reference(options);
+  const base = git_spawn_sync.read(git_diff_reads.merge_base_arguments(reference), options);
+  if (base === void 0) return reference;
+  return through_merge(base, reference, options);
+}
+function read_changed_paths(cwd) {
+  const options = options_of(cwd);
+  const tracked = git_spawn_sync.read(
+    git_diff_reads.names_since_arguments(change_base(options)),
+    options
+  );
+  const untracked = git_spawn_sync.read(git_diff_reads.UNTRACKED_ARGUMENTS, options);
+  return [tracked, untracked].flatMap((raw = "") => changed_paths.to_paths(raw));
 }
-function estimate_cost(totals, price) {
-  const weighted_input = totals.input_tokens + totals.cache_write_5m_tokens * CACHE_WRITE_5M_MULTIPLIER + totals.cache_write_1h_tokens * CACHE_WRITE_1H_MULTIPLIER + totals.cache_read_tokens * cache_read_multiplier(price);
-  return (weighted_input * price.input + totals.output_tokens * price.output) / TOKENS_PER_MILLION;
+var changed_paths_sync = { read_changed_paths };
+
+// scripts/delegation/delegation-policy.ts
+var DELEGATE_VERDICT = "delegate";
+var KEEP_VERDICT = "keep";
+var INVESTIGATION_FILE_THRESHOLD = 3;
+var INVESTIGATION_SEARCH_TURN_THRESHOLD = 3;
+var INVESTIGATOR_AGENT = "investigator";
+var INVESTIGATION_LIMIT = `${String(INVESTIGATION_FILE_THRESHOLD)} files read and not edited, or ${String(INVESTIGATION_SEARCH_TURN_THRESHOLD)} search turns, since the last delegated unit`;
+var INVESTIGATION_STEP = `Dispatch the \`${INVESTIGATOR_AGENT}\` agent (\`kit:${INVESTIGATOR_AGENT}\` in a consumer) with \`run_in_background: false\`; it returns \`file:line\` citations, never the file text.`;
+var DELEGATABLE_STEPS = [
+  {
+    name: "gate-fix",
+    does: "apply the fixes the verification gate already named \u2014 a lint rule, a type error, a spelling the dictionary rejects",
+    verifier: "`pnpm josh gate` is re-run; a wrong fix fails it again, and the failure names the file"
+  },
+  {
+    name: "epic-child",
+    // One row, two entry points: an epic's child and one named issue of a `backlogrun` are the same
+    // unit — same brief, same summary, same verifier. A second row for the batch would be the clone
+    // `CLAUDE.md` prohibits.
+    does: "run one child of a batch end to end in an isolated unit \u2014 an epic's child or one named issue of a `backlogrun` alike \u2014 plan, verification gate, PR, merge \u2014 and return only its summary to the parent loop",
+    verifier: "the parent reads the child's state from GitHub with `pnpm josh issue:state`, not from the summary; a child reported done but not merged is still open, which is the failure showing rather than a run continuing, and its own gate, `/code-review` and CI ran inside the unit before `followup` would touch the PR"
+  },
+  {
+    name: "followup-filing",
+    // The late-run follow-up filing chain — `issue:file` (which scouts, lints, labels and runs
+    // epic:bundle itself) → epic --add — is a dependency chain the batching guard
+    // correctly keeps one call per step, and what makes it expensive is the ~340k context it runs in
+    // at the tail of a run, not the step count. A fresh unit runs the same
+    // chain at a small context, and the review round cap already composed the finding text, so what
+    // the unit is handed is mechanical: run the commands and act on their deterministic answers. This
+    // is not the batching guard's business — delegation only moves the chain to a cheaper context.
+    does: "run the late-run follow-up filing chain in an isolated unit \u2014 issue:file (lint, labels, scout, epic:bundle), then epic --add \u2014 given the finding text the parent already composed, and return the new Issue number and the epic:bundle answer",
+    verifier: "the parent reads the filed Issue from GitHub with `pnpm josh issue:state <new>`, not the unit's summary; a follow-up reported filed but not created is still absent, the way `epic-child`'s reported-done-but-not-merged child is still open. The finding text came from the parent and `issue:file`'s steps are deterministic, so the unit's work is the mechanical execution `issue:state` confirms"
+  },
+  {
+    name: "implementation-unit",
+    // The Step 0 change list already decided *what* to change — that design stays in the main line,
+    // which is why `design` is rejected below. What is delegated is the *writing* of one unit of that
+    // list, and only a unit whose files are disjoint from every other dispatched unit: two subagents
+    // editing one file in parallel race on it. `pnpm josh fanout` confirms that disjointness
+    // mechanically, so the split is read off the file sets rather than judged.
+    does: "implement one file-disjoint unit of the Step 0 change list in an isolated subagent \u2014 the files it edits shared with no other dispatched unit, confirmed by `pnpm josh fanout` \u2014 and return the edited files, never a summary standing in for the diff; the main line keeps integration and the verification gate. Units that share a file, or an Issue that will not split, stay serial",
+    verifier: "the parent runs the whole integrated change through `pnpm josh gate` and a `/code-review` subagent it would run anyway \u2014 a unit's mistake fails the same gate and review a serial edit passes through, so delegating writes nothing the backstop does not already catch, and the `pnpm josh fanout` disjointness removes the one failure parallelism adds, two units colliding on a file"
+  },
+  {
+    name: "survey",
+    does: "read across many files and report where something appears \u2014 every reference to a symbol, which documents carry a marker",
+    verifier: "the reported locations are checked directly; a fabricated or missed location does not survive one `grep` of what it claimed"
+  },
+  {
+    name: "investigation",
+    // Not `survey`: that row reports *where* something appears and is checked by one `grep`, while
+    // this one reports *how the subject works* and is checked by opening the lines it cited. The two
+    // verifiers differ, so widening `survey` would put both in one field and lose the boundary below.
+    // **No ordinal.** `${N}rd` would print `1rd` for any other threshold, past a test that only looks
+    // for the numeral, so the count is phrased as a plain "N or more".
+    does: `read the Issue's subject to find out how it currently works \u2014 once ${String(INVESTIGATION_FILE_THRESHOLD)} or more files the run will not edit have to be read, or ${String(INVESTIGATION_SEARCH_TURN_THRESHOLD)} or more search turns run without an edit \u2014 and return the conclusion plus the \`file:line\` citations that support it, never the file text, which would put the cost back where it was. A throwaway probe script is written, run and deleted inside the unit, which returns its output alone`,
+    verifier: "the parent opens the cited lines; a conclusion those lines do not support fails there, and reading a handful of cited regions costs far less than redoing the reading. The unit reports what the code does and never what to change \u2014 deciding that is `diagnosis`, which stays kept, so a unit returning a root cause would be delegating the rejected row under this name"
+  },
+  {
+    name: "lane-failure-investigation",
+    // The `backlogrun` parent's counterpart of `investigation`. The parent
+    // orchestrates and never implements, yet it read a failed lane's logs, records and sources in its
+    // own context — about 150 grep / cat / sed calls on 2026-10-02 — and every later request of the
+    // batch re-read them. The verifier is `investigation`'s, and so is the boundary: the unit reports
+    // what happened, and what the parent does about it (park, re-dispatch, file) stays its own call.
+    does: "find out why a lane's child stopped, failed or conflicted \u2014 its output log, run records, PR checks and the files they name \u2014 and return the conclusion plus the `file:line` or log-line citations that support it, never the text read, so the batch parent's context stays the size its orchestration needs",
+    verifier: "the parent opens the cited lines and re-reads the child with `pnpm josh issue:state`; a conclusion those do not support fails there. The unit reports what happened and never what to do \u2014 parking, re-dispatching or filing stays with the parent, so a wrong account is caught before it is acted on"
+  }
+];
+var REJECTED_STEPS = [
+  {
+    name: "notify-body",
+    because: "no verifier. A notification with a wrong body is sent and read as though it were right; nothing in the run disagrees with it afterwards"
+  },
+  {
+    name: "issue-comment",
+    because: "no verifier. A decision log or completion comment that says the wrong thing is the record, so there is nothing left to check it against"
+  },
+  {
+    name: "status-read",
+    because: "a misread routes the run to the wrong child, and no later step disagrees. Running the status command is already cheap; what is expensive is acting on it, which is not this step"
+  },
+  {
+    name: "diagnosis",
+    because: "a wrong root cause produces a fix that passes the gate and leaves the defect"
+  },
+  {
+    name: "design",
+    because: "the cost of a wrong design is paid by every step after it"
+  },
+  {
+    name: "split-assessment",
+    because: "a missed split widens one Issue into a batch nobody authorized"
+  },
+  {
+    name: "review",
+    because: "the review is the last thing between a defect and a merge; a cheaper one finds less"
+  }
+];
+function find_step(name) {
+  return DELEGATABLE_STEPS.find((step) => step.name === name.trim());
+}
+function verdict_for(name) {
+  return find_step(name) === void 0 ? KEEP_VERDICT : DELEGATE_VERDICT;
+}
+function rejection_for(name) {
+  return REJECTED_STEPS.find((step) => step.name === name.trim());
+}
+function reason_for(name) {
+  const step = find_step(name);
+  if (step !== void 0) return `delegatable: ${step.verifier}`;
+  const rejected = rejection_for(name);
+  if (rejected !== void 0) return `kept deliberately: ${rejected.because}`;
+  return "kept by default: not on the delegatable list, and the list is the whole of it";
+}
+var delegation_policy = {
+  DELEGATE_VERDICT,
+  INVESTIGATION_FILE_THRESHOLD,
+  INVESTIGATION_LIMIT,
+  INVESTIGATION_SEARCH_TURN_THRESHOLD,
+  INVESTIGATION_STEP,
+  INVESTIGATOR_AGENT,
+  KEEP_VERDICT,
+  DELEGATABLE_STEPS,
+  REJECTED_STEPS,
+  find_step,
+  verdict_for,
+  reason_for
+};
+
+// scripts/delegation/investigation-reads.ts
+var READ_TOOLS = /* @__PURE__ */ new Set(["Read"]);
+var DELEGATION_TOOLS = /* @__PURE__ */ new Set(["Agent", "Task"]);
+var CONTENT_READ_COMMANDS = [
+  "bat",
+  "cat",
+  "head",
+  "less",
+  "more",
+  "nl",
+  "sed",
+  "tail"
+];
+var CONTENT_READ_LABELS = new Set(
+  CONTENT_READ_COMMANDS.map((command) => time_shell.bash_label(command))
+);
+var { INVESTIGATOR_AGENT: INVESTIGATOR_AGENT2 } = delegation_policy;
+var REASON = `\u26D4 investigation: ${delegation_policy.INVESTIGATION_LIMIT}. ${delegation_policy.INVESTIGATION_STEP} Keep main-line reads to files you will edit; every read-only search turn counts. \`.claude/skills/workflow-commands/delegation.md\``;
+var INSTRUCTION_PATHS = ["prompts", ".claude/skills"];
+var INSTRUCTION_FILES = /* @__PURE__ */ new Set(["CLAUDE.md", "AGENTS.md", "GEMINI.md"]);
+var REPOSITORY_ROOT = process.cwd();
+function resolved(target) {
+  return path2.resolve(REPOSITORY_ROOT, target);
+}
+function repository_relative(absolute) {
+  return path2.relative(REPOSITORY_ROOT, absolute);
+}
+function is_instruction_document(target) {
+  const relative = repository_relative(resolved(target));
+  const segments = relative.split(path2.sep);
+  return INSTRUCTION_FILES.has(segments.at(-1) ?? "") || INSTRUCTION_PATHS.some((prefix) => relative.startsWith(`${prefix}${path2.sep}`));
+}
+var SESSION_TEMP_SEGMENT = /^claude-\d+$/u;
+var SESSION_STATE_SEGMENTS = cost_transcript.TRANSCRIPT_ROOT.split(path2.sep);
+var HARNESS_OUTPUT_DIRECTORY = "tasks";
+var HARNESS_OUTPUT_EXTENSION = ".output";
+var FILE_SEGMENT_INDEX = -1;
+var PARENT_SEGMENT_INDEX = -2;
+function has_state_root(segments, index) {
+  return SESSION_STATE_SEGMENTS.every((segment, offset) => segments[index + offset] === segment);
+}
+function is_harness_output(segments) {
+  return segments.some((segment) => SESSION_TEMP_SEGMENT.test(segment)) && segments.at(PARENT_SEGMENT_INDEX) === HARNESS_OUTPUT_DIRECTORY && (segments.at(FILE_SEGMENT_INDEX) ?? "").endsWith(HARNESS_OUTPUT_EXTENSION);
+}
+function is_outside_repository(absolute) {
+  return repository_relative(absolute).startsWith("..");
+}
+function is_session_artifact(target) {
+  const absolute = resolved(target);
+  const segments = absolute.split(path2.sep);
+  if (!is_outside_repository(absolute)) return false;
+  return segments.some((_segment, index) => has_state_root(segments, index)) || is_harness_output(segments) || capped_print_part.is_part_file(absolute);
+}
+function is_subject_file(target) {
+  return !is_instruction_document(target) && !is_session_artifact(target);
+}
+function is_nameable_file(target) {
+  return !target.includes("*") && !target.includes("?");
+}
+function is_content_read(label) {
+  return READ_TOOLS.has(label) || CONTENT_READ_LABELS.has(label);
+}
+function subject_targets(targets) {
+  return targets.filter((target) => is_nameable_file(target) && is_subject_file(target)).map((target) => resolved(target));
+}
+function call_targets(call) {
+  return subject_targets(time_bundle_call.call_facts(call.name, call.input).targets);
+}
+function delegation_instant(span) {
+  return span === void 0 ? hook_decision.NEVER_MS : span.ended_ms;
+}
+function is_failed_outcome(span) {
+  return span.outcome === time_spans.FAILED_OUTCOME;
+}
+function edited_files(spans) {
+  const written = spans.filter((span) => !is_failed_outcome(span)).flatMap((span) => subject_targets(span.writes));
+  return new Set(written);
+}
+function add_all(pending, targets, at_ms) {
+  for (const target of targets) if (!pending.has(target)) pending.set(target, at_ms);
+}
+function search_turn_key(searches, span) {
+  if (span.message_id !== time_spans.NO_MESSAGE_ID) return span.message_id;
+  return `${time_spans.NO_MESSAGE_ID}#${String(searches.size)}`;
+}
+function apply_search(searches, span) {
+  if (span.is_writing) {
+    searches.clear();
+    return;
+  }
+  const turn = search_turn_key(searches, span);
+  if (time_search_call.is_read_only_search(span) && !searches.has(turn)) {
+    searches.set(turn, span.ended_ms);
+  }
 }
-function priced(tokens, rate) {
-  return tokens * rate / TOKENS_PER_MILLION;
+function is_delegation(span) {
+  return DELEGATION_TOOLS.has(span.label) && !is_failed_outcome(span);
 }
-function estimate_composition(totals, price) {
+function apply_span(accumulation, span, edited) {
+  if (is_failed_outcome(span)) return;
+  if (is_delegation(span)) {
+    accumulation.pending.clear();
+    accumulation.searches.clear();
+    return;
+  }
+  apply_search(accumulation.searches, span);
+  if (!is_content_read(span.label)) return;
+  const fresh = subject_targets(span.targets).filter((target) => !edited.has(target));
+  add_all(accumulation.pending, fresh, span.ended_ms);
+}
+function last_delegation_ms(spans) {
+  return delegation_instant(spans.findLast((span) => is_delegation(span)));
+}
+function pending_after(pending, since_ms) {
+  return [...pending.values()].filter((at_ms) => at_ms > since_ms).length;
+}
+function tally_of(text2, since_ms = hook_decision.NEVER_MS, branch_files = []) {
+  const { spans, started_ms } = time_spans.parse_timeline(text2);
+  const edited = /* @__PURE__ */ new Set([...edited_files(spans), ...subject_targets(branch_files)]);
+  const accumulation = { pending: /* @__PURE__ */ new Map(), searches: /* @__PURE__ */ new Map() };
+  for (const span of spans) apply_span(accumulation, span, edited);
   return {
-    input_usd: priced(totals.input_tokens, price.input),
-    cache_write_5m_usd: priced(
-      totals.cache_write_5m_tokens * CACHE_WRITE_5M_MULTIPLIER,
-      price.input
-    ),
-    cache_write_1h_usd: priced(
-      totals.cache_write_1h_tokens * CACHE_WRITE_1H_MULTIPLIER,
-      price.input
-    ),
-    cache_read_usd: priced(totals.cache_read_tokens * cache_read_multiplier(price), price.input),
-    output_usd: priced(totals.output_tokens, price.output)
+    pending: [...accumulation.pending.keys()],
+    pending_since: pending_after(accumulation.pending, since_ms),
+    reset_ms: last_delegation_ms(spans),
+    window_start_ms: started_ms,
+    searches: accumulation.searches.size,
+    searches_since: pending_after(accumulation.searches, since_ms),
+    edited
   };
 }
-function to_model_cost(model, totals) {
-  const price = resolve_price(model);
-  if (price === void 0) return { model, totals };
-  return { model, totals, cost_usd: estimate_cost(totals, price) };
+function projected_count(pending, call, edited = /* @__PURE__ */ new Set()) {
+  return (/* @__PURE__ */ new Set([...pending, ...call_targets(call).filter((target) => !edited.has(target))])).size;
 }
-function billed_model(usage) {
-  const long_id = `${known_id(usage.model) ?? usage.model}${LONG_PROMPT_SUFFIX}`;
-  const is_long = cost_usage.billed_input(usage.totals) > LONG_PROMPT_THRESHOLD;
-  return is_long && Object.hasOwn(MODEL_PRICES, long_id) ? long_id : usage.model;
+function is_at_threshold(pending_count) {
+  return pending_count + 1 >= delegation_policy.INVESTIGATION_FILE_THRESHOLD;
 }
-function cost_by_model(records) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const record2 of records) {
-    const model = billed_model(record2);
-    const running = grouped.get(model) ?? cost_usage.EMPTY_TOTALS;
-    grouped.set(model, cost_usage.add_totals(running, record2.totals));
+function is_at_search_threshold(search_count) {
+  return search_count + 1 >= delegation_policy.INVESTIGATION_SEARCH_TURN_THRESHOLD;
+}
+function has_cleared_the_disarm(tally, refused_at_ms) {
+  return tally.reset_ms > refused_at_ms || refused_at_ms < tally.window_start_ms;
+}
+function is_rearmed(tally, refused_at_ms) {
+  if (refused_at_ms === hook_decision.NEVER_MS || has_cleared_the_disarm(tally, refused_at_ms)) {
+    return true;
   }
-  return [...grouped].map(([model, totals]) => to_model_cost(model, totals));
+  return is_at_threshold(tally.pending_since) || is_at_search_threshold(tally.searches_since);
 }
-function total_cost(costs) {
-  return {
-    usd: costs.reduce((sum, entry) => sum + (entry.cost_usd ?? 0), 0),
-    unpriced: costs.filter((entry) => entry.cost_usd === void 0).map((entry) => entry.model)
-  };
+function is_unit_transcript(transcript) {
+  return transcript.split(path2.sep).includes(cost_transcript.UNIT_DIRECTORY);
 }
-function cost_of(records) {
-  return total_cost(cost_by_model(records)).usd;
+function is_unit_run(run2) {
+  return run2 !== void 0 && is_unit_transcript(run2.transcript);
 }
-var cost_pricing = {
-  CACHE_WRITE_5M_MULTIPLIER,
-  CACHE_WRITE_1H_MULTIPLIER,
-  DEFAULT_CACHE_READ_MULTIPLIER,
-  LONG_PROMPT_THRESHOLD,
-  resolve_price,
-  estimate_cost,
-  estimate_composition,
-  cost_by_model,
-  total_cost,
-  cost_of
+function is_read_only_command(call, labels) {
+  if (call.name !== cost_blocks.BASH_TOOL) return false;
+  const label = time_shell.bash_label(time_shell.bash_command(call.input));
+  return labels.has(label) && time_batch_guard.is_read_only_call(call);
+}
+function is_search_call(call) {
+  return time_search_call.is_read_only_search(
+    time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID)
+  );
+}
+function is_refusable_call(call) {
+  if (is_search_call(call)) return true;
+  if (call_targets(call).length === 0) return false;
+  if (READ_TOOLS.has(call.name)) return true;
+  return is_read_only_command(call, CONTENT_READ_LABELS);
+}
+function is_growing_past_threshold(tally, call) {
+  if (is_search_call(call)) return is_at_search_threshold(tally.searches);
+  if (!is_at_threshold(tally.pending.length)) return false;
+  return projected_count(tally.pending, call, tally.edited) > tally.pending.length;
+}
+function is_blocking(tally, call, refused_at_ms) {
+  return is_growing_past_threshold(tally, call) && is_rearmed(tally, refused_at_ms);
+}
+function is_blocking_past_branch(text2, call, refused_at_ms) {
+  if (!is_blocking(tally_of(text2, refused_at_ms), call, refused_at_ms)) return false;
+  const branch_files = changed_paths_sync.read_changed_paths();
+  return is_blocking(tally_of(text2, refused_at_ms, branch_files), call, refused_at_ms);
+}
+function should_block(text2, call, refused_at_ms, run2) {
+  if (!is_refusable_call(call) || is_unit_run(run2)) return false;
+  return is_blocking_past_branch(text2, call, refused_at_ms);
+}
+var investigation_reads = {
+  DELEGATION_TOOLS,
+  INVESTIGATOR_AGENT: INVESTIGATOR_AGENT2,
+  READ_TOOLS,
+  REASON,
+  is_at_threshold,
+  is_instruction_document,
+  is_rearmed,
+  is_refusable_call,
+  is_session_artifact,
+  is_subject_file,
+  projected_count,
+  resolved,
+  should_block,
+  tally_of
 };
 
-// scripts/cost-runtime/context-cut-payback.ts
-var POST_CUT_CONTEXT = 6e4;
-var EXPECTED_REMAINING_REQUESTS = 10;
-function write_over_read() {
-  return cost_pricing.CACHE_WRITE_5M_MULTIPLIER / cost_pricing.DEFAULT_CACHE_READ_MULTIPLIER;
+// scripts/delegation/duplicate-read-guard.ts
+var SWITCH_ENV_KEY = "JOSH_DUPLICATE_READ_GUARD";
+var LANE_GUARD_ID = "duplicate-read";
+var STAMP_PREFIX = "josh-duplicate-read-guard-";
+var NOTICE_STAMP_PREFIX = "josh-duplicate-read-notice-";
+var READ_TOOL = "Read";
+var GLOB_CHARACTERS = /[*?]/u;
+var REASON2 = `\u26D4 duplicate read: this file was already read in this session and has not changed since (its mtime predates that read), so reading it again returns nothing new. Scroll up to the earlier result instead of re-reading it. A read with a new offset/limit, or of a file that has since changed, is allowed; set \`JOSH_DUPLICATE_READ_GUARD=off\` to disable this guard.`;
+var NOTICE = `\u26A0 duplicate read: this file was already read in this session and has not changed since, so re-reading it returns nothing new \u2014 scroll up to the earlier result instead of re-reading it. Set \`JOSH_DUPLICATE_READ_GUARD=off\` to silence this.`;
+function is_paginated(input) {
+  return input["offset"] !== void 0 || input["limit"] !== void 0;
+}
+function names_one_file(file_path) {
+  return typeof file_path === "string" && file_path !== "" && !GLOB_CHARACTERS.test(file_path);
+}
+function read_target(call) {
+  if (call.name !== READ_TOOL || !json_value.is_record(call.input)) return void 0;
+  const { input } = call;
+  if (is_paginated(input) || !names_one_file(input["file_path"])) return void 0;
+  return investigation_reads.resolved(input["file_path"]);
+}
+function is_refusable_call2(call) {
+  return read_target(call) !== void 0;
+}
+function is_successful_read(span) {
+  const is_read = investigation_reads.READ_TOOLS.has(span.label);
+  return is_read && span.outcome !== time_spans.FAILED_OUTCOME;
+}
+function reads_target(span, target) {
+  return span.targets.some((one) => investigation_reads.resolved(one) === target);
+}
+function last_read_ms(spans, target) {
+  const times = spans.filter((span) => is_successful_read(span) && reads_target(span, target)).map((span) => span.ended_ms);
+  return times.length === 0 ? hook_decision.NEVER_MS : Math.max(...times);
+}
+function file_mtime_ms(target) {
+  try {
+    return statSync(target).mtimeMs;
+  } catch {
+    return void 0;
+  }
 }
-function break_even_context(remaining = EXPECTED_REMAINING_REQUESTS) {
-  if (remaining <= 0) return Infinity;
-  return Math.round(POST_CUT_CONTEXT * (1 + write_over_read() / remaining));
+function read_window(tail, target) {
+  const { spans, started_ms } = time_spans.parse_timeline(tail);
+  return { last_ms: last_read_ms(spans, target), window_start_ms: started_ms };
 }
-function break_even_requests(current_context) {
-  const saved_per_request = current_context - POST_CUT_CONTEXT;
-  if (saved_per_request <= 0) return Infinity;
-  return POST_CUT_CONTEXT * write_over_read() / saved_per_request;
+function is_unchanged_reread(last_ms, mtime) {
+  if (mtime === void 0 || last_ms === hook_decision.NEVER_MS) return false;
+  return mtime < last_ms;
 }
-function pays_back(current_context, remaining = EXPECTED_REMAINING_REQUESTS) {
-  return current_context > break_even_context(remaining);
+function is_rearmed2(window, fired_at_ms) {
+  if (fired_at_ms === hook_decision.NEVER_MS || fired_at_ms < window.window_start_ms) return true;
+  return window.last_ms > fired_at_ms;
 }
-var context_cut_payback = {
-  POST_CUT_CONTEXT,
-  EXPECTED_REMAINING_REQUESTS,
-  break_even_context,
-  break_even_requests,
-  pays_back
+function is_redundant_reread(tail, call, fired_at_ms) {
+  const target = read_target(call);
+  if (target === void 0) return false;
+  const window = read_window(tail, target);
+  if (!is_unchanged_reread(window.last_ms, file_mtime_ms(target))) return false;
+  return is_rearmed2(window, fired_at_ms);
+}
+function duplicate_mode() {
+  return lane_guard_policy.mode_here(LANE_GUARD_ID);
+}
+function is_candidate(call) {
+  return is_refusable_call2(call) && duplicate_mode() !== "off";
+}
+function should_block_here(tail, call, refused_at_ms) {
+  if (duplicate_mode() !== "refuse") return false;
+  return is_redundant_reread(tail, call, refused_at_ms);
+}
+function should_notify_here(tail, call, notified_at_ms) {
+  if (duplicate_mode() !== "notice") return false;
+  return is_redundant_reread(tail, call, notified_at_ms);
+}
+var GUARD = hook_decision.create_transcript_guard({
+  prefix: STAMP_PREFIX,
+  switch_key: SWITCH_ENV_KEY,
+  is_candidate,
+  should_block: should_block_here,
+  reason: REASON2,
+  notify: {
+    prefix: NOTICE_STAMP_PREFIX,
+    should_notify: should_notify_here,
+    text: () => NOTICE
+  }
+});
+var duplicate_read_refusal = GUARD.refusal;
+var duplicate_read_outcome = GUARD.outcome;
+var { is_enabled, refusal_path } = GUARD;
+var notice_refusal_path = hook_decision.create_refusal_stamp(NOTICE_STAMP_PREFIX).path;
+var { deny_envelope: deny_envelope2, DISABLED_VALUES: DISABLED_VALUES2 } = hook_decision;
+var duplicate_reads = {
+  is_successful_read,
+  REASON: REASON2,
+  NOTICE
 };
 
-// scripts/cost-runtime/context-cut-threshold.ts
-var CONTEXT_CUT_THRESHOLD = context_cut_payback.break_even_context();
-
-// scripts/run/cut/run-cut.ts
-import { z as z3 } from "zod";
+// scripts/run/cut/run-cut-digest.ts
+import { z as z2 } from "zod";
+var session_digest_schema = z2.object({
+  read: z2.array(z2.string()),
+  decisions: z2.array(z2.string())
+});
+var MAX_READ_ENTRIES = 40;
+var MAX_DECISIONS = 12;
+var MAX_DECISION_CHARS = 240;
+var DECISION_PREFIX = "Auto-decided:";
+var DECISION_LINE = /(?:^|[\s'"=])(Auto-decided: [^\n]+)/gu;
+var TRAILING_QUOTES = /['"]$/u;
+var ASSISTANT = "assistant";
+var READ_LABEL = "Already read before the cut \u2014 re-read only the lines you need";
+var DECISIONS_LABEL = "Decided before the cut \u2014 do not reopen";
+function shown_path(target, cwd) {
+  const relative = path3.relative(cwd, path3.resolve(cwd, target));
+  return relative.startsWith("..") ? target : relative;
+}
+function newest_unique(entries, limit) {
+  const unique = [...new Set(entries.toReversed())].toReversed();
+  return unique.slice(-limit);
+}
+function read_files_of(text2, cwd) {
+  const reads = time_spans.parse_timeline(text2).spans.filter((span) => duplicate_reads.is_successful_read(span)).flatMap((span) => span.targets.map((target) => shown_path(target, cwd)));
+  return newest_unique(reads, MAX_READ_ENTRIES);
+}
+var COMMENT_INPUT_KEYS = ["command", "content"];
+function input_strings(input) {
+  if (!json_value.is_record(input)) return [];
+  return COMMENT_INPUT_KEYS.map((key2) => input[key2]).filter((value) => typeof value === "string");
+}
+function assistant_texts(record3) {
+  if (record3?.type !== ASSISTANT) return [];
+  return transcript_record.blocks_of(record3).flatMap((block) => [block.text ?? "", ...input_strings(block.input)]);
+}
+function decisions_of(text2) {
+  const decisions = text2.split("\n").flatMap((line) => assistant_texts(transcript_record.parse(line))).flatMap((written) => [...written.matchAll(DECISION_LINE)].map((match) => match[1] ?? "")).map((line) => line.replace(TRAILING_QUOTES, "").slice(0, MAX_DECISION_CHARS));
+  return newest_unique(decisions, MAX_DECISIONS);
+}
+function digest_of(text2, cwd) {
+  return { read: read_files_of(text2, cwd), decisions: decisions_of(text2) };
+}
+function own_transcript(cwd, environment) {
+  if (own_session.session_id_of(environment) === void 0) return void 0;
+  const files = cost_transcript.list_sessions_across(cost_transcript.transcript_directories(cwd));
+  const selection = own_session.select_own_session(files, environment);
+  if (selection.kind === "absent") return void 0;
+  const file = files[selection.index];
+  return file === void 0 ? void 0 : cost_transcript.read_optional(file);
+}
+function own_digest(cwd = process.cwd(), environment = process.env) {
+  const text2 = own_transcript(cwd, environment);
+  return text2 === void 0 ? void 0 : digest_of(text2, cwd);
+}
+function describe_list(label, entries) {
+  if (entries.length === 0) return [];
+  const bullets = entries.map((entry) => `  - ${entry}`).join("\n");
+  return [`${label}:
+${bullets}`];
+}
+function describe_digest(digest) {
+  if (digest === void 0) return void 0;
+  const blocks = [
+    ...describe_list(READ_LABEL, digest.read),
+    ...describe_list(DECISIONS_LABEL, digest.decisions)
+  ];
+  return blocks.length === 0 ? void 0 : blocks.join("\n\n");
+}
+var run_cut_digest = {
+  DECISION_PREFIX,
+  describe_digest,
+  digest_of,
+  own_digest,
+  session_digest_schema
+};
 
 // scripts/run/cut/run-cut-handoff.ts
 import { readFileSync } from "node:fs";
-import { z as z2 } from "zod";
-var handoff_schema = z2.object({
-  instruction: z2.string(),
-  completed: z2.array(z2.string()),
-  remaining: z2.array(z2.string()),
-  untouched: z2.array(z2.string())
+import { z as z3 } from "zod";
+var handoff_schema = z3.object({
+  instruction: z3.string(),
+  completed: z3.array(z3.string()),
+  remaining: z3.array(z3.string()),
+  untouched: z3.array(z3.string()),
+  findings: z3.array(z3.string()).optional()
 });
 var COMPLETED_LABEL = "Completed";
 var REMAINING_LABEL = "Remaining";
 var UNTOUCHED_LABEL = "Deliberately untouched";
 var INSTRUCTION_LABEL = "Instruction (verbatim)";
+var FINDINGS_LABEL = "Round-1 findings, attested but not recorded \u2014 do not rerun round 1: fix them, then record them with `pnpm josh review:record --issue <N>`";
 var EMPTY_LIST_NOTE = "(none)";
-function describe_key(key2) {
-  const value = handoff_schema.shape[key2] instanceof z2.ZodArray ? '["\u2026"]' : '"\u2026"';
-  return `"${key2}": ${value}`;
-}
-var HANDOFF_FORMAT = `a JSON object {${handoff_schema.keyof().options.map((key2) => describe_key(key2)).join(", ")}}`;
+var PLACEHOLDER = "\u2026";
+var FINDINGS_PLACEHOLDER = "unrecorded";
+var EXAMPLE_LIST = `["${PLACEHOLDER}"]`;
+var EXAMPLE_VALUES = {
+  instruction: `"${PLACEHOLDER}"`,
+  completed: EXAMPLE_LIST,
+  remaining: EXAMPLE_LIST,
+  untouched: EXAMPLE_LIST,
+  findings: `["${FINDINGS_PLACEHOLDER}"]`
+};
+var HANDOFF_FORMAT = `{${handoff_schema.keyof().options.map((key2) => `"${key2}":${EXAMPLE_VALUES[key2]}`).join(",")}}`;
 function parse_handoff(raw) {
   return json_value.parse_with(raw, handoff_schema);
 }
@@ -930,25 +1282,43 @@ function load_handoff(handoff_path, max_bytes) {
   }
   return { kind: "ok", handoff };
 }
-function describe_list(label, items) {
+function describe_list2(label, items) {
   if (items.length === 0) return `${label}: ${EMPTY_LIST_NOTE}`;
   const bullets = items.map((item) => `  - ${item}`).join("\n");
   return `${label}:
 ${bullets}`;
 }
+function carried_findings(handoff) {
+  const findings = handoff?.findings ?? [];
+  return findings.filter(
+    (finding) => ![PLACEHOLDER, FINDINGS_PLACEHOLDER, ""].includes(finding.trim())
+  );
+}
+function describe_findings(handoff) {
+  const findings = carried_findings(handoff);
+  if (findings.length === 0) return [];
+  return [describe_list2(FINDINGS_LABEL, findings)];
+}
 function describe_handoff(handoff) {
   return [
     `${INSTRUCTION_LABEL}:
 ${handoff.instruction}`,
-    describe_list(COMPLETED_LABEL, handoff.completed),
-    describe_list(REMAINING_LABEL, handoff.remaining),
-    describe_list(UNTOUCHED_LABEL, handoff.untouched)
+    describe_list2(COMPLETED_LABEL, handoff.completed),
+    describe_list2(REMAINING_LABEL, handoff.remaining),
+    describe_list2(UNTOUCHED_LABEL, handoff.untouched),
+    ...describe_findings(handoff)
   ].join("\n\n");
 }
 var HANDOFF_PATH = ".josh/tmp/handoff-<N>.json";
+var ISSUE_PLACEHOLDER = "<N>";
+function handoff_path_of(issue) {
+  return HANDOFF_PATH.replace(ISSUE_PLACEHOLDER, () => issue);
+}
 var run_cut_handoff = {
   HANDOFF_FORMAT,
   HANDOFF_PATH,
+  handoff_path_of,
+  carried_findings,
   describe_handoff,
   handoff_schema,
   is_complete_handoff,
@@ -960,21 +1330,21 @@ var run_cut_handoff = {
 // scripts/run/cut/run-cut.ts
 var CUT_PREFIX = "josh-run-cut-";
 var { PRE_GATE_PHASE, IMPLEMENTATION_PHASE } = agent_role_profile;
-var IMPLEMENTATION_CONTEXT_THRESHOLD = CONTEXT_CUT_THRESHOLD;
 var CUT_MAX_AGE_MS = backlog_budget.DEFAULT_IDLE_MS;
 var CUT_MAX_AGE_HOURS = backlog_budget.IDLE_WAIT_HOURS;
 var END_COMMAND = "pnpm josh run:cut --end";
 var READ_COMMAND = "pnpm josh run:cut --json";
 var MAX_HANDOFF_BYTES = 8192;
-var run_cut_schema = z3.object({
-  invocation: z3.string(),
-  issue: z3.string(),
-  branch: z3.string(),
-  phase: z3.string(),
-  cut_at: z3.string(),
-  is_handed_off: z3.boolean().optional(),
+var run_cut_schema = z4.object({
+  invocation: z4.string(),
+  issue: z4.string(),
+  branch: z4.string(),
+  phase: z4.string(),
+  cut_at: z4.string(),
+  is_handed_off: z4.boolean().optional(),
   handoff: run_cut_handoff.handoff_schema.optional(),
-  is_merge_relaunched: z3.boolean().optional()
+  digest: run_cut_digest.session_digest_schema.optional(),
+  is_merge_relaunched: z4.boolean().optional()
 });
 function cut_path(git_directory) {
   return stamp_file.stamp_path(CUT_PREFIX, git_directory);
@@ -997,21 +1367,21 @@ var CUT_SPEC = {
 function is_expired(cut, now) {
   return stamp_record.is_older_than(cut_at_of(cut), CUT_MAX_AGE_MS, now);
 }
-function classify(raw, now) {
-  const read3 = stamp_record.classify(raw, CUT_SPEC, now);
-  if (!("record" in read3)) return read3;
-  return { kind: read3.kind, cut: read3.record };
+function classify2(raw, now) {
+  const read4 = stamp_record.classify(raw, CUT_SPEC, now);
+  if (!("record" in read4)) return read4;
+  return { kind: read4.kind, cut: read4.record };
 }
 function read_cut(target, now = /* @__PURE__ */ new Date()) {
-  return classify(stamp_file.read_stamp_text(target), now);
+  return classify2(stamp_file.read_stamp_text(target), now);
 }
 function worktree_git_directory_sync() {
   return git_common_directory.own();
 }
 function carried_cut_sync(now = /* @__PURE__ */ new Date(), directory = worktree_git_directory_sync()) {
   if (directory === void 0) return void 0;
-  const read3 = read_cut(cut_path(directory), now);
-  return read3.kind === "carried" ? read3.cut : void 0;
+  const read4 = read_cut(cut_path(directory), now);
+  return read4.kind === "carried" ? read4.cut : void 0;
 }
 function lane_cut_sync(lane_directory) {
   const directory = git_common_directory.own(lane_directory);
@@ -1027,7 +1397,8 @@ function fresh_cut(spec, now) {
     phase: spec.phase,
     cut_at: now.toISOString(),
     is_handed_off: true,
-    handoff: spec.handoff
+    handoff: spec.handoff,
+    digest: spec.digest
   };
 }
 function resumes_into_implementation(phase) {
@@ -1039,6 +1410,11 @@ function within_handoff_bound(cut) {
 function record_within_bound(spec, now = /* @__PURE__ */ new Date()) {
   return within_handoff_bound(fresh_cut(spec, now));
 }
+function with_digest(spec, digest_of2) {
+  if (spec.handoff === void 0) return spec;
+  const digested = { ...spec, digest: digest_of2() };
+  return record_within_bound(digested) ? digested : spec;
+}
 function begin_cut(target, spec, now = /* @__PURE__ */ new Date()) {
   const cut = fresh_cut(spec, now);
   if (!within_handoff_bound(cut)) return void 0;
@@ -1078,8 +1454,8 @@ function end_cut(target) {
 }
 function hold_of(directory) {
   if (directory === void 0) return void 0;
-  const read3 = run_hold.read_hold(run_hold.hold_path(directory));
-  return read3.kind === "held" || read3.kind === "stale" ? read3.hold : void 0;
+  const read4 = run_hold.read_hold(run_hold.hold_path(directory));
+  return read4.kind === "held" || read4.kind === "stale" ? read4.hold : void 0;
 }
 function fullrun_issue(hold) {
   return hold?.is_fullrun === true ? hold.issue : void 0;
@@ -1124,7 +1500,6 @@ var run_cut = {
   CUT_MAX_AGE_HOURS,
   CUT_MAX_AGE_MS,
   END_COMMAND,
-  IMPLEMENTATION_CONTEXT_THRESHOLD,
   IMPLEMENTATION_PHASE,
   MAX_HANDOFF_BYTES,
   PRE_GATE_PHASE,
@@ -1132,9 +1507,10 @@ var run_cut = {
   begin_cut,
   busy_message,
   carried_cut_sync,
-  classify,
+  classify: classify2,
   classify_resume,
   current_state,
+  with_digest,
   cut_path,
   describe_cut,
   end_cut,
@@ -1161,6 +1537,56 @@ var run_cut = {
   worktree_git_directory_sync
 };
 
+// scripts/rules/shell-segments.ts
+var SEGMENT_SEPARATOR = /&&|\|\||;|\n/u;
+var SEGMENT_PARTS = new RegExp(`(${SEGMENT_SEPARATOR.source})`, "u");
+var COMMAND_SEPARATOR = /&&|\|\||;|\n|(?<!>)\|&?|(?<![<>])&(?!>)/u;
+function segments_of(command) {
+  return command.split(SEGMENT_SEPARATOR).map((segment) => segment.trim());
+}
+function commands_of(command) {
+  return command.split(COMMAND_SEPARATOR).map((segment) => segment.trim());
+}
+var COMMAND_SEPARATORS = new RegExp(COMMAND_SEPARATOR.source, "gu");
+function quote_aware_commands_of(command) {
+  const plain = time_shell.blanked(command);
+  if (plain === void 0) return commands_of(command);
+  const cuts = [...plain.matchAll(COMMAND_SEPARATORS)].map((match) => ({
+    begin: match.index,
+    end: match.index + match[0].length
+  }));
+  const starts = [0, ...cuts.map((cut) => cut.end)];
+  const stops = cuts.map((cut) => cut.begin);
+  return starts.map((start, index) => command.slice(start, stops[index] ?? command.length).trim());
+}
+var LINE_CONTINUATION = /\\\n/gu;
+function joined_continuations(command) {
+  return command.replaceAll(LINE_CONTINUATION, " ");
+}
+function parts_of(command) {
+  return command.split(SEGMENT_PARTS);
+}
+function first_of(command) {
+  const plain = time_shell.blanked(command);
+  if (plain === void 0) return void 0;
+  const cut = plain.search(SEGMENT_SEPARATOR);
+  return (cut === -1 ? command : command.slice(0, cut)).trim();
+}
+function is_josh_command(segment, names) {
+  const named = time_shell.josh_command_of(segment);
+  if (!named.startsWith(time_shell.JOSH_PREFIX)) return false;
+  return names.has(named.slice(time_shell.JOSH_PREFIX.length));
+}
+var shell_segments = {
+  commands_of,
+  first_of,
+  is_josh_command,
+  joined_continuations,
+  parts_of,
+  quote_aware_commands_of,
+  segments_of
+};
+
 // scripts/rules/run-tail-rule.ts
 var SEGMENT_PREFIX = String.raw`(?:\(\s*)?(?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)*(?:npx\s+|pnpm\s+(?:exec\s+|run\s+)?)?`;
 var WORD_END = String.raw`(?=\s|$|\))`;
@@ -1197,13 +1623,13 @@ function is_foreground_push_step(call) {
   if (is_backgrounded(call.input)) return false;
   return is_push_step_call(call);
 }
-function decide3() {
+function decide2() {
   return true;
 }
 var RUN_TAIL_REASON = "\u26D4 run tail: this issues the commit-push-PR step in the foreground, where the harness decides when to stop waiting. Reissue it with `run_in_background` set; when it exits, go straight on to `pnpm josh followup` in the foreground \u2014 the turn never ends at the push (`.claude/skills/workflow-commands/background-commands.md`). It fires on every foreground push, not once per run.";
 var run_tail_rule = {
   RUN_TAIL_REASON,
-  decide: decide3,
+  decide: decide2,
   is_backgrounded_push_step,
   is_foreground_push_step,
   is_push_step,
@@ -1211,10 +1637,12 @@ var run_tail_rule = {
 };
 
 // scripts/rules/lane-background.ts
-var SHIP_COMMAND = `${time_shell.JOSH_PREFIX}ship`;
+var FOREGROUND_COMMANDS = new Set(
+  ["ship", "ship:wait", "lane:plan"].map((name) => `${time_shell.JOSH_PREFIX}${name}`)
+);
 var LONG_RUNNING_COMMANDS = /* @__PURE__ */ new Set([
   ...["gate", "git", "followup"].map((name) => `${time_shell.JOSH_PREFIX}${name}`),
-  SHIP_COMMAND
+  ...FOREGROUND_COMMANDS
 ]);
 var BACKGROUND_KEY2 = "run_in_background";
 var TIMEOUT_KEY = "timeout";
@@ -1227,7 +1655,7 @@ function long_commands_of(command) {
 }
 function ships_alone(command) {
   const names = long_commands_of(command);
-  return names.length > 0 && names.every((name) => name === SHIP_COMMAND);
+  return names.length > 0 && names.every((name) => FOREGROUND_COMMANDS.has(name));
 }
 function backgrounded_bash_command(call) {
   if (call.name !== cost_blocks.BASH_TOOL || !is_backgrounded2(call.input)) return void 0;
@@ -1237,14 +1665,14 @@ function is_backgrounded_ship(call) {
   const command = backgrounded_bash_command(call);
   return command !== void 0 && ships_alone(command);
 }
-function is_candidate(call) {
+function is_candidate2(call) {
   if (run_tail_rule.is_push_step_call(call)) return true;
   const command = backgrounded_bash_command(call);
   if (command === void 0 || is_backgrounded_ship(call)) return false;
   return long_commands_of(command).length > 0;
 }
 function is_background_long_run(call, is_lane_child = () => lane_child_marker.is_child_of(process.cwd())) {
-  return is_candidate(call) && is_lane_child();
+  return is_candidate2(call) && is_lane_child();
 }
 function ship_alone_input(call) {
   if (call.name !== cost_blocks.BASH_TOOL || !json_value.is_record(call.input)) return void 0;
@@ -1259,7 +1687,7 @@ function foreground_input(call, is_lane_child = () => lane_child_marker.is_child
   if (input === void 0 || is_capped_foreground(input) || !is_lane_child()) return void 0;
   return { ...input, [BACKGROUND_KEY2]: false, [TIMEOUT_KEY]: FOREGROUND_TIMEOUT_MS };
 }
-var FOREGROUND_NOTE = "lane background: a lane child's `josh ship` backgrounded, by its flag or by outrunning the Bash timeout, dies with the headless turn before its supervisor exists \u2014 so it was run in the foreground at the 600000 ms cap, where it detaches itself after the preflight. End the turn on `launched` / `busy`.";
+var FOREGROUND_NOTE = "lane background: a lane child's `josh ship`, `josh ship:wait` or `josh lane:plan` backgrounded, by its flag or by outrunning the Bash timeout, dies with the headless turn \u2014 so it was run in the foreground at the 600000 ms cap, where `ship` detaches itself after the preflight. Then follow `chain-rule.md` step 0 (`josh ship:wait` on `launched`).";
 function apply_line(open, line, launched_ids) {
   const parsed = time_transcript_line.parse_line(line);
   if (parsed === void 0) return;
@@ -1279,36 +1707,376 @@ function pending_background_ids(tail) {
 function pending_agent_ids(tail) {
   return unfinished_ids(tail, (block) => [block.agent_id]);
 }
-var LANE_BACKGROUND_REASON = '\u26D4 lane background: this session is a dispatched lane child (`JOSH_LANE_CHILD`), a headless process whose background tasks die when the turn ends. Hand over to `pnpm josh ship --detach --review "<title> #<N>"`, issued in the foreground, then end the turn on `launched` / `busy`. It fires on every occurrence (`.claude/skills/workflow-commands/chain-rule.md` step 0).';
+function pending_command_ids(tail) {
+  return unfinished_ids(tail, (block) => [block.background_id]);
+}
+var LANE_BACKGROUND_REASON = '\u26D4 lane background: this session is a dispatched lane child (`JOSH_LANE_CHILD`), a headless process whose background tasks die when the turn ends. Hand over to `pnpm josh ship --detach --review "<title> #<N>"`, issued in the foreground, then `josh ship:wait <N>` on `launched` or end the turn. It fires on every occurrence (`.claude/skills/workflow-commands/chain-rule.md` step 0).';
 var LANE_BACKGROUND_STOP_REASON = "\u26D4 lane background stop: this is a dispatched lane child (`JOSH_LANE_CHILD`) and a background task it launched has not finished, and ending this turn kills it. Wait for it in the foreground, or re-issue the work through `pnpm josh ship --detach` \u2014 do not notify, stop or repeat your reply.";
-var ROW2 = {
+var LANE_AGENT_STOP_REASON = "\u26D4 lane agent stop: this is a dispatched lane child (`JOSH_LANE_CHILD`) and a subagent it launched has not finished; ending this turn kills it. Its completion notice arrives only when a tool call ends: wait with one short foreground call at a time (`sleep 20`) until it arrives \u2014 never a loop over its `.output`. Do not notify, stop or repeat your reply.";
+var ROW = {
   id: "lane-background",
   is_trigger: (call) => is_background_long_run(call),
   reason: LANE_BACKGROUND_REASON,
   decide: () => true,
+  // `pretool-guard.ts` rewrites a lone `josh ship` to the foreground rather than refusing it; this is
+  // the note it attaches, so `rule-value.ts` counts that rewrite as this row's delivery.
+  rewrite_note: FOREGROUND_NOTE,
+  // The Stop hook delivers the same rule at the turn's end, for the background task or subagent the
+  // turn would kill.
+  stop_reasons: [LANE_BACKGROUND_STOP_REASON, LANE_AGENT_STOP_REASON],
   about: {
     title: "Lane child background push",
     topic: "`.claude/skills/workflow-commands/background-commands.md`",
-    fires: "a dispatched lane child backgrounding `josh gate` / `git` / `followup` / `ship`; it hands over `pnpm josh ship --detach`. Every occurrence",
+    fires: "a dispatched lane child backgrounding `josh gate` / `git` / `followup` / `ship`; it hands over `pnpm josh ship --detach`; the Stop hook also blocks ending a turn with its background task or subagent unfinished. Every occurrence",
     quiet: "not a lane child, or the foreground `ship --detach`"
   }
 };
 var lane_background = {
   FOREGROUND_NOTE,
+  LANE_AGENT_STOP_REASON,
   LANE_BACKGROUND_REASON,
   LANE_BACKGROUND_STOP_REASON,
-  ROW: ROW2,
+  ROW,
   foreground_input,
   is_background_long_run,
   pending_agent_ids,
-  pending_background_ids
+  pending_background_ids,
+  pending_command_ids
+};
+
+// scripts/rules/stop-rules.ts
+import { z as z5 } from "zod";
+
+// scripts/rules/concise-reply.ts
+import path4 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// scripts/rules/reply-prose.ts
+var CODE_PATTERNS = [
+  /```[\s\S]*?(?:```|$)/gu,
+  /`[^`\n]*`/gu,
+  /\]\([^)\s]*\)/gu,
+  /https?:\/\/\S+/gu
+];
+var ASCII_RUN_PATTERN = /[!-~]+/gu;
+var STRUCTURE_LINE_PATTERN = /^\s*(?:\||[-*+] |[・•] ?|\d+\. )/u;
+function prose_of(message) {
+  let text2 = message;
+  for (const pattern of CODE_PATTERNS) text2 = text2.replaceAll(pattern, " ");
+  return text2.replaceAll(ASCII_RUN_PATTERN, (run2) => run2.includes("/") ? " " : run2);
+}
+function narrative_of(message) {
+  return prose_of(message).split("\n").filter((line) => !STRUCTURE_LINE_PATTERN.test(line)).join("\n");
+}
+var reply_prose = { narrative_of, prose_of };
+
+// scripts/rules/concise-reply.ts
+var PROSE_LIMIT = 400;
+var EXEMPT_WORDS = ["\u8A73\u3057\u304F", "\u5177\u4F53\u7684\u306B", "\u8A73\u7D30"];
+var COUNTED_PATTERN = /[\p{L}\p{N}]/gu;
+var PRINCIPLES_FILE = "prompts/collaboration-workflow/principles.md";
+var SECTION = "concise-reply";
+var PACKAGE_DIRECTORY = find_package_directory(path4.dirname(fileURLToPath(import.meta.url)));
+var REASON_OPENING = `\u26D4 concise reply: your reply's prose outside code, tables and lists is over the limit of \`${PRINCIPLES_FILE}\` \u2192 "${SECTION}"`;
+var KEEP_DECISION = " Keep its `Recommended:` / `Alternative:` lines as they are.";
+function prose_length(message) {
+  return reply_prose.narrative_of(message).match(COUNTED_PATTERN)?.length ?? 0;
+}
+function is_exempt(prompt) {
+  return EXEMPT_WORDS.some((word) => prompt.includes(word));
+}
+function is_over(message, prompt) {
+  if (prompt === void 0 || is_exempt(prompt)) return false;
+  return prose_length(message) > PROSE_LIMIT;
+}
+function section_text(root) {
+  const markdown = document_section.read_optional(path4.join(root, PRINCIPLES_FILE));
+  return markdown === void 0 ? void 0 : document_section.section(markdown, SECTION)?.text;
+}
+function decision_note(message) {
+  return stop_decision.decision_of(message) === void 0 ? "" : KEEP_DECISION;
+}
+function build_reason(message, root = PACKAGE_DIRECTORY) {
+  const head = `${REASON_OPENING} (${String(prose_length(message))} of ${String(PROSE_LIMIT)}). Rewrite it shorter as that section says \u2014 do not repeat your previous reply.${decision_note(message)}`;
+  const body = section_text(root);
+  return body === void 0 ? head : `${head}
+
+${body}`;
+}
+var ROW2 = {
+  id: SECTION,
+  reason: REASON_OPENING,
+  about: {
+    title: "Concise reply",
+    topic: `\`principles.md\` \u2192 "${SECTION}"`,
+    entry: "pnpm josh stop:guard",
+    fires: `a reply whose narrative outside code, tables and lists is over ${String(PROSE_LIMIT)} letters. Blocks the stop`,
+    quiet: "a reply under the limit, a prompt asking for the detail (`\u8A73\u3057\u304F` / `\u5177\u4F53\u7684\u306B` / `\u8A73\u7D30`), a fixed output in a code block, no prompt of the person\u2019s on the transcript tail, or a headless session"
+  }
+};
+var concise_reply = {
+  EXEMPT_WORDS,
+  PROSE_LIMIT,
+  REASON_OPENING,
+  ROW: ROW2,
+  build_reason,
+  is_over,
+  prose_length
+};
+
+// scripts/rules/filing-offer.ts
+var OFFER_PATTERNS = [
+  /起票(?:して)?(?:も)?(?:よければ|よろしければ|よいですか|良いですか|よろしいですか|いいですか)/u,
+  /起票(?:しましょうか|しますか|するのが妥当|すべきだと|すべきと|を提案|をご提案)/u,
+  /Issue\s*[化に](?:しましょうか|しますか|してよければ)/iu,
+  /\b(?:shall|should)\s+I\s+(?:file|open|raise)\b/iu,
+  /\b(?:want|like)\s+me\s+to\s+(?:file|open|raise)\b/iu,
+  /\blet\s+me\s+know\s+if\s+you\s+(?:want|would\s+like)\s+(?:me\s+to\s+file|it\s+filed)\b/iu
+];
+var GITHUB_URL_OWNER = /github\.com\/([\w.-]+)\//gu;
+var OWNER_SEPARATOR = "/";
+function is_offer_line(line) {
+  return OFFER_PATTERNS.some((pattern) => pattern.test(line));
+}
+function offers_filing(message) {
+  return issue_citation.prose_lines(message).some((line) => is_offer_line(line));
+}
+function url_owners(message) {
+  return [...message.matchAll(GITHUB_URL_OWNER)].map((match) => match[1] ?? "");
+}
+function qualified_owners(message) {
+  return issue_citation.bare_references(message).filter((reference) => reference.includes(OWNER_SEPARATOR)).map((reference) => reference.split(OWNER_SEPARATOR)[0] ?? "");
+}
+function mentioned_owners(message) {
+  return [...url_owners(message), ...qualified_owners(message)];
+}
+function is_first_party_target(message, session_owner) {
+  if (session_owner === void 0) return false;
+  return mentioned_owners(message).every(
+    (owner) => repo_party.classify(session_owner, owner) === repo_party.FIRST_PARTY
+  );
+}
+var filing_offer = { is_first_party_target, mentioned_owners, offers_filing };
+
+// scripts/rules/reply-language.ts
+var LATIN_SCRIPT = "Latn";
+var COMPOUND_SCRIPTS = {
+  Jpan: ["Hira", "Kana", "Hani"],
+  Kore: ["Hang", "Hani"],
+  Hans: ["Hani"],
+  Hant: ["Hani"]
+};
+var MIN_PROSE_LETTERS = 20;
+var MATCH_SHARE_FLOOR = 0.5;
+var MIN_VOTING_LETTERS = 8;
+var LETTER_PATTERN = new RegExp("\\p{L}", "gu");
+var NON_LATIN_LETTER_PATTERN = new RegExp("(?![\\p{Script=Latn}\\p{Script=Common}\\p{Script=Inherited}])\\p{L}", "u");
+function script_of(lang) {
+  try {
+    return new Intl.Locale(lang).maximize().script;
+  } catch {
+    return void 0;
+  }
+}
+function letter_pattern(script) {
+  const scripts = COMPOUND_SCRIPTS[script] ?? [script];
+  const classes = scripts.map((name) => String.raw`\p{Script=${name}}`).join("");
+  try {
+    return new RegExp(`[${classes}]`, "u");
+  } catch {
+    return void 0;
+  }
+}
+function letter_count(text2) {
+  return text2.match(LETTER_PATTERN)?.length ?? 0;
+}
+function is_line_in_script(line, script, pattern) {
+  if (script === LATIN_SCRIPT) return !NON_LATIN_LETTER_PATTERN.test(line);
+  return pattern.test(line);
+}
+function voting_lines(prose) {
+  const lines = prose.split("\n").filter((line) => letter_count(line) > 0);
+  const voting = lines.filter((line) => letter_count(line) >= MIN_VOTING_LETTERS);
+  return voting.length > 0 ? voting : lines;
+}
+function matches_share(prose, script, pattern) {
+  const lines = voting_lines(prose);
+  const matched = lines.filter((line) => is_line_in_script(line, script, pattern));
+  return matched.length / lines.length;
+}
+function is_mismatch(message, lang) {
+  const script = script_of(lang);
+  if (script === void 0) return false;
+  const pattern = letter_pattern(script);
+  if (pattern === void 0) return false;
+  const prose = reply_prose.prose_of(message);
+  if (letter_count(prose) < MIN_PROSE_LETTERS) return false;
+  return matches_share(prose, script, pattern) < MATCH_SHARE_FLOOR;
+}
+var reply_language = { is_mismatch, script_of };
+
+// scripts/rules/stop-rules.ts
+var SWITCH_ENV_KEY2 = "JOSH_STOP_GUARD";
+var BLOCK_DECISION = "block";
+var stop_payload_schema = z5.object({
+  transcript_path: z5.string().min(1),
+  stop_hook_active: z5.boolean().nullish(),
+  last_assistant_message: z5.string().nullish()
+});
+var NO_OUTCOME2 = { reason: void 0, actions: [], blocks_on_failure: false };
+var STOP_NOTIFY_REASON = '\u26D4 mid-workflow stop notification: this working tree is still held by a run and no `confirmation` Telegram was sent this turn. Send `pnpm josh notify --task-type confirmation --issue-url "<url>" --body=$\'<reason>\' --recommended "<choice>" --alternative "<choice>"` (`rule-delivery.md` \u2192 "stop-notify"), then confirm in one line that it was sent \u2014 do not repeat your previous reply.';
+var HOLD_RELEASE_REASON = "\u26D4 working-tree hold not released: this working tree is clean but its `run:hold` record is still in place. Release it with `pnpm josh run:release <N>` (bare for a `new` entry; `working-tree-hold.md`), then confirm in one line that it was released \u2014 do not repeat your previous reply.";
+var FILING_OFFER_REASON = '\u26D4 filing offer: your reply offers to file an Issue instead of filing it, and this run is unattended \u2014 nobody is there to answer. Run `pnpm josh issue:file "<title>" --body-file <path>` (Tier A, `observation-filing.md`), then end with the one-line citation of what was filed; do not repeat your previous reply. If it is not worth filing after all, say so in one line instead.';
+var HEADLESS_WAIT_MARKER = "\u26D4 headless parent:";
+var HEADLESS_REFUSAL_CAP = 3;
+var HEADLESS_WAIT_CALLS = ['"command":"pnpm josh lane:await'];
+var HEADLESS_WAIT_BODY = ' this is a `claude -p` `backlogrun` parent with lanes in flight, and ending this turn kills the process and its background waits. Hand the loop back with `pnpm josh run:carry --cut --owner "$PPID"` (or `--end` when the run is over), then end the turn (`backlogrun-progress.md`).';
+var HEADLESS_WAIT_REASON = `${HEADLESS_WAIT_MARKER}${HEADLESS_WAIT_BODY}`;
+var INDEX_COMMAND_PATTERN = /git (?:add|stage|rm --cached|restore --staged|restore -S)\b/u;
+var PERMISSION_PATTERN = /許可|承認|permission|approve|approval|authorization/iu;
+var LANE_INDEX_REASON = "\u26D4 lane index permission: this is a dispatched lane child (`JOSH_LANE_CHILD`) and your reply asks a person for permission to change the git index. That is Tier A here (`chain-rule.md`): remove any conflict markers, run `pnpm josh git -y` (it stages and commits, a conflicted merge included) and continue the run \u2014 do not repeat your previous reply.";
+function asks_index_permission(message) {
+  return INDEX_COMMAND_PATTERN.test(message) && PERMISSION_PATTERN.test(message);
+}
+function needs_index_route(context) {
+  return context.lane_child && asks_index_permission(context.message);
+}
+function language_note(lang) {
+  return `Write your reply in the session language (JOSH_SESSION_LANG: ${lang}); code, commands and identifiers stay as they are.`;
+}
+function build_language_reason(lang) {
+  return `\u26D4 session language: your reply is not written in the session language (JOSH_SESSION_LANG: ${lang}). Rewrite it in that language and keep writing in it on the turns that follow, whatever language a notification, tool output or hook message was in (\`CLAUDE.md\` \u2192 "Output language").`;
+}
+function language_reason(context) {
+  if (!reply_language.is_mismatch(context.message, context.session_lang)) return void 0;
+  return build_language_reason(context.session_lang);
+}
+function concise_reason(context) {
+  if (!concise_reply.is_over(context.message, context.prompt)) return void 0;
+  return concise_reply.build_reason(context.message);
+}
+function is_unattended(context) {
+  return context.headless_agent || context.lane_child || context.backlog_parent;
+}
+function needs_filing(context) {
+  if (!is_unattended(context) || context.filed) return false;
+  return filing_offer.offers_filing(context.message) && filing_offer.is_first_party_target(context.message, context.session_owner);
+}
+function is_held_idle(context) {
+  if (context.hold_issue === void 0 || !context.hold_owned) return false;
+  return !context.agent_pending && !context.handed_off;
+}
+function needs_notify(context) {
+  return is_held_idle(context) && !context.notified && !context.answers_question;
+}
+function needs_decision(context) {
+  return needs_notify(context) && stop_decision.decision_of(context.message) === void 0;
+}
+function needs_release(context) {
+  return is_held_idle(context) && context.tree_clean && !context.prrun_stopped;
+}
+function reply_reason(context) {
+  if (needs_filing(context)) return FILING_OFFER_REASON;
+  if (context.headless_agent) return void 0;
+  return language_reason(context) ?? concise_reason(context);
+}
+function decision_reason(context) {
+  return needs_decision(context) ? stop_decision.DECISION_REASON : void 0;
+}
+function is_headless_held(context) {
+  if (!context.headless_waiting) return false;
+  return !context.stop_hook_active || context.headless_refusals < HEADLESS_REFUSAL_CAP;
+}
+function count_headless_refusals(tail) {
+  const last_wait = Math.max(...HEADLESS_WAIT_CALLS.map((call) => tail.lastIndexOf(call)));
+  return tail.slice(Math.max(last_wait, 0)).split(HEADLESS_WAIT_MARKER).length - 1;
+}
+function needs_background_wait(context) {
+  return context.lane_child && context.background_pending;
+}
+function background_wait_reason(context) {
+  if (context.command_pending) return lane_background.LANE_BACKGROUND_STOP_REASON;
+  return lane_background.LANE_AGENT_STOP_REASON;
+}
+function lane_reason(context) {
+  if (needs_index_route(context)) return LANE_INDEX_REASON;
+  if (needs_background_wait(context)) return background_wait_reason(context);
+  return void 0;
+}
+function model_reason(context) {
+  const lane = lane_reason(context);
+  if (lane !== void 0) return lane;
+  const reasons = [reply_reason(context), decision_reason(context)].filter(
+    (reason) => reason !== void 0
+  );
+  return reasons.length === 0 ? void 0 : reasons.join("\n\n");
+}
+function notify_actions(context, issue) {
+  const decision = stop_decision.decision_of(context.message);
+  if (decision === void 0 || !needs_notify(context)) return [];
+  return [{ kind: "notify", issue, message: context.message, decision }];
+}
+function hold_actions(context) {
+  const issue = context.hold_issue;
+  if (issue === void 0) return [];
+  const notify = notify_actions(context, issue);
+  return needs_release(context) ? [...notify, { kind: "release", issue }] : notify;
+}
+function block_reason(context) {
+  if (is_headless_held(context)) return HEADLESS_WAIT_REASON;
+  if (context.stop_hook_active || context.cut_pending) return void 0;
+  return model_reason(context);
+}
+function runs_actions(context, reason) {
+  return reason === void 0 && !context.cut_pending && lane_reason(context) === void 0;
+}
+function stop_outcome(context) {
+  const reason = block_reason(context);
+  if (!runs_actions(context, reason)) return { ...NO_OUTCOME2, reason };
+  const actions = hold_actions(context);
+  if (actions.length === 0) return NO_OUTCOME2;
+  return { reason, actions, blocks_on_failure: !context.stop_hook_active };
+}
+function fallback_reason(action) {
+  return action.kind === "notify" ? STOP_NOTIFY_REASON : HOLD_RELEASE_REASON;
+}
+function block_envelope(reason, lang, notice) {
+  const refusal = { decision: BLOCK_DECISION, reason: `${reason} ${language_note(lang)}` };
+  return JSON.stringify(notice === void 0 ? refusal : { ...refusal, systemMessage: notice });
+}
+function notice_envelope2(notice) {
+  return JSON.stringify({ systemMessage: notice });
+}
+function parse_stop_payload(raw_payload) {
+  return json_value.parse_with(raw_payload, stop_payload_schema);
+}
+function is_enabled2() {
+  return hook_decision.is_switch_enabled(SWITCH_ENV_KEY2);
+}
+var stop_rules = {
+  FILING_OFFER_REASON,
+  HEADLESS_REFUSAL_CAP,
+  HEADLESS_WAIT_REASON,
+  HOLD_RELEASE_REASON,
+  LANE_INDEX_REASON,
+  NO_OUTCOME: NO_OUTCOME2,
+  STOP_NOTIFY_REASON,
+  SWITCH_ENV_KEY: SWITCH_ENV_KEY2,
+  block_envelope,
+  build_language_reason,
+  count_headless_refusals,
+  fallback_reason,
+  is_enabled: is_enabled2,
+  notice_envelope: notice_envelope2,
+  parse_stop_payload,
+  stop_outcome
 };
 
 // scripts/run/ship/run-ship-detach.ts
 import { randomUUID } from "node:crypto";
 import { setTimeout as sleep } from "node:timers/promises";
-import { z as z4 } from "zod";
-var LOG_PREFIX = "josh-ship-log-";
+import { z as z6 } from "zod";
+var LOG_PREFIX = durable_state.PREFIX.SHIP_LOG;
 var PID_PREFIX = "josh-ship-pid-";
 var BODY_PREFIX = "josh-ship-notify-";
 var KEY_SEPARATOR = "-";
@@ -1324,18 +2092,18 @@ var SUPERVISED_VALUE = "1";
 var LAUNCHED = "launched";
 var BUSY = "busy";
 var FAILED = "failed";
-var RESULT_PREFIX = "josh-ship-result-";
+var RESULT_PREFIX = durable_state.PREFIX.SHIP_RESULT;
 var RECORD_POLL_MS = 25;
 var RECORD_WAIT_ATTEMPTS = 200;
 var CLAIM_WINDOW_MS = 12e4;
-var ship_record_schema = z4.object({
-  pid: z4.number().int().positive().optional(),
-  process_start: z4.string().optional(),
-  launched_at: z4.number().optional(),
-  launcher_pid: z4.number().int().positive().optional(),
-  launcher_start: z4.string().optional(),
-  launch_id: z4.string(),
-  result: z4.enum(["success", "failed"]).optional()
+var ship_record_schema = z6.object({
+  pid: z6.number().int().positive().optional(),
+  process_start: z6.string().optional(),
+  launched_at: z6.number().optional(),
+  launcher_pid: z6.number().int().positive().optional(),
+  launcher_start: z6.string().optional(),
+  launch_id: z6.string(),
+  result: z6.enum(["success", "failed"]).optional()
 });
 var LAUNCH_MARK = " \xB7 started by process ";
 var HEADER_START = "\n";
@@ -1343,10 +2111,10 @@ function key(prefix, request2) {
   return stamp_file.stamp_path(`${prefix}${request2.number}${KEY_SEPARATOR}`, request2.repository);
 }
 function log_path(repository, number) {
-  return stamp_file.stamp_path(`${LOG_PREFIX}${number}${KEY_SEPARATOR}`, repository, LOG_SUFFIX);
+  return durable_state.path(`${LOG_PREFIX}${number}${KEY_SEPARATOR}`, repository, LOG_SUFFIX);
 }
 function result_path(repository, number) {
-  return stamp_file.stamp_path(`${RESULT_PREFIX}${number}${KEY_SEPARATOR}`, repository);
+  return durable_state.path(`${RESULT_PREFIX}${number}${KEY_SEPARATOR}`, repository);
 }
 function read_record(repository, number) {
   try {
@@ -1373,56 +2141,56 @@ function supervisor_environment(launch_id) {
     [LAUNCH_ID_KEY]: launch_id
   };
 }
-function is_within_claim_window(record2) {
-  return record2.launched_at !== void 0 && Date.now() - record2.launched_at < CLAIM_WINDOW_MS;
+function is_within_claim_window(record3) {
+  return record3.launched_at !== void 0 && Date.now() - record3.launched_at < CLAIM_WINDOW_MS;
 }
-function has_live_identity(pid, record2, read3) {
-  if (record2.process_start === void 0) {
-    return is_within_claim_window(record2) && process_identity.is_live_pid(pid);
+function has_live_identity(pid, record3, read4) {
+  if (record3.process_start === void 0) {
+    return is_within_claim_window(record3) && process_identity.is_live_pid(pid);
   }
-  return process_identity.is_same_process(pid, record2.process_start, read3) !== false;
+  return process_identity.is_same_process(pid, record3.process_start, read4) !== false;
 }
-function result_of(record2, read3) {
-  if (record2.pid === void 0) {
-    const { launcher_pid, launcher_start } = record2;
-    const is_launcher = process_identity.is_same_process(launcher_pid, launcher_start, read3);
+function result_of(record3, read4) {
+  if (record3.pid === void 0) {
+    const { launcher_pid, launcher_start } = record3;
+    const is_launcher = process_identity.is_same_process(launcher_pid, launcher_start, read4);
     return is_launcher === false ? "abnormal" : "running";
   }
-  if (has_live_identity(record2.pid, record2, read3)) return "running";
-  return record2.result ?? "abnormal";
-}
-function read_result(repository, number, read3 = process_identity.read_start) {
-  const record2 = read_record(repository, number);
-  return record2 === void 0 ? void 0 : {
-    launch_id: record2.launch_id,
-    launched_at: record2.launched_at,
-    result: result_of(record2, read3)
+  if (has_live_identity(record3.pid, record3, read4)) return "running";
+  return record3.result ?? "abnormal";
+}
+function read_result(repository, number, read4 = process_identity.read_start) {
+  const record3 = read_record(repository, number);
+  return record3 === void 0 ? void 0 : {
+    launch_id: record3.launch_id,
+    launched_at: record3.launched_at,
+    result: result_of(record3, read4)
   };
 }
 function current_record(repository, number) {
-  const record2 = read_record(repository, number);
-  return record2?.launch_id === process.env[LAUNCH_ID_KEY] ? record2 : void 0;
+  const record3 = read_record(repository, number);
+  return record3?.launch_id === process.env[LAUNCH_ID_KEY] ? record3 : void 0;
 }
 function running_since(repository, number) {
-  const record2 = read_record(repository, number);
-  return record2 !== void 0 && result_of(record2, process_identity.read_start) === "running" ? record2.launched_at : void 0;
+  const record3 = read_record(repository, number);
+  return record3 !== void 0 && result_of(record3, process_identity.read_start) === "running" ? record3.launched_at : void 0;
 }
-function is_pending(record2) {
-  return record2 !== void 0 && record2.pid === void 0;
+function is_pending(record3) {
+  return record3 !== void 0 && record3.pid === void 0;
 }
 async function ready_record(repository, number) {
-  let record2 = current_record(repository, number);
+  let record3 = current_record(repository, number);
   for (let attempt = 0; attempt < RECORD_WAIT_ATTEMPTS; attempt += 1) {
-    if (!is_pending(record2)) return record2;
+    if (!is_pending(record3)) return record3;
     await sleep(RECORD_POLL_MS);
-    record2 = current_record(repository, number);
+    record3 = current_record(repository, number);
   }
   return void 0;
 }
 async function update_record(repository, number, fields) {
-  const record2 = await ready_record(repository, number);
-  if (record2 === void 0) return;
-  stamp_file.replace_stamp(result_path(repository, number), { ...record2, ...fields });
+  const record3 = await ready_record(repository, number);
+  if (record3 === void 0) return;
+  stamp_file.replace_stamp(result_path(repository, number), { ...record3, ...fields });
 }
 async function mark_result(repository, number, code) {
   await update_record(repository, number, { result: code === 0 ? "success" : "failed" });
@@ -1456,6 +2224,7 @@ function supervisor_argv(request2) {
       "josh",
       "ship",
       ...review,
+      ...request2.unpinned_ok,
       ...notify_arguments(request2),
       ...request2.body,
       ...cites,
@@ -1540,8 +2309,11 @@ var run_ship_detach = {
   last_launch,
   log_path,
   read_log,
+  read_record,
+  result_path,
   running_since,
-  supervisor_argv
+  supervisor_argv,
+  supervisor_environment
 };
 
 // scripts/lane/lane-handoff.ts
@@ -1561,17 +2333,17 @@ async function read_repository() {
     return void 0;
   }
 }
-async function ship_reader(read3) {
+async function ship_reader(read4) {
   const repository = await read_repository();
-  return (issue) => repository !== void 0 && run_ship_detach.read_result(repository, issue, read3)?.result === "running";
+  return (issue) => repository !== void 0 && run_ship_detach.read_result(repository, issue, read4)?.result === "running";
 }
-function is_merge_waiting(repository, issue, read3) {
-  if (run_ship_detach.read_result(repository, issue, read3)?.result !== "running") return false;
+function is_merge_waiting(repository, issue, read4) {
+  if (run_ship_detach.read_result(repository, issue, read4)?.result !== "running") return false;
   return run_ship_stage.read_merge_waiting(run_ship_stage.record_path(repository, issue));
 }
-async function merge_wait_reader(read3) {
+async function merge_wait_reader(read4) {
   const repository = await read_repository();
-  return (issue) => repository !== void 0 && is_merge_waiting(repository, issue, read3);
+  return (issue) => repository !== void 0 && is_merge_waiting(repository, issue, read4);
 }
 function is_place_waiting(issue, directory) {
   const repository = git_common_directory.repository(directory);
@@ -1614,6 +2386,7 @@ var AUTO_OK_LABEL = "auto-ok";
 var NEEDS_HUMAN_REVIEW_LABEL = "needs-human-review";
 var ALREADY_DONE_LABEL = "already-done";
 var MEASURED_LABEL = "measured";
+var MEASURED_UNMET_LABEL = "measured:unmet";
 var RELEASE_LABEL = "release";
 var DEFERRED_LABEL = "deferred";
 var NOT_BEFORE_LABEL = "not-before";
@@ -1720,6 +2493,11 @@ var WORKFLOW_LABELS = [
     color: "6f42c1",
     description: "Measurement-only \u2014 a run recorded the result and closed it"
   },
+  {
+    name: MEASURED_UNMET_LABEL,
+    color: "6f42c1",
+    description: "The measurement fell short of the expected effect \u2014 retire or shrink the mechanism"
+  },
   {
     name: DEFERRED_LABEL,
     color: "d4c5f9",
@@ -1765,17 +2543,20 @@ function label_name_of(labels, wanted) {
 function has_label_name(labels, wanted) {
   return label_name_of(labels, wanted) !== void 0;
 }
+function parked_label_of(labels) {
+  return [...PARKED_LABELS].find((label) => has_label_name(labels, label));
+}
 function has_parked_label(labels) {
-  return [...PARKED_LABELS].some((label) => has_label_name(labels, label));
+  return parked_label_of(labels) !== void 0;
 }
 
 // scripts/run/park/run-park.ts
-import { z as z5 } from "zod";
+import { z as z7 } from "zod";
 var PARK_PREFIX = "josh-run-park-";
 var PARK_MAX_AGE_MS = backlog_budget.DEFAULT_IDLE_MS;
-var run_park_schema = z5.object({
-  issue: z5.string(),
-  parked_at: z5.string()
+var run_park_schema = z7.object({
+  issue: z7.string(),
+  parked_at: z7.string()
 });
 function parse_park(raw) {
   return json_value.parse_with(raw, run_park_schema);
@@ -1804,15 +2585,153 @@ function clear(issue, directory) {
 function is_parked_sync(issue, directory, now = /* @__PURE__ */ new Date()) {
   const repository = git_common_directory.repository(directory);
   if (repository === void 0) return false;
-  const read3 = stamp_record.classify(
+  const read4 = stamp_record.classify(
     stamp_file.read_stamp_text(park_path(repository, issue)),
     PARK_SPEC,
     now
   );
-  return read3.kind === "carried" && read3.record.issue === issue;
+  return read4.kind === "carried" && read4.record.issue === issue;
 }
 var run_park = { PARK_MAX_AGE_MS, clear, is_parked_sync, record };
 
+// scripts/rules/git-argv.ts
+var ENV_ASSIGNMENT = /^[A-Za-z_]\w*=/u;
+var WRAPPER_WORDS = /* @__PURE__ */ new Set([
+  "pnpm",
+  "npx",
+  "exec",
+  "run",
+  "sudo",
+  "command",
+  "env",
+  "time"
+]);
+var FLAGGED_WRAPPERS = /* @__PURE__ */ new Set(["time"]);
+var WRAPPER_VALUE_FLAGS = /* @__PURE__ */ new Set(["-o", "-f", "--output", "--format"]);
+var SUBSHELL_OPEN = "(";
+var VALUE_TAKING_GLOBALS = /* @__PURE__ */ new Set([
+  "-C",
+  "-c",
+  "--git-dir",
+  "--work-tree",
+  "--namespace",
+  "--exec-path",
+  "--super-prefix"
+]);
+var FLAG_PREFIX = "-";
+var GIT_COMMAND = "git";
+var NEXT = 1;
+var AFTER_VALUE = 2;
+var WORD = /(?:\\.|'[^']*'|"(?:\\.|[^"\\])*"|\S)+/gsu;
+function words_of(segment) {
+  return segment.match(WORD) ?? [];
+}
+var PATH_SEPARATOR = "/";
+function program_name(word) {
+  return word.slice(word.lastIndexOf(PATH_SEPARATOR) + NEXT);
+}
+function is_wrapper_token(word) {
+  return word === SUBSHELL_OPEN || ENV_ASSIGNMENT.test(word) || WRAPPER_WORDS.has(program_name(word));
+}
+function wrapper_flag_width(word = "") {
+  if (!word.startsWith(FLAG_PREFIX)) return 0;
+  return WRAPPER_VALUE_FLAGS.has(word) ? AFTER_VALUE : NEXT;
+}
+function after_wrapper_word(words, index) {
+  let next = index + NEXT;
+  if (!FLAGGED_WRAPPERS.has(program_name(words[index] ?? ""))) return next;
+  let width = wrapper_flag_width(words[next]);
+  while (width > 0) {
+    next += width;
+    width = wrapper_flag_width(words[next]);
+  }
+  return next;
+}
+function after_wrapper(words) {
+  let index = 0;
+  while (index < words.length && is_wrapper_token(words[index] ?? "")) {
+    index = after_wrapper_word(words, index);
+  }
+  return index;
+}
+function global_step(flag) {
+  return VALUE_TAKING_GLOBALS.has(flag) ? AFTER_VALUE : NEXT;
+}
+function after_globals(words, start) {
+  let index = start;
+  while (index < words.length) {
+    const flag = words[index] ?? "";
+    if (!flag.startsWith(FLAG_PREFIX)) return index;
+    index += global_step(flag);
+  }
+  return index;
+}
+function program_of(segment) {
+  const words = words_of(segment);
+  const command_index = after_wrapper(words);
+  const word = words[command_index];
+  if (word === void 0) return void 0;
+  return { name: program_name(word), args: words.slice(command_index + NEXT) };
+}
+function arguments_of(segment, command) {
+  const call = program_of(segment);
+  return call?.name === command ? call.args : void 0;
+}
+function parse(segment) {
+  const words = arguments_of(segment, GIT_COMMAND);
+  if (words === void 0) return void 0;
+  const subcommand_index = after_globals(words, 0);
+  return { subcommand: words[subcommand_index], args: words.slice(subcommand_index + NEXT) };
+}
+var SHORT_CLUSTER = /^-[A-Za-z]+$/u;
+function short_cluster_has(token, letters) {
+  if (!SHORT_CLUSTER.test(token)) return false;
+  const cluster = token.slice(FLAG_PREFIX.length);
+  for (let index = 0; index < letters.length; index += 1) {
+    if (cluster.includes(letters.charAt(index))) return true;
+  }
+  return false;
+}
+var git_argv = { arguments_of, parse, program_of, short_cluster_has };
+
+// scripts/rules/bash-triggers.ts
+function on_bash_command(is_match) {
+  return function is_trigger(call) {
+    if (call.name !== cost_blocks.BASH_TOOL) return false;
+    return is_match(time_shell.bash_command(call.input));
+  };
+}
+var ISSUE_CREATE_COMMAND = /\bgh\s+(?:\S+\s+)*?issue\s+create\b/u;
+var ISSUES_ENDPOINT = /repos\/[^\s'"]*\/issues(?=$|["'\s])/u;
+var TITLE_FIELD = /(?:-f|-F|--field|--raw-field)\s*'?title=/u;
+var GH_API_COMMAND = /\bgh\s+api\b/u;
+var SHELL_SCRIPT_RUNNER = /\b(?:(?:ba|z|da|k)?sh\s+(?:-\w+\s+)*-\w*c\b|eval\b)/u;
+function spoken_line(command) {
+  if (time_shell.has_heredoc(command)) return command;
+  const plain = time_shell.unquoted(command);
+  return SHELL_SCRIPT_RUNNER.test(plain) ? command : plain;
+}
+var LEADING_SHELL_SCRIPT_RUNNER = new RegExp(`^${SHELL_SCRIPT_RUNNER.source}`, "u");
+var QUOTE_MARK = /["']/gu;
+function shell_script_of(segment) {
+  const call = git_argv.program_of(segment);
+  if (call === void 0) return void 0;
+  const spoken = [call.name, ...call.args].join(" ");
+  const runner = LEADING_SHELL_SCRIPT_RUNNER.exec(spoken);
+  if (runner === null) return void 0;
+  return spoken.slice(runner[0].length).replaceAll(QUOTE_MARK, "").trim();
+}
+function is_direct_filing(command) {
+  const spoken = spoken_line(command);
+  if (ISSUE_CREATE_COMMAND.test(spoken)) return true;
+  return GH_API_COMMAND.test(spoken) && ISSUES_ENDPOINT.test(command) && TITLE_FIELD.test(command);
+}
+var FILING_NAMES = /* @__PURE__ */ new Set(["issue:file"]);
+function is_issue_filing(command) {
+  return shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, FILING_NAMES));
+}
+var bash_triggers = { is_direct_filing, is_issue_filing, on_bash_command, shell_script_of };
+
 // scripts/rules/lane-park.ts
 var NOTIFY_COMMANDS = /* @__PURE__ */ new Set(["notify"]);
 var CONFIRMATION_TASK_TYPE = /(?:^|\s)--task-type[=\s]+["']?confirmation\b/u;
@@ -1852,7 +2771,7 @@ function records_the_park(command) {
   if (APPLIES_NEEDS_DECISION.test(command)) return true;
   return shell_segments.segments_of(command).some((segment) => is_park_command(segment));
 }
-var LANE_PARK_REASON = "\u26D4 lane child park: this session is a dispatched lane child, so a stop for a person parks first: `pnpm josh run:park <N> --body-file <path>` (question, options, stash \u2014 it applies `needs-decision`); a `needs-human-review` / `already-done` stop already is. Reissue this notify, once per run (`.claude/skills/workflow-commands/pre-gate-cut.md`).";
+var LANE_PARK_REASON = "\u26D4 lane child park: this session is a dispatched lane child, so a stop for a person parks first: `pnpm josh run:park <N> --body-file <path>` (question, options, stash \u2014 it applies `needs-decision`); a `needs-human-review` / `already-done` stop already is. The park is the stop: no notify after it. Refused once per run (`.claude/skills/workflow-commands/pre-gate-cut.md`).";
 var ROW3 = {
   id: "lane-park",
   is_trigger: bash_triggers.on_bash_command(is_unparked_stop),
@@ -1879,19 +2798,19 @@ var lane_park = {
 
 // scripts/cost-runtime/codex-usage.ts
 import { globSync, readFileSync as readFileSync2 } from "node:fs";
-import path from "node:path";
-import { z as z6 } from "zod";
+import path5 from "node:path";
+import { z as z8 } from "zod";
 var THREAD_ID_PATTERN = /^[A-Za-z0-9-]+$/u;
-var SESSION_META_SCHEMA = z6.looseObject({
-  type: z6.literal("session_meta"),
-  payload: z6.looseObject({ id: z6.string(), cwd: z6.string() })
+var SESSION_META_SCHEMA = z8.looseObject({
+  type: z8.literal("session_meta"),
+  payload: z8.looseObject({ id: z8.string(), cwd: z8.string() })
 });
-var TOTAL_USAGE_SCHEMA = z6.looseObject({ input_tokens: z6.number().nonnegative() });
-var TOKEN_COUNT_SCHEMA = z6.looseObject({
-  type: z6.literal("event_msg"),
-  payload: z6.looseObject({
-    type: z6.literal("token_count"),
-    info: z6.looseObject({
+var TOTAL_USAGE_SCHEMA = z8.looseObject({ input_tokens: z8.number().nonnegative() });
+var TOKEN_COUNT_SCHEMA = z8.looseObject({
+  type: z8.literal("event_msg"),
+  payload: z8.looseObject({
+    type: z8.literal("token_count"),
+    info: z8.looseObject({
       total_token_usage: TOTAL_USAGE_SCHEMA,
       last_token_usage: TOTAL_USAGE_SCHEMA
     })
@@ -1900,52 +2819,197 @@ var TOKEN_COUNT_SCHEMA = z6.looseObject({
 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 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) => path5.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"] ?? path5.join(default_home, ".codex");
+  return latest_measurement(rollout_files(home, thread_id), target, thread_id);
+}
+var codex_usage = { measurement };
+
+// scripts/cost-runtime/cost-pricing.ts
+var CACHE_WRITE_5M_MULTIPLIER = 1.25;
+var CACHE_WRITE_1H_MULTIPLIER = 2;
+var DEFAULT_CACHE_READ_MULTIPLIER = 0.1;
+var HALVED_CACHE_READ_MULTIPLIER = 0.05;
+var QUARTERED_CACHE_READ_MULTIPLIER = 0.025;
+var TOKENS_PER_MILLION = 1e6;
+var LONG_PROMPT_SUFFIX = ":long-prompt";
+var LONG_PROMPT_THRESHOLD = 1e5;
+var MODEL_PRICES = {
+  "claude-fable-5-1": {
+    input: 10,
+    output: 50,
+    cache_read_multiplier: QUARTERED_CACHE_READ_MULTIPLIER
+  },
+  "claude-mythos-5-1": {
+    input: 10,
+    output: 50,
+    cache_read_multiplier: QUARTERED_CACHE_READ_MULTIPLIER
+  },
+  "claude-fable-5": { input: 10, output: 50 },
+  "claude-mythos-5": { input: 10, output: 50 },
+  "claude-opus-5-5": { input: 4, output: 20, cache_read_multiplier: HALVED_CACHE_READ_MULTIPLIER },
+  "claude-opus-5": { input: 5, output: 25 },
+  "claude-opus-4-8": { input: 5, output: 25 },
+  "claude-opus-4-7": { input: 5, output: 25 },
+  "claude-opus-4-6": { input: 5, output: 25 },
+  "claude-sonnet-5-5": {
+    input: 2,
+    output: 10,
+    cache_read_multiplier: HALVED_CACHE_READ_MULTIPLIER
+  },
+  "claude-sonnet-5": { input: 2, output: 10 },
+  "claude-sonnet-4-6": { input: 3, output: 15 },
+  "claude-haiku-5-5": { input: 0.1, output: 0.5 },
+  [`claude-haiku-5-5${LONG_PROMPT_SUFFIX}`]: { input: 0.5, output: 2.5 },
+  "claude-haiku-4-5": { input: 1, output: 5 }
+};
+var CONTEXT_MARKER = "[";
+var DATE_SUFFIX = /-\d{8}$/u;
+function known_id(model) {
+  const base = model.split(CONTEXT_MARKER)[0] ?? model;
+  return [base, base.replace(DATE_SUFFIX, "")].find((id) => Object.hasOwn(MODEL_PRICES, id));
+}
+function resolve_price(model) {
+  const id = known_id(model);
+  return id === void 0 ? void 0 : MODEL_PRICES[id];
+}
+function cache_read_multiplier(price) {
+  return price.cache_read_multiplier ?? DEFAULT_CACHE_READ_MULTIPLIER;
+}
+function cache_read_multiplier_of(model) {
+  const price = model === void 0 ? void 0 : resolve_price(model);
+  return price === void 0 ? DEFAULT_CACHE_READ_MULTIPLIER : cache_read_multiplier(price);
+}
+function estimate_cost(totals, price) {
+  const weighted_input = totals.input_tokens + totals.cache_write_5m_tokens * CACHE_WRITE_5M_MULTIPLIER + totals.cache_write_1h_tokens * CACHE_WRITE_1H_MULTIPLIER + totals.cache_read_tokens * cache_read_multiplier(price);
+  return (weighted_input * price.input + totals.output_tokens * price.output) / TOKENS_PER_MILLION;
+}
+function priced(tokens, rate) {
+  return tokens * rate / TOKENS_PER_MILLION;
+}
+function estimate_composition(totals, price) {
+  return {
+    input_usd: priced(totals.input_tokens, price.input),
+    cache_write_5m_usd: priced(
+      totals.cache_write_5m_tokens * CACHE_WRITE_5M_MULTIPLIER,
+      price.input
+    ),
+    cache_write_1h_usd: priced(
+      totals.cache_write_1h_tokens * CACHE_WRITE_1H_MULTIPLIER,
+      price.input
+    ),
+    cache_read_usd: priced(totals.cache_read_tokens * cache_read_multiplier(price), price.input),
+    output_usd: priced(totals.output_tokens, price.output)
+  };
+}
+function to_model_cost(model, totals) {
+  const price = resolve_price(model);
+  if (price === void 0) return { model, totals };
+  return { model, totals, cost_usd: estimate_cost(totals, price) };
 }
-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;
+function billed_model(usage) {
+  const long_id = `${known_id(usage.model) ?? usage.model}${LONG_PROMPT_SUFFIX}`;
+  const is_long = cost_usage.billed_input(usage.totals) > LONG_PROMPT_THRESHOLD;
+  return is_long && Object.hasOwn(MODEL_PRICES, long_id) ? long_id : usage.model;
+}
+function cost_by_model(records) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const record3 of records) {
+    const model = billed_model(record3);
+    const running = grouped.get(model) ?? cost_usage.EMPTY_TOTALS;
+    grouped.set(model, cost_usage.add_totals(running, record3.totals));
   }
-  return { billed_input_per_request: billed_per_request(usages) };
+  return [...grouped].map(([model, totals]) => to_model_cost(model, totals));
 }
-function rollout_files(home, thread_id) {
-  if (!THREAD_ID_PATTERN.test(thread_id)) return [];
-  return globSync(`sessions/**/*${thread_id}.jsonl`, { cwd: home }).map(
-    (file) => path.join(home, file)
-  );
+function total_cost(costs) {
+  return {
+    usd: costs.reduce((sum, entry) => sum + (entry.cost_usd ?? 0), 0),
+    unpriced: costs.filter((entry) => entry.cost_usd === void 0).map((entry) => entry.model)
+  };
 }
-function read_measurement(file, target, thread_id) {
-  try {
-    return measurement_from(readFileSync2(file, "utf8"), target, thread_id);
-  } catch {
-    return void 0;
-  }
+function cost_of(records) {
+  return total_cost(cost_by_model(records)).usd;
 }
-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;
+var cost_pricing = {
+  CACHE_WRITE_5M_MULTIPLIER,
+  CACHE_WRITE_1H_MULTIPLIER,
+  DEFAULT_CACHE_READ_MULTIPLIER,
+  LONG_PROMPT_THRESHOLD,
+  resolve_price,
+  cache_read_multiplier_of,
+  estimate_cost,
+  estimate_composition,
+  cost_by_model,
+  total_cost,
+  cost_of
+};
+
+// scripts/cost-runtime/context-cut-payback.ts
+var POST_CUT_CONTEXT = 6e4;
+var EXPECTED_REMAINING_REQUESTS = 23;
+function write_over_read(model) {
+  return cost_pricing.CACHE_WRITE_5M_MULTIPLIER / cost_pricing.cache_read_multiplier_of(model);
 }
-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"] ?? path.join(default_home, ".codex");
-  return latest_measurement(rollout_files(home, thread_id), target, thread_id);
+function break_even_context(model, remaining = EXPECTED_REMAINING_REQUESTS) {
+  if (remaining <= 0) return Infinity;
+  return Math.round(POST_CUT_CONTEXT * (1 + write_over_read(model) / remaining));
 }
-var codex_usage = { measurement };
+function break_even_requests(current_context, model) {
+  const saved_per_request = current_context - POST_CUT_CONTEXT;
+  if (saved_per_request <= 0) return Infinity;
+  return POST_CUT_CONTEXT * write_over_read(model) / saved_per_request;
+}
+function pays_back(current_context, model, remaining = EXPECTED_REMAINING_REQUESTS) {
+  return current_context > break_even_context(model, remaining);
+}
+var context_cut_payback = {
+  POST_CUT_CONTEXT,
+  EXPECTED_REMAINING_REQUESTS,
+  break_even_context,
+  break_even_requests,
+  pays_back
+};
 
 // scripts/cost-runtime/cost-corpus.ts
 function accumulate_missing(sessions) {
@@ -1987,8 +3051,8 @@ function owner_sets(corpus, meta) {
 }
 function pairs_with_inherited(session, inherited, is_delegated) {
   return cost_attribute.group_by_issue(session.records).flatMap(
-    (group) => group.records.map((record2) => ({
-      record: record2,
+    (group) => group.records.map((record3) => ({
+      record: record3,
       issue: group.issue === cost_attribute.UNATTRIBUTED_KEY ? inherited : group.issue,
       baseline_tokens: session.baseline_tokens,
       session_id: session.session_id,
@@ -2070,7 +3134,7 @@ var UNDER_VERDICT = "under";
 function per_request_cost(measurement2) {
   return measurement2.billed_input_per_request.at(-1) ?? 0;
 }
-function classify2(measurement2, limit) {
+function classify3(measurement2, limit) {
   return per_request_cost(measurement2) > limit ? OVER_VERDICT : UNDER_VERDICT;
 }
 function over_summary(measurement2, limit) {
@@ -2082,22 +3146,22 @@ function report_over(measurement2, limit) {
     console.error("No requests in this session; there is nothing to hand off.");
     return FAILURE_EXIT_CODE;
   }
-  console.info(classify2(measurement2, limit));
+  console.info(classify3(measurement2, limit));
   console.error(over_summary(measurement2, limit));
   return 0;
 }
 var cost_verdict = {
   OVER_VERDICT,
   UNDER_VERDICT,
-  classify: classify2,
+  classify: classify3,
   per_request_cost,
   report_over
 };
 
 // scripts/cost-runtime/transcript-cwd.ts
-import path2 from "node:path";
+import path6 from "node:path";
 function resolve(target, cwd) {
-  return target === void 0 ? cwd : path2.resolve(target);
+  return target === void 0 ? cwd : path6.resolve(target);
 }
 var transcript_cwd = { resolve };
 
@@ -2105,6 +3169,7 @@ var transcript_cwd = { resolve };
 var FAILURE_EXIT_CODE2 = 1;
 var USAGE = "Usage: josh cost (--cut | --over <tokens-per-request>) [--path <dir>]";
 var UNMEASURABLE_VERDICT = "unmeasurable";
+var CUT_LIMIT = "cut";
 function to_threshold(raw) {
   if (raw === void 0 || raw.trim() === "") return void 0;
   const parsed = Number(raw);
@@ -2113,19 +3178,24 @@ function to_threshold(raw) {
 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 cut_threshold(measurement2) {
+  return context_cut_payback.break_even_context(measurement2?.model);
+}
+function limit_of(limit, measurement2) {
+  return limit === CUT_LIMIT ? cut_threshold(measurement2) : limit;
 }
 function threshold_option(over) {
   return over === void 0 ? {} : { over };
 }
-function path_option(path15) {
-  return path15 === void 0 ? {} : { path: path15 };
+function path_option(path19) {
+  return path19 === void 0 ? {} : { path: path19 };
+}
+function cut_options(values) {
+  return values.over === void 0 ? { over: CUT_LIMIT, ...path_option(values.path) } : void 0;
 }
 function to_options(values) {
-  if (values.cut === true && values.over !== void 0) return void 0;
-  const over = selected_threshold(values);
+  if (values.cut === true) return cut_options(values);
+  const over = to_threshold(values.over);
   if (is_unparsed(values.over, over)) return void 0;
   return { ...threshold_option(over), ...path_option(values.path) };
 }
@@ -2144,15 +3214,16 @@ function report_empty(cwd, session_id) {
   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;
+  const resolved2 = agent_role_profile.resolve_provider(environment);
+  if (resolved2.kind !== "provider" || resolved2.is_default === true) return void 0;
+  return resolved2.provider;
 }
 function measurement_of(session) {
   return {
     billed_input_per_request: session.records.map(
-      (record2) => cost_usage.billed_input(record2.totals)
-    )
+      (record3) => cost_usage.billed_input(record3.totals)
+    ),
+    model: session.records.at(-1)?.model
   };
 }
 function anthropic_own(target, environment) {
@@ -2183,12 +3254,16 @@ 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);
+  if (own.kind === "measured") {
+    return cost_verdict.report_over(own.measurement, limit_of(limit, own.measurement));
+  }
   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);
+  if (measurement2 !== void 0) {
+    return cost_verdict.report_over(measurement2, limit_of(limit, measurement2));
+  }
   console.error(`No Codex usage found for the current OpenAI thread under ${target}.`);
   return FAILURE_EXIT_CODE2;
 }
@@ -2202,13 +3277,13 @@ 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);
+  return cost_verdict.classify(measurement2, cut_threshold(measurement2));
 }
 function figures_of(measurement2) {
   const verdict = verdict_of(measurement2);
   const is_priced = measurement2 !== void 0 && verdict !== UNMEASURABLE_VERDICT;
   const cost = is_priced ? cost_verdict.per_request_cost(measurement2) : void 0;
-  return { verdict, cost, threshold: CONTEXT_CUT_THRESHOLD };
+  return { verdict, cost, threshold: cut_threshold(measurement2) };
 }
 function session_figures(cwd = process.cwd(), environment = process.env) {
   const provider = provider_of(environment);
@@ -2291,7 +3366,7 @@ function is_uncut_gate(command, state = current_state2()) {
   if (!runs_the_gate(command) || uncut_lane_issue(state) === void 0) return false;
   return warrants_the_cut(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`).";
+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 `split-unresolved`, answer its notice and rerun it; 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));
@@ -2307,42 +3382,6 @@ var pre_gate_cut = {
   uncut_lane_issue
 };
 
-// scripts/discovery/repo-party.ts
-var FIRST_PARTY = "first-party";
-var THIRD_PARTY = "third-party";
-var UNKNOWN = "unknown";
-var GH_REPO_ENV_KEY = "GH_REPO";
-var GH_REPO_PATH_SEGMENTS = 2;
-function classify3(session_owner, target) {
-  if (session_owner === void 0 || target === void 0) return UNKNOWN;
-  return session_owner.toLowerCase() === target.toLowerCase() ? FIRST_PARTY : THIRD_PARTY;
-}
-function target_owner(owner_repo) {
-  return repo_origin.parse_origin_url(`https://${repo_origin.GITHUB_HOST}/${owner_repo}`)?.owner;
-}
-function current_owner(repository_path = process.cwd()) {
-  return repo_discovery.resolve_current_owner(repository_path);
-}
-function gh_repo_owners(gh_repo) {
-  return [target_owner(gh_repo.split("/").slice(-GH_REPO_PATH_SEGMENTS).join("/"))];
-}
-function remote_owners(repository_path) {
-  return repo_discovery.read_remote_urls(repository_path).map((url) => repo_origin.parse_origin_url(url)?.owner);
-}
-function placeholder_owners(repository_path = process.cwd(), environment = process.env) {
-  const gh_repo = environment[GH_REPO_ENV_KEY];
-  return gh_repo === void 0 || gh_repo === "" ? remote_owners(repository_path) : gh_repo_owners(gh_repo);
-}
-var repo_party = {
-  FIRST_PARTY,
-  THIRD_PARTY,
-  UNKNOWN,
-  classify: classify3,
-  current_owner,
-  placeholder_owners,
-  target_owner
-};
-
 // scripts/gh/git-gh-repo.ts
 async function repo_get_name_with_owner() {
   try {
@@ -2393,8 +3432,8 @@ function is_selected(rest, request2) {
   return !git_gh_issue_rest.is_pull_request(rest) && matches_body(rest, request2.body_term);
 }
 async function fetch_page(request2, page) {
-  const path15 = listing_path(request2, page);
-  const rows = git_gh_issue_rest.parse_rest_issues(await git_gh_exec.exec_gh_api({ path: path15 }));
+  const path19 = listing_path(request2, page);
+  const rows = git_gh_issue_rest.parse_rest_issues(await git_gh_exec.exec_gh_api({ path: path19 }));
   return {
     selected: rows.filter((row) => is_selected(row, request2)),
     is_full: rows.length >= PER_PAGE
@@ -2489,8 +3528,8 @@ ${issue_watch_diff.RUN_MARKER}` }),
     jq_filter: HTML_URL_FILTER
   });
 }
-async function issue_try_comment(issue_number, body) {
-  return await did_write_succeed(async () => await issue_comment(issue_number, body));
+async function issue_try_comment(issue_number, body, repo) {
+  return await did_write_succeed(async () => await issue_comment(issue_number, body, repo));
 }
 async function close_with(issue_number, comment, state) {
   return await did_write_succeed(async () => {
@@ -2537,7 +3576,9 @@ function issue_create_request(input) {
       ...labels !== void 0 && { labels },
       body: input.body
     }),
-    jq_filter: HTML_URL_FILTER
+    jq_filter: HTML_URL_FILTER,
+    // A 502 can follow an issue GitHub already opened, and a retry would open a second one.
+    should_retry: false
   };
 }
 async function issue_create_with_label(input) {
@@ -2647,10 +3688,10 @@ var LABELLED_FIELDS = "number,body,stateReason";
 var BACKLOG_SCAN_FIELDS = `number,title,body,labels,${BLOCKED_BY_COUNT_FIELD}`;
 var NUMBER_TITLE_AND_LABELS_FIELDS = "number,title,labels";
 var SUMMARY_FIELDS = "number,title,labels,createdAt";
-var PICKUP_FIELDS = `${SUMMARY_FIELDS},blockedBy,body`;
+var PICKUP_FIELDS = `${SUMMARY_FIELDS},blockedBy,body,${gh_author_association.AUTHOR_FIELDS}`;
 var { issue_list: issue_list2 } = git_gh_issue_list;
 async function issue_list_recent(limit) {
-  return await issue_list2({ json_fields: SUMMARY_FIELDS, limit });
+  return await issue_list2({ json_fields: `${SUMMARY_FIELDS},body`, limit });
 }
 async function issue_list_open_bodies(limit) {
   return await issue_list2({ json_fields: BACKLOG_SCAN_FIELDS, limit });
@@ -2702,18 +3743,18 @@ var git_gh_issue = {
 
 // scripts/ci/pr-classification.ts
 import { readFileSync as readFileSync3 } from "node:fs";
-import { z as z7 } from "zod";
+import { z as z9 } from "zod";
 var CLASSIFICATION_SET = new Set(RELEASE_CLASSIFICATION_NAMES);
 var DECLARATION_PREFIX = "- \u30EA\u30EA\u30FC\u30B9\u5206\u985E: ";
 var DECLARATION = new RegExp(`^${DECLARATION_PREFIX}(.+)$`, "gmu");
 var LEGACY_LABELS = /* @__PURE__ */ new Set(["semver-major", "semver-minor"]);
 var LABEL_NAMES_FILTER2 = ".[].name";
-var LABEL = z7.object({ name: z7.string() });
-var USER = z7.object({ login: z7.string() });
-var PULL_REQUEST = z7.object({ number: z7.number(), user: USER });
-var EVENT = z7.object({
+var LABEL = z9.object({ name: z9.string() });
+var USER = z9.object({ login: z9.string() });
+var PULL_REQUEST = z9.object({ number: z9.number(), user: USER });
+var EVENT = z9.object({
   pull_request: PULL_REQUEST,
-  repository: z7.object({ full_name: z7.string() })
+  repository: z9.object({ full_name: z9.string() })
 });
 function classification_error(labels, author) {
   const legacy = labels.filter((label) => LEGACY_LABELS.has(label.toLowerCase()));
@@ -2736,7 +3777,7 @@ function release_candidates(candidates) {
   return candidates.filter((candidate) => candidate !== ENHANCEMENT_LABEL);
 }
 function issue_candidates(issue_json) {
-  const issue = z7.object({ labels: z7.array(LABEL), body: z7.string().nullable() }).parse(JSON.parse(issue_json));
+  const issue = z9.object({ labels: z9.array(LABEL), body: z9.string().nullable() }).parse(JSON.parse(issue_json));
   const names = issue.labels.map((label) => label.name.toLowerCase());
   const declared = [...(issue.body ?? "").matchAll(DECLARATION)].map((match) => match[1] ?? "");
   const candidates = [...release_candidates([...names, ...declared].filter(is_classification))];
@@ -2759,10 +3800,10 @@ function select_issue_classification(issue_json) {
   return label;
 }
 function fetch_current_labels(repository, pull_number) {
-  const path15 = git_gh_api_path.issue_labels_api_path(String(pull_number), repository);
+  const path19 = git_gh_api_path.issue_labels_api_path(String(pull_number), repository);
   try {
     const names = git_gh_exec.exec_gh_api_sync({
-      path: path15,
+      path: path19,
       should_paginate: true,
       jq_filter: LABEL_NAMES_FILTER2
     });
@@ -2795,25 +3836,35 @@ async function sleep2(duration_ms) {
 async function wait_between(wait, interval_ms, attempt, attempts) {
   if (attempt < attempts - 1) await wait(interval_ms);
 }
-async function poll_until(is_done, options) {
+async function poll_for(read4, options) {
   const wait = options.sleeper ?? sleep2;
   for (let attempt = 0; attempt < options.attempts; attempt += 1) {
-    if (await is_done()) return true;
+    const value = await read4();
+    if (value !== void 0) return value;
     await wait_between(wait, options.interval_ms, attempt, options.attempts);
   }
-  return false;
+  return void 0;
+}
+async function poll_until(is_done, options) {
+  const is_reached = await poll_for(async () => await is_done() ? true : void 0, options);
+  return is_reached === true;
+}
+async function wait_for(read4, options) {
+  const value = await poll_for(read4, { ...options, attempts: Infinity });
+  if (value === void 0) throw new Error("an unbounded poll ran out of attempts");
+  return value;
 }
-var poll = { poll_until, sleep: sleep2 };
+var poll = { poll_for, poll_until, sleep: sleep2, wait_for };
 
 // scripts/gh/git-gh-branch-rules.ts
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
 var REQUIRED_STATUS_CHECKS_RULE = "required_status_checks";
-var required_check_schema = z8.looseObject({ context: z8.string() });
-var rule_parameters_schema = z8.looseObject({
-  required_status_checks: z8.array(required_check_schema).optional()
+var required_check_schema = z10.looseObject({ context: z10.string() });
+var rule_parameters_schema = z10.looseObject({
+  required_status_checks: z10.array(required_check_schema).optional()
 });
-var branch_rule_schema = z8.looseObject({
-  type: z8.string(),
+var branch_rule_schema = z10.looseObject({
+  type: z10.string(),
   parameters: rule_parameters_schema.nullish()
 });
 var required_contexts_by_branch = /* @__PURE__ */ new Map();
@@ -2844,33 +3895,33 @@ async function read_required_contexts(branch_name) {
 var git_gh_branch_rules = { read_required_contexts };
 
 // scripts/gh/git-gh-poll-read.ts
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 var UNREADABLE_POLL_MESSAGE = "gh api could not read a merge-gate poll";
 var PAGE_SIZE = 100;
 var kept_by_path = /* @__PURE__ */ new Map();
-var page_schema = z9.object({ total_count: z9.number() });
-function unreadable(path15, answer) {
+var page_schema = z11.object({ total_count: z11.number() });
+function unreadable(path19, answer) {
   const cause = answer.kind === "unreadable" ? answer.cause : void 0;
   const reason = cause === void 0 ? "" : `: ${error_text.message_of(cause)}`;
-  return new Error(`${UNREADABLE_POLL_MESSAGE}: ${path15}${reason}`, { cause });
+  return new Error(`${UNREADABLE_POLL_MESSAGE}: ${path19}${reason}`, { cause });
 }
-function to_body(path15, answer) {
-  const previous = kept_by_path.get(path15);
+function to_body(path19, answer) {
+  const previous = kept_by_path.get(path19);
   if (previous !== void 0 && answer.kind === "unchanged") return previous.body;
-  if (answer.kind !== "changed") throw unreadable(path15, answer);
-  if (answer.etag !== void 0) kept_by_path.set(path15, { etag: answer.etag, body: answer.body });
+  if (answer.kind !== "changed") throw unreadable(path19, answer);
+  if (answer.etag !== void 0) kept_by_path.set(path19, { etag: answer.etag, body: answer.body });
   return answer.body;
 }
-async function read(path15) {
-  const answer = await git_gh_conditional.read_conditional(path15, kept_by_path.get(path15)?.etag);
-  return to_body(path15, answer);
+async function read(path19) {
+  const answer = await git_gh_conditional.read_conditional(path19, kept_by_path.get(path19)?.etag);
+  return to_body(path19, answer);
 }
 function is_whole_listing(page) {
   const total = json_value.parse_with(page, page_schema)?.total_count;
   return total !== void 0 && total <= PAGE_SIZE;
 }
-async function read_object_pages(path15) {
-  const full_path = `${path15}${FULL_PAGE_QUERY}`;
+async function read_object_pages(path19) {
+  const full_path = `${path19}${FULL_PAGE_QUERY}`;
   const page = await read(full_path);
   if (is_whole_listing(page)) return `[${page}]`;
   return await git_gh_exec.exec_gh_api({
@@ -2884,15 +3935,45 @@ function forget_poll_reads() {
 }
 var git_gh_poll_read = { UNREADABLE_POLL_MESSAGE, forget_poll_reads, read, read_object_pages };
 
+// scripts/gh/git-gh-pr-graphql-state.ts
+import { z as z12 } from "zod";
+var GRAPHQL_PATH = "graphql";
+var MERGE_STATE_QUERY = "query($id: ID!) { node(id: $id) { ... on PullRequest { mergeStateStatus } } }";
+var NO_MERGE_STATE_MESSAGE = "The merge state cannot be judged: GitHub refuses this pull request as too many files changed, and GraphQL did not answer its mergeStateStatus";
+var merge_state_node_schema = z12.looseObject({ mergeStateStatus: z12.string() });
+var merge_state_data_schema = z12.looseObject({ node: merge_state_node_schema });
+var merge_state_response_schema = z12.looseObject({ data: merge_state_data_schema });
+async function query_merge_state(node_id) {
+  const json = await git_gh_exec.exec_gh_api({
+    path: GRAPHQL_PATH,
+    body: JSON.stringify({ query: MERGE_STATE_QUERY, variables: { id: node_id } })
+  });
+  return parse_json_object_or_undefined(json, merge_state_response_schema)?.data.node.mergeStateStatus;
+}
+async function try_query_merge_state(node_id) {
+  if (node_id === void 0) return void 0;
+  try {
+    return await query_merge_state(node_id);
+  } catch {
+    return void 0;
+  }
+}
+async function read_merge_state_status(listed, detail_error) {
+  const state = await try_query_merge_state(listed.node_id);
+  if (state === void 0) throw new Error(NO_MERGE_STATE_MESSAGE, { cause: detail_error });
+  return state;
+}
+var git_gh_pr_graphql_state = { read_merge_state_status };
+
 // scripts/gh/git-gh-pr-review.ts
-import { z as z10 } from "zod";
+import { z as z13 } from "zod";
 var REVIEW_APPROVED = "APPROVED";
 var REVIEW_CHANGES_REQUESTED = "CHANGES_REQUESTED";
 var REVIEW_NONE = "";
 var STATE_CHANGING_REVIEWS = /* @__PURE__ */ new Set([REVIEW_APPROVED, REVIEW_CHANGES_REQUESTED]);
-var rest_review_schema = z10.looseObject({
-  state: z10.string().optional(),
-  user: z10.looseObject({ login: z10.string().optional() }).nullish()
+var rest_review_schema = z13.looseObject({
+  state: z13.string().optional(),
+  user: z13.looseObject({ login: z13.string().optional() }).nullish()
 });
 var NOT_A_REVIEW_LISTING = "gh api answered something other than a review listing";
 function parse_rest_reviews(reviews_json) {
@@ -2925,18 +4006,18 @@ function to_review_decision(reviews_json) {
 var git_gh_pr_review = { to_review_decision };
 
 // scripts/gh/git-gh-pr-rollup.ts
-import { z as z11 } from "zod";
+import { z as z14 } from "zod";
 var STATUS_CONTEXT_TYPE_NAME = "StatusContext";
 var TYPE_NAME_KEY = "__typename";
-var rollup_element_schema = z11.looseObject({});
-var check_runs_page_schema = z11.looseObject({
+var rollup_element_schema = z14.looseObject({});
+var check_runs_page_schema = z14.looseObject({
   // Required, not optional: GitHub always names the key, and accepting a page without one would
   // answer an empty rollup — which `git-pr-followup.ts` reports as "this branch has no checks".
-  check_runs: z11.array(rollup_element_schema)
+  check_runs: z14.array(rollup_element_schema)
 });
-var id_holder_schema = z11.object({ id: z11.number() });
-var status_page_schema = z11.looseObject({
-  statuses: z11.array(rollup_element_schema)
+var id_holder_schema = z14.object({ id: z14.number() });
+var status_page_schema = z14.looseObject({
+  statuses: z14.array(rollup_element_schema)
 });
 var NOT_A_CHECK_RUNS_LISTING = "gh api answered something other than a check run listing";
 var NOT_A_STATUS_LISTING = "gh api answered something other than a commit status listing";
@@ -3002,9 +4083,9 @@ var git_gh_pr_rollup = {
 
 // scripts/gh/git-gh-pr-snapshot.ts
 var NO_HEAD_SHA_MESSAGE = "gh api answered a pull request with no head commit";
-async function read_array_pages(path15) {
+async function read_array_pages(path19) {
   return await git_gh_exec.exec_gh_api({
-    path: `${path15}${FULL_PAGE_QUERY}`,
+    path: `${path19}${FULL_PAGE_QUERY}`,
     should_paginate: true
   });
 }
@@ -3021,8 +4102,8 @@ async function read_status_check_rollup(commit_sha) {
   return git_gh_pr_rollup.to_status_check_rollup({ check_runs_json, status_json });
 }
 async function pr_get_review_decision(pr_number) {
-  const path15 = git_gh_api_path.pull_reviews_api_path(String(pr_number));
-  return git_gh_pr_review.to_review_decision(await read_array_pages(path15));
+  const path19 = git_gh_api_path.pull_reviews_api_path(String(pr_number));
+  return git_gh_pr_review.to_review_decision(await read_array_pages(path19));
 }
 async function build_checks_fields(pull) {
   const head_sha = read_head_sha(pull);
@@ -3037,12 +4118,19 @@ async function build_checks_fields(pull) {
     requiredContexts: required_contexts
   };
 }
+async function read_detail_or_listed(branch_name, pr_number) {
+  try {
+    return await read_pull(pr_number);
+  } catch (error) {
+    const listed = await read_listed_pull(error, branch_name, pr_number);
+    if (listed === void 0) throw error;
+    const state = await git_gh_pr_graphql_state.read_merge_state_status(listed, error);
+    return { ...listed, mergeable_state: state };
+  }
+}
 async function resolve_pull(branch_name) {
   const pr_number = await require_pr_number(branch_name);
-  const json = await git_gh_exec.exec_gh_api({
-    path: git_gh_api_path.pull_api_path(String(pr_number))
-  });
-  return { pr_number, pull: git_gh_pr_rest.parse_rest_pull(json) };
+  return { pr_number, pull: await read_detail_or_listed(branch_name, pr_number) };
 }
 async function pr_get_checks_snapshot(branch_name) {
   const { pr_number, pull } = await resolve_pull(branch_name);
@@ -3141,9 +4229,9 @@ async function put_merge(pr_number, head_sha) {
 function is_head_moved(error) {
   return gh_failure.failure_of(error)?.status === HEAD_MOVED_STATUS;
 }
-async function read_merge_state(pr_number) {
+async function read_merge_state(branch_name, pr_number) {
   try {
-    return git_gh_pr_rest.is_merged(await read_pull(pr_number));
+    return git_gh_pr_rest.is_merged(await read_pull_or_listed(branch_name, pr_number, read_pull));
   } catch (error) {
     console.warn(`Could not read the pull request back: ${String(error)}`);
     return void 0;
@@ -3152,9 +4240,9 @@ async function read_merge_state(pr_number) {
 async function sleep_between_read_backs(attempt) {
   if (attempt < MERGE_READ_BACK_ATTEMPTS - 1) await poll.sleep(MERGE_READ_BACK_INTERVAL_MS);
 }
-async function has_merge_landed(pr_number, merge_error) {
+async function has_merge_landed(branch_name, pr_number, merge_error) {
   for (let attempt = 0; attempt < MERGE_READ_BACK_ATTEMPTS; attempt += 1) {
-    const is_merged = await read_merge_state(pr_number);
+    const is_merged = await read_merge_state(branch_name, pr_number);
     if (is_merged !== void 0) return is_merged;
     await sleep_between_read_backs(attempt);
   }
@@ -3165,7 +4253,7 @@ async function pr_merge(branch_name, head_sha) {
   try {
     await put_merge(pr_number, head_sha);
   } catch (error) {
-    if (!await has_merge_landed(pr_number, error)) throw error;
+    if (!await has_merge_landed(branch_name, pr_number, error)) throw error;
   }
 }
 var git_gh_pr = {
@@ -3181,12 +4269,14 @@ var git_gh_pr = {
 };
 
 // scripts/gh/git-gh-pr-auto-merge.ts
-var GRAPHQL_PATH = "graphql";
 var OPEN_PULLS_QUERY = `${git_gh_api_path.FULL_PAGE_QUERY}&state=open`;
 var MISSING_NODE_ID_MESSAGE = "gh api answered a pull request without a node_id";
 var ENABLE_AUTO_MERGE_MUTATION = "mutation($id: ID!, $head: GitObjectID!) { enablePullRequestAutoMerge(input: { pullRequestId: $id, mergeMethod: MERGE, expectedHeadOid: $head }) { clientMutationId } }";
+async function read_branch_pull(branch_name) {
+  return await read_pull_or_listed(branch_name, await require_pr_number(branch_name), read_pull);
+}
 async function pr_enable_auto_merge(branch_name, head_sha) {
-  const pull = await read_pull(await require_pr_number(branch_name));
+  const pull = await read_branch_pull(branch_name);
   if (pull.node_id === void 0) throw new Error(MISSING_NODE_ID_MESSAGE);
   await git_gh_exec.exec_gh_api({
     path: GRAPHQL_PATH,
@@ -3198,7 +4288,7 @@ async function pr_enable_auto_merge(branch_name, head_sha) {
 }
 async function pr_is_merged(branch_name) {
   try {
-    return git_gh_pr_rest.is_merged(await read_pull(await require_pr_number(branch_name)));
+    return git_gh_pr_rest.is_merged(await read_branch_pull(branch_name));
   } catch (error) {
     error_text.trace_swallowed("git_gh_pr_auto_merge.pr_is_merged", error);
     return false;
@@ -3304,16 +4394,16 @@ function to_exhaustion_error(last_read_failure) {
 }
 async function attempt_pr_success_poll(input) {
   const evaluator = input.options.evaluator ?? MERGE_GATE_EVALUATOR;
-  const read3 = await read_pr_state(input, evaluator);
-  if (read3.kind === "unreadable") return await retry_after_unreadable(input, read3.cause);
+  const read4 = await read_pr_state(input, evaluator);
+  if (read4.kind === "unreadable") return await retry_after_unreadable(input, read4.cause);
   const classification = classify_poll_result({
-    snapshot: read3.snapshot,
+    snapshot: read4.snapshot,
     stable_count: input.stable_count,
     required_stable_reads: input.options.required_stable_reads,
     evaluator
   });
   if (classification.is_done) {
-    return { snapshot: read3.snapshot, next_stable_count: 0, next_failure_count: 0 };
+    return { snapshot: read4.snapshot, next_stable_count: 0, next_failure_count: 0 };
   }
   await sleep_before_next_attempt(input);
   return { next_stable_count: classification.next_stable_count, next_failure_count: 0 };
@@ -3437,7 +4527,7 @@ function get_repo_name_with_owner_within(timeout_ms) {
 var gh_spawn = { get_repo_name_with_owner, get_repo_name_with_owner_within };
 
 // scripts/issue/issue-state.ts
-import { z as z12 } from "zod";
+import { z as z15 } from "zod";
 var NO_LABELS = "(none)";
 var LABEL_SEPARATOR = ", ";
 var STATE_LABEL = "state: ";
@@ -3447,9 +4537,9 @@ var YES = "yes";
 var NO = "no";
 var ISSUE_LABEL = "issue: ";
 var HUMAN_REVIEW_LABELS = /* @__PURE__ */ new Set([NEEDS_HUMAN_REVIEW_LABEL]);
-var label_schema = z12.looseObject({ name: z12.string() });
-var issue_state_schema = z12.looseObject({
-  state: z12.string(),
+var label_schema = z15.looseObject({ name: z15.string() });
+var issue_state_schema = z15.looseObject({
+  state: z15.string(),
   labels: label_schema.array().optional()
 });
 function parse_issue_state(json) {
@@ -3479,7 +4569,11 @@ function format_attributed_issue_state(issue_number, state) {
   return `${ISSUE_LABEL}${issue_number}
 ${format_issue_state(state)}`;
 }
+function is_planned(read4) {
+  return read4.kind === "state" && has_label_name(read4.state.labels, PLANNED_LABEL);
+}
 var issue_state = {
+  is_planned,
   NO_LABELS,
   parse_issue_state,
   format_issue_state,
@@ -3487,32 +4581,32 @@ var issue_state = {
 };
 
 // scripts/run/run-liveness.ts
-import { readFileSync as readFileSync4, realpathSync, statSync } from "node:fs";
+import { readFileSync as readFileSync4, realpathSync, statSync as statSync2 } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import path3 from "node:path";
+import path7 from "node:path";
 import { setTimeout as sleep3 } from "node:timers/promises";
 
 // scripts/agent/agent-event.ts
-import { z as z15 } from "zod";
+import { z as z18 } from "zod";
 
 // scripts/agent/claude-result-event.ts
-import { z as z14 } from "zod";
+import { z as z17 } from "zod";
 
 // scripts/agent/interactive-ask.ts
-import { z as z13 } from "zod";
+import { z as z16 } from "zod";
 var INTERACTIVE_TOOLS = /* @__PURE__ */ new Set(["AskUserQuestion"]);
 function is_interactive_tool(name) {
   return INTERACTIVE_TOOLS.has(name);
 }
-var OPTION_SCHEMA = z13.looseObject({ label: z13.string().optional() });
-var QUESTION_SCHEMA = z13.looseObject({
-  question: z13.string().optional(),
-  options: z13.array(OPTION_SCHEMA).optional()
+var OPTION_SCHEMA = z16.looseObject({ label: z16.string().optional() });
+var QUESTION_SCHEMA = z16.looseObject({
+  question: z16.string().optional(),
+  options: z16.array(OPTION_SCHEMA).optional()
 });
-var ASK_INPUT_SCHEMA = z13.looseObject({ questions: z13.array(QUESTION_SCHEMA).optional() });
-var DENIAL_SCHEMA = z13.looseObject({
-  tool_name: z13.string().optional(),
-  tool_input: z13.unknown().optional()
+var ASK_INPUT_SCHEMA = z16.looseObject({ questions: z16.array(QUESTION_SCHEMA).optional() });
+var DENIAL_SCHEMA = z16.looseObject({
+  tool_name: z16.string().optional(),
+  tool_input: z16.unknown().optional()
 });
 var UNKNOWN_QUESTION = "(question text unavailable)";
 var OPTION_SEPARATOR = " / ";
@@ -3541,20 +4635,20 @@ function refused_ask_of(permission_denials) {
 var interactive_ask = { is_interactive_tool, refused_ask_of };
 
 // scripts/agent/claude-result-event.ts
-var RESULT_EVENT_SCHEMA = z14.looseObject({
-  type: z14.literal("result"),
-  is_error: z14.unknown().optional(),
-  subtype: z14.unknown().optional(),
-  num_turns: z14.unknown().optional(),
-  permission_denials: z14.unknown().optional(),
-  result: z14.unknown().optional(),
-  session_id: z14.unknown().optional(),
-  usage: z14.unknown().optional()
+var RESULT_EVENT_SCHEMA = z17.looseObject({
+  type: z17.literal("result"),
+  is_error: z17.unknown().optional(),
+  subtype: z17.unknown().optional(),
+  num_turns: z17.unknown().optional(),
+  permission_denials: z17.unknown().optional(),
+  result: z17.unknown().optional(),
+  session_id: z17.unknown().optional(),
+  usage: z17.unknown().optional()
 });
-var USAGE_SCHEMA = z14.looseObject({
-  input_tokens: z14.unknown().optional(),
-  cache_read_input_tokens: z14.unknown().optional(),
-  output_tokens: z14.unknown().optional()
+var USAGE_SCHEMA = z17.looseObject({
+  input_tokens: z17.unknown().optional(),
+  cache_read_input_tokens: z17.unknown().optional(),
+  output_tokens: z17.unknown().optional()
 });
 function usable_reason(value) {
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
@@ -3594,25 +4688,25 @@ var claude_result_event = { decode };
 
 // scripts/agent/agent-event.ts
 var ASSISTANT_TYPE = "assistant";
-var CLAUDE_INIT_SCHEMA = z15.looseObject({ type: z15.literal("system"), subtype: z15.literal("init") });
-var USAGE_SCHEMA2 = z15.looseObject({
-  input_tokens: z15.number().optional(),
-  cached_input_tokens: z15.number().optional(),
-  output_tokens: z15.number().optional()
+var CLAUDE_INIT_SCHEMA = z18.looseObject({ type: z18.literal("system"), subtype: z18.literal("init") });
+var USAGE_SCHEMA2 = z18.looseObject({
+  input_tokens: z18.number().optional(),
+  cached_input_tokens: z18.number().optional(),
+  output_tokens: z18.number().optional()
 });
-var CODEX_START_SCHEMA = z15.looseObject({ type: z15.enum(["thread.started", "turn.started"]) });
-var CODEX_PROGRESS_SCHEMA = z15.looseObject({
-  type: z15.enum(["item.started", "item.updated", "item.completed"]),
-  item: z15.looseObject({ type: z15.string(), text: z15.string().optional() }).optional()
+var CODEX_START_SCHEMA = z18.looseObject({ type: z18.enum(["thread.started", "turn.started"]) });
+var CODEX_PROGRESS_SCHEMA = z18.looseObject({
+  type: z18.enum(["item.started", "item.updated", "item.completed"]),
+  item: z18.looseObject({ type: z18.string(), text: z18.string().optional() }).optional()
 });
-var CODEX_COMPLETE_SCHEMA = z15.looseObject({
-  type: z15.literal("turn.completed"),
+var CODEX_COMPLETE_SCHEMA = z18.looseObject({
+  type: z18.literal("turn.completed"),
   usage: USAGE_SCHEMA2.optional()
 });
-var CODEX_FAILURE_SCHEMA = z15.looseObject({
-  type: z15.enum(["turn.failed", "error"]),
-  error: z15.looseObject({ message: z15.string().optional() }).optional(),
-  message: z15.string().optional()
+var CODEX_FAILURE_SCHEMA = z18.looseObject({
+  type: z18.enum(["turn.failed", "error"]),
+  error: z18.looseObject({ message: z18.string().optional() }).optional(),
+  message: z18.string().optional()
 });
 var EMPTY_STATE = {
   provider: void 0,
@@ -3627,11 +4721,11 @@ var LAUNCH_HEADER_MARKER = " \xB7 started by process ";
 function usable_text(value) {
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
 }
-function claude_progress(record2) {
-  return transcript_record.blocks_of(record2).filter((block) => block.type === transcript_record.TEXT_TYPE).map((block) => usable_text(block.text)).findLast((text2) => text2 !== void 0);
+function claude_progress(record3) {
+  return transcript_record.blocks_of(record3).filter((block) => block.type === transcript_record.TEXT_TYPE).map((block) => usable_text(block.text)).findLast((text2) => text2 !== void 0);
 }
-function is_claude_assistant(record2) {
-  return record2?.type === ASSISTANT_TYPE && record2.message !== void 0 && record2.message !== null;
+function is_claude_assistant(record3) {
+  return record3?.type === ASSISTANT_TYPE && record3.message !== void 0 && record3.message !== null;
 }
 function claude_result(value, state) {
   const result = claude_result_event.decode(value);
@@ -3645,9 +4739,9 @@ function claude_result(value, state) {
   };
 }
 function claude_assistant(value, state) {
-  const record2 = transcript_record.read(value);
-  if (!is_claude_assistant(record2)) return void 0;
-  const progress = claude_progress(record2) ?? state.progress;
+  const record3 = transcript_record.read(value);
+  if (!is_claude_assistant(record3)) return void 0;
+  const progress = claude_progress(record3) ?? state.progress;
   return { ...state, provider: "anthropic", progress };
 }
 function claude_terminal(value, state) {
@@ -3774,7 +4868,7 @@ function to_advice(verdict, has_work_to_stash) {
   if (verdict !== STOPPED_VERDICT) return ADVICE[verdict];
   return has_work_to_stash ? STOPPED_DIRTY_ADVICE : STOPPED_CLEAN_ADVICE;
 }
-function decide4(traces) {
+function decide3(traces) {
   const verdict = to_verdict(traces);
   const has_work_to_stash = verdict === STOPPED_VERDICT && traces.is_tree_dirty;
   return {
@@ -3797,18 +4891,18 @@ var ALLOWED_ROOTS = [
   )
 ];
 function is_within(candidate, root) {
-  const relative = path3.relative(root, candidate);
-  return relative !== "" && !relative.startsWith("..") && !path3.isAbsolute(relative);
+  const relative = path7.relative(root, candidate);
+  return relative !== "" && !relative.startsWith("..") && !path7.isAbsolute(relative);
 }
 function to_safe_path(output_path) {
-  const normalized2 = path3.normalize(output_path);
-  if (!path3.isAbsolute(normalized2)) return void 0;
+  const normalized2 = path7.normalize(output_path);
+  if (!path7.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 });
+  const stats = statSync2(safe_path, { throwIfNoEntry: false });
   if (!stats?.isFile()) return void 0;
   return { mtime_ms: stats.mtimeMs, size: stats.size };
 }
@@ -3854,7 +4948,7 @@ function freshness_of(request2) {
   };
 }
 async function read_traces(request2) {
-  const [is_initial_child_settled, is_output_frozen, is_tree_dirty, record2] = await Promise.all([
+  const [is_initial_child_settled, is_output_frozen, is_tree_dirty, record3] = await Promise.all([
     read_child_settled(request2.issue, request2.repo),
     read_output_frozen(freshness_of(request2)),
     run_hold.is_tree_dirty(),
@@ -3868,17 +4962,17 @@ async function read_traces(request2) {
     is_child_settled,
     is_output_frozen,
     is_tree_dirty,
-    lane_state: record2?.state,
+    lane_state: record3?.state,
     process_trace: request2.process_trace
   };
 }
 async function check(request2) {
   issue_number_shape.require_issue_number(request2.issue);
-  return decide4(await read_traces(request2));
+  return decide3(await read_traces(request2));
 }
 var run_liveness = {
   check,
-  decide: decide4,
+  decide: decide3,
   describe_agent_state,
   read_child_settled,
   read_output_frozen,
@@ -3886,6 +4980,199 @@ var run_liveness = {
   to_safe_path
 };
 
+// scripts/backlog/backlog-overlap.ts
+var CODE_SPAN = /`([^`\s]+)`/gu;
+var LINE_SUFFIX = /:\d+(?:[-:]\d+)?$/u;
+var FILE_EXTENSION = /\.[a-z]\w*$/iu;
+var ROOT_FILE_EXTENSION = /\.(?:[cm]?[jt]sx?|svelte|jsonc?|md|ya?ml|css|html|sh|toml|txt|properties)$/u;
+var GLOB = "*";
+var ISSUE_MARK = "#";
+var SEPARATOR = "/";
+var MIN_DIRECTORY_DEPTH = 2;
+var DOCS_DIRECTORY = "docs/";
+var MARKDOWN = ".md";
+function without_glob(path19) {
+  const glob = path19.indexOf(GLOB);
+  return glob === -1 ? path19 : path19.slice(0, path19.lastIndexOf(SEPARATOR, glob) + 1);
+}
+function is_narrow(directory) {
+  return directory.split(SEPARATOR).filter(Boolean).length >= MIN_DIRECTORY_DEPTH;
+}
+function is_file(path19) {
+  return (path19.includes(SEPARATOR) ? FILE_EXTENSION : ROOT_FILE_EXTENSION).test(path19);
+}
+function claim_of(path19) {
+  if (path19.endsWith(SEPARATOR)) return is_narrow(path19) ? path19 : void 0;
+  return is_file(path19) ? path19 : void 0;
+}
+function path_claims(tokens) {
+  const paths = tokens.filter((token) => !token.includes(ISSUE_MARK)).map((token) => claim_of(without_glob(token.replace(LINE_SUFFIX, ""))));
+  return new Set(paths.filter((path19) => path19 !== void 0));
+}
+function declared_paths(body) {
+  return path_claims([...body.matchAll(CODE_SPAN)].map((match) => match[1] ?? ""));
+}
+function declared_of(issues) {
+  return new Map(issues.map((issue) => [issue.number, declared_paths(issue.body ?? "")]));
+}
+function contains(outer, inner) {
+  return outer.endsWith(SEPARATOR) ? inner.startsWith(outer) : outer === inner;
+}
+function is_shared_document(path19) {
+  return path19.startsWith(DOCS_DIRECTORY) && (path19.endsWith(SEPARATOR) || path19.endsWith(MARKDOWN));
+}
+function overlaps(left, right) {
+  if (is_shared_document(left) || is_shared_document(right)) return false;
+  return contains(left, right) || contains(right, left);
+}
+function claims_of(declared, holders) {
+  const pairs = holders.flatMap(
+    (number) => [...declared.get(number) ?? []].map((path19) => [path19, number])
+  );
+  return new Map(pairs);
+}
+function running_claims(declared, read4) {
+  return claims_of(declared, read4.kind === "busy" ? read4.issues.map((issue) => issue.number) : []);
+}
+function paths_of(child, declared, repo) {
+  if (child.repo !== repo) return /* @__PURE__ */ new Set();
+  return declared.get(child.number) ?? /* @__PURE__ */ new Set();
+}
+function clash_of(claims, paths) {
+  const clashes = [...paths].flatMap(
+    (path19) => [...claims].filter(([claimed]) => overlaps(claimed, path19)).map(([claimed, holder]) => ({ path: path19, claimed, holder }))
+  );
+  return clashes[0];
+}
+function path_clash(paths, declared, holders) {
+  return clash_of(claims_of(declared, holders), paths);
+}
+function running_clash(child, declared, holding) {
+  return path_clash(paths_of(child, declared, holding.repo), declared, holding.holders);
+}
+function holds(declared, holder, waiting) {
+  return clash_of(claims_of(declared, [holder]), declared.get(waiting) ?? /* @__PURE__ */ new Set()) !== void 0;
+}
+function paused_tail(clash, lanes) {
+  const note = lane_state.paused_note(lanes.get(String(clash.holder)));
+  return note === void 0 ? "" : ` \u2014 ${note}`;
+}
+function clash_note(child, clash, lanes) {
+  const waiting = session_cite.issue(child.number, void 0, child.repo);
+  const holder = session_cite.issue(clash.holder, void 0, child.repo);
+  return `${waiting} waits: its \`${clash.path}\` overlaps \`${clash.claimed}\`, which ${holder} declares${paused_tail(clash, lanes)}.`;
+}
+function visit(walk, child, paths) {
+  const clash = clash_of(walk.claims, paths);
+  if (clash === void 0) {
+    walk.offered.push(child);
+    for (const path19 of paths) walk.claims.set(path19, child.number);
+    return;
+  }
+  walk.withheld.push(child);
+  walk.notes.push(clash_note(child, clash, walk.lanes));
+}
+function merged_notice(notice, notes) {
+  const parts = notice === void 0 ? notes : [notice, ...notes];
+  return parts.length === 0 ? void 0 : parts.join("\n");
+}
+function separate(selection, declared, context) {
+  const walk = {
+    claims: running_claims(declared, context.read),
+    lanes: context.lanes ?? /* @__PURE__ */ new Map(),
+    offered: [],
+    withheld: [],
+    notes: []
+  };
+  for (const child of selection.offered) visit(walk, child, paths_of(child, declared, context.repo));
+  const notice = merged_notice(selection.notice, walk.notes);
+  const withheld = [...walk.withheld, ...selection.withheld];
+  return { offered: walk.offered, withheld, ...notice !== void 0 && { notice } };
+}
+var backlog_overlap = {
+  declared_of,
+  declared_paths,
+  holds,
+  path_claims,
+  path_clash,
+  running_clash,
+  separate
+};
+
+// scripts/lane/lane-plan.ts
+import { z as z19 } from "zod";
+var lane_plan_schema = z19.object({
+  issue: z19.number(),
+  paths: z19.array(z19.string()),
+  planned_at: z19.string(),
+  cleared: z19.boolean().optional(),
+  // The lane gave its lane back on this plan (`lane-yield.ts`), so the plan outlives the lane.
+  yielded: z19.boolean().optional()
+});
+function plan_path(repository, issue) {
+  return durable_state.path(durable_state.PREFIX.LANE_PLAN, repository, `-${String(issue)}.json`);
+}
+function record2(plan, directory) {
+  const repository = git_common_directory.repository(directory);
+  if (repository === void 0) return false;
+  stamp_file.replace_stamp(plan_path(repository, plan.issue), plan);
+  return true;
+}
+function remove(issue, directory) {
+  const repository = git_common_directory.repository(directory);
+  if (repository !== void 0) stamp_file.remove_stamp(plan_path(repository, issue));
+}
+function read3(issue, directory) {
+  const repository = git_common_directory.repository(directory);
+  const text2 = repository === void 0 ? void 0 : stamp_file.read_stamp_text(plan_path(repository, issue));
+  return text2 === void 0 ? void 0 : json_value.parse_with(text2, lane_plan_schema);
+}
+function is_uncleared(issue, directory) {
+  return git_common_directory.repository(directory) !== void 0 && read3(issue, directory)?.cleared !== true;
+}
+function release(issue, directory) {
+  if (read3(issue, directory)?.yielded !== true) remove(issue, directory);
+}
+function with_plans(declared, directory) {
+  const replaced = [...declared].map(([issue, paths]) => [
+    issue,
+    new Set(read3(issue, directory)?.paths ?? paths)
+  ]);
+  return new Map(replaced);
+}
+function goes_before(other, plan) {
+  return other.cleared === true || other.planned_at < plan.planned_at;
+}
+function earlier_holders(plan, holders, directory) {
+  return holders.filter((holder) => {
+    const other = holder === plan.issue ? void 0 : read3(holder, directory);
+    return other !== void 0 && goes_before(other, plan);
+  });
+}
+function clash_of2(plan, declared, directory) {
+  const holders = earlier_holders(plan, [...declared.keys()], directory);
+  return backlog_overlap.path_clash(new Set(plan.paths), declared, holders);
+}
+function is_yielded(issue, directory) {
+  return read3(issue, directory)?.yielded === true;
+}
+function is_yield_held(issue, declared, directory) {
+  const plan = read3(issue, directory);
+  return plan?.yielded === true && clash_of2(plan, declared, directory) !== void 0;
+}
+var lane_plan = {
+  clash_of: clash_of2,
+  earlier_holders,
+  is_uncleared,
+  is_yield_held,
+  is_yielded,
+  read: read3,
+  record: record2,
+  release,
+  remove,
+  with_plans
+};
+
 // scripts/run/run-stage.ts
 var KICKOFF = "kickoff";
 var HALFRUN = "halfrun";
@@ -3928,7 +5215,7 @@ function state_of(facts) {
   if (facts.is_halfrun_stopped) return HALFRUN_STOPPED;
   return facts.is_planned ? PLANNED : FRESH;
 }
-function decide5(state, command) {
+function decide4(state, command) {
   const is_reached = STATES.indexOf(state) > COMMANDS.indexOf(command);
   const start = is_reached ? REACHED : STARTS[state];
   return { state, command, start, end: ENDS[command], is_reached };
@@ -3945,7 +5232,7 @@ function format_decision(issue, decision) {
   return `stage ${issue_cite.plain(issue)} \u2014 ${fields.join(" \xB7 ")}`;
 }
 function cell(state, command) {
-  const decision = decide5(state, command);
+  const decision = decide4(state, command);
   return decision.is_reached ? REACHED_CELL : `${decision.start}${CELL_ARROW}${decision.end}`;
 }
 function table_rows() {
@@ -3970,7 +5257,7 @@ var run_stage = {
   REACHED,
   START_TOKENS,
   STATES,
-  decide: decide5,
+  decide: decide4,
   format_decision,
   next_commands,
   next_line,
@@ -3990,8 +5277,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(read4) {
+  return read4.kind === "busy" ? read4.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)}.`;
@@ -4009,18 +5296,18 @@ var BUSY_REASONS = {
   unreadable: unreadable_message2,
   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(read4, repo, limit, ages = NO_AGES) {
+  if (read4.kind === "busy") return lanes_full_message(read4.issues, repo, limit, ages);
+  if (read4.kind === "idle") return "";
+  return BUSY_REASONS[read4.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 read4 = read_json_listing(raw, open_issue_schema);
+  if (read4.kind !== "read") return { kind: "unreadable" };
+  const holders = read4.rows.filter((row) => !is_parked(row));
   if (holders.length > 0) return { kind: "busy", issues: holders };
   return { kind: is_capped ? "truncated" : "idle" };
 }
@@ -4047,26 +5334,26 @@ var epic_busy = {
 
 // scripts/doctor/doctor-consumer.ts
 import { existsSync } from "node:fs";
-import path4 from "node:path";
+import path8 from "node:path";
 
 // scripts/version/kit-descriptor.ts
 var KIT_PACKAGE_NAME = "@joshuafolkken/kit";
 
 // scripts/doctor/doctor-consumer.ts
-import { z as z16 } from "zod";
+import { z as z20 } from "zod";
 var NODE_MODULES = "node_modules";
-var SETTINGS_PATH = path4.join(".claude", "settings.json");
+var SETTINGS_PATH = path8.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 = z16.object({
-  name: z16.string().optional(),
-  dependencies: z16.record(z16.string(), z16.string()).optional(),
-  devDependencies: z16.record(z16.string(), z16.string()).optional()
+var SECRETLINT_BIN = path8.join(NODE_MODULES, ".bin", "secretlint");
+var manifest_schema = z20.object({
+  name: z20.string().optional(),
+  dependencies: z20.record(z20.string(), z20.string()).optional(),
+  devDependencies: z20.record(z20.string(), z20.string()).optional()
 });
-var settings_schema = z16.object({
-  enabledPlugins: z16.record(z16.string(), z16.boolean()).optional()
+var settings_schema = z20.object({
+  enabledPlugins: z20.record(z20.string(), z20.boolean()).optional()
 });
 var STATE_OK = "ok";
 var STATE_TARGET_MISSING = "target-missing";
@@ -4081,10 +5368,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) || existsSync(path4.join(root, NODE_MODULES, KIT_PACKAGE_NAME));
+  return lists_kit_dependency(manifest) || existsSync(path8.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(path8.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;
@@ -4096,13 +5383,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(path8.join(root, CLAUDE_MD));
   if (content === void 0) return STATE_MISSING;
   if (!content.includes(CLAUDE_MD_POINTER)) return STATE_OK;
-  return existsSync(path4.join(root, NODE_MODULES, KIT_PACKAGE_NAME, "dist", CLAUDE_MD)) ? STATE_OK : STATE_TARGET_MISSING;
+  return existsSync(path8.join(root, NODE_MODULES, KIT_PACKAGE_NAME, "dist", CLAUDE_MD)) ? STATE_OK : STATE_TARGET_MISSING;
 }
 function is_secretlint_runnable(root) {
-  return existsSync(path4.join(root, SECRETLINT_BIN));
+  return existsSync(path8.join(root, SECRETLINT_BIN));
 }
 function status_line(is_ok, ok_text, warn_text) {
   return is_ok ? `  \u2713 ${ok_text}` : `  \u26A0 ${warn_text}`;
@@ -4164,11 +5451,11 @@ var doctor_consumer = {
 
 // scripts/gate/project-checks.ts
 import { existsSync as existsSync6, globSync as globSync2 } from "node:fs";
-import path14 from "node:path";
+import path18 from "node:path";
 
 // scripts/init/own-formatter.ts
 import { existsSync as existsSync2 } from "node:fs";
-import path5 from "node:path";
+import path9 from "node:path";
 var OWN_FORMATTER_CONFIGS = [
   "biome.json",
   "biome.jsonc",
@@ -4178,23 +5465,23 @@ var OWN_FORMATTER_CONFIGS = [
   ".dprint.jsonc"
 ];
 function find_config(root) {
-  return OWN_FORMATTER_CONFIGS.find((name) => existsSync2(path5.join(root, name)));
+  return OWN_FORMATTER_CONFIGS.find((name) => existsSync2(path9.join(root, name)));
 }
 var own_formatter = { find_config };
 
 // scripts/init/project-profile.ts
 import { existsSync as existsSync5, readdirSync } from "node:fs";
-import path13 from "node:path";
-import { z as z22 } from "zod";
+import path17 from "node:path";
+import { z as z26 } from "zod";
 
 // scripts/sync/file-content.ts
-import path6 from "node:path";
-var PATH_SEPARATORS = path6.sep === "\\" ? /[/\\]/u : /\//u;
+import path10 from "node:path";
+var PATH_SEPARATORS = path10.sep === "\\" ? /[/\\]/u : /\//u;
 
 // scripts/safe-chain/pack-hook.ts
-import { z as z17 } from "zod";
+import { z as z21 } from "zod";
 var PACK_HOOK_FILE = ".pnpmfile.mjs";
-var manifest_schema2 = z17.looseObject({ private: z17.boolean().optional() });
+var manifest_schema2 = z21.looseObject({ private: z21.boolean().optional() });
 var MESSAGES = {
   written: `  \u2714 synced    ${PACK_HOOK_FILE} (run \`pnpm install\` to refresh pnpmfileChecksum)`,
   unchanged: `  \u2714 unchanged ${PACK_HOOK_FILE}`,
@@ -4229,17 +5516,17 @@ function parse_yaml_documents(content) {
 var yaml_document = { is_mapping_document, parse_yaml, parse_yaml_documents };
 
 // scripts/version/release-window.ts
-import { z as z19 } from "zod";
+import { z as z23 } from "zod";
 
 // scripts/version/release-age.ts
 import { readFileSync as readFileSync5 } from "node:fs";
-import path7 from "node:path";
+import path11 from "node:path";
 import semver from "semver";
-import { z as z18 } from "zod";
+import { z as z22 } from "zod";
 var NO_QUARANTINE_MINUTES = 0;
 var WORKSPACE_PATH = "pnpm-workspace.yaml";
-var workspace_age_schema = z18.object({ minimumReleaseAge: z18.number().int().nonnegative() });
-var release_times_schema = z18.record(z18.string(), z18.string());
+var workspace_age_schema = z22.object({ minimumReleaseAge: z22.number().int().nonnegative() });
+var release_times_schema = z22.record(z22.string(), z22.string());
 function parse_workspace(workspace_content) {
   try {
     return yaml_document.parse_yaml(workspace_content);
@@ -4280,14 +5567,14 @@ function read_minimum_release_age(workspace_path = WORKSPACE_PATH) {
   return read_declared_minimum_release_age(workspace_path) ?? NO_QUARANTINE_MINUTES;
 }
 function find_declared_minimum_release_age(start, boundary) {
-  const declared = read_declared_minimum_release_age(path7.join(start, WORKSPACE_PATH));
+  const declared = read_declared_minimum_release_age(path11.join(start, WORKSPACE_PATH));
   if (declared !== void 0) return declared;
   if (start === boundary) return void 0;
-  const parent = path7.dirname(start);
+  const parent = path11.dirname(start);
   return parent === start ? void 0 : find_declared_minimum_release_age(parent, boundary);
 }
 function read_nearest_minimum_release_age(start, boundary) {
-  return find_declared_minimum_release_age(path7.resolve(start), boundary) ?? NO_QUARANTINE_MINUTES;
+  return find_declared_minimum_release_age(path11.resolve(start), boundary) ?? NO_QUARANTINE_MINUTES;
 }
 var release_age = {
   release_times_schema,
@@ -4299,7 +5586,7 @@ var release_age = {
 };
 
 // scripts/version/release-window.ts
-var exclusions_schema = z19.object({ minimumReleaseAgeExclude: z19.array(z19.string()).optional() });
+var exclusions_schema = z23.object({ minimumReleaseAgeExclude: z23.array(z23.string()).optional() });
 
 // scripts/safe-chain/project-config.ts
 import { dump } from "js-yaml";
@@ -4323,7 +5610,7 @@ function flatten_elements(elements) {
   const scalars = elements.map((line) => line.trim().replace(/,$/u, ""));
   return `[${scalars.join(", ")}]`;
 }
-function collect_block2(lines, start) {
+function collect_block(lines, start) {
   const close = lines.findIndex((line, index) => index > start && ARRAY_CLOSE.test(line));
   if (close === -1) return void 0;
   const elements = lines.slice(start + 1, close);
@@ -4337,7 +5624,7 @@ function try_inline(open, block) {
 }
 function rewrite_at(lines, index, line) {
   const verbatim = { lines: [line], next: index + 1 };
-  const block = is_array_open(line) ? collect_block2(lines, index) : void 0;
+  const block = is_array_open(line) ? collect_block(lines, index) : void 0;
   if (block === void 0) return verbatim;
   const inlined = try_inline(line, block);
   if (inlined === void 0) return verbatim;
@@ -4425,9 +5712,9 @@ function is_matching(entry, matchers) {
     (matcher) => typeof matcher === "string" ? matcher === entry : matcher.test(entry)
   );
 }
-function apply_remove(existing, remove) {
-  if (remove === void 0 || remove.length === 0) return existing;
-  return existing.filter((entry) => !is_matching(entry, remove));
+function apply_remove(existing, remove2) {
+  if (remove2 === void 0 || remove2.length === 0) return existing;
+  return existing.filter((entry) => !is_matching(entry, remove2));
 }
 function collect_additions(kept, ensure) {
   if (ensure === void 0) return [];
@@ -4666,10 +5953,10 @@ function set_json_key(content, key2, 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, path15) {
+function resolve_parent(content, path19) {
   const root = parse_root(content);
   if (root === void 0) return void 0;
-  const parent = path15.length > 1 ? findNodeAtLocation(root, path15.slice(0, -1)) : root;
+  const parent = path19.length > 1 ? findNodeAtLocation(root, path19.slice(0, -1)) : root;
   return parent?.type === "object" ? parent : void 0;
 }
 function cut_ranges(content, parent, ranges) {
@@ -4680,24 +5967,24 @@ function cut_ranges(content, parent, ranges) {
   }
   return next;
 }
-function rebalance_new_last(content, path15) {
-  const parent = resolve_parent(content, path15);
+function rebalance_new_last(content, path19) {
+  const parent = resolve_parent(content, path19);
   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, path15) {
-  const index = property_index(parent, path15.at(-1) ?? "");
+function cut_property(content, parent, path19) {
+  const index = property_index(parent, path19.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, path15) : cut;
+  return did_end_object ? rebalance_new_last(cut, path19) : cut;
 }
-function remove_json_path(content, path15) {
-  const parent = resolve_parent(content, path15);
+function remove_json_path(content, path19) {
+  const parent = resolve_parent(content, path19);
   if (parent === void 0) return content;
-  const next = cut_property(content, parent, path15);
+  const next = cut_property(content, parent, path19);
   return next === content ? content : with_trailing_newline(next);
 }
 function remove_json_key(content, key2) {
@@ -4864,13 +6151,13 @@ var kit_base_preset = {
 
 // scripts/init/tsconfig-preset-migration.ts
 import { existsSync as existsSync3 } from "node:fs";
-import path8 from "node:path";
+import path12 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 existsSync3(path8.resolve(base_directory, entry));
+  return existsSync3(path12.resolve(base_directory, entry));
 }
 function migrate_entry(base_directory, entry) {
   if (!LEGACY_PRESET_ENTRY.test(entry)) return entry;
@@ -4966,11 +6253,11 @@ function merge_owned_entries(current, update) {
   return { ...owned, ...Object.fromEntries(missing) };
 }
 function collect_applicable_updates(parsed, updates) {
-  const resolved = Object.entries(updates).map(([key2, value]) => [
+  const resolved2 = Object.entries(updates).map(([key2, value]) => [
     key2,
     Object.hasOwn(parsed, key2) ? merge_owned_entries(parsed[key2], value) : value
   ]);
-  return Object.fromEntries(resolved.filter(([, merged]) => merged !== void 0));
+  return Object.fromEntries(resolved2.filter(([, merged]) => merged !== void 0));
 }
 function merge_json_object(content, updates) {
   const parsed = parse_jsonc(content);
@@ -5102,10 +6389,10 @@ var init_logic_json_merge = {
 };
 
 // scripts/init/kit-development-versions.ts
-import { z as z20 } from "zod";
-var kit_manifest_schema = z20.object({
-  peerDependencies: z20.record(z20.string(), z20.string()).default({}),
-  devDependencies: z20.record(z20.string(), z20.string())
+import { z as z24 } from "zod";
+var kit_manifest_schema = z24.object({
+  peerDependencies: z24.record(z24.string(), z24.string()).default({}),
+  devDependencies: z24.record(z24.string(), z24.string())
 });
 function read_kit_manifest() {
   return package_manifest.read_manifest(PACKAGE_DIR, kit_manifest_schema);
@@ -5236,14 +6523,14 @@ function resolve_multicriteria_conflicts(existing, template) {
   const existing_ids = get_multicriteria_ids(existing);
   const template_ids = get_multicriteria_ids(template);
   const reusable_ids = existing_ids.filter((id) => !template_ids.includes(id));
-  let resolved = template;
+  let resolved2 = template;
   for (const id of template_ids) {
-    if (!existing_ids.includes(id) || !has_criterion_conflict(existing, resolved, id)) continue;
-    const matching_id = find_matching_criterion(existing, resolved, reusable_ids, id);
-    const replacement_id = matching_id ?? allocate_criterion_id(/* @__PURE__ */ new Set([...existing_ids, ...get_multicriteria_ids(resolved)]));
-    resolved = rename_criterion(resolved, id, replacement_id);
+    if (!existing_ids.includes(id) || !has_criterion_conflict(existing, resolved2, id)) continue;
+    const matching_id = find_matching_criterion(existing, resolved2, reusable_ids, id);
+    const replacement_id = matching_id ?? allocate_criterion_id(/* @__PURE__ */ new Set([...existing_ids, ...get_multicriteria_ids(resolved2)]));
+    resolved2 = rename_criterion(resolved2, id, replacement_id);
   }
-  return resolved;
+  return resolved2;
 }
 function merge_multicriteria_ids(existing, template_content) {
   const existing_value = get_multicriteria_value(existing);
@@ -5284,7 +6571,7 @@ var init_logic_sonar = {
 
 // scripts/init/init-logic-templates.ts
 import { existsSync as existsSync4, readFileSync as readFileSync6 } from "node:fs";
-import path9 from "node:path";
+import path13 from "node:path";
 var ESLINT_VANILLA = `import { create_vanilla_config } from '@joshuafolkken/kit/eslint/vanilla'
 
 export default create_vanilla_config({
@@ -5369,7 +6656,7 @@ function merge_eslint_config(existing) {
   return apply_rules_template(rules_blocks.join(",\n"));
 }
 function detect_tailwind_stylesheet(project_root2) {
-  return existsSync4(path9.join(project_root2, DEFAULT_TAILWIND_STYLESHEET)) ? DEFAULT_TAILWIND_STYLESHEET : void 0;
+  return existsSync4(path13.join(project_root2, DEFAULT_TAILWIND_STYLESHEET)) ? DEFAULT_TAILWIND_STYLESHEET : void 0;
 }
 function generate_prettier_config(stylesheet) {
   const stylesheet_line = stylesheet === void 0 ? "" : `	tailwindStylesheet: '${stylesheet}',
@@ -5383,7 +6670,7 @@ ${stylesheet_line}}
 }
 function existing_stylesheet(existing, project_root2) {
   const named = TAILWIND_STYLESHEET_PATTERN.exec(existing)?.[1];
-  return named !== void 0 && existsSync4(path9.resolve(project_root2, named)) ? named : void 0;
+  return named !== void 0 && existsSync4(path13.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);
@@ -5899,23 +7186,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_SEPARATOR2 = "/";
-function is_inside(path15, directory) {
-  return path15 === directory || path15.startsWith(`${directory}${PATH_SEPARATOR2}`);
+function is_inside(path19, directory) {
+  return path19 === directory || path19.startsWith(`${directory}${PATH_SEPARATOR2}`);
 }
-function matches_file(path15) {
-  return init_logic.get_ai_copy_files().includes(path15);
+function matches_file(path19) {
+  return init_logic.get_ai_copy_files().includes(path19);
 }
-function matches_mapping(path15) {
-  return init_logic.get_ai_copy_file_mappings().some((mapping) => mapping.src === path15 || mapping.dest === path15);
+function matches_mapping(path19) {
+  return init_logic.get_ai_copy_file_mappings().some((mapping) => mapping.src === path19 || mapping.dest === path19);
 }
-function matches_directory(path15) {
-  return init_logic.get_ai_copy_directories().some((directory) => is_inside(path15, directory));
+function matches_directory(path19) {
+  return init_logic.get_ai_copy_directories().some((directory) => is_inside(path19, directory));
 }
-function matches_plugin_skill(path15) {
-  return PLUGIN_SKILL_DIRECTORIES.some((directory) => is_inside(path15, directory));
+function matches_plugin_skill(path19) {
+  return PLUGIN_SKILL_DIRECTORIES.some((directory) => is_inside(path19, directory));
 }
-function matches_synced_path(path15) {
-  return synced_paths.get_synced_paths().includes(path15);
+function matches_synced_path(path19) {
+  return synced_paths.get_synced_paths().includes(path19);
 }
 var MATCHERS = [
   { list: AI_COPY_FILES_LIST, matches: matches_file },
@@ -5924,18 +7211,18 @@ var MATCHERS = [
   { list: PLUGIN_SKILL_DIRECTORIES_LIST, matches: matches_plugin_skill },
   { list: SYNCED_PATHS_LIST, matches: matches_synced_path }
 ];
-function find_list(path15) {
-  return MATCHERS.find((matcher) => matcher.matches(path15))?.list;
+function find_list(path19) {
+  return MATCHERS.find((matcher) => matcher.matches(path19))?.list;
 }
-function to_hit(path15) {
-  const list = find_list(path15);
-  return list === void 0 ? void 0 : { path: path15, list };
+function to_hit(path19) {
+  const list = find_list(path19);
+  return list === void 0 ? void 0 : { path: path19, list };
 }
 function find_managed_paths(paths) {
-  return paths.flatMap((path15) => to_hit(path15) ?? []);
+  return paths.flatMap((path19) => to_hit(path19) ?? []);
 }
 function has_managed_path(paths) {
-  return paths.some((path15) => find_list(path15) !== void 0);
+  return paths.some((path19) => find_list(path19) !== void 0);
 }
 function format_hit(hit) {
   return `${hit.path} (${hit.list})`;
@@ -5951,8 +7238,8 @@ var managed_config_scope = {
 };
 
 // scripts/init/session-language-environment.ts
-import path10 from "node:path";
-var CLAUDE_SETTINGS_PATH = path10.join(".claude", "settings.json");
+import path14 from "node:path";
+var CLAUDE_SETTINGS_PATH = path14.join(".claude", "settings.json");
 var KEY_LINE_PATTERN = new RegExp(
   String.raw`^\s*(?:export\s+)?${session_language.ENV_KEY}\s*=`,
   "mu"
@@ -5962,8 +7249,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 z21 } from "zod";
-var task_array_schema = z21.array(json_object_schema);
+import { z as z25 } from "zod";
+var task_array_schema = z25.array(json_object_schema);
 
 // scripts/init/init-actions.ts
 var BASIC_PRETTIER_CONFIG = "prettier.config.mjs";
@@ -5973,11 +7260,11 @@ var MARKER_TOKEN = "josh-managed-workflow:";
 var MARKER_PREFIX = `# ${MARKER_TOKEN}`;
 
 // scripts/init/claude-plugin-config.ts
-import path11 from "node:path";
+import path15 from "node:path";
 var MARKETPLACE_NAME = "kit";
 var PLUGIN_ID2 = "kit@kit";
 var MARKETPLACE_PATH = "./node_modules/@joshuafolkken/kit";
-var CLAUDE_SETTINGS_DESTINATION = path11.join(".claude", "settings.json");
+var CLAUDE_SETTINGS_DESTINATION = path15.join(".claude", "settings.json");
 var PLUGIN_SETTINGS = {
   extraKnownMarketplaces: {
     [MARKETPLACE_NAME]: { source: { source: "directory", path: MARKETPLACE_PATH } }
@@ -6003,7 +7290,7 @@ var HOOK_DIST_DIR = "dist/hooks";
 var RUN_HOOK_SCRIPT = "scripts/hooks/run-hook.sh";
 var ROOT_LOOKUP = "git rev-parse --show-toplevel";
 var CODEX_ROOT = `$( (unset ${GIT_LOCATION_VARIABLES.join(" ")}; ${ROOT_LOOKUP} 2>/dev/null) || ${ROOT_LOOKUP})`;
-var PROJECT_ROOT_PREFIX = `project_root="\${CLAUDE_PROJECT_DIR:-${CODEX_ROOT}}" && cd "$project_root" && `;
+var PROJECT_ROOT_PREFIX = `export JOSH_HOOK_CWD="$PWD" && project_root="\${CLAUDE_PROJECT_DIR:-${CODEX_ROOT}}" && cd "$project_root" && `;
 function hook_launch_command(name) {
   return `${PROJECT_ROOT_PREFIX}sh ${RUN_HOOK_SCRIPT} ${name}`;
 }
@@ -6039,14 +7326,16 @@ var PLAIN_KIT_COMMANDS = new Set(
 var LOCATION_VARIABLES = "GIT_ALTERNATE_OBJECT_DIRECTORIES GIT_COMMON_DIR GIT_DIR GIT_INDEX_FILE GIT_NAMESPACE GIT_OBJECT_DIRECTORY GIT_WORK_TREE";
 var ROOT_LOOKUP2 = "git rev-parse --show-toplevel";
 var LEGACY_ROOT_PREFIX = `if project_root="$(unset ${LOCATION_VARIABLES}; ${ROOT_LOOKUP2} 2>/dev/null)"; then unset ${LOCATION_VARIABLES}; else project_root="$(${ROOT_LOOKUP2})"; fi && cd "$project_root" && `;
+var PRE_WORKTREE_ROOT_PREFIX = `project_root="\${CLAUDE_PROJECT_DIR:-$( (unset ${LOCATION_VARIABLES}; ${ROOT_LOOKUP2} 2>/dev/null) || ${ROOT_LOOKUP2})}" && cd "$project_root" && `;
 var ROOT_PREFIXES = [
   hook_launch.PROJECT_ROOT_PREFIX,
+  PRE_WORKTREE_ROOT_PREFIX,
   LEGACY_ROOT_PREFIX
 ].map((prefix) => JSON.stringify(prefix).slice(1, -1));
 var [PROJECT_ROOT_PREFIX2 = ""] = ROOT_PREFIXES;
 
 // scripts/init/security-policy.ts
-import path12 from "node:path";
+import path16 from "node:path";
 var SECURITY_MD = "SECURITY.md";
 var SECURITY_TEMPLATE = "templates/SECURITY.md";
 var REPOSITORY_PLACEHOLDER = "{{REPOSITORY}}";
@@ -6062,15 +7351,15 @@ function apply_repository(content, repository) {
   return content.replaceAll(REPOSITORY_PLACEHOLDER, () => repository);
 }
 function apply_repository_for_destination(destination_path, content) {
-  if (path12.basename(destination_path) !== SECURITY_MD) return content;
-  const repository = repository_at(path12.dirname(destination_path));
+  if (path16.basename(destination_path) !== SECURITY_MD) return content;
+  const repository = repository_at(path16.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(path12.join(root, SECURITY_MD)) ?? "";
+  const existing = file_reader.read_if_readable(path16.join(root, SECURITY_MD)) ?? "";
   return new Set(existing.split(LINK_DELIMITER)).has(KIT_ADVISORY_URL);
 }
 function unresolved_warning(root) {
@@ -6190,7 +7479,7 @@ function requested_profile(args, usage = "josh init [--profile basic|full]") {
 }
 function read_manifest(root) {
   if (!existsSync5(package_manifest.manifest_path(root))) return void 0;
-  const parsed = package_manifest.read_manifest(root, z22.unknown());
+  const parsed = package_manifest.read_manifest(root, z26.unknown());
   if (!json_value.is_record(parsed)) throw new Error("package.json must contain an object");
   return parsed;
 }
@@ -6231,12 +7520,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) => path13.join(directory, entry.name))
+    ...entries.filter((entry) => should_visit(entry)).map((entry) => path17.join(directory, entry.name))
   );
-  return entries.filter((entry) => entry.isFile()).map((entry) => path13.join(directory, entry.name));
+  return entries.filter((entry) => entry.isFile()).map((entry) => path17.join(directory, entry.name));
 }
 function is_project_file(root, file) {
-  const relative_path = path13.relative(root, file).split(path13.sep).join(path13.posix.sep);
+  const relative_path = path17.relative(root, file).split(path17.sep).join(path17.posix.sep);
   return !kit_written_paths.is_kit_written(relative_path);
 }
 function list_files(root) {
@@ -6248,7 +7537,7 @@ function list_files(root) {
   return files;
 }
 function file_extensions(root) {
-  return list_files(root).filter((file) => is_project_file(root, file)).map((file) => path13.extname(file));
+  return list_files(root).filter((file) => is_project_file(root, file)).map((file) => path17.extname(file));
 }
 function scan_files(root) {
   const extensions = file_extensions(root);
@@ -6262,7 +7551,7 @@ function has_github_remote(root) {
   return url !== void 0 && repo_origin.parse_origin_url(url) !== void 0;
 }
 function has_git(root) {
-  return existsSync5(path13.join(root, ".git"));
+  return existsSync5(path17.join(root, ".git"));
 }
 function has_workflow(root) {
   return workflow_mark.is_requested() || workflow_mark.is_recorded(read_manifest(root));
@@ -6295,7 +7584,7 @@ var SKIP_MARKER = "\u2014 skipping";
 var NOT_USED_MARKER = "which this project does not use";
 
 // scripts/gate/project-checks.ts
-import { z as z23 } from "zod";
+import { z as z27 } from "zod";
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -6329,7 +7618,7 @@ var CSPELL_CONFIGS = [
 ];
 var TYPE_CONFIGS = ["tsconfig.json", "jsconfig.json"];
 var DEPENDENCY_FIELDS = ["dependencies", "devDependencies"];
-var object_schema = z23.record(z23.string(), z23.unknown());
+var object_schema = z27.record(z27.string(), z27.unknown());
 function project_root(directory) {
   return ancestor_directories.nearest(
     directory,
@@ -6346,7 +7635,7 @@ function has_files(directory, pattern) {
   return globSync2(pattern, { cwd: project_root(directory), exclude: is_ignored }).length > 0;
 }
 function has_config(directory, names) {
-  return names.some((name) => existsSync6(path14.join(project_root(directory), name)));
+  return names.some((name) => existsSync6(path18.join(project_root(directory), name)));
 }
 function has_bin(directory, bin_name) {
   return find_local_bin_upwards(directory, bin_name) !== void 0;
@@ -6360,7 +7649,7 @@ function is_basic_manifest(manifest) {
   return project_profile.parse_profile(josh["profile"]) === "basic";
 }
 function read_manifest2(directory) {
-  return package_manifest.read_manifest_if_valid(project_root(directory), z23.unknown());
+  return package_manifest.read_manifest_if_valid(project_root(directory), z27.unknown());
 }
 function is_basic(directory) {
   return is_basic_manifest(read_manifest2(directory));
@@ -6424,24 +7713,31 @@ var project_checks = {
 export {
   hook_decision,
   bounded_pool,
+  lane_guard_policy,
+  delegation_policy,
+  investigation_reads,
+  duplicate_read_outcome,
   git_argv,
   shell_segments,
   bash_triggers,
+  stop_decision,
+  concise_reply,
+  repo_party,
   tail_commands,
-  filing_cap,
-  CONTEXT_CUT_THRESHOLD,
+  run_cut_handoff,
   cost_verdict,
   cost_cli,
   backlog_budget,
-  run_cut_handoff,
   run_cut,
   run_tail_rule,
   lane_background,
   interactive_ask,
+  stop_rules,
   EPIC_LABEL,
   BUG_LABEL,
   ENHANCEMENT_LABEL,
   IN_PROGRESS_LABEL,
+  PLANNED_LABEL,
   RUN_SOLO_LABEL,
   RUN_LANE_LABEL,
   PRIORITY_HIGH_LABEL,
@@ -6467,7 +7763,6 @@ export {
   release_age,
   gh_spawn,
   project_checks,
-  repo_party,
   MAX_SCANNED,
   git_gh_issue_write,
   SUMMARY_FIELDS,
@@ -6479,5 +7774,7 @@ export {
   PROCESS_ALIVE,
   PROCESS_NONE,
   PROCESS_UNKNOWN,
-  run_liveness
+  run_liveness,
+  backlog_overlap,
+  lane_plan
 };