@joshuafolkken/kit 1.3000.0 → 1.3041.0

package/dist/hooks/{chunk-CICKRHTB.js → chunk-AO4TOV4V.js}

@@ -4,38 +4,21 @@ import {
   OPTIONAL_ENV_FILE_FLAGS,
   PACKAGE_JSON,
   ancestor_directories,
-  canonical_command,
-  cost_blocks,
-  figure_format,
-  issue_cite,
-  josh_environment_file,
-  lane_reap,
+  josh_verdict,
   lane_state_record,
   ports,
-  pr_raw_schema,
   process_owner_schema,
-  run_event_stream,
-  run_event_stream_emit,
-  session_language,
-  time_josh_names,
-  time_shell,
-  transcript_record,
-  transcript_tail
-} from "./chunk-NUPVO7RI.js";
+  session_language
+} from "./chunk-G5WSPYJ6.js";
 import {
   git_directory
 } from "./chunk-LRD2ERRI.js";
 import {
-  cost_transcript,
-  file_reader,
   issue_number_shape,
-  lane_ledger_write,
   lane_paths,
-  process_identity,
-  time_instant
+  process_identity
 } from "./chunk-FOW4B7OQ.js";
 import {
-  MS_PER_SECOND,
   PLATFORM_TEMP_ROOT,
   durable_state_root,
   external_exports,
@@ -44,2561 +27,10 @@ import {
   stamp_file
 } from "./chunk-CY3ADSDR.js";
 
-// scripts/hooks/hook-context.ts
-function from_process() {
-  return { cwd: process.cwd(), env: process.env, ancestry: lane_reap.own_ancestry };
-}
-var hook_context = { from_process };
-
-// scripts/time-runtime/time-hook-transcript.ts
-import path from "node:path";
-var { TRANSCRIPT_EXTENSION } = cost_transcript;
-var AGENT_PREFIX = "agent-";
-var AGENT_ID_PATTERN = /^[\w-]+$/u;
-function is_agent_id(value2) {
-  return typeof value2 === "string" && AGENT_ID_PATTERN.test(value2);
-}
-function fork_path(transcript_path, agent_id) {
-  const directory = path.dirname(transcript_path);
-  const session_id = path.basename(transcript_path, TRANSCRIPT_EXTENSION);
-  const file_name = `${AGENT_PREFIX}${agent_id}${TRANSCRIPT_EXTENSION}`;
-  return path.join(cost_transcript.unit_directory(directory, session_id), file_name);
-}
-function transcript_of(transcript_path, agent_id) {
-  if (!is_agent_id(agent_id) || !transcript_path.endsWith(TRANSCRIPT_EXTENSION)) {
-    return transcript_path;
-  }
-  return fork_path(transcript_path, agent_id);
-}
-var time_hook_transcript = {
-  fork_path,
-  transcript_of
-};
-
-// scripts/josh/hook-payload-capture.ts
-import { mkdirSync, readdirSync, writeFileSync } from "node:fs";
-import path2 from "node:path";
-var CAPTURE_DIR_KEY = "JOSH_HOOK_CAPTURE_DIR";
-var NO_TOOL = "none";
-var FILE_EXTENSION = ".json";
-var UNSAFE_NAME_CHARACTERS = /[^\w.-]/gu;
-var MAX_ATTEMPTS = 32;
-var tool_schema = external_exports.looseObject({ tool_name: external_exports.string().min(1) });
-function safe_name(name) {
-  return name.replaceAll(UNSAFE_NAME_CHARACTERS, "-");
-}
-function tool_label(raw_payload) {
-  return safe_name(json_value.parse_with(raw_payload, tool_schema)?.tool_name ?? NO_TOOL);
-}
-function write_new(file, raw_payload) {
-  try {
-    writeFileSync(file, raw_payload, { flag: "wx" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function write_capture(directory, hook, raw_payload) {
-  const prefix2 = `${safe_name(hook)}-${tool_label(raw_payload)}-`;
-  const first = readdirSync(directory).filter((name) => name.startsWith(prefix2)).length + 1;
-  for (let index = first; index < first + MAX_ATTEMPTS; index += 1) {
-    const file = path2.join(directory, `${prefix2}${String(index)}${FILE_EXTENSION}`);
-    if (write_new(file, raw_payload)) return file;
-  }
-  return void 0;
-}
-function capture(hook, raw_payload, environment = process.env) {
-  const directory = environment[CAPTURE_DIR_KEY];
-  if (directory === void 0 || directory === "") return void 0;
-  try {
-    mkdirSync(directory, { recursive: true });
-    return write_capture(directory, hook, raw_payload);
-  } catch {
-    return void 0;
-  }
-}
-var hook_payload_capture = { CAPTURE_DIR_KEY, capture };
-
-// scripts/josh/hook-decision.ts
-import { text } from "node:stream/consumers";
-
-// scripts/josh/hook-envelope.ts
-var HOOK_EVENT_NAME = "PreToolUse";
-var DENY_DECISION = "deny";
-var ALLOW_DECISION = "allow";
-function deny_envelope(reason) {
-  return JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: HOOK_EVENT_NAME,
-      permissionDecision: DENY_DECISION,
-      permissionDecisionReason: reason
-    }
-  });
-}
-function rewrite_envelope(updated_input, context) {
-  return JSON.stringify({
-    systemMessage: context,
-    hookSpecificOutput: {
-      hookEventName: HOOK_EVENT_NAME,
-      permissionDecision: ALLOW_DECISION,
-      updatedInput: updated_input,
-      additionalContext: context
-    }
-  });
-}
-function flow_rewrite_envelope(updated_input, context) {
-  return JSON.stringify({
-    systemMessage: context,
-    hookSpecificOutput: {
-      hookEventName: HOOK_EVENT_NAME,
-      updatedInput: updated_input,
-      additionalContext: context
-    }
-  });
-}
-function notice_envelope(notice) {
-  return JSON.stringify({
-    systemMessage: notice,
-    hookSpecificOutput: { hookEventName: HOOK_EVENT_NAME, additionalContext: notice }
-  });
-}
-var hook_envelope = { deny_envelope, flow_rewrite_envelope, notice_envelope, rewrite_envelope };
-
-// scripts/josh/hook-tool-payload.ts
-var schema = external_exports.object({
-  tool_name: external_exports.string().min(1),
-  tool_input: external_exports.unknown()
-});
-function parse(raw_payload) {
-  return json_value.parse_with(raw_payload, schema);
-}
-var hook_tool_payload = { parse, schema };
-
-// scripts/josh/hook-decision.ts
-var payload_schema = hook_tool_payload.schema.extend({
-  transcript_path: external_exports.string().min(1),
-  // **`nullish`, not `optional`.** A payload spelling the absent agent as `null` has to read as "no
-  // fork"; rejected, it would fail `safeParse` for the whole payload and take the guard off every
-  // call of the main line, in silence — the failure every other path here is written to avoid.
-  agent_id: external_exports.string().nullish(),
-  // The session's model where the harness hands it over (a Codex payload); Claude Code names it on
-  // the transcript's assistant entries instead (`scripts/rules/main-model.ts`).
-  model: external_exports.string().nullish()
-});
-var refusal_schema = external_exports.object({ refused_at_ms: external_exports.number() });
-var NEVER_MS = 0;
-var DISABLED_VALUES = ["off", "0", "false", "no"];
-function is_switch_enabled(key2, environment = process.env) {
-  return !DISABLED_VALUES.includes((environment[key2] ?? "").trim().toLowerCase());
-}
-var ENABLED_VALUES = ["on", "1", "true", "yes"];
-function is_switch_opt_in(key2) {
-  return ENABLED_VALUES.includes((process.env[key2] ?? "").trim().toLowerCase());
-}
-function parse_hook_payload(raw_payload) {
-  return json_value.parse_with(raw_payload, payload_schema);
-}
-var { deny_envelope: deny_envelope2, flow_rewrite_envelope: flow_rewrite_envelope2, notice_envelope: notice_envelope2, rewrite_envelope: rewrite_envelope2 } = hook_envelope;
-function stamp_fault(switch_key) {
-  return `\u26A0 ${switch_key}: the run is past the limit but the refusal stamp could not be written, so this call was allowed rather than refused. Without the stamp a refusal could repeat and wedge the run. Batch the calls that do not need each other anyway, and check the temp directory is writable.`;
-}
-function error_text(error) {
-  if (error instanceof Error) return error.message;
-  return typeof error === "string" ? error : "a value that is not an error";
-}
-function fault_notice(switch_key, error) {
-  if (file_reader.is_absent(error)) return void 0;
-  const detail = error_text(error);
-  return `\u26A0 ${switch_key}: the guard could not read the run's history, so this call was allowed without being checked \u2014 silence here is not evidence that the run is batching. Cause: ${detail}`;
-}
-function last_refusal_ms(target) {
-  const raw = stamp_file.read_stamp_text(target);
-  if (raw === void 0) return NEVER_MS;
-  return json_value.parse_with(raw, refusal_schema)?.refused_at_ms ?? NEVER_MS;
-}
-function record_refusal(target, now_ms) {
-  try {
-    stamp_file.write_stamp(target, { refused_at_ms: now_ms });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function create_refusal_stamp(prefix2) {
-  function path6(transcript_path) {
-    return stamp_file.stamp_path(prefix2, transcript_path);
-  }
-  return { path: path6, last_ms: last_refusal_ms, record: record_refusal };
-}
-var { load_environment_file } = josh_environment_file;
-var NO_OUTCOME = { reason: void 0, notice: void 0, fault: void 0 };
-function fire_once(stamp, run, should_fire, switch_key) {
-  const target = stamp.path(run.transcript);
-  if (!should_fire(stamp.last_ms(target))) return { fired: false, fault: void 0 };
-  if (!stamp.record(target, run.now_ms)) return { fired: false, fault: stamp_fault(switch_key) };
-  return { fired: true, fault: void 0 };
-}
-function block_outcome(context) {
-  const { spec, stamp, tail, call, run } = context;
-  const result = fire_once(
-    stamp,
-    run,
-    (last_fired_ms) => spec.should_block(tail, call, last_fired_ms, run),
-    spec.switch_key
-  );
-  if (result.fired) return { reason: spec.reason, notice: void 0, fault: void 0 };
-  return { reason: void 0, notice: void 0, fault: result.fault };
-}
-function notify_outcome(context) {
-  const { spec, notify_stamp, tail, call, run } = context;
-  if (notify_stamp === void 0 || spec.notify === void 0) return NO_OUTCOME;
-  const { notify } = spec;
-  const result = fire_once(
-    notify_stamp,
-    run,
-    (last_fired_ms) => notify.should_notify(tail, call, last_fired_ms, run),
-    spec.switch_key
-  );
-  if (result.fired) return { reason: void 0, notice: notify.text(call, tail), fault: void 0 };
-  return { reason: void 0, notice: void 0, fault: result.fault };
-}
-function is_clear(outcome) {
-  return outcome.reason === void 0 && outcome.notice === void 0 && outcome.fault === void 0;
-}
-function guard_reason_for_payload(parts, payload, now_ms, hook) {
-  const call = { name: payload.tool_name, input: payload.tool_input };
-  if (!parts.spec.is_candidate(call, hook)) return NO_OUTCOME;
-  const transcript = time_hook_transcript.transcript_of(payload.transcript_path, payload.agent_id);
-  const tail = transcript_tail.read_tail(transcript);
-  const is_unit = typeof payload.agent_id === "string" && payload.agent_id.length > 0;
-  const run = { transcript, now_ms, model: payload.model ?? void 0, is_unit, context: hook };
-  const context = { ...parts, tail, call, run };
-  const blocked = block_outcome(context);
-  if (!is_clear(blocked)) return blocked;
-  return notify_outcome(context);
-}
-function guard_outcome(parts, raw_payload, now_ms, hook) {
-  const payload = parse_hook_payload(raw_payload);
-  if (payload === void 0 || !is_switch_enabled(parts.spec.switch_key, hook.env)) {
-    return NO_OUTCOME;
-  }
-  return guard_reason_for_payload(parts, payload, now_ms, hook);
-}
-function create_transcript_guard(spec) {
-  const stamp = create_refusal_stamp(spec.prefix);
-  const notify_stamp = spec.notify ? create_refusal_stamp(spec.notify.prefix) : void 0;
-  const parts = { spec, stamp, notify_stamp };
-  function is_enabled(environment = process.env) {
-    return is_switch_enabled(spec.switch_key, environment);
-  }
-  function outcome(raw_payload, now_ms = Date.now(), hook = hook_context.from_process()) {
-    try {
-      return guard_outcome(parts, raw_payload, now_ms, hook);
-    } catch (error) {
-      return { reason: void 0, notice: void 0, fault: fault_notice(spec.switch_key, error) };
-    }
-  }
-  function refusal(...call) {
-    return outcome(...call).reason;
-  }
-  return { is_enabled, outcome, refusal, refusal_path: stamp.path };
-}
-function emit_outcome(outcome) {
-  const { reason, notice, fault } = outcome;
-  if (reason !== void 0) process.stdout.write(`${deny_envelope2(reason)}
-`);
-  else if (notice !== void 0) process.stdout.write(`${notice_envelope2(notice)}
-`);
-  else if (fault !== void 0) process.stdout.write(`${notice_envelope2(fault)}
-`);
-}
-function report_no_payload(command) {
-  process.stderr.write(
-    `${command} reads a Claude Code hook payload on stdin; it is not run by hand.
-`
-  );
-}
-async function respond_from_stdin(command, respond) {
-  if (process.stdin.isTTY) {
-    report_no_payload(command);
-    return;
-  }
-  const raw_payload = await text(process.stdin);
-  load_environment_file();
-  hook_payload_capture.capture(command, raw_payload);
-  await respond(raw_payload);
-}
-var hook_decision = {
-  DISABLED_VALUES,
-  ENABLED_VALUES,
-  NEVER_MS,
-  create_refusal_stamp,
-  create_transcript_guard,
-  deny_envelope: deny_envelope2,
-  emit_outcome,
-  flow_rewrite_envelope: flow_rewrite_envelope2,
-  is_switch_enabled,
-  is_switch_opt_in,
-  load_environment_file,
-  notice_envelope: notice_envelope2,
-  parse_hook_payload,
-  respond_from_stdin,
-  rewrite_envelope: rewrite_envelope2,
-  stamp_fault
-};
-
-// scripts/lib/status-icons.ts
-var FAIL_ICON = "\u2717";
-var PASS_ICON = "\u2714";
-var WARN_ICON = "\u26A0";
-var status_icons = { FAIL_ICON, PASS_ICON, WARN_ICON };
-
-// scripts/josh/josh-verdict.ts
-var { FAIL_ICON: FAIL_ICON2, PASS_ICON: PASS_ICON2, WARN_ICON: WARN_ICON2 } = status_icons;
-var GATE_SUBJECT = "verification gate";
-var GATE_PASSED_PREFIX = `${PASS_ICON2} ${GATE_SUBJECT} passed`;
-var GATE_FAILED_PREFIX = `${FAIL_ICON2} ${GATE_SUBJECT} failed`;
-var GATE_UNVERIFIED_PREFIX = `${WARN_ICON2} ${GATE_SUBJECT} not verified`;
-var PASSED_VERDICT = "passed";
-var FAILED_VERDICT = "failed";
-var UNVERIFIED_VERDICT = "unverified";
-function format_counts(counts) {
-  if (counts.skipped === 0) return `${String(counts.ran)} checks`;
-  return `${String(counts.ran)} ran, ${String(counts.skipped)} skipped`;
-}
-function format_gate_passed(counts, total) {
-  return `${GATE_PASSED_PREFIX} (${format_counts(counts)}) in ${total}.`;
-}
-function format_gate_unverified(skipped, total) {
-  return `${GATE_UNVERIFIED_PREFIX} (0 ran, ${String(skipped)} skipped) in ${total}.`;
-}
-function format_gate_failed(failed_labels, total) {
-  return `${GATE_FAILED_PREFIX}: ${failed_labels} (${total})`;
-}
-var GATE_OPENING_PREFIX = "plan: ";
-var GATE_OPENING_MARK = " checks at once";
-function is_gate_opening(line2) {
-  const trimmed = line2.trimStart();
-  return trimmed.startsWith(GATE_OPENING_PREFIX) && trimmed.includes(GATE_OPENING_MARK);
-}
-function read_verdict(line2) {
-  const trimmed = line2.trimStart();
-  if (trimmed.startsWith(GATE_FAILED_PREFIX)) return FAILED_VERDICT;
-  if (trimmed.startsWith(GATE_PASSED_PREFIX)) return PASSED_VERDICT;
-  if (trimmed.startsWith(GATE_UNVERIFIED_PREFIX)) return UNVERIFIED_VERDICT;
-  return void 0;
-}
-var josh_verdict = {
-  PASSED_VERDICT,
-  FAILED_VERDICT,
-  UNVERIFIED_VERDICT,
-  format_gate_passed,
-  format_gate_failed,
-  format_gate_unverified,
-  GATE_OPENING_MARK,
-  GATE_OPENING_PREFIX,
-  is_gate_opening,
-  read_verdict
-};
-
-// scripts/time-runtime/time-reported-failure.ts
-var TEXT_BLOCK_SCHEMA = external_exports.object({ text: external_exports.string().nullish() });
-var CONTENT_SCHEMA = external_exports.union([external_exports.string(), external_exports.array(external_exports.unknown())]);
-var LINE_SEPARATOR = "\n";
-function block_text(block) {
-  const parsed = TEXT_BLOCK_SCHEMA.safeParse(block);
-  return parsed.success ? parsed.data.text ?? "" : "";
-}
-function result_text(content) {
-  const parsed = CONTENT_SCHEMA.safeParse(content);
-  if (!parsed.success) return "";
-  if (typeof parsed.data === "string") return parsed.data;
-  return parsed.data.map((block) => block_text(block)).join(LINE_SEPARATOR);
-}
-function is_failure_line(line2) {
-  return line2.trimStart().startsWith(status_icons.FAIL_ICON);
-}
-function is_failed_verdict(line2) {
-  return josh_verdict.read_verdict(line2) === josh_verdict.FAILED_VERDICT;
-}
-var GREEN_VERDICTS = /* @__PURE__ */ new Set([
-  josh_verdict.PASSED_VERDICT,
-  josh_verdict.UNVERIFIED_VERDICT
-]);
-function is_green_verdict(line2) {
-  return GREEN_VERDICTS.has(josh_verdict.read_verdict(line2));
-}
-function new_scan() {
-  return {
-    did_find: false,
-    has_failure_before_region: false,
-    has_failure_in_region: false,
-    is_region_open: false
-  };
-}
-function close_region(scan) {
-  scan.did_find ||= scan.is_region_open && scan.has_failure_before_region;
-  scan.has_failure_before_region = false;
-  scan.has_failure_in_region = false;
-  scan.is_region_open = false;
-}
-function note_failure(scan) {
-  if (scan.is_region_open) {
-    scan.has_failure_in_region = true;
-    return;
-  }
-  scan.has_failure_before_region = true;
-}
-function scan_line(scan, line2) {
-  if (is_green_verdict(line2)) {
-    close_region(scan);
-    return;
-  }
-  if (is_failure_line(line2)) {
-    note_failure(scan);
-    return;
-  }
-  if (josh_verdict.is_gate_opening(line2)) scan.is_region_open = true;
-}
-function scan_body(lines) {
-  const scan = new_scan();
-  for (const line2 of lines) scan_line(scan, line2);
-  return scan;
-}
-function did_scan_find(scan) {
-  return scan.did_find || scan.has_failure_before_region || scan.has_failure_in_region;
-}
-function has_failure_line(content) {
-  const lines = result_text(content).split(LINE_SEPARATOR);
-  if (lines.some((line2) => is_failed_verdict(line2))) return true;
-  return did_scan_find(scan_body(lines));
-}
-function is_reported_failure(josh_command, did_print_failure) {
-  return josh_command !== "" && did_print_failure;
-}
-var time_reported_failure = { result_text, has_failure_line, is_reported_failure };
-
-// scripts/time-runtime/time-phase-names.ts
-var GATE_PHASE = "gate";
-var PR_PHASE = "pr";
-var MERGE_PHASE = "merge";
-var GATE_COMMAND2 = "josh gate";
-var COMMAND_PHASES = /* @__PURE__ */ new Map([
-  [GATE_COMMAND2, GATE_PHASE],
-  ["josh git", PR_PHASE],
-  ["josh pr", PR_PHASE],
-  ["josh followup", MERGE_PHASE]
-]);
-
-// scripts/time-runtime/time-background.ts
-var NO_BACKGROUND = "";
-var NO_FINISH = 0;
-var LAUNCH_PATTERN = /(?:running in background with ID:|moved to the background \(ID:)\s*([\w-]+)/iu;
-var AGENT_LAUNCH_PATTERN = /^(?:Async agent launched[\s\S]*?\bagentId:\s*|\{"success":[^\n]*?"resumedAgentId":")([\w-]+)/u;
-var FINISH_PATTERN = /^<task-notification>[\s\S]*?<task-id>([\w-]+)<\/task-id>/u;
-var STOP_PATTERN = /^\{"message":"Successfully stopped task:\s*([\w-]+)/u;
-var OUTPUT_PATTERN = /tasks\/([\w-]+)\.output/u;
-var BASH_ID_KEY = "bash_id";
-function read_id(command) {
-  return OUTPUT_PATTERN.exec(time_shell.unquoted(command))?.[1] ?? NO_BACKGROUND;
-}
-function read_id_of(input) {
-  if (!json_value.is_record(input)) return NO_BACKGROUND;
-  const id = input[BASH_ID_KEY];
-  return typeof id === "string" ? id : read_id(time_shell.bash_command(input));
-}
-function launch_id(text2) {
-  return LAUNCH_PATTERN.exec(text2)?.[1] ?? NO_BACKGROUND;
-}
-function agent_launch_id(text2) {
-  return AGENT_LAUNCH_PATTERN.exec(text2)?.[1] ?? NO_BACKGROUND;
-}
-function finished_id(text2) {
-  return FINISH_PATTERN.exec(text2)?.[1] ?? NO_BACKGROUND;
-}
-function stopped_id(text2) {
-  return STOP_PATTERN.exec(text2)?.[1] ?? NO_BACKGROUND;
-}
-function finished_at(lines) {
-  const notices = lines.filter((one) => one.finished_background !== NO_BACKGROUND).toSorted((left, right) => right.timestamp_ms - left.timestamp_ms);
-  return new Map(notices.map((one) => [one.finished_background, one.timestamp_ms]));
-}
-function started_ms(span) {
-  return span.ended_ms - span.duration_ms;
-}
-function read_end_ms(spans, run) {
-  if (run.background_ended_ms === NO_FINISH) return void 0;
-  const found = spans.find(
-    (span) => span.reads_background === run.background_id && span.ended_ms >= run.background_ended_ms
-  );
-  return found?.ended_ms;
-}
-function to_run(spans, launch) {
-  const read = read_end_ms(spans, launch);
-  return {
-    id: launch.background_id,
-    josh_command: launch.josh_command,
-    started_ms: started_ms(launch),
-    ended_ms: read ?? launch.ended_ms,
-    is_read: read !== void 0
-  };
-}
-function is_launch(span) {
-  return span.background_id !== NO_BACKGROUND;
-}
-function runs(spans) {
-  return spans.filter((span) => is_launch(span)).map((launch) => to_run(spans, launch));
-}
-function is_within(span, run) {
-  const start = started_ms(span);
-  return start >= run.started_ms && start < run.ended_ms;
-}
-function latest_first(all2) {
-  return all2.filter((run) => run.is_read).toSorted((left, right) => right.started_ms - left.started_ms);
-}
-function own_run(span, all2) {
-  return is_launch(span) ? all2.find((run) => run.id === span.background_id) : void 0;
-}
-function placed(span, all2, ordered) {
-  const own = own_run(span, all2);
-  const run = own ?? ordered.find((one) => is_within(span, one));
-  if (run === void 0) return span;
-  const beside = { ...span, background_command: run.josh_command };
-  return own === void 0 ? beside : { ...beside, own_duration_ms: own.ended_ms - own.started_ms };
-}
-function positioned(spans) {
-  const all2 = runs(spans);
-  if (all2.length === 0) return [...spans];
-  const ordered = latest_first(all2);
-  return spans.map((span) => placed(span, all2, ordered));
-}
-function unread_phases(spans) {
-  const names = runs(spans).filter((run) => !run.is_read).map((run) => COMMAND_PHASES.get(run.josh_command));
-  return new Set(names.filter((phase) => phase !== void 0));
-}
-var time_background = {
-  NO_BACKGROUND,
-  NO_FINISH,
-  launch_id,
-  agent_launch_id,
-  finished_id,
-  stopped_id,
-  finished_at,
-  read_id,
-  read_id_of,
-  runs,
-  positioned,
-  unread_phases
-};
-
-// scripts/gh/git-pr-checks-parse.ts
-var CHECK_STATUS_PASS = "pass";
-var CHECK_STATUS_PENDING = "pending";
-var CHECK_STATUS_FAIL = "fail";
-var CHECK_STATUS_MISSING = "missing";
-var PASSING_CONCLUSIONS = /* @__PURE__ */ new Set(["success", "skipped", "neutral"]);
-var KEY_TYPE_NAME = "__typename";
-var KEY_STATE = "state";
-var KEY_STATUS = "status";
-var KEY_CONCLUSION = "conclusion";
-var KEY_NAME = "name";
-var KEY_CONTEXT = "context";
-var KEY_DESCRIPTION = "description";
-function read_string(value2) {
-  if (typeof value2 !== "string") return void 0;
-  const trimmed = value2.trim();
-  if (trimmed.length === 0) return void 0;
-  return trimmed;
-}
-var PENDING_STATUS_STATES = /* @__PURE__ */ new Set(["pending", "expected"]);
-function parse_status_context(item) {
-  const state = read_string(item[KEY_STATE])?.toLowerCase();
-  if (state === "success") return CHECK_STATUS_PASS;
-  if (state !== void 0 && PENDING_STATUS_STATES.has(state)) return CHECK_STATUS_PENDING;
-  return CHECK_STATUS_FAIL;
-}
-function is_passing_conclusion(item) {
-  const conclusion = read_string(item[KEY_CONCLUSION])?.toLowerCase();
-  return conclusion !== void 0 && PASSING_CONCLUSIONS.has(conclusion);
-}
-function parse_check_run(item) {
-  const status = read_string(item[KEY_STATUS])?.toLowerCase();
-  if (status !== "completed") return CHECK_STATUS_PENDING;
-  return is_passing_conclusion(item) ? CHECK_STATUS_PASS : CHECK_STATUS_FAIL;
-}
-function parse_rollup_status(item) {
-  const type_name = read_string(item[KEY_TYPE_NAME]);
-  if (type_name === "StatusContext") return parse_status_context(item);
-  return parse_check_run(item);
-}
-function read_rollup_array(parsed) {
-  const result = pr_raw_schema.safeParse(parsed);
-  if (!result.success) return [];
-  return result.data.statusCheckRollup ?? [];
-}
-function parse_rollup_item(item) {
-  const name = read_string(item[KEY_NAME]) ?? read_string(item[KEY_CONTEXT]);
-  if (name === void 0) return void 0;
-  const check = { name, status: parse_rollup_status(item) };
-  const description = read_string(item[KEY_DESCRIPTION]);
-  return description === void 0 ? check : { ...check, description };
-}
-function parse_rollup_checks(raw_json) {
-  const parsed = json_value.parse_or_undefined(raw_json);
-  const rollup = read_rollup_array(parsed);
-  const checks = [];
-  for (const item of rollup) {
-    const parsed_item = parse_rollup_item(item);
-    if (parsed_item !== void 0) checks.push(parsed_item);
-  }
-  return checks;
-}
-function with_head_sha(snapshot, head_sha) {
-  return head_sha === void 0 ? snapshot : { ...snapshot, head_sha };
-}
-function with_required_contexts(snapshot, required_contexts) {
-  if (required_contexts === void 0 || required_contexts.length === 0) return snapshot;
-  return { ...snapshot, required_contexts };
-}
-function read_pr_raw_data(raw_json) {
-  const result = pr_raw_schema.safeParse(json_value.parse_or_undefined(raw_json));
-  return result.success ? result.data : {};
-}
-function parse_pr_state_snapshot(raw_json) {
-  const data = read_pr_raw_data(raw_json);
-  const snapshot = {
-    rollup: parse_rollup_checks(raw_json),
-    merge_state_status: read_string(data.mergeStateStatus),
-    review_decision: read_string(data.reviewDecision),
-    ...data.merged === true && { is_merged: true }
-  };
-  return with_required_contexts(
-    with_head_sha(snapshot, read_string(data.headRefOid)),
-    data.requiredContexts
-  );
-}
-
-// scripts/gh/git-pr-checks-missing.ts
-var MISSING_GRACE_MS = 12e4;
-var CHECK_SUITE_SEPARATOR = " / ";
-var MERGE_STATE_CLEAN = "CLEAN";
-function is_required_match(check_name, required_name) {
-  if (check_name === required_name) return true;
-  return check_name.startsWith(`${required_name}${CHECK_SUITE_SEPARATOR}`);
-}
-function is_settled(rollup) {
-  return rollup.length > 0 && rollup.every((check) => check.status !== CHECK_STATUS_PENDING);
-}
-var first_absent_at = /* @__PURE__ */ new Map();
-function absence_key(snapshot, context) {
-  return `${snapshot.head_sha ?? ""} ${context}`;
-}
-function has_outlasted_grace(key2, now) {
-  const first = first_absent_at.get(key2);
-  if (first !== void 0) return now - first >= MISSING_GRACE_MS;
-  first_absent_at.set(key2, now);
-  return false;
-}
-function absent_from(rollup, required) {
-  return required.filter(
-    (context) => rollup.every((check) => !is_required_match(check.name, context))
-  );
-}
-function collect_absent_contexts(snapshot) {
-  if (snapshot.merge_state_status === MERGE_STATE_CLEAN || !is_settled(snapshot.rollup)) return [];
-  return absent_from(snapshot.rollup, snapshot.required_contexts ?? []);
-}
-function forget_present_contexts(snapshot, absent) {
-  const present = (snapshot.required_contexts ?? []).filter((context) => !absent.includes(context));
-  for (const context of present) first_absent_at.delete(absence_key(snapshot, context));
-}
-function collect_missing_contexts(snapshot) {
-  const absent = collect_absent_contexts(snapshot);
-  forget_present_contexts(snapshot, absent);
-  const now = Date.now();
-  return absent.filter((context) => has_outlasted_grace(absence_key(snapshot, context), now));
-}
-function describe_missing_context(context) {
-  return `required context ${context} has no check-run`;
-}
-var MissingContextError = class extends Error {
-  name = "MissingContextError";
-  missing;
-  constructor(message, options) {
-    super(message, options);
-    this.missing = options.missing;
-  }
-};
-function missing_context_error(message, snapshot) {
-  const contexts = collect_missing_contexts(snapshot);
-  if (contexts.length === 0 || snapshot.head_sha === void 0) return void 0;
-  return new MissingContextError(message, { missing: { contexts, head_sha: snapshot.head_sha } });
-}
-var BLOCKED_LEAD = "BLOCKED: ";
-var MERGE_STATE_LEAD = "mergeStateStatus: ";
-function absent_required(snapshot, required_checks) {
-  const required = [.../* @__PURE__ */ new Set([...required_checks, ...snapshot.required_contexts ?? []])];
-  return absent_from(snapshot.rollup, required);
-}
-function blocked_cause(snapshot, required_checks) {
-  const absent = absent_required(snapshot, required_checks);
-  if (absent.length > 0) return `${BLOCKED_LEAD}${absent.join(", ")} missing`;
-  if (snapshot.merge_state_status === void 0) return void 0;
-  return `${MERGE_STATE_LEAD}${snapshot.merge_state_status}`;
-}
-
-// scripts/gh/git-pr-checks-eval.ts
-var DEFAULT_REQUIRED_CHECKS = ["SonarQube"];
-var CODERABBIT_CHECK_NAME = "CodeRabbit";
-var REQUIRED_CHECKS_ENV_VAR = "JOSH_REQUIRED_CHECKS";
-function parse_required_checks() {
-  const raw = process.env[REQUIRED_CHECKS_ENV_VAR];
-  if (!raw) return DEFAULT_REQUIRED_CHECKS;
-  return raw.split(",").map((check) => check.trim()).filter((check) => check.length > 0);
-}
-var REQUIRED_CHECKS = parse_required_checks();
-var MERGE_STATE_CLEAN2 = "CLEAN";
-var MERGE_STATE_UNSTABLE = "UNSTABLE";
-var MERGE_STATE_DIRTY = "DIRTY";
-var REVIEW_CHANGES_REQUESTED = "CHANGES_REQUESTED";
-var FAILURE_MESSAGE_PREFIX = "PR checks failed";
-var FAILURE_REASON_REVIEW = "review requested changes";
-var FAILURE_REASON_CHECKS = "failed checks";
-var FAILURE_REASON_CONFLICT = "merge conflict";
-function find_required_check(checks, required_name) {
-  return checks.find((check) => is_required_match(check.name, required_name));
-}
-function read_required_statuses(checks) {
-  return REQUIRED_CHECKS.map(
-    (name) => find_required_check(checks, name)?.status ?? CHECK_STATUS_MISSING
-  );
-}
-function is_review_blocked(review_decision) {
-  return review_decision === REVIEW_CHANGES_REQUESTED;
-}
-function is_merge_conflict(merge_state_status) {
-  return merge_state_status === MERGE_STATE_DIRTY;
-}
-function evaluate_failure_state(input) {
-  if (is_merge_conflict(input.merge_state_status) || is_review_blocked(input.review_decision) || input.failed_checks.length > 0) {
-    return "failure";
-  }
-  return void 0;
-}
-function is_merge_state_clean(merge_state_status) {
-  return merge_state_status === MERGE_STATE_CLEAN2;
-}
-function is_every_required_passing(statuses) {
-  return statuses.every((status) => status === CHECK_STATUS_PASS);
-}
-function is_coderabbit_check(check_name) {
-  return is_required_match(check_name, CODERABBIT_CHECK_NAME);
-}
-var CODERABBIT_RATE_LIMIT_DESCRIPTION = /rate limit/iu;
-function is_coderabbit_rate_limited(check) {
-  return is_coderabbit_check(check.name) && CODERABBIT_RATE_LIMIT_DESCRIPTION.test(check.description ?? "");
-}
-function matches_any(check_name, required_names) {
-  return required_names.some((required) => is_required_match(check_name, required));
-}
-function is_optional_pending(check, required_contexts) {
-  if (required_contexts.length === 0 || check.status !== CHECK_STATUS_PENDING) return false;
-  return !matches_any(check.name, required_contexts);
-}
-function is_every_context_passing(checks, contexts) {
-  return contexts.every(
-    (context) => find_required_check(checks, context)?.status === CHECK_STATUS_PASS
-  );
-}
-function is_unstable_only_from_optional(snapshot) {
-  if (snapshot.merge_state_status !== MERGE_STATE_UNSTABLE) return false;
-  const required_contexts = snapshot.required_contexts ?? [];
-  const non_passing = snapshot.rollup.filter((check) => check.status !== CHECK_STATUS_PASS);
-  if (non_passing.length === 0) return false;
-  const is_tolerated = non_passing.every(
-    (check) => is_coderabbit_check(check.name) || is_optional_pending(check, required_contexts)
-  );
-  return is_tolerated && is_every_context_passing(snapshot.rollup, required_contexts);
-}
-function is_required_check(check_name) {
-  return REQUIRED_CHECKS.some((required) => is_required_match(check_name, required));
-}
-function is_blocking_failure(check) {
-  if (check.status !== CHECK_STATUS_FAIL) return false;
-  return !is_coderabbit_check(check.name) || is_required_check(check.name);
-}
-function collect_blocking_failures(snapshot) {
-  return snapshot.rollup.filter((check) => is_blocking_failure(check)).map((check) => check.name);
-}
-function is_mergeable_state(snapshot) {
-  if (is_merge_state_clean(snapshot.merge_state_status)) return true;
-  return is_unstable_only_from_optional(snapshot);
-}
-function collect_failure_reasons(snapshot) {
-  const reasons = [];
-  if (is_merge_conflict(snapshot.merge_state_status)) reasons.push(FAILURE_REASON_CONFLICT);
-  if (is_review_blocked(snapshot.review_decision)) reasons.push(FAILURE_REASON_REVIEW);
-  const failed = collect_blocking_failures(snapshot);
-  if (failed.length > 0) reasons.push(`${FAILURE_REASON_CHECKS}: ${failed.join(", ")}`);
-  reasons.push(
-    ...collect_missing_contexts(snapshot).map((context) => describe_missing_context(context))
-  );
-  return reasons;
-}
-function describe_pr_failure(snapshot) {
-  const reasons = collect_failure_reasons(snapshot);
-  if (reasons.length === 0) return `${FAILURE_MESSAGE_PREFIX}.`;
-  return `${FAILURE_MESSAGE_PREFIX} (${reasons.join("; ")}).`;
-}
-function evaluate_pr_state(snapshot) {
-  const statuses = read_required_statuses(snapshot.rollup);
-  const failure = evaluate_failure_state({
-    review_decision: snapshot.review_decision,
-    failed_checks: [...collect_blocking_failures(snapshot), ...collect_missing_contexts(snapshot)],
-    merge_state_status: snapshot.merge_state_status
-  });
-  if (failure !== void 0) return failure;
-  if (is_mergeable_state(snapshot) && is_every_required_passing(statuses)) return "success";
-  return "pending";
-}
-function is_review_decision_decisive(snapshot) {
-  return evaluate_pr_state(snapshot) !== "pending";
-}
-var PrConflictError = class extends Error {
-  name = "PrConflictError";
-};
-
-// scripts/time-runtime/time-format.ts
-var SECOND_DECIMALS = 1;
-var LABEL_WIDTH = 24;
-var MINUTES_WIDTH = 9;
-var NOT_MEASURED = "not measured";
-var NO_CALLS = "no tool call to divide";
-var MAX_ROWS = 15;
-function overflow_line(row_count) {
-  if (row_count <= MAX_ROWS) return [];
-  return [
-    `  \u2026 and ${String(row_count - MAX_ROWS)} more (--json carries every row this report holds)`
-  ];
-}
-function format_seconds(duration_ms) {
-  return `${(duration_ms / MS_PER_SECOND).toFixed(SECOND_DECIMALS)} s`;
-}
-function format_columns(label, minutes, suffix) {
-  return `  ${label.padEnd(LABEL_WIDTH)}${minutes.padStart(MINUTES_WIDTH)}   ${suffix}`;
-}
-function format_row(label, duration_ms, suffix) {
-  return format_columns(label, figure_format.format_minutes(duration_ms), suffix);
-}
-function unmeasured_row(label) {
-  return format_columns(label, "", NOT_MEASURED);
-}
-var time_format = {
-  MAX_ROWS,
-  NO_CALLS,
-  overflow_line,
-  format_seconds,
-  format_columns,
-  format_row,
-  // `format_clock` stays private: `format_window` is its only caller, and a namespace that offers
-  // both invites a second renderer to join the two with its own arrow.
-  unmeasured_row
-};
-
-// scripts/followup/followup-ci-path.ts
-function new_path() {
-  return { pending: /* @__PURE__ */ new Set(), settled: /* @__PURE__ */ new Set(), check_ms: {} };
-}
-function settle(path6, name, elapsed_ms) {
-  if (path6.pending.delete(name)) path6.check_ms[name] = elapsed_ms;
-  path6.settled.add(name);
-}
-function hold(path6, name) {
-  if (path6.settled.has(name)) path6.has_rerun = true;
-  path6.pending.add(name);
-}
-function observe(path6, snapshot, now_ms) {
-  path6.start_ms ??= now_ms;
-  const elapsed_ms = now_ms - path6.start_ms;
-  const checks = snapshot.rollup.filter((check) => !is_coderabbit_check(check.name));
-  const pending = new Set(
-    checks.filter((check) => check.status === CHECK_STATUS_PENDING).map((check) => check.name)
-  );
-  for (const name of pending) hold(path6, name);
-  for (const check of checks) if (!pending.has(check.name)) settle(path6, check.name, elapsed_ms);
-}
-function observer_of(path6) {
-  const is_first_wait = path6.start_ms === void 0;
-  return async function time_checks(snapshot) {
-    if (is_first_wait) observe(path6, snapshot, performance.now());
-  };
-}
-function record_of(path6) {
-  const [last] = Object.entries(path6.check_ms).toSorted((left, right) => right[1] - left[1]);
-  if (last === void 0) return {};
-  return {
-    last_check: last[0],
-    check_ms: { ...path6.check_ms },
-    ...path6.has_rerun && { has_rerun: path6.has_rerun }
-  };
-}
-var followup_ci_path = { new_path, observe, observer_of, record_of };
-
-// scripts/run/event/run-event-checks.ts
-var CODERABBIT_STATES = ["running", "done", "rate-limited", "failed", "none"];
-var CHECKS_PATTERN = /^#\d+ PR (?<pr>\d+) pass (?<pass>\d+) pending (?<pending>\d+) fail (?<fail>\d+) coderabbit (?<coderabbit>\S+)$/u;
-function text_of(issue, checks) {
-  const { pr, pass, pending, fail, coderabbit } = checks;
-  return `${issue_cite.plain_for("program", issue)} PR ${String(pr)} pass ${String(pass)} pending ${String(pending)} fail ${String(fail)} coderabbit ${coderabbit}`;
-}
-var STATE_NAMES = new Set(CODERABBIT_STATES);
-function is_coderabbit_state(value2 = "") {
-  return STATE_NAMES.has(value2);
-}
-function checks_of(text2) {
-  const groups = CHECKS_PATTERN.exec(text2)?.groups;
-  const coderabbit = groups?.["coderabbit"];
-  if (groups === void 0 || !is_coderabbit_state(coderabbit)) return void 0;
-  return {
-    pr: Number(groups["pr"]),
-    pass: Number(groups["pass"]),
-    pending: Number(groups["pending"]),
-    fail: Number(groups["fail"]),
-    coderabbit
-  };
-}
-var run_event_checks = { checks_of, text_of };
-
-// scripts/followup/followup-checks-event.ts
-var PR_NUMBER_PATTERN = /\/pull\/(?<number>\d+)/u;
-var { PR_CHECKS } = run_event_stream.EVENT_KIND;
-function count_of(checks, status) {
-  return checks.filter((check) => check.status === status).length;
-}
-function coderabbit_state_of(check) {
-  if (check === void 0) return "none";
-  if (check.status === CHECK_STATUS_PENDING) return "running";
-  if (check.status !== CHECK_STATUS_PASS) return "failed";
-  return is_coderabbit_rate_limited(check) ? "rate-limited" : "done";
-}
-function coderabbit_of(snapshot) {
-  return coderabbit_state_of(snapshot.rollup.find((check) => is_coderabbit_check(check.name)));
-}
-function summary_of(snapshot, pr) {
-  const ci = snapshot.rollup.filter((check) => !is_coderabbit_check(check.name));
-  return {
-    pr,
-    pass: count_of(ci, CHECK_STATUS_PASS),
-    pending: count_of(ci, CHECK_STATUS_PENDING),
-    fail: count_of(ci, CHECK_STATUS_FAIL),
-    coderabbit: coderabbit_of(snapshot)
-  };
-}
-function pr_number_of(pr_url = "") {
-  const number = PR_NUMBER_PATTERN.exec(pr_url)?.groups?.["number"];
-  return number === void 0 ? void 0 : Number(number);
-}
-async function skip_snapshot() {
-}
-function observer_of2(issue, pr_url) {
-  const pr = pr_number_of(pr_url);
-  if (issue === void 0 || pr === void 0) return skip_snapshot;
-  let last_text = "";
-  return async function report_snapshot(snapshot) {
-    const text2 = run_event_checks.text_of(issue, summary_of(snapshot, pr));
-    if (text2 === last_text) return;
-    last_text = text2;
-    await run_event_stream_emit.emit(PR_CHECKS, text2);
-  };
-}
-var followup_checks_event = { coderabbit_of, observer_of: observer_of2, summary_of };
-
-// scripts/followup/followup-coderabbit-wait.ts
-var NO_TIME = 0;
-var RATE_LIMITED = "rate-limited";
-var WAITING_STATES = /* @__PURE__ */ new Set(["running", RATE_LIMITED]);
-function new_wait() {
-  return { wait_ms: NO_TIME, rate_limited_ms: NO_TIME };
-}
-function charge(wait, last, now_ms) {
-  const elapsed_ms = now_ms - last.at_ms;
-  if (WAITING_STATES.has(last.state)) wait.wait_ms += elapsed_ms;
-  if (last.state === RATE_LIMITED) wait.rate_limited_ms += elapsed_ms;
-}
-function observe2(wait, snapshot, now_ms) {
-  if (wait.last !== void 0) charge(wait, wait.last, now_ms);
-  wait.last = { state: followup_checks_event.coderabbit_of(snapshot), at_ms: now_ms };
-}
-function observer_of3(wait) {
-  delete wait.last;
-  return async function time_snapshot(snapshot) {
-    observe2(wait, snapshot, performance.now());
-  };
-}
-function all(...observers) {
-  return async function observe_all(snapshot) {
-    await Promise.all(
-      observers.map(async (observer) => {
-        await observer(snapshot);
-      })
-    );
-  };
-}
-async function record_part(stage, elapsed_ms) {
-  if (elapsed_ms > NO_TIME) await lane_ledger_write.record_stage({ stage, elapsed_ms });
-}
-async function record(wait) {
-  await record_part(lane_ledger_write.CODERABBIT_WAIT_STAGE, wait.wait_ms);
-  await record_part(lane_ledger_write.CODERABBIT_RATE_LIMIT_STAGE, wait.rate_limited_ms);
-}
-var followup_coderabbit_wait = { all, new_wait, observe: observe2, observer_of: observer_of3, record };
-
-// scripts/followup/git-followup-stages.ts
-var STAGE_LINE_PREFIX = "followup stage: ";
-var STAGE_TOTAL_PREFIX = "followup stages total: ";
-var STAGE_NAME_WIDTH = 26;
-var VALUE_COLUMN = STAGE_LINE_PREFIX.length + STAGE_NAME_WIDTH;
-var NO_DURATION = 0;
-var STAGE = {
-  closes_and_context: "closes-and-context",
-  checks_wait: "checks-wait",
-  // Only on a run that retriggered a rate-limited CodeRabbit: the window and the review after it
-  // (joshuafolkken/kit#5289), kept out of `checks-wait` so the `ci-wait` row is the checks alone.
-  coderabbit_retrigger: "coderabbit-retrigger",
-  coderabbit_comments: "coderabbit-comments",
-  ai_review_comments: "ai-review-comments",
-  // The interval of a run that merged nothing, where the send has nothing to go beside.
-  telegram: "telegram",
-  telegram_and_merge: "telegram-and-merge",
-  completion_and_epic_close: "completion-and-epic-close",
-  // The completion tail `git-followup-finish.ts` prints after this block (#5131): the next-issue list
-  // and the unreleased-merge count. Printed as its own row there, since the block is already out.
-  completion: "completion",
-  // The lap that was still running when a stage threw. `followup` exits non-zero on an AI-review
-  // blocker and on a red check, and those are the runs whose wait is longest — reporting nothing for
-  // them would leave the measurement blind to exactly the invocations worth measuring.
-  interrupted: "interrupted",
-  // The interrupted lap when the wait failed on a merge conflict, so the
-  // stage block names the cause a resumed session would otherwise look up with `gh pr view`.
-  conflict: "conflict"
-};
-function stopped_lap(error) {
-  return error instanceof PrConflictError ? STAGE.conflict : STAGE.interrupted;
-}
-function new_log() {
-  return {
-    stages: [],
-    last_ms: performance.now(),
-    coderabbit: followup_coderabbit_wait.new_wait(),
-    ci_path: followup_ci_path.new_path(),
-    reran: []
-  };
-}
-function hold_issue(log, issue_number) {
-  const issue = Number(issue_number);
-  if (Number.isSafeInteger(issue) && issue > 0) log.issue = issue;
-}
-function lap(log, name) {
-  const now_ms = performance.now();
-  log.stages.push({ name, duration_ms: now_ms - log.last_ms });
-  log.last_ms = now_ms;
-}
-function total_ms(stages) {
-  return stages.reduce((sum, stage) => sum + stage.duration_ms, NO_DURATION);
-}
-function format_stage(stage) {
-  const name = stage.name.padEnd(STAGE_NAME_WIDTH);
-  return `${STAGE_LINE_PREFIX}${name}${time_format.format_seconds(stage.duration_ms)}`;
-}
-function format_stages(log) {
-  if (log.stages.length === 0) return [];
-  const rows = log.stages.map((stage) => format_stage(stage));
-  const total = time_format.format_seconds(total_ms(log.stages));
-  return ["", ...rows, `${STAGE_TOTAL_PREFIX.padEnd(VALUE_COLUMN)}${total}`];
-}
-function print_stages(log) {
-  for (const line2 of format_stages(log)) console.info(line2);
-}
-async function record_ci_wait(log) {
-  const wait = log.stages.find((stage) => stage.name === STAGE.checks_wait);
-  if (wait === void 0) return;
-  await lane_ledger_write.record_stage({
-    stage: lane_ledger_write.CI_WAIT_STAGE,
-    elapsed_ms: wait.duration_ms,
-    ...log.issue !== void 0 && { issue: log.issue },
-    ...followup_ci_path.record_of(log.ci_path)
-  });
-}
-async function record_waits(log) {
-  await record_ci_wait(log);
-  await followup_coderabbit_wait.record(log.coderabbit);
-}
-var git_followup_stages = {
-  STAGE,
-  STAGE_LINE_PREFIX,
-  STAGE_TOTAL_PREFIX,
-  new_log,
-  hold_issue,
-  lap,
-  total_ms,
-  format_stage,
-  format_stages,
-  print_stages,
-  record_waits,
-  stopped_lap
-};
-
-// scripts/time-runtime/time-followup-stage.ts
-var LINE_SEPARATOR2 = "\n";
-var SECONDS_SUFFIX = " s";
-var DIGIT_OR_POINT = /[\d.]/u;
-var NO_STAGES = [];
-function stage_body(line2) {
-  const trimmed = line2.trimStart();
-  if (!trimmed.startsWith(git_followup_stages.STAGE_LINE_PREFIX)) return void 0;
-  return trimmed.slice(git_followup_stages.STAGE_LINE_PREFIX.length);
-}
-function digits_start(head) {
-  let index = head.length;
-  while (index > 0 && DIGIT_OR_POINT.test(head.charAt(index - 1))) index -= 1;
-  return index;
-}
-function is_duration(digits) {
-  return digits !== "" && Number.isFinite(Number(digits));
-}
-function to_stage(body) {
-  const text2 = body.trimEnd();
-  if (!text2.endsWith(SECONDS_SUFFIX)) return void 0;
-  const head = text2.slice(0, -SECONDS_SUFFIX.length);
-  const start = digits_start(head);
-  const name = head.slice(0, start).trim();
-  const digits = head.slice(start);
-  if (name === "" || !is_duration(digits)) return void 0;
-  return { name, duration_ms: Number(digits) * MS_PER_SECOND };
-}
-function read_stages(text2) {
-  if (!text2.includes(git_followup_stages.STAGE_LINE_PREFIX)) return NO_STAGES;
-  return text2.split(LINE_SEPARATOR2).map((line2) => stage_body(line2)).filter((body) => body !== void 0).map((body) => to_stage(body)).filter((stage) => stage !== void 0);
-}
-var time_followup_stage = { NO_STAGES, read_stages };
-
-// scripts/time-runtime/time-transcript-block.ts
-var ERROR_TEXT_LIMIT = 256;
-var REFUSAL_MARKER = "\u26D4";
-var HOOK_ERROR_LABEL = /^PreToolUse:\S+ hook error: /u;
-var TOKEN_LINE = /^[a-z][a-z-]*$/u;
-var TOKEN_LINE_LIMIT = 8;
-function block_names(raw) {
-  return {
-    type: raw.type ?? "",
-    name: raw.name ?? "",
-    id: raw.id ?? "",
-    result_id: raw.tool_use_id ?? ""
-  };
-}
-function refusal_body(text2) {
-  return text2.trimStart().replace(HOOK_ERROR_LABEL, "");
-}
-function guard_from_refusal(text2) {
-  const trimmed = refusal_body(text2);
-  if (!trimmed.startsWith(REFUSAL_MARKER)) return "";
-  const headline = trimmed.slice(REFUSAL_MARKER.length).split("\n", 1)[0]?.trimStart() ?? "";
-  const colon = headline.indexOf(":");
-  return (colon === -1 ? headline : headline.slice(0, colon)).trim();
-}
-function token_lines_of(text2) {
-  return text2.split("\n").map((line2) => line2.trim()).filter((line2) => TOKEN_LINE.test(line2)).slice(0, TOKEN_LINE_LIMIT);
-}
-function to_block(raw) {
-  const text2 = time_reported_failure.result_text(raw.content);
-  const is_error = raw.is_error ?? void 0;
-  return {
-    ...block_names(raw),
-    input: raw.input,
-    is_error,
-    has_failure_line: time_reported_failure.has_failure_line(text2),
-    followup_stages: time_followup_stage.read_stages(text2),
-    error_text: is_error === true ? text2.slice(0, ERROR_TEXT_LIMIT) : "",
-    refusal_guard: is_error === true ? guard_from_refusal(text2) : "",
-    token_lines: is_error === true ? [] : token_lines_of(text2),
-    background_id: time_background.launch_id(text2),
-    agent_id: time_background.agent_launch_id(text2),
-    result_chars: text2.length
-  };
-}
-function to_blocks(content) {
-  return typeof content === "string" || content === null || content === void 0 ? [] : content.map((block) => to_block(block));
-}
-var time_transcript_block = {
-  ERROR_TEXT_LIMIT,
-  TOKEN_LINE_LIMIT,
-  guard_from_refusal,
-  refusal_body,
-  to_blocks
-};
-
-// scripts/time-runtime/time-transcript-line.ts
-var UNKNOWN_BRANCH = "";
-var PROMPT_KEY = "prompt";
-var NO_MESSAGE_ID = "";
-var STOP_FEEDBACK_LABEL = /^Stop hook feedback:\s*/u;
-function stop_feedback_of(data) {
-  const content = data.message?.content;
-  if (typeof content !== "string" || !STOP_FEEDBACK_LABEL.test(content)) return "";
-  return content.replace(STOP_FEEDBACK_LABEL, "").trim();
-}
-function message_fields(message) {
-  return {
-    message_id: message?.id ?? NO_MESSAGE_ID,
-    blocks: time_transcript_block.to_blocks(message?.content)
-  };
-}
-function notice_text(data) {
-  const attachment = json_value.is_record(data.attachment) ? data.attachment[PROMPT_KEY] : void 0;
-  const carried = [data.message?.content, data.content, attachment];
-  return carried.find((one) => typeof one === "string") ?? "";
-}
-function stopped_background(content) {
-  if (!Array.isArray(content)) return time_background.NO_BACKGROUND;
-  const ids = content.map(
-    (block) => typeof block.content === "string" ? time_background.stopped_id(block.content) : ""
-  );
-  return ids.find((id) => id !== time_background.NO_BACKGROUND) ?? time_background.NO_BACKGROUND;
-}
-function finished_background(data) {
-  const notice = time_background.finished_id(notice_text(data));
-  return notice === time_background.NO_BACKGROUND ? stopped_background(data.message?.content) : notice;
-}
-function request_fields(data) {
-  return { request_id: data.requestId ?? "", effort: data.effort ?? "" };
-}
-function to_line(data) {
-  const timestamp_ms = time_instant.parse_instant(data.timestamp);
-  if (timestamp_ms === void 0) return void 0;
-  const stop_feedback = stop_feedback_of(data);
-  return {
-    type: data.type ?? "",
-    timestamp_ms,
-    branch: data.gitBranch ?? UNKNOWN_BRANCH,
-    finished_background: finished_background(data),
-    stop_feedback,
-    stop_guard: time_transcript_block.guard_from_refusal(stop_feedback),
-    ...request_fields(data),
-    ...message_fields(data.message)
-  };
-}
-function parse_line(line2) {
-  const record2 = transcript_record.parse(line2);
-  return record2 === void 0 ? void 0 : to_line(record2);
-}
-function parse_text(text2) {
-  return text2.split("\n").flatMap((line2) => parse_line(line2) ?? []);
-}
-var time_transcript_line = {
-  ERROR_TEXT_LIMIT: time_transcript_block.ERROR_TEXT_LIMIT,
-  NO_MESSAGE_ID,
-  TOKEN_LINE_LIMIT: time_transcript_block.TOKEN_LINE_LIMIT,
-  guard_from_refusal: time_transcript_block.guard_from_refusal,
-  parse_line,
-  parse_text,
-  refusal_body: time_transcript_block.refusal_body
-};
-
-// scripts/time-runtime/time-bundle-call.ts
-var { BASH_TOOL } = cost_blocks;
-var BUNDLEABLE_TOOLS = /* @__PURE__ */ new Set(["Edit", "Glob", "Grep", "Read", "WebFetch", "WebSearch", "Write"]);
-var LAUNCH_TOOLS = /* @__PURE__ */ new Set(["Agent", "Task"]);
-var PRIOR_REFERENCE_MARKERS = [
-  "previous finding",
-  "prior finding",
-  "earlier finding",
-  "previous result",
-  "prior result",
-  "earlier result",
-  "based on the previous",
-  "based on the earlier",
-  "from the previous agent",
-  "from the prior agent",
-  "the finding above",
-  "as found earlier",
-  "as found above",
-  "building on the previous"
-];
-var READ_COMMANDS = /* @__PURE__ */ new Set([
-  "awk",
-  "basename",
-  "cat",
-  "comm",
-  "cut",
-  "diff",
-  "dirname",
-  "du",
-  "echo",
-  "file",
-  "find",
-  "gh",
-  "grep",
-  "head",
-  "jq",
-  "ls",
-  "nl",
-  "printf",
-  "pwd",
-  "realpath",
-  "rg",
-  // **`sed -i` is deliberately not excluded.** An in-place edit is what `Edit` does, and `Edit` is on
-  // the allow-list above — a turn may issue several of them, so rejecting the shell spelling of the
-  // same thing would exclude a call the tool form counts. Two in-place edits of the *same* file are
-  // caught by the target test instead, which is where that ordering actually lives.
-  "sed",
-  "sort",
-  "stat",
-  "tail",
-  "tree",
-  "uniq",
-  "wc",
-  "which"
-]);
-var MUTATION_WORDS = /* @__PURE__ */ new Set([
-  "--field",
-  "--method",
-  "--raw-field",
-  "-F",
-  "-X",
-  "-delete",
-  "-exec",
-  "-f",
-  "add",
-  "chmod",
-  "chown",
-  "close",
-  "comment",
-  "cp",
-  "create",
-  "dd",
-  "delete",
-  "edit",
-  "git",
-  "install",
-  "kill",
-  "ln",
-  "merge",
-  "mkdir",
-  "mv",
-  "node",
-  "npm",
-  "npx",
-  "pkill",
-  "pnpm",
-  "remove",
-  "rm",
-  "scp",
-  "secret",
-  "set",
-  "ssh",
-  "sudo",
-  "tee",
-  "touch",
-  "truncate",
-  "tsx",
-  "upload",
-  "wget"
-]);
-var READ_JOSH_SUBCOMMANDS = /* @__PURE__ */ new Set([
-  "backlog:budget",
-  "backlog:next",
-  "cost",
-  "delegate",
-  "epic:audit",
-  "epic:bundle",
-  "epic:check",
-  "epic:next",
-  "issue:read",
-  "issue:scout",
-  "issue:state",
-  "lane:list",
-  "latest:scope",
-  "release:scope",
-  "review:brief",
-  "review:round2",
-  "run:liveness"
-]);
-var JOSH_WORD = "josh";
-var JOSH_SCRIPT_SUFFIX = "josh.ts";
-var COMMAND_CHAIN = /[|;&`>]|\$\(/u;
-var WHITESPACE_PATTERN = /\s+/u;
-var TARGET_FIELDS = ["file_path", "notebook_path", "path", "url"];
-var TARGET_ARRAY_FIELD = "file_paths";
-var MAX_TARGETS = 8;
-var WORD_PATTERN = /[\s'"=(),;:|&]+/u;
-var EXTENSION_PATTERN = /^[A-Za-z]+$/u;
-var MAX_EXTENSION = 5;
-var AFTER_DOT = 1;
-var FIRST_INDEX = 0;
-var CURRENT_DIRECTORY = "./";
-var LAST_CHARACTER = -1;
-var FLAG_PREFIX = "-";
-var PATH_SEPARATOR = "/";
-var MIN_TARGET_LENGTH = 3;
-var WRITING_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "NotebookEdit"]);
-var WRITING_WORDS = /* @__PURE__ */ new Set(["dd", "sed", "tee"]);
-var REDIRECTION = ">";
-var IN_PLACE_COMMAND = "sed";
-var IN_PLACE_FLAG_PATTERN = /^--in-place\b|^-[A-Za-z]*i/u;
-function not_bundleable() {
-  return {
-    is_bundleable: false,
-    targets: [],
-    is_writing: false,
-    may_write: false,
-    has_prior_reference: false
-  };
-}
-function is_launch_tool(name) {
-  return LAUNCH_TOOLS.has(name);
-}
-function words_of(command) {
-  return command.split(WORD_PATTERN).filter((word) => word !== "");
-}
-function has_mutation(command) {
-  return words_of(command).some((word) => MUTATION_WORDS.has(word));
-}
-function josh_subcommand(command) {
-  const tokens = command.split(WHITESPACE_PATTERN).filter((token) => token !== "");
-  const josh_index = tokens.findIndex(
-    (token) => token === JOSH_WORD || token.endsWith(JOSH_SCRIPT_SUFFIX)
-  );
-  return josh_index < FIRST_INDEX ? void 0 : tokens[josh_index + 1];
-}
-function is_read_josh(command) {
-  if (COMMAND_CHAIN.test(command)) return false;
-  const subcommand = josh_subcommand(command);
-  if (subcommand === void 0) return false;
-  return READ_JOSH_SUBCOMMANDS.has(canonical_command(subcommand));
-}
-function may_write_command(command) {
-  if (command.includes(REDIRECTION)) return true;
-  return words_of(command).some((word) => WRITING_WORDS.has(word));
-}
-function write_segment(command) {
-  return time_shell.command_segment(time_shell.unquoted(command));
-}
-function is_in_place_sed(segment) {
-  if (time_shell.leading_word(segment) !== IN_PLACE_COMMAND) return false;
-  return words_of(segment).some((word) => IN_PLACE_FLAG_PATTERN.test(word));
-}
-function normalize(word) {
-  const head = word.startsWith(CURRENT_DIRECTORY) ? word.slice(CURRENT_DIRECTORY.length) : word;
-  return head.endsWith(PATH_SEPARATOR) ? head.slice(0, LAST_CHARACTER) : head;
-}
-function has_extension(word) {
-  const dot = word.lastIndexOf(".");
-  if (dot <= FIRST_INDEX) return false;
-  const suffix = word.slice(dot + AFTER_DOT);
-  return suffix.length <= MAX_EXTENSION && EXTENSION_PATTERN.test(suffix);
-}
-function is_target(word) {
-  if (word.startsWith(FLAG_PREFIX) || word.length < MIN_TARGET_LENGTH) return false;
-  return word.includes(PATH_SEPARATOR) || has_extension(word);
-}
-function targets_in(text2) {
-  return words_of(text2).map((word) => normalize(word)).filter((word) => is_target(word)).slice(0, MAX_TARGETS);
-}
-function field_text(input, field) {
-  if (!json_value.is_record(input)) return "";
-  const value2 = input[field];
-  return typeof value2 === "string" ? value2 : "";
-}
-function field_targets(input) {
-  if (!json_value.is_record(input)) return [];
-  const value2 = input[TARGET_ARRAY_FIELD];
-  return Array.isArray(value2) ? value2.filter((entry) => typeof entry === "string") : [];
-}
-function tool_targets(input) {
-  const scalar_targets = TARGET_FIELDS.map((field) => field_text(input, field));
-  const targets = [...scalar_targets, ...field_targets(input)].map((target) => normalize(target));
-  return [...new Set(targets)].filter((target) => target !== "");
-}
-function prompt_references_prior(input) {
-  const prompt = field_text(input, "prompt").toLowerCase();
-  return PRIOR_REFERENCE_MARKERS.some((marker) => prompt.includes(marker));
-}
-function tool_facts(name, input) {
-  const writes = { is_writing: WRITING_TOOLS.has(name), may_write: WRITING_TOOLS.has(name) };
-  const has_prior_reference = LAUNCH_TOOLS.has(name) && prompt_references_prior(input);
-  if (!BUNDLEABLE_TOOLS.has(name)) return { ...not_bundleable(), ...writes, has_prior_reference };
-  return { is_bundleable: true, targets: tool_targets(input), ...writes, has_prior_reference };
-}
-function bash_facts(command) {
-  const writes = {
-    is_writing: is_in_place_sed(write_segment(command)),
-    may_write: may_write_command(command)
-  };
-  if (is_read_josh(command)) {
-    return {
-      is_bundleable: true,
-      targets: targets_in(time_shell.unquoted(command)),
-      ...writes,
-      has_prior_reference: false
-    };
-  }
-  if (!READ_COMMANDS.has(time_shell.leading_word(command)) || has_mutation(command)) {
-    return { ...not_bundleable(), ...writes };
-  }
-  return {
-    is_bundleable: true,
-    targets: targets_in(time_shell.unquoted(command)),
-    ...writes,
-    has_prior_reference: false
-  };
-}
-function call_facts(name, input) {
-  if (name !== BASH_TOOL) return tool_facts(name, input);
-  return bash_facts(time_shell.bash_command(input));
-}
-var time_bundle_call = {
-  MAX_TARGETS,
-  not_bundleable,
-  bash_facts,
-  call_facts,
-  tool_facts,
-  // Exported for `time-agent-bundles.ts`, which asks the launch question of a
-  // span's `label` — the tool name for a non-Bash call — so the set lives in one place.
-  is_launch_tool,
-  // Exported for `time-writes.ts`, which asks what a call *wrote* rather
-  // than what it named. The extraction is the same one either way — a second copy of it would let a
-  // path be recognized as a target when read and missed when written.
-  targets_in,
-  tool_targets,
-  // Exported for the batching guard's own word scan, so the two scanners
-  // cannot come to disagree about where one word of a shell line ends and the next begins.
-  // Exported for the read-fold notice, which offers `read:files <path>` only
-  // over file-shaped targets — a bare directory like `scripts/` is a target here but not something
-  // `read:files` can read, so the notice reuses this test rather than keep a second copy that could
-  // drift from what counts as a file path.
-  has_extension,
-  // Exported for `time-writes.ts`, which needs the same two answers to say
-  // *which* files an in-place `sed` wrote. Two copies of this test disagreed in both directions at
-  // once — one called a piped `grep -i` a write, the other missed a bundled `sed -ni`.
-  write_segment,
-  is_in_place_sed,
-  // Exported for the drift test in `time-bundle-call.test.ts`, which pins that
-  // every name here is a real `josh` command and none of them writes.
-  READ_JOSH_SUBCOMMANDS
-};
-
-// scripts/cost-runtime/cost-attribute.ts
-var ISSUE_BRANCH_PATTERN = /^(\d+)-/u;
-var UNATTRIBUTED_KEY = -1;
-function issue_from_branch(branch) {
-  const matched = ISSUE_BRANCH_PATTERN.exec(branch);
-  return matched?.[1] === void 0 ? UNATTRIBUTED_KEY : Number(matched[1]);
-}
-function declared_issue(record2) {
-  const declared = record2.issue ?? UNATTRIBUTED_KEY;
-  return declared === UNATTRIBUTED_KEY ? issue_from_branch(record2.branch) : declared;
-}
-function fill(declared, is_reverse) {
-  const filled = Array.from({ length: declared.length }, () => UNATTRIBUTED_KEY);
-  const order = declared.map((_value, index) => is_reverse ? declared.length - 1 - index : index);
-  let carried = UNATTRIBUTED_KEY;
-  for (const index of order) {
-    const own = declared[index] ?? UNATTRIBUTED_KEY;
-    carried = own === UNATTRIBUTED_KEY ? carried : own;
-    filled[index] = carried;
-  }
-  return filled;
-}
-function is_attributed(value2) {
-  return value2 !== void 0 && value2 !== UNATTRIBUTED_KEY;
-}
-function pick(own, carried, next, previous) {
-  if (is_attributed(own)) return own;
-  if (is_attributed(carried)) return carried;
-  if (is_attributed(next)) return next;
-  return previous ?? UNATTRIBUTED_KEY;
-}
-function announcements(records) {
-  return fill(
-    records.map((record2) => record2.issue ?? UNATTRIBUTED_KEY),
-    false
-  );
-}
-function attribute(records) {
-  const declared = records.map((record2) => declared_issue(record2));
-  const carried = announcements(records);
-  const next = fill(declared, true);
-  const previous = fill(declared, false);
-  return declared.map(
-    (own, index) => pick(own, carried[index] ?? UNATTRIBUTED_KEY, next[index], previous[index])
-  );
-}
-function group_by_issue(records) {
-  const issues = attribute(records);
-  const grouped = /* @__PURE__ */ new Map();
-  for (const [index, record2] of records.entries()) {
-    const bucket = grouped.get(issues[index] ?? UNATTRIBUTED_KEY) ?? [];
-    bucket.push(record2);
-    grouped.set(issues[index] ?? UNATTRIBUTED_KEY, bucket);
-  }
-  return [...grouped].toSorted(([left], [right]) => left - right).map(([issue, bucket]) => ({ issue, records: bucket }));
-}
-function records_for_issue(records, issue_number) {
-  const issues = attribute(records);
-  return records.filter((_record, index) => issues[index] === issue_number);
-}
-var cost_attribute = {
-  UNATTRIBUTED_KEY,
-  issue_from_branch,
-  declared_issue,
-  attribute,
-  group_by_issue,
-  records_for_issue
-};
-
-// scripts/time-runtime/time-markers.ts
-var NO_MARKER = "none";
-var PLAN_MARKER = "plan";
-var EDIT_MARKER = "edit";
-var REVIEW_MARKER = "review";
-var WORKFLOW_MARKER = "workflow";
-var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
-var SKILL_TOOL = "Skill";
-var SKILL_KEY = "skill";
-var REVIEW_SKILL = "code-review";
-var WORKFLOW_SKILL = "workflow-commands";
-var AGENT_TOOL = "Agent";
-var PROMPT_KEY2 = "prompt";
-var REVIEW_INVOCATION = "/code-review";
-var REVIEW_ATTEST = "review:attest";
-var SKILL_MARKERS = /* @__PURE__ */ new Map([
-  [REVIEW_SKILL, REVIEW_MARKER],
-  [WORKFLOW_SKILL, WORKFLOW_MARKER]
-]);
-var ISSUE_API_PATTERN = /repos\/\S+\/issues\/\d+/u;
-var BODY_FIELD_PATTERN = /\bbody=/u;
-var ISSUE_COMMENT_PATTERN = /\bgh\s+issue\s+comment\b/u;
-var BODY_FLAG_PATTERN = /--body(?:-file)?\b/u;
-var ISSUE_PLAN_PATTERN = /(?:^|[;&|]\s*)pnpm\s+josh\s+issue:plan\b/u;
-var ISSUE_LABELS_PATTERN = /repos\/\S+\/issues\/(\d+)\/labels\b(?!\/)/u;
-var IN_PROGRESS_FIELD = "labels[]=in-progress";
-var RUN_ENTRY_PATTERN = /\bjosh\s+run:entry\s+(\d+)\b/u;
-var NO_ISSUE = cost_attribute.UNATTRIBUTED_KEY;
-function string_field(input, key2) {
-  if (!json_value.is_record(input)) return "";
-  const value2 = input[key2];
-  return typeof value2 === "string" ? value2 : "";
-}
-function skill_name(input) {
-  return string_field(input, SKILL_KEY);
-}
-function agent_marker(input) {
-  const prompt = string_field(input, PROMPT_KEY2);
-  const is_review = prompt.includes(REVIEW_INVOCATION) && prompt.includes(REVIEW_ATTEST);
-  return is_review ? REVIEW_MARKER : NO_MARKER;
-}
-function tool_marker(name, input) {
-  if (EDIT_TOOLS.has(name)) return EDIT_MARKER;
-  if (name === AGENT_TOOL) return agent_marker(input);
-  if (name !== SKILL_TOOL) return NO_MARKER;
-  return SKILL_MARKERS.get(skill_name(input)) ?? NO_MARKER;
-}
-function is_api_body_write(command) {
-  return ISSUE_API_PATTERN.test(command) && BODY_FIELD_PATTERN.test(command);
-}
-function is_issue_comment(command) {
-  return ISSUE_COMMENT_PATTERN.test(command) && BODY_FLAG_PATTERN.test(command);
-}
-function is_plan_write(command) {
-  return is_api_body_write(command) || is_issue_comment(command) || ISSUE_PLAN_PATTERN.test(command);
-}
-function is_in_progress_label(command) {
-  return ISSUE_LABELS_PATTERN.test(command) && command.includes(IN_PROGRESS_FIELD);
-}
-function is_run_start(command) {
-  return is_in_progress_label(command) || RUN_ENTRY_PATTERN.test(command);
-}
-var COMMAND_SEPARATOR = /&&|\|\||;/u;
-function declared_issue2(part) {
-  const pattern = is_in_progress_label(part) ? ISSUE_LABELS_PATTERN : RUN_ENTRY_PATTERN;
-  const matched = pattern.exec(part);
-  return matched?.[1] === void 0 ? NO_ISSUE : Number(matched[1]);
-}
-function bash_issue(command) {
-  for (const part of command.split(COMMAND_SEPARATOR)) {
-    if (is_run_start(part)) return declared_issue2(part);
-  }
-  return NO_ISSUE;
-}
-function bash_marker(command) {
-  if (is_run_start(command)) return WORKFLOW_MARKER;
-  return is_plan_write(command) ? PLAN_MARKER : NO_MARKER;
-}
-var time_markers = {
-  NO_MARKER,
-  PLAN_MARKER,
-  EDIT_MARKER,
-  REVIEW_MARKER,
-  WORKFLOW_MARKER,
-  NO_ISSUE,
-  tool_marker,
-  bash_marker,
-  bash_issue
-};
-
-// scripts/time-runtime/time-single-check.ts
-var CHECK_COMMANDS = /* @__PURE__ */ new Set([
-  "josh check",
-  "josh cspell",
-  "josh cspell:dot",
-  "josh lint",
-  "josh lint:related",
-  "josh test:related",
-  "josh test:unit"
-]);
-var NO_CHECK = "";
-var KEY_SEPARATOR = " ";
-function argument_key(command) {
-  return [...new Set(time_shell.josh_arguments(command))].toSorted(
-    (left, right) => left.localeCompare(right)
-  );
-}
-function check_key(josh_command, command) {
-  if (!CHECK_COMMANDS.has(josh_command)) return NO_CHECK;
-  return [josh_command, ...argument_key(command)].join(KEY_SEPARATOR);
-}
-var time_single_check = { NO_CHECK, check_key };
-
-// scripts/time-runtime/time-writes.ts
-function bash_writes(command) {
-  const segment = time_bundle_call.write_segment(command);
-  return time_bundle_call.is_in_place_sed(segment) ? time_bundle_call.targets_in(segment) : [];
-}
-function tool_writes(name, input) {
-  if (time_markers.tool_marker(name, input) !== time_markers.EDIT_MARKER) return [];
-  return time_bundle_call.tool_targets(input);
-}
-var time_writes = {
-  bash_writes,
-  tool_writes
-};
-
-// scripts/time-runtime/time-tool-call.ts
-var { NO_MESSAGE_ID: NO_MESSAGE_ID2 } = time_transcript_line;
-var UNKNOWN_TOOL = "unknown";
-var NO_CALL = {
-  label: "",
-  josh_command: "",
-  josh_commands: [],
-  josh_signatures: [],
-  check_key: time_single_check.NO_CHECK,
-  marker: time_markers.NO_MARKER,
-  message_id: NO_MESSAGE_ID2,
-  writes: [],
-  issue: time_markers.NO_ISSUE,
-  reads_background: time_background.NO_BACKGROUND,
-  ...time_bundle_call.not_bundleable()
-};
-var UNKNOWN_CALL = {
-  label: UNKNOWN_TOOL,
-  josh_command: "",
-  josh_commands: [],
-  josh_signatures: [],
-  check_key: time_single_check.NO_CHECK,
-  marker: time_markers.NO_MARKER,
-  message_id: NO_MESSAGE_ID2,
-  writes: [],
-  issue: time_markers.NO_ISSUE,
-  reads_background: time_background.NO_BACKGROUND,
-  ...time_bundle_call.not_bundleable()
-};
-function non_bash_call(name, input, message_id) {
-  return {
-    label: name,
-    josh_command: "",
-    josh_commands: [],
-    josh_signatures: [],
-    check_key: time_single_check.NO_CHECK,
-    marker: time_markers.tool_marker(name, input),
-    message_id,
-    writes: time_writes.tool_writes(name, input),
-    issue: time_markers.NO_ISSUE,
-    // A non-Bash tool joins a backgrounded command too — `BashOutput` carries the shell id in a
-    // field of its own, `Monitor` names the same `…/tasks/<id>.output` path in a command — so the
-    // same reader is asked here rather than the field being left empty for every tool but `Bash`.
-    reads_background: time_background.read_id_of(input),
-    ...time_bundle_call.tool_facts(name, input)
-  };
-}
-function bash_call(input, message_id) {
-  const command = time_shell.bash_command(input);
-  const josh_command = time_josh_names.josh_command_of(command);
-  return {
-    label: time_shell.bash_label(command),
-    josh_command,
-    josh_commands: time_josh_names.josh_commands_of(command),
-    josh_signatures: time_josh_names.josh_signatures_of(command),
-    check_key: time_single_check.check_key(josh_command, command),
-    marker: time_markers.bash_marker(command),
-    message_id,
-    writes: time_writes.bash_writes(command),
-    issue: time_markers.bash_issue(command),
-    reads_background: time_background.read_id_of(input),
-    ...time_bundle_call.bash_facts(command)
-  };
-}
-function to_tool_call(name, input, message_id) {
-  if (name !== cost_blocks.BASH_TOOL) return non_bash_call(name, input, message_id);
-  return bash_call(input, message_id);
-}
-var time_tool_call = {
-  UNKNOWN_TOOL,
-  NO_CALL,
-  UNKNOWN_CALL,
-  to_tool_call
-};
-
-// scripts/time-runtime/time-spans.ts
-var { NO_MESSAGE_ID: NO_MESSAGE_ID3, parse_line: parse_line2 } = time_transcript_line;
-var { NO_CALL: NO_CALL2, UNKNOWN_CALL: UNKNOWN_CALL2, UNKNOWN_TOOL: UNKNOWN_TOOL2, to_tool_call: to_tool_call2 } = time_tool_call;
-var ASSISTANT_TYPE = "assistant";
-var USER_TYPE = "user";
-var MODEL_CATEGORY = "model";
-var TOOL_CATEGORY = "tool";
-var HUMAN_CATEGORY = "human";
-var OK_OUTCOME = "ok";
-var FAILED_OUTCOME = "failed";
-var UNKNOWN_OUTCOME = "unknown";
-var NO_RESULT = {
-  call_id: "",
-  outcome: UNKNOWN_OUTCOME,
-  refusal_guard: "",
-  background_id: time_background.NO_BACKGROUND,
-  followup_stages: time_followup_stage.NO_STAGES
-};
-function tool_use_blocks(lines) {
-  return lines.flatMap(
-    (line2) => line2.blocks.filter((block) => block.type === cost_blocks.TOOL_USE_TYPE && block.id !== "").map((block) => ({ block, message_id: line2.message_id }))
-  );
-}
-function collect_calls(lines) {
-  return new Map(
-    tool_use_blocks(lines).map(({ block, message_id }) => [
-      block.id,
-      to_tool_call2(block.name, block.input, message_id)
-    ])
-  );
-}
-function result_block(line2) {
-  return line2.blocks.find((block) => block.type === cost_blocks.TOOL_RESULT_TYPE);
-}
-function event_of(line2, category, call, result = NO_RESULT) {
-  return { timestamp_ms: line2.timestamp_ms, branch: line2.branch, category, ...result, ...call };
-}
-function outcome_of(result, call) {
-  if (time_reported_failure.is_reported_failure(call.josh_command, result.has_failure_line)) {
-    return FAILED_OUTCOME;
-  }
-  if (result.is_error === void 0) return UNKNOWN_OUTCOME;
-  return result.is_error ? FAILED_OUTCOME : OK_OUTCOME;
-}
-function facts_of(result, call) {
-  return {
-    call_id: result.result_id,
-    outcome: outcome_of(result, call),
-    refusal_guard: result.refusal_guard,
-    background_id: result.background_id,
-    followup_stages: result.followup_stages
-  };
-}
-function user_event(line2, calls) {
-  const result = result_block(line2);
-  if (result === void 0) return event_of(line2, HUMAN_CATEGORY, NO_CALL2);
-  const call = calls.get(result.result_id) ?? UNKNOWN_CALL2;
-  return event_of(line2, TOOL_CATEGORY, call, facts_of(result, call));
-}
-function to_event(line2, calls) {
-  if (line2.type === ASSISTANT_TYPE) {
-    return event_of(line2, MODEL_CATEGORY, { ...NO_CALL2, message_id: line2.message_id });
-  }
-  return line2.type === USER_TYPE ? user_event(line2, calls) : void 0;
-}
-function to_events(lines, calls) {
-  return lines.map((line2) => to_event(line2, calls)).filter((event) => event !== void 0).toSorted((left, right) => left.timestamp_ms - right.timestamp_ms);
-}
-function equal_durations(duration_ms) {
-  return { duration_ms, own_duration_ms: duration_ms };
-}
-function no_background() {
-  const none = time_background.NO_BACKGROUND;
-  return {
-    background_id: none,
-    reads_background: none,
-    background_command: none,
-    background_ended_ms: time_background.NO_FINISH
-  };
-}
-function background_fields(event, finished) {
-  return {
-    background_id: event.background_id,
-    reads_background: event.reads_background,
-    background_command: time_background.NO_BACKGROUND,
-    background_ended_ms: finished.get(event.background_id) ?? time_background.NO_FINISH
-  };
-}
-function result_facts_of(event) {
-  return {
-    call_id: event.call_id,
-    outcome: event.outcome,
-    refusal_guard: event.refusal_guard,
-    followup_stages: event.followup_stages
-  };
-}
-function to_spans(events, finished) {
-  return events.slice(1).map((event, index) => ({
-    category: event.category,
-    label: event.label,
-    josh_command: event.josh_command,
-    josh_commands: event.josh_commands,
-    josh_signatures: event.josh_signatures,
-    check_key: event.check_key,
-    marker: event.marker,
-    is_bundleable: event.is_bundleable,
-    targets: event.targets,
-    is_writing: event.is_writing,
-    may_write: event.may_write,
-    has_prior_reference: event.has_prior_reference,
-    writes: event.writes,
-    message_id: event.message_id,
-    issue: event.issue,
-    branch: event.branch,
-    ...result_facts_of(event),
-    is_continuation: false,
-    ...background_fields(event, finished),
-    ended_ms: event.timestamp_ms,
-    ...equal_durations(event.timestamp_ms - (events[index]?.timestamp_ms ?? event.timestamp_ms))
-  }));
-}
-function parse_timeline(text2) {
-  const lines = text2.split("\n").map((line2) => parse_line2(line2)).filter((line2) => line2 !== void 0);
-  const events = to_events(lines, collect_calls(lines));
-  return {
-    started_ms: events[0]?.timestamp_ms ?? 0,
-    ended_ms: events.at(-1)?.timestamp_ms ?? 0,
-    // **The positioning happens here rather than in a caller**: a launch and
-    // the call that reads its output are in one transcript, and by the time spans have been merged
-    // across sessions and trimmed they are fragments rather than calls.
-    spans: time_background.positioned(to_spans(events, time_background.finished_at(lines)))
-  };
-}
-function has_transcript_data(span_count) {
-  return span_count > 0;
-}
-var time_spans = {
-  ASSISTANT_TYPE,
-  MODEL_CATEGORY,
-  TOOL_CATEGORY,
-  HUMAN_CATEGORY,
-  OK_OUTCOME,
-  FAILED_OUTCOME,
-  UNKNOWN_OUTCOME,
-  NO_MESSAGE_ID: NO_MESSAGE_ID3,
-  UNKNOWN_TOOL: UNKNOWN_TOOL2,
-  has_transcript_data,
-  equal_durations,
-  no_background,
-  // Re-exported so the suites that measure how a command is read keep asking one namespace, and so
-  // `time-shell.ts` moving out of this file changed no call site.
-  bash_label: time_shell.bash_label,
-  josh_command_of: time_josh_names.josh_command_of,
-  josh_commands_of: time_josh_names.josh_commands_of,
-  to_tool_call: to_tool_call2,
-  parse_line: parse_line2,
-  parse_timeline
-};
-
-// scripts/time-runtime/time-round-trips.ts
-var CALLS_PER_ROUND_TRIP_FLOOR = 1.5;
-var DENSITY_DECIMALS = 2;
-var NONE = 0;
-function is_tool(span) {
-  return span.category === time_spans.TOOL_CATEGORY;
-}
-function is_model(span) {
-  return span.category === time_spans.MODEL_CATEGORY;
-}
-function started_ms2(span) {
-  return span.ended_ms - span.duration_ms;
-}
-function in_time_order(spans) {
-  return spans.toSorted((left, right) => started_ms2(left) - started_ms2(right));
-}
-function is_tool_at(spans, index) {
-  const span = spans[index];
-  return span !== void 0 && is_tool(span);
-}
-function is_call(span) {
-  return is_tool(span) && !span.is_continuation;
-}
-function count_calls(spans) {
-  return spans.filter((span) => is_call(span)).length;
-}
-function previous_break(spans, index) {
-  for (let back = index - 1; back >= 0; back -= 1) {
-    const span = spans[back];
-    if (span === void 0 || !is_model(span)) return span;
-  }
-  return void 0;
-}
-function continues_turn(spans, index, message_id) {
-  if (message_id === time_spans.NO_MESSAGE_ID) return false;
-  const earlier = previous_break(spans, index);
-  return earlier !== void 0 && !earlier.is_continuation && earlier.message_id === message_id;
-}
-function opens_round_trip(spans, index) {
-  const span = spans[index];
-  if (span === void 0 || !is_tool(span) || span.is_continuation || is_tool_at(spans, index - 1)) {
-    return false;
-  }
-  return !continues_turn(spans, index, span.message_id);
-}
-function open_trip(walk) {
-  walk.open = [];
-  walk.trips.push(walk.open);
-}
-function place_call(walk, span) {
-  if (is_call(span)) walk.open?.push(span);
-}
-function step_trip(walk, span, is_opener) {
-  if (is_opener) open_trip(walk);
-  if (is_tool(span)) place_call(walk, span);
-  else if (!is_model(span)) walk.open = void 0;
-}
-function group_round_trips(spans) {
-  const ordered = in_time_order(spans);
-  const walk = { trips: [], open: void 0 };
-  for (const [index, span] of ordered.entries()) {
-    step_trip(walk, span, opens_round_trip(ordered, index));
-  }
-  return walk.trips;
-}
-function count_round_trips(spans) {
-  return group_round_trips(spans).length;
-}
-function turn_key(span, index) {
-  return span.message_id === time_spans.NO_MESSAGE_ID ? `#${String(index)}` : span.message_id;
-}
-function count_turns(spans) {
-  const keys = spans.filter((span) => is_model(span)).map((span, index) => turn_key(span, index));
-  return new Set(keys).size;
-}
-function per_round_trip(total, round_trip_count) {
-  if (round_trip_count === NONE) return NONE;
-  return total / round_trip_count;
-}
-function format_density(density) {
-  return density.toFixed(DENSITY_DECIMALS);
-}
-function is_below_floor(density) {
-  return density > NONE && density < CALLS_PER_ROUND_TRIP_FLOOR;
-}
-var time_round_trips = {
-  CALLS_PER_ROUND_TRIP_FLOOR,
-  count_calls,
-  count_round_trips,
-  // Exported so a turn is defined in the one module that already defines a round trip rather than
-  // as a span filter in the report next door.
-  count_turns,
-  format_density,
-  // Exported so the per-tool counts are read off the very groups this module counts rather than off
-  // a second grouping beside them.
-  group_round_trips,
-  // Exported so the failure aggregation orders a run's spans through
-  // the one function that already knows why they need it — a second `toSorted` beside it would be
-  // the clone `CLAUDE.md` prohibits, and the seam it guards (a delegated unit's spans appended
-  // after the parent's) is not one a second copy would keep remembering.
-  in_time_order,
-  is_below_floor,
-  // Exported so callers price a round trip with the same divisor and guard rather than a private
-  // copy — the clone `CLAUDE.md` prohibits.
-  per_round_trip
-};
-
-// scripts/time-runtime/time-agent-bundles.ts
-var NONE2 = 0;
-var ONE = 1;
-var MIN_GROUP = 2;
-function is_launch2(span) {
-  return span.category === time_spans.TOOL_CATEGORY && !span.is_continuation && time_bundle_call.is_launch_tool(span.label);
-}
-function new_walk() {
-  return { closed: [], open: NONE2, wrote_since: false, turn_id: time_spans.NO_MESSAGE_ID };
-}
-function close_group(walk) {
-  if (walk.open >= MIN_GROUP) walk.closed.push(walk.open);
-  walk.open = NONE2;
-}
-function is_same_turn(walk, span) {
-  return span.message_id !== time_spans.NO_MESSAGE_ID && span.message_id === walk.turn_id;
-}
-function open_turn(walk, span) {
-  if (walk.wrote_since || span.has_prior_reference) close_group(walk);
-  walk.open += ONE;
-  walk.turn_id = span.message_id;
-  walk.wrote_since = false;
-}
-function step(walk, span) {
-  if (span.is_writing) {
-    walk.wrote_since = true;
-    return;
-  }
-  if (!is_launch2(span) || is_same_turn(walk, span)) return;
-  open_turn(walk, span);
-}
-function agent_bundles(spans) {
-  const walk = new_walk();
-  for (const span of time_round_trips.in_time_order(spans)) step(walk, span);
-  close_group(walk);
-  return walk.closed;
-}
-var time_agent_bundles = { agent_bundles };
-
-// scripts/time-runtime/time-bundles.ts
-var { unmeasured_row: unmeasured_row2 } = time_format;
-var HEADING = "Bundling:";
-var SEQUENCE_LABEL = "bundleable sequences";
-var RECOVERABLE_LABEL = "recoverable round trips";
-var SAVING_LABEL = "recoverable wait";
-var BY_TOOL_LABEL = "recoverable by tool";
-var AGENT_ROW_LABEL = "Agent";
-var ROW_INDENT = "  ";
-var MIN_SEQUENCE = 2;
-var ONE_CALL = 1;
-var NONE3 = 0;
-var PATH_SEPARATOR2 = "/";
-var FIRST_CALL = 1;
-var NO_LABEL = "";
-var NO_BUNDLES = {
-  sequence_count: 0,
-  longest_sequence: 0,
-  recoverable_round_trips: 0,
-  by_tool: [],
-  unattributed_round_trips: 0,
-  single_call: { independent_round_trips: 0, dependent_round_trips: 0, by_tool: [] },
-  is_measured: false
-};
-function contains_segments(whole, part) {
-  if (whole.startsWith(`${part}${PATH_SEPARATOR2}`)) return true;
-  return whole.endsWith(`${PATH_SEPARATOR2}${part}`) || whole.includes(`${PATH_SEPARATOR2}${part}${PATH_SEPARATOR2}`);
-}
-function is_related(left, right) {
-  if (left === right) return true;
-  return contains_segments(left, right) || contains_segments(right, left);
-}
-function shares_target(left, right) {
-  return left.some((one) => right.some((other) => is_related(one, other)));
-}
-function is_dependent(earlier, later) {
-  if (earlier.is_writing && later.is_writing) return false;
-  return shares_target(earlier.targets, later.targets);
-}
-function conflicts(span, sequence) {
-  return sequence.some((earlier) => is_dependent(earlier, span));
-}
-function is_call2(span) {
-  return span.category === time_spans.TOOL_CATEGORY && !span.is_continuation;
-}
-function is_turn_boundary(span) {
-  return span.category === time_spans.MODEL_CATEGORY;
-}
-function new_walk2() {
-  return { pending: [], sequence: [], closed: [], dependent: NONE3 };
-}
-function flush(walk) {
-  if (walk.sequence.length >= MIN_SEQUENCE) walk.closed.push(walk.sequence);
-  walk.sequence = [];
-}
-function extend(walk, span) {
-  if (conflicts(span, walk.sequence)) {
-    walk.dependent += ONE_CALL;
-    flush(walk);
-  }
-  walk.sequence.push(span);
-}
-function close_trip(walk) {
-  const [only] = walk.pending;
-  if (walk.pending.length === ONE_CALL && only?.is_bundleable === true) extend(walk, only);
-  else if (walk.pending.length > NONE3) flush(walk);
-  walk.pending = [];
-}
-function is_same_turn2(span, pending) {
-  const [first] = pending;
-  if (first === void 0 || span.is_continuation || span.message_id === time_spans.NO_MESSAGE_ID) {
-    return false;
-  }
-  return span.message_id === first.message_id;
-}
-function step2(walk, span) {
-  if (is_call2(span)) {
-    walk.pending.push(span);
-    return;
-  }
-  if (is_same_turn2(span, walk.pending)) return;
-  close_trip(walk);
-  if (!is_turn_boundary(span)) flush(walk);
-}
-function longest_of(sizes) {
-  return sizes.length === NONE3 ? NONE3 : Math.max(...sizes);
-}
-function recoverable_of(sizes) {
-  return sizes.reduce((sum, size) => sum + size - ONE_CALL, NONE3);
-}
-function sizes_of(closed) {
-  return closed.map((sequence) => sequence.length);
-}
-function tally_for(tallies, label) {
-  const found = tallies.get(label);
-  if (found !== void 0) return found;
-  const created = { sequence_count: NONE3, recoverable_round_trips: NONE3 };
-  tallies.set(label, created);
-  return created;
-}
-function count_trip(tallies, counted, label) {
-  const tally = tally_for(tallies, label);
-  tally.recoverable_round_trips += ONE_CALL;
-  if (!counted.has(label)) tally.sequence_count += ONE_CALL;
-  counted.add(label);
-}
-function tally_sequence(tallies, sequence) {
-  const counted = /* @__PURE__ */ new Set();
-  for (const span of sequence.slice(FIRST_CALL)) {
-    if (span.label !== NO_LABEL) count_trip(tallies, counted, span.label);
-  }
-}
-function by_weight(left, right) {
-  if (left.recoverable_round_trips !== right.recoverable_round_trips) {
-    return right.recoverable_round_trips - left.recoverable_round_trips;
-  }
-  return left.label.localeCompare(right.label);
-}
-function tool_rows(closed) {
-  const tallies = /* @__PURE__ */ new Map();
-  for (const sequence of closed) tally_sequence(tallies, sequence);
-  return [...tallies].map(([label, tally]) => ({ label, ...tally })).toSorted(by_weight);
-}
-function attributed_of(rows) {
-  return rows.reduce((sum, row) => sum + row.recoverable_round_trips, NONE3);
-}
-function with_agent_row(rows, agent_sizes) {
-  const recoverable_round_trips = recoverable_of(agent_sizes);
-  if (recoverable_round_trips === NONE3) return [...rows];
-  const row = {
-    label: AGENT_ROW_LABEL,
-    sequence_count: agent_sizes.length,
-    recoverable_round_trips
-  };
-  return [...rows, row].toSorted(by_weight);
-}
-function single_call_split(walk, sizes) {
-  return {
-    independent_round_trips: recoverable_of(sizes),
-    dependent_round_trips: walk.dependent,
-    by_tool: tool_rows(walk.closed)
-  };
-}
-function build_bundles(spans) {
-  const walk = new_walk2();
-  for (const span of time_round_trips.in_time_order(spans)) step2(walk, span);
-  close_trip(walk);
-  flush(walk);
-  const sizes = sizes_of(walk.closed);
-  const agent_sizes = time_agent_bundles.agent_bundles(spans);
-  const single_call = single_call_split(walk, sizes);
-  const by_tool = with_agent_row(single_call.by_tool, agent_sizes);
-  const recoverable_round_trips = single_call.independent_round_trips + recoverable_of(agent_sizes);
-  return {
-    sequence_count: sizes.length + agent_sizes.length,
-    longest_sequence: Math.max(longest_of(sizes), longest_of(agent_sizes)),
-    recoverable_round_trips,
-    by_tool,
-    unattributed_round_trips: recoverable_round_trips - attributed_of(by_tool),
-    single_call,
-    is_measured: time_spans.has_transcript_data(spans.length)
-  };
-}
-function open_sequence(spans) {
-  const walk = new_walk2();
-  for (const span of time_round_trips.in_time_order(spans)) step2(walk, span);
-  return walk.sequence;
-}
-function sequence_suffix(totals) {
-  return `longest ${String(totals.longest_sequence)} turn(s)`;
-}
-function recoverable_suffix(totals, round_trip_count) {
-  const share = figure_format.format_share(totals.recoverable_round_trips, round_trip_count);
-  return `${share} of ${String(round_trip_count)} round trip(s)`;
-}
-function saving_line(totals, model_ms_per_round_trip) {
-  const saved_ms = totals.recoverable_round_trips * model_ms_per_round_trip;
-  const rate = `at ${time_format.format_seconds(model_ms_per_round_trip)} model time per round trip`;
-  return time_format.format_row(SAVING_LABEL, saved_ms, rate);
-}
-function by_tool_suffix(totals) {
-  const attributed = totals.recoverable_round_trips - totals.unattributed_round_trips;
-  return `${String(attributed)} of ${String(totals.recoverable_round_trips)} attributed`;
-}
-function tool_row(row) {
-  return time_format.format_columns(
-    `${ROW_INDENT}${row.label}`,
-    String(row.recoverable_round_trips),
-    `in ${String(row.sequence_count)} sequence(s)`
-  );
-}
-function by_tool_lines(totals) {
-  const heading2 = time_format.format_columns(
-    BY_TOOL_LABEL,
-    String(totals.by_tool.length),
-    by_tool_suffix(totals)
-  );
-  const rows = totals.by_tool.slice(NONE3, time_format.MAX_ROWS).map((row) => tool_row(row));
-  return [heading2, ...rows, ...time_format.overflow_line(totals.by_tool.length)];
-}
-function measured_lines(totals, price) {
-  return [
-    time_format.format_columns(
-      SEQUENCE_LABEL,
-      String(totals.sequence_count),
-      sequence_suffix(totals)
-    ),
-    time_format.format_columns(
-      RECOVERABLE_LABEL,
-      String(totals.recoverable_round_trips),
-      recoverable_suffix(totals, price.round_trip_count)
-    ),
-    saving_line(totals, price.model_ms_per_round_trip),
-    ...by_tool_lines(totals)
-  ];
-}
-var LABELS = [SEQUENCE_LABEL, RECOVERABLE_LABEL, SAVING_LABEL, BY_TOOL_LABEL];
-function no_divisor_lines() {
-  return LABELS.map((label) => time_format.format_columns(label, "", time_format.NO_CALLS));
-}
-function bundle_lines(totals, price) {
-  const heading2 = ["", HEADING];
-  if (!totals.is_measured) return [...heading2, ...LABELS.map((label) => unmeasured_row2(label))];
-  if (price.round_trip_count === NONE3) return [...heading2, ...no_divisor_lines()];
-  return [...heading2, ...measured_lines(totals, price)];
-}
-var time_bundles = {
-  HEADING,
-  BY_TOOL_LABEL,
-  NO_BUNDLES,
-  build_bundles,
-  bundle_lines,
-  by_weight,
-  is_dependent,
-  open_sequence,
-  shares_target
-};
-
-// scripts/time-runtime/time-command-key.ts
-var UNNAMED_KEY = "";
-function command_key(span) {
-  if (span.label === time_spans.UNKNOWN_TOOL) return UNNAMED_KEY;
-  return span.josh_command === "" ? span.label : span.josh_command;
-}
-var time_command_key = { UNNAMED_KEY, command_key };
-
-// scripts/time-runtime/time-call-identity.ts
-var IDENTITY_SEPARATOR = "\0";
-function identity_of(call) {
-  return [
-    time_command_key.command_key(call),
-    call.check_key,
-    [...call.targets].toSorted((left, right) => left.localeCompare(right)).join(",")
-  ].join(IDENTITY_SEPARATOR);
-}
-var time_call_identity = { identity_of };
-
-// scripts/time-runtime/time-search-call.ts
-var SEARCH_COMMANDS = ["fd", "find", "grep", "rg"];
-var SEARCH_LABELS = new Set(
-  SEARCH_COMMANDS.map((command) => time_shell.bash_label(command))
-);
-var CHAIN_COMMANDS = [...SEARCH_COMMANDS, "sed"];
-var CHAIN_LABELS = new Set(
-  CHAIN_COMMANDS.map((command) => time_shell.bash_label(command))
-);
-function is_read_only_search(call) {
-  return SEARCH_LABELS.has(call.label) && call.is_bundleable && !call.may_write;
-}
-function is_search_chain_call(call) {
-  return CHAIN_LABELS.has(call.label) && call.is_bundleable && !call.is_writing;
-}
-var time_search_call = {
-  is_read_only_search,
-  is_search_chain_call
-};
-
-// scripts/time-runtime/time-batch-guard.ts
-var CONSECUTIVE_LIMIT = 3;
-var REFIRE_EVERY = CONSECUTIVE_LIMIT;
-var ONE_TURN = 1;
-var NONE4 = 0;
-var NOTICE_REFIRE_EVERY = ONE_TURN;
-var NAMED_CANDIDATE_COUNT = 3;
-var SEQUENCE_BEFORE_LIMIT = CONSECUTIVE_LIMIT - ONE_TURN;
-var RULE_POINTER = "`prompts/collaboration-workflow/turn-batching.md`";
-var STREAK = `${String(CONSECUTIVE_LIMIT)} single-call turns in a row`;
-var REASON = `\u26D4 batching: ${STREAK}. Reissue this with the calls that do not need its result \u2014 the test is whether a call's input needs another call's result, not what kind of call it is (edits are covered exactly as reads); it never authorizes weakening a verification gate or a review. Nothing to pair? Reissue it unchanged. ${RULE_POINTER}`;
-var NOTICE = `\u{1F4A1} batching: ${STREAK}; the Write proceeds. Issue the writes that do not need its result in one turn, never by weakening a gate or a review. ${RULE_POINTER}`;
-var LANE_NOTICE = `\u{1F4A1} batching: ${STREAK}; the call proceeds. Pair independent calls. ${RULE_POINTER}`;
-var WHOLE_FILE_WRITE_TOOL = "Write";
-var EDIT_TOOL = "Edit";
-function is_guarded_call(call) {
-  if (call.name === WHOLE_FILE_WRITE_TOOL) return false;
-  return time_bundle_call.call_facts(call.name, call.input).is_bundleable;
-}
-function is_notice_call(call) {
-  return call.name === WHOLE_FILE_WRITE_TOOL;
-}
-function is_read_only_call(call) {
-  const facts = time_bundle_call.call_facts(call.name, call.input);
-  return facts.is_bundleable && !facts.may_write;
-}
-function depends_on_sequence(sequence, facts) {
-  return sequence.some((span) => time_bundles.shares_target(span.targets, facts.targets));
-}
-function sequence_started_ms(sequence) {
-  return sequence[0]?.ended_ms ?? NONE4;
-}
-function turns_since(sequence, last_fired_ms) {
-  return sequence.filter((span) => span.ended_ms > last_fired_ms).length;
-}
-function is_sequence_at_limit(sequence, facts, last_fired_ms, refire_every) {
-  if (sequence.length < SEQUENCE_BEFORE_LIMIT || depends_on_sequence(sequence, facts)) return false;
-  if (last_fired_ms < sequence_started_ms(sequence)) return true;
-  return turns_since(sequence, last_fired_ms) >= refire_every;
-}
-function is_at_limit(spans, call, last_fired_ms, refire_every) {
-  return is_sequence_at_limit(
-    time_bundles.open_sequence(spans),
-    time_bundle_call.call_facts(call.name, call.input),
-    last_fired_ms,
-    refire_every
-  );
-}
-var GUARD_LABEL = time_transcript_line.guard_from_refusal(REASON);
-function is_reissued_refusal(spans, call) {
-  const identity = time_call_identity.identity_of(
-    time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID)
-  );
-  return spans.some(
-    (span) => span.refusal_guard === GUARD_LABEL && time_call_identity.identity_of(span) === identity
-  );
-}
-function refusable_spans(text2, call) {
-  if (!is_guarded_call(call)) return [];
-  const { spans } = time_spans.parse_timeline(text2);
-  return is_reissued_refusal(spans, call) ? [] : spans;
-}
-function should_block(text2, call, refused_at_ms, refire_every = REFIRE_EVERY) {
-  return is_at_limit(refusable_spans(text2, call), call, refused_at_ms, refire_every);
-}
-function as_tool_call(call) {
-  return time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID);
-}
-function is_search_chain_call2(call) {
-  return is_guarded_call(call) && time_search_call.is_search_chain_call(as_tool_call(call));
-}
-function is_search_chain(spans, call) {
-  const recent = time_bundles.open_sequence(spans).slice(-SEQUENCE_BEFORE_LIMIT);
-  return [...recent, as_tool_call(call)].every(
-    (turn) => time_search_call.is_search_chain_call(turn)
-  );
-}
-function should_block_search_chain(text2, call, refused_at_ms) {
-  const spans = refusable_spans(text2, call);
-  return is_search_chain(spans, call) && is_at_limit(spans, call, refused_at_ms, REFIRE_EVERY);
-}
-function should_notify(text2, call, notified_at_ms) {
-  if (!is_notice_call(call)) return false;
-  const { spans } = time_spans.parse_timeline(text2);
-  return is_at_limit(spans, call, notified_at_ms, NOTICE_REFIRE_EVERY);
-}
-function describe_span(span) {
-  const target = span.targets[0] ?? "";
-  if (target === "" || span.label.includes(target)) return span.label;
-  return `${span.label} ${target}`;
-}
-var FOLD_MINIMUM = 2;
-function read_targets(sequence) {
-  const paths = sequence.filter((span) => span.is_bundleable && !span.is_writing).map((span) => span.targets[0] ?? "").filter((path6) => path6 !== "" && time_bundle_call.has_extension(path6));
-  return [...new Set(paths)];
-}
-function read_fold_directive(sequence) {
-  const paths = read_targets(sequence);
-  if (paths.length < FOLD_MINIMUM) return "";
-  return ` Fold them into one call: \`pnpm josh read:files ${paths.join(" ")}\`.`;
-}
-function write_targets(sequence) {
-  const paths = sequence.filter((span) => span.label === EDIT_TOOL).map((span) => span.targets[0] ?? "").filter((path6) => path6 !== "" && time_bundle_call.has_extension(path6));
-  return [...new Set(paths)];
-}
-function write_fold_directive(sequence) {
-  const paths = write_targets(sequence);
-  if (paths.length < FOLD_MINIMUM) return "";
-  return ` Fold them into one \`pnpm josh edit:files\` call with a plan over: ${paths.join(" ")}.`;
-}
-function name_candidates(calls) {
-  if (calls.length === NONE4) return "";
-  const named = calls.map((call) => describe_span(call)).join(", ");
-  const folds = `${read_fold_directive(calls)}${write_fold_directive(calls)}`;
-  return ` Just issued one per turn, so at least these could have shared a turn: ${named}.${folds}`;
-}
-function recent_candidates(tail) {
-  return name_candidates(
-    time_bundles.open_sequence(time_spans.parse_timeline(tail).spans).slice(-NAMED_CANDIDATE_COUNT)
-  );
-}
-function pairing_candidates(tail, call) {
-  const sequence = time_bundles.open_sequence(time_spans.parse_timeline(tail).spans);
-  if (call === void 0 || sequence.length === NONE4) {
-    return name_candidates(sequence.slice(-NAMED_CANDIDATE_COUNT));
-  }
-  const facts = time_bundle_call.call_facts(call.name, call.input);
-  if (!facts.is_bundleable || depends_on_sequence(sequence, facts)) return "";
-  const current = time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID);
-  return name_candidates([...sequence.slice(ONE_TURN - NAMED_CANDIDATE_COUNT), current]);
-}
-var STAMP_PREFIX = "josh-batch-guard-";
-var NOTICE_STAMP_PREFIX = "josh-batch-guard-notice-";
-var time_batch_guard = {
-  CONSECUTIVE_LIMIT,
-  GUARD_LABEL,
-  LANE_NOTICE,
-  NOTICE,
-  NOTICE_REFIRE_EVERY,
-  NOTICE_STAMP_PREFIX,
-  REASON,
-  REFIRE_EVERY,
-  SEQUENCE_BEFORE_LIMIT,
-  STAMP_PREFIX,
-  is_guarded_call,
-  is_notice_call,
-  is_read_only_call,
-  is_search_chain_call: is_search_chain_call2,
-  pairing_candidates,
-  recent_candidates,
-  should_block,
-  should_block_search_chain,
-  should_notify
-};
-
 // scripts/build/local-bin.ts
 import { existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import path3 from "node:path";
+import path from "node:path";
 
 // scripts/lib/pnpm-reach.ts
 var PNPM = "pnpm";
@@ -2652,23 +84,23 @@ var WINDOWS_PLATFORM = "win32";
 var WINDOWS_SHIM_SUFFIX = ".cmd";
 function resolve_local_bin(project_root, bin_name) {
   const shim = process.platform === WINDOWS_PLATFORM ? `${bin_name}${WINDOWS_SHIM_SUFFIX}` : bin_name;
-  return path3.join(project_root, NODE_MODULES, BIN_DIR, shim);
+  return path.join(project_root, NODE_MODULES, BIN_DIR, shim);
 }
 function find_local_bin_upwards(start_directory, bin_name) {
   return ancestor_directories.list(start_directory).map((directory) => resolve_local_bin(directory, bin_name)).find((candidate) => existsSync(candidate));
 }
 function read_bin_entry(manifest_path, package_name, bin_name) {
   const { bin } = package_bin_schema.parse(JSON.parse(readFileSync(manifest_path, "utf8")));
-  if (typeof bin === "string") return bin_name === path3.basename(package_name) ? bin : void 0;
+  if (typeof bin === "string") return bin_name === path.basename(package_name) ? bin : void 0;
   return bin?.[bin_name];
 }
 function resolve_package_bin(base_directory, package_name, bin_name) {
   try {
-    const resolve_from = createRequire(path3.join(base_directory, PACKAGE_JSON));
+    const resolve_from = createRequire(path.join(base_directory, PACKAGE_JSON));
     const manifest_path = resolve_from.resolve(`${package_name}/${PACKAGE_JSON}`);
     const bin_entry = read_bin_entry(manifest_path, package_name, bin_name);
     if (bin_entry === void 0) return void 0;
-    const cli_entry = path3.join(path3.dirname(manifest_path), bin_entry);
+    const cli_entry = path.join(path.dirname(manifest_path), bin_entry);
     return existsSync(cli_entry) ? cli_entry : void 0;
   } catch {
     return void 0;
@@ -2710,41 +142,41 @@ var BASIC_REQUIRED_SUFFIXES = [
   ".yml",
   ".toml"
 ];
-function normalize2(paths) {
-  return paths.map((path6) => path6.trim()).filter((path6) => path6 !== "");
+function normalize(paths) {
+  return paths.map((path4) => path4.trim()).filter((path4) => path4 !== "");
 }
-function is_test_file(path6) {
-  return TEST_SUFFIXES.some((suffix) => path6.endsWith(suffix));
+function is_test_file(path4) {
+  return TEST_SUFFIXES.some((suffix) => path4.endsWith(suffix));
 }
-function is_basic_manual(path6, is_basic) {
-  const lower = path6.toLowerCase();
+function is_basic_manual(path4, is_basic) {
+  const lower = path4.toLowerCase();
   return is_basic && BASIC_REQUIRED_SUFFIXES.every((suffix) => !lower.endsWith(suffix));
 }
-function is_basic_visual(path6) {
-  const lower = path6.toLowerCase();
+function is_basic_visual(path4) {
+  const lower = path4.toLowerCase();
   return BASIC_VISUAL_SUFFIXES.some((suffix) => lower.endsWith(suffix));
 }
-function is_exempt(path6, is_basic = false) {
-  if (EXEMPT_PATHS.includes(path6) || is_basic_manual(path6, is_basic)) return true;
-  return EXEMPT_SUFFIXES.some((suffix) => path6.endsWith(suffix)) || EXEMPT_PREFIXES.some((prefix2) => path6.startsWith(prefix2));
+function is_exempt(path4, is_basic = false) {
+  if (EXEMPT_PATHS.includes(path4) || is_basic_manual(path4, is_basic)) return true;
+  return EXEMPT_SUFFIXES.some((suffix) => path4.endsWith(suffix)) || EXEMPT_PREFIXES.some((prefix2) => path4.startsWith(prefix2));
 }
-function is_runtime(path6, is_basic = false) {
-  return !is_test_file(path6) && !is_exempt(path6, is_basic);
+function is_runtime(path4, is_basic = false) {
+  return !is_test_file(path4) && !is_exempt(path4, is_basic);
 }
 function verdict_for(paths, is_basic = false) {
-  const changed = normalize2(paths);
-  if (changed.some((path6) => is_test_file(path6))) return "satisfied";
-  if (changed.some((path6) => is_runtime(path6, is_basic))) return "required";
+  const changed = normalize(paths);
+  if (changed.some((path4) => is_test_file(path4))) return "satisfied";
+  if (changed.some((path4) => is_runtime(path4, is_basic))) return "required";
   return "exempt";
 }
 function runtime_files(paths, is_basic = false) {
-  return normalize2(paths).filter((path6) => is_runtime(path6, is_basic));
+  return normalize(paths).filter((path4) => is_runtime(path4, is_basic));
 }
 function exempt_files(paths, is_basic = false) {
-  return normalize2(paths).filter((path6) => is_exempt(path6, is_basic));
+  return normalize(paths).filter((path4) => is_exempt(path4, is_basic));
 }
 function manual_check_files(paths, is_basic) {
-  return normalize2(paths).filter((path6) => is_exempt(path6, is_basic) && !is_exempt(path6));
+  return normalize(paths).filter((path4) => is_exempt(path4, is_basic) && !is_exempt(path4));
 }
 var test_declared_logic = {
   EXEMPT_PATHS,
@@ -2837,7 +269,10 @@ var KEYS = {
   measure_absent: { ja: "\u8A08\u6E2C\u5BA3\u8A00\u306A\u3057", en: "No measure declaration" },
   sample_gate: { ja: "\u5B9F\u65BD\u53EF\u80FD\u6761\u4EF6", en: "Sample gate" },
   not_before: { ja: "\u5B9F\u65BD\u53EF\u80FD\u65E5", en: "Not before" },
-  source: { ja: "\u51FA\u3069\u3053\u308D", en: "Source" }
+  source: { ja: "\u51FA\u3069\u3053\u308D", en: "Source" },
+  constraint_source: { ja: "\u51FA\u6240", en: "Constraint source" },
+  constraint_reference: { ja: "\u53C2\u7167", en: "Constraint reference" },
+  constraint_instruction: { ja: "\u6307\u793A", en: "Constraint instruction" }
 };
 var VALUES = {
   bug: { ja: "\u4E0D\u5177\u5408", en: "defect" },
@@ -2865,7 +300,8 @@ var HEADINGS = {
   trigger: { ja: "\u767A\u706B\u70B9", en: "Trigger" },
   baseline: { ja: "\u30D9\u30FC\u30B9\u30E9\u30A4\u30F3", en: "Baseline" },
   reproduction: { ja: "\u518D\u73FE", en: "Reproduction" },
-  expected_effect: { ja: "\u671F\u5F85\u52B9\u679C", en: "Expected effect" }
+  expected_effect: { ja: "\u671F\u5F85\u52B9\u679C", en: "Expected effect" },
+  auto_execution_constraint: { ja: "\u81EA\u52D5\u5B9F\u884C\u306E\u5236\u7D04", en: "Automatic execution constraint" }
 };
 var SIZE_VALUES = {
   ja: "\u7D04 <files> \u30D5\u30A1\u30A4\u30EB / <lines> \u884C\uFF08\u30C6\u30B9\u30C8\u9664\u304F\uFF09",
@@ -2884,14 +320,14 @@ var VALUE_TEXTS = Object.values(VALUES).flatMap((row) => COLUMNS.map((at) => ({
 function column() {
   return session_language.is_japanese(session_language.resolve_session_lang().lang) ? "ja" : "en";
 }
-function text_of2(row) {
+function text_of(row) {
   return row[column()];
 }
 function key(name) {
-  return text_of2(KEYS[name]);
+  return text_of(KEYS[name]);
 }
 function value(name) {
-  return text_of2(VALUES[name]);
+  return text_of(VALUES[name]);
 }
 function prefix(name) {
   return `- ${key(name)}:`;
@@ -2906,16 +342,16 @@ function line_variants(name, value_name) {
   return COLUMNS.map((at) => `- ${KEYS[name][at]}: ${VALUES[value_name][at]}`);
 }
 function heading(name) {
-  return `## ${text_of2(HEADINGS[name])}`;
+  return `## ${text_of(HEADINGS[name])}`;
 }
 function size_value(files, lines) {
-  return text_of2(SIZE_VALUES).replace("<files>", () => files).replace("<lines>", () => lines);
+  return text_of(SIZE_VALUES).replace("<files>", () => files).replace("<lines>", () => lines);
 }
-function size_counts(text2) {
-  return SIZE_PATTERNS.map((pattern) => pattern.exec(text2)?.groups).find(Boolean);
+function size_counts(text) {
+  return SIZE_PATTERNS.map((pattern) => pattern.exec(text)?.groups).find(Boolean);
 }
-function row_named(rows, text2) {
-  return Object.values(rows).find((row) => COLUMNS.some((at) => row[at] === text2));
+function row_named(rows, text) {
+  return Object.values(rows).find((row) => COLUMNS.some((at) => row[at] === text));
 }
 function indent_of(raw) {
   return raw.slice(0, raw.length - raw.trimStart().length);
@@ -2923,21 +359,21 @@ function indent_of(raw) {
 function canonical_value(rest) {
   const trimmed = rest.trimStart();
   const found = VALUE_TEXTS.find(
-    ({ text: text2 }) => trimmed.startsWith(text2) && VALUE_END.test(trimmed.slice(text2.length))
+    ({ text }) => trimmed.startsWith(text) && VALUE_END.test(trimmed.slice(text.length))
   );
   if (found === void 0) return rest;
-  return `${indent_of(rest)}${text_of2(found.row)}${trimmed.slice(found.text.length)}`;
+  return `${indent_of(rest)}${text_of(found.row)}${trimmed.slice(found.text.length)}`;
 }
 function canonical_declaration(raw) {
-  const text2 = raw.trimStart();
-  const end = text2.indexOf(KEY_END);
-  const row = end !== -1 && text2.startsWith(BULLET) ? row_named(KEYS, text2.slice(BULLET.length, end)) : void 0;
-  return row === void 0 ? void 0 : `${indent_of(raw)}${BULLET}${text_of2(row)}${KEY_END}${canonical_value(text2.slice(end + 1))}`;
+  const text = raw.trimStart();
+  const end = text.indexOf(KEY_END);
+  const row = end !== -1 && text.startsWith(BULLET) ? row_named(KEYS, text.slice(BULLET.length, end)) : void 0;
+  return row === void 0 ? void 0 : `${indent_of(raw)}${BULLET}${text_of(row)}${KEY_END}${canonical_value(text.slice(end + 1))}`;
 }
 function canonical_heading(raw) {
-  const text2 = raw.trim();
-  const row = text2.startsWith(HEADING_PREFIX) ? row_named(HEADINGS, text2.slice(HEADING_PREFIX.length)) : void 0;
-  return row === void 0 ? void 0 : `${indent_of(raw)}${HEADING_PREFIX}${text_of2(row)}`;
+  const text = raw.trim();
+  const row = text.startsWith(HEADING_PREFIX) ? row_named(HEADINGS, text.slice(HEADING_PREFIX.length)) : void 0;
+  return row === void 0 ? void 0 : `${indent_of(raw)}${HEADING_PREFIX}${text_of(row)}`;
 }
 function canonical_line(raw) {
   return canonical_heading(raw) ?? canonical_declaration(raw) ?? raw;
@@ -3675,7 +1111,7 @@ var ISSUE_WRITE_COMMANDS = {
         },
         {
           names: ["--label <name>"],
-          description: "an extra label (for example `epic`). Repeatable."
+          description: "an extra label (e.g. `epic`). Repeatable. With `josh.worker`, `worker:<name>` names a printed profile."
         },
         {
           names: ["--defect / --verification / --every-run <yes|no|unknown>"],
@@ -3699,7 +1135,7 @@ var ISSUE_WRITE_COMMANDS = {
         },
         {
           names: ["--no-auto-ok"],
-          description: "needs a person's judgement (Tier B / C); no `auto-ok`."
+          description: "needs human judgement or a verified user prohibition; no `auto-ok`."
         },
         {
           names: ["--release"],
@@ -4612,17 +2048,25 @@ var RUN_COMMANDS = {
   },
   "run:park": {
     script: "scripts/run/park/run-park-cli.ts",
-    description: "Park a lane child for a decision, or clear the park",
+    description: "Park a lane child for a decision or an escalation, or clear the park",
     category: "AI tools",
     tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    reference: ["<issue> --body-file <path> | <issue> --clear", "automation", ["files", "network"]],
+    reference: [
+      "<issue> --body-file <path> | <issue> --clear | <issue> --escalate <reason>",
+      "automation",
+      ["files", "network"]
+    ],
     usage: {
       examples: [
         {
           arguments: "1839 --body-file .josh/tmp/park-1839.md",
           note: "options, tiers and a recommendation; then needs-decision, the record, run:release"
         },
-        { arguments: "1839 --clear", note: "remove needs-decision and the record" }
+        { arguments: "1839 --clear", note: "remove needs-decision and the record" },
+        {
+          arguments: '1839 --escalate "needs a stronger model"',
+          note: "josh.worker.escalate only: run:stalled with the reason, resumed one profile up"
+        }
       ]
     }
   },
@@ -5408,7 +2852,7 @@ var AI_COMMANDS = {
     description: "Record a lane child's planned files; yield its lane, naming file and holder, when an earlier-planned running lane declares or plans one; `--size-approval` bounds lines/files",
     category: "AI tools",
     reference: [
-      "<issue> <path>... [--probe] [--single] [--size-approval <json-file>] [--imports <path>...]",
+      "<issue> <path>... [--probe] [--single] [--estimate <json-file>] [--size-approval <json-file>] [--imports <path>...]",
       "automation",
       ["files", "network"]
     ],
@@ -5471,7 +2915,7 @@ var AI_COMMANDS = {
   },
   "lane:stats": {
     ...MEASURE_ARGUMENTS,
-    description: "Print period lane throughput, stage, stop, check and machine-load statistics; --sinks shows stage totals, --over lane chains, --why cause groups above a net-minute threshold, and --pairs scoped pair runs",
+    description: "Print period lane throughput, stage, stop (by failed CI check, longest first), check and machine-load statistics; --sinks shows stage totals, --over lane chains, --why cause groups above a net-minute threshold, and --pairs scoped pair runs",
     category: "AI tools",
     reference: [
       "(--period <days> | --since <instant>) [--limit <lane-limit> | --sinks [<minutes>] | --over <minutes> | --why <minutes> | --pairs]",
@@ -5638,23 +3082,23 @@ import { availableParallelism as availableParallelism2 } from "node:os";
 import { availableParallelism } from "node:os";
 
 // scripts/test/unit-lane-count.ts
-import { readdirSync as readdirSync2 } from "node:fs";
-import path4 from "node:path";
+import { readdirSync } from "node:fs";
+import path2 from "node:path";
 function is_idle_lane(lanes_root, issue, environment) {
-  const common = git_directory.resolve_git_directory(path4.join(lanes_root, issue));
+  const common = git_directory.resolve_git_directory(path2.join(lanes_root, issue));
   if (common === void 0) return false;
   const override = environment[platform_temporary.TEMP_ROOT_KEY];
   const state_root = durable_state_root.state_root(override, () => common);
   return lane_state_record.is_idle(state_root, common, issue);
 }
 function own_lane(checkout, environment) {
-  return lane_paths.lane_issue_of(lane_paths.checkout_of(path4.resolve(checkout)), environment);
+  return lane_paths.lane_issue_of(lane_paths.checkout_of(path2.resolve(checkout)), environment);
 }
 function live_lane_count(checkout = process.cwd(), environment = process.env) {
   try {
     const lanes_root = lane_paths.lanes_root_of(checkout, environment);
     const own = own_lane(checkout, environment);
-    const issues = readdirSync2(lanes_root).filter(
+    const issues = readdirSync(lanes_root).filter(
       (name) => issue_number_shape.ISSUE_NUMBER_PATTERN.test(name)
     );
     return issues.filter((issue) => issue === own || !is_idle_lane(lanes_root, issue, environment)).length;
@@ -5665,8 +3109,8 @@ function live_lane_count(checkout = process.cwd(), environment = process.env) {
 var unit_lane_count = { live_lane_count };
 
 // scripts/test/unit-run-marker.ts
-import { readdirSync as readdirSync3 } from "node:fs";
-import path5 from "node:path";
+import { readdirSync as readdirSync2 } from "node:fs";
+import path3 from "node:path";
 var RUN_PREFIX = "josh-unit-running-";
 var MIN_WORKERS = 1;
 var SOLO_RUNS = 1;
@@ -5684,7 +3128,7 @@ function read_marker(source) {
 }
 function marker_files(directory = PLATFORM_TEMP_ROOT) {
   try {
-    return readdirSync3(directory).filter((name) => name.startsWith(RUN_PREFIX));
+    return readdirSync2(directory).filter((name) => name.startsWith(RUN_PREFIX));
   } catch {
     return [];
   }
@@ -5703,19 +3147,19 @@ function is_marker_live(source) {
   return false;
 }
 function live_run_count(directory = PLATFORM_TEMP_ROOT) {
-  return marker_files(directory).filter((name) => is_marker_live(path5.join(directory, name))).length;
+  return marker_files(directory).filter((name) => is_marker_live(path3.join(directory, name))).length;
 }
 var NESTED_KEY = "JOSH_UNIT_RUN_MARKED";
 var NESTED_VALUE = "1";
 function is_nested_run() {
   return process.env[NESTED_KEY] === NESTED_VALUE;
 }
-function resolve_unit_workers(available_cores, runs2) {
-  if (runs2 <= SOLO_RUNS) return void 0;
-  return Math.max(MIN_WORKERS, Math.floor(available_cores / runs2));
+function resolve_unit_workers(available_cores, runs) {
+  if (runs <= SOLO_RUNS) return void 0;
+  return Math.max(MIN_WORKERS, Math.floor(available_cores / runs));
 }
-function sharing_runs(runs2, lanes) {
-  return Math.max(runs2, lanes);
+function sharing_runs(runs, lanes) {
+  return Math.max(runs, lanes);
 }
 function mark_run_started(target) {
   try {
@@ -5765,13 +3209,13 @@ function cap_to_claim(share, claim) {
   const bound = Math.max(MIN_WORKERS2, (claim.granted ?? claim.weight) - MAIN_PROCESS_CORES);
   return Math.min(share ?? bound, bound);
 }
-function own_run2() {
+function own_run() {
   return is_nested_run2() ? 0 : SOLO_RUNS2;
 }
 function current_share(available_cores = availableParallelism(), live_runs = live_run_count2(), free = UNREAD_CAPACITY, live_lanes = SOLO_RUNS2) {
   const share = resolve_unit_workers2(
     available_cores,
-    sharing_runs2(live_runs + own_run2(), live_lanes)
+    sharing_runs2(live_runs + own_run(), live_lanes)
   );
   return cap_to_capacity(share, free, available_cores);
 }
@@ -5919,8 +3363,8 @@ function lightest_first(items, reserved_cores_of) {
   return items.toSorted((left, right) => reserved_cores_of(left) - reserved_cores_of(right));
 }
 function shared_cores(available_cores, concurrent_runs) {
-  const runs2 = Number.isFinite(concurrent_runs) ? Math.max(unit_worker_share.SOLO_RUNS, concurrent_runs) : unit_worker_share.SOLO_RUNS;
-  return Math.max(MIN_SHARED_CORES, Math.floor(available_cores / runs2));
+  const runs = Number.isFinite(concurrent_runs) ? Math.max(unit_worker_share.SOLO_RUNS, concurrent_runs) : unit_worker_share.SOLO_RUNS;
+  return Math.max(MIN_SHARED_CORES, Math.floor(available_cores / runs));
 }
 function resolve_concurrency(available_cores, concurrent_runs = unit_worker_share.SOLO_RUNS, checks = LANE_GATE_CHECKS2) {
   const share = shared_cores(available_cores, concurrent_runs);
@@ -6207,6 +3651,7 @@ var TEST_CHECK_COMMANDS = {
 
 // scripts/josh/josh-commands-development.ts
 var NARROWED = { arguments: "scripts/thing.ts", note: "narrow by the given files instead" };
+var FORWARDED_TO_VITEST = "flags are forwarded to vitest";
 var UNSEEDED = {};
 var FILE_ARGUMENTS = "[files...]";
 var REQUIRED_FILE_ARGUMENTS = "<files...>";
@@ -6248,13 +3693,14 @@ var DEV_COMMANDS = {
     script: "scripts/lint/lint-parallel-main.ts",
     description: "Check code with prettier and eslint (skips a tool a basic project lacks)",
     category: "Development",
-    reference: ["[--changed]", "developer", ["processes"]],
+    reference: ["[--changed] [--shard=<n>]", "developer", ["processes"]],
     core_weight: core_weights.CORE_WEIGHTS.lint,
     memory_mb: core_weights.MEMORY_MB.lint,
     usage: {
       examples: [
         { arguments: "" },
-        { arguments: "--changed", note: "the branch's changed files \u2014 the gate's form" }
+        { arguments: "--changed", note: "the branch's changed files \u2014 the gate's form" },
+        { arguments: "--shard=1", note: "one of two fixed halves of the tree (1 or 2) \u2014 a CI leg" }
       ]
     }
   },
@@ -6322,7 +3768,11 @@ var DEV_COMMANDS = {
     script: "scripts/rules/rule-value-cli.ts",
     description: "Print each delivered rule's unaided compliance \u2014 runs reached, kept rate, refusals",
     category: "AI tools",
-    reference: ["[--fresh | --refresh | --prose]", "developer", ["files"]],
+    reference: [
+      "[--fresh | --refresh | --period <days> | --weekly <rule-id>... | --prose]",
+      "developer",
+      ["files"]
+    ],
     usage: {
       examples: [
         { arguments: "", note: "a reading cached under 15 minutes ago, else measure" },
@@ -6331,6 +3781,14 @@ var DEV_COMMANDS = {
           arguments: "--refresh",
           note: "write the reading to the loop-head cache instead of stdout"
         },
+        {
+          arguments: "--period 7",
+          note: "measure only the transcripts written in the last 7 days, cache untouched"
+        },
+        {
+          arguments: "--weekly <rule-id>...",
+          note: "reached / refused / rephrased of the named rules, one line per week"
+        },
         { arguments: "--prose", note: "class each prose rule: enforced, measured or prose only" }
       ]
     }
@@ -6415,7 +3873,9 @@ var DEV_COMMANDS = {
     category: "Development",
     reference: [FILTER_ARGUMENTS, "developer", ["processes"]],
     ...gate_plan.DIRECT_UNIT_CLAIM,
-    usage: { examples: [{ arguments: "" }] }
+    usage: {
+      examples: [{ arguments: "" }, { arguments: "--shard=1/3", note: FORWARDED_TO_VITEST }]
+    }
   },
   "test:related": {
     script: "scripts/test/test-related-main.ts",
@@ -6426,8 +3886,8 @@ var DEV_COMMANDS = {
       examples: [
         { arguments: "" },
         NARROWED,
-        { arguments: "--touched", note: "only the diff's tests and its modules' same-named ones" },
-        { arguments: "--silent", note: "flags are forwarded to vitest" }
+        { arguments: "--touched", note: "diff tests, same-named tests and direct test importers" },
+        { arguments: "--silent", note: FORWARDED_TO_VITEST }
       ]
     }
   },
@@ -6635,7 +4095,7 @@ var LINT_COMMANDS = {
     script: "scripts/plan/plan-scaffold-cli.ts",
     description: "Print a work summary's inputs in one call: the run:prep skeleton, planned files near the line limit, the test:declared verdict, the owed cases and the plan:consumers draft",
     category: "AI tools",
-    reference: ["<issue> [<path>...]", "automation", ["network"]],
+    reference: ["<issue> [<path>...] [--estimate <json-file>]", "automation", ["network"]],
     usage: {
       examples: [
         { arguments: "123", note: "planned files from the issue body" },
@@ -7005,8 +4465,13 @@ var PROJECT_COMMANDS = {
     script: "scripts/sync/sync-main.ts",
     description: "Sync config files",
     category: "Project",
-    reference: ["", "developer", ["files"]],
-    usage: { examples: [{ arguments: "", note: "overwrite managed files" }] }
+    reference: ["[--force]", "developer", ["files"]],
+    usage: {
+      examples: [
+        { arguments: "", note: "overwrite managed files" },
+        { arguments: "--force", note: "also replace a file you added to, dropping your additions" }
+      ]
+    }
   },
   uninstall: {
     script: "scripts/uninstall/uninstall.ts",
@@ -7261,6 +4726,10 @@ var WORKFLOW_COMMANDS = {
         {
           names: [SKIP_COMMIT, SKIP_PUSH],
           description: "recover/open a PR without a new commit or push."
+        },
+        {
+          names: ["--body-file <path>"],
+          description: "extra PR body text after `closes #N`, from a file (`-` = stdin); use it when the text holds a backtick or `$`."
         }
       ]
     }
@@ -7538,35 +5007,6 @@ var COMMAND_MAP = {
 };
 
 export {
-  hook_context,
-  time_hook_transcript,
-  hook_payload_capture,
-  hook_tool_payload,
-  hook_decision,
-  time_bundle_call,
-  CHECK_STATUS_PENDING,
-  CHECK_STATUS_FAIL,
-  read_string,
-  parse_pr_state_snapshot,
-  missing_context_error,
-  blocked_cause,
-  REQUIRED_CHECKS,
-  is_merge_conflict,
-  is_coderabbit_check,
-  is_required_check,
-  collect_blocking_failures,
-  describe_pr_failure,
-  evaluate_pr_state,
-  is_review_decision_decisive,
-  PrConflictError,
-  time_reported_failure,
-  cost_attribute,
-  time_markers,
-  time_transcript_line,
-  time_spans,
-  time_round_trips,
-  time_search_call,
-  time_batch_guard,
   test_declared_logic,
   pnpm_reach,
   package_version_schema,