@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-A3JYZWBS.js

@@ -1,803 +0,0 @@
-import {
-  lane_breakdown
-} from "./chunk-R7PYR4HW.js";
-import {
-  lane_net_time
-} from "./chunk-SNSZ25XZ.js";
-import {
-  lane_stage_stats
-} from "./chunk-J4XHEOOW.js";
-import {
-  hook_ledger
-} from "./chunk-4NSIW3UB.js";
-import {
-  command_memory
-} from "./chunk-QKTTKAXM.js";
-import {
-  lint_timing
-} from "./chunk-EAOTR2WL.js";
-import {
-  lint_related_scope
-} from "./chunk-DLHH3MLS.js";
-import {
-  lane_stats
-} from "./chunk-2XLR7R6E.js";
-import {
-  lane_ledger
-} from "./chunk-2O64H5UJ.js";
-import {
-  review_prompt_level
-} from "./chunk-E33LSO2W.js";
-import {
-  shell_segments
-} from "./chunk-CVJHQOI3.js";
-import {
-  time_josh_names,
-  time_shell
-} from "./chunk-LHKXJD6L.js";
-import {
-  git_argv
-} from "./chunk-G6BXCWPH.js";
-import {
-  cost_transcript
-} from "./chunk-DDZVMXZD.js";
-import {
-  MS_PER_SECOND
-} from "./chunk-WPAQUMHC.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/lane/lane-transcript-calls.ts
-import { z } from "zod";
-function join_parts(parts) {
-  return parts.map((part) => part.text ?? "").join("\n");
-}
-var SUBAGENT_TOOLS = /* @__PURE__ */ new Set(["Agent", "Task"]);
-var GENERAL_PURPOSE = "general-purpose";
-var PASS_MARKERS = [
-  [["review-brief-interaction-", "## Interaction review"], "interaction"],
-  [["round-2 verification pass"], "round 2"]
-];
-function string_or_undefined(value) {
-  return typeof value === "string" ? value : void 0;
-}
-function named(value) {
-  return value === "" ? void 0 : string_or_undefined(value);
-}
-function level_of(prompt) {
-  const [first = ""] = prompt.split("\n", 1);
-  return review_prompt_level.level_of(first.trim());
-}
-function pass_of(prompt) {
-  return PASS_MARKERS.find(([markers]) => markers.some((marker) => prompt.includes(marker)))?.[1];
-}
-function brief_of(value) {
-  const prompt = string_or_undefined(value) ?? "";
-  return { level: level_of(prompt), pass: pass_of(prompt) };
-}
-function subagent_of(input) {
-  return {
-    type: named(input?.subagent_type) ?? GENERAL_PURPOSE,
-    model: named(input?.model),
-    ...brief_of(input?.prompt)
-  };
-}
-function to_input(input) {
-  return {
-    background: input?.run_in_background === true,
-    command: string_or_undefined(input?.command),
-    subagent: subagent_of(input),
-    file_path: string_or_undefined(input?.file_path),
-    head: hook_ledger.command_of(input)
-  };
-}
-var TEXT_PARTS_SCHEMA = z.array(z.object({ text: z.string().nullish() }));
-var RESULT_CONTENT_SCHEMA = z.union([z.string(), TEXT_PARTS_SCHEMA.transform(join_parts)]).catch("");
-var INPUT_SCHEMA = z.object({
-  command: z.unknown(),
-  run_in_background: z.unknown(),
-  subagent_type: z.unknown(),
-  model: z.unknown(),
-  prompt: z.unknown(),
-  file_path: z.unknown(),
-  pattern: z.unknown(),
-  url: z.unknown()
-}).partial();
-var BLOCK_SCHEMA = z.object({
-  type: z.string(),
-  id: z.string().nullish(),
-  name: z.string().nullish(),
-  input: INPUT_SCHEMA.nullish().transform(to_input),
-  tool_use_id: z.string().nullish(),
-  content: RESULT_CONTENT_SCHEMA.optional(),
-  is_error: z.boolean().nullish()
-});
-function blocks_of(message) {
-  return message?.content ?? [];
-}
-var LINE_SCHEMA = z.object({
-  timestamp: z.string().transform(Date.parse).pipe(z.number()),
-  message: z.object({ content: z.array(BLOCK_SCHEMA).catch([]) }).nullish().transform(blocks_of)
-});
-function subagent_in(tool, block) {
-  return SUBAGENT_TOOLS.has(tool ?? "") ? block.input.subagent : void 0;
-}
-function record_use(pairs, block, started_ms) {
-  if (block.type !== "tool_use" || !block.id) return;
-  const tool = block.name ?? void 0;
-  pairs.uses.set(block.id, { started_ms, tool, ...block.input, subagent: subagent_in(tool, block) });
-}
-function record_result(pairs, block, ended_ms) {
-  if (block.type !== "tool_result" || !block.tool_use_id) return;
-  pairs.results.set(block.tool_use_id, {
-    ended_ms,
-    output: block.content ?? "",
-    is_error: block.is_error === true
-  });
-}
-function record_line(pairs, line) {
-  const parsed = LINE_SCHEMA.safeParse(json_value.parse_or_undefined(line));
-  if (!parsed.success) return;
-  const { timestamp, message } = parsed.data;
-  for (const block of message) {
-    record_use(pairs, block, timestamp);
-    record_result(pairs, block, timestamp);
-  }
-}
-function outcome_of(result) {
-  return { output: result?.output ?? "", is_error: result?.is_error };
-}
-function to_call(source, use, result) {
-  const is_timed2 = result !== void 0 && !use.background;
-  return {
-    ...source,
-    started_ms: use.started_ms,
-    duration_ms: is_timed2 ? result.ended_ms - use.started_ms : void 0,
-    tool: use.tool,
-    background: use.background,
-    command: use.command,
-    subagent: use.subagent,
-    file_path: use.file_path,
-    head: use.head,
-    ...outcome_of(result)
-  };
-}
-function parse(source, raw) {
-  const pairs = { uses: /* @__PURE__ */ new Map(), results: /* @__PURE__ */ new Map() };
-  const lines = raw.split("\n");
-  for (const line of lines) record_line(pairs, line);
-  return [...pairs.uses].map(([id, use]) => to_call(source, use, pairs.results.get(id)));
-}
-var lane_transcript_calls = { parse };
-
-// scripts/lane/lane-transcript-stats.ts
-import path from "node:path";
-var TIMED_COMMANDS = ["lint:related", "test:related"];
-var CALL_CLASSES = [
-  ["verification calls, scoped checks", /* @__PURE__ */ new Set([...TIMED_COMMANDS, "cspell:dot"])],
-  ["verification calls, gate / metrics by hand", /* @__PURE__ */ new Set(["gate", "metrics"])],
-  ["verification calls, ship", /* @__PURE__ */ new Set(["ship"])]
-];
-var VERIFICATION_COMMANDS = new Set(
-  CALL_CLASSES.flatMap(([, names]) => [...names])
-);
-var SEPARATOR_PATTERN = /[;&|()\n]/u;
-var WORD_PATTERN = /\s+/u;
-var KEYWORDS = /* @__PURE__ */ new Set([
-  "if",
-  "elif",
-  "else",
-  "then",
-  "while",
-  "until",
-  "do",
-  "!",
-  "{"
-]);
-var CORE_WAIT_PHRASE = "waits for the core budget";
-var PERCENT = 100;
-var COLUMNS = ["transcript metric", "value"];
-var { NOT_MEASURED } = lane_stage_stats;
-function segment_command(segment) {
-  const words = segment.trim().split(WORD_PATTERN);
-  const start = words.findIndex((word) => !KEYWORDS.has(word));
-  const named2 = time_josh_names.josh_command_of_segment(words.slice(start).join(" "));
-  return named2.slice(time_shell.JOSH_PREFIX.length);
-}
-function command_segments(command = "") {
-  return time_shell.unquoted(command).split(SEPARATOR_PATTERN);
-}
-function josh_commands(command = "") {
-  const named2 = command_segments(command).map((segment) => segment_command(segment));
-  return named2.filter((name) => name !== "");
-}
-function verification_commands(command = "") {
-  return josh_commands(command).filter((name) => VERIFICATION_COMMANDS.has(name));
-}
-function seconds_cell(ms) {
-  return ms === void 0 ? NOT_MEASURED : (ms / MS_PER_SECOND).toFixed(1);
-}
-function is_timed(ms) {
-  return ms !== void 0;
-}
-function durations(calls) {
-  return calls.map((call) => call.duration_ms).filter((ms) => is_timed(ms));
-}
-function sessions_of(calls) {
-  return [...new Set(calls.map((call) => call.session_id))];
-}
-function session_times(calls) {
-  return sessions_of(calls).map(
-    (session) => durations(calls.filter((call) => call.session_id === session)).reduce(
-      (sum, value) => sum + value,
-      0
-    )
-  );
-}
-function share_cell(part, whole) {
-  if (whole === 0) return NOT_MEASURED;
-  return `${String(part)} of ${String(whole)} (${(part / whole * PERCENT).toFixed(1)}%)`;
-}
-function solo_calls(calls, name) {
-  return calls.filter((call) => {
-    const named2 = verification_commands(call.command);
-    return named2.length === 1 && named2[0] === name;
-  });
-}
-function solo_median_row(verifying, name) {
-  const solo = solo_calls(verifying, name);
-  return [`${name} median, solo (s)`, seconds_cell(lane_stats.median(durations(solo)))];
-}
-function class_rows(verifying) {
-  return CALL_CLASSES.map(([metric, names]) => {
-    const named2 = verifying.filter(
-      (call) => verification_commands(call.command).some((name) => names.has(name))
-    );
-    return [metric, String(named2.length)];
-  });
-}
-function rows_of(calls) {
-  const times = session_times(calls);
-  const verifying = calls.filter((call) => verification_commands(call.command).length > 0);
-  const chained = verifying.filter((call) => verification_commands(call.command).length > 1);
-  const waited = verifying.filter((call) => call.output.includes(CORE_WAIT_PHRASE));
-  return [
-    ["lane sessions", String(times.length)],
-    ["tool time per session, median (min)", lane_stage_stats.cell(lane_stats.median(times))],
-    ["tool time per session, mean (min)", lane_stage_stats.cell(lane_stats.mean(times))],
-    ["verification calls, solo", String(verifying.length - chained.length)],
-    ["verification calls, chained", String(chained.length)],
-    ...class_rows(verifying),
-    ["waited for the core budget", share_cell(waited.length, verifying.length)],
-    ...TIMED_COMMANDS.map((name) => solo_median_row(verifying, name))
-  ];
-}
-function in_period(calls, window) {
-  return calls.filter(
-    (call) => call.started_ms >= window.since_ms && call.started_ms <= window.until_ms
-  );
-}
-function table(calls, window) {
-  const period = in_period(calls, window);
-  return [
-    lane_stats.to_row(COLUMNS),
-    lane_stats.to_row(COLUMNS.map(() => "---")),
-    ...rows_of(period).map((row) => lane_stats.to_row(row))
-  ].join("\n");
-}
-function read_calls(directories, window) {
-  return cost_transcript.list_sessions_across(directories).filter((file) => !file.is_delegated && file.modified_ms >= window.since_ms).flatMap(
-    (file) => lane_transcript_calls.parse(
-      { session_id: file.session_id, lane: path.dirname(file.path) },
-      cost_transcript.read_raw(file)
-    )
-  );
-}
-var lane_transcript_stats = {
-  command_segments,
-  durations,
-  in_period,
-  josh_commands,
-  read_calls,
-  solo_calls,
-  table,
-  verification_commands
-};
-
-// scripts/lane/lane-breakdown-calls.ts
-var TOP = 3;
-var LABEL_WIDTH = 60;
-var JOSH_COMMAND = /\bjosh ([\w:-]+)/gu;
-var CHAIN = " + ";
-var LEADING_CD = /^cd \S+ && /u;
-var WHITESPACE = /\s+/gu;
-var ROUND_TWO_AGENT = "reviewer-verification";
-var ROUND_ONE_AGENT = "reviewer";
-var SEPARATOR = " \xB7 ";
-var LINT_RELATED = "lint:related";
-function josh_commands2(command) {
-  return [...command.matchAll(JOSH_COMMAND)].map((match) => match[1]);
-}
-function reserved_label(wrapped) {
-  const commands = josh_commands2(wrapped);
-  const program = git_argv.program_of(wrapped)?.name ?? "";
-  return `reserved-run (${commands.length > 0 ? commands.join(CHAIN) : program})`;
-}
-function segment_labels(segment) {
-  const call = git_argv.program_of(segment);
-  const wrapped = call === void 0 ? void 0 : command_memory.wrapped_command_of(call);
-  return wrapped === void 0 ? josh_commands2(segment) : [reserved_label(wrapped)];
-}
-function command_label(command) {
-  const words = command.replace(LEADING_CD, "").replaceAll(WHITESPACE, " ").trim();
-  const commands = shell_segments.quote_aware_commands_of(words).flatMap((segment) => segment_labels(segment));
-  return commands.length > 0 ? commands.join(CHAIN) : words.slice(0, LABEL_WIDTH);
-}
-function pass_of2(subagent) {
-  if (subagent.pass !== void 0) return subagent.pass;
-  if (subagent.type.endsWith(ROUND_TWO_AGENT)) return "round 2";
-  return subagent.type.endsWith(ROUND_ONE_AGENT) ? "round 1" : void 0;
-}
-function subagent_label(subagent) {
-  const words = [pass_of2(subagent), subagent.level].filter((word) => word !== void 0);
-  return words.length > 0 ? words.join(SEPARATOR) : subagent.type;
-}
-function label_of(call) {
-  if (call.command !== void 0) return command_label(call.command);
-  if (call.subagent !== void 0) return subagent_label(call.subagent);
-  return call.tool ?? "";
-}
-function top_of(timed) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const { call, ms } of timed) {
-    const label = label_of(call);
-    const group = groups.get(label) ?? { label, count: 0, ms: 0 };
-    groups.set(label, { label, count: group.count + 1, ms: group.ms + ms });
-  }
-  return [...groups.values()].toSorted((left, right) => right.ms - left.ms).slice(0, TOP);
-}
-function names_lint_related(label) {
-  return label.split(CHAIN).includes(LINT_RELATED);
-}
-function lint_detail(label, timed) {
-  const [longest] = timed.filter(({ call }) => label_of(call) === label).toSorted((left, right) => right.ms - left.ms);
-  return longest === void 0 ? void 0 : lint_timing.detail_of(lint_related_scope.COMMAND_LABEL, longest.call.output);
-}
-function with_lint_detail(groups, timed) {
-  return groups.map(
-    (group) => names_lint_related(group.label) ? { ...group, detail: lint_detail(group.label, timed) } : group
-  );
-}
-function by_kind(parts) {
-  const names = new Set(parts.map((part) => part.name));
-  return new Map(
-    [...names].map((name) => {
-      const timed = parts.filter((part) => part.name === name);
-      return [name, with_lint_detail(top_of(timed), timed)];
-    })
-  );
-}
-function group_text(group) {
-  const text = `${group.label} \xD7${String(group.count)} ${lane_breakdown.minutes_text(group.ms)}`;
-  return group.detail === void 0 ? text : `${text} (${group.detail})`;
-}
-var lane_breakdown_calls = { by_kind, group_text, label_of, top_of, with_lint_detail };
-
-// scripts/lane/lane-paused-spans.ts
-var PAUSED = "paused";
-var LANE_ISSUE_PATTERN = /-(?<issue>\d+)$/u;
-var NONE = [];
-function is_change(entry) {
-  return entry.kind === lane_ledger.KIND.LANE_STATE || entry.kind === lane_ledger.KIND.DISPATCH;
-}
-function is_pause(change) {
-  return change.kind === lane_ledger.KIND.LANE_STATE && change.state === PAUSED;
-}
-function step(walk, change) {
-  const at_ms = Date.parse(change.at);
-  if (is_pause(change)) return { spans: walk.spans, open_ms: walk.open_ms ?? at_ms };
-  if (walk.open_ms === void 0) return walk;
-  return { spans: [...walk.spans, { from_ms: walk.open_ms, to_ms: at_ms }], open_ms: void 0 };
-}
-function spans_of(changes) {
-  let walk = { spans: [], open_ms: void 0 };
-  for (const change of changes) walk = step(walk, change);
-  if (walk.open_ms === void 0) return walk.spans;
-  return [...walk.spans, { from_ms: walk.open_ms, to_ms: Infinity }];
-}
-function by_lane(entries) {
-  const changes = entries.filter((entry) => is_change(entry)).toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at));
-  const issues = [...new Set(changes.map((change) => change.issue))];
-  return new Map(
-    issues.map((issue) => [issue, spans_of(changes.filter((change) => change.issue === issue))])
-  );
-}
-function issue_of_lane(lane) {
-  const issue = LANE_ISSUE_PATTERN.exec(lane)?.groups?.["issue"];
-  return issue === void 0 ? void 0 : Number(issue);
-}
-function of_lane(spans, lane) {
-  const issue = issue_of_lane(lane);
-  return issue === void 0 ? NONE : spans.get(issue) ?? NONE;
-}
-function overlap_ms(spans, from_ms, to_ms) {
-  let sum = 0;
-  for (const span of spans) {
-    sum += Math.max(0, Math.min(to_ms, span.to_ms) - Math.max(from_ms, span.from_ms));
-  }
-  return sum;
-}
-var lane_paused_spans = { by_lane, issue_of_lane, of_lane, overlap_ms };
-
-// scripts/lane/lane-implement-subagents.ts
-var NO_TOTAL = { ms: 0, timed: 0, untimed: 0 };
-function own_ms(call, paused) {
-  const duration = call.duration_ms ?? 0;
-  const end = call.started_ms + duration;
-  return duration - lane_paused_spans.overlap_ms(paused, call.started_ms, end);
-}
-function added(total, call, paused) {
-  return {
-    ms: total.ms + own_ms(call, paused),
-    timed: total.timed + (call.duration_ms === void 0 ? 0 : 1),
-    untimed: total.untimed + (call.background ? 1 : 0)
-  };
-}
-function lane_types(lane) {
-  const types = /* @__PURE__ */ new Map();
-  for (const call of lane.calls) {
-    const type = call.subagent?.type;
-    if (type !== void 0) types.set(type, added(types.get(type) ?? NO_TOTAL, call, lane.paused));
-  }
-  return types;
-}
-function type_row(type, totals) {
-  const values = totals.filter((total) => total.timed > 0).map((total) => total.ms);
-  const untimed = totals.reduce((sum, total) => sum + total.untimed, 0);
-  return [
-    `subagent: ${type}`,
-    String(values.length),
-    lane_stage_stats.cell(lane_stats.median(values)),
-    lane_stage_stats.cell(lane_stats.peak(values)),
-    String(untimed)
-  ];
-}
-function rows(lanes) {
-  const per_lane = lanes.map((lane) => lane_types(lane));
-  const types = [...new Set(per_lane.flatMap((types_of) => [...types_of.keys()]))].toSorted(
-    (left, right) => left.localeCompare(right)
-  );
-  return types.map(
-    (type) => type_row(
-      type,
-      per_lane.flatMap((types_of) => types_of.get(type) ?? [])
-    )
-  );
-}
-var lane_implement_subagents = { rows };
-
-// scripts/lane/lane-implement-stats.ts
-var SUB_STAGES = ["plan", "read", "edit", "check", "review-fix"];
-var [PLAN, READ, EDIT, CHECK, REVIEW_FIX] = SUB_STAGES;
-var LINT_RELATED2 = "lint:related";
-var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "MultiEdit", "NotebookEdit", "Write"]);
-var CHECK_COMMANDS = /* @__PURE__ */ new Set([
-  "check:related",
-  "cspell:dot",
-  "gate",
-  LINT_RELATED2,
-  "metrics",
-  "test:pinned",
-  "test:related"
-]);
-var REVIEW_COMMANDS = /* @__PURE__ */ new Set(["review:brief", "run:review"]);
-var SHIP_COMMANDS = /* @__PURE__ */ new Set(["ship"]);
-var JOIN_FLAG = /\s--join(?:\s|$)/u;
-var SHIP_FLAG = /\s--ship(?:\s|=|$)/u;
-var CHAIN_REACHED_SHIP = /^run:chain \d+ — (?:ran (?:[^\s]+ → )*ship$|stopped at ship \()/mu;
-var FIRST_LINT_ROW = `lane first ${LINT_RELATED2}`;
-var COLUMNS2 = [
-  "implement sub-stage",
-  "lanes",
-  "median (min)",
-  "max (min)",
-  "backgrounded"
-];
-var NO_REACH = { session_id: void 0, end_ms: 0 };
-function runs_any(call, names) {
-  return lane_transcript_stats.josh_commands(call.command).some((name) => names.has(name));
-}
-function is_edit(call) {
-  return EDIT_TOOLS.has(call.tool ?? "");
-}
-function next_phase(call, phase) {
-  return {
-    edited: phase.edited || is_edit(call),
-    reviewing: phase.reviewing || runs_any(call, REVIEW_COMMANDS)
-  };
-}
-function sub_stage_of(call, phase) {
-  if (phase.reviewing) return REVIEW_FIX;
-  if (is_edit(call)) return EDIT;
-  if (runs_any(call, CHECK_COMMANDS)) return CHECK;
-  return phase.edited ? READ : PLAN;
-}
-function end_ms(call) {
-  return call.started_ms + (call.duration_ms ?? 0);
-}
-function span_ms(call, reach) {
-  if (reach.session_id !== call.session_id) return call.duration_ms ?? 0;
-  return Math.max(0, end_ms(call) - reach.end_ms);
-}
-function next_reach(call, reach) {
-  const latest = reach.session_id === call.session_id ? reach.end_ms : 0;
-  return { session_id: call.session_id, end_ms: Math.max(latest, end_ms(call)) };
-}
-function active_ms(call, reach, paused) {
-  const span = span_ms(call, reach);
-  const end = end_ms(call);
-  return span - lane_paused_spans.overlap_ms(paused, end - span, end);
-}
-function staged(calls, paused) {
-  const result = [];
-  let phase = { edited: false, reviewing: false };
-  let reach = NO_REACH;
-  for (const call of calls) {
-    phase = next_phase(call, phase);
-    result.push({
-      call,
-      stage: sub_stage_of(call, phase),
-      active_ms: active_ms(call, reach, paused)
-    });
-    reach = next_reach(call, reach);
-  }
-  return result;
-}
-function lane_totals(calls, paused) {
-  const totals = new Map(SUB_STAGES.map((stage) => [stage, 0]));
-  for (const entry of staged(calls, paused)) {
-    totals.set(entry.stage, (totals.get(entry.stage) ?? 0) + entry.active_ms);
-  }
-  return totals;
-}
-function chain_ships(segment) {
-  return lane_transcript_stats.josh_commands(segment).includes("run:chain") && JOIN_FLAG.test(segment) && SHIP_FLAG.test(segment);
-}
-function starts_ship(call) {
-  return runs_any(call, SHIP_COMMANDS) || CHAIN_REACHED_SHIP.test(call.output) && lane_transcript_stats.command_segments(call.command).some((segment) => chain_ships(segment));
-}
-function implement_calls(calls) {
-  const ship = calls.findIndex((call) => starts_ship(call));
-  return ship === -1 ? void 0 : calls.slice(0, ship);
-}
-function lanes_of(calls) {
-  const lanes = [...new Set(calls.map((call) => call.lane))];
-  return lanes.map(
-    (lane) => calls.filter((call) => call.lane === lane).toSorted((left, right) => left.started_ms - right.started_ms)
-  );
-}
-function implement_lane(lane, paused) {
-  const implement = implement_calls(lane);
-  const spans = lane_paused_spans.of_lane(paused, lane[0]?.lane ?? "");
-  return implement === void 0 ? void 0 : { calls: implement, paused: spans };
-}
-function implement_lanes(calls, window, paused) {
-  const lanes = lanes_of(lane_transcript_stats.in_period(calls, window));
-  return lanes.flatMap((lane) => implement_lane(lane, paused) ?? []);
-}
-function lane_totals_in(calls, window, paused) {
-  return implement_lanes(calls, window, paused).map((lane) => lane_totals(lane.calls, lane.paused));
-}
-function minutes_row(label, values) {
-  return [
-    label,
-    String(values.length),
-    lane_stage_stats.cell(lane_stats.median(values)),
-    lane_stage_stats.cell(lane_stats.peak(values)),
-    ""
-  ];
-}
-function stage_row(stage, totals) {
-  return minutes_row(
-    stage,
-    totals.map((lane) => lane.get(stage) ?? 0)
-  );
-}
-function first_lint_ms(lane) {
-  const first = lane_transcript_stats.solo_calls(lane.calls, LINT_RELATED2).find((call) => call.duration_ms !== void 0);
-  return first === void 0 ? void 0 : active_ms(first, NO_REACH, lane.paused);
-}
-function first_lint_rows(lanes) {
-  const values = lanes.flatMap((lane) => first_lint_ms(lane) ?? []);
-  return values.length === 0 ? [] : [minutes_row(FIRST_LINT_ROW, values)];
-}
-function table2(calls, window, paused) {
-  const lanes = implement_lanes(calls, window, paused);
-  const totals = lanes.map((lane) => lane_totals(lane.calls, lane.paused));
-  const rows2 = [
-    ...SUB_STAGES.map((stage) => stage_row(stage, totals)),
-    ...first_lint_rows(lanes),
-    ...lane_implement_subagents.rows(lanes)
-  ];
-  return [
-    lane_stats.to_row(COLUMNS2),
-    lane_stats.to_row(COLUMNS2.map(() => "---")),
-    ...rows2.map((row) => lane_stats.to_row(row))
-  ].join("\n");
-}
-var lane_implement_stats = {
-  EDIT_TOOLS,
-  SUB_STAGES,
-  implement_lanes,
-  lane_totals_in,
-  staged,
-  table: table2
-};
-
-// scripts/lane/lane-breakdown-implement.ts
-var REMAINDER = "editing & thinking";
-var OTHER_BASH = "other bash";
-var BASH_TOOL = "Bash";
-var READ2 = "read";
-var EDIT2 = "edit";
-var EDIT_TOOLS2 = /* @__PURE__ */ new Set(["Edit", "Write"]);
-var TOOL_KINDS = /* @__PURE__ */ new Map([
-  ["Read", READ2],
-  ["Grep", READ2],
-  ["Glob", READ2]
-]);
-var BETWEEN_TOOL_KINDS = new Map([
-  ...TOOL_KINDS,
-  ...[...lane_implement_stats.EDIT_TOOLS].map((tool) => [tool, EDIT2])
-]);
-var COMMAND_KINDS = [
-  [/\bjosh main:merge\b/u, "main:merge"],
-  [/\bjosh check:related\b/u, "check:related"],
-  [/\bjosh gate\b/u, "gate"],
-  // Match each chain's own arguments, so a join flag on another command cannot rename its open.
-  [/\bjosh run:chain\b[^;&|\n]*\s--join\b/u, "run:chain join"],
-  [/\bjosh run:chain\b/u, "run:chain open"],
-  [/\bjosh run:review\b/u, "run:review"],
-  // Not `\b`: it holds before the `:` of `ship:evidence`, whose wrapped command is its own kind.
-  [/\bjosh ship(?::wait)?(?![\w:-])/u, "ship / ship:wait"],
-  [/\bjosh test(?::[\w-]+)?\b/u, "test"],
-  [/\bjosh (?:lint|cspell)(?::[\w-]+)?\b/u, "lint / cspell"]
-];
-function command_kind(command) {
-  return COMMAND_KINDS.find(([pattern]) => pattern.test(command))?.[1] ?? OTHER_BASH;
-}
-function subagent_kind(subagent) {
-  return `subagent: ${subagent.type}`;
-}
-function kind_of(call, tool_kinds) {
-  if (call.tool === BASH_TOOL) return command_kind(call.command ?? "");
-  if (call.subagent !== void 0) return subagent_kind(call.subagent);
-  return tool_kinds.get(call.tool ?? "");
-}
-function is_untimed_subagent(call) {
-  return call.background && call.subagent !== void 0;
-}
-function end_ms2(call) {
-  return call.started_ms + (call.duration_ms ?? 0);
-}
-function timed_part(call, span, tool_kinds) {
-  const name = kind_of(call, tool_kinds);
-  if (name === void 0) return [];
-  const from_ms = Math.max(call.started_ms, span.from_ms);
-  const ms = Math.min(end_ms2(call), span.to_ms) - from_ms;
-  const is_counted = call.duration_ms !== void 0 || is_untimed_subagent(call);
-  return is_counted ? [{ name, ms, from_ms, call }] : [];
-}
-function untimed_of(placed) {
-  const counts = /* @__PURE__ */ new Map();
-  const kinds = placed.filter(([call]) => is_untimed_subagent(call)).map(([call]) => kind_of(call, TOOL_KINDS));
-  for (const kind of kinds) if (kind !== void 0) counts.set(kind, (counts.get(kind) ?? 0) + 1);
-  return counts;
-}
-function remainder_ms(parts, spans, waits) {
-  const busy = parts.map((part) => ({ from_ms: part.from_ms, to_ms: part.from_ms + part.ms }));
-  const covering = [...busy, ...waits];
-  const idle = spans.map(
-    (span) => span.to_ms - span.from_ms - lane_breakdown.covered_ms(span, covering)
-  );
-  return idle.reduce((sum, ms) => sum + ms, 0);
-}
-function span_of(call, spans) {
-  return spans.find((span) => call.started_ms >= span.from_ms && call.started_ms < span.to_ms);
-}
-function placed_of(calls, spans) {
-  return calls.flatMap((call) => {
-    const span = span_of(call, spans);
-    return span === void 0 ? [] : [[call, span]];
-  });
-}
-function is_overlapping(call, span) {
-  return call.started_ms < span.to_ms && Math.max(call.started_ms + 1, end_ms2(call)) > span.from_ms;
-}
-function overlapping_of(calls, spans) {
-  return spans.flatMap(
-    (span) => calls.filter((call) => is_overlapping(call, span)).map((call) => [call, span])
-  );
-}
-function of(calls, breakdown) {
-  const placed = placed_of(calls, breakdown.implement);
-  const parts = placed.flatMap(([call, span]) => timed_part(call, span, TOOL_KINDS));
-  const remainder = {
-    name: REMAINDER,
-    ms: remainder_ms(parts, breakdown.implement, breakdown.waits)
-  };
-  return {
-    kinds: lane_breakdown.ranked([...parts, remainder]),
-    background: placed.filter(([call]) => call.background).length,
-    untimed: untimed_of(placed),
-    calls: lane_breakdown_calls.by_kind(parts)
-  };
-}
-function plan_parts(calls, breakdown) {
-  const placed = placed_of(calls, breakdown.plan ?? []);
-  return placed.flatMap(([call, span]) => timed_part(call, span, TOOL_KINDS));
-}
-function plan_calls(calls, breakdown) {
-  const timed = plan_parts(calls, breakdown);
-  return lane_breakdown_calls.with_lint_detail(lane_breakdown_calls.top_of(timed), timed);
-}
-function plan_outside(calls, breakdown) {
-  if (calls.length === 0) return void 0;
-  const spans = breakdown.plan ?? [];
-  return {
-    ms: remainder_ms(plan_parts(calls, breakdown), spans, breakdown.waits),
-    background: placed_of(calls, spans).filter(([call]) => call.background).length
-  };
-}
-function between_kinds(calls, spans, waits) {
-  if (calls.length === 0) return [];
-  const timed = calls.filter((call) => !is_untimed_subagent(call));
-  const placed = overlapping_of(timed, spans);
-  const parts = placed.flatMap(([call, span]) => timed_part(call, span, BETWEEN_TOOL_KINDS));
-  const remainder = { name: REMAINDER, ms: remainder_ms(parts, spans, waits) };
-  return lane_breakdown.ranked(remainder.ms > 0 ? [...parts, remainder] : parts);
-}
-function transcript_directories(issue) {
-  const main_cwd = cost_transcript.session_cwd(process.cwd());
-  const home = cost_transcript.home_directory();
-  const suffix = `-${String(issue)}`;
-  return cost_transcript.lane_transcript_directories(main_cwd, home).filter((directory) => directory.endsWith(suffix));
-}
-function read(issue, breakdown) {
-  const [first] = [...breakdown.plan ?? [], ...breakdown.implement];
-  const last = breakdown.ship.at(-1) ?? breakdown.implement.at(-1);
-  if (first === void 0 || last === void 0) return [];
-  const window = { since_ms: first.from_ms, until_ms: last.to_ms };
-  return lane_transcript_stats.read_calls(transcript_directories(issue), window);
-}
-function first_edit_ms(calls, span) {
-  const edits = calls.filter((call) => EDIT_TOOLS2.has(call.tool ?? "") && span_of(call, [span]) !== void 0).map((call) => call.started_ms);
-  return edits.length === 0 ? void 0 : Math.min(...edits);
-}
-function breakdown_of(entries, events, issue) {
-  const span = lane_net_time.span_of(entries, issue);
-  if (span === void 0) return void 0;
-  const window = { since_ms: span.from_ms, until_ms: span.to_ms };
-  const calls = lane_transcript_stats.read_calls(transcript_directories(issue), window);
-  return lane_breakdown.of(entries, events, issue, first_edit_ms(calls, span));
-}
-var lane_breakdown_implement = {
-  between_kinds,
-  breakdown_of,
-  first_edit_ms,
-  of,
-  plan_calls,
-  plan_outside,
-  read,
-  transcript_directories
-};
-
-export {
-  lane_breakdown_calls,
-  lane_paused_spans,
-  lane_transcript_calls,
-  lane_transcript_stats,
-  lane_implement_stats,
-  lane_breakdown_implement
-};