@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-SP7DKYGU.js

@@ -1,1263 +0,0 @@
-import {
-  run_handoff_launch
-} from "./chunk-KODXWMBX.js";
-import {
-  lane_net_read
-} from "./chunk-MFBNNTBM.js";
-import {
-  lane_ledger_archive
-} from "./chunk-5UJGACVN.js";
-import {
-  guard_rephrase
-} from "./chunk-6FWV56B3.js";
-import {
-  lane_breakdown
-} from "./chunk-MLW4S35K.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  delivered_rules
-} from "./chunk-CP2J4RV2.js";
-import {
-  cost_pricing
-} from "./chunk-GW4UWR3O.js";
-import {
-  lane_stats
-} from "./chunk-XXC32PVL.js";
-import {
-  time_transcript_line
-} from "./chunk-OJ65BZBV.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-ZZXO6TFH.js";
-import {
-  cost_transcript,
-  cost_usage
-} from "./chunk-6WKJ3GDA.js";
-import {
-  lane_paths
-} from "./chunk-YIA6FC3K.js";
-import {
-  cli_flags
-} from "./chunk-2FE3C4PH.js";
-import {
-  git_gh_exec,
-  parse_json
-} from "./chunk-XDF25GSU.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
-};