@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-A3JYZWBS.js

@@ -0,0 +1,803 @@
+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
+};