@joshuafolkken/kit 1.1128.0 → 1.1166.0

package/dist/hooks/{chunk-4JZDP5X5.js → chunk-DYAVAM6S.js}

@@ -297,10 +297,10 @@ var ISSUE_COMMANDS = {
   },
   "issue:file": {
     script: "scripts/issue/issue-file-cli.ts",
-    description: "File an Issue with every filing step: lint, Origin, duplicate scout, labels, then epic:bundle",
+    description: "File an Issue with every filing step: lint, Origin, WIP cap, duplicate scout, labels, then epic:bundle",
     category: "AI tools",
     reference: [
-      "<title> --body-file <path> --depth <0|1|2> [--route <route>] [--label <name>] [--repo <owner/repo>] [--distinct <N,\u2026>]",
+      "<title> --body-file <path> --depth <0|1|2> [--route <route>] [--label <name>] [--repo <owner/repo>] [--distinct <N,\u2026>] [--over-cap] [--no-auto-ok]",
       "automation",
       ["network"]
     ]
@@ -358,7 +358,7 @@ var LANE_COMMANDS = {
     ...LANE_ARGUMENTS,
     description: "Block until any of the named in-flight lane children completes; prints which one finished",
     category: "AI tools",
-    reference: ["<issue> [<issue>...]", "automation", ["processes"]],
+    reference: ["<issue> [<issue>...] [--owner <pid>]", "automation", ["files", "processes"]],
     default_script_arguments: ["await"]
   },
   "lane:launch": {
@@ -811,6 +811,15 @@ var DEV_COMMANDS = {
     // `UserPromptSubmit`, so it must stay eligible for in-process dispatch rather than pay a second
     // tsx start each turn. It calls `process.loadEnvFile` itself through the shared loader.
   },
+  "codex:hook-adapter": {
+    script: "scripts/hooks/codex-hook-adapter.ts",
+    description: "Codex hook: run the pretool or posttool guard on a Codex payload (reads the tool call on stdin)",
+    category: "Development",
+    reference: ["<pretool|posttool>", "automation", ["none"]]
+    // The live-source fallback `scripts/hooks/run-hook.sh` derives from the `codex-hook-adapter`
+    // bundle name (joshuafolkken/kit#3184). **No `tsx_arguments`**, the same as `pretool:guard`
+    // above: it runs before every guarded Codex call.
+  },
   "cspell:dot": {
     script: "scripts/lint/cspell-cached.ts",
     description: "Run spell check including dotfiles",
@@ -1059,6 +1068,13 @@ var PROJECT_COMMANDS = {
       ["files", "git", "network", "processes"]
     ]
   },
+  "dogfood:commit": {
+    script: "scripts/dogfood/dogfood-commit-cli.ts",
+    description: "Make the first commit of a dogfood run's own kit-test-* project",
+    category: "Project",
+    reference: ["<dir>", "automation", ["files", "git"]],
+    is_kit_only: true
+  },
   init: {
     script: "scripts/init/init.ts",
     description: "Initialize config in a new project",
@@ -2085,6 +2101,7 @@ var ISSUE_COMMENT_PATTERN = /\bgh\s+issue\s+comment\b/u;
 var BODY_FLAG_PATTERN = /--body(?:-file)?\b/u;
 var ISSUE_LABELS_PATTERN = /repos\/\S+\/issues\/(\d+)\/labels\b(?!\/)/u;
 var IN_PROGRESS_FIELD = "labels[]=in-progress";
+var RUN_ENTRY_PATTERN = /\bjosh\s+run:entry\s+(\d+)\b/u;
 var NO_ISSUE = cost_attribute.UNATTRIBUTED_KEY;
 function string_field(input, key) {
   if (!json_value.is_record(input)) return "";
@@ -2114,19 +2131,23 @@ function is_issue_comment(command) {
 function is_in_progress_label(command) {
   return ISSUE_LABELS_PATTERN.test(command) && command.includes(IN_PROGRESS_FIELD);
 }
+function is_run_start(command) {
+  return is_in_progress_label(command) || RUN_ENTRY_PATTERN.test(command);
+}
 var COMMAND_SEPARATOR = /&&|\|\||;/u;
-function label_issue(part) {
-  const matched = ISSUE_LABELS_PATTERN.exec(part);
+function declared_issue2(part) {
+  const pattern = is_in_progress_label(part) ? ISSUE_LABELS_PATTERN : RUN_ENTRY_PATTERN;
+  const matched = pattern.exec(part);
   return matched?.[1] === void 0 ? NO_ISSUE : Number(matched[1]);
 }
 function bash_issue(command) {
   for (const part of command.split(COMMAND_SEPARATOR)) {
-    if (is_in_progress_label(part)) return label_issue(part);
+    if (is_run_start(part)) return declared_issue2(part);
   }
   return NO_ISSUE;
 }
 function bash_marker(command) {
-  if (is_in_progress_label(command)) return WORKFLOW_MARKER;
+  if (is_run_start(command)) return WORKFLOW_MARKER;
   return is_api_body_write(command) || is_issue_comment(command) ? PLAN_MARKER : NO_MARKER;
 }
 var time_markers = {
@@ -2573,6 +2594,7 @@ function to_spans(events, finished) {
     is_bundleable: event.is_bundleable,
     targets: event.targets,
     is_writing: event.is_writing,
+    may_write: event.may_write,
     has_prior_reference: event.has_prior_reference,
     writes: event.writes,
     message_id: event.message_id,
@@ -2623,6 +2645,530 @@ var time_spans = {
   parse_timeline
 };
 
+// scripts/time-runtime/time-round-trips.ts
+var CALLS_PER_ROUND_TRIP_FLOOR = 1.5;
+var DENSITY_DECIMALS = 2;
+var NONE = 0;
+function is_tool(span) {
+  return span.category === time_spans.TOOL_CATEGORY;
+}
+function is_model(span) {
+  return span.category === time_spans.MODEL_CATEGORY;
+}
+function started_ms2(span) {
+  return span.ended_ms - span.duration_ms;
+}
+function in_time_order(spans) {
+  return spans.toSorted((left, right) => started_ms2(left) - started_ms2(right));
+}
+function is_tool_at(spans, index) {
+  const span = spans[index];
+  return span !== void 0 && is_tool(span);
+}
+function is_call(span) {
+  return is_tool(span) && !span.is_continuation;
+}
+function count_calls(spans) {
+  return spans.filter((span) => is_call(span)).length;
+}
+function previous_break(spans, index) {
+  for (let back = index - 1; back >= 0; back -= 1) {
+    const span = spans[back];
+    if (span === void 0 || !is_model(span)) return span;
+  }
+  return void 0;
+}
+function continues_turn(spans, index, message_id) {
+  if (message_id === time_spans.NO_MESSAGE_ID) return false;
+  const earlier = previous_break(spans, index);
+  return earlier !== void 0 && !earlier.is_continuation && earlier.message_id === message_id;
+}
+function opens_round_trip(spans, index) {
+  const span = spans[index];
+  if (span === void 0 || !is_tool(span) || span.is_continuation || is_tool_at(spans, index - 1)) {
+    return false;
+  }
+  return !continues_turn(spans, index, span.message_id);
+}
+function open_trip(walk) {
+  walk.open = [];
+  walk.trips.push(walk.open);
+}
+function place_call(walk, span) {
+  if (is_call(span)) walk.open?.push(span);
+}
+function step_trip(walk, span, is_opener) {
+  if (is_opener) open_trip(walk);
+  if (is_tool(span)) place_call(walk, span);
+  else if (!is_model(span)) walk.open = void 0;
+}
+function group_round_trips(spans) {
+  const ordered = in_time_order(spans);
+  const walk = { trips: [], open: void 0 };
+  for (const [index, span] of ordered.entries()) {
+    step_trip(walk, span, opens_round_trip(ordered, index));
+  }
+  return walk.trips;
+}
+function count_round_trips(spans) {
+  return group_round_trips(spans).length;
+}
+function turn_key(span, index) {
+  return span.message_id === time_spans.NO_MESSAGE_ID ? `#${String(index)}` : span.message_id;
+}
+function count_turns(spans) {
+  const keys = spans.filter((span) => is_model(span)).map((span, index) => turn_key(span, index));
+  return new Set(keys).size;
+}
+function per_round_trip(total, round_trip_count) {
+  if (round_trip_count === NONE) return NONE;
+  return total / round_trip_count;
+}
+function format_density(density) {
+  return density.toFixed(DENSITY_DECIMALS);
+}
+function is_below_floor(density) {
+  return density > NONE && density < CALLS_PER_ROUND_TRIP_FLOOR;
+}
+var time_round_trips = {
+  CALLS_PER_ROUND_TRIP_FLOOR,
+  count_calls,
+  count_round_trips,
+  // Exported since joshuafolkken/kit#1406, so a turn is defined in the one module that already
+  // defines a round trip rather than as a span filter in the report next door.
+  count_turns,
+  format_density,
+  // Exported since joshuafolkken/kit#1385, so the per-tool counts are read off the very groups this
+  // module counts rather than off a second grouping beside them.
+  group_round_trips,
+  // Exported since joshuafolkken/kit#1309, so the failure aggregation orders a run's spans through
+  // the one function that already knows why they need it — a second `toSorted` beside it would be
+  // the clone `CLAUDE.md` prohibits, and the seam it guards (a delegated unit's spans appended
+  // after the parent's) is not one a second copy would keep remembering.
+  in_time_order,
+  is_below_floor,
+  // The four below are exported since joshuafolkken/kit#1406, when the model-gap walk moved to
+  // `time-model-gaps.ts` and needed the same predicates and the same opener test this walk uses. A
+  // private copy there would be the clone `CLAUDE.md` prohibits, in the one place a drift would have
+  // the distribution and the count disagreeing about what a round trip is.
+  per_round_trip
+};
+
+// scripts/time-runtime/time-agent-bundles.ts
+var NONE2 = 0;
+var ONE = 1;
+var MIN_GROUP = 2;
+function is_launch2(span) {
+  return span.category === time_spans.TOOL_CATEGORY && !span.is_continuation && time_bundle_call.is_launch_tool(span.label);
+}
+function new_walk() {
+  return { closed: [], open: NONE2, wrote_since: false, turn_id: time_spans.NO_MESSAGE_ID };
+}
+function close_group(walk) {
+  if (walk.open >= MIN_GROUP) walk.closed.push(walk.open);
+  walk.open = NONE2;
+}
+function is_same_turn(walk, span) {
+  return span.message_id !== time_spans.NO_MESSAGE_ID && span.message_id === walk.turn_id;
+}
+function open_turn(walk, span) {
+  if (walk.wrote_since || span.has_prior_reference) close_group(walk);
+  walk.open += ONE;
+  walk.turn_id = span.message_id;
+  walk.wrote_since = false;
+}
+function step(walk, span) {
+  if (span.is_writing) {
+    walk.wrote_since = true;
+    return;
+  }
+  if (!is_launch2(span) || is_same_turn(walk, span)) return;
+  open_turn(walk, span);
+}
+function agent_bundles(spans) {
+  const walk = new_walk();
+  for (const span of time_round_trips.in_time_order(spans)) step(walk, span);
+  close_group(walk);
+  return walk.closed;
+}
+var time_agent_bundles = { agent_bundles };
+
+// scripts/time-runtime/time-bundles.ts
+var { unmeasured_row: unmeasured_row2 } = time_format;
+var HEADING = "Bundling:";
+var SEQUENCE_LABEL = "bundleable sequences";
+var RECOVERABLE_LABEL = "recoverable round trips";
+var SAVING_LABEL = "recoverable wait";
+var BY_TOOL_LABEL = "recoverable by tool";
+var AGENT_ROW_LABEL = "Agent";
+var ROW_INDENT = "  ";
+var MIN_SEQUENCE = 2;
+var ONE_CALL = 1;
+var NONE3 = 0;
+var PATH_SEPARATOR2 = "/";
+var FIRST_CALL = 1;
+var NO_LABEL = "";
+var NO_BUNDLES = {
+  sequence_count: 0,
+  longest_sequence: 0,
+  recoverable_round_trips: 0,
+  by_tool: [],
+  unattributed_round_trips: 0,
+  is_measured: false
+};
+function contains_segments(whole, part) {
+  if (whole.startsWith(`${part}${PATH_SEPARATOR2}`)) return true;
+  return whole.endsWith(`${PATH_SEPARATOR2}${part}`) || whole.includes(`${PATH_SEPARATOR2}${part}${PATH_SEPARATOR2}`);
+}
+function is_related(left, right) {
+  if (left === right) return true;
+  return contains_segments(left, right) || contains_segments(right, left);
+}
+function shares_target(left, right) {
+  return left.some((one) => right.some((other) => is_related(one, other)));
+}
+function is_dependent(earlier, later) {
+  if (earlier.is_writing && later.is_writing) return false;
+  return shares_target(earlier.targets, later.targets);
+}
+function conflicts(span, sequence) {
+  return sequence.some((earlier) => is_dependent(earlier, span));
+}
+function is_call2(span) {
+  return span.category === time_spans.TOOL_CATEGORY && !span.is_continuation;
+}
+function is_turn_boundary(span) {
+  return span.category === time_spans.MODEL_CATEGORY;
+}
+function new_walk2() {
+  return { pending: [], sequence: [], closed: [] };
+}
+function flush(walk) {
+  if (walk.sequence.length >= MIN_SEQUENCE) walk.closed.push(walk.sequence);
+  walk.sequence = [];
+}
+function extend(walk, span) {
+  if (conflicts(span, walk.sequence)) flush(walk);
+  walk.sequence.push(span);
+}
+function close_trip(walk) {
+  const [only] = walk.pending;
+  if (walk.pending.length === ONE_CALL && only?.is_bundleable === true) extend(walk, only);
+  else if (walk.pending.length > NONE3) flush(walk);
+  walk.pending = [];
+}
+function is_same_turn2(span, pending) {
+  const [first] = pending;
+  if (first === void 0 || span.is_continuation || span.message_id === time_spans.NO_MESSAGE_ID) {
+    return false;
+  }
+  return span.message_id === first.message_id;
+}
+function step2(walk, span) {
+  if (is_call2(span)) {
+    walk.pending.push(span);
+    return;
+  }
+  if (is_same_turn2(span, walk.pending)) return;
+  close_trip(walk);
+  if (!is_turn_boundary(span)) flush(walk);
+}
+function longest_of(sizes) {
+  return sizes.length === NONE3 ? NONE3 : Math.max(...sizes);
+}
+function recoverable_of(sizes) {
+  return sizes.reduce((sum, size) => sum + size - ONE_CALL, NONE3);
+}
+function sizes_of(closed) {
+  return closed.map((sequence) => sequence.length);
+}
+function tally_for(tallies, label) {
+  const found = tallies.get(label);
+  if (found !== void 0) return found;
+  const created = { sequence_count: NONE3, recoverable_round_trips: NONE3 };
+  tallies.set(label, created);
+  return created;
+}
+function count_trip(tallies, counted, label) {
+  const tally2 = tally_for(tallies, label);
+  tally2.recoverable_round_trips += ONE_CALL;
+  if (!counted.has(label)) tally2.sequence_count += ONE_CALL;
+  counted.add(label);
+}
+function tally_sequence(tallies, sequence) {
+  const counted = /* @__PURE__ */ new Set();
+  for (const span of sequence.slice(FIRST_CALL)) {
+    if (span.label !== NO_LABEL) count_trip(tallies, counted, span.label);
+  }
+}
+function by_weight(left, right) {
+  if (left.recoverable_round_trips !== right.recoverable_round_trips) {
+    return right.recoverable_round_trips - left.recoverable_round_trips;
+  }
+  return left.label.localeCompare(right.label);
+}
+function tool_rows(closed) {
+  const tallies = /* @__PURE__ */ new Map();
+  for (const sequence of closed) tally_sequence(tallies, sequence);
+  return [...tallies].map(([label, tally2]) => ({ label, ...tally2 })).toSorted(by_weight);
+}
+function attributed_of(rows) {
+  return rows.reduce((sum, row) => sum + row.recoverable_round_trips, NONE3);
+}
+function with_agent_row(rows, agent_sizes) {
+  const recoverable_round_trips = recoverable_of(agent_sizes);
+  if (recoverable_round_trips === NONE3) return [...rows];
+  const row = {
+    label: AGENT_ROW_LABEL,
+    sequence_count: agent_sizes.length,
+    recoverable_round_trips
+  };
+  return [...rows, row].toSorted(by_weight);
+}
+function build_bundles(spans) {
+  const walk = new_walk2();
+  for (const span of time_round_trips.in_time_order(spans)) step2(walk, span);
+  close_trip(walk);
+  flush(walk);
+  const sizes = sizes_of(walk.closed);
+  const agent_sizes = time_agent_bundles.agent_bundles(spans);
+  const by_tool = with_agent_row(tool_rows(walk.closed), agent_sizes);
+  const recoverable_round_trips = recoverable_of(sizes) + recoverable_of(agent_sizes);
+  return {
+    sequence_count: sizes.length + agent_sizes.length,
+    longest_sequence: Math.max(longest_of(sizes), longest_of(agent_sizes)),
+    recoverable_round_trips,
+    by_tool,
+    unattributed_round_trips: recoverable_round_trips - attributed_of(by_tool),
+    is_measured: time_spans.has_transcript_data(spans.length)
+  };
+}
+function open_sequence(spans) {
+  const walk = new_walk2();
+  for (const span of time_round_trips.in_time_order(spans)) step2(walk, span);
+  return walk.sequence;
+}
+function sequence_suffix(totals) {
+  return `longest ${String(totals.longest_sequence)} turn(s)`;
+}
+function recoverable_suffix(totals, round_trip_count) {
+  const share = time_format.format_share(totals.recoverable_round_trips, round_trip_count);
+  return `${share} of ${String(round_trip_count)} round trip(s)`;
+}
+function saving_line(totals, model_ms_per_round_trip) {
+  const saved_ms = totals.recoverable_round_trips * model_ms_per_round_trip;
+  const rate = `at ${time_format.format_seconds(model_ms_per_round_trip)} model time per round trip`;
+  return time_format.format_row(SAVING_LABEL, saved_ms, rate);
+}
+function by_tool_suffix(totals) {
+  const attributed = totals.recoverable_round_trips - totals.unattributed_round_trips;
+  return `${String(attributed)} of ${String(totals.recoverable_round_trips)} attributed`;
+}
+function tool_row(row) {
+  return time_format.format_columns(
+    `${ROW_INDENT}${row.label}`,
+    String(row.recoverable_round_trips),
+    `in ${String(row.sequence_count)} sequence(s)`
+  );
+}
+function by_tool_lines(totals) {
+  const heading = time_format.format_columns(
+    BY_TOOL_LABEL,
+    String(totals.by_tool.length),
+    by_tool_suffix(totals)
+  );
+  const rows = totals.by_tool.slice(NONE3, time_format.MAX_ROWS).map((row) => tool_row(row));
+  return [heading, ...rows, ...time_format.overflow_line(totals.by_tool.length)];
+}
+function measured_lines(totals, price) {
+  return [
+    time_format.format_columns(
+      SEQUENCE_LABEL,
+      String(totals.sequence_count),
+      sequence_suffix(totals)
+    ),
+    time_format.format_columns(
+      RECOVERABLE_LABEL,
+      String(totals.recoverable_round_trips),
+      recoverable_suffix(totals, price.round_trip_count)
+    ),
+    saving_line(totals, price.model_ms_per_round_trip),
+    ...by_tool_lines(totals)
+  ];
+}
+var LABELS = [SEQUENCE_LABEL, RECOVERABLE_LABEL, SAVING_LABEL, BY_TOOL_LABEL];
+function no_divisor_lines() {
+  return LABELS.map((label) => time_format.format_columns(label, "", time_format.NO_CALLS));
+}
+function bundle_lines(totals, price) {
+  const heading = ["", HEADING];
+  if (!totals.is_measured) return [...heading, ...LABELS.map((label) => unmeasured_row2(label))];
+  if (price.round_trip_count === NONE3) return [...heading, ...no_divisor_lines()];
+  return [...heading, ...measured_lines(totals, price)];
+}
+var time_bundles = {
+  HEADING,
+  BY_TOOL_LABEL,
+  NO_BUNDLES,
+  build_bundles,
+  bundle_lines,
+  is_dependent,
+  open_sequence,
+  shares_target
+};
+
+// scripts/time-runtime/time-command-key.ts
+var UNNAMED_KEY = "";
+function command_key(span) {
+  if (span.label === time_spans.UNKNOWN_TOOL) return UNNAMED_KEY;
+  return span.josh_command === "" ? span.label : span.josh_command;
+}
+var time_command_key = { UNNAMED_KEY, command_key };
+
+// scripts/time-runtime/time-call-identity.ts
+var IDENTITY_SEPARATOR = "\0";
+function identity_of(call) {
+  return [
+    time_command_key.command_key(call),
+    call.check_key,
+    [...call.targets].toSorted((left, right) => left.localeCompare(right)).join(",")
+  ].join(IDENTITY_SEPARATOR);
+}
+var time_call_identity = { identity_of };
+
+// scripts/time-runtime/time-batch-guard.ts
+var CONSECUTIVE_LIMIT = 3;
+var REFIRE_EVERY = CONSECUTIVE_LIMIT;
+var ONE_TURN = 1;
+var NONE4 = 0;
+var NOTICE_REFIRE_EVERY = ONE_TURN;
+var NAMED_CANDIDATE_COUNT = 3;
+var SEQUENCE_BEFORE_LIMIT = CONSECUTIVE_LIMIT - ONE_TURN;
+var REASON = `\u26D4 batching: the last ${String(SEQUENCE_BEFORE_LIMIT)} turns each issued a single tool call, so this one would make ${String(CONSECUTIVE_LIMIT)} in a row. Reissue it in one turn together with the calls meant to follow it that do not need its result. **The criterion is whether this call's input needs another call's result, not what kind of call it is** \u2014 edits are covered exactly as reads are, and it never authorizes weakening a verification gate or a review: fewer turns, never less work. The rule, and where its measured cost and rejected mechanisms are, is in \`prompts/collaboration-workflow/turn-batching.md\`. If this turn was already batching, or the call genuinely has nothing to go beside it, reissue it as it was: this fires once per run of single-call turns and cannot repeat on the call in hand.`;
+var NOTICE = `\u{1F4A1} batching: the last ${String(SEQUENCE_BEFORE_LIMIT)} turns each issued a single tool call, so this Write makes ${String(CONSECUTIVE_LIMIT)} in a row. This is a notice, not a refusal \u2014 the write proceeds. Where the writes meant to follow it do not need its result, issue them in one turn together. **The criterion is whether a call's input needs another call's result, not what kind of call it is** \u2014 it never authorizes weakening a verification gate or a review: fewer turns, never less work. The rule, and where its measured cost and rejected mechanisms are, is in \`prompts/collaboration-workflow/turn-batching.md\`. If this run was already batching, or the write genuinely has nothing to go beside it, carry on: this recurs every ${String(NOTICE_REFIRE_EVERY)} further single-call turn(s).`;
+var LANE_NOTICE = `\u{1F4A1} batching: the last ${String(SEQUENCE_BEFORE_LIMIT)} turns each issued a single tool call, so this one makes ${String(CONSECUTIVE_LIMIT)} in a row. This is a notice, not a refusal \u2014 the call proceeds, because a dispatched lane child ends its turn on a denial. Where the calls meant to follow it do not need its result, issue them in one turn together. **The criterion is whether a call's input needs another call's result, not what kind of call it is** \u2014 it never authorizes weakening a verification gate or a review: fewer turns, never less work. The rule, and where its measured cost and rejected mechanisms are, is in \`prompts/collaboration-workflow/turn-batching.md\`. If this run was already batching, or the call genuinely has nothing to go beside it, carry on: this recurs every ${String(NOTICE_REFIRE_EVERY)} further single-call turn(s).`;
+var WHOLE_FILE_WRITE_TOOL = "Write";
+var EDIT_TOOL = "Edit";
+function is_guarded_call(call) {
+  if (call.name === WHOLE_FILE_WRITE_TOOL) return false;
+  return time_bundle_call.call_facts(call.name, call.input).is_bundleable;
+}
+function is_notice_call(call) {
+  return call.name === WHOLE_FILE_WRITE_TOOL;
+}
+function is_read_only_call(call) {
+  const facts = time_bundle_call.call_facts(call.name, call.input);
+  return facts.is_bundleable && !facts.may_write;
+}
+function depends_on_sequence(sequence, facts) {
+  return sequence.some((span) => time_bundles.shares_target(span.targets, facts.targets));
+}
+function sequence_started_ms(sequence) {
+  return sequence[0]?.ended_ms ?? NONE4;
+}
+function turns_since(sequence, last_fired_ms) {
+  return sequence.filter((span) => span.ended_ms > last_fired_ms).length;
+}
+function is_sequence_at_limit(sequence, facts, last_fired_ms, refire_every) {
+  if (sequence.length < SEQUENCE_BEFORE_LIMIT || depends_on_sequence(sequence, facts)) return false;
+  if (last_fired_ms < sequence_started_ms(sequence)) return true;
+  return turns_since(sequence, last_fired_ms) >= refire_every;
+}
+function is_at_limit(spans, call, last_fired_ms, refire_every) {
+  return is_sequence_at_limit(
+    time_bundles.open_sequence(spans),
+    time_bundle_call.call_facts(call.name, call.input),
+    last_fired_ms,
+    refire_every
+  );
+}
+var GUARD_LABEL = time_transcript_line.guard_from_refusal(REASON);
+function is_reissued_refusal(spans, call) {
+  const identity = time_call_identity.identity_of(
+    time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID)
+  );
+  return spans.some(
+    (span) => span.refusal_guard === GUARD_LABEL && time_call_identity.identity_of(span) === identity
+  );
+}
+function should_block(text, call, refused_at_ms, refire_every = REFIRE_EVERY) {
+  if (!is_guarded_call(call)) return false;
+  const { spans } = time_spans.parse_timeline(text);
+  if (is_reissued_refusal(spans, call)) return false;
+  return is_at_limit(spans, call, refused_at_ms, refire_every);
+}
+function should_notify(text, call, notified_at_ms) {
+  if (!is_notice_call(call)) return false;
+  const { spans } = time_spans.parse_timeline(text);
+  return is_at_limit(spans, call, notified_at_ms, NOTICE_REFIRE_EVERY);
+}
+function describe_span(span) {
+  const target = span.targets[0] ?? "";
+  if (target === "" || span.label.includes(target)) return span.label;
+  return `${span.label} ${target}`;
+}
+var FOLD_MINIMUM = 2;
+function read_targets(sequence) {
+  const paths = sequence.filter((span) => span.is_bundleable && !span.is_writing).map((span) => span.targets[0] ?? "").filter((path6) => path6 !== "" && time_bundle_call.has_extension(path6));
+  return [...new Set(paths)];
+}
+function read_fold_directive(sequence) {
+  const paths = read_targets(sequence);
+  if (paths.length < FOLD_MINIMUM) return "";
+  return ` Fold them into one call: \`pnpm josh read:files ${paths.join(" ")}\`.`;
+}
+function write_targets(sequence) {
+  const paths = sequence.filter((span) => span.label === EDIT_TOOL).map((span) => span.targets[0] ?? "").filter((path6) => path6 !== "" && time_bundle_call.has_extension(path6));
+  return [...new Set(paths)];
+}
+function write_fold_directive(sequence) {
+  const paths = write_targets(sequence);
+  if (paths.length < FOLD_MINIMUM) return "";
+  return ` Fold them into one \`pnpm josh edit:files\` call with a plan over: ${paths.join(" ")}.`;
+}
+function name_candidates(calls) {
+  if (calls.length === NONE4) return "";
+  const named = calls.map((call) => describe_span(call)).join(", ");
+  const folds = `${read_fold_directive(calls)}${write_fold_directive(calls)}`;
+  return ` Just issued one per turn, so at least these could have shared a turn: ${named}.${folds}`;
+}
+function recent_candidates(tail) {
+  return name_candidates(
+    time_bundles.open_sequence(time_spans.parse_timeline(tail).spans).slice(-NAMED_CANDIDATE_COUNT)
+  );
+}
+function pairing_candidates(tail, call) {
+  const sequence = time_bundles.open_sequence(time_spans.parse_timeline(tail).spans);
+  if (call === void 0 || sequence.length === NONE4) {
+    return name_candidates(sequence.slice(-NAMED_CANDIDATE_COUNT));
+  }
+  const facts = time_bundle_call.call_facts(call.name, call.input);
+  if (!facts.is_bundleable || depends_on_sequence(sequence, facts)) return "";
+  const current = time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID);
+  return name_candidates([...sequence.slice(ONE_TURN - NAMED_CANDIDATE_COUNT), current]);
+}
+var STAMP_PREFIX = "josh-batch-guard-";
+var NOTICE_STAMP_PREFIX = "josh-batch-guard-notice-";
+var time_batch_guard = {
+  CONSECUTIVE_LIMIT,
+  GUARD_LABEL,
+  LANE_NOTICE,
+  NOTICE,
+  NOTICE_REFIRE_EVERY,
+  NOTICE_STAMP_PREFIX,
+  REASON,
+  REFIRE_EVERY,
+  SEQUENCE_BEFORE_LIMIT,
+  STAMP_PREFIX,
+  is_guarded_call,
+  is_notice_call,
+  is_read_only_call,
+  pairing_candidates,
+  recent_candidates,
+  should_block,
+  should_notify
+};
+
 // scripts/time-runtime/time-hook-transcript.ts
 import path3 from "node:path";
 
@@ -3198,120 +3744,11 @@ var stamp_file = {
 // scripts/time-runtime/time-density-hook.ts
 import { z as z5 } from "zod";
 
-// scripts/time-runtime/time-round-trips.ts
-var CALLS_PER_ROUND_TRIP_FLOOR = 1.5;
-var DENSITY_DECIMALS = 2;
-var NONE = 0;
-function is_tool(span) {
-  return span.category === time_spans.TOOL_CATEGORY;
-}
-function is_model(span) {
-  return span.category === time_spans.MODEL_CATEGORY;
-}
-function started_ms2(span) {
-  return span.ended_ms - span.duration_ms;
-}
-function in_time_order(spans) {
-  return spans.toSorted((left, right) => started_ms2(left) - started_ms2(right));
-}
-function is_tool_at(spans, index) {
-  const span = spans[index];
-  return span !== void 0 && is_tool(span);
-}
-function is_call(span) {
-  return is_tool(span) && !span.is_continuation;
-}
-function count_calls(spans) {
-  return spans.filter((span) => is_call(span)).length;
-}
-function previous_break(spans, index) {
-  for (let back = index - 1; back >= 0; back -= 1) {
-    const span = spans[back];
-    if (span === void 0 || !is_model(span)) return span;
-  }
-  return void 0;
-}
-function continues_turn(spans, index, message_id) {
-  if (message_id === time_spans.NO_MESSAGE_ID) return false;
-  const earlier = previous_break(spans, index);
-  return earlier !== void 0 && !earlier.is_continuation && earlier.message_id === message_id;
-}
-function opens_round_trip(spans, index) {
-  const span = spans[index];
-  if (span === void 0 || !is_tool(span) || span.is_continuation || is_tool_at(spans, index - 1)) {
-    return false;
-  }
-  return !continues_turn(spans, index, span.message_id);
-}
-function open_trip(walk) {
-  walk.open = [];
-  walk.trips.push(walk.open);
-}
-function place_call(walk, span) {
-  if (is_call(span)) walk.open?.push(span);
-}
-function step_trip(walk, span, is_opener) {
-  if (is_opener) open_trip(walk);
-  if (is_tool(span)) place_call(walk, span);
-  else if (!is_model(span)) walk.open = void 0;
-}
-function group_round_trips(spans) {
-  const ordered = in_time_order(spans);
-  const walk = { trips: [], open: void 0 };
-  for (const [index, span] of ordered.entries()) {
-    step_trip(walk, span, opens_round_trip(ordered, index));
-  }
-  return walk.trips;
-}
-function count_round_trips(spans) {
-  return group_round_trips(spans).length;
-}
-function turn_key(span, index) {
-  return span.message_id === time_spans.NO_MESSAGE_ID ? `#${String(index)}` : span.message_id;
-}
-function count_turns(spans) {
-  const keys = spans.filter((span) => is_model(span)).map((span, index) => turn_key(span, index));
-  return new Set(keys).size;
-}
-function per_round_trip(total, round_trip_count) {
-  if (round_trip_count === NONE) return NONE;
-  return total / round_trip_count;
-}
-function format_density(density) {
-  return density.toFixed(DENSITY_DECIMALS);
-}
-function is_below_floor(density) {
-  return density > NONE && density < CALLS_PER_ROUND_TRIP_FLOOR;
-}
-var time_round_trips = {
-  CALLS_PER_ROUND_TRIP_FLOOR,
-  count_calls,
-  count_round_trips,
-  // Exported since joshuafolkken/kit#1406, so a turn is defined in the one module that already
-  // defines a round trip rather than as a span filter in the report next door.
-  count_turns,
-  format_density,
-  // Exported since joshuafolkken/kit#1385, so the per-tool counts are read off the very groups this
-  // module counts rather than off a second grouping beside them.
-  group_round_trips,
-  // Exported since joshuafolkken/kit#1309, so the failure aggregation orders a run's spans through
-  // the one function that already knows why they need it — a second `toSorted` beside it would be
-  // the clone `CLAUDE.md` prohibits, and the seam it guards (a delegated unit's spans appended
-  // after the parent's) is not one a second copy would keep remembering.
-  in_time_order,
-  is_below_floor,
-  // The four below are exported since joshuafolkken/kit#1406, when the model-gap walk moved to
-  // `time-model-gaps.ts` and needed the same predicates and the same opener test this walk uses. A
-  // private copy there would be the clone `CLAUDE.md` prohibits, in the one place a drift would have
-  // the distribution and the count disagreeing about what a round trip is.
-  per_round_trip
-};
-
 // scripts/time-runtime/time-density.ts
 var MIN_ROUND_TRIPS = 10;
 var NOTICE_INTERVAL_MS = 3e5;
-var ONE_CALL = 1;
-var NONE2 = 0;
+var ONE_CALL2 = 1;
+var NONE5 = 0;
 function has_whole_tail(text) {
   const last = text.split("\n").findLast((line) => line.trim() !== "");
   return last !== void 0 && time_spans.parse_line(last) !== void 0;
@@ -3320,10 +3757,10 @@ function assistant_lines(text) {
   return text.split("\n").map((line) => time_spans.parse_line(line)).filter((line) => line?.type === time_spans.ASSISTANT_TYPE);
 }
 function last_turn_calls(text) {
-  if (!has_whole_tail(text)) return NONE2;
+  if (!has_whole_tail(text)) return NONE5;
   const lines = assistant_lines(text);
   const message_id = lines.at(-1)?.message_id;
-  if (message_id === void 0 || message_id === time_spans.NO_MESSAGE_ID) return NONE2;
+  if (message_id === void 0 || message_id === time_spans.NO_MESSAGE_ID) return NONE5;
   return lines.filter((line) => line.message_id === message_id).flatMap((line) => line.blocks).filter((block) => block.type === cost_blocks.TOOL_USE_TYPE).length;
 }
 function read_window(text) {
@@ -3337,15 +3774,15 @@ function read_window(text) {
   };
 }
 function is_due(reading, since_last_ms) {
-  if (reading.round_trip_count < MIN_ROUND_TRIPS || reading.turn_calls !== ONE_CALL || !time_round_trips.is_below_floor(reading.density)) {
+  if (reading.round_trip_count < MIN_ROUND_TRIPS || reading.turn_calls !== ONE_CALL2 || !time_round_trips.is_below_floor(reading.density)) {
     return false;
   }
   return since_last_ms >= NOTICE_INTERVAL_MS;
 }
-function format_notice(reading) {
+function format_notice(reading, candidates = "") {
   const density = time_round_trips.format_density(reading.density);
   const floor = time_round_trips.format_density(time_round_trips.CALLS_PER_ROUND_TRIP_FLOOR);
-  return `\u26A0 batching: ${density} calls per round trip over the last ${String(reading.round_trip_count)}, under the ${floor} floor, and this turn issued one call. Independent reads, greps, gh queries and edits go out together; the criterion is whether this call's input needs another call's result, not what kind of call it is \u2014 prompts/collaboration-workflow/turn-batching.md.`;
+  return `\u26A0 batching: ${density} calls per round trip over the last ${String(reading.round_trip_count)}, under the ${floor} floor, and this turn issued one call. Independent reads, greps, gh queries and edits go out together; the criterion is whether this call's input needs another call's result, not what kind of call it is \u2014 prompts/collaboration-workflow/turn-batching.md.${candidates}`;
 }
 var time_density = {
   MIN_ROUND_TRIPS,
@@ -3369,11 +3806,17 @@ var payload_schema = z5.object({
   agent_id: z5.string().nullish()
 });
 var notice_schema = z5.object({ notified_at_ms: z5.number() });
+var call_schema = z5.object({ tool_name: z5.string().min(1), tool_input: z5.unknown() });
 function parse_transcript_path(raw_payload) {
   const parsed = payload_schema.safeParse(JSON.parse(raw_payload));
   if (!parsed.success || parsed.data.transcript_path === void 0) return void 0;
   return time_hook_transcript.transcript_of(parsed.data.transcript_path, parsed.data.agent_id);
 }
+function parse_call(raw_payload) {
+  const parsed = call_schema.safeParse(JSON.parse(raw_payload));
+  if (!parsed.success) return void 0;
+  return { name: parsed.data.tool_name, input: parsed.data.tool_input };
+}
 function read_tail(file_path, max_bytes = TAIL_BYTES) {
   const descriptor = openSync(file_path, "r");
   try {
@@ -3407,11 +3850,14 @@ function arm_throttle(target, now_ms) {
 function notice_for(raw_payload, now_ms) {
   const transcript_path = parse_transcript_path(raw_payload);
   if (transcript_path === void 0) return void 0;
-  const reading = time_density.read_window(read_tail(transcript_path));
+  const tail = read_tail(transcript_path);
+  const reading = time_density.read_window(tail);
   const target = notice_path(transcript_path);
   if (!time_density.is_due(reading, now_ms - last_notice_ms(target))) return void 0;
+  const candidates = time_batch_guard.pairing_candidates(tail, parse_call(raw_payload));
+  if (candidates === "") return void 0;
   arm_throttle(target, now_ms);
-  return time_density.format_notice(reading);
+  return time_density.format_notice(reading, candidates);
 }
 function density_notice(raw_payload, now_ms = Date.now()) {
   try {
@@ -3435,12 +3881,11 @@ export {
   ESLINT_EDIT_CACHE_FLAGS,
   time_shell,
   time_bundle_call,
-  time_format,
   cost_attribute,
   time_reported_failure,
   time_transcript_line,
   time_spans,
-  time_round_trips,
+  time_batch_guard,
   lane_paths,
   file_reader,
   cost_usage,