@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-F2VYWU6Z.js

@@ -0,0 +1,653 @@
+import {
+  run_cut_report
+} from "./chunk-ZHSNQ2F7.js";
+import {
+  implementation_cut
+} from "./chunk-ZEH2B3DF.js";
+import {
+  tail_commands
+} from "./chunk-77LEKVEE.js";
+import {
+  cost_pricing
+} from "./chunk-5PLJ7R3D.js";
+import {
+  git_branch
+} from "./chunk-YEQFAEVW.js";
+import {
+  backlog_budget
+} from "./chunk-BYSPYVLD.js";
+import {
+  figure_format
+} from "./chunk-7EAYFMDN.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  cost_transcript,
+  cost_usage
+} from "./chunk-DDZVMXZD.js";
+import {
+  issue_number_shape,
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+
+// tools/cost/cost-run-tree.ts
+import path from "node:path";
+
+// tools/cost/cost-run-cut.ts
+var { CUT_VERDICT, RESUME_VERDICT } = run_cut_report;
+function took_cut_text(text) {
+  return tail_commands.answered(text, implementation_cut.takes_the_impl_cut, CUT_VERDICT);
+}
+function is_ship_text(text) {
+  return tail_commands.answered(text, implementation_cut.resumes_a_cut, RESUME_VERDICT);
+}
+function lane_marks(file) {
+  const text = cost_transcript.read_raw(file);
+  return { took_cut: took_cut_text(text), is_ship: is_ship_text(text) };
+}
+var cost_run_cut = { is_ship_text, lane_marks, took_cut_text };
+
+// tools/cost/cost-run-nodes.ts
+var PARENT_DEPTH = 0;
+var LANE_DEPTH = 1;
+var FIRST = 0;
+function branch_issue(records) {
+  for (const record of records) {
+    const issue = git_branch.issue_from_branch(record.branch);
+    if (issue !== void 0) return issue;
+  }
+  return void 0;
+}
+function started_ms(records) {
+  const stamps = records.map((record) => record.at_ms).filter((ms) => ms !== void 0);
+  return stamps.length === FIRST ? Infinity : Math.min(...stamps);
+}
+function bucket_of(file, context) {
+  if (file.is_delegated) return "subs";
+  if (context.lane_issue(file) === void 0) return "mains";
+  return "lanes";
+}
+function split_files(files, context) {
+  const split = { mains: [], lanes: [], subs: [] };
+  for (const file of files) split[bucket_of(file, context)].push(file);
+  return split;
+}
+function order_mains(mains, context) {
+  return [...mains].toSorted(
+    (left, right) => started_ms(context.facts(left.session_id).records) - started_ms(context.facts(right.session_id).records)
+  );
+}
+function to_node(file, role, head, facts) {
+  return {
+    session_id: file.session_id,
+    role,
+    modified_ms: file.modified_ms,
+    records: facts.records,
+    baseline_tokens: facts.baseline_tokens,
+    is_readable: facts.is_readable,
+    took_cut: false,
+    is_ship: false,
+    ...head
+  };
+}
+function main_node(file, is_parent, root_id, context) {
+  return to_node(
+    file,
+    is_parent ? "parent" : "wake",
+    { issue: void 0, parent_id: is_parent ? void 0 : root_id, depth: PARENT_DEPTH },
+    context.facts(file.session_id)
+  );
+}
+function lane_node(file, root_id, context) {
+  const facts = context.facts(file.session_id);
+  const node = to_node(
+    file,
+    "lane",
+    {
+      issue: context.lane_issue(file) ?? branch_issue(facts.records),
+      parent_id: root_id,
+      depth: LANE_DEPTH
+    },
+    facts
+  );
+  return { ...node, ...context.lane_marks(file) };
+}
+function sub_node(file, lane_roots, context) {
+  const facts = context.facts(file.session_id);
+  const base = lane_roots.has(cost_transcript.owning_session_id(file)) ? LANE_DEPTH : PARENT_DEPTH;
+  return to_node(
+    file,
+    "subagent",
+    {
+      issue: branch_issue(facts.records),
+      parent_id: cost_transcript.parent_session_id(file),
+      depth: base + file.depth
+    },
+    facts
+  );
+}
+function build_nodes(files, context) {
+  const split = split_files(files, context);
+  const mains = order_mains(split.mains, context);
+  const root_id = mains[FIRST]?.session_id;
+  const lane_roots = new Set(split.lanes.map((file) => file.session_id));
+  return [
+    ...mains.map(
+      (file, index) => main_node(file, index === FIRST, root_id ?? file.session_id, context)
+    ),
+    ...split.lanes.map((file) => lane_node(file, root_id, context)),
+    ...split.subs.map((file) => sub_node(file, lane_roots, context))
+  ];
+}
+var cost_run_nodes = {
+  issue_from_branch: git_branch.issue_from_branch,
+  started_ms,
+  split_files,
+  order_mains,
+  build_nodes
+};
+
+// tools/cost/cost-run-tree.ts
+var RUN_GAP_MS = backlog_budget.DEFAULT_IDLE_MS + backlog_budget.OFFER_INTERVAL_MS;
+var FIRST2 = 0;
+var NONE = -1;
+function cluster_end(cluster) {
+  return Math.max(...cluster.files.map((file) => file.modified_ms));
+}
+function start_of(file, context) {
+  return cost_run_nodes.started_ms(context.facts(file.session_id).records);
+}
+function write_stamps(activity, context) {
+  const stamps = activity.sessions.flatMap(
+    (file) => context.facts(file.session_id).records.map((record) => record.at_ms)
+  );
+  return stamps.filter((ms) => ms !== void 0).toSorted((left, right) => left - right);
+}
+function writes_before(activity, context) {
+  const stamps = write_stamps(activity, context);
+  const before = /* @__PURE__ */ new Map();
+  let cursor = FIRST2;
+  for (const main of activity.mains) {
+    const start = start_of(main, context);
+    while ((stamps[cursor] ?? Infinity) < start) cursor += 1;
+    before.set(main.session_id, stamps[cursor - 1] ?? -Infinity);
+  }
+  return before;
+}
+function fits(last, quiet_ms) {
+  return last !== void 0 && quiet_ms <= RUN_GAP_MS;
+}
+function open_cluster(file, start) {
+  return { root_id: file.session_id, first_start: start, files: [file] };
+}
+function cluster_mains(activity, context) {
+  const clusters = [];
+  const before = writes_before(activity, context);
+  for (const file of activity.mains) {
+    const start = start_of(file, context);
+    const last = clusters.at(NONE);
+    if (fits(last, start - (before.get(file.session_id) ?? -Infinity))) last.files.push(file);
+    else clusters.push(open_cluster(file, start));
+  }
+  return clusters;
+}
+function cluster_for_start(clusters, start) {
+  return clusters.findLast((cluster) => cluster.first_start <= start) ?? clusters[FIRST2];
+}
+function attach_lanes(clusters, lanes, context) {
+  for (const file of lanes) {
+    const start = cost_run_nodes.started_ms(context.facts(file.session_id).records);
+    cluster_for_start(clusters, start)?.files.push(file);
+  }
+}
+function index_by_session(clusters) {
+  const by_session = /* @__PURE__ */ new Map();
+  for (const cluster of clusters) {
+    for (const file of cluster.files) by_session.set(file.session_id, cluster);
+  }
+  return by_session;
+}
+function attach_subs(clusters, subs, context) {
+  const by_session = index_by_session(clusters);
+  for (const file of subs) {
+    const owner = by_session.get(cost_transcript.owning_session_id(file));
+    const start = cost_run_nodes.started_ms(context.facts(file.session_id).records);
+    (owner ?? cluster_for_start(clusters, start))?.files.push(file);
+  }
+}
+function build_clusters(files, context) {
+  const split = cost_run_nodes.split_files(files, context);
+  const has_mains = split.mains.length > FIRST2;
+  const roots = has_mains ? split.mains : split.lanes;
+  const mains = cost_run_nodes.order_mains(roots, context);
+  const clusters = cluster_mains({ mains, sessions: [...split.mains, ...split.lanes] }, context);
+  if (has_mains) attach_lanes(clusters, split.lanes, context);
+  attach_subs(clusters, split.subs, context);
+  return clusters;
+}
+function last_cluster(clusters) {
+  return [...clusters].toSorted((left, right) => cluster_end(right) - cluster_end(left))[FIRST2];
+}
+function named_cluster(clusters, run_id) {
+  return clusters.find(
+    (cluster) => cluster.root_id === run_id || cluster.files.some((file) => file.session_id === run_id)
+  );
+}
+function select(clusters, run_id) {
+  return run_id === void 0 ? last_cluster(clusters) : named_cluster(clusters, run_id);
+}
+function to_tree(files, chosen, context, run_count) {
+  const nodes = cost_run_nodes.build_nodes(chosen.files, context);
+  return {
+    nodes,
+    files: chosen.files,
+    run_count,
+    unattributed_count: files.length - chosen.files.length
+  };
+}
+function build_tree(files, context, run_id) {
+  const clusters = build_clusters(files, context);
+  const chosen = select(clusters, run_id);
+  if (chosen === void 0) return void 0;
+  return to_tree(files, chosen, context, clusters.length);
+}
+function lane_prefix(cwd) {
+  return `${cost_transcript.project_slug(lane_paths.lane_root(cwd))}-`;
+}
+function slug_of(file_path, projects_root) {
+  return path.relative(projects_root, file_path).split(path.sep)[FIRST2] ?? "";
+}
+function lane_issue_of(file, projects_root, prefix) {
+  const slug = slug_of(file.path, projects_root);
+  if (!slug.startsWith(prefix)) return void 0;
+  const rest = slug.slice(prefix.length);
+  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(rest) ? Number(rest) : void 0;
+}
+function to_context(files, cwd, projects_root) {
+  const prefix = lane_prefix(cwd);
+  const usage = new Map(files.map((file) => [file.session_id, cost_transcript.read_session(file)]));
+  return {
+    facts: (id) => usage.get(id) ?? { records: [], baseline_tokens: 0, is_readable: false },
+    lane_issue: (file) => lane_issue_of(file, projects_root, prefix),
+    lane_marks: (file) => cost_run_cut.lane_marks(file)
+  };
+}
+function load(cwd, run_id) {
+  const directories = cost_transcript.transcript_directories(cwd);
+  const files = cost_transcript.list_sessions_across(directories);
+  if (files.length === FIRST2) return void 0;
+  const projects_root = path.dirname(directories[FIRST2] ?? "");
+  return build_tree(files, to_context(files, cwd, projects_root), run_id);
+}
+var cost_run_tree = {
+  build_tree,
+  lane_issue_of,
+  load
+};
+
+// tools/cost/cost-run-issues.ts
+var NONE2 = 0;
+function sum(rows, pick) {
+  return rows.reduce((total, row) => total + pick(row), NONE2);
+}
+function totals_of(issue, rows) {
+  return {
+    issue,
+    session_count: rows.length,
+    cost_usd: sum(rows, (row) => row.cost_usd),
+    request_count: sum(rows, (row) => row.request_count),
+    elapsed_ms: sum(rows, (row) => row.elapsed_ms),
+    took_cut: rows.some((row) => row.took_cut),
+    is_measured: rows.every((row) => row.is_measured)
+  };
+}
+function group_by_issue(rows) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (row.issue !== void 0) groups.set(row.issue, [...groups.get(row.issue) ?? [], row]);
+  }
+  return groups;
+}
+function build(rows) {
+  return [...group_by_issue(rows)].map(([issue, members]) => totals_of(issue, members)).toSorted((left, right) => left.issue - right.issue);
+}
+var cost_run_issues = { build };
+
+// tools/cost/cost-dollar-composition.ts
+var ZERO = {
+  input_usd: 0,
+  cache_write_5m_usd: 0,
+  cache_write_1h_usd: 0,
+  cache_read_usd: 0,
+  output_usd: 0
+};
+function add(left, right) {
+  return {
+    input_usd: left.input_usd + right.input_usd,
+    cache_write_5m_usd: left.cache_write_5m_usd + right.cache_write_5m_usd,
+    cache_write_1h_usd: left.cache_write_1h_usd + right.cache_write_1h_usd,
+    cache_read_usd: left.cache_read_usd + right.cache_read_usd,
+    output_usd: left.output_usd + right.output_usd
+  };
+}
+function total_of(parts) {
+  return parts.input_usd + parts.cache_write_5m_usd + parts.cache_write_1h_usd + parts.cache_read_usd + parts.output_usd;
+}
+function build2(costs) {
+  let parts = ZERO;
+  const unpriced = [];
+  for (const entry of costs) {
+    const price = cost_pricing.resolve_price(entry.model);
+    if (price === void 0) {
+      unpriced.push(entry.model);
+      continue;
+    }
+    parts = add(parts, cost_pricing.estimate_composition(entry.totals, price));
+  }
+  return { ...parts, total_usd: total_of(parts), unpriced_models: unpriced };
+}
+var cost_dollar_composition = { build: build2 };
+
+// tools/cost/cost-run-roles.ts
+var NONE3 = 0;
+var WHOLE = 1;
+var TWO = 2;
+var ROLE_ORDER = ["parent", "wake", "lane", "subagent"];
+function records_of(nodes) {
+  return nodes.flatMap((node) => [...node.records]);
+}
+function cost_of(records) {
+  return cost_pricing.cost_of(records);
+}
+function elapsed_of(records) {
+  const stamps = records.map((record) => record.at_ms).filter((ms) => ms !== void 0);
+  return stamps.length < TWO ? NONE3 : Math.max(...stamps) - Math.min(...stamps);
+}
+function elapsed_of_nodes(nodes) {
+  return nodes.reduce((total, node) => total + elapsed_of(node.records), NONE3);
+}
+function preamble_of(nodes) {
+  return nodes.reduce((total, node) => total + node.baseline_tokens, NONE3);
+}
+function share(part, whole) {
+  return whole === NONE3 ? NONE3 : part / whole;
+}
+function role_totals(role, nodes, run2) {
+  const records = records_of(nodes);
+  const models = cost_pricing.cost_by_model(records);
+  const cost_usd = cost_pricing.total_cost(models).usd;
+  const elapsed_ms = elapsed_of_nodes(nodes);
+  return {
+    role,
+    session_count: nodes.length,
+    request_count: records.length,
+    output_tokens: cost_usage.sum_totals(records).output_tokens,
+    cost_usd,
+    composition: cost_dollar_composition.build(models),
+    preamble_tokens: preamble_of(nodes),
+    cost_share: share(cost_usd, run2.total_usd),
+    elapsed_ms,
+    elapsed_share: share(elapsed_ms, run2.total_elapsed_ms)
+  };
+}
+function nodes_in_role(nodes, role) {
+  return nodes.filter((node) => node.role === role);
+}
+function build_roles(nodes, run2) {
+  return ROLE_ORDER.map((role) => role_totals(role, nodes_in_role(nodes, role), run2)).filter(
+    (totals) => totals.session_count > NONE3
+  );
+}
+function to_row(node) {
+  return {
+    session_id: node.session_id,
+    role: node.role,
+    issue: node.issue,
+    parent_id: node.parent_id,
+    depth: node.depth,
+    is_readable: node.is_readable,
+    is_measured: node.is_readable && node.records.length > NONE3,
+    cost_usd: cost_of(node.records),
+    elapsed_ms: elapsed_of(node.records),
+    request_count: node.records.length,
+    output_tokens: cost_usage.sum_totals(node.records).output_tokens,
+    preamble_tokens: node.baseline_tokens,
+    took_cut: node.took_cut
+  };
+}
+function build_rows(nodes) {
+  return nodes.map((node) => to_row(node)).toSorted((left, right) => right.cost_usd - left.cost_usd);
+}
+function unreadable_of(nodes) {
+  return nodes.filter((node) => !node.is_readable).length;
+}
+function lane_issue_rows(rows, issue) {
+  return rows.filter((row) => row.role === "lane" && row.issue === issue);
+}
+function measure_lane_issue(rows, issue) {
+  const matching = lane_issue_rows(rows, issue);
+  if (matching.length === NONE3 || matching.some((row) => !row.is_measured)) return void 0;
+  return {
+    output_tokens: matching.reduce((total, row) => total + row.output_tokens, NONE3),
+    cost_usd: matching.reduce((total, row) => total + row.cost_usd, NONE3),
+    elapsed_ms: matching.reduce((total, row) => total + row.elapsed_ms, NONE3)
+  };
+}
+function build3(nodes) {
+  const run2 = { total_usd: cost_of(records_of(nodes)), total_elapsed_ms: elapsed_of_nodes(nodes) };
+  return {
+    roles: build_roles(nodes, run2),
+    sessions: build_rows(nodes),
+    total_usd: run2.total_usd,
+    total_elapsed_ms: run2.total_elapsed_ms,
+    unreadable_count: unreadable_of(nodes)
+  };
+}
+function shares_total(roles) {
+  return roles.reduce((total, role) => total + role.cost_share, NONE3);
+}
+var cost_run_roles = { ROLE_ORDER, WHOLE, build: build3, measure_lane_issue, shares_total };
+
+// tools/cost/cost-run-phase.ts
+var NONE4 = 0;
+var PHASE_PAD = 9;
+function totals_of2(phase, nodes) {
+  const lane = cost_run_roles.build(nodes).roles.find((totals) => totals.role === "lane");
+  if (lane === void 0) return { phase, session_count: NONE4, request_count: NONE4, cost_usd: NONE4 };
+  return {
+    phase,
+    session_count: lane.session_count,
+    request_count: lane.request_count,
+    cost_usd: lane.cost_usd
+  };
+}
+function build4(nodes) {
+  const lanes = nodes.filter((node) => node.role === "lane");
+  return [
+    totals_of2(
+      "implement",
+      lanes.filter((node) => !node.is_ship)
+    ),
+    totals_of2(
+      "ship",
+      lanes.filter((node) => node.is_ship)
+    )
+  ];
+}
+function phase_line(totals) {
+  const requests = `${String(totals.request_count)} request(s)`;
+  return `  ${totals.phase.padEnd(PHASE_PAD)} ${String(totals.session_count)} session(s) \xB7 ${requests} \xB7 ${figure_format.format_usd(totals.cost_usd)}`;
+}
+function format_lines(phases) {
+  if (phases.every((totals) => totals.session_count === NONE4)) return [];
+  return ["", "Worker by phase:", ...phases.map((totals) => phase_line(totals))];
+}
+var cost_run_phase = { build: build4, format_lines };
+
+// tools/cost/cost-run-split.ts
+var NONE5 = 0;
+var DENSITY_DIGITS = 1;
+var ROLE_PAD = 8;
+var NO_VALUE = "\u2014";
+function to_side(nodes) {
+  const roles = cost_run_roles.build(nodes);
+  return {
+    session_count: nodes.length,
+    total_usd: roles.total_usd,
+    total_elapsed_ms: roles.total_elapsed_ms,
+    roles: roles.roles
+  };
+}
+function build5(nodes, at_ms) {
+  const starts = nodes.map((node) => ({ node, start: cost_run_nodes.started_ms(node.records) }));
+  const stamped = starts.filter((entry) => Number.isFinite(entry.start));
+  return {
+    at: new Date(at_ms).toISOString(),
+    before: to_side(stamped.filter((entry) => entry.start < at_ms).map((entry) => entry.node)),
+    after: to_side(stamped.filter((entry) => entry.start >= at_ms).map((entry) => entry.node))
+  };
+}
+function side_line(label, side) {
+  const minutes = figure_format.format_minutes(side.total_elapsed_ms);
+  return `  ${label.padEnd(ROLE_PAD)} ${String(side.session_count)} session(s) \xB7 ${minutes} \xB7 ${figure_format.format_usd(side.total_usd)}`;
+}
+function role_of(side, role) {
+  return side.roles.find((totals) => totals.role === role);
+}
+function time_share(totals, side) {
+  if (totals === void 0) return NO_VALUE;
+  return figure_format.format_share(totals.elapsed_ms, side.total_elapsed_ms);
+}
+function cost_share(totals, side) {
+  if (totals === void 0) return NO_VALUE;
+  return figure_format.format_share(totals.cost_usd, side.total_usd);
+}
+function density(totals) {
+  if (totals === void 0 || totals.session_count === NONE5) return NO_VALUE;
+  return (totals.request_count / totals.session_count).toFixed(DENSITY_DIGITS);
+}
+function role_line(split, role) {
+  const before = role_of(split.before, role);
+  const after = role_of(split.after, role);
+  const time = `time ${time_share(before, split.before)} \u2192 ${time_share(after, split.after)}`;
+  const spent = `cost ${cost_share(before, split.before)} \u2192 ${cost_share(after, split.after)}`;
+  return `  ${role.padEnd(ROLE_PAD)} ${time} \xB7 ${spent} \xB7 req/session ${density(before)} \u2192 ${density(after)}`;
+}
+function has_role(split, role) {
+  return role_of(split.before, role) !== void 0 || role_of(split.after, role) !== void 0;
+}
+function format_lines2(split) {
+  const roles = cost_run_roles.ROLE_ORDER.filter((role) => has_role(split, role));
+  return [
+    "",
+    `Before \u2192 after ${split.at} (each session by its first request):`,
+    side_line("before", split.before),
+    side_line("after", split.after),
+    ...roles.map((role) => role_line(split, role))
+  ];
+}
+var cost_run_split = { build: build5, format_lines: format_lines2 };
+
+// tools/cost/cost-run-report.ts
+var FAILURE_EXIT_CODE = 1;
+var OK_EXIT_CODE = 0;
+var JSON_INDENT = 2;
+var NOT_MEASURED = "not measured";
+var ROLE_PAD2 = 8;
+var ISSUE_PAD = 6;
+var { format_minutes, format_share, format_tokens, format_usd } = figure_format;
+var DEFAULT_VIEW = { lead: [], split_at_ms: void 0 };
+function build6(run_count, unattributed_count, nodes, split_at_ms) {
+  const roles = cost_run_roles.build(nodes);
+  return {
+    scope: "run tree",
+    session_count: nodes.length,
+    run_count,
+    merged: void 0,
+    unattributed_count,
+    unreadable_count: roles.unreadable_count,
+    total_usd: roles.total_usd,
+    total_elapsed_ms: roles.total_elapsed_ms,
+    roles: roles.roles,
+    sessions: roles.sessions,
+    issues: cost_run_issues.build(roles.sessions),
+    worker_phases: cost_run_phase.build(nodes),
+    split: split_at_ms === void 0 ? void 0 : cost_run_split.build(nodes, split_at_ms)
+  };
+}
+function count_or_missing(count) {
+  return count === void 0 ? NOT_MEASURED : String(count);
+}
+function header_lines(report) {
+  return [
+    `run tree \u2014 ${String(report.session_count)} session(s), ${format_minutes(report.total_elapsed_ms)} active, ${format_usd(report.total_usd)}`,
+    `runs in store: ${String(report.run_count)} \xB7 merges: ${count_or_missing(report.merged)} \xB7 transcripts outside this run: ${String(report.unattributed_count)} \xB7 unreadable: ${String(report.unreadable_count)}`
+  ];
+}
+function role_line2(role, report) {
+  const spent = `${format_usd(role.cost_usd)} ${format_share(role.cost_usd, report.total_usd)}`;
+  const time = `${format_minutes(role.elapsed_ms)} ${format_share(role.elapsed_ms, report.total_elapsed_ms)}`;
+  const counts = `${String(role.session_count)} session(s) \xB7 ${String(role.request_count)} req \xB7 preamble ${format_tokens(role.preamble_tokens)}`;
+  return `  ${role.role.padEnd(ROLE_PAD2)} ${spent}  ${time}  ${counts}`;
+}
+function role_lines(report) {
+  return [
+    "",
+    "By role (cost-heaviest first):",
+    ...report.roles.map((role) => role_line2(role, report))
+  ];
+}
+function session_issue(issue) {
+  return issue === void 0 ? "\u2014" : session_cite.issue(issue);
+}
+function session_parent(parent_id) {
+  return parent_id === void 0 ? "" : ` \u2190 ${parent_id}`;
+}
+function session_line(row) {
+  const tag = `${row.role.padEnd(ROLE_PAD2)} d${String(row.depth)} ${session_issue(row.issue).padEnd(ISSUE_PAD)}`;
+  const identity = `  ${tag} ${row.session_id}`;
+  if (!row.is_measured) return `${identity}  ${NOT_MEASURED}${session_parent(row.parent_id)}`;
+  const usage = `${String(row.request_count)} req \xB7 output ${format_tokens(row.output_tokens)}`;
+  const spent = `${format_usd(row.cost_usd)} \xB7 ${format_minutes(row.elapsed_ms)} \xB7 ${usage} \xB7 preamble ${format_tokens(row.preamble_tokens)}`;
+  return `${identity}  ${spent}${session_parent(row.parent_id)}`;
+}
+function session_lines(report) {
+  return ["", "Sessions (cost-heaviest first):", ...report.sessions.map((row) => session_line(row))];
+}
+function format_report(report, lead = []) {
+  const split = report.split === void 0 ? [] : cost_run_split.format_lines(report.split);
+  const phases = cost_run_phase.format_lines(report.worker_phases);
+  const body = [
+    ...header_lines(report),
+    ...role_lines(report),
+    ...phases,
+    ...split,
+    ...session_lines(report)
+  ];
+  return (lead.length === 0 ? body : [...lead, "", ...body]).join("\n");
+}
+function print_report(report, is_json, lead) {
+  console.info(
+    is_json ? JSON.stringify(report, void 0, JSON_INDENT) : format_report(report, lead)
+  );
+}
+function report_empty(cwd) {
+  const searched = cost_transcript.searched_directories(cost_transcript.transcript_directories(cwd));
+  for (const line of cost_transcript.missing_message(searched, void 0)) console.error(line);
+  return FAILURE_EXIT_CODE;
+}
+function run(cwd, run_id, is_json, view = DEFAULT_VIEW) {
+  const tree = cost_run_tree.load(cwd, run_id);
+  if (tree === void 0) return report_empty(cwd);
+  const report = build6(tree.run_count, tree.unattributed_count, tree.nodes, view.split_at_ms);
+  print_report(report, is_json, view.lead);
+  return OK_EXIT_CODE;
+}
+var cost_run_report = { NOT_MEASURED, build: build6, format_report, run };
+
+export {
+  cost_run_nodes,
+  cost_run_tree,
+  cost_run_report
+};

