@joshuafolkken/kit 1.1136.0 → 1.1178.0

package/dist/hooks/{chunk-GDU26K3J.js → chunk-S6X6WYKR.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"]
     ]
@@ -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",
@@ -849,7 +858,7 @@ var DEV_COMMANDS = {
   },
   "test:red": {
     script: "scripts/test/test-red.ts",
-    description: "Run the changed unit tests against the pre-fix tree (merge-base worktree) and report red/green/no-test",
+    description: "Run the changed unit tests against the pre-fix tree (merge-base worktree) and report red/green/no-test/test-only",
     category: "Development",
     reference: ["", "developer", ["git", "processes"]]
   },
@@ -1855,6 +1864,252 @@ var time_bundle_call = {
   READ_JOSH_SUBCOMMANDS
 };
 
+// scripts/git/schemas.ts
+import { z as z2 } from "zod";
+var package_name_schema = z2.object({ name: z2.string().min(1) });
+var rollup_item_schema = z2.looseObject({
+  // eslint-disable-next-line @typescript-eslint/naming-convention -- GraphQL field name from GitHub API
+  __typename: z2.string().optional(),
+  state: z2.string().optional(),
+  status: z2.string().optional(),
+  conclusion: z2.string().optional(),
+  name: z2.string().optional(),
+  context: z2.string().optional()
+});
+var pr_raw_schema = z2.object({
+  statusCheckRollup: z2.array(rollup_item_schema).optional(),
+  mergeStateStatus: z2.string().optional(),
+  reviewDecision: z2.string().optional()
+});
+var pull_comment_schema = z2.object({
+  body: z2.string().optional(),
+  html_url: z2.string().optional(),
+  user: z2.object({ login: z2.string().optional() }).optional()
+});
+var ai_review_pull_comment_schema = z2.object({
+  body: z2.string().optional(),
+  url: z2.string().optional(),
+  author: z2.object({ login: z2.string().optional() }).optional()
+});
+var pr_info_schema = z2.object({
+  mergeable: z2.union([z2.boolean(), z2.string()]).nullable().optional(),
+  mergeStateStatus: z2.string().nullable().optional(),
+  state: z2.string().optional()
+});
+var epic_issue_schema = z2.object({
+  number: z2.number(),
+  body: z2.string().optional()
+});
+var blocking_issue_schema = z2.object({
+  number: z2.number(),
+  state: z2.string().optional(),
+  repository_url: z2.string().optional()
+});
+var blocked_by_schema = z2.object({
+  nodes: z2.array(blocking_issue_schema).default([]),
+  totalCount: z2.number().optional()
+}).optional();
+var epic_child_schema = z2.object({
+  state: z2.string().optional(),
+  blockedBy: blocked_by_schema
+});
+var rest_comment_schema = z2.looseObject({
+  body: z2.string().nullish(),
+  html_url: z2.string().optional(),
+  user: z2.looseObject({ login: z2.string().optional() }).nullish()
+});
+var issue_label_schema = z2.object({ name: z2.string() });
+var epic_subject_schema = z2.object({
+  number: z2.number(),
+  state: z2.string().optional(),
+  labels: z2.array(issue_label_schema).optional(),
+  body: z2.string().optional()
+});
+var open_issue_schema = z2.object({
+  number: z2.number(),
+  title: z2.string(),
+  labels: z2.array(issue_label_schema).optional(),
+  createdAt: z2.string(),
+  blockedBy: blocked_by_schema,
+  // Present only on the pickup listing, which reads it for the restructures each issue declares.
+  body: z2.string().optional()
+});
+
+// scripts/gh/git-pr-checks-parse.ts
+var CHECK_STATUS_PASS = "pass";
+var CHECK_STATUS_PENDING = "pending";
+var CHECK_STATUS_FAIL = "fail";
+var CHECK_STATUS_MISSING = "missing";
+var PASSING_CONCLUSIONS = /* @__PURE__ */ new Set(["success", "skipped", "neutral"]);
+var KEY_TYPE_NAME = "__typename";
+var KEY_STATE = "state";
+var KEY_STATUS = "status";
+var KEY_CONCLUSION = "conclusion";
+var KEY_NAME = "name";
+var KEY_CONTEXT = "context";
+function read_string(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return void 0;
+  return trimmed;
+}
+var PENDING_STATUS_STATES = /* @__PURE__ */ new Set(["pending", "expected"]);
+function parse_status_context(item) {
+  const state = read_string(item[KEY_STATE])?.toLowerCase();
+  if (state === "success") return CHECK_STATUS_PASS;
+  if (state !== void 0 && PENDING_STATUS_STATES.has(state)) return CHECK_STATUS_PENDING;
+  return CHECK_STATUS_FAIL;
+}
+function is_passing_conclusion(item) {
+  const conclusion = read_string(item[KEY_CONCLUSION])?.toLowerCase();
+  return conclusion !== void 0 && PASSING_CONCLUSIONS.has(conclusion);
+}
+function parse_check_run(item) {
+  const status = read_string(item[KEY_STATUS])?.toLowerCase();
+  if (status !== "completed") return CHECK_STATUS_PENDING;
+  return is_passing_conclusion(item) ? CHECK_STATUS_PASS : CHECK_STATUS_FAIL;
+}
+function parse_rollup_status(item) {
+  const type_name = read_string(item[KEY_TYPE_NAME]);
+  if (type_name === "StatusContext") return parse_status_context(item);
+  return parse_check_run(item);
+}
+function read_rollup_array(parsed) {
+  const result = pr_raw_schema.safeParse(parsed);
+  if (!result.success) return [];
+  return result.data.statusCheckRollup ?? [];
+}
+function parse_rollup_item(item) {
+  const name = read_string(item[KEY_NAME]) ?? read_string(item[KEY_CONTEXT]);
+  if (name === void 0) return void 0;
+  return { name, status: parse_rollup_status(item) };
+}
+function parse_rollup_checks(raw_json) {
+  const parsed = json_value.parse_or_undefined(raw_json);
+  const rollup = read_rollup_array(parsed);
+  const checks = [];
+  for (const item of rollup) {
+    const parsed_item = parse_rollup_item(item);
+    if (parsed_item !== void 0) checks.push(parsed_item);
+  }
+  return checks;
+}
+function parse_pr_state_snapshot(raw_json) {
+  const parsed = json_value.parse_or_undefined(raw_json);
+  const result = pr_raw_schema.safeParse(parsed);
+  const data = result.success ? result.data : void 0;
+  return {
+    rollup: parse_rollup_checks(raw_json),
+    merge_state_status: read_string(data?.mergeStateStatus),
+    review_decision: read_string(data?.reviewDecision)
+  };
+}
+
+// scripts/gh/git-pr-checks-eval.ts
+var DEFAULT_REQUIRED_CHECKS = ["SonarQube"];
+var CODERABBIT_CHECK_NAME = "CodeRabbit";
+var REQUIRED_CHECKS_ENV_VAR = "JOSH_REQUIRED_CHECKS";
+function parse_required_checks() {
+  const raw = process.env[REQUIRED_CHECKS_ENV_VAR];
+  if (!raw) return DEFAULT_REQUIRED_CHECKS;
+  return raw.split(",").map((check) => check.trim()).filter((check) => check.length > 0);
+}
+var REQUIRED_CHECKS = parse_required_checks();
+var MERGE_STATE_CLEAN = "CLEAN";
+var MERGE_STATE_UNSTABLE = "UNSTABLE";
+var MERGE_STATE_DIRTY = "DIRTY";
+var REVIEW_CHANGES_REQUESTED = "CHANGES_REQUESTED";
+var CHECK_SUITE_SEPARATOR = " / ";
+var FAILURE_MESSAGE_PREFIX = "PR checks failed";
+var FAILURE_REASON_REVIEW = "review requested changes";
+var FAILURE_REASON_CHECKS = "failed checks";
+var FAILURE_REASON_CONFLICT = "merge conflict";
+function is_required_match(check_name, required_name) {
+  if (check_name === required_name) return true;
+  return check_name.startsWith(`${required_name}${CHECK_SUITE_SEPARATOR}`);
+}
+function find_required_check(checks, required_name) {
+  return checks.find((check) => is_required_match(check.name, required_name));
+}
+function read_required_statuses(checks) {
+  return REQUIRED_CHECKS.map(
+    (name) => find_required_check(checks, name)?.status ?? CHECK_STATUS_MISSING
+  );
+}
+function is_review_blocked(review_decision) {
+  return review_decision === REVIEW_CHANGES_REQUESTED;
+}
+function is_merge_conflict(merge_state_status) {
+  return merge_state_status === MERGE_STATE_DIRTY;
+}
+function evaluate_failure_state(input) {
+  if (is_merge_conflict(input.merge_state_status) || is_review_blocked(input.review_decision) || input.failed_checks.length > 0) {
+    return "failure";
+  }
+  return void 0;
+}
+function is_merge_state_clean(merge_state_status) {
+  return merge_state_status === MERGE_STATE_CLEAN;
+}
+function is_every_required_passing(statuses) {
+  return statuses.every((status) => status === CHECK_STATUS_PASS);
+}
+function is_coderabbit_check(check_name) {
+  return is_required_match(check_name, CODERABBIT_CHECK_NAME);
+}
+function is_unstable_only_from_coderabbit(snapshot) {
+  if (snapshot.merge_state_status !== MERGE_STATE_UNSTABLE) return false;
+  const non_passing = snapshot.rollup.filter((check) => check.status !== CHECK_STATUS_PASS);
+  if (non_passing.length === 0) return false;
+  return non_passing.every((check) => is_coderabbit_check(check.name));
+}
+function is_required_check(check_name) {
+  return REQUIRED_CHECKS.some((required) => is_required_match(check_name, required));
+}
+function is_blocking_failure(check) {
+  if (check.status !== CHECK_STATUS_FAIL) return false;
+  return !is_coderabbit_check(check.name) || is_required_check(check.name);
+}
+function collect_blocking_failures(snapshot) {
+  return snapshot.rollup.filter((check) => is_blocking_failure(check)).map((check) => check.name);
+}
+function is_mergeable_state(snapshot) {
+  if (is_merge_state_clean(snapshot.merge_state_status)) return true;
+  return is_unstable_only_from_coderabbit(snapshot);
+}
+function collect_failure_reasons(snapshot) {
+  const reasons = [];
+  if (is_merge_conflict(snapshot.merge_state_status)) reasons.push(FAILURE_REASON_CONFLICT);
+  if (is_review_blocked(snapshot.review_decision)) reasons.push(FAILURE_REASON_REVIEW);
+  const failed = collect_blocking_failures(snapshot);
+  if (failed.length > 0) reasons.push(`${FAILURE_REASON_CHECKS}: ${failed.join(", ")}`);
+  return reasons;
+}
+function describe_pr_failure(snapshot) {
+  const reasons = collect_failure_reasons(snapshot);
+  if (reasons.length === 0) return `${FAILURE_MESSAGE_PREFIX}.`;
+  return `${FAILURE_MESSAGE_PREFIX} (${reasons.join("; ")}).`;
+}
+function evaluate_pr_state(snapshot) {
+  const statuses = read_required_statuses(snapshot.rollup);
+  const failure = evaluate_failure_state({
+    review_decision: snapshot.review_decision,
+    failed_checks: collect_blocking_failures(snapshot),
+    merge_state_status: snapshot.merge_state_status
+  });
+  if (failure !== void 0) return failure;
+  if (is_mergeable_state(snapshot) && is_every_required_passing(statuses)) {
+    return "success";
+  }
+  return "pending";
+}
+function is_review_decision_decisive(snapshot) {
+  return evaluate_pr_state(snapshot) !== "pending";
+}
+var PrConflictError = class extends Error {
+  name = "PrConflictError";
+};
+
 // scripts/time-runtime/time-format.ts
 var MS_PER_MINUTE = 6e4;
 var MS_PER_SECOND = 1e3;
@@ -1926,8 +2181,14 @@ var STAGE = {
   // The lap that was still running when a stage threw. `followup` exits non-zero on an AI-review
   // blocker and on a red check, and those are the runs whose wait is longest — reporting nothing for
   // them would leave the measurement blind to exactly the invocations worth measuring.
-  interrupted: "interrupted"
+  interrupted: "interrupted",
+  // The interrupted lap when the wait failed on a merge conflict (joshuafolkken/kit#3221), so the
+  // stage block names the cause a resumed session used to look up with `gh pr view`.
+  conflict: "conflict"
 };
+function stopped_lap(error) {
+  return error instanceof PrConflictError ? STAGE.conflict : STAGE.interrupted;
+}
 function new_log() {
   return { stages: [], last_ms: performance.now() };
 }
@@ -1960,7 +2221,8 @@ var git_followup_stages = {
   lap,
   total_ms,
   format_stages,
-  print_stages
+  print_stages,
+  stopped_lap
 };
 
 // scripts/time-runtime/time-followup-stage.ts
@@ -2092,6 +2354,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 "";
@@ -2121,19 +2384,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 = {
@@ -2190,9 +2457,9 @@ var josh_verdict = {
 };
 
 // scripts/time-runtime/time-reported-failure.ts
-import { z as z2 } from "zod";
-var TEXT_BLOCK_SCHEMA = z2.object({ text: z2.string().nullish() });
-var CONTENT_SCHEMA = z2.union([z2.string(), z2.array(z2.unknown())]);
+import { z as z3 } from "zod";
+var TEXT_BLOCK_SCHEMA = z3.object({ text: z3.string().nullish() });
+var CONTENT_SCHEMA = z3.union([z3.string(), z3.array(z3.unknown())]);
 var LINE_SEPARATOR2 = "\n";
 function block_text(block) {
   const parsed = TEXT_BLOCK_SCHEMA.safeParse(block);
@@ -2287,7 +2554,7 @@ function check_key(josh_command, command) {
 var time_single_check = { NO_CHECK, check_key };
 
 // scripts/time-runtime/time-transcript-line.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // scripts/time-runtime/time-instant.ts
 function parse_instant(raw) {
@@ -2297,37 +2564,37 @@ function parse_instant(raw) {
 var time_instant = { parse_instant };
 
 // scripts/time-runtime/time-transcript-line.ts
-var BLOCK_SCHEMA2 = z3.object({
-  type: z3.string().nullish(),
-  name: z3.string().nullish(),
-  id: z3.string().nullish(),
-  tool_use_id: z3.string().nullish(),
-  input: z3.unknown().nullish(),
+var BLOCK_SCHEMA2 = z4.object({
+  type: z4.string().nullish(),
+  name: z4.string().nullish(),
+  id: z4.string().nullish(),
+  tool_use_id: z4.string().nullish(),
+  input: z4.unknown().nullish(),
   // Whether the harness wrote this result back as a failure (joshuafolkken/kit#1309). Present on a
   // `tool_result` block and on nothing else, and absent even there for the tools that never report
   // one — which is why it is read as three answers rather than as a boolean with a default.
-  is_error: z3.boolean().nullish(),
+  is_error: z4.boolean().nullish(),
   // What the call printed. Read only to recover the outcome a pipeline threw away
   // (joshuafolkken/kit#1361): it is kept as flattened text rather than as blocks, because that is
   // the whole of what `time-reported-failure.ts` asks of it.
-  content: z3.unknown().nullish()
+  content: z4.unknown().nullish()
 });
-var CONTENT_SCHEMA2 = z3.union([z3.string(), z3.array(BLOCK_SCHEMA2)]);
-var MESSAGE_SCHEMA2 = z3.object({ id: z3.string().nullish(), content: CONTENT_SCHEMA2.nullish() });
-var LINE_SCHEMA = z3.object({
-  type: z3.string().nullish(),
-  timestamp: z3.string().nullish(),
+var CONTENT_SCHEMA2 = z4.union([z4.string(), z4.array(BLOCK_SCHEMA2)]);
+var MESSAGE_SCHEMA2 = z4.object({ id: z4.string().nullish(), content: CONTENT_SCHEMA2.nullish() });
+var LINE_SCHEMA = z4.object({
+  type: z4.string().nullish(),
+  timestamp: z4.string().nullish(),
   // The branch the line was written on, which is where the issue number lives — `josh git` names a
   // branch `<N>-<slug>`. Read here rather than re-parsed by a second reader so `josh time --issue`
   // and `josh cost --issue` answer from the same field (joshuafolkken/kit#1268).
-  gitBranch: z3.string().nullish(),
+  gitBranch: z4.string().nullish(),
   // The two fields outside `message` that the harness writes an end-of-task notice on
   // (joshuafolkken/kit#1696). **Both are read as `unknown` rather than as strings**: a schema
   // insisting on a string here would reject every line whose `content` is a list of blocks — which is
   // most of them — and a rejected line is dropped from the timeline entirely, so the shares would stop
   // reconstructing the elapsed time. The shape is checked at the read below instead.
-  content: z3.unknown().nullish(),
-  attachment: z3.unknown().nullish(),
+  content: z4.unknown().nullish(),
+  attachment: z4.unknown().nullish(),
   message: MESSAGE_SCHEMA2.nullish()
 });
 var UNKNOWN_BRANCH = "";
@@ -2335,6 +2602,9 @@ var PROMPT_KEY2 = "prompt";
 var NO_MESSAGE_ID = "";
 var ERROR_TEXT_LIMIT = 256;
 var REFUSAL_MARKER = "\u26D4";
+var HOOK_ERROR_LABEL = /^PreToolUse:\S+ hook error: /u;
+var TOKEN_LINE = /^[a-z][a-z-]*$/u;
+var TOKEN_LINE_LIMIT = 8;
 function block_names(raw) {
   return {
     type: raw.type ?? "",
@@ -2344,12 +2614,15 @@ function block_names(raw) {
   };
 }
 function guard_from_refusal(text) {
-  const trimmed = text.trimStart();
+  const trimmed = text.trimStart().replace(HOOK_ERROR_LABEL, "");
   if (!trimmed.startsWith(REFUSAL_MARKER)) return "";
   const headline = trimmed.slice(REFUSAL_MARKER.length).split("\n", 1)[0]?.trimStart() ?? "";
   const colon = headline.indexOf(":");
   return (colon === -1 ? headline : headline.slice(0, colon)).trim();
 }
+function token_lines_of(text) {
+  return text.split("\n").map((line) => line.trim()).filter((line) => TOKEN_LINE.test(line)).slice(0, TOKEN_LINE_LIMIT);
+}
 function to_block2(raw) {
   const text = time_reported_failure.result_text(raw.content);
   const is_error = raw.is_error ?? void 0;
@@ -2361,6 +2634,7 @@ function to_block2(raw) {
     followup_stages: time_followup_stage.read_stages(text),
     error_text: is_error === true ? text.slice(0, ERROR_TEXT_LIMIT) : "",
     refusal_guard: is_error === true ? guard_from_refusal(text) : "",
+    token_lines: is_error === true ? [] : token_lines_of(text),
     background_id: time_background.launch_id(text),
     agent_id: time_background.agent_launch_id(text)
   };
@@ -2394,6 +2668,7 @@ function parse_line2(line) {
 var time_transcript_line = {
   ERROR_TEXT_LIMIT,
   NO_MESSAGE_ID,
+  TOKEN_LINE_LIMIT,
   guard_from_refusal,
   parse_line: parse_line2
 };
@@ -2631,6 +2906,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";
 
@@ -2708,30 +3507,30 @@ function read_if_readable(path6) {
 var file_reader = { read_optional, read_file_or_empty, read_if_readable };
 
 // scripts/cost-runtime/cost-usage.ts
-import { z as z4 } from "zod";
-var CACHE_CREATION_SCHEMA = z4.object({
-  ephemeral_1h_input_tokens: z4.number().nullish(),
-  ephemeral_5m_input_tokens: z4.number().nullish()
+import { z as z5 } from "zod";
+var CACHE_CREATION_SCHEMA = z5.object({
+  ephemeral_1h_input_tokens: z5.number().nullish(),
+  ephemeral_5m_input_tokens: z5.number().nullish()
 });
-var USAGE_SCHEMA = z4.object({
-  input_tokens: z4.number(),
-  cache_creation_input_tokens: z4.number().nullish(),
-  cache_read_input_tokens: z4.number().nullish(),
-  output_tokens: z4.number(),
-  output_tokens_details: z4.object({ thinking_tokens: z4.number().nullish() }).nullish(),
+var USAGE_SCHEMA = z5.object({
+  input_tokens: z5.number(),
+  cache_creation_input_tokens: z5.number().nullish(),
+  cache_read_input_tokens: z5.number().nullish(),
+  output_tokens: z5.number(),
+  output_tokens_details: z5.object({ thinking_tokens: z5.number().nullish() }).nullish(),
   cache_creation: CACHE_CREATION_SCHEMA.nullish()
 });
-var MESSAGE_SCHEMA3 = z4.object({
-  id: z4.string().nullish(),
-  model: z4.string().nullish(),
+var MESSAGE_SCHEMA3 = z5.object({
+  id: z5.string().nullish(),
+  model: z5.string().nullish(),
   usage: USAGE_SCHEMA.nullish()
 });
-var LINE_SCHEMA2 = z4.object({
-  type: z4.string(),
-  requestId: z4.string().nullish(),
-  uuid: z4.string().nullish(),
-  gitBranch: z4.string().nullish(),
-  timestamp: z4.string().nullish(),
+var LINE_SCHEMA2 = z5.object({
+  type: z5.string(),
+  requestId: z5.string().nullish(),
+  uuid: z5.string().nullish(),
+  gitBranch: z5.string().nullish(),
+  timestamp: z5.string().nullish(),
   message: MESSAGE_SCHEMA3.nullish()
 });
 var SYNTHETIC_MODEL = "<synthetic>";
@@ -3204,122 +4003,13 @@ 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
-};
+import { z as z6 } from "zod";
 
 // 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;
@@ -3328,10 +4018,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) {
@@ -3345,15 +4035,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,19 +4059,25 @@ var TAIL_BYTES = 262144;
 var FILE_START = 0;
 var NOTICE_PREFIX = "josh-density-notice-";
 var NEVER_MS = 0;
-var payload_schema = z5.object({
-  transcript_path: z5.string().min(1).optional(),
+var payload_schema = z6.object({
+  transcript_path: z6.string().min(1).optional(),
   // **`nullish`, not `optional`.** A payload spelling the absent agent as `null` has to read as "no
   // fork"; rejected, it would fail `safeParse` for the whole payload and silence the line for every
   // edit of the main line — the opposite of this module's stated failure direction.
-  agent_id: z5.string().nullish()
+  agent_id: z6.string().nullish()
 });
-var notice_schema = z5.object({ notified_at_ms: z5.number() });
+var notice_schema = z6.object({ notified_at_ms: z6.number() });
+var call_schema = z6.object({ tool_name: z6.string().min(1), tool_input: z6.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 {
@@ -3415,11 +4111,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 {
@@ -3443,12 +4142,25 @@ export {
   ESLINT_EDIT_CACHE_FLAGS,
   time_shell,
   time_bundle_call,
-  time_format,
+  blocking_issue_schema,
+  rest_comment_schema,
+  open_issue_schema,
+  CHECK_STATUS_PENDING,
+  CHECK_STATUS_FAIL,
+  read_string,
+  parse_pr_state_snapshot,
+  is_merge_conflict,
+  is_coderabbit_check,
+  is_required_check,
+  describe_pr_failure,
+  evaluate_pr_state,
+  is_review_decision_decisive,
+  PrConflictError,
   cost_attribute,
   time_reported_failure,
   time_transcript_line,
   time_spans,
-  time_round_trips,
+  time_batch_guard,
   lane_paths,
   file_reader,
   cost_usage,