@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/dist/hooks/chunk-Z6DQJKH3.js

@@ -0,0 +1,2806 @@
+import {
+  PACKAGE_JSON,
+  ancestor_directories,
+  cost_transcript,
+  figure_format,
+  issue_cite,
+  json_value,
+  lane_ledger_write,
+  pr_raw_schema,
+  run_event_stream,
+  run_event_stream_emit,
+  time_instant
+} from "./chunk-7SIUNQXK.js";
+import {
+  MS_PER_SECOND,
+  stamp_file
+} from "./chunk-45CJJOO7.js";
+
+// scripts/time-runtime/time-hook-transcript.ts
+import path from "node:path";
+var { TRANSCRIPT_EXTENSION } = cost_transcript;
+var AGENT_PREFIX = "agent-";
+var AGENT_ID_PATTERN = /^[\w-]+$/u;
+function is_agent_id(value) {
+  return typeof value === "string" && AGENT_ID_PATTERN.test(value);
+}
+function fork_path(transcript_path, agent_id) {
+  const directory = path.dirname(transcript_path);
+  const session_id = path.basename(transcript_path, TRANSCRIPT_EXTENSION);
+  const file_name = `${AGENT_PREFIX}${agent_id}${TRANSCRIPT_EXTENSION}`;
+  return path.join(cost_transcript.unit_directory(directory, session_id), file_name);
+}
+function transcript_of(transcript_path, agent_id) {
+  if (!is_agent_id(agent_id) || !transcript_path.endsWith(TRANSCRIPT_EXTENSION)) {
+    return transcript_path;
+  }
+  return fork_path(transcript_path, agent_id);
+}
+var time_hook_transcript = {
+  fork_path,
+  transcript_of
+};
+
+// scripts/time-runtime/time-density-hook.ts
+import { closeSync, fstatSync, openSync, readSync } from "node:fs";
+import { z as z4 } from "zod";
+
+// scripts/lib/transcript-record.ts
+import { z } from "zod";
+var TEXT_TYPE = "text";
+var TOOL_USE_TYPE = "tool_use";
+var TOOL_RESULT_TYPE = "tool_result";
+var BLOCK_SCHEMA = z.object({
+  type: z.string().nullish(),
+  text: z.string().nullish(),
+  name: z.string().nullish(),
+  id: z.string().nullish(),
+  tool_use_id: z.string().nullish(),
+  input: z.unknown().nullish(),
+  // Whether the harness wrote a `tool_result` back as a failure — absent on every other block, and
+  // on the results of tools that never report one.
+  is_error: z.boolean().nullish(),
+  // A result's body: a string or a list of blocks. Read as `unknown` because each reader flattens it
+  // its own way, and a narrower type here would drop the whole line over one odd item.
+  content: z.unknown().nullish()
+});
+var CONTENT_SCHEMA = z.union([z.string(), z.array(BLOCK_SCHEMA)]);
+var MESSAGE_SCHEMA = z.object({ id: z.string().nullish(), content: CONTENT_SCHEMA.nullish() });
+var LINE_SCHEMA = z.object({
+  type: z.string().nullish(),
+  timestamp: z.string().nullish(),
+  gitBranch: z.string().nullish(),
+  // The two fields outside `message` the harness writes an end-of-task notice on. `unknown`, since a
+  // string here would reject every line whose `content` is a list of blocks.
+  content: z.unknown().nullish(),
+  attachment: z.unknown().nullish(),
+  message: MESSAGE_SCHEMA.nullish()
+});
+function read(value) {
+  return LINE_SCHEMA.safeParse(value).data;
+}
+function parse(line) {
+  return read(json_value.parse_or_undefined(line));
+}
+function blocks_of(record2) {
+  const content = record2.message?.content;
+  return Array.isArray(content) ? content : [];
+}
+function is_tool_call(block) {
+  return block.type === TOOL_USE_TYPE && typeof block.name === "string";
+}
+function tool_calls_of(record2) {
+  return blocks_of(record2).filter((block) => is_tool_call(block));
+}
+var transcript_record = {
+  TEXT_TYPE,
+  TOOL_USE_TYPE,
+  TOOL_RESULT_TYPE,
+  read,
+  parse,
+  blocks_of,
+  tool_calls_of
+};
+
+// scripts/cost-runtime/cost-blocks.ts
+import { z as z2 } from "zod";
+var CONTENT_ITEM_SCHEMA = z2.object({ text: z2.string().nullish() });
+var RESULT_CONTENT_SCHEMA = z2.union([z2.string(), z2.array(CONTENT_ITEM_SCHEMA)]);
+var { TEXT_TYPE: TEXT_TYPE2, TOOL_USE_TYPE: TOOL_USE_TYPE2, TOOL_RESULT_TYPE: TOOL_RESULT_TYPE2 } = transcript_record;
+var BASH_TOOL = "Bash";
+var COMMAND_KEY = "command";
+function json_of(value) {
+  return value === void 0 || value === null ? "" : JSON.stringify(value);
+}
+function split_bash_input(input) {
+  if (!json_value.is_record(input)) return { command: "", rest: json_of(input) };
+  const command = input[COMMAND_KEY];
+  const rest = Object.entries(input).filter(([key]) => key !== COMMAND_KEY);
+  return {
+    command: typeof command === "string" ? command : "",
+    rest: json_of(Object.fromEntries(rest))
+  };
+}
+function to_tool_use(block) {
+  const tool_name = block.name ?? "";
+  const is_bash = tool_name === BASH_TOOL;
+  const { command, rest } = is_bash ? split_bash_input(block.input) : { command: "", rest: json_of(block.input) };
+  return { type: TOOL_USE_TYPE2, tool_name, command, text: rest };
+}
+function result_text(content) {
+  const parsed = RESULT_CONTENT_SCHEMA.safeParse(content);
+  if (!parsed.success) return "";
+  if (typeof parsed.data === "string") return parsed.data;
+  return parsed.data.map((item) => item.text ?? "").join("");
+}
+function to_plain_block(block) {
+  const base = { type: block.type ?? "", tool_name: "", command: "" };
+  const text = block.type === TOOL_RESULT_TYPE2 ? result_text(block.content) : block.text ?? "";
+  return { ...base, text };
+}
+function to_block(block) {
+  return block.type === TOOL_USE_TYPE2 ? to_tool_use(block) : to_plain_block(block);
+}
+function to_blocks(content) {
+  if (typeof content === "string") {
+    return [{ type: TEXT_TYPE2, tool_name: "", command: "", text: content }];
+  }
+  return content.map((block) => to_block(block));
+}
+function content_of(line) {
+  return transcript_record.parse(line)?.message?.content ?? void 0;
+}
+function parse_line(line) {
+  const content = content_of(line);
+  return content === void 0 ? [] : to_blocks(content);
+}
+function parse_content(text) {
+  return text.split("\n").flatMap((line) => parse_line(line));
+}
+var cost_blocks = {
+  BASH_TOOL,
+  TEXT_TYPE: TEXT_TYPE2,
+  TOOL_USE_TYPE: TOOL_USE_TYPE2,
+  TOOL_RESULT_TYPE: TOOL_RESULT_TYPE2,
+  parse_line,
+  parse_content
+};
+
+// scripts/josh/josh-aliases.ts
+var ALIASES = {
+  ga: "gate",
+  l: "lint",
+  lr: "lint:related",
+  cr: "check:related",
+  ln: "lines",
+  by: "bytes",
+  mt: "metrics",
+  f: "format",
+  sd: "cspell:dot",
+  bh: "behavior",
+  eu: "exports:unused",
+  t: "test",
+  tu: "test:unit",
+  tr: "test:related",
+  td: "test:declared",
+  trd: "test:red",
+  tpn: "test:pinned",
+  te: "test:e2e",
+  c: "check",
+  pt: "port",
+  i: "init",
+  pf: "profile",
+  st: "start",
+  sy: "sync",
+  un: "uninstall",
+  g: "git",
+  gp: "pr",
+  ms: "main:sync",
+  mm: "main:merge",
+  bp: "bump",
+  re: "release",
+  v: "version",
+  r: "ranges",
+  dr: "doctor",
+  rc: "ruleset:check",
+  pg: "propagate",
+  ad: "adopt",
+  ov: "overrides",
+  a: "audit",
+  rt: "reconcile-templates",
+  cdv: "command:derive",
+  u: "latest",
+  lc: "latest:corepack",
+  lu: "latest:update",
+  tm: "time",
+  tmd: "time:density",
+  rtr: "retrospective",
+  ca: "cost:audit",
+  rvf: "review:findings",
+  rvs: "review:stops",
+  ruv: "rule:value",
+  ev: "eval",
+  fr: "fresh:run",
+  as: "auth:setup",
+  lsm: "lane:sample",
+  lst: "lane:stats",
+  lva: "lane:value",
+  lnt: "lane:net",
+  lbd: "lane:breakdown",
+  lli: "lane:limit",
+  lrs: "lane:restart",
+  lwd: "lane:withdraw",
+  lps: "lane:pause",
+  lru: "lane:resume",
+  lad: "lane:adopt",
+  blr: "backlogrun"
+};
+function canonical_command(name) {
+  if (!Object.hasOwn(ALIASES, name)) return name;
+  return ALIASES[name] ?? name;
+}
+
+// scripts/time-runtime/time-shell.ts
+var BASH_SEPARATOR = ": ";
+var WHITESPACE_PATTERN = /\s+/u;
+var SEGMENT_PATTERN = /&&|\|\||;|\|/u;
+var PIPE_PATTERN = /(?<!\|)\|(?!\|)/u;
+var CHAIN_PATTERN = /&&|\|\||;|\n/u;
+var SUBSTITUTION_ATOM = /\$\([^()]*\)/u;
+var LONE_DOLLAR = /\$(?!\([^()]*\))/u;
+var QUOTED_SPAN_PATTERN = new RegExp(
+  String.raw`\\[\s\S]|'[^']*'|"(?:\\[\s\S]|${SUBSTITUTION_ATOM.source}|${LONE_DOLLAR.source}|[^"\\$])*"`,
+  "gu"
+);
+var HEREDOC_MARKER = /(?<!<)<<-?\s*(['"]?)(\w+)\1/u;
+var HEREDOC_DELIMITER_GROUP = 2;
+var LINE_BREAK = "\n";
+var DOUBLE_QUOTE = '"';
+var SUBSTITUTION_PATTERN = /(?<!\\)\$\((?<dollar>[^()]*)\)|(?<!\\)`(?<tick>[^`]*)`/gu;
+var PIPEFAIL_PATTERN = /\bset\s+-[a-z]*o\s+pipefail\b/u;
+var COMMAND_WORD_PATTERN = /^[\w./@:+][\w./@:+-]*$/u;
+var ASSIGNMENT_PATTERN = /^\w+=/u;
+var SUBSHELL_OPENER = "$(";
+var FLAG_PREFIX = "-";
+var WRAPPER_COMMANDS = /* @__PURE__ */ new Map([
+  ["time", { valued: /* @__PURE__ */ new Set(["-f", "-o", "--format", "--output"]), operands: 0 }],
+  ["env", { valued: /* @__PURE__ */ new Set(["-u", "-C", "-S", "--unset", "--chdir"]), operands: 0 }],
+  ["sudo", { valued: /* @__PURE__ */ new Set(["-u", "-g", "-C", "-D"]), operands: 0 }],
+  ["timeout", { valued: /* @__PURE__ */ new Set(["-s", "-k", "--signal", "--kill-after"]), operands: 1 }],
+  ["nohup", { valued: /* @__PURE__ */ new Set(), operands: 0 }],
+  ["nice", { valued: /* @__PURE__ */ new Set(["-n", "--adjustment"]), operands: 0 }],
+  ["command", { valued: /* @__PURE__ */ new Set(), operands: 0 }],
+  ["exec", { valued: /* @__PURE__ */ new Set(["-a"]), operands: 0 }],
+  ["stdbuf", { valued: /* @__PURE__ */ new Set(["-i", "-o", "-e"]), operands: 0 }]
+]);
+var NAVIGATION_COMMANDS = /* @__PURE__ */ new Set(["cd", "pushd", "popd", "export", "source", "set", "."]);
+var PATH_SEPARATOR = "/";
+var FLAG_AND_VALUE = 2;
+var JOSH_PATTERN = /^(?:(?:pnpm|npx)\s+(?:exec\s+)?)?josh\s+([a-z][\w:-]*)/u;
+var JOSH_PREFIX = "josh ";
+var COMMAND_KEY2 = "command";
+function bash_command(input) {
+  if (!json_value.is_record(input)) return "";
+  const command = input[COMMAND_KEY2];
+  return typeof command === "string" ? command : "";
+}
+function after_flags(words, start, valued) {
+  let index = start;
+  while (words[index]?.startsWith(FLAG_PREFIX) === true) {
+    index += valued.has(words[index] ?? "") ? FLAG_AND_VALUE : 1;
+  }
+  return index;
+}
+function after_prefix_word(words, index) {
+  const word = words[index] ?? "";
+  if (word.startsWith(FLAG_PREFIX) || ASSIGNMENT_PATTERN.test(word)) return index + 1;
+  const wrapper = WRAPPER_COMMANDS.get(word.slice(word.lastIndexOf(PATH_SEPARATOR) + 1));
+  if (wrapper === void 0) return index;
+  return after_flags(words, index + 1, wrapper.valued) + wrapper.operands;
+}
+function command_words(segment) {
+  const words = segment.replaceAll(SUBSHELL_OPENER, " ").trim().split(WHITESPACE_PATTERN);
+  let start = 0;
+  for (let next = after_prefix_word(words, start); next !== start; ) {
+    start = next;
+    next = after_prefix_word(words, start);
+  }
+  return words.slice(start);
+}
+function segment_command(segment) {
+  const [head] = command_words(segment);
+  if (head === void 0 || NAVIGATION_COMMANDS.has(head)) return "";
+  return COMMAND_WORD_PATTERN.test(head) ? head : "";
+}
+function command_segment(command) {
+  return command.split(SEGMENT_PATTERN).find((segment) => segment_command(segment) !== "") ?? "";
+}
+function leading_word(command) {
+  return segment_command(command_segment(command));
+}
+function open_heredoc(line, kept) {
+  kept.push(line.replace(HEREDOC_MARKER, " "));
+  return HEREDOC_MARKER.exec(line)?.[HEREDOC_DELIMITER_GROUP];
+}
+function close_heredoc(line, delimiter) {
+  return line.trim() === delimiter ? void 0 : delimiter;
+}
+function without_heredoc_bodies(command) {
+  const kept = [];
+  const body = {};
+  for (const line of command.split(LINE_BREAK)) {
+    body.delimiter = body.delimiter === void 0 ? open_heredoc(line, kept) : close_heredoc(line, body.delimiter);
+  }
+  return kept.join(LINE_BREAK);
+}
+function spoken_substitutions(span) {
+  if (!span.startsWith(DOUBLE_QUOTE)) return " ";
+  const inner = [...span.matchAll(SUBSTITUTION_PATTERN)].map(
+    (match) => (match.groups?.["dollar"] ?? match.groups?.["tick"] ?? "").replaceAll(QUOTED_SPAN_PATTERN, " ")
+  );
+  return inner.length === 0 ? " " : ` ; ${inner.join(" ; ")} ; `;
+}
+function unquoted(command) {
+  return without_heredoc_bodies(command).replaceAll(
+    QUOTED_SPAN_PATTERN,
+    (span) => spoken_substitutions(span)
+  );
+}
+function has_heredoc(command) {
+  return HEREDOC_MARKER.test(command);
+}
+function blanked(command) {
+  if (has_heredoc(command)) return void 0;
+  return command.replaceAll(QUOTED_SPAN_PATTERN, (span) => " ".repeat(span.length));
+}
+function discarded_commands(command) {
+  const plain = unquoted(command);
+  if (PIPEFAIL_PATTERN.test(plain)) return [];
+  return plain.split(PIPE_PATTERN).slice(0, -1).map((segment) => segment.split(CHAIN_PATTERN).at(-1) ?? "");
+}
+function bash_label(command) {
+  const word = leading_word(command);
+  return word === "" ? cost_blocks.BASH_TOOL : `${cost_blocks.BASH_TOOL}${BASH_SEPARATOR}${word}`;
+}
+function josh_command_of_segment(segment) {
+  const name = JOSH_PATTERN.exec(command_words(segment).join(" "))?.[1];
+  return name === void 0 ? "" : `${JOSH_PREFIX}${canonical_command(name)}`;
+}
+function josh_command_of(command) {
+  return josh_command_of_segment(command_segment(command));
+}
+function josh_commands_of(command) {
+  return unquoted(command).split(SEGMENT_PATTERN).map((segment) => josh_command_of_segment(segment)).filter((name) => name !== "");
+}
+var REDIRECTION_CHARACTERS = ["<", ">"];
+function is_redirection(word) {
+  return REDIRECTION_CHARACTERS.some((character) => word.includes(character));
+}
+function ends_in_redirection(word) {
+  return REDIRECTION_CHARACTERS.some((character) => word.endsWith(character));
+}
+function drop_redirections(words) {
+  const kept = [];
+  let is_target2 = false;
+  for (const word of words) {
+    const is_dropped = is_target2 || is_redirection(word);
+    is_target2 = ends_in_redirection(word);
+    if (!is_dropped) kept.push(word);
+  }
+  return kept;
+}
+function josh_arguments_of_segment(segment) {
+  const text = command_words(segment).join(" ");
+  const match = JOSH_PATTERN.exec(text);
+  if (match === null) return [];
+  const words = text.slice(match[0].length).split(WHITESPACE_PATTERN).filter((word) => word !== "");
+  return drop_redirections(words);
+}
+function josh_arguments(command) {
+  return josh_arguments_of_segment(command_segment(command));
+}
+function josh_signature_of_segment(segment) {
+  const name = josh_command_of_segment(segment);
+  if (name === "") return "";
+  return [name, ...josh_arguments_of_segment(segment)].join(" ");
+}
+function josh_signatures_of(command) {
+  return unquoted(command).split(SEGMENT_PATTERN).map((segment) => josh_signature_of_segment(segment)).filter((signature) => signature !== "");
+}
+var time_shell = {
+  JOSH_PREFIX,
+  bash_command,
+  bash_label,
+  blanked,
+  command_segment,
+  discarded_commands,
+  has_heredoc,
+  josh_arguments,
+  josh_command_of,
+  josh_command_of_segment,
+  josh_commands_of,
+  josh_signatures_of,
+  leading_word,
+  unquoted,
+  without_heredoc_bodies
+};
+
+// scripts/time-runtime/time-bundle-call.ts
+var { BASH_TOOL: BASH_TOOL2 } = cost_blocks;
+var BUNDLEABLE_TOOLS = /* @__PURE__ */ new Set(["Edit", "Glob", "Grep", "Read", "WebFetch", "WebSearch", "Write"]);
+var LAUNCH_TOOLS = /* @__PURE__ */ new Set(["Agent", "Task"]);
+var PRIOR_REFERENCE_MARKERS = [
+  "previous finding",
+  "prior finding",
+  "earlier finding",
+  "previous result",
+  "prior result",
+  "earlier result",
+  "based on the previous",
+  "based on the earlier",
+  "from the previous agent",
+  "from the prior agent",
+  "the finding above",
+  "as found earlier",
+  "as found above",
+  "building on the previous"
+];
+var READ_COMMANDS = /* @__PURE__ */ new Set([
+  "awk",
+  "basename",
+  "cat",
+  "comm",
+  "cut",
+  "diff",
+  "dirname",
+  "du",
+  "echo",
+  "file",
+  "find",
+  "gh",
+  "grep",
+  "head",
+  "jq",
+  "ls",
+  "nl",
+  "printf",
+  "pwd",
+  "realpath",
+  "rg",
+  // **`sed -i` is deliberately not excluded.** An in-place edit is what `Edit` does, and `Edit` is on
+  // the allow-list above — a turn may issue several of them, so rejecting the shell spelling of the
+  // same thing would exclude a call the tool form counts. Two in-place edits of the *same* file are
+  // caught by the target test instead, which is where that ordering actually lives.
+  "sed",
+  "sort",
+  "stat",
+  "tail",
+  "tree",
+  "uniq",
+  "wc",
+  "which"
+]);
+var MUTATION_WORDS = /* @__PURE__ */ new Set([
+  "--field",
+  "--method",
+  "--raw-field",
+  "-F",
+  "-X",
+  "-delete",
+  "-exec",
+  "-f",
+  "add",
+  "chmod",
+  "chown",
+  "close",
+  "comment",
+  "cp",
+  "create",
+  "dd",
+  "delete",
+  "edit",
+  "git",
+  "install",
+  "kill",
+  "ln",
+  "merge",
+  "mkdir",
+  "mv",
+  "node",
+  "npm",
+  "npx",
+  "pkill",
+  "pnpm",
+  "remove",
+  "rm",
+  "scp",
+  "secret",
+  "set",
+  "ssh",
+  "sudo",
+  "tee",
+  "touch",
+  "truncate",
+  "tsx",
+  "upload",
+  "wget"
+]);
+var READ_JOSH_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "backlog:budget",
+  "backlog:next",
+  "cost",
+  "delegate",
+  "epic:audit",
+  "epic:bundle",
+  "epic:check",
+  "epic:next",
+  "issue:read",
+  "issue:scout",
+  "issue:state",
+  "lane:list",
+  "latest:scope",
+  "release:scope",
+  "review:brief",
+  "review:round2",
+  "run:liveness"
+]);
+var JOSH_WORD = "josh";
+var JOSH_SCRIPT_SUFFIX = "josh.ts";
+var COMMAND_CHAIN = /[|;&`>]|\$\(/u;
+var WHITESPACE_PATTERN2 = /\s+/u;
+var TARGET_FIELDS = ["file_path", "notebook_path", "path", "url"];
+var TARGET_ARRAY_FIELD = "file_paths";
+var MAX_TARGETS = 8;
+var WORD_PATTERN = /[\s'"=(),;:|&]+/u;
+var EXTENSION_PATTERN = /^[A-Za-z]+$/u;
+var MAX_EXTENSION = 5;
+var AFTER_DOT = 1;
+var FIRST_INDEX = 0;
+var CURRENT_DIRECTORY = "./";
+var LAST_CHARACTER = -1;
+var FLAG_PREFIX2 = "-";
+var PATH_SEPARATOR2 = "/";
+var MIN_TARGET_LENGTH = 3;
+var WRITING_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "NotebookEdit"]);
+var WRITING_WORDS = /* @__PURE__ */ new Set(["dd", "sed", "tee"]);
+var REDIRECTION = ">";
+var IN_PLACE_COMMAND = "sed";
+var IN_PLACE_FLAG_PATTERN = /^--in-place\b|^-[A-Za-z]*i/u;
+function not_bundleable() {
+  return {
+    is_bundleable: false,
+    targets: [],
+    is_writing: false,
+    may_write: false,
+    has_prior_reference: false
+  };
+}
+function is_launch_tool(name) {
+  return LAUNCH_TOOLS.has(name);
+}
+function words_of(command) {
+  return command.split(WORD_PATTERN).filter((word) => word !== "");
+}
+function has_mutation(command) {
+  return words_of(command).some((word) => MUTATION_WORDS.has(word));
+}
+function josh_subcommand(command) {
+  const tokens = command.split(WHITESPACE_PATTERN2).filter((token) => token !== "");
+  const josh_index = tokens.findIndex(
+    (token) => token === JOSH_WORD || token.endsWith(JOSH_SCRIPT_SUFFIX)
+  );
+  return josh_index < FIRST_INDEX ? void 0 : tokens[josh_index + 1];
+}
+function is_read_josh(command) {
+  if (COMMAND_CHAIN.test(command)) return false;
+  const subcommand = josh_subcommand(command);
+  if (subcommand === void 0) return false;
+  return READ_JOSH_SUBCOMMANDS.has(canonical_command(subcommand));
+}
+function may_write_command(command) {
+  if (command.includes(REDIRECTION)) return true;
+  return words_of(command).some((word) => WRITING_WORDS.has(word));
+}
+function write_segment(command) {
+  return time_shell.command_segment(time_shell.unquoted(command));
+}
+function is_in_place_sed(segment) {
+  if (time_shell.leading_word(segment) !== IN_PLACE_COMMAND) return false;
+  return words_of(segment).some((word) => IN_PLACE_FLAG_PATTERN.test(word));
+}
+function normalize(word) {
+  const head = word.startsWith(CURRENT_DIRECTORY) ? word.slice(CURRENT_DIRECTORY.length) : word;
+  return head.endsWith(PATH_SEPARATOR2) ? head.slice(0, LAST_CHARACTER) : head;
+}
+function has_extension(word) {
+  const dot = word.lastIndexOf(".");
+  if (dot <= FIRST_INDEX) return false;
+  const suffix = word.slice(dot + AFTER_DOT);
+  return suffix.length <= MAX_EXTENSION && EXTENSION_PATTERN.test(suffix);
+}
+function is_target(word) {
+  if (word.startsWith(FLAG_PREFIX2) || word.length < MIN_TARGET_LENGTH) return false;
+  return word.includes(PATH_SEPARATOR2) || has_extension(word);
+}
+function targets_in(text) {
+  return words_of(text).map((word) => normalize(word)).filter((word) => is_target(word)).slice(0, MAX_TARGETS);
+}
+function field_text(input, field) {
+  if (!json_value.is_record(input)) return "";
+  const value = input[field];
+  return typeof value === "string" ? value : "";
+}
+function field_targets(input) {
+  if (!json_value.is_record(input)) return [];
+  const value = input[TARGET_ARRAY_FIELD];
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function tool_targets(input) {
+  const scalar_targets = TARGET_FIELDS.map((field) => field_text(input, field));
+  const targets = [...scalar_targets, ...field_targets(input)].map((target) => normalize(target));
+  return [...new Set(targets)].filter((target) => target !== "");
+}
+function prompt_references_prior(input) {
+  const prompt = field_text(input, "prompt").toLowerCase();
+  return PRIOR_REFERENCE_MARKERS.some((marker) => prompt.includes(marker));
+}
+function tool_facts(name, input) {
+  const writes = { is_writing: WRITING_TOOLS.has(name), may_write: WRITING_TOOLS.has(name) };
+  const has_prior_reference = LAUNCH_TOOLS.has(name) && prompt_references_prior(input);
+  if (!BUNDLEABLE_TOOLS.has(name)) return { ...not_bundleable(), ...writes, has_prior_reference };
+  return { is_bundleable: true, targets: tool_targets(input), ...writes, has_prior_reference };
+}
+function bash_facts(command) {
+  const writes = {
+    is_writing: is_in_place_sed(write_segment(command)),
+    may_write: may_write_command(command)
+  };
+  if (is_read_josh(command)) {
+    return {
+      is_bundleable: true,
+      targets: targets_in(time_shell.unquoted(command)),
+      ...writes,
+      has_prior_reference: false
+    };
+  }
+  if (!READ_COMMANDS.has(time_shell.leading_word(command)) || has_mutation(command)) {
+    return { ...not_bundleable(), ...writes };
+  }
+  return {
+    is_bundleable: true,
+    targets: targets_in(time_shell.unquoted(command)),
+    ...writes,
+    has_prior_reference: false
+  };
+}
+function call_facts(name, input) {
+  if (name !== BASH_TOOL2) return tool_facts(name, input);
+  return bash_facts(time_shell.bash_command(input));
+}
+var time_bundle_call = {
+  MAX_TARGETS,
+  not_bundleable,
+  bash_facts,
+  call_facts,
+  tool_facts,
+  // Exported for `time-agent-bundles.ts`, which asks the launch question of a
+  // span's `label` — the tool name for a non-Bash call — so the set lives in one place.
+  is_launch_tool,
+  // Exported for `time-writes.ts`, which asks what a call *wrote* rather
+  // than what it named. The extraction is the same one either way — a second copy of it would let a
+  // path be recognized as a target when read and missed when written.
+  targets_in,
+  tool_targets,
+  // Exported for the batching guard's own word scan, so the two scanners
+  // cannot come to disagree about where one word of a shell line ends and the next begins.
+  // Exported for the read-fold notice, which offers `read:files <path>` only
+  // over file-shaped targets — a bare directory like `scripts/` is a target here but not something
+  // `read:files` can read, so the notice reuses this test rather than keep a second copy that could
+  // drift from what counts as a file path.
+  has_extension,
+  // Exported for `time-writes.ts`, which needs the same two answers to say
+  // *which* files an in-place `sed` wrote. Two copies of this test disagreed in both directions at
+  // once — one called a piped `grep -i` a write, the other missed a bundled `sed -ni`.
+  write_segment,
+  is_in_place_sed,
+  // Exported for the drift test in `time-bundle-call.test.ts`, which pins that
+  // every name here is a real `josh` command and none of them writes.
+  READ_JOSH_SUBCOMMANDS
+};
+
+// scripts/time-runtime/time-phase-names.ts
+var GATE_PHASE = "gate";
+var PR_PHASE = "pr";
+var MERGE_PHASE = "merge";
+var GATE_COMMAND = "josh gate";
+var COMMAND_PHASES = /* @__PURE__ */ new Map([
+  [GATE_COMMAND, GATE_PHASE],
+  ["josh git", PR_PHASE],
+  ["josh pr", PR_PHASE],
+  ["josh followup", MERGE_PHASE]
+]);
+
+// scripts/time-runtime/time-background.ts
+var NO_BACKGROUND = "";
+var NO_FINISH = 0;
+var LAUNCH_PATTERN = /(?:running in background with ID:|moved to the background \(ID:)\s*([\w-]+)/iu;
+var AGENT_LAUNCH_PATTERN = /^(?:Async agent launched[\s\S]*?\bagentId:\s*|\{"success":[^\n]*?"resumedAgentId":")([\w-]+)/u;
+var FINISH_PATTERN = /^<task-notification>[\s\S]*?<task-id>([\w-]+)<\/task-id>/u;
+var STOP_PATTERN = /^\{"message":"Successfully stopped task:\s*([\w-]+)/u;
+var OUTPUT_PATTERN = /tasks\/([\w-]+)\.output/u;
+var BASH_ID_KEY = "bash_id";
+function read_id(command) {
+  return OUTPUT_PATTERN.exec(time_shell.unquoted(command))?.[1] ?? NO_BACKGROUND;
+}
+function read_id_of(input) {
+  if (!json_value.is_record(input)) return NO_BACKGROUND;
+  const id = input[BASH_ID_KEY];
+  return typeof id === "string" ? id : read_id(time_shell.bash_command(input));
+}
+function launch_id(text) {
+  return LAUNCH_PATTERN.exec(text)?.[1] ?? NO_BACKGROUND;
+}
+function agent_launch_id(text) {
+  return AGENT_LAUNCH_PATTERN.exec(text)?.[1] ?? NO_BACKGROUND;
+}
+function finished_id(text) {
+  return FINISH_PATTERN.exec(text)?.[1] ?? NO_BACKGROUND;
+}
+function stopped_id(text) {
+  return STOP_PATTERN.exec(text)?.[1] ?? NO_BACKGROUND;
+}
+function finished_at(lines) {
+  const notices = lines.filter((one) => one.finished_background !== NO_BACKGROUND).toSorted((left, right) => right.timestamp_ms - left.timestamp_ms);
+  return new Map(notices.map((one) => [one.finished_background, one.timestamp_ms]));
+}
+function started_ms(span) {
+  return span.ended_ms - span.duration_ms;
+}
+function read_end_ms(spans, run) {
+  if (run.background_ended_ms === NO_FINISH) return void 0;
+  const found = spans.find(
+    (span) => span.reads_background === run.background_id && span.ended_ms >= run.background_ended_ms
+  );
+  return found?.ended_ms;
+}
+function to_run(spans, launch) {
+  const read2 = read_end_ms(spans, launch);
+  return {
+    id: launch.background_id,
+    josh_command: launch.josh_command,
+    started_ms: started_ms(launch),
+    ended_ms: read2 ?? launch.ended_ms,
+    is_read: read2 !== void 0
+  };
+}
+function is_launch(span) {
+  return span.background_id !== NO_BACKGROUND;
+}
+function runs(spans) {
+  return spans.filter((span) => is_launch(span)).map((launch) => to_run(spans, launch));
+}
+function is_within(span, run) {
+  const start = started_ms(span);
+  return start >= run.started_ms && start < run.ended_ms;
+}
+function latest_first(all2) {
+  return all2.filter((run) => run.is_read).toSorted((left, right) => right.started_ms - left.started_ms);
+}
+function own_run(span, all2) {
+  return is_launch(span) ? all2.find((run) => run.id === span.background_id) : void 0;
+}
+function placed(span, all2, ordered) {
+  const own = own_run(span, all2);
+  const run = own ?? ordered.find((one) => is_within(span, one));
+  if (run === void 0) return span;
+  const beside = { ...span, background_command: run.josh_command };
+  return own === void 0 ? beside : { ...beside, own_duration_ms: own.ended_ms - own.started_ms };
+}
+function positioned(spans) {
+  const all2 = runs(spans);
+  if (all2.length === 0) return [...spans];
+  const ordered = latest_first(all2);
+  return spans.map((span) => placed(span, all2, ordered));
+}
+function unread_phases(spans) {
+  const names = runs(spans).filter((run) => !run.is_read).map((run) => COMMAND_PHASES.get(run.josh_command));
+  return new Set(names.filter((phase) => phase !== void 0));
+}
+var time_background = {
+  NO_BACKGROUND,
+  NO_FINISH,
+  launch_id,
+  agent_launch_id,
+  finished_id,
+  stopped_id,
+  finished_at,
+  read_id,
+  read_id_of,
+  runs,
+  positioned,
+  unread_phases
+};
+
+// 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";
+var KEY_DESCRIPTION = "description";
+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;
+  const check = { name, status: parse_rollup_status(item) };
+  const description = read_string(item[KEY_DESCRIPTION]);
+  return description === void 0 ? check : { ...check, description };
+}
+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 with_head_sha(snapshot, head_sha) {
+  return head_sha === void 0 ? snapshot : { ...snapshot, head_sha };
+}
+function with_required_contexts(snapshot, required_contexts) {
+  if (required_contexts === void 0 || required_contexts.length === 0) return snapshot;
+  return { ...snapshot, required_contexts };
+}
+function read_pr_raw_data(raw_json) {
+  const result = pr_raw_schema.safeParse(json_value.parse_or_undefined(raw_json));
+  return result.success ? result.data : {};
+}
+function parse_pr_state_snapshot(raw_json) {
+  const data = read_pr_raw_data(raw_json);
+  const snapshot = {
+    rollup: parse_rollup_checks(raw_json),
+    merge_state_status: read_string(data.mergeStateStatus),
+    review_decision: read_string(data.reviewDecision)
+  };
+  return with_required_contexts(
+    with_head_sha(snapshot, read_string(data.headRefOid)),
+    data.requiredContexts
+  );
+}
+
+// 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);
+}
+var CODERABBIT_RATE_LIMIT_DESCRIPTION = /rate limit/iu;
+function is_coderabbit_rate_limited(check) {
+  return is_coderabbit_check(check.name) && CODERABBIT_RATE_LIMIT_DESCRIPTION.test(check.description ?? "");
+}
+function matches_any(check_name, required_names) {
+  return required_names.some((required) => is_required_match(check_name, required));
+}
+function is_optional_pending(check, required_contexts) {
+  if (required_contexts.length === 0 || check.status !== CHECK_STATUS_PENDING) return false;
+  return !matches_any(check.name, required_contexts);
+}
+function is_every_context_passing(checks, contexts) {
+  return contexts.every(
+    (context) => find_required_check(checks, context)?.status === CHECK_STATUS_PASS
+  );
+}
+function is_unstable_only_from_optional(snapshot) {
+  if (snapshot.merge_state_status !== MERGE_STATE_UNSTABLE) return false;
+  const required_contexts = snapshot.required_contexts ?? [];
+  const non_passing = snapshot.rollup.filter((check) => check.status !== CHECK_STATUS_PASS);
+  if (non_passing.length === 0) return false;
+  const is_tolerated = non_passing.every(
+    (check) => is_coderabbit_check(check.name) || is_optional_pending(check, required_contexts)
+  );
+  return is_tolerated && is_every_context_passing(snapshot.rollup, required_contexts);
+}
+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_optional(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 SECOND_DECIMALS = 1;
+var LABEL_WIDTH = 24;
+var MINUTES_WIDTH = 9;
+var NOT_MEASURED = "not measured";
+var NO_CALLS = "no tool call to divide";
+var MAX_ROWS = 15;
+function overflow_line(row_count) {
+  if (row_count <= MAX_ROWS) return [];
+  return [
+    `  \u2026 and ${String(row_count - MAX_ROWS)} more (--json carries every row this report holds)`
+  ];
+}
+function format_seconds(duration_ms) {
+  return `${(duration_ms / MS_PER_SECOND).toFixed(SECOND_DECIMALS)} s`;
+}
+function format_columns(label, minutes, suffix) {
+  return `  ${label.padEnd(LABEL_WIDTH)}${minutes.padStart(MINUTES_WIDTH)}   ${suffix}`;
+}
+function format_row(label, duration_ms, suffix) {
+  return format_columns(label, figure_format.format_minutes(duration_ms), suffix);
+}
+function unmeasured_row(label) {
+  return format_columns(label, "", NOT_MEASURED);
+}
+var time_format = {
+  MAX_ROWS,
+  NO_CALLS,
+  overflow_line,
+  format_seconds,
+  format_columns,
+  format_row,
+  // `format_clock` stays private: `format_window` is its only caller, and a namespace that offers
+  // both invites a second renderer to join the two with its own arrow.
+  unmeasured_row
+};
+
+// scripts/followup/followup-ci-path.ts
+function new_path() {
+  return { pending: /* @__PURE__ */ new Set(), check_ms: {} };
+}
+function settle(path3, name, elapsed_ms) {
+  if (path3.pending.delete(name)) path3.check_ms[name] = elapsed_ms;
+}
+function observe(path3, snapshot, now_ms) {
+  path3.start_ms ??= now_ms;
+  const elapsed_ms = now_ms - path3.start_ms;
+  const checks = snapshot.rollup.filter((check) => !is_coderabbit_check(check.name));
+  for (const check of checks) {
+    if (check.status === CHECK_STATUS_PENDING) path3.pending.add(check.name);
+    else settle(path3, check.name, elapsed_ms);
+  }
+}
+function observer_of(path3) {
+  const is_first_wait = path3.start_ms === void 0;
+  return async function time_checks(snapshot) {
+    if (is_first_wait) observe(path3, snapshot, performance.now());
+  };
+}
+function record_of(path3) {
+  const [last] = Object.entries(path3.check_ms).toSorted((left, right) => right[1] - left[1]);
+  if (last === void 0) return {};
+  return { last_check: last[0], check_ms: { ...path3.check_ms } };
+}
+var followup_ci_path = { new_path, observe, observer_of, record_of };
+
+// scripts/run/event/run-event-checks.ts
+var CODERABBIT_STATES = ["running", "done", "rate-limited", "failed", "none"];
+var CHECKS_PATTERN = /^#\d+ PR (?<pr>\d+) pass (?<pass>\d+) pending (?<pending>\d+) fail (?<fail>\d+) coderabbit (?<coderabbit>\S+)$/u;
+function text_of(issue, checks) {
+  const { pr, pass, pending, fail, coderabbit } = checks;
+  return `${issue_cite.plain(issue)} PR ${String(pr)} pass ${String(pass)} pending ${String(pending)} fail ${String(fail)} coderabbit ${coderabbit}`;
+}
+var STATE_NAMES = new Set(CODERABBIT_STATES);
+function is_coderabbit_state(value = "") {
+  return STATE_NAMES.has(value);
+}
+function checks_of(text) {
+  const groups = CHECKS_PATTERN.exec(text)?.groups;
+  const coderabbit = groups?.["coderabbit"];
+  if (groups === void 0 || !is_coderabbit_state(coderabbit)) return void 0;
+  return {
+    pr: Number(groups["pr"]),
+    pass: Number(groups["pass"]),
+    pending: Number(groups["pending"]),
+    fail: Number(groups["fail"]),
+    coderabbit
+  };
+}
+var run_event_checks = { checks_of, text_of };
+
+// scripts/followup/followup-checks-event.ts
+var PR_NUMBER_PATTERN = /\/pull\/(?<number>\d+)/u;
+var { PR_CHECKS } = run_event_stream.EVENT_KIND;
+function count_of(checks, status) {
+  return checks.filter((check) => check.status === status).length;
+}
+function coderabbit_state_of(check) {
+  if (check === void 0) return "none";
+  if (check.status === CHECK_STATUS_PENDING) return "running";
+  if (check.status !== CHECK_STATUS_PASS) return "failed";
+  return is_coderabbit_rate_limited(check) ? "rate-limited" : "done";
+}
+function coderabbit_of(snapshot) {
+  return coderabbit_state_of(snapshot.rollup.find((check) => is_coderabbit_check(check.name)));
+}
+function summary_of(snapshot, pr) {
+  const ci = snapshot.rollup.filter((check) => !is_coderabbit_check(check.name));
+  return {
+    pr,
+    pass: count_of(ci, CHECK_STATUS_PASS),
+    pending: count_of(ci, CHECK_STATUS_PENDING),
+    fail: count_of(ci, CHECK_STATUS_FAIL),
+    coderabbit: coderabbit_of(snapshot)
+  };
+}
+function pr_number_of(pr_url = "") {
+  const number = PR_NUMBER_PATTERN.exec(pr_url)?.groups?.["number"];
+  return number === void 0 ? void 0 : Number(number);
+}
+async function skip_snapshot() {
+}
+function observer_of2(issue, pr_url) {
+  const pr = pr_number_of(pr_url);
+  if (issue === void 0 || pr === void 0) return skip_snapshot;
+  let last_text = "";
+  return async function report_snapshot(snapshot) {
+    const text = run_event_checks.text_of(issue, summary_of(snapshot, pr));
+    if (text === last_text) return;
+    last_text = text;
+    await run_event_stream_emit.emit(PR_CHECKS, text);
+  };
+}
+var followup_checks_event = { coderabbit_of, observer_of: observer_of2, summary_of };
+
+// scripts/followup/followup-coderabbit-wait.ts
+var NO_TIME = 0;
+var RATE_LIMITED = "rate-limited";
+var WAITING_STATES = /* @__PURE__ */ new Set(["running", RATE_LIMITED]);
+function new_wait() {
+  return { wait_ms: NO_TIME, rate_limited_ms: NO_TIME };
+}
+function charge(wait, last, now_ms) {
+  const elapsed_ms = now_ms - last.at_ms;
+  if (WAITING_STATES.has(last.state)) wait.wait_ms += elapsed_ms;
+  if (last.state === RATE_LIMITED) wait.rate_limited_ms += elapsed_ms;
+}
+function observe2(wait, snapshot, now_ms) {
+  if (wait.last !== void 0) charge(wait, wait.last, now_ms);
+  wait.last = { state: followup_checks_event.coderabbit_of(snapshot), at_ms: now_ms };
+}
+function observer_of3(wait) {
+  delete wait.last;
+  return async function time_snapshot(snapshot) {
+    observe2(wait, snapshot, performance.now());
+  };
+}
+function all(...observers) {
+  return async function observe_all(snapshot) {
+    await Promise.all(
+      observers.map(async (observer) => {
+        await observer(snapshot);
+      })
+    );
+  };
+}
+async function record_part(stage, elapsed_ms) {
+  if (elapsed_ms > NO_TIME) await lane_ledger_write.record_stage({ stage, elapsed_ms });
+}
+async function record(wait) {
+  await record_part(lane_ledger_write.CODERABBIT_WAIT_STAGE, wait.wait_ms);
+  await record_part(lane_ledger_write.CODERABBIT_RATE_LIMIT_STAGE, wait.rate_limited_ms);
+}
+var followup_coderabbit_wait = { all, new_wait, observe: observe2, observer_of: observer_of3, record };
+
+// scripts/followup/git-followup-stages.ts
+var STAGE_LINE_PREFIX = "followup stage: ";
+var STAGE_TOTAL_PREFIX = "followup stages total: ";
+var STAGE_NAME_WIDTH = 26;
+var VALUE_COLUMN = STAGE_LINE_PREFIX.length + STAGE_NAME_WIDTH;
+var NO_DURATION = 0;
+var STAGE = {
+  closes_and_context: "closes-and-context",
+  checks_wait: "checks-wait",
+  // Only on a run that retriggered a rate-limited CodeRabbit: the window and the review after it
+  // (joshuafolkken/kit#5289), kept out of `checks-wait` so the `ci-wait` row is the checks alone.
+  coderabbit_retrigger: "coderabbit-retrigger",
+  coderabbit_comments: "coderabbit-comments",
+  ai_review_comments: "ai-review-comments",
+  // The interval of a run that merged nothing, where the send has nothing to go beside.
+  telegram: "telegram",
+  telegram_and_merge: "telegram-and-merge",
+  completion_and_epic_close: "completion-and-epic-close",
+  // The completion tail `git-followup-finish.ts` prints after this block (#5131): the next-issue list
+  // and the unreleased-merge count. Printed as its own row there, since the block is already out.
+  completion: "completion",
+  // 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",
+  // The interrupted lap when the wait failed on a merge conflict, so the
+  // stage block names the cause a resumed session would otherwise 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(),
+    coderabbit: followup_coderabbit_wait.new_wait(),
+    ci_path: followup_ci_path.new_path()
+  };
+}
+function hold_issue(log, issue_number) {
+  const issue = Number(issue_number);
+  if (Number.isSafeInteger(issue) && issue > 0) log.issue = issue;
+}
+function lap(log, name) {
+  const now_ms = performance.now();
+  log.stages.push({ name, duration_ms: now_ms - log.last_ms });
+  log.last_ms = now_ms;
+}
+function total_ms(stages) {
+  return stages.reduce((sum, stage) => sum + stage.duration_ms, NO_DURATION);
+}
+function format_stage(stage) {
+  const name = stage.name.padEnd(STAGE_NAME_WIDTH);
+  return `${STAGE_LINE_PREFIX}${name}${time_format.format_seconds(stage.duration_ms)}`;
+}
+function format_stages(log) {
+  if (log.stages.length === 0) return [];
+  const rows = log.stages.map((stage) => format_stage(stage));
+  const total = time_format.format_seconds(total_ms(log.stages));
+  return ["", ...rows, `${STAGE_TOTAL_PREFIX.padEnd(VALUE_COLUMN)}${total}`];
+}
+function print_stages(log) {
+  for (const line of format_stages(log)) console.info(line);
+}
+async function record_ci_wait(log) {
+  const wait = log.stages.find((stage) => stage.name === STAGE.checks_wait);
+  if (wait === void 0) return;
+  await lane_ledger_write.record_stage({
+    stage: lane_ledger_write.CI_WAIT_STAGE,
+    elapsed_ms: wait.duration_ms,
+    ...log.issue !== void 0 && { issue: log.issue },
+    ...followup_ci_path.record_of(log.ci_path)
+  });
+}
+async function record_waits(log) {
+  await record_ci_wait(log);
+  await followup_coderabbit_wait.record(log.coderabbit);
+}
+var git_followup_stages = {
+  STAGE,
+  STAGE_LINE_PREFIX,
+  STAGE_TOTAL_PREFIX,
+  new_log,
+  hold_issue,
+  lap,
+  total_ms,
+  format_stage,
+  format_stages,
+  print_stages,
+  record_waits,
+  stopped_lap
+};
+
+// scripts/time-runtime/time-followup-stage.ts
+var LINE_SEPARATOR = "\n";
+var SECONDS_SUFFIX = " s";
+var DIGIT_OR_POINT = /[\d.]/u;
+var NO_STAGES = [];
+function stage_body(line) {
+  const trimmed = line.trimStart();
+  if (!trimmed.startsWith(git_followup_stages.STAGE_LINE_PREFIX)) return void 0;
+  return trimmed.slice(git_followup_stages.STAGE_LINE_PREFIX.length);
+}
+function digits_start(head) {
+  let index = head.length;
+  while (index > 0 && DIGIT_OR_POINT.test(head.charAt(index - 1))) index -= 1;
+  return index;
+}
+function is_duration(digits) {
+  return digits !== "" && Number.isFinite(Number(digits));
+}
+function to_stage(body) {
+  const text = body.trimEnd();
+  if (!text.endsWith(SECONDS_SUFFIX)) return void 0;
+  const head = text.slice(0, -SECONDS_SUFFIX.length);
+  const start = digits_start(head);
+  const name = head.slice(0, start).trim();
+  const digits = head.slice(start);
+  if (name === "" || !is_duration(digits)) return void 0;
+  return { name, duration_ms: Number(digits) * MS_PER_SECOND };
+}
+function read_stages(text) {
+  if (!text.includes(git_followup_stages.STAGE_LINE_PREFIX)) return NO_STAGES;
+  return text.split(LINE_SEPARATOR).map((line) => stage_body(line)).filter((body) => body !== void 0).map((body) => to_stage(body)).filter((stage) => stage !== void 0);
+}
+var time_followup_stage = { NO_STAGES, read_stages };
+
+// scripts/lib/status-icons.ts
+var FAIL_ICON = "\u2717";
+var PASS_ICON = "\u2714";
+var WARN_ICON = "\u26A0";
+var status_icons = { FAIL_ICON, PASS_ICON, WARN_ICON };
+
+// scripts/josh/josh-verdict.ts
+var { FAIL_ICON: FAIL_ICON2, PASS_ICON: PASS_ICON2, WARN_ICON: WARN_ICON2 } = status_icons;
+var GATE_SUBJECT = "verification gate";
+var GATE_PASSED_PREFIX = `${PASS_ICON2} ${GATE_SUBJECT} passed`;
+var GATE_FAILED_PREFIX = `${FAIL_ICON2} ${GATE_SUBJECT} failed`;
+var GATE_UNVERIFIED_PREFIX = `${WARN_ICON2} ${GATE_SUBJECT} not verified`;
+var PASSED_VERDICT = "passed";
+var FAILED_VERDICT = "failed";
+var UNVERIFIED_VERDICT = "unverified";
+function format_counts(counts) {
+  if (counts.skipped === 0) return `${String(counts.ran)} checks`;
+  return `${String(counts.ran)} ran, ${String(counts.skipped)} skipped`;
+}
+function format_gate_passed(counts, total) {
+  return `${GATE_PASSED_PREFIX} (${format_counts(counts)}) in ${total}.`;
+}
+function format_gate_unverified(skipped, total) {
+  return `${GATE_UNVERIFIED_PREFIX} (0 ran, ${String(skipped)} skipped) in ${total}.`;
+}
+function format_gate_failed(failed_labels, total) {
+  return `${GATE_FAILED_PREFIX}: ${failed_labels} (${total})`;
+}
+var GATE_OPENING_PREFIX = "plan: ";
+var GATE_OPENING_MARK = " checks at once";
+function is_gate_opening(line) {
+  const trimmed = line.trimStart();
+  return trimmed.startsWith(GATE_OPENING_PREFIX) && trimmed.includes(GATE_OPENING_MARK);
+}
+function read_verdict(line) {
+  const trimmed = line.trimStart();
+  if (trimmed.startsWith(GATE_FAILED_PREFIX)) return FAILED_VERDICT;
+  if (trimmed.startsWith(GATE_PASSED_PREFIX)) return PASSED_VERDICT;
+  if (trimmed.startsWith(GATE_UNVERIFIED_PREFIX)) return UNVERIFIED_VERDICT;
+  return void 0;
+}
+var josh_verdict = {
+  PASSED_VERDICT,
+  FAILED_VERDICT,
+  UNVERIFIED_VERDICT,
+  format_gate_passed,
+  format_gate_failed,
+  format_gate_unverified,
+  GATE_OPENING_MARK,
+  GATE_OPENING_PREFIX,
+  is_gate_opening,
+  read_verdict
+};
+
+// scripts/time-runtime/time-reported-failure.ts
+import { z as z3 } from "zod";
+var TEXT_BLOCK_SCHEMA = z3.object({ text: z3.string().nullish() });
+var CONTENT_SCHEMA2 = z3.union([z3.string(), z3.array(z3.unknown())]);
+var LINE_SEPARATOR2 = "\n";
+function block_text(block) {
+  const parsed = TEXT_BLOCK_SCHEMA.safeParse(block);
+  return parsed.success ? parsed.data.text ?? "" : "";
+}
+function result_text2(content) {
+  const parsed = CONTENT_SCHEMA2.safeParse(content);
+  if (!parsed.success) return "";
+  if (typeof parsed.data === "string") return parsed.data;
+  return parsed.data.map((block) => block_text(block)).join(LINE_SEPARATOR2);
+}
+function is_failure_line(line) {
+  return line.trimStart().startsWith(status_icons.FAIL_ICON);
+}
+function is_failed_verdict(line) {
+  return josh_verdict.read_verdict(line) === josh_verdict.FAILED_VERDICT;
+}
+var GREEN_VERDICTS = /* @__PURE__ */ new Set([
+  josh_verdict.PASSED_VERDICT,
+  josh_verdict.UNVERIFIED_VERDICT
+]);
+function is_green_verdict(line) {
+  return GREEN_VERDICTS.has(josh_verdict.read_verdict(line));
+}
+function new_scan() {
+  return {
+    did_find: false,
+    has_failure_before_region: false,
+    has_failure_in_region: false,
+    is_region_open: false
+  };
+}
+function close_region(scan) {
+  scan.did_find ||= scan.is_region_open && scan.has_failure_before_region;
+  scan.has_failure_before_region = false;
+  scan.has_failure_in_region = false;
+  scan.is_region_open = false;
+}
+function note_failure(scan) {
+  if (scan.is_region_open) {
+    scan.has_failure_in_region = true;
+    return;
+  }
+  scan.has_failure_before_region = true;
+}
+function scan_line(scan, line) {
+  if (is_green_verdict(line)) {
+    close_region(scan);
+    return;
+  }
+  if (is_failure_line(line)) {
+    note_failure(scan);
+    return;
+  }
+  if (josh_verdict.is_gate_opening(line)) scan.is_region_open = true;
+}
+function scan_body(lines) {
+  const scan = new_scan();
+  for (const line of lines) scan_line(scan, line);
+  return scan;
+}
+function did_scan_find(scan) {
+  return scan.did_find || scan.has_failure_before_region || scan.has_failure_in_region;
+}
+function has_failure_line(content) {
+  const lines = result_text2(content).split(LINE_SEPARATOR2);
+  if (lines.some((line) => is_failed_verdict(line))) return true;
+  return did_scan_find(scan_body(lines));
+}
+function is_reported_failure(josh_command, did_print_failure) {
+  return josh_command !== "" && did_print_failure;
+}
+var time_reported_failure = { result_text: result_text2, has_failure_line, is_reported_failure };
+
+// scripts/cost-runtime/cost-attribute.ts
+var ISSUE_BRANCH_PATTERN = /^(\d+)-/u;
+var UNATTRIBUTED_KEY = -1;
+function issue_from_branch(branch) {
+  const matched = ISSUE_BRANCH_PATTERN.exec(branch);
+  return matched?.[1] === void 0 ? UNATTRIBUTED_KEY : Number(matched[1]);
+}
+function declared_issue(record2) {
+  const declared = record2.issue ?? UNATTRIBUTED_KEY;
+  return declared === UNATTRIBUTED_KEY ? issue_from_branch(record2.branch) : declared;
+}
+function fill(declared, is_reverse) {
+  const filled = Array.from({ length: declared.length }, () => UNATTRIBUTED_KEY);
+  const order = declared.map((_value, index) => is_reverse ? declared.length - 1 - index : index);
+  let carried = UNATTRIBUTED_KEY;
+  for (const index of order) {
+    const own = declared[index] ?? UNATTRIBUTED_KEY;
+    carried = own === UNATTRIBUTED_KEY ? carried : own;
+    filled[index] = carried;
+  }
+  return filled;
+}
+function is_attributed(value) {
+  return value !== void 0 && value !== UNATTRIBUTED_KEY;
+}
+function pick(own, carried, next, previous) {
+  if (is_attributed(own)) return own;
+  if (is_attributed(carried)) return carried;
+  if (is_attributed(next)) return next;
+  return previous ?? UNATTRIBUTED_KEY;
+}
+function announcements(records) {
+  return fill(
+    records.map((record2) => record2.issue ?? UNATTRIBUTED_KEY),
+    false
+  );
+}
+function attribute(records) {
+  const declared = records.map((record2) => declared_issue(record2));
+  const carried = announcements(records);
+  const next = fill(declared, true);
+  const previous = fill(declared, false);
+  return declared.map(
+    (own, index) => pick(own, carried[index] ?? UNATTRIBUTED_KEY, next[index], previous[index])
+  );
+}
+function group_by_issue(records) {
+  const issues = attribute(records);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const [index, record2] of records.entries()) {
+    const bucket = grouped.get(issues[index] ?? UNATTRIBUTED_KEY) ?? [];
+    bucket.push(record2);
+    grouped.set(issues[index] ?? UNATTRIBUTED_KEY, bucket);
+  }
+  return [...grouped].toSorted(([left], [right]) => left - right).map(([issue, bucket]) => ({ issue, records: bucket }));
+}
+function records_for_issue(records, issue_number) {
+  const issues = attribute(records);
+  return records.filter((_record, index) => issues[index] === issue_number);
+}
+var cost_attribute = {
+  UNATTRIBUTED_KEY,
+  issue_from_branch,
+  declared_issue,
+  attribute,
+  group_by_issue,
+  records_for_issue
+};
+
+// scripts/time-runtime/time-markers.ts
+var NO_MARKER = "none";
+var PLAN_MARKER = "plan";
+var EDIT_MARKER = "edit";
+var REVIEW_MARKER = "review";
+var WORKFLOW_MARKER = "workflow";
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+var SKILL_TOOL = "Skill";
+var SKILL_KEY = "skill";
+var REVIEW_SKILL = "code-review";
+var WORKFLOW_SKILL = "workflow-commands";
+var AGENT_TOOL = "Agent";
+var PROMPT_KEY = "prompt";
+var REVIEW_INVOCATION = "/code-review";
+var REVIEW_ATTEST = "review:attest";
+var SKILL_MARKERS = /* @__PURE__ */ new Map([
+  [REVIEW_SKILL, REVIEW_MARKER],
+  [WORKFLOW_SKILL, WORKFLOW_MARKER]
+]);
+var ISSUE_API_PATTERN = /repos\/\S+\/issues\/\d+/u;
+var BODY_FIELD_PATTERN = /\bbody=/u;
+var ISSUE_COMMENT_PATTERN = /\bgh\s+issue\s+comment\b/u;
+var BODY_FLAG_PATTERN = /--body(?:-file)?\b/u;
+var ISSUE_PLAN_PATTERN = /(?:^|[;&|]\s*)pnpm\s+josh\s+issue:plan\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 "";
+  const value = input[key];
+  return typeof value === "string" ? value : "";
+}
+function skill_name(input) {
+  return string_field(input, SKILL_KEY);
+}
+function agent_marker(input) {
+  const prompt = string_field(input, PROMPT_KEY);
+  const is_review = prompt.includes(REVIEW_INVOCATION) && prompt.includes(REVIEW_ATTEST);
+  return is_review ? REVIEW_MARKER : NO_MARKER;
+}
+function tool_marker(name, input) {
+  if (EDIT_TOOLS.has(name)) return EDIT_MARKER;
+  if (name === AGENT_TOOL) return agent_marker(input);
+  if (name !== SKILL_TOOL) return NO_MARKER;
+  return SKILL_MARKERS.get(skill_name(input)) ?? NO_MARKER;
+}
+function is_api_body_write(command) {
+  return ISSUE_API_PATTERN.test(command) && BODY_FIELD_PATTERN.test(command);
+}
+function is_issue_comment(command) {
+  return ISSUE_COMMENT_PATTERN.test(command) && BODY_FLAG_PATTERN.test(command);
+}
+function is_plan_write(command) {
+  return is_api_body_write(command) || is_issue_comment(command) || ISSUE_PLAN_PATTERN.test(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 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_run_start(part)) return declared_issue2(part);
+  }
+  return NO_ISSUE;
+}
+function bash_marker(command) {
+  if (is_run_start(command)) return WORKFLOW_MARKER;
+  return is_plan_write(command) ? PLAN_MARKER : NO_MARKER;
+}
+var time_markers = {
+  NO_MARKER,
+  PLAN_MARKER,
+  EDIT_MARKER,
+  REVIEW_MARKER,
+  WORKFLOW_MARKER,
+  NO_ISSUE,
+  tool_marker,
+  bash_marker,
+  bash_issue
+};
+
+// scripts/time-runtime/time-single-check.ts
+var CHECK_COMMANDS = /* @__PURE__ */ new Set([
+  "josh check",
+  "josh cspell",
+  "josh cspell:dot",
+  "josh lint",
+  "josh lint:related",
+  "josh test:related",
+  "josh test:unit"
+]);
+var NO_CHECK = "";
+var KEY_SEPARATOR = " ";
+function argument_key(command) {
+  return [...new Set(time_shell.josh_arguments(command))].toSorted(
+    (left, right) => left.localeCompare(right)
+  );
+}
+function check_key(josh_command, command) {
+  if (!CHECK_COMMANDS.has(josh_command)) return NO_CHECK;
+  return [josh_command, ...argument_key(command)].join(KEY_SEPARATOR);
+}
+var time_single_check = { NO_CHECK, check_key };
+
+// scripts/time-runtime/time-transcript-line.ts
+var UNKNOWN_BRANCH = "";
+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 STOP_FEEDBACK_LABEL = /^Stop hook feedback:\s*/u;
+var TOKEN_LINE = /^[a-z][a-z-]*$/u;
+var TOKEN_LINE_LIMIT = 8;
+function block_names(raw) {
+  return {
+    type: raw.type ?? "",
+    name: raw.name ?? "",
+    id: raw.id ?? "",
+    result_id: raw.tool_use_id ?? ""
+  };
+}
+function refusal_body(text) {
+  return text.trimStart().replace(HOOK_ERROR_LABEL, "");
+}
+function guard_from_refusal(text) {
+  const trimmed = refusal_body(text);
+  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 stop_feedback_of(data) {
+  const content = data.message?.content;
+  if (typeof content !== "string" || !STOP_FEEDBACK_LABEL.test(content)) return "";
+  return content.replace(STOP_FEEDBACK_LABEL, "").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;
+  return {
+    ...block_names(raw),
+    input: raw.input,
+    is_error,
+    has_failure_line: time_reported_failure.has_failure_line(text),
+    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)
+  };
+}
+function to_blocks2(content) {
+  return typeof content === "string" || content === null || content === void 0 ? [] : content.map((block) => to_block2(block));
+}
+function message_fields(message) {
+  return { message_id: message?.id ?? NO_MESSAGE_ID, blocks: to_blocks2(message?.content) };
+}
+function notice_text(data) {
+  const attachment = json_value.is_record(data.attachment) ? data.attachment[PROMPT_KEY2] : void 0;
+  const carried = [data.message?.content, data.content, attachment];
+  return carried.find((one) => typeof one === "string") ?? "";
+}
+function stopped_background(content) {
+  if (!Array.isArray(content)) return time_background.NO_BACKGROUND;
+  const ids = content.map(
+    (block) => typeof block.content === "string" ? time_background.stopped_id(block.content) : ""
+  );
+  return ids.find((id) => id !== time_background.NO_BACKGROUND) ?? time_background.NO_BACKGROUND;
+}
+function finished_background(data) {
+  const notice = time_background.finished_id(notice_text(data));
+  return notice === time_background.NO_BACKGROUND ? stopped_background(data.message?.content) : notice;
+}
+function to_line(data) {
+  const timestamp_ms = time_instant.parse_instant(data.timestamp);
+  if (timestamp_ms === void 0) return void 0;
+  const stop_feedback = stop_feedback_of(data);
+  return {
+    type: data.type ?? "",
+    timestamp_ms,
+    branch: data.gitBranch ?? UNKNOWN_BRANCH,
+    finished_background: finished_background(data),
+    stop_feedback,
+    stop_guard: guard_from_refusal(stop_feedback),
+    ...message_fields(data.message)
+  };
+}
+function parse_line2(line) {
+  const record2 = transcript_record.parse(line);
+  return record2 === void 0 ? void 0 : to_line(record2);
+}
+function parse_text(text) {
+  return text.split("\n").flatMap((line) => parse_line2(line) ?? []);
+}
+var time_transcript_line = {
+  ERROR_TEXT_LIMIT,
+  NO_MESSAGE_ID,
+  TOKEN_LINE_LIMIT,
+  guard_from_refusal,
+  parse_line: parse_line2,
+  parse_text,
+  refusal_body
+};
+
+// scripts/time-runtime/time-writes.ts
+function bash_writes(command) {
+  const segment = time_bundle_call.write_segment(command);
+  return time_bundle_call.is_in_place_sed(segment) ? time_bundle_call.targets_in(segment) : [];
+}
+function tool_writes(name, input) {
+  if (time_markers.tool_marker(name, input) !== time_markers.EDIT_MARKER) return [];
+  return time_bundle_call.tool_targets(input);
+}
+var time_writes = {
+  bash_writes,
+  tool_writes
+};
+
+// scripts/time-runtime/time-tool-call.ts
+var { NO_MESSAGE_ID: NO_MESSAGE_ID2 } = time_transcript_line;
+var UNKNOWN_TOOL = "unknown";
+var NO_CALL = {
+  label: "",
+  josh_command: "",
+  josh_commands: [],
+  josh_signatures: [],
+  check_key: time_single_check.NO_CHECK,
+  marker: time_markers.NO_MARKER,
+  message_id: NO_MESSAGE_ID2,
+  writes: [],
+  issue: time_markers.NO_ISSUE,
+  reads_background: time_background.NO_BACKGROUND,
+  ...time_bundle_call.not_bundleable()
+};
+var UNKNOWN_CALL = {
+  label: UNKNOWN_TOOL,
+  josh_command: "",
+  josh_commands: [],
+  josh_signatures: [],
+  check_key: time_single_check.NO_CHECK,
+  marker: time_markers.NO_MARKER,
+  message_id: NO_MESSAGE_ID2,
+  writes: [],
+  issue: time_markers.NO_ISSUE,
+  reads_background: time_background.NO_BACKGROUND,
+  ...time_bundle_call.not_bundleable()
+};
+function non_bash_call(name, input, message_id) {
+  return {
+    label: name,
+    josh_command: "",
+    josh_commands: [],
+    josh_signatures: [],
+    check_key: time_single_check.NO_CHECK,
+    marker: time_markers.tool_marker(name, input),
+    message_id,
+    writes: time_writes.tool_writes(name, input),
+    issue: time_markers.NO_ISSUE,
+    // A non-Bash tool joins a backgrounded command too — `BashOutput` carries the shell id in a
+    // field of its own, `Monitor` names the same `…/tasks/<id>.output` path in a command — so the
+    // same reader is asked here rather than the field being left empty for every tool but `Bash`.
+    reads_background: time_background.read_id_of(input),
+    ...time_bundle_call.tool_facts(name, input)
+  };
+}
+function bash_call(input, message_id) {
+  const command = time_shell.bash_command(input);
+  const josh_command = time_shell.josh_command_of(command);
+  return {
+    label: time_shell.bash_label(command),
+    josh_command,
+    josh_commands: time_shell.josh_commands_of(command),
+    josh_signatures: time_shell.josh_signatures_of(command),
+    check_key: time_single_check.check_key(josh_command, command),
+    marker: time_markers.bash_marker(command),
+    message_id,
+    writes: time_writes.bash_writes(command),
+    issue: time_markers.bash_issue(command),
+    reads_background: time_background.read_id_of(input),
+    ...time_bundle_call.bash_facts(command)
+  };
+}
+function to_tool_call(name, input, message_id) {
+  if (name !== cost_blocks.BASH_TOOL) return non_bash_call(name, input, message_id);
+  return bash_call(input, message_id);
+}
+var time_tool_call = {
+  UNKNOWN_TOOL,
+  NO_CALL,
+  UNKNOWN_CALL,
+  to_tool_call
+};
+
+// scripts/time-runtime/time-spans.ts
+var { NO_MESSAGE_ID: NO_MESSAGE_ID3, parse_line: parse_line3 } = time_transcript_line;
+var { NO_CALL: NO_CALL2, UNKNOWN_CALL: UNKNOWN_CALL2, UNKNOWN_TOOL: UNKNOWN_TOOL2, to_tool_call: to_tool_call2 } = time_tool_call;
+var ASSISTANT_TYPE = "assistant";
+var USER_TYPE = "user";
+var MODEL_CATEGORY = "model";
+var TOOL_CATEGORY = "tool";
+var HUMAN_CATEGORY = "human";
+var OK_OUTCOME = "ok";
+var FAILED_OUTCOME = "failed";
+var UNKNOWN_OUTCOME = "unknown";
+var NO_RESULT = {
+  call_id: "",
+  outcome: UNKNOWN_OUTCOME,
+  refusal_guard: "",
+  background_id: time_background.NO_BACKGROUND,
+  followup_stages: time_followup_stage.NO_STAGES
+};
+function tool_use_blocks(lines) {
+  return lines.flatMap(
+    (line) => line.blocks.filter((block) => block.type === cost_blocks.TOOL_USE_TYPE && block.id !== "").map((block) => ({ block, message_id: line.message_id }))
+  );
+}
+function collect_calls(lines) {
+  return new Map(
+    tool_use_blocks(lines).map(({ block, message_id }) => [
+      block.id,
+      to_tool_call2(block.name, block.input, message_id)
+    ])
+  );
+}
+function result_block(line) {
+  return line.blocks.find((block) => block.type === cost_blocks.TOOL_RESULT_TYPE);
+}
+function event_of(line, category, call, result = NO_RESULT) {
+  return { timestamp_ms: line.timestamp_ms, branch: line.branch, category, ...result, ...call };
+}
+function outcome_of(result, call) {
+  if (time_reported_failure.is_reported_failure(call.josh_command, result.has_failure_line)) {
+    return FAILED_OUTCOME;
+  }
+  if (result.is_error === void 0) return UNKNOWN_OUTCOME;
+  return result.is_error ? FAILED_OUTCOME : OK_OUTCOME;
+}
+function facts_of(result, call) {
+  return {
+    call_id: result.result_id,
+    outcome: outcome_of(result, call),
+    refusal_guard: result.refusal_guard,
+    background_id: result.background_id,
+    followup_stages: result.followup_stages
+  };
+}
+function user_event(line, calls) {
+  const result = result_block(line);
+  if (result === void 0) return event_of(line, HUMAN_CATEGORY, NO_CALL2);
+  const call = calls.get(result.result_id) ?? UNKNOWN_CALL2;
+  return event_of(line, TOOL_CATEGORY, call, facts_of(result, call));
+}
+function to_event(line, calls) {
+  if (line.type === ASSISTANT_TYPE) {
+    return event_of(line, MODEL_CATEGORY, { ...NO_CALL2, message_id: line.message_id });
+  }
+  return line.type === USER_TYPE ? user_event(line, calls) : void 0;
+}
+function to_events(lines, calls) {
+  return lines.map((line) => to_event(line, calls)).filter((event) => event !== void 0).toSorted((left, right) => left.timestamp_ms - right.timestamp_ms);
+}
+function equal_durations(duration_ms) {
+  return { duration_ms, own_duration_ms: duration_ms };
+}
+function no_background() {
+  const none = time_background.NO_BACKGROUND;
+  return {
+    background_id: none,
+    reads_background: none,
+    background_command: none,
+    background_ended_ms: time_background.NO_FINISH
+  };
+}
+function background_fields(event, finished) {
+  return {
+    background_id: event.background_id,
+    reads_background: event.reads_background,
+    background_command: time_background.NO_BACKGROUND,
+    background_ended_ms: finished.get(event.background_id) ?? time_background.NO_FINISH
+  };
+}
+function result_facts_of(event) {
+  return {
+    call_id: event.call_id,
+    outcome: event.outcome,
+    refusal_guard: event.refusal_guard,
+    followup_stages: event.followup_stages
+  };
+}
+function to_spans(events, finished) {
+  return events.slice(1).map((event, index) => ({
+    category: event.category,
+    label: event.label,
+    josh_command: event.josh_command,
+    josh_commands: event.josh_commands,
+    josh_signatures: event.josh_signatures,
+    check_key: event.check_key,
+    marker: event.marker,
+    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,
+    issue: event.issue,
+    branch: event.branch,
+    ...result_facts_of(event),
+    is_continuation: false,
+    ...background_fields(event, finished),
+    ended_ms: event.timestamp_ms,
+    ...equal_durations(event.timestamp_ms - (events[index]?.timestamp_ms ?? event.timestamp_ms))
+  }));
+}
+function parse_timeline(text) {
+  const lines = text.split("\n").map((line) => parse_line3(line)).filter((line) => line !== void 0);
+  const events = to_events(lines, collect_calls(lines));
+  return {
+    started_ms: events[0]?.timestamp_ms ?? 0,
+    ended_ms: events.at(-1)?.timestamp_ms ?? 0,
+    // **The positioning happens here rather than in a caller**: a launch and
+    // the call that reads its output are in one transcript, and by the time spans have been merged
+    // across sessions and trimmed they are fragments rather than calls.
+    spans: time_background.positioned(to_spans(events, time_background.finished_at(lines)))
+  };
+}
+function has_transcript_data(span_count) {
+  return span_count > 0;
+}
+var time_spans = {
+  ASSISTANT_TYPE,
+  MODEL_CATEGORY,
+  TOOL_CATEGORY,
+  HUMAN_CATEGORY,
+  OK_OUTCOME,
+  FAILED_OUTCOME,
+  UNKNOWN_OUTCOME,
+  NO_MESSAGE_ID: NO_MESSAGE_ID3,
+  UNKNOWN_TOOL: UNKNOWN_TOOL2,
+  has_transcript_data,
+  equal_durations,
+  no_background,
+  // Re-exported so the suites that measure how a command is read keep asking one namespace, and so
+  // `time-shell.ts` moving out of this file changed no call site.
+  bash_label: time_shell.bash_label,
+  josh_command_of: time_shell.josh_command_of,
+  josh_commands_of: time_shell.josh_commands_of,
+  to_tool_call: to_tool_call2,
+  parse_line: parse_line3,
+  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 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 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 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,
+  // Exported so callers price a round trip with the same divisor and guard rather than a private
+  // copy — the clone `CLAUDE.md` prohibits.
+  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_SEPARATOR3 = "/";
+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,
+  single_call: { independent_round_trips: 0, dependent_round_trips: 0, by_tool: [] },
+  is_measured: false
+};
+function contains_segments(whole, part) {
+  if (whole.startsWith(`${part}${PATH_SEPARATOR3}`)) return true;
+  return whole.endsWith(`${PATH_SEPARATOR3}${part}`) || whole.includes(`${PATH_SEPARATOR3}${part}${PATH_SEPARATOR3}`);
+}
+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: [], dependent: NONE3 };
+}
+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)) {
+    walk.dependent += ONE_CALL;
+    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 tally = tally_for(tallies, label);
+  tally.recoverable_round_trips += ONE_CALL;
+  if (!counted.has(label)) tally.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, tally]) => ({ label, ...tally })).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 single_call_split(walk, sizes) {
+  return {
+    independent_round_trips: recoverable_of(sizes),
+    dependent_round_trips: walk.dependent,
+    by_tool: tool_rows(walk.closed)
+  };
+}
+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 single_call = single_call_split(walk, sizes);
+  const by_tool = with_agent_row(single_call.by_tool, agent_sizes);
+  const recoverable_round_trips = single_call.independent_round_trips + 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),
+    single_call,
+    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 = figure_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,
+  by_weight,
+  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-search-call.ts
+var SEARCH_COMMANDS = ["fd", "find", "grep", "rg"];
+var SEARCH_LABELS = new Set(
+  SEARCH_COMMANDS.map((command) => time_shell.bash_label(command))
+);
+var CHAIN_COMMANDS = [...SEARCH_COMMANDS, "sed"];
+var CHAIN_LABELS = new Set(
+  CHAIN_COMMANDS.map((command) => time_shell.bash_label(command))
+);
+function is_read_only_search(call) {
+  return SEARCH_LABELS.has(call.label) && call.is_bundleable && !call.may_write;
+}
+function is_search_chain_call(call) {
+  return CHAIN_LABELS.has(call.label) && call.is_bundleable && !call.is_writing;
+}
+var time_search_call = {
+  is_read_only_search,
+  is_search_chain_call
+};
+
+// 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 RULE_POINTER = "`prompts/collaboration-workflow/turn-batching.md`";
+var STREAK = `${String(CONSECUTIVE_LIMIT)} single-call turns in a row`;
+var REASON = `\u26D4 batching: ${STREAK}. Reissue this with the calls that do not need its result \u2014 the test is whether a call's input needs another call's result, not what kind of call it is (edits are covered exactly as reads); it never authorizes weakening a verification gate or a review. Nothing to pair? Reissue it unchanged. ${RULE_POINTER}`;
+var NOTICE = `\u{1F4A1} batching: ${STREAK}; the Write proceeds. Issue the writes that do not need its result in one turn, never by weakening a gate or a review. ${RULE_POINTER}`;
+var LANE_NOTICE = `\u{1F4A1} batching: ${STREAK}; the call proceeds. Pair independent calls. ${RULE_POINTER}`;
+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 refusable_spans(text, call) {
+  if (!is_guarded_call(call)) return [];
+  const { spans } = time_spans.parse_timeline(text);
+  return is_reissued_refusal(spans, call) ? [] : spans;
+}
+function should_block(text, call, refused_at_ms, refire_every = REFIRE_EVERY) {
+  return is_at_limit(refusable_spans(text, call), call, refused_at_ms, refire_every);
+}
+function as_tool_call(call) {
+  return time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID);
+}
+function is_search_chain_call2(call) {
+  return is_guarded_call(call) && time_search_call.is_search_chain_call(as_tool_call(call));
+}
+function is_search_chain(spans, call) {
+  const recent = time_bundles.open_sequence(spans).slice(-SEQUENCE_BEFORE_LIMIT);
+  return [...recent, as_tool_call(call)].every(
+    (turn) => time_search_call.is_search_chain_call(turn)
+  );
+}
+function should_block_search_chain(text, call, refused_at_ms) {
+  const spans = refusable_spans(text, call);
+  return is_search_chain(spans, call) && 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((path3) => path3 !== "" && time_bundle_call.has_extension(path3));
+  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((path3) => path3 !== "" && time_bundle_call.has_extension(path3));
+  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,
+  is_search_chain_call: is_search_chain_call2,
+  pairing_candidates,
+  recent_candidates,
+  should_block,
+  should_block_search_chain,
+  should_notify
+};
+
+// scripts/time-runtime/time-density.ts
+var MIN_ROUND_TRIPS = 10;
+var NOTICE_INTERVAL_MS = 3e5;
+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;
+}
+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 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 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) {
+  const { spans } = time_spans.parse_timeline(text);
+  const round_trip_count = time_round_trips.count_round_trips(spans);
+  const call_count = time_round_trips.count_calls(spans);
+  return {
+    density: time_round_trips.per_round_trip(call_count, round_trip_count),
+    round_trip_count,
+    turn_calls: last_turn_calls(text)
+  };
+}
+function is_due(reading, since_last_ms) {
+  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, 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.${candidates}`;
+}
+var time_density = {
+  MIN_ROUND_TRIPS,
+  NOTICE_INTERVAL_MS,
+  format_notice,
+  is_due,
+  last_turn_calls,
+  read_window
+};
+
+// scripts/time-runtime/time-density-hook.ts
+var TAIL_BYTES = 262144;
+var FILE_START = 0;
+var NOTICE_PREFIX = "josh-density-notice-";
+var NEVER_MS = 0;
+var payload_schema = z4.object({
+  transcript_path: z4.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: z4.string().nullish()
+});
+var notice_schema = z4.object({ notified_at_ms: z4.number() });
+var call_schema = z4.object({ tool_name: z4.string().min(1), tool_input: z4.unknown() });
+function parse_transcript_path(raw_payload) {
+  const payload = json_value.parse_with(raw_payload, payload_schema);
+  if (payload?.transcript_path === void 0) return void 0;
+  return time_hook_transcript.transcript_of(payload.transcript_path, payload.agent_id);
+}
+function parse_call(raw_payload) {
+  const call = json_value.parse_with(raw_payload, call_schema);
+  if (call === void 0) return void 0;
+  return { name: call.tool_name, input: call.tool_input };
+}
+function read_tail(file_path, max_bytes = TAIL_BYTES) {
+  const descriptor = openSync(file_path, "r");
+  try {
+    const { size } = fstatSync(descriptor);
+    const length = Math.min(size, max_bytes);
+    const buffer = Buffer.alloc(length);
+    const read2 = readSync(descriptor, buffer, FILE_START, length, size - length);
+    return buffer.subarray(FILE_START, read2).toString("utf8");
+  } finally {
+    closeSync(descriptor);
+  }
+}
+function notice_path(transcript_path) {
+  return stamp_file.stamp_path(NOTICE_PREFIX, transcript_path);
+}
+function last_notice_ms(source) {
+  const raw = stamp_file.read_stamp_text(source);
+  if (raw === void 0) return NEVER_MS;
+  return json_value.parse_with(raw, notice_schema)?.notified_at_ms ?? NEVER_MS;
+}
+function arm_throttle(target, now_ms) {
+  try {
+    stamp_file.write_stamp(target, { notified_at_ms: now_ms });
+  } catch {
+  }
+}
+function notice_for(raw_payload, now_ms) {
+  const transcript_path = parse_transcript_path(raw_payload);
+  if (transcript_path === void 0) return void 0;
+  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, candidates);
+}
+function density_notice(raw_payload, now_ms = Date.now()) {
+  try {
+    return notice_for(raw_payload, now_ms);
+  } catch {
+    return void 0;
+  }
+}
+var time_density_hook = {
+  density_notice,
+  notice_path,
+  parse_call,
+  parse_transcript_path,
+  read_tail
+};
+
+// scripts/build/local-bin.ts
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path2 from "node:path";
+
+// scripts/lib/schemas.ts
+import { z as z5 } from "zod";
+var overrides_snapshot_schema = z5.record(z5.string(), z5.string());
+var package_version_schema = z5.object({ version: z5.string() });
+var package_named_version_schema = z5.looseObject({ name: z5.string(), version: z5.string() });
+var package_with_version_schema = z5.looseObject({ version: z5.string() });
+var ls_global_dependency_schema = z5.looseObject({ version: z5.string() });
+var ls_global_dependencies_schema = z5.record(z5.string(), ls_global_dependency_schema).optional();
+var pnpm_ls_global_schema = z5.array(
+  z5.looseObject({
+    dependencies: ls_global_dependencies_schema
+  })
+);
+var vscode_settings_schema = z5.record(z5.string(), z5.unknown());
+var with_scripts_schema = z5.looseObject({
+  scripts: z5.record(z5.string(), z5.string()).optional()
+});
+var with_development_deps_schema = z5.looseObject({
+  devDependencies: z5.record(z5.string(), z5.string()).optional()
+});
+var with_package_manager_schema = z5.looseObject({
+  packageManager: z5.string().optional()
+});
+var with_development_engine_schema = z5.looseObject({
+  devEngines: z5.record(z5.string(), z5.unknown()).optional()
+});
+var bin_entry_schema = z5.union([z5.string(), z5.record(z5.string(), z5.string())]).optional();
+var package_bin_schema = z5.looseObject({ bin: bin_entry_schema });
+var json_object_schema = z5.record(z5.string(), z5.unknown());
+var string_array_schema = z5.array(z5.string());
+var string_record_schema = z5.record(z5.string(), z5.string());
+
+// scripts/build/local-bin.ts
+var NODE_MODULES = "node_modules";
+var BIN_DIR = ".bin";
+var WINDOWS_PLATFORM = "win32";
+var WINDOWS_SHIM_SUFFIX = ".cmd";
+function resolve_local_bin(project_root, bin_name) {
+  const shim = process.platform === WINDOWS_PLATFORM ? `${bin_name}${WINDOWS_SHIM_SUFFIX}` : bin_name;
+  return path2.join(project_root, NODE_MODULES, BIN_DIR, shim);
+}
+function find_local_bin_upwards(start_directory, bin_name) {
+  return ancestor_directories.list(start_directory).map((directory) => resolve_local_bin(directory, bin_name)).find((candidate) => existsSync(candidate));
+}
+function read_bin_entry(manifest_path, package_name, bin_name) {
+  const { bin } = package_bin_schema.parse(JSON.parse(readFileSync(manifest_path, "utf8")));
+  if (typeof bin === "string") return bin_name === path2.basename(package_name) ? bin : void 0;
+  return bin?.[bin_name];
+}
+function resolve_package_bin(base_directory, package_name, bin_name) {
+  try {
+    const resolve_from = createRequire(path2.join(base_directory, PACKAGE_JSON));
+    const manifest_path = resolve_from.resolve(`${package_name}/${PACKAGE_JSON}`);
+    const bin_entry = read_bin_entry(manifest_path, package_name, bin_name);
+    if (bin_entry === void 0) return void 0;
+    const cli_entry = path2.join(path2.dirname(manifest_path), bin_entry);
+    return existsSync(cli_entry) ? cli_entry : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  transcript_record,
+  cost_blocks,
+  time_shell,
+  time_bundle_call,
+  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,
+  time_reported_failure,
+  cost_attribute,
+  time_markers,
+  time_transcript_line,
+  time_spans,
+  time_search_call,
+  time_batch_guard,
+  time_hook_transcript,
+  time_density_hook,
+  vscode_settings_schema,
+  json_object_schema,
+  string_array_schema,
+  string_record_schema,
+  resolve_local_bin,
+  find_local_bin_upwards,
+  resolve_package_bin
+};