@joshuafolkken/kit 1.2116.0 → 1.3000.0

package/dist/commands/chunk-KVSSLDA3.js

@@ -0,0 +1,1062 @@
+import {
+  cost_attribute
+} from "./chunk-6CJXLPRI.js";
+import {
+  time_background,
+  time_followup_stage,
+  time_reported_failure,
+  time_transcript_line
+} from "./chunk-GPMSYXYO.js";
+import {
+  time_format
+} from "./chunk-6NV2F7QH.js";
+import {
+  cost_blocks,
+  time_josh_names,
+  time_shell
+} from "./chunk-LHKXJD6L.js";
+import {
+  canonical_command
+} from "./chunk-ROJXMBXP.js";
+import {
+  figure_format
+} from "./chunk-5Y7QQYTU.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/time-runtime/time-bundle-call.ts
+var { BASH_TOOL } = 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_PATTERN = /\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_PREFIX = "-";
+var PATH_SEPARATOR = "/";
+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_PATTERN).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_SEPARATOR) ? 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_PREFIX) || word.length < MIN_TARGET_LENGTH) return false;
+  return word.includes(PATH_SEPARATOR) || 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_TOOL) 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-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_issue(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_issue(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-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 } = 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_ID,
+  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_ID,
+  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_josh_names.josh_command_of(command);
+  return {
+    label: time_shell.bash_label(command),
+    josh_command,
+    josh_commands: time_josh_names.josh_commands_of(command),
+    josh_signatures: time_josh_names.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_ID2, parse_line } = 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_line(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_ID2,
+  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_josh_names.josh_command_of,
+  josh_commands_of: time_josh_names.josh_commands_of,
+  to_tool_call: to_tool_call2,
+  parse_line,
+  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_ms(span) {
+  return span.ended_ms - span.duration_ms;
+}
+function in_time_order(spans) {
+  return spans.toSorted((left, right) => started_ms(left) - started_ms(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_launch(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_launch(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 } = time_format;
+var HEADING = "Bundling:";
+var SEQUENCE_LABEL = "bundleable sequences";
+var RECOVERABLE_LABEL = "recoverable round trips";
+var SAVING_LABEL = "recoverable wait";
+var BY_TOOL_LABEL = "recoverable by tool";
+var AGENT_ROW_LABEL = "Agent";
+var ROW_INDENT = "  ";
+var MIN_SEQUENCE = 2;
+var ONE_CALL = 1;
+var NONE3 = 0;
+var PATH_SEPARATOR2 = "/";
+var FIRST_CALL = 1;
+var NO_LABEL = "";
+var NO_BUNDLES = {
+  sequence_count: 0,
+  longest_sequence: 0,
+  recoverable_round_trips: 0,
+  by_tool: [],
+  unattributed_round_trips: 0,
+  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_SEPARATOR2}`)) return true;
+  return whole.endsWith(`${PATH_SEPARATOR2}${part}`) || whole.includes(`${PATH_SEPARATOR2}${part}${PATH_SEPARATOR2}`);
+}
+function is_related(left, right) {
+  if (left === right) return true;
+  return contains_segments(left, right) || contains_segments(right, left);
+}
+function shares_target(left, right) {
+  return left.some((one) => right.some((other) => is_related(one, other)));
+}
+function is_dependent(earlier, later) {
+  if (earlier.is_writing && later.is_writing) return false;
+  return shares_target(earlier.targets, later.targets);
+}
+function conflicts(span, sequence) {
+  return sequence.some((earlier) => is_dependent(earlier, span));
+}
+function is_call2(span) {
+  return span.category === time_spans.TOOL_CATEGORY && !span.is_continuation;
+}
+function is_turn_boundary(span) {
+  return span.category === time_spans.MODEL_CATEGORY;
+}
+function new_walk2() {
+  return { pending: [], sequence: [], closed: [], 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_row(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
+};
+
+export {
+  time_bundle_call,
+  time_markers,
+  time_spans,
+  time_round_trips,
+  time_bundles
+};