@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-XUA7QZET.js

@@ -0,0 +1,1263 @@
+import {
+  run_handoff_launch
+} from "./chunk-CRCQOA4Z.js";
+import {
+  lane_net_read
+} from "./chunk-Q7GMTDMG.js";
+import {
+  lane_ledger_archive
+} from "./chunk-2TI22UNK.js";
+import {
+  guard_rephrase
+} from "./chunk-6FWV56B3.js";
+import {
+  lane_breakdown
+} from "./chunk-2MDLCJZ4.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  delivered_rules
+} from "./chunk-UC5ZOPKX.js";
+import {
+  cost_pricing
+} from "./chunk-5PLJ7R3D.js";
+import {
+  lane_stats
+} from "./chunk-WYAY6CQI.js";
+import {
+  time_transcript_line
+} from "./chunk-ZW6DLYS4.js";
+import {
+  cost_blocks,
+  time_josh_names,
+  time_shell
+} from "./chunk-LHKXJD6L.js";
+import {
+  transcript_record
+} from "./chunk-O3NDWYNT.js";
+import {
+  figure_format
+} from "./chunk-OYZP5ANC.js";
+import {
+  git_gh_exec,
+  parse_json
+} from "./chunk-NAZ753DE.js";
+import {
+  cost_transcript,
+  cost_usage
+} from "./chunk-DDZVMXZD.js";
+import {
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// tools/cost-audit/cost-audit-cli.ts
+import { z as z2 } from "zod";
+
+// tools/retrospective/guard-friction.ts
+function renamed_pairs(reason, former_reasons) {
+  const current = time_transcript_line.guard_from_refusal(reason);
+  return former_reasons.map((former) => [time_transcript_line.guard_from_refusal(former), current]);
+}
+var RENAMED_GUARDS = new Map(
+  delivered_rules.MEASURED_RULES.flatMap(
+    (rule) => renamed_pairs(rule.reason, rule.former_reasons ?? [])
+  ).filter(([former, current]) => former !== current)
+);
+function guard_name(raw_guard) {
+  return RENAMED_GUARDS.get(raw_guard) ?? raw_guard;
+}
+function hit(guard, kind, at_ms) {
+  return { guard: guard_name(guard), kind, at_ms };
+}
+function line_hits(line) {
+  const refusals = line.blocks.filter((block) => block.refusal_guard !== "").map((block) => hit(block.refusal_guard, "refusal", line.timestamp_ms));
+  const stops = line.stop_guard === "" ? [] : [hit(line.stop_guard, "stop", line.timestamp_ms)];
+  return [...refusals, ...stops];
+}
+function hits_of(lines) {
+  return lines.flatMap((line) => line_hits(line));
+}
+function answer_of(at_ms, records) {
+  return records.find((record) => record.at_ms !== void 0 && record.at_ms >= at_ms);
+}
+function share_counts(answers) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const answer of answers) {
+    if (answer !== void 0) counts.set(answer, (counts.get(answer) ?? 0) + 1);
+  }
+  return counts;
+}
+function share_usd(answer, counts) {
+  if (answer === void 0) return 0;
+  return cost_pricing.cost_of([answer]) / (counts.get(answer) ?? 1);
+}
+function priced_hits(session) {
+  const hits = hits_of(session.lines);
+  const answers = hits.map((one) => answer_of(one.at_ms, session.node.records));
+  const counts = share_counts(answers);
+  return hits.map((one, index) => [one, share_usd(answers[index], counts)]);
+}
+function count_of(kind, wanted) {
+  return kind === wanted ? 1 : 0;
+}
+function row_of(rows, guard) {
+  return rows.get(guard) ?? { guard, refusals: 0, stops: 0, rephrased: 0, usd: 0 };
+}
+function add_hit(rows, one, usd) {
+  const row2 = row_of(rows, one.guard);
+  rows.set(one.guard, {
+    ...row2,
+    refusals: row2.refusals + count_of(one.kind, "refusal"),
+    stops: row2.stops + count_of(one.kind, "stop"),
+    usd: row2.usd + usd
+  });
+}
+function add_rephrase(rows, raw_guard) {
+  const guard = guard_name(raw_guard);
+  const row2 = row_of(rows, guard);
+  rows.set(guard, { ...row2, rephrased: row2.rephrased + 1 });
+}
+function add_session(rows, session) {
+  for (const [one, usd] of priced_hits(session)) add_hit(rows, one, usd);
+  for (const guard of guard_rephrase.rephrased_guards(session.lines)) add_rephrase(rows, guard);
+}
+function total_hits(row2) {
+  return row2.refusals + row2.stops;
+}
+function guard_rows(sessions) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const session of sessions) add_session(rows, session);
+  return [...rows.values()].toSorted((left, right) => total_hits(right) - total_hits(left));
+}
+function sum_of(rows, field) {
+  return rows.reduce((total, row2) => total + row2[field], 0);
+}
+function row_line(row2) {
+  return `  ${row2.guard}: ${String(row2.refusals)} refused, ${String(row2.rephrased)} rephrased, ${String(row2.stops)} stopped, ${figure_format.format_usd(row2.usd)}`;
+}
+function report_lines(rows) {
+  if (rows.length === 0) return ["Guard friction: none"];
+  const refusals = String(sum_of(rows, "refusals"));
+  const stops = String(sum_of(rows, "stops"));
+  const usd = figure_format.format_usd(sum_of(rows, "usd"));
+  const head = `Guard friction: ${refusals} refusal(s), ${stops} Stop re-entry(ies), ${usd} in round trips`;
+  return [head, ...rows.map((row2) => row_line(row2))];
+}
+var guard_friction = { guard_name, guard_rows, report_lines };
+
+// tools/cost-audit/cost-audit-density.ts
+var SUBAGENT_KIND = "subagent";
+var SINGLE_CALL = 1;
+function is_lane_child(session) {
+  return session.is_lane && session.kind !== SUBAGENT_KIND;
+}
+function call_counts(session) {
+  return session.records.map((record) => session.categories.get(record.request_id)?.length ?? 0).filter((count) => count > 0);
+}
+function density_of(sessions) {
+  const counts = sessions.filter((session) => is_lane_child(session)).flatMap((session) => call_counts(session));
+  return {
+    requests: counts.length,
+    calls: counts.reduce((sum, count) => sum + count, 0),
+    single: counts.filter((count) => count === SINGLE_CALL).length
+  };
+}
+function calls_per_request(density) {
+  return density.requests === 0 ? 0 : density.calls / density.requests;
+}
+function single_share(density) {
+  return density.requests === 0 ? 0 : density.single / density.requests;
+}
+var cost_audit_density = { calls_per_request, density_of, single_share };
+
+// tools/cost-audit/cost-audit-kind.ts
+var RUN_KEYWORDS = ["fullrun", "halfrun", "prrun", "backlogrun", "kickoff"];
+var CONVERSATION = "conversation";
+var REVIEW = "review";
+var REVIEW_MARKER = "/code-review";
+var RESUME_PREFIX = "Resuming";
+var WAKE_MARKER = "Driver handoff";
+var WORD_PATTERN = /^\s*([a-z]+)/u;
+var RULES = [
+  { kind: "wake", matches: (prompt) => prompt.includes(WAKE_MARKER) },
+  { kind: "handoff", matches: (prompt) => prompt.includes(run_handoff_launch.ORIGIN_MARKER) },
+  { kind: REVIEW, matches: (prompt) => prompt.includes(REVIEW_MARKER) },
+  { kind: "subagent", matches: (_prompt, is_delegated) => is_delegated },
+  { kind: "resume", matches: (prompt) => prompt.trimStart().startsWith(RESUME_PREFIX) }
+];
+function run_keyword(prompt) {
+  const word = WORD_PATTERN.exec(prompt)?.[1] ?? "";
+  return RUN_KEYWORDS.find((keyword) => keyword === word);
+}
+function kind_of(prompt, is_delegated) {
+  const rule = RULES.find((one) => one.matches(prompt, is_delegated));
+  return rule?.kind ?? run_keyword(prompt) ?? CONVERSATION;
+}
+var cost_audit_kind = { CONVERSATION, REVIEW, kind_of };
+
+// tools/cost-audit/cost-audit-spend.ts
+function spend_of_model(cost) {
+  const price = cost_pricing.resolve_price(cost.model);
+  if (price === void 0) return void 0;
+  const terms = cost_pricing.estimate_composition(cost.totals, price);
+  return {
+    model: cost.model,
+    input: terms.input_usd,
+    cache_read: terms.cache_read_usd,
+    cache_write: terms.cache_write_5m_usd + terms.cache_write_1h_usd,
+    output: terms.output_usd
+  };
+}
+function total_of(spend) {
+  return spend.input + spend.cache_read + spend.cache_write + spend.output;
+}
+function spend_of(records) {
+  return cost_pricing.cost_by_model(records).map((cost) => spend_of_model(cost)).filter((spend) => spend !== void 0).toSorted((left, right) => total_of(right) - total_of(left));
+}
+var cost_audit_spend = { spend_of, total_of };
+
+// tools/cost-audit/cost-audit-usage.ts
+var LONG_OUTPUT_TOKENS = 2e3;
+function record_cache_write(record) {
+  const price = cost_pricing.resolve_price(record.model);
+  const tokens = {
+    tokens_5m: record.totals.cache_write_5m_tokens,
+    tokens_1h: record.totals.cache_write_1h_tokens
+  };
+  if (price === void 0) return { ...tokens, usd_5m: 0, usd_1h: 0 };
+  const terms = cost_pricing.estimate_composition(record.totals, price);
+  return { ...tokens, usd_5m: terms.cache_write_5m_usd, usd_1h: terms.cache_write_1h_usd };
+}
+function cache_write_of(records) {
+  const total = { tokens_5m: 0, tokens_1h: 0, usd_5m: 0, usd_1h: 0 };
+  for (const record of records) {
+    const write = record_cache_write(record);
+    total.tokens_5m += write.tokens_5m;
+    total.tokens_1h += write.tokens_1h;
+    total.usd_5m += write.usd_5m;
+    total.usd_1h += write.usd_1h;
+  }
+  return total;
+}
+function add_run(runs, agent_type, records) {
+  const run2 = runs.get(agent_type) ?? { agent_type, runs: 0, calls: 0, usd: 0 };
+  runs.set(agent_type, {
+    agent_type,
+    runs: run2.runs + 1,
+    calls: run2.calls + records.length,
+    usd: run2.usd + cost_pricing.cost_of(records)
+  });
+}
+function agents_of(sessions) {
+  const runs = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    if (session.agent_type !== void 0 && session.records.length > 0) {
+      add_run(runs, session.agent_type, session.records);
+    }
+  }
+  return [...runs.values()].toSorted((left, right) => right.usd - left.usd);
+}
+function context_tokens(record) {
+  const { input_tokens, cache_read_tokens, cache_write_5m_tokens, cache_write_1h_tokens } = record.totals;
+  return input_tokens + cache_read_tokens + cache_write_5m_tokens + cache_write_1h_tokens;
+}
+function first_context_of(sessions, is_inside2) {
+  const firsts = sessions.map((session) => session.records[0]).filter((record) => record !== void 0 && is_inside2(record.at_ms));
+  const tokens = firsts.map((record) => context_tokens(record));
+  return { sessions: tokens.length, p50_tokens: lane_stats.median(tokens) };
+}
+function long_records(records) {
+  return records.filter((record) => record.totals.output_tokens > LONG_OUTPUT_TOKENS);
+}
+function long_calls_of(records) {
+  return long_records(records).length;
+}
+function long_output_of(records) {
+  const long = long_records(records);
+  return { calls: long.length, all_calls: records.length, usd: cost_pricing.cost_of(long) };
+}
+function is_subagent(session) {
+  return session.agent_type !== void 0;
+}
+function breakdown_of(sessions, is_inside2) {
+  const cut = sessions.map((session) => ({
+    ...session,
+    records: session.records.filter((record) => is_inside2(record.at_ms))
+  }));
+  const records = cut.flatMap((session) => session.records);
+  return {
+    cache_write: cache_write_of(records),
+    agents: agents_of(cut),
+    first_main: first_context_of(
+      sessions.filter((session) => !is_subagent(session)),
+      is_inside2
+    ),
+    first_subagent: first_context_of(
+      sessions.filter((session) => is_subagent(session)),
+      is_inside2
+    ),
+    long_output: long_output_of(records)
+  };
+}
+var cost_audit_usage = { LONG_OUTPUT_TOKENS, breakdown_of, long_calls_of };
+
+// tools/cost-audit/cost-audit-phase.ts
+var REVIEW_KIND = cost_audit_kind.REVIEW;
+var PLAN = "plan";
+var UNATTRIBUTED = "unattributed";
+var ROUND_ONE = "review round 1";
+var ROUND_TWO = "review round 2";
+var IMPLEMENT_LEAD = "implement: ";
+var REVIEW_FIX = "review-fix";
+var AGENT_LEAD = "subagent: ";
+var EDIT = "edit";
+var IMPLEMENT_KINDS = [
+  ["verification", "check"],
+  ["edit", EDIT],
+  ["code search", "read"],
+  ["doc read", "read"]
+];
+var NO_TOKENS = { input: 0, cache_read: 0, cache_write: 0, output: 0 };
+function tokens_of(totals) {
+  return {
+    input: totals.input_tokens,
+    cache_read: totals.cache_read_tokens,
+    cache_write: totals.cache_write_5m_tokens + totals.cache_write_1h_tokens,
+    output: totals.output_tokens
+  };
+}
+function summed(left, right) {
+  return {
+    input: left.input + right.input,
+    cache_read: left.cache_read + right.cache_read,
+    cache_write: left.cache_write + right.cache_write,
+    output: left.output + right.output
+  };
+}
+function implement_kind(categories) {
+  return IMPLEMENT_KINDS.find(([category]) => categories.includes(category))?.[1] ?? EDIT;
+}
+function is_fix(placed, at_ms) {
+  return placed.review_from_ms !== void 0 && at_ms > placed.review_from_ms;
+}
+function implement_phase(placed, at_ms) {
+  const categories = placed.session.categories.get(placed.record.request_id) ?? [];
+  return `${IMPLEMENT_LEAD}${is_fix(placed, at_ms) ? REVIEW_FIX : implement_kind(categories)}`;
+}
+function between_phase(placed, at_ms) {
+  return is_fix(placed, at_ms) ? `${IMPLEMENT_LEAD}${REVIEW_FIX}` : lane_breakdown.BETWEEN_STAGE;
+}
+function review_round(stage) {
+  return stage === lane_breakdown.ROUND_TWO_STAGE ? ROUND_TWO : ROUND_ONE;
+}
+function stage_phase(placed, stage, at_ms) {
+  if (placed.session.kind === REVIEW_KIND) return review_round(stage);
+  if (stage === lane_breakdown.PLAN_STAGE) return PLAN;
+  if (stage === lane_breakdown.IMPLEMENT_STAGE) return implement_phase(placed, at_ms);
+  return stage === lane_breakdown.BETWEEN_STAGE ? between_phase(placed, at_ms) : stage;
+}
+function phase_of(placed) {
+  const { at_ms } = placed.record;
+  if (at_ms === void 0 || placed.breakdown === void 0) return UNATTRIBUTED;
+  const stage = lane_breakdown.stage_at(placed.breakdown, at_ms);
+  return stage === void 0 ? UNATTRIBUTED : stage_phase(placed, stage, at_ms);
+}
+function review_from_ms(sessions, issue) {
+  const instants = sessions.filter((session) => session.issue === issue && session.kind === REVIEW_KIND).flatMap((session) => session.records.map((record) => record.at_ms)).filter((at_ms) => at_ms !== void 0);
+  return instants.length === 0 ? void 0 : Math.min(...instants);
+}
+function add_record(groups, key, record) {
+  groups.set(key, [...groups.get(key) ?? [], record]);
+}
+function tokens_sum(records) {
+  let tokens = NO_TOKENS;
+  for (const record of records) tokens = summed(tokens, tokens_of(record.totals));
+  return tokens;
+}
+function row_of2(key, records) {
+  return {
+    key,
+    tokens: tokens_sum(records),
+    usd: cost_pricing.cost_of(records),
+    models: cost_audit_spend.spend_of(records),
+    long_calls: cost_audit_usage.long_calls_of(records)
+  };
+}
+function add_session2(rows, input, session) {
+  const { issue } = session;
+  if (issue === void 0) return;
+  const breakdown = input.breakdowns.get(issue);
+  const from_ms = review_from_ms(input.reviews, issue);
+  for (const record of session.records) {
+    add_record(rows, phase_of({ session, record, breakdown, review_from_ms: from_ms }), record);
+  }
+}
+function sorted(groups) {
+  return [...groups].map(([key, records]) => row_of2(key, records)).toSorted((left, right) => right.usd - left.usd);
+}
+function rows_of(input) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const session of input.sessions) add_session2(rows, input, session);
+  return sorted(rows);
+}
+function agent_key(session) {
+  return session.agent_type === void 0 ? session.kind : `${AGENT_LEAD}${session.agent_type}`;
+}
+function add_unit(rows, session) {
+  if (session.issue === void 0 || session.is_lane) return;
+  for (const record of session.records) add_record(rows, agent_key(session), record);
+}
+function agent_rows_of(sessions) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const session of sessions) add_unit(rows, session);
+  return sorted(rows);
+}
+var cost_audit_phase = { PLAN, ROUND_ONE, ROUND_TWO, UNATTRIBUTED, agent_rows_of, rows_of };
+
+// tools/cost-audit/cost-audit-command.ts
+var KEY_WORD_LIMIT = 3;
+var SUBCOMMAND_PATTERN = /^[a-z][\w:-]*$/u;
+function command_key(command) {
+  const segment = time_shell.command_segment(command);
+  if (segment === "" || time_shell.runs_josh(segment)) return "";
+  const [head = "", ...rest] = time_shell.command_words(segment);
+  const stop = rest.findIndex((word) => !SUBCOMMAND_PATTERN.test(word));
+  const subcommands = stop === -1 ? rest : rest.slice(0, stop);
+  return [head, ...subcommands.slice(0, KEY_WORD_LIMIT - 1)].join(" ");
+}
+var cost_audit_command = { command_key };
+
+// tools/cost-audit/cost-audit-result.ts
+var UNKNOWN_EFFORT = "unknown";
+var READ_TOOL = "Read";
+var BASH_TOOL = "Bash";
+var FILE_PATH_KEY = "file_path";
+var ROW_LIMIT = 10;
+function add(totals, key, value) {
+  totals.set(key, (totals.get(key) ?? 0) + value);
+}
+function effort_by_request(lines) {
+  const priced = lines.filter((line) => line.request_id !== "" && line.effort !== "");
+  return new Map(priced.map((line) => [line.request_id, line.effort]));
+}
+function add_efforts(totals, session) {
+  const efforts = effort_by_request(session.lines);
+  for (const record of session.records) {
+    add(totals, efforts.get(record.request_id) ?? UNKNOWN_EFFORT, cost_pricing.cost_of([record]));
+  }
+}
+function calls_of(blocks) {
+  const calls = blocks.filter((block) => block.type === transcript_record.TOOL_USE_TYPE);
+  return new Map(calls.filter((call) => call.id !== "").map((call) => [call.id, call]));
+}
+function results_of(lines, seen) {
+  const blocks = lines.flatMap((line) => line.blocks);
+  const calls = calls_of(blocks);
+  const fresh = blocks.filter((block) => block.result_id !== "" && !seen.has(block.result_id));
+  for (const block of fresh) seen.add(block.result_id);
+  return fresh.map((block) => ({ call: calls.get(block.result_id), chars: block.result_chars })).filter((result) => result.call !== void 0);
+}
+function josh_of(call) {
+  if (call.name !== BASH_TOOL) return "";
+  return time_josh_names.josh_command_of(time_shell.bash_command(call.input));
+}
+function command_of(call) {
+  if (call.name !== BASH_TOOL) return "";
+  return cost_audit_command.command_key(time_shell.bash_command(call.input));
+}
+function read_path(call) {
+  if (call.name !== READ_TOOL || !json_value.is_record(call.input)) return "";
+  const value = call.input[FILE_PATH_KEY];
+  return typeof value === "string" ? value : "";
+}
+function repeats_of(results) {
+  const seen = /* @__PURE__ */ new Set();
+  const reads = results.map((result) => ({ file: read_path(result.call), chars: result.chars }));
+  return reads.filter((read) => {
+    const is_repeat = seen.has(read.file);
+    seen.add(read.file);
+    return read.file !== "" && is_repeat;
+  });
+}
+function duplicates_of(repeats) {
+  const all = repeats.flat();
+  const files = repeats.map((one) => new Set(one.map((read) => read.file)).size);
+  return {
+    files: files.reduce((sum, count) => sum + count, 0),
+    reads: all.length,
+    chars: all.reduce((sum, read) => sum + read.chars, 0)
+  };
+}
+function chars_rows(results, key_of) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const { call, chars } of results) {
+    const key = key_of(call);
+    const row2 = rows.get(key) ?? { key, results: 0, chars: 0 };
+    rows.set(key, { key, results: row2.results + 1, chars: row2.chars + chars });
+  }
+  rows.delete("");
+  return [...rows.values()].toSorted((left, right) => right.chars - left.chars);
+}
+function effort_rows(sessions) {
+  const totals = /* @__PURE__ */ new Map();
+  for (const session of sessions) add_efforts(totals, session);
+  return [...totals].map(([effort, usd]) => ({ effort, usd })).toSorted((left, right) => right.usd - left.usd);
+}
+function breakdown_of2(sessions) {
+  const seen = /* @__PURE__ */ new Set();
+  const per_session = sessions.map((session) => results_of(session.lines, seen));
+  const results = per_session.flat();
+  const efforts = effort_rows(sessions);
+  return {
+    total_usd: efforts.reduce((sum, row2) => sum + row2.usd, 0),
+    efforts,
+    tools: chars_rows(results, (call) => call.name),
+    josh: chars_rows(results, (call) => josh_of(call)),
+    commands: chars_rows(results, (call) => command_of(call)),
+    reads: chars_rows(results, (call) => lane_paths.main_checkout_path(read_path(call))),
+    duplicate_reads: duplicates_of(per_session.map((one) => repeats_of(one)))
+  };
+}
+function effort_line(row2, total_usd) {
+  return `    ${row2.effort}: ${figure_format.format_usd(row2.usd)} (${figure_format.format_share(row2.usd, total_usd)})`;
+}
+function chars_line(row2) {
+  const average = figure_format.format_tokens(Math.round(row2.chars / row2.results));
+  return `    ${row2.key}: ${figure_format.format_tokens(row2.chars)} chars, ${String(row2.results)} results, ${average} avg`;
+}
+function chars_lines(rows) {
+  if (rows.length === 0) return ["    none"];
+  return rows.slice(0, ROW_LIMIT).map((row2) => chars_line(row2));
+}
+function duplicate_line(duplicates) {
+  const counts = `${String(duplicates.reads)} reads of ${String(duplicates.files)} files`;
+  return `  repeated Reads of a file the session already read: ${counts}, ${figure_format.format_tokens(duplicates.chars)} chars`;
+}
+function result_lines(breakdown) {
+  const efforts = breakdown.efforts.map((row2) => effort_line(row2, breakdown.total_usd));
+  const limit = String(ROW_LIMIT);
+  return [
+    "",
+    "Effort and tool results (this period: dollars and result characters)",
+    "  cost by effort:",
+    ...efforts.length === 0 ? ["    none"] : efforts,
+    `  result characters by tool (top ${limit}):`,
+    ...chars_lines(breakdown.tools),
+    `  result characters by josh subcommand (top ${limit}):`,
+    ...chars_lines(breakdown.josh),
+    `  result characters by other Bash command (top ${limit}):`,
+    ...chars_lines(breakdown.commands),
+    `  result characters by Read file (top ${limit}):`,
+    ...chars_lines(breakdown.reads),
+    duplicate_line(breakdown.duplicate_reads)
+  ];
+}
+var cost_audit_result = { ROW_LIMIT, UNKNOWN_EFFORT, breakdown_of: breakdown_of2, result_lines };
+
+// tools/cost-audit/cost-audit-rewrite.ts
+var REWRITE_FLOOR_TOKENS = 15e3;
+var CACHE_TTL_MS = 3e5;
+var READ_BACK_SHARE = 0.5;
+function written(record) {
+  return record.totals.cache_write_5m_tokens + record.totals.cache_write_1h_tokens;
+}
+function is_rewrite(record, before) {
+  const held = before.totals.cache_read_tokens + written(before);
+  return written(record) > REWRITE_FLOOR_TOKENS && record.totals.cache_read_tokens < held * READ_BACK_SHARE;
+}
+function write_cost(record) {
+  const { cache_write_5m_tokens, cache_write_1h_tokens } = record.totals;
+  const totals = { ...cost_usage.EMPTY_TOTALS, cache_write_5m_tokens, cache_write_1h_tokens };
+  return cost_pricing.cost_of([{ model: record.model, totals }]);
+}
+function add_rewrite(rewrites, record, before) {
+  const gap_ms = (record.at_ms ?? 0) - (before.at_ms ?? 0);
+  const bucket = gap_ms >= CACHE_TTL_MS ? rewrites.after_wait : rewrites.within_ttl;
+  bucket.count += 1;
+  bucket.usd += write_cost(record);
+}
+function pairs_of(records) {
+  const ordered = records.toSorted((left, right) => (left.at_ms ?? 0) - (right.at_ms ?? 0));
+  return ordered.slice(1).flatMap((record, index) => {
+    const before = ordered[index];
+    return before === void 0 ? [] : [[record, before]];
+  });
+}
+function add_session3(rewrites, session, is_counted) {
+  for (const [record, before] of pairs_of(session.records)) {
+    const is_counted_rewrite = is_counted(record.at_ms) && is_rewrite(record, before);
+    if (is_counted_rewrite) add_rewrite(rewrites, record, before);
+  }
+}
+function rewrites_in(sessions, is_counted) {
+  const rewrites = { after_wait: { count: 0, usd: 0 }, within_ttl: { count: 0, usd: 0 } };
+  for (const session of sessions) add_session3(rewrites, session, is_counted);
+  return rewrites;
+}
+var cost_audit_rewrite = { REWRITE_FLOOR_TOKENS, rewrites_in };
+
+// tools/cost-audit/cost-audit-sequence.ts
+var SHORTEST_RUN = 2;
+var LONGEST_RUN = 3;
+var RUN_LENGTHS = [SHORTEST_RUN, LONGEST_RUN];
+var TOP_RUNS = 10;
+var RETRY_REACH = 2;
+var RUN_SEPARATOR = " \u2192 ";
+function token_of(input) {
+  const command = time_shell.bash_command(input);
+  return time_josh_names.josh_command_of(command) || cost_audit_command.command_key(command);
+}
+function bash_tokens(lines) {
+  return lines.flatMap((line) => line.blocks).filter((block) => block.type === "tool_use" && block.name === cost_blocks.BASH_TOOL).map((block) => token_of(block.input)).filter((token) => token !== "");
+}
+function runs_of(tokens, length) {
+  return tokens.slice(0, Math.max(tokens.length - length + 1, 0)).map((_, start) => tokens.slice(start, start + length).join(RUN_SEPARATOR));
+}
+function session_runs(lines) {
+  const tokens = bash_tokens(lines);
+  return RUN_LENGTHS.flatMap((length) => runs_of(tokens, length));
+}
+function count_rows(keys) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const key of keys) counts.set(key, (counts.get(key) ?? 0) + 1);
+  return [...counts].map(([key, count]) => ({ key, count })).toSorted((left, right) => right.count - left.count);
+}
+function on_use(state, block) {
+  const token = block.name === cost_blocks.BASH_TOOL ? token_of(block.input) : "";
+  const matched = state.pending.filter((pending) => pending.token === token);
+  state.tokens.set(block.id, token);
+  state.retries.push(...matched.map((pending) => pending.guard));
+  state.pending = state.pending.filter((pending) => pending.token !== token && pending.left > 1).map((pending) => ({ ...pending, left: pending.left - 1 }));
+}
+function on_result(state, block) {
+  const token = state.tokens.get(block.result_id) ?? "";
+  if (token === "" || block.refusal_guard === "") return;
+  const guard = guard_friction.guard_name(block.refusal_guard);
+  state.pending.push({ guard, token, left: RETRY_REACH });
+}
+function on_block(state, block) {
+  if (block.type === "tool_use") on_use(state, block);
+  else if (block.result_id !== "") on_result(state, block);
+}
+function session_retries(lines) {
+  const state = { tokens: /* @__PURE__ */ new Map(), pending: [], retries: [] };
+  const blocks = lines.flatMap((line) => line.blocks);
+  for (const block of blocks) on_block(state, block);
+  return state.retries;
+}
+function sequences_of(sessions) {
+  const runs = sessions.flatMap((session) => session_runs(session.lines));
+  return {
+    runs: count_rows(runs).slice(0, TOP_RUNS),
+    retries: count_rows(sessions.flatMap((session) => session_retries(session.lines)))
+  };
+}
+function count_lines(title, rows) {
+  const body = rows.length === 0 ? ["  none"] : rows.map((row2) => `  ${row2.key}: ${String(row2.count)}`);
+  return ["", title, ...body];
+}
+function sequence_lines(sequences) {
+  return [
+    ...count_lines("Bash command runs (2 and 3 consecutive calls)", sequences.runs),
+    ...count_lines(
+      `Retries after a refusal (same command within ${String(RETRY_REACH)} calls), by guard`,
+      sequences.retries
+    )
+  ];
+}
+var cost_audit_sequence = { sequences_of, sequence_lines };
+
+// tools/cost-audit/cost-audit-tool.ts
+var OTHER = "other";
+var REPLY = "reply";
+var ORCHESTRATION = "orchestration";
+var CATEGORY_NAMES = [
+  {
+    category: "code search",
+    tools: ["Grep", "Glob", "WebSearch"],
+    josh: [],
+    shell: ["grep", "rg", "find", "ls"]
+  },
+  {
+    category: "doc read",
+    tools: ["Read", "WebFetch"],
+    josh: ["doc:", "read:"],
+    shell: ["cat", "sed", "head", "tail", "wc"]
+  },
+  { category: "edit", tools: ["Edit", "Write", "MultiEdit", "NotebookEdit"], josh: [], shell: [] },
+  {
+    category: ORCHESTRATION,
+    tools: [
+      "Agent",
+      "Task",
+      "Skill",
+      "TodoWrite",
+      "ToolSearch",
+      "SendMessage",
+      "Monitor",
+      "TaskStop"
+    ],
+    josh: [],
+    shell: []
+  },
+  { category: "issue ops", tools: [], josh: ["issue", "epic"], shell: ["gh"] },
+  {
+    category: "verification",
+    tools: [],
+    josh: ["gate", "lint", "test", "cspell", "review"],
+    shell: ["vitest", "tsc", "eslint"]
+  }
+];
+function category_where(is_match) {
+  return CATEGORY_NAMES.find((names) => is_match(names))?.category;
+}
+function josh_category(josh_command) {
+  const name = josh_command.slice(time_shell.JOSH_PREFIX.length);
+  const found = category_where((names) => names.josh.some((prefix) => name.startsWith(prefix)));
+  return found ?? ORCHESTRATION;
+}
+function bash_category(input) {
+  const command = time_shell.bash_command(input);
+  const josh_command = time_josh_names.josh_command_of(command);
+  if (josh_command !== "") return josh_category(josh_command);
+  const word = time_shell.leading_word(command);
+  return category_where((names) => names.shell.includes(word)) ?? OTHER;
+}
+function category_of(name, input) {
+  if (name === cost_blocks.BASH_TOOL) return bash_category(input);
+  return category_where((names) => names.tools.includes(name)) ?? OTHER;
+}
+var cost_audit_tool = { OTHER, REPLY, category_of };
+
+// tools/cost-audit/cost-audit.ts
+var REGRESSION_THRESHOLD = { ratio: 0.2, floor_usd: 1 };
+var DEFAULT_PERIOD_DAYS = 7;
+var MS_PER_DAY = 864e5;
+var PERIOD_COUNT = 2;
+function windows_of(days, now_ms) {
+  const span = days * MS_PER_DAY;
+  return [
+    { start_ms: now_ms - span, end_ms: now_ms },
+    { start_ms: now_ms - span * PERIOD_COUNT, end_ms: now_ms - span }
+  ];
+}
+function is_inside(at_ms, window) {
+  return at_ms !== void 0 && at_ms >= window.start_ms && at_ms < window.end_ms;
+}
+function add2(totals, key, usd) {
+  totals.set(key, (totals.get(key) ?? 0) + usd);
+}
+function add_request(period, session, record) {
+  const usd = cost_pricing.cost_of([record]);
+  const categories = session.categories.get(record.request_id) ?? [cost_audit_tool.REPLY];
+  period.total += usd;
+  add2(period.kinds, session.kind, usd);
+  for (const category of categories) add2(period.tools, category, usd / categories.length);
+}
+function inside(sessions, window) {
+  return sessions.map((session) => ({
+    ...session,
+    records: session.records.filter((record) => is_inside(record.at_ms, window)),
+    lines: session.lines.filter((line) => is_inside(line.timestamp_ms, window))
+  }));
+}
+function guard_costs(sessions) {
+  const sources = sessions.map((session) => ({ node: session, lines: session.lines }));
+  return new Map(guard_friction.guard_rows(sources).map((guard) => [guard.guard, guard.usd]));
+}
+function period_cost(sessions, window) {
+  const cut = inside(sessions, window);
+  const period = {
+    total: 0,
+    kinds: /* @__PURE__ */ new Map(),
+    tools: /* @__PURE__ */ new Map(),
+    guards: guard_costs(cut)
+  };
+  for (const session of cut) {
+    for (const record of session.records) add_request(period, session, record);
+  }
+  return period;
+}
+function is_regression(current, previous) {
+  const limit = previous * (1 + REGRESSION_THRESHOLD.ratio);
+  return current >= REGRESSION_THRESHOLD.floor_usd && current > limit;
+}
+function row(key, current, previous) {
+  return { key, current, previous, is_regression: is_regression(current, previous) };
+}
+function rows_of2(current, previous) {
+  const keys = /* @__PURE__ */ new Set([...current.keys(), ...previous.keys()]);
+  return [...keys].map((key) => row(key, current.get(key) ?? 0, previous.get(key) ?? 0)).toSorted((left, right) => right.current - left.current);
+}
+function per_merge(current, previous, merges) {
+  if (merges === void 0 || merges.current === 0 || merges.previous === 0) return void 0;
+  return row("per merge", current.total / merges.current, previous.total / merges.previous);
+}
+function rewrites_inside(sessions, window) {
+  return cost_audit_rewrite.rewrites_in(sessions, (at_ms) => is_inside(at_ms, window));
+}
+function records_by_kind(sessions) {
+  const records = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    records.set(session.kind, [...records.get(session.kind) ?? [], ...session.records]);
+  }
+  return records;
+}
+function kind_rows(current, previous, cut) {
+  const records = records_by_kind(cut);
+  return rows_of2(current.kinds, previous.kinds).map((kind) => ({
+    ...kind,
+    models: cost_audit_spend.spend_of(records.get(kind.key) ?? [])
+  }));
+}
+function phases_inside(input, window) {
+  const breakdowns = input.breakdowns ?? /* @__PURE__ */ new Map();
+  return cost_audit_phase.rows_of({
+    sessions: inside(input.sessions, window),
+    reviews: input.sessions,
+    breakdowns
+  });
+}
+function lane_density(sessions, current, previous) {
+  return {
+    current: cost_audit_density.density_of(inside(sessions, current)),
+    previous: cost_audit_density.density_of(inside(sessions, previous))
+  };
+}
+function current_only(input, window) {
+  const cut = inside(input.sessions, window);
+  return {
+    phases: phases_inside(input, window),
+    agents: cost_audit_phase.agent_rows_of(cut),
+    usage: cost_audit_usage.breakdown_of(input.sessions, (at_ms) => is_inside(at_ms, window)),
+    results: cost_audit_result.breakdown_of(cut),
+    sequences: cost_audit_sequence.sequences_of(cut)
+  };
+}
+function audit(input) {
+  const [current_window, previous_window] = windows_of(input.days, input.now_ms);
+  const current = period_cost(input.sessions, current_window);
+  const previous = period_cost(input.sessions, previous_window);
+  return {
+    ...current_only(input, current_window),
+    days: input.days,
+    lane_density: lane_density(input.sessions, current_window, previous_window),
+    total: row("total", current.total, previous.total),
+    merges: input.merges,
+    per_merge: per_merge(current, previous, input.merges),
+    kinds: kind_rows(current, previous, inside(input.sessions, current_window)),
+    tools: rows_of2(current.tools, previous.tools),
+    guards: rows_of2(current.guards, previous.guards),
+    rewrites: {
+      current: rewrites_inside(input.sessions, current_window),
+      previous: rewrites_inside(input.sessions, previous_window)
+    }
+  };
+}
+function since_ms(days, now_ms) {
+  return windows_of(days, now_ms)[1].start_ms;
+}
+var cost_audit = { DEFAULT_PERIOD_DAYS, MS_PER_DAY, audit, since_ms, windows_of };
+
+// tools/cost-audit/cost-audit-format.ts
+var PERCENT = 100;
+var PERCENT_DECIMALS = 1;
+var CALLS_PER_RUN_DECIMALS = 1;
+var REGRESSION_MARK = "  regression";
+var NO_PREVIOUS = "new";
+var FILING_PREFIX = "File a cost regression: ";
+var FILING_ROW_SEPARATOR = ", ";
+var FILING_SUFFIX = " \u2014 reproduce with `pnpm josh cost:audit`";
+var KIND_TITLE = "By session kind (this period per model: cost \u2014 input / cache read / cache write / output in dollars)";
+var LONG_OUTPUT = String(cost_audit_usage.LONG_OUTPUT_TOKENS);
+var TABLE_FIGURES = `cost \u2014 billed input / cache read / cache write / output tokens \xB7 calls with output over ${LONG_OUTPUT} tokens; per model in dollars`;
+var PHASE_TITLE = `Lane children by phase (this period: ${TABLE_FIGURES})`;
+var AGENT_TITLE = `Lane subagents by agent type (this period: ${TABLE_FIGURES})`;
+function change(row2) {
+  if (row2.previous === 0) return NO_PREVIOUS;
+  const share = (row2.current - row2.previous) / row2.previous * PERCENT;
+  const sign = share >= 0 ? "+" : "";
+  return `${sign}${share.toFixed(PERCENT_DECIMALS)}%`;
+}
+function row_line2(row2) {
+  const figures = `${figure_format.format_usd(row2.current)} (prev ${figure_format.format_usd(row2.previous)}, ${change(row2)})`;
+  return `  ${row2.key}: ${figures}${row2.is_regression ? REGRESSION_MARK : ""}`;
+}
+function sections_of(audit2) {
+  return [
+    { name: "kind", title: KIND_TITLE, rows: audit2.kinds },
+    { name: "tool", title: "By tool category", rows: audit2.tools },
+    { name: "guard", title: "By guard (refusal and Stop round trips)", rows: audit2.guards }
+  ];
+}
+function merge_lines(audit2) {
+  if (audit2.merges === void 0) return ["  merges: not read from GitHub"];
+  const counts = `  merges: ${String(audit2.merges.current)} (prev ${String(audit2.merges.previous)})`;
+  return audit2.per_merge === void 0 ? [counts] : [counts, row_line2(audit2.per_merge)];
+}
+var DENSITY_DECIMALS = 2;
+function density_text(density) {
+  const calls = cost_audit_density.calls_per_request(density).toFixed(DENSITY_DECIMALS);
+  const single = (cost_audit_density.single_share(density) * PERCENT).toFixed(PERCENT_DECIMALS);
+  return `${calls} calls/request, ${single}% single-call`;
+}
+function density_line(audit2) {
+  const { current, previous } = audit2.lane_density;
+  return `  lane-child density: ${density_text(current)} (prev ${density_text(previous)})`;
+}
+function density_value(audit2) {
+  const { current } = audit2.lane_density;
+  if (current.requests === 0) return void 0;
+  return cost_audit_density.calls_per_request(current).toFixed(DENSITY_DECIMALS);
+}
+function rewrite_figures(count) {
+  return `${String(count.count)} (${figure_format.format_usd(count.usd)})`;
+}
+function rewrite_line(label, current, previous) {
+  return `  ${label}: ${rewrite_figures(current)} (prev ${rewrite_figures(previous)})`;
+}
+function rewrite_lines(audit2) {
+  const { current, previous } = audit2.rewrites;
+  const floor = String(cost_audit_rewrite.REWRITE_FLOOR_TOKENS);
+  return [
+    "",
+    `Full cache rewrites (cache write over ${floor} tokens, the earlier context not read back)`,
+    rewrite_line("after a wait of 5 min or more", current.after_wait, previous.after_wait),
+    rewrite_line("within 5 min", current.within_ttl, previous.within_ttl)
+  ];
+}
+function phase_line(row2) {
+  const { input, cache_read, cache_write, output } = row2.tokens;
+  const tokens = [input, cache_read, cache_write, output].map(
+    (count) => figure_format.format_tokens(count)
+  );
+  const long = `${String(row2.long_calls)} calls over ${LONG_OUTPUT}`;
+  return `  ${row2.key}: ${figure_format.format_usd(row2.usd)} \u2014 ${tokens.join(" / ")} \xB7 ${long}`;
+}
+function spend_line(spend) {
+  const terms = [spend.input, spend.cache_read, spend.cache_write, spend.output].map(
+    (usd) => figure_format.format_usd(usd)
+  );
+  const total = figure_format.format_usd(cost_audit_spend.total_of(spend));
+  return `    ${spend.model}: ${total} \u2014 ${terms.join(" / ")}`;
+}
+function phase_row_lines(row2) {
+  return [phase_line(row2), ...row2.models.map((spend) => spend_line(spend))];
+}
+function token_table_lines(title, rows) {
+  const body = rows.length === 0 ? ["  none"] : rows.flatMap((row2) => phase_row_lines(row2));
+  return ["", title, ...body];
+}
+function phase_lines(audit2) {
+  return [
+    ...token_table_lines(PHASE_TITLE, audit2.phases),
+    ...token_table_lines(AGENT_TITLE, audit2.agents)
+  ];
+}
+function tokens_usd(tokens, usd) {
+  return `${figure_format.format_tokens(tokens)} tokens (${figure_format.format_usd(usd)})`;
+}
+function first_text(first, unit) {
+  const p50 = first.p50_tokens === void 0 ? "none" : figure_format.format_tokens(first.p50_tokens);
+  return `${p50} (${String(first.sessions)} ${unit})`;
+}
+function long_output_line(long) {
+  const share = long.all_calls === 0 ? 0 : long.calls / long.all_calls * PERCENT;
+  const counts = `${String(long.calls)} of ${String(long.all_calls)} calls`;
+  return `  output over ${String(cost_audit_usage.LONG_OUTPUT_TOKENS)} tokens: ${counts} (${share.toFixed(PERCENT_DECIMALS)}%, ${figure_format.format_usd(long.usd)})`;
+}
+function agent_runs_line(agent) {
+  const per_run = (agent.calls / agent.runs).toFixed(CALLS_PER_RUN_DECIMALS);
+  return `    ${agent.agent_type}: ${String(agent.runs)} runs, ${per_run} calls/run, ${figure_format.format_usd(agent.usd)}`;
+}
+function usage_lines(usage) {
+  const { cache_write: write } = usage;
+  const agents = usage.agents.length === 0 ? ["    none"] : usage.agents.map((agent) => agent_runs_line(agent));
+  return [
+    "",
+    "Usage breakdown (this period: tokens and dollars)",
+    `  cache write 5m: ${tokens_usd(write.tokens_5m, write.usd_5m)} / 1h: ${tokens_usd(write.tokens_1h, write.usd_1h)}`,
+    `  first request context p50: main ${first_text(usage.first_main, "sessions")} / subagent ${first_text(usage.first_subagent, "runs")}`,
+    long_output_line(usage.long_output),
+    "  subagent runs by agent type:",
+    ...agents
+  ];
+}
+function row_lines(row2) {
+  return [row_line2(row2), ...(row2.models ?? []).map((spend) => spend_line(spend))];
+}
+function section_lines(section) {
+  const body = section.rows.length === 0 ? ["  none"] : section.rows.flatMap((row2) => row_lines(row2));
+  return ["", section.title, ...body];
+}
+function regression_names(audit2) {
+  const head = [audit2.total, audit2.per_merge].filter((row2) => row2?.is_regression === true).map((row2) => row2.key);
+  const named = sections_of(audit2).flatMap(
+    (section) => section.rows.filter((row2) => row2.is_regression).map((row2) => `${section.name} ${row2.key}`)
+  );
+  return [...head, ...named];
+}
+function regression_text(audit2) {
+  const names = regression_names(audit2);
+  return names.length === 0 ? "none" : names.join(", ");
+}
+function report_lines2(audit2) {
+  const days = String(audit2.days);
+  return [
+    `Cost audit \u2014 the last ${days} day(s) against the ${days} before`,
+    row_line2(audit2.total),
+    ...merge_lines(audit2),
+    density_line(audit2),
+    ...sections_of(audit2).flatMap((section) => section_lines(section)),
+    ...rewrite_lines(audit2),
+    ...phase_lines(audit2),
+    ...usage_lines(audit2.usage),
+    ...cost_audit_result.result_lines(audit2.results),
+    ...cost_audit_sequence.sequence_lines(audit2.sequences),
+    "",
+    `Regressions: ${regression_text(audit2)}`
+  ];
+}
+function summary_line(audit2) {
+  const total = `${figure_format.format_usd(audit2.total.current)} (${change(audit2.total)})`;
+  const merge = audit2.per_merge === void 0 ? "" : `, ${figure_format.format_usd(audit2.per_merge.current)} per merge`;
+  return `Cost audit (${String(audit2.days)}d): ${total}${merge}; regressions: ${regression_text(audit2)}`;
+}
+function filing_lines(audit2) {
+  const names = regression_names(audit2);
+  if (names.length === 0) return [];
+  return [FILING_PREFIX + names.join(FILING_ROW_SEPARATOR) + FILING_SUFFIX];
+}
+var cost_audit_format = {
+  FILING_PREFIX,
+  FILING_ROW_SEPARATOR,
+  FILING_SUFFIX,
+  density_value,
+  filing_lines,
+  report_lines: report_lines2,
+  summary_line
+};
+
+// tools/cost-audit/cost-audit-read.ts
+import { homedir } from "node:os";
+import path from "node:path";
+import { z } from "zod";
+var LANE_ISSUE_PATTERN = /-(\d+)$/u;
+var TRANSCRIPT_EXTENSION = /\.jsonl$/u;
+var META_SCHEMA = z.object({ agentType: z.string().min(1) });
+function first_text2(raw) {
+  const block = cost_blocks.parse_line(raw).find((one) => one.type === cost_blocks.TEXT_TYPE && one.text.trim() !== "");
+  return block?.text ?? "";
+}
+function line_categories(line) {
+  return line.blocks.filter((block) => block.type === cost_blocks.TOOL_USE_TYPE).map((block) => cost_audit_tool.category_of(block.name, block.input));
+}
+function add_categories(parts, request_id, line) {
+  const found = line_categories(line);
+  const earlier = parts.categories.get(request_id) ?? [];
+  if (found.length > 0) parts.categories.set(request_id, [...earlier, ...found]);
+}
+function add_line(parts, raw) {
+  const outcome = cost_usage.parse_line(raw);
+  const line = time_transcript_line.parse_line(raw);
+  if (parts.prompt === "") parts.prompt = first_text2(raw);
+  if (line !== void 0) parts.lines.push(line);
+  if (outcome.kind !== "record") return;
+  parts.records.push(outcome.record);
+  if (line !== void 0) add_categories(parts, outcome.record.request_id, line);
+}
+function session_of(text, is_delegated, is_lane = false) {
+  const parts = { records: [], categories: /* @__PURE__ */ new Map(), lines: [], prompt: "" };
+  for (const raw of text.split("\n")) add_line(parts, raw);
+  return {
+    kind: cost_audit_kind.kind_of(parts.prompt, is_delegated),
+    is_lane: is_lane && !is_delegated,
+    records: cost_usage.dedupe(parts.records),
+    categories: parts.categories,
+    lines: parts.lines
+  };
+}
+function without_seen(session, seen) {
+  const records = session.records.filter((record) => !seen.has(record.request_id));
+  for (const record of records) seen.add(record.request_id);
+  return { ...session, records };
+}
+function dedupe_across(sessions) {
+  const seen = /* @__PURE__ */ new Set();
+  return sessions.map((session) => without_seen(session, seen));
+}
+function session_files(cwd, since_ms2) {
+  const main = cost_transcript.session_cwd(cwd);
+  const files = cost_transcript.list_sessions_across(cost_transcript.transcript_directories(main));
+  return files.filter((file) => file.modified_ms >= since_ms2).toReversed();
+}
+function lane_of(file_path, lanes) {
+  return lanes.find((directory) => file_path.startsWith(`${directory}${path.sep}`));
+}
+function issue_of(file_path, lanes) {
+  const digits = LANE_ISSUE_PATTERN.exec(lane_of(file_path, lanes) ?? "")?.[1];
+  return digits === void 0 ? void 0 : Number(digits);
+}
+function json_or_undefined(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function agent_type_of(transcript_path) {
+  const meta_path = transcript_path.replace(TRANSCRIPT_EXTENSION, ".meta.json");
+  const text = file_reader.read_if_readable(meta_path);
+  if (text === void 0) return void 0;
+  const parsed = META_SCHEMA.safeParse(json_or_undefined(text));
+  return parsed.success ? parsed.data.agentType : void 0;
+}
+function file_session(file, lanes) {
+  const issue = issue_of(file.path, lanes);
+  const session = session_of(cost_transcript.read_raw(file), file.is_delegated, issue !== void 0);
+  const agent_type = file.is_delegated ? agent_type_of(file.path) : void 0;
+  return { ...session, issue, agent_type };
+}
+function load(cwd, since_ms2) {
+  const lanes = cost_transcript.lane_transcript_directories(
+    cost_transcript.session_cwd(cwd),
+    homedir()
+  );
+  const sessions = session_files(cwd, since_ms2).map((file) => file_session(file, lanes));
+  return dedupe_across(sessions);
+}
+var cost_audit_read = { session_of, dedupe_across, issue_of, agent_type_of, load };
+
+// tools/cost-audit/cost-audit-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var USAGE = "Usage: pnpm josh cost:audit [--period <days> | --since <YYYY-MM-DD> --until <YYYY-MM-DD>] [--density]";
+var DENSITY_FLAG = "--density";
+var OPTIONS = {
+  period: { type: "string" },
+  since: { type: "string" },
+  until: { type: "string" },
+  density: { type: "boolean" }
+};
+var MAX_PERIOD_DAYS = 3650;
+var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
+var ISO_DATE_LENGTH = 10;
+var MILLISECONDS_PATTERN = /\.\d{3}Z$/u;
+var search_count_schema = z2.object({ total_count: z2.number() });
+function read_period(argv) {
+  const values = cli_flags.values_of(argv, OPTIONS);
+  if (values === void 0) return void 0;
+  const raw = values.period ?? String(cost_audit.DEFAULT_PERIOD_DAYS);
+  const days = cli_flags.to_positive(raw);
+  return days !== void 0 && days <= MAX_PERIOD_DAYS ? days : void 0;
+}
+function date_ms(raw) {
+  if (!DATE_PATTERN.test(raw)) return void 0;
+  const ms = Date.parse(`${raw}T00:00:00Z`);
+  if (Number.isNaN(ms)) return void 0;
+  return new Date(ms).toISOString().slice(0, ISO_DATE_LENGTH) === raw ? ms : void 0;
+}
+function dated_span(since, until) {
+  const start = date_ms(since);
+  const end = date_ms(until);
+  if (start === void 0 || end === void 0 || end < start) return void 0;
+  const days = (end - start) / cost_audit.MS_PER_DAY + 1;
+  return days <= MAX_PERIOD_DAYS ? { days, now_ms: end + cost_audit.MS_PER_DAY } : void 0;
+}
+function relative_span(argv, now_ms) {
+  const days = read_period(argv);
+  return days === void 0 ? void 0 : { days, now_ms };
+}
+function absolute_span(values) {
+  const { period, since, until } = values;
+  if (since === void 0 || until === void 0 || period !== void 0) return void 0;
+  return dated_span(since, until);
+}
+function read_span(argv, now_ms) {
+  const values = cli_flags.values_of(argv, OPTIONS);
+  if (values === void 0) return void 0;
+  const is_dated = values.since !== void 0 || values.until !== void 0;
+  return is_dated ? absolute_span(values) : relative_span(argv, now_ms);
+}
+function instant(ms) {
+  return new Date(ms).toISOString().replace(MILLISECONDS_PATTERN, "Z");
+}
+function merged_query(repo, window) {
+  return `repo:${repo} is:pr is:merged merged:${instant(window.start_ms)}..${instant(window.end_ms)}`;
+}
+async function merge_count(repo, window) {
+  const parameters = new URLSearchParams({ q: merged_query(repo, window), per_page: "1" });
+  const raw = await git_gh_exec.exec_gh_api({ path: `search/issues?${parameters.toString()}` });
+  return parse_json.parse_json_object_or_undefined(raw, search_count_schema)?.total_count;
+}
+async function read_merges(days, now_ms) {
+  try {
+    const repo = await git_gh_command.repo_get_name_with_owner();
+    if (repo === void 0) return void 0;
+    const [current, previous] = await Promise.all(
+      cost_audit.windows_of(days, now_ms).map(async (window) => await merge_count(repo, window))
+    );
+    return current === void 0 || previous === void 0 ? void 0 : { current, previous };
+  } catch {
+    return void 0;
+  }
+}
+async function read_breakdowns(sessions) {
+  const [entries, events] = await Promise.all([
+    lane_ledger_archive.read_history({}),
+    lane_net_read.read_events({})
+  ]);
+  const issues = new Set(sessions.flatMap((session) => session.issue ?? []));
+  const pairs = [...issues].map(
+    (issue) => [issue, lane_breakdown.of(entries, events, issue)]
+  );
+  return new Map(pairs.filter((pair) => pair[1] !== void 0));
+}
+async function measure(cwd, days, now_ms) {
+  const sessions = cost_audit_read.load(cwd, cost_audit.since_ms(days, now_ms));
+  const [merges, breakdowns] = await Promise.all([
+    read_merges(days, now_ms),
+    read_breakdowns(sessions)
+  ]);
+  return cost_audit.audit({ sessions, days, now_ms, merges, breakdowns });
+}
+async function summary(cwd, now_ms = Date.now()) {
+  const audit2 = await measure(cwd, cost_audit.DEFAULT_PERIOD_DAYS, now_ms);
+  return [cost_audit_format.summary_line(audit2), ...cost_audit_format.filing_lines(audit2)].join(
+    "\n"
+  );
+}
+function printed_lines(argv, audit2) {
+  if (!argv.includes(DENSITY_FLAG)) return cost_audit_format.report_lines(audit2);
+  const value = cost_audit_format.density_value(audit2);
+  return value === void 0 ? [] : [value];
+}
+function printed(lines) {
+  for (const line of lines) console.info(line);
+  return lines.length > 0 ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE;
+}
+async function run(argv, cwd = process.cwd(), now_ms = Date.now()) {
+  const span = read_span(argv, now_ms);
+  if (span === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  return printed(printed_lines(argv, await measure(cwd, span.days, span.now_ms)));
+}
+var cost_audit_cli = { USAGE, read_period, read_span, merged_query, run, summary };
+
+export {
+  guard_friction,
+  cost_audit_format,
+  cost_audit_cli
+};