@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-7HAGC6SW.js

@@ -1,1062 +0,0 @@
-import {
-  cost_attribute
-} from "./chunk-6CJXLPRI.js";
-import {
-  time_background,
-  time_followup_stage,
-  time_reported_failure,
-  time_transcript_line
-} from "./chunk-OJ65BZBV.js";
-import {
-  cost_blocks,
-  time_josh_names,
-  time_shell
-} from "./chunk-LHKXJD6L.js";
-import {
-  canonical_command
-} from "./chunk-ROJXMBXP.js";
-import {
-  time_format
-} from "./chunk-5RG4S66L.js";
-import {
-  figure_format
-} from "./chunk-ZZXO6TFH.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
-};