package/dist/commands/chunk-F4SGOTUF.js

@@ -0,0 +1,36 @@
+import {
+  COMMAND_MAP
+} from "./chunk-CCHJZEF5.js";
+import {
+  canonical_command
+} from "./chunk-ROJXMBXP.js";
+
+// scripts/josh/josh-read-only.ts
+var HELP_COMMANDS = /* @__PURE__ */ new Set(["help", "--help", "-h"]);
+var ALL_FLAG = "--all";
+function is_help_request(command) {
+  return command === void 0 || command === ALL_FLAG || HELP_COMMANDS.has(command);
+}
+function entry_of(name) {
+  const command = canonical_command(name);
+  return Object.hasOwn(COMMAND_MAP, command) ? COMMAND_MAP[command] : void 0;
+}
+function is_read_only_call(entry, rest) {
+  const write_flags = entry.write_flags ?? [];
+  if (rest.some((argument) => write_flags.includes(argument.split("=", 1)[0] ?? ""))) return false;
+  if (entry.is_read_only === true) return true;
+  const flags = entry.read_only_flags ?? [];
+  return rest.some((argument) => flags.includes(argument));
+}
+function refusal(args) {
+  const [command = "", ...rest] = args;
+  if (is_help_request(args[0])) return void 0;
+  const entry = entry_of(command);
+  if (entry !== void 0 && is_read_only_call(entry, rest)) return void 0;
+  return `\`josh ${command}\` is not read-only: it carries a declared write flag, or its entry is not declared read-only and it carries no read-only flag its entry declares; read its usage with \`pnpm josh help ${command}\``;
+}
+var josh_read_only = { ALL_FLAG, entry_of, is_help_request, refusal };
+
+export {
+  josh_read_only
+};