@joshuafolkken/kit 1.872.0

package/dist/hooks/chunk-Q32WETDO.js

@@ -0,0 +1,3265 @@
+import {
+  ENV_FILE_NAME
+} from "./chunk-LRYD2GLM.js";
+
+// scripts/josh/josh-command-types.ts
+var OPTIONAL_ENV_FILE_FLAGS = [`--env-file-if-exists=${ENV_FILE_NAME}`];
+var GATE_COMMAND = "gate";
+var PE = ["pnpm", "exec"];
+var ESLINT_CACHE_FILE = ".eslintcache";
+var TS_BUILD_INFO_FILE = ".tsbuildinfo";
+var CSPELL_CACHE_FILE = ".cspellcache";
+var ESLINT_EDIT_CACHE_FILE = ".eslintcache.edit";
+var ESLINT_RELATED_CACHE_FILE = ".eslintcache.related";
+var ROOTED_JSON_PORTABILITY = "rooted-json";
+var ESLINT_CACHE_SPEC = {
+  cache_file: ESLINT_CACHE_FILE,
+  portability: ROOTED_JSON_PORTABILITY
+};
+var TS_CACHE_SPEC = {
+  cache_file: TS_BUILD_INFO_FILE,
+  portability: "raw"
+};
+var CSPELL_CACHE_SPEC = {
+  cache_file: CSPELL_CACHE_FILE,
+  portability: "raw"
+};
+var GATE_CACHE_SPECS = [
+  ESLINT_CACHE_SPEC,
+  TS_CACHE_SPEC,
+  CSPELL_CACHE_SPEC
+];
+var GATE_CACHE_FILES = GATE_CACHE_SPECS.map((spec) => spec.cache_file);
+var IGNORED_CACHE_FILES = [
+  ...GATE_CACHE_FILES,
+  ESLINT_EDIT_CACHE_FILE,
+  ESLINT_RELATED_CACHE_FILE
+];
+var CONTENT_CACHE_FLAGS = ["--cache", "--cache-strategy", "content"];
+var CACHE_LOCATION_FLAG = "--cache-location";
+function content_cache_flags(cache_file) {
+  return [...CONTENT_CACHE_FLAGS, CACHE_LOCATION_FLAG, cache_file];
+}
+var ESLINT_CACHE_FLAGS = content_cache_flags(ESLINT_CACHE_FILE);
+var ESLINT_EDIT_CACHE_FLAGS = content_cache_flags(ESLINT_EDIT_CACHE_FILE);
+var ESLINT_RELATED_CACHE_FLAGS = content_cache_flags(ESLINT_RELATED_CACHE_FILE);
+var TS_CACHE_FLAGS = ["--incremental", "--tsBuildInfoFile", TS_BUILD_INFO_FILE];
+var CSPELL_CACHE_FLAGS = content_cache_flags(CSPELL_CACHE_FILE);
+
+// scripts/time-runtime/time-hook-transcript.ts
+import path3 from "node:path";
+
+// scripts/cost-runtime/cost-transcript.ts
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import path2 from "node:path";
+
+// scripts/lane/lane-paths.ts
+import path from "node:path";
+var LANE_ROOT_KEY = "JOSH_LANE_ROOT";
+var LANE_DIRECTORY_SUFFIX = "-lanes";
+var LANE_BRANCH_SUFFIX = "-lane";
+function default_lane_root(repository_root) {
+  const name = path.basename(repository_root);
+  return path.join(path.dirname(repository_root), `.${name}${LANE_DIRECTORY_SUFFIX}`);
+}
+function lane_root(repository_root, environment = process.env) {
+  const configured = environment[LANE_ROOT_KEY]?.trim() ?? "";
+  return configured.length === 0 ? default_lane_root(repository_root) : path.resolve(configured);
+}
+function lane_directory(root, issue) {
+  return path.join(root, issue);
+}
+var LANE_ISSUE_PATTERN = /^\d+$/u;
+var DEFAULT_LANE_ROOT_PATTERN = new RegExp(String.raw`^\..+${LANE_DIRECTORY_SUFFIX}$`, "u");
+function is_lane_root(directory, environment) {
+  const configured = environment[LANE_ROOT_KEY]?.trim() ?? "";
+  if (configured.length > 0) return path.resolve(configured) === directory;
+  return DEFAULT_LANE_ROOT_PATTERN.test(path.basename(directory));
+}
+function lane_issue_of(directory, environment = process.env) {
+  const resolved = path.resolve(directory);
+  const issue = path.basename(resolved);
+  if (!LANE_ISSUE_PATTERN.test(issue)) return void 0;
+  return is_lane_root(path.dirname(resolved), environment) ? issue : void 0;
+}
+function lane_branch(issue) {
+  return `${issue}${LANE_BRANCH_SUFFIX}`;
+}
+var lane_paths = {
+  LANE_BRANCH_SUFFIX,
+  LANE_ROOT_KEY,
+  default_lane_root,
+  lane_branch,
+  lane_directory,
+  lane_issue_of,
+  lane_root
+};
+
+// scripts/lib/json-value.ts
+function parse_or_undefined(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function is_record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var json_value = { parse_or_undefined, is_record };
+
+// scripts/time-runtime/time-instant.ts
+function parse_instant(raw) {
+  const parsed = Date.parse(raw ?? "");
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+var time_instant = { parse_instant };
+
+// scripts/cost-runtime/cost-usage.ts
+import { z } from "zod";
+var CACHE_CREATION_SCHEMA = z.object({
+  ephemeral_1h_input_tokens: z.number().nullish(),
+  ephemeral_5m_input_tokens: z.number().nullish()
+});
+var USAGE_SCHEMA = z.object({
+  input_tokens: z.number(),
+  cache_creation_input_tokens: z.number().nullish(),
+  cache_read_input_tokens: z.number().nullish(),
+  output_tokens: z.number(),
+  output_tokens_details: z.object({ thinking_tokens: z.number().nullish() }).nullish(),
+  cache_creation: CACHE_CREATION_SCHEMA.nullish()
+});
+var MESSAGE_SCHEMA = z.object({
+  id: z.string().nullish(),
+  model: z.string().nullish(),
+  usage: USAGE_SCHEMA.nullish()
+});
+var LINE_SCHEMA = z.object({
+  type: z.string(),
+  requestId: z.string().nullish(),
+  uuid: z.string().nullish(),
+  gitBranch: z.string().nullish(),
+  timestamp: z.string().nullish(),
+  message: MESSAGE_SCHEMA.nullish()
+});
+var SYNTHETIC_MODEL = "<synthetic>";
+var EMPTY_TOTALS = {
+  input_tokens: 0,
+  cache_write_5m_tokens: 0,
+  cache_write_1h_tokens: 0,
+  cache_read_tokens: 0,
+  output_tokens: 0,
+  thinking_tokens: 0,
+  thinking_measured: false
+};
+var UNKNOWN_MODEL = "unknown";
+var UNKNOWN_BRANCH = "";
+function split_cache_write(usage) {
+  const total = usage.cache_creation_input_tokens ?? 0;
+  const detail = usage.cache_creation;
+  if (!detail) return { write_5m: total, write_1h: 0 };
+  const write_1h = detail.ephemeral_1h_input_tokens ?? 0;
+  return { write_5m: detail.ephemeral_5m_input_tokens ?? total - write_1h, write_1h };
+}
+function thinking_usage(usage) {
+  const raw = usage.output_tokens_details?.thinking_tokens;
+  return { tokens: raw ?? 0, measured: raw !== null && raw !== void 0 };
+}
+function to_totals(usage) {
+  const { write_5m, write_1h } = split_cache_write(usage);
+  const thinking = thinking_usage(usage);
+  return {
+    input_tokens: usage.input_tokens,
+    cache_write_5m_tokens: write_5m,
+    cache_write_1h_tokens: write_1h,
+    cache_read_tokens: usage.cache_read_input_tokens ?? 0,
+    output_tokens: usage.output_tokens,
+    thinking_tokens: thinking.tokens,
+    thinking_measured: thinking.measured
+  };
+}
+function declared_id(data) {
+  return data.requestId ?? data.message?.id ?? data.uuid ?? void 0;
+}
+function request_id_of(data, usage) {
+  const fallback = `${data.timestamp ?? ""}-${String(usage.output_tokens)}`;
+  return declared_id(data) ?? fallback;
+}
+function to_record(data, usage) {
+  return {
+    request_id: request_id_of(data, usage),
+    model: data.message?.model ?? UNKNOWN_MODEL,
+    branch: data.gitBranch ?? UNKNOWN_BRANCH,
+    at_ms: time_instant.parse_instant(data.timestamp),
+    totals: to_totals(usage)
+  };
+}
+var ASSISTANT_TYPE = "assistant";
+function is_priced_line(data) {
+  return data.type === ASSISTANT_TYPE && data.message?.model !== SYNTHETIC_MODEL;
+}
+function classify(data) {
+  if (!is_priced_line(data)) return { kind: "skipped" };
+  const usage = data.message?.usage;
+  return usage ? { kind: "record", record: to_record(data, usage) } : { kind: "no_usage" };
+}
+function parse_line(line) {
+  if (line.trim() === "") return { kind: "skipped" };
+  const parsed = LINE_SCHEMA.safeParse(json_value.parse_or_undefined(line));
+  return parsed.success ? classify(parsed.data) : { kind: "malformed" };
+}
+function later_instant(left, right) {
+  if (left === void 0) return right;
+  if (right === void 0) return left;
+  return Math.max(left, right);
+}
+function dedupe(records) {
+  const by_id = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const seen = by_id.get(record.request_id);
+    const at_ms = later_instant(seen?.at_ms, record.at_ms);
+    by_id.set(record.request_id, { ...seen ?? record, at_ms });
+  }
+  return [...by_id.values()];
+}
+function add_totals(left, right) {
+  return {
+    input_tokens: left.input_tokens + right.input_tokens,
+    cache_write_5m_tokens: left.cache_write_5m_tokens + right.cache_write_5m_tokens,
+    cache_write_1h_tokens: left.cache_write_1h_tokens + right.cache_write_1h_tokens,
+    cache_read_tokens: left.cache_read_tokens + right.cache_read_tokens,
+    output_tokens: left.output_tokens + right.output_tokens,
+    thinking_tokens: left.thinking_tokens + right.thinking_tokens,
+    thinking_measured: left.thinking_measured || right.thinking_measured
+  };
+}
+function sum_totals(records) {
+  let total = EMPTY_TOTALS;
+  for (const record of records) total = add_totals(total, record.totals);
+  return total;
+}
+function billed_input(totals) {
+  return totals.input_tokens + totals.cache_write_5m_tokens + totals.cache_write_1h_tokens + totals.cache_read_tokens;
+}
+var cost_usage = {
+  EMPTY_TOTALS,
+  UNKNOWN_MODEL,
+  SYNTHETIC_MODEL,
+  parse_line,
+  dedupe,
+  add_totals,
+  sum_totals,
+  billed_input
+};
+
+// scripts/cost-runtime/cost-transcript.ts
+var TRANSCRIPT_ROOT = path2.join(".claude", "projects");
+var TRANSCRIPT_EXTENSION = ".jsonl";
+var SLUG_PATTERN = /[^a-zA-Z0-9-]/gu;
+var UNIT_DIRECTORY = "subagents";
+var UNIT_ID_SEPARATOR = "/";
+function project_slug(cwd) {
+  return cwd.replaceAll(SLUG_PATTERN, "-");
+}
+function transcript_directory(cwd, home = homedir()) {
+  return path2.join(home, TRANSCRIPT_ROOT, project_slug(cwd));
+}
+var GIT_ENTRY = ".git";
+var GITDIR_PREFIX = "gitdir:";
+var WORKTREE_SEGMENT = `/${GIT_ENTRY}/worktrees/`;
+var NOT_FOUND = -1;
+function linked_worktree_gitdir(cwd) {
+  try {
+    const contents = readFileSync(path2.join(cwd, GIT_ENTRY), "utf8").trim();
+    return contents.startsWith(GITDIR_PREFIX) ? contents.slice(GITDIR_PREFIX.length).trim() : "";
+  } catch {
+    return "";
+  }
+}
+function session_cwd(cwd) {
+  const gitdir = linked_worktree_gitdir(cwd);
+  const absolute = gitdir === "" ? "" : path2.resolve(cwd, gitdir);
+  const segment = absolute.indexOf(WORKTREE_SEGMENT);
+  return segment === NOT_FOUND ? cwd : absolute.slice(0, segment);
+}
+function read_directory(directory) {
+  try {
+    return readdirSync(directory);
+  } catch {
+    return [];
+  }
+}
+var LANE_ISSUE_SLUG = /^\d+$/u;
+function lane_transcript_directories(main_cwd, home) {
+  const projects = path2.join(home, TRANSCRIPT_ROOT);
+  const prefix = `${project_slug(lane_paths.lane_root(main_cwd))}-`;
+  return read_directory(projects).filter((name) => name.startsWith(prefix) && LANE_ISSUE_SLUG.test(name.slice(prefix.length))).map((name) => path2.join(projects, name));
+}
+function transcript_directories(cwd, home = homedir()) {
+  const own = transcript_directory(cwd, home);
+  const lanes = session_cwd(cwd) === cwd ? lane_transcript_directories(cwd, home) : [];
+  return [.../* @__PURE__ */ new Set([own, ...lanes])];
+}
+var OWN_DEPTH = 0;
+function home_directory() {
+  return homedir();
+}
+function to_session_file(full_path, session_id, depth) {
+  try {
+    return {
+      session_id,
+      path: full_path,
+      modified_ms: statSync(full_path).mtimeMs,
+      is_delegated: depth > OWN_DEPTH,
+      depth
+    };
+  } catch {
+    return void 0;
+  }
+}
+function is_transcript(name) {
+  return name.endsWith(TRANSCRIPT_EXTENSION);
+}
+function without_extension(name) {
+  return name.slice(0, -TRANSCRIPT_EXTENSION.length);
+}
+function own_files(directory, names) {
+  return names.filter((name) => is_transcript(name)).map((name) => to_session_file(path2.join(directory, name), without_extension(name), OWN_DEPTH)).filter((file) => file !== void 0);
+}
+function unit_directory(directory, session_id) {
+  return path2.join(directory, session_id, UNIT_DIRECTORY);
+}
+var UNIT_DEPTH = 1;
+function level_units(subagents_directory, prefix, depth) {
+  return read_directory(subagents_directory).filter((name) => is_transcript(name)).map(
+    (name) => to_session_file(
+      path2.join(subagents_directory, name),
+      `${prefix}${UNIT_ID_SEPARATOR}${without_extension(name)}`,
+      depth
+    )
+  ).filter((file) => file !== void 0);
+}
+function collect_units(subagents_directory, prefix, depth) {
+  const nested = read_directory(subagents_directory).filter((name) => !is_transcript(name)).flatMap(
+    (name) => collect_units(
+      unit_directory(subagents_directory, name),
+      `${prefix}${UNIT_ID_SEPARATOR}${name}`,
+      depth + 1
+    )
+  );
+  return [...level_units(subagents_directory, prefix, depth), ...nested];
+}
+function unit_files(directory, session_name) {
+  return collect_units(unit_directory(directory, session_name), session_name, UNIT_DEPTH);
+}
+function list_sessions(directory) {
+  const names = read_directory(directory);
+  const units = names.filter((name) => !is_transcript(name)).flatMap((name) => unit_files(directory, name));
+  return [...own_files(directory, names), ...units].toSorted(
+    (left, right) => right.modified_ms - left.modified_ms
+  );
+}
+function list_sessions_across(directories) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = directories.flatMap((directory) => list_sessions(directory));
+  const newest_first = merged.toSorted((left, right) => right.modified_ms - left.modified_ms);
+  const kept = [];
+  for (const file of newest_first) {
+    if (seen.has(file.session_id)) continue;
+    seen.add(file.session_id);
+    kept.push(file);
+  }
+  return kept;
+}
+function owning_session_id(file) {
+  const [owner] = file.session_id.split(UNIT_ID_SEPARATOR);
+  return owner ?? file.session_id;
+}
+function parent_session_id(file) {
+  const separator = file.session_id.lastIndexOf(UNIT_ID_SEPARATOR);
+  return separator === NOT_FOUND ? file.session_id : file.session_id.slice(0, separator);
+}
+function latest_own_index(files) {
+  const index = files.findIndex((file) => !file.is_delegated);
+  return index === -1 ? 0 : index;
+}
+function empty_session() {
+  return {
+    records: [],
+    no_usage_lines: 0,
+    malformed_lines: 0,
+    is_readable: false,
+    baseline_tokens: 0
+  };
+}
+function tally(content) {
+  const outcomes = content.split("\n").map((line) => cost_usage.parse_line(line));
+  const records = outcomes.flatMap(
+    (outcome) => outcome.kind === "record" ? [outcome.record] : []
+  );
+  const unique = cost_usage.dedupe(records);
+  const [first] = unique;
+  return {
+    records: unique,
+    no_usage_lines: outcomes.filter((outcome) => outcome.kind === "no_usage").length,
+    malformed_lines: outcomes.filter((outcome) => outcome.kind === "malformed").length,
+    is_readable: true,
+    baseline_tokens: first === void 0 ? 0 : cost_usage.billed_input(first.totals)
+  };
+}
+function read_text(file_path) {
+  try {
+    return readFileSync(file_path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function read_session(file) {
+  const content = read_text(file.path);
+  if (content === void 0) return { session_id: file.session_id, ...empty_session() };
+  return { session_id: file.session_id, ...tally(content) };
+}
+function read_raw(file) {
+  return read_text(file.path) ?? "";
+}
+function read_optional(file) {
+  return read_text(file.path);
+}
+function directory_exists(directory) {
+  try {
+    return statSync(directory).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function searched_directories(directories) {
+  return directories.map((directory) => ({
+    path: directory,
+    exists: directory_exists(directory)
+  }));
+}
+function describe_searched(directory) {
+  return `  ${directory.path} \u2014 ${directory.exists ? "no transcripts here" : "no such directory"}`;
+}
+function missing_message(searched, session_id) {
+  const lead = session_id === void 0 ? "No transcripts found. Searched:" : `No transcript named ${session_id}. Searched:`;
+  const listed = searched.map((directory) => describe_searched(directory));
+  if (session_id !== void 0) return [lead, ...listed];
+  return [
+    lead,
+    ...listed,
+    "Claude Code writes them per project; run this from the project it ran in."
+  ];
+}
+var cost_transcript = {
+  TRANSCRIPT_EXTENSION,
+  TRANSCRIPT_ROOT,
+  UNIT_DIRECTORY,
+  project_slug,
+  transcript_directory,
+  transcript_directories,
+  session_cwd,
+  unit_directory,
+  list_sessions,
+  list_sessions_across,
+  searched_directories,
+  owning_session_id,
+  parent_session_id,
+  latest_own_index,
+  tally,
+  read_session,
+  read_raw,
+  read_optional,
+  missing_message,
+  home_directory
+};
+
+// scripts/time-runtime/time-hook-transcript.ts
+var { TRANSCRIPT_EXTENSION: TRANSCRIPT_EXTENSION2 } = cost_transcript;
+var AGENT_PREFIX = "agent-";
+var AGENT_ID_PATTERN = /^[\w-]+$/u;
+function is_agent_id(value) {
+  return typeof value === "string" && AGENT_ID_PATTERN.test(value);
+}
+function fork_path(transcript_path, agent_id) {
+  const directory = path3.dirname(transcript_path);
+  const session_id = path3.basename(transcript_path, TRANSCRIPT_EXTENSION2);
+  const file_name = `${AGENT_PREFIX}${agent_id}${TRANSCRIPT_EXTENSION2}`;
+  return path3.join(cost_transcript.unit_directory(directory, session_id), file_name);
+}
+function transcript_of(transcript_path, agent_id) {
+  if (!is_agent_id(agent_id)) return transcript_path;
+  if (!transcript_path.endsWith(TRANSCRIPT_EXTENSION2)) return transcript_path;
+  return fork_path(transcript_path, agent_id);
+}
+var time_hook_transcript = {
+  fork_path,
+  transcript_of
+};
+
+// scripts/time-runtime/time-density-hook.ts
+import { closeSync, fstatSync, openSync, readSync } from "node:fs";
+
+// scripts/josh/stamp-file.ts
+import { createHash, randomUUID } from "node:crypto";
+import { lstatSync, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync } from "node:fs";
+import path5 from "node:path";
+
+// scripts/init/init-paths.ts
+import path4 from "node:path";
+import { fileURLToPath } from "node:url";
+var PACKAGE_DIR = path4.join(path4.dirname(fileURLToPath(import.meta.url)), "..", "..");
+var PROJECT_ROOT = process.cwd();
+
+// scripts/josh/platform-temporary.ts
+import { accessSync, constants } from "node:fs";
+import { tmpdir } from "node:os";
+var POSIX_TEMP_ROOT = "/tmp";
+var WINDOWS_PLATFORM = "win32";
+function is_writable_directory(directory) {
+  try {
+    accessSync(directory, constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolve_temporary_root(platform, can_write = is_writable_directory) {
+  if (platform === WINDOWS_PLATFORM) return tmpdir();
+  return can_write(POSIX_TEMP_ROOT) ? POSIX_TEMP_ROOT : tmpdir();
+}
+var PLATFORM_TEMP_ROOT = resolve_temporary_root(process.platform);
+
+// scripts/josh/stamp-file.ts
+var HASH_ALGORITHM = "sha256";
+var STAMP_SUFFIX = ".json";
+var STAMP_KEY_LENGTH = 16;
+var STAMP_FILE_MODE = 384;
+var STAMP_WRITE_FLAG = "wx";
+var STAMP_CREATE_FLAG = STAMP_WRITE_FLAG;
+var EXISTS_ERROR_CODE = "EEXIST";
+var ACCOUNT_KEY_SEPARATOR = ":";
+function digest(content) {
+  return createHash(HASH_ALGORITHM).update(content).digest("hex");
+}
+function account_key() {
+  return String(process.getuid?.() ?? "");
+}
+function stamp_path(prefix, root = PACKAGE_DIR, suffix = STAMP_SUFFIX) {
+  const key = digest(`${account_key()}${ACCOUNT_KEY_SEPARATOR}${root}`).slice(0, STAMP_KEY_LENGTH);
+  return path5.join(PLATFORM_TEMP_ROOT, `${prefix}${key}${suffix}`);
+}
+function write_exclusively(target, content) {
+  rmSync(target, { force: true });
+  writeFileSync(target, content, { flag: STAMP_WRITE_FLAG, mode: STAMP_FILE_MODE });
+  return target;
+}
+function write_stamp(target, payload) {
+  return write_exclusively(target, JSON.stringify(payload));
+}
+function replace_stamp(target, payload) {
+  const temporary = `${target}.${String(process.pid)}.${randomUUID()}`;
+  try {
+    writeFileSync(temporary, JSON.stringify(payload), {
+      flag: STAMP_CREATE_FLAG,
+      mode: STAMP_FILE_MODE
+    });
+    renameSync(temporary, target);
+    return target;
+  } finally {
+    rmSync(temporary, { force: true });
+  }
+}
+function write_text_stamp(target, text) {
+  return write_exclusively(target, text);
+}
+function create_stamp(target, payload) {
+  try {
+    writeFileSync(target, JSON.stringify(payload), {
+      flag: STAMP_CREATE_FLAG,
+      mode: STAMP_FILE_MODE
+    });
+    return true;
+  } catch (error) {
+    if (error.code === EXISTS_ERROR_CODE) return false;
+    throw error;
+  }
+}
+function remove_stamp(target) {
+  rmSync(target, { force: true });
+}
+function is_own_regular_file(source) {
+  const stats = lstatSync(source);
+  if (!stats.isFile()) return false;
+  const uid = process.getuid?.();
+  return uid === void 0 || stats.uid === uid;
+}
+function read_stamp_text(source) {
+  try {
+    if (!is_own_regular_file(source)) return void 0;
+    return readFileSync2(source, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+var stamp_file = {
+  create_stamp,
+  digest,
+  is_own_regular_file,
+  read_stamp_text,
+  replace_stamp,
+  remove_stamp,
+  stamp_path,
+  write_stamp,
+  write_text_stamp
+};
+
+// scripts/time-runtime/time-density-hook.ts
+import { z as z5 } from "zod";
+
+// scripts/cost-runtime/cost-blocks.ts
+import { z as z2 } from "zod";
+var CONTENT_ITEM_SCHEMA = z2.object({ text: z2.string().nullish() });
+var RESULT_CONTENT_SCHEMA = z2.union([z2.string(), z2.array(CONTENT_ITEM_SCHEMA)]);
+var BLOCK_SCHEMA = z2.object({
+  type: z2.string().nullish(),
+  text: z2.string().nullish(),
+  name: z2.string().nullish(),
+  input: z2.unknown().nullish(),
+  content: RESULT_CONTENT_SCHEMA.nullish()
+});
+var LINE_CONTENT_SCHEMA = z2.union([z2.string(), z2.array(BLOCK_SCHEMA)]);
+var MESSAGE_SCHEMA2 = z2.object({ content: LINE_CONTENT_SCHEMA.nullish() });
+var CONTENT_LINE_SCHEMA = z2.object({ type: z2.string(), message: MESSAGE_SCHEMA2.nullish() });
+var TEXT_TYPE = "text";
+var TOOL_USE_TYPE = "tool_use";
+var TOOL_RESULT_TYPE = "tool_result";
+var BASH_TOOL = "Bash";
+var COMMAND_KEY = "command";
+function json_of(value) {
+  return value === void 0 || value === null ? "" : JSON.stringify(value);
+}
+function split_bash_input(input) {
+  if (!json_value.is_record(input)) return { command: "", rest: json_of(input) };
+  const command = input[COMMAND_KEY];
+  const rest = Object.entries(input).filter(([key]) => key !== COMMAND_KEY);
+  return {
+    command: typeof command === "string" ? command : "",
+    rest: json_of(Object.fromEntries(rest))
+  };
+}
+function to_tool_use(block) {
+  const tool_name = block.name ?? "";
+  const is_bash = tool_name === BASH_TOOL;
+  const { command, rest } = is_bash ? split_bash_input(block.input) : { command: "", rest: json_of(block.input) };
+  return { type: TOOL_USE_TYPE, tool_name, command, text: rest };
+}
+function result_text(content) {
+  if (typeof content === "string") return content;
+  return content.map((item) => item.text ?? "").join("");
+}
+function to_plain_block(block) {
+  const base = { type: block.type ?? "", tool_name: "", command: "" };
+  const text = block.type === TOOL_RESULT_TYPE ? result_text(block.content ?? "") : block.text ?? "";
+  return { ...base, text };
+}
+function to_block(block) {
+  return block.type === TOOL_USE_TYPE ? to_tool_use(block) : to_plain_block(block);
+}
+function to_blocks(content) {
+  if (typeof content === "string") {
+    return [{ type: TEXT_TYPE, tool_name: "", command: "", text: content }];
+  }
+  return content.map((block) => to_block(block));
+}
+function content_of(line) {
+  const parsed = CONTENT_LINE_SCHEMA.safeParse(json_value.parse_or_undefined(line));
+  return parsed.success ? parsed.data.message?.content ?? void 0 : void 0;
+}
+function parse_line2(line) {
+  const content = content_of(line);
+  return content === void 0 ? [] : to_blocks(content);
+}
+function parse_content(text) {
+  return text.split("\n").flatMap((line) => parse_line2(line));
+}
+var cost_blocks = {
+  BASH_TOOL,
+  TEXT_TYPE,
+  TOOL_USE_TYPE,
+  TOOL_RESULT_TYPE,
+  parse_line: parse_line2,
+  parse_content
+};
+
+// 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/josh/josh-commands-issue.ts
+var ISSUES_WITH_REPO = "<issue...> [--repo <owner/repo>]";
+var ISSUE_COMMANDS = {
+  "issue:read": {
+    script: "scripts/issue/issue-read-cli.ts",
+    description: "Print each issue's title, body and every comment on it, in one call",
+    category: "AI tools",
+    reference: ["<issue...>", "automation", ["network"]]
+  },
+  "issue:state": {
+    script: "scripts/issue/issue-state-cli.ts",
+    description: "Print each issue's state and labels, in the spelling the documents compare against",
+    category: "AI tools",
+    reference: [ISSUES_WITH_REPO, "automation", ["network"]]
+  },
+  "issue:scout": {
+    script: "scripts/issue/issue-scout-cli.ts",
+    description: "Before filing: say whether an issue like this exists and which epic it belongs to",
+    category: "AI tools",
+    reference: ["<title> [--body <summary>]", "automation", ["network"]]
+  },
+  "issue:fold": {
+    script: "scripts/issue/issue-fold-cli.ts",
+    description: "Before a second filing: say whether findings from this session fold into one issue",
+    category: "AI tools",
+    reference: ["<title>... [--not-separable] [--json]", "automation", ["none"]]
+  },
+  "issue:cite": {
+    script: "scripts/issue/issue-cite-cli.ts",
+    description: "Print the paste-ready number-link citation line for each issue, in one call",
+    category: "AI tools",
+    reference: [ISSUES_WITH_REPO, "automation", ["network"]]
+  }
+};
+
+// scripts/josh/josh-commands-lane.ts
+var LANE_SCRIPT = "scripts/lane/lane-cli.ts";
+var LANE_ARGUMENTS = { script: LANE_SCRIPT, tsx_arguments: OPTIONAL_ENV_FILE_FLAGS };
+var ISSUE_WITH_OPTIONS = "<issue> [options]";
+var LANE_COMMANDS = {
+  "lane:open": {
+    ...LANE_ARGUMENTS,
+    description: "Open a lane: a linked work tree with its own branch and its own port seed",
+    category: "AI tools",
+    reference: [ISSUE_WITH_OPTIONS, "automation", ["files", "git"]],
+    default_script_arguments: ["open"]
+  },
+  "lane:close": {
+    ...LANE_ARGUMENTS,
+    description: "Close a lane, leaving no work tree, branch or directory behind",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["files", "git"]],
+    default_script_arguments: ["close"]
+  },
+  "lane:list": {
+    ...LANE_ARGUMENTS,
+    description: "List the open lanes: which issue, which ports, and where each one is",
+    category: "AI tools",
+    reference: ["", "automation", ["none"]],
+    default_script_arguments: ["list"]
+  },
+  "lane:prune": {
+    ...LANE_ARGUMENTS,
+    description: "Close every lane an interruption left without its work tree",
+    category: "AI tools",
+    reference: ["", "automation", ["files", "git"]],
+    default_script_arguments: ["prune"]
+  },
+  "lane:output": {
+    ...LANE_ARGUMENTS,
+    description: "Record, or read back, where the unit running a lane\u2019s child writes",
+    category: "AI tools",
+    reference: ["<issue> [path]", "automation", ["files"]],
+    default_script_arguments: ["output"]
+  },
+  "lane:dispatch": {
+    ...LANE_ARGUMENTS,
+    description: "Start a lane\u2019s child as a detached process that outlives this session",
+    category: "AI tools",
+    reference: ["<issue> <prompt>", "automation", ["processes"]],
+    default_script_arguments: ["dispatch"]
+  },
+  "lane:await": {
+    ...LANE_ARGUMENTS,
+    description: "Block until any of the named in-flight lane children completes; prints which one finished",
+    category: "AI tools",
+    reference: ["<issue> [<issue>...]", "automation", ["processes"]],
+    default_script_arguments: ["await"]
+  },
+  "lane:launch": {
+    script: "scripts/lane/lane-launch-cli.ts",
+    description: "Collapse a backlogrun lane-start event into one call: open the lane, pop and re-install on the first, dispatch the child",
+    category: "AI tools",
+    reference: ["<issue> [--stash <message>]", "automation", ["files", "git", "processes"]]
+  }
+};
+
+// scripts/josh/josh-commands-split.ts
+var SPLIT_COMMANDS = {
+  "split:assess": {
+    script: "scripts/split/split-assess-cli.ts",
+    description: "Measure the branch change size (tests excluded) and answer the split assessment size question: split | single",
+    category: "AI tools",
+    reference: ["[--json]", "automation", ["none"]]
+  }
+};
+
+// scripts/josh/josh-commands-ai.ts
+var RUN_HOLD_SCRIPT = "scripts/run/run-hold-cli.ts";
+var ISSUE_WITH_OPTIONS2 = "<issue> [options]";
+var AI_COMMANDS = {
+  ...ISSUE_COMMANDS,
+  "pkg:scout": {
+    script: "scripts/package/package-scout-cli.ts",
+    description: "Rank package candidates by measured metrics so the Package-First tier decision is read, not judged",
+    category: "AI tools",
+    reference: ["<keywords> [--size <n>]", "automation", ["network"]]
+  },
+  "stash:pop": {
+    script: "scripts/git/stash-pop-cli.ts",
+    description: "Pop the stash matching this message, not whichever a shared stack has on top",
+    category: "AI tools",
+    reference: ["<message>", "automation", ["git"]]
+  },
+  epic: {
+    script: "scripts-ai/epic.ts",
+    description: "Create an epic issue from its child issue numbers",
+    category: "AI tools",
+    reference: ["<title> <issue...> [--ordered]", "automation", ["network"]]
+  },
+  "epic:next": {
+    script: "scripts/epic/epic-next.ts",
+    description: "List an epic's runnable children, bundled per repository",
+    category: "AI tools",
+    reference: ["<epic>", "automation", ["network"]]
+  },
+  "epic:bundle": {
+    script: "scripts/epic/epic-bundle-cli.ts",
+    description: "Say whether a newly filed issue belongs with ones already in the backlog",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["network"]]
+  },
+  "epic:audit": {
+    script: "scripts/epic/epic-audit-cli.ts",
+    description: "Audit an epic's children against each other for contradictions",
+    category: "AI tools",
+    reference: ["<epic>", "automation", ["network"]]
+  },
+  "epic:check": {
+    script: "scripts-ai/epic-check.ts",
+    description: "Check an epic issue against the tracking requirements",
+    category: "AI tools",
+    reference: ["<epic>", "automation", ["network"]]
+  },
+  "auto-ok:next": {
+    script: "scripts/auto-ok/auto-ok-cli.ts",
+    description: "Print the next opted-in issue an unattended run may pick up outside an epic",
+    category: "AI tools",
+    reference: ["[--exclude <n>[,<n>...]] [--label <name>]", "automation", ["network"]]
+  },
+  "backlog:next": {
+    script: "scripts/backlog/backlog-next.ts",
+    description: "Order the whole opted-in backlog: auto-ok issues and the descendants of auto-ok epics, transitively through nested epics",
+    category: "AI tools",
+    reference: ["[--exclude <n>[,<n>...]] [--repo <owner/repo>]", "automation", ["network"]]
+  },
+  "backlog:offer": {
+    script: "scripts/backlog/backlog-offer-cli.ts",
+    description: "Collapse a backlogrun loop-head event into one call: read backlog:next, ask backlog:budget, return the verdict and any issues to start",
+    category: "AI tools",
+    reference: ["[options]", "automation", ["network"]]
+  },
+  "backlog:plan": {
+    script: "scripts/backlog/backlog-plan-cli.ts",
+    description: "Print the whole backlog as a plan: ready now, waiting on what, waiting on a person, out of scope",
+    category: "AI tools",
+    reference: ["[issue...] [--only]", "automation", ["network"]]
+  },
+  "backlog:budget": {
+    script: "scripts/backlog/backlog-budget-cli.ts",
+    description: "Say whether a backlogrun may start more work, keep watching, or finish",
+    category: "AI tools",
+    reference: ["[options]", "automation", ["none"]]
+  },
+  cost: {
+    script: "scripts/cost-runtime/cost-cli.ts",
+    description: "Report a run's token and credit cost from Claude Code's session transcripts",
+    category: "AI tools",
+    reference: ["[--cut|--over]", "automation", ["none"]]
+  },
+  "doc:section": {
+    script: "scripts/document/document-section-cli.ts",
+    description: 'Print one section of a markdown document, for a `file.md` \u2192 "Heading" reference',
+    category: "AI tools",
+    reference: ["<file> <heading>", "automation", ["none"]]
+  },
+  "read:set": {
+    script: "scripts/document/read-set-cli.ts",
+    description: "Print what an entry point reads before it starts, and what that read costs",
+    category: "AI tools",
+    reference: ["[<entry>] [--json]", "automation", ["none"]]
+  },
+  "doc:read": {
+    script: "scripts/document/document-read-cli.ts",
+    description: "Read a whole document safely: print it, or point at the Read tool when over the Bash cap",
+    category: "AI tools",
+    reference: ["<file>", "automation", ["none"]]
+  },
+  "read:files": {
+    script: "scripts/document/read-files-cli.ts",
+    description: "Read several files in one call so edit targets fold into one turn",
+    category: "AI tools",
+    reference: ["<path> [<path> ...]", "automation", ["none"]]
+  },
+  time: {
+    script: "scripts/time/time-cli.ts",
+    description: "Report where a run's wall clock went: model wait, tool execution, human wait",
+    category: "AI tools",
+    reference: ["[options]", "maintainer", ["none"]],
+    // Kit-only: it measures kit's own development runs and its report modules live under the
+    // undistributed `scripts/time/`, so it means nothing in a consumer project and is dropped from a
+    // consumer's help (joshuafolkken/kit#1997). The runtime analysis hooks and guards rely on stays
+    // distributed under `scripts/time-runtime/`.
+    is_kit_only: true
+  },
+  "review:brief": {
+    script: "scripts/review/review-brief-cli.ts",
+    description: "Print the whole /code-review invocation: level, what the gate already proved, target (--level-only for the level alone)",
+    category: "AI tools",
+    reference: ["[--round <1|2>] | --level-only [--staged] [--json]", "automation", ["files"]]
+  },
+  "review:attest": {
+    script: "scripts/review/review-attest-cli.ts",
+    description: "Record, or verify, which checkout a /code-review actually read",
+    category: "AI tools",
+    reference: ["<nonce> | --check", "automation", ["files"]]
+  },
+  "review:round2": {
+    script: "scripts/review/review-round2-cli.ts",
+    description: "Say whether the second /code-review round is due, or may be skipped entirely",
+    category: "AI tools",
+    reference: ["[--round-1-closed] [--json]", "automation", ["none"]]
+  },
+  delegate: {
+    script: "scripts/delegation/delegation-cli.ts",
+    description: "Say whether a run step may go to a cheaper execution tier",
+    category: "AI tools",
+    reference: ["<step> | --list", "automation", ["none"]]
+  },
+  "run:hold": {
+    script: RUN_HOLD_SCRIPT,
+    description: "Claim this working tree for a run, or say which run already holds it",
+    category: "AI tools",
+    reference: ["[issue]", "automation", ["files"]]
+  },
+  "run:release": {
+    script: RUN_HOLD_SCRIPT,
+    description: "Release this working tree's run record",
+    category: "AI tools",
+    reference: ["[issue|--force]", "automation", ["files"]],
+    default_script_arguments: ["--release"]
+  },
+  "run:carry": {
+    script: "scripts/run/run-carry-cli.ts",
+    description: "Carry one invocation\u2019s budget across its own session cuts",
+    category: "AI tools",
+    reference: ["<operation> [arguments...]", "automation", ["files"]]
+  },
+  "run:wake": {
+    script: "scripts/run/run-wake-cli.ts",
+    // `.env` rather than the ambient environment:
+    // the failure warning needs the Telegram credentials, the same
+    // reasons `notify` and `followup` carry these flags.
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
+    description: "Wake the next session of a cut backlogrun from outside the conversation",
+    category: "AI tools",
+    reference: ["[options]", "automation", ["processes", "notifications"]]
+  },
+  "run:cut": {
+    script: "scripts/run/run-cut-cli.ts",
+    description: "Cut a lane child before the gate and resume a fresh process",
+    category: "AI tools",
+    reference: ["[--resume] <issue>", "automation", ["files"]]
+  },
+  "run:liveness": {
+    script: "scripts/run/run-liveness-cli.ts",
+    description: "Say whether a delegated unit is still working, or stopped without reporting",
+    category: "AI tools",
+    reference: ["<issue> --output <path> [options]", "automation", ["processes"]]
+  },
+  "run:ending": {
+    script: "scripts/run/run-ending-cli.ts",
+    description: "Classify how a dispatched lane child ended (merged, cut, abandoned, unreadable)",
+    category: "AI tools",
+    reference: ["<issue> --output <path> [--repo <owner/repo>]", "automation", ["network"]]
+  },
+  "run:progress": {
+    script: "scripts/run/run-progress-cli.ts",
+    description: "Report an unattended run\u2019s progress once it has gone quiet for an interval",
+    category: "AI tools",
+    reference: ["[--wait|--mark]", "automation", ["files"]]
+  },
+  "run:prep": {
+    script: "scripts/run/run-prep-cli.ts",
+    description: "Bundle a run\u2019s pre-edit reads: body, comments, state, dependency scope",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["network"]]
+  },
+  "run:status": {
+    script: "scripts/run/run-status-cli.ts",
+    description: "Bundle a run\u2019s read-only status: issue state, cost verdict, carry counters",
+    category: "AI tools",
+    reference: ["<issue> [--repo <owner/repo>]", "automation", ["network"]]
+  },
+  "run:next": {
+    script: "scripts/run/run-next-cli.ts",
+    description: "Print the next step a fullrun takes, computed from the run\u2019s state",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["network"]]
+  },
+  "run:step": {
+    script: "scripts/run/run-step-cli.ts",
+    description: "Print the run\u2019s next single action, computed from the event stream, carry record and issue state",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["network", "files"]]
+  },
+  "repo:party": {
+    script: "scripts/discovery/repo-party-cli.ts",
+    description: "Say whether a repository is first-party or third-party by owner equality (computed, not judged)",
+    category: "AI tools",
+    reference: ["[<owner/repo>]", "automation", ["none"]]
+  },
+  "run:merge": {
+    script: "scripts/run/run-merge-cli.ts",
+    description: "Collapse a backlogrun merge event into one call: confirm the child, do the post-merge steps, offer the next child",
+    category: "AI tools",
+    reference: [ISSUE_WITH_OPTIONS2, "automation", ["git", "network"]]
+  },
+  "run:review": {
+    script: "scripts/run/run-review-cli.ts",
+    description: "Start the gate in the background and print the /code-review brief in one call so the two overlap (--join to join the gate and check its verdict)",
+    category: "AI tools",
+    reference: ["[--join]", "automation", ["processes", "files"]]
+  },
+  "run:event": {
+    script: "scripts/run/run-event-cli.ts",
+    description: "Append to or read the run\u2019s append-only event stream (--append <kind> <text> | --from|--follow <n> | --last)",
+    category: "AI tools",
+    reference: ["--append <kind> <text> | --from|--follow <n> | --last", "automation", ["files"]]
+  },
+  "run:report": {
+    script: "scripts/run/run-report-cli.ts",
+    description: "Generate the session-facing report from the run\u2019s event stream (merges, parks, cuts) with the release tail \u2014 the same text josh notify sends",
+    category: "AI tools",
+    reference: ["", "automation", ["files", "network"]]
+  },
+  ...LANE_COMMANDS,
+  "investigation:guard": {
+    script: "scripts/delegation/investigation-guard.ts",
+    description: "Claude Code hook: refuse a read once the unedited-read threshold is reached again (reads the tool call on stdin)",
+    category: "AI tools",
+    reference: ["", "automation", ["none"]]
+    // **No `tsx_arguments`, for the reason `batch:guard` declares none** (joshuafolkken/kit#1342):
+    // declaring any disqualifies a command from in-process dispatch, and this one runs in front of
+    // every read. The script calls `process.loadEnvFile` itself instead, through
+    // `hook-decision.ts`.
+  },
+  "rule:guard": {
+    script: "scripts/rules/rule-guard.ts",
+    description: "Claude Code hook: deliver a trigger-delivered rule at the call that binds it (reads the tool call on stdin)",
+    category: "AI tools",
+    reference: ["", "automation", ["none"]]
+    // **No `tsx_arguments`, for the reason the other two guards declare none**
+    // (joshuafolkken/kit#1342): declaring any disqualifies a command from in-process dispatch, and
+    // this one runs in front of every shell call.
+  },
+  "run:watcher:guard": {
+    script: "scripts/run/run-watcher-guard-cli.ts",
+    description: "Guard: exits non-zero when lane children are in-flight but the watcher has not pinged recently",
+    category: "AI tools",
+    reference: ["", "automation", ["none"]]
+  },
+  ...SPLIT_COMMANDS,
+  "oracle:list": {
+    script: "scripts/rules/oracle-list-cli.ts",
+    description: "Print the decision oracles \u2014 commands that answer a rule question mechanically",
+    category: "AI tools",
+    reference: ["", "automation", ["none"]]
+  },
+  eval: {
+    script: "scripts/eval/eval-run.ts",
+    description: "Run the agent rule-compliance scenarios (real Claude sessions)",
+    category: "AI tools",
+    reference: ["[scenario...]", "maintainer", ["processes", "network"]],
+    // Kit-only: it replays kit's own distributed rules against real Claude sessions, so it means
+    // nothing in a consumer project and is dropped from a consumer's help (joshuafolkken/kit#1988).
+    is_kit_only: true
+  }
+};
+
+// scripts/josh/josh-commands-clone.ts
+var CLONE_COMMANDS = {
+  "clone:scan": {
+    script: "scripts/clone/clone-scan-cli.ts",
+    description: "Count code duplication across files and first-party repositories, printing each clone as file:line pairs",
+    category: "AI tools",
+    reference: ["", "automation", ["files"]]
+  }
+};
+
+// scripts/josh/josh-commands-development.ts
+var FILE_ARGUMENTS = "[files...]";
+var REQUIRED_FILE_ARGUMENTS = "<files...>";
+var FILTER_ARGUMENTS = "[filters...]";
+var MATCH_ARGUMENTS = "[--match]";
+var PATH_ARGUMENTS = "<path...>";
+var DEV_COMMANDS = {
+  [GATE_COMMAND]: {
+    script: "scripts/gate/verification-gate.ts",
+    description: "Run lint, type check, spell check and unit tests concurrently",
+    category: "Development",
+    reference: ["[--verbose|--force|--no-unit]", "developer", ["files", "processes"]]
+  },
+  lint: {
+    script: "scripts/lint/lint-parallel.ts",
+    description: "Check code with prettier and eslint",
+    category: "Development",
+    reference: ["", "developer", ["processes"]]
+  },
+  "lint:related": {
+    script: "scripts/lint/lint-related.ts",
+    description: "Check only the changed files with prettier and eslint (whole tree on fallback)",
+    category: "Development",
+    reference: [FILE_ARGUMENTS, "developer", ["processes"]]
+  },
+  lines: {
+    script: "scripts/lines/lines-command.ts",
+    description: "Print a file's code lines against the max-lines limit and the headroom left",
+    category: "Development",
+    reference: [REQUIRED_FILE_ARGUMENTS, "developer", ["none"]]
+  },
+  "refactor:scan": {
+    script: "scripts/refactor/refactor-scan-cli.ts",
+    description: "List refactoring candidates in the changed scope by category and answer clear/candidates",
+    category: "Development",
+    reference: ["", "automation", ["processes"]]
+  },
+  bytes: {
+    script: "scripts/bytes/bytes-command.ts",
+    description: "Print an agent-read document's byte size against its ceiling and the headroom left",
+    category: "Development",
+    reference: [REQUIRED_FILE_ARGUMENTS, "developer", ["none"]]
+  },
+  "rule:value": {
+    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: ["", "developer", ["none"]]
+  },
+  format: {
+    // prettier first here, unlike `format:edited`, and deliberately: `eslint --fix` exits 1
+    // whenever a non-autofixable error remains, so putting it first behind `&&` would mean one
+    // unused variable anywhere in the tree stops prettier from running at all.
+    shell: [
+      "sh",
+      "-c",
+      `pnpm exec prettier --write . && pnpm exec eslint . --fix ${ESLINT_CACHE_FLAGS.join(" ")}`
+    ],
+    description: "Format code with prettier and eslint",
+    category: "Development",
+    reference: ["", "developer", ["files", "processes"]]
+  },
+  "format:edited": {
+    script: "scripts/hooks/format-edited-file.ts",
+    description: "Claude Code hook: format the file just edited (reads the tool call on stdin)",
+    category: "Development",
+    reference: ["", "automation", ["files", "processes"]]
+  },
+  "batch:guard": {
+    script: "scripts/hooks/batch-guard.ts",
+    description: "Claude Code hook: refuse a third consecutive single-call turn (reads the tool call on stdin)",
+    category: "Development",
+    reference: ["", "automation", ["none"]]
+    // **No `tsx_arguments`, deliberately.** `JOSH_BATCH_GUARD` is a per-machine preference kept in
+    // `.env`, which every other command reads through `OPTIONAL_ENV_FILE_FLAGS` — but declaring any
+    // `tsx_arguments` disqualifies a command from in-process dispatch (`josh-in-process.ts`), and
+    // this one runs before every `Bash` call. That is the hot path joshuafolkken/kit#1342 took a
+    // second ~0.16 s tsx start off. The script calls `process.loadEnvFile` itself instead, which is
+    // node's own `--env-file` parser with node's own precedence.
+  },
+  "pretool:guard": {
+    script: "scripts/hooks/pretool-guard.ts",
+    description: "Claude Code hook: the batch, investigation and rule guards in one process (reads the tool call on stdin)",
+    category: "Development",
+    reference: ["", "automation", ["none"]]
+    // **No `tsx_arguments`, deliberately**, the same as `batch:guard` above: this is the one
+    // PreToolUse hook consumers run before every guarded call, so it must stay eligible for
+    // in-process dispatch rather than pay a second tsx start. Each guard it composes loads `.env`
+    // through the shared loader.
+  },
+  "stop:guard": {
+    script: "scripts/hooks/stop-guard.ts",
+    description: "Claude Code Stop hook: deliver the three stop-time rules \u2014 hold notify/release and issue citation (reads the Stop payload on stdin)",
+    category: "Development",
+    reference: ["", "automation", ["none"]]
+    // **No `tsx_arguments`, deliberately**, the same as `pretool:guard` above: this runs at every
+    // turn end, so it must stay eligible for in-process dispatch rather than pay a second tsx start.
+    // It loads `.env` through the shared `hook-decision.ts` loader.
+  },
+  "session:lang": {
+    script: "scripts/josh/session-language-cli.ts",
+    description: "Claude Code hook: print the resolved JOSH_SESSION_LANG (defaults to ja) for the session context",
+    category: "Development",
+    reference: ["", "automation", ["none"]]
+    // **No `tsx_arguments`, deliberately**, the same as `batch:guard` above: this runs on every
+    // `UserPromptSubmit`, so it must stay eligible for in-process dispatch rather than pay a second
+    // tsx start each turn. It calls `process.loadEnvFile` itself through the shared loader.
+  },
+  "cspell:dot": {
+    script: "scripts/lint/cspell-cached.ts",
+    description: "Run spell check including dotfiles",
+    category: "Development",
+    reference: ["", "developer", ["processes"]]
+  },
+  "test:unit": {
+    script: "scripts/test/test-unit-guard.ts",
+    description: "Run unit tests with Vitest (skips when Vitest is absent; fails when it has no tests)",
+    category: "Development",
+    reference: [FILTER_ARGUMENTS, "developer", ["processes"]]
+  },
+  "test:related": {
+    script: "scripts/test/test-related.ts",
+    description: "Run only the unit tests related to the changed files (full suite on fallback)",
+    category: "Development",
+    reference: [FILE_ARGUMENTS, "developer", ["processes"]]
+  },
+  "test:declared": {
+    script: "scripts/test/test-declared.ts",
+    description: "Report whether the working-tree change needs a test (required/exempt/satisfied); --match checks Step 0 declarations on stdin",
+    category: "Development",
+    reference: [MATCH_ARGUMENTS, "developer", ["processes"]]
+  },
+  disposition: {
+    script: "scripts/review/disposition-cli.ts",
+    description: "Say whether a review finding reaches a runtime path (runtime) or is inert (non-runtime)",
+    category: "AI tools",
+    reference: [PATH_ARGUMENTS, "automation", ["none"]]
+  },
+  "e2e:retry-check": {
+    script: "scripts/test/e2e-retry-check.ts",
+    description: "Report whether the preview server crashed during a failed E2E attempt (CI)",
+    category: "Development",
+    reference: ["", "automation", ["none"]]
+  },
+  "test:e2e": {
+    script: "scripts/test/test-e2e-guard.ts",
+    description: "Run E2E tests with Playwright (skips when absent or no e2e files)",
+    category: "Development",
+    reference: [FILTER_ARGUMENTS, "developer", ["processes"]]
+  },
+  test: {
+    shell: ["sh", "-c", "pnpm josh test:unit && pnpm josh test:e2e"],
+    description: "Run unit and E2E tests",
+    category: "Development",
+    reference: ["", "developer", ["processes"]],
+    argument_targets: ["test:unit", "test:e2e"]
+  },
+  check: {
+    shell: [...PE, "tsc", "--noEmit", ...TS_CACHE_FLAGS],
+    description: "Type-check TypeScript project",
+    category: "Development",
+    reference: ["[arguments...]", "developer", ["processes"]]
+  },
+  port: {
+    script: "scripts/ports/port-command.ts",
+    description: "Print the PORT_SEED-resolved dev or preview port",
+    category: "Development",
+    reference: ["<dev|preview>", "developer", ["none"]]
+  }
+};
+
+// scripts/josh/josh-commands-hooks.ts
+var HOOKS_COMMANDS = {
+  "prevent-main-commit": {
+    script: "scripts/hooks/prevent-main-commit.ts",
+    description: "Git hook: block commits to main",
+    category: "Git hooks",
+    reference: ["", "automation", ["none"]]
+  },
+  "check-commit-message": {
+    script: "scripts/hooks/check-commit-message.ts",
+    description: "Git hook: validate commit message",
+    category: "Git hooks",
+    reference: ["[<message-file>]", "automation", ["none"]]
+  },
+  "secretlint-scan": {
+    script: "scripts/security/secretlint-scan.ts",
+    description: "Git hook: scan staged files for secrets",
+    category: "Git hooks",
+    reference: ["[paths...]", "automation", ["none"]]
+  },
+  "pre-push-unit": {
+    script: "scripts/hooks/pre-push-unit.ts",
+    description: "Git hook: run unit tests, reusing a green gate recorded on the pushed tree",
+    category: "Git hooks",
+    reference: ["", "automation", ["processes"]]
+  },
+  "pre-commit-type-check": {
+    script: "scripts/gate/pre-commit-type-check.ts",
+    description: "Git hook: type-check, reusing a green gate recorded on the committed tree",
+    category: "Git hooks",
+    reference: ["", "automation", ["processes"]]
+  }
+};
+
+// scripts/josh/josh-commands-lint.ts
+var LINT_COMMANDS = {
+  "issue:lint": {
+    script: "scripts/issue/issue-lint-cli.ts",
+    description: "Check an issue body file for the template's required headings",
+    category: "AI tools",
+    reference: ["<path>", "automation", ["files"]]
+  },
+  "issue:backlinks": {
+    script: "scripts/issue/issue-backlinks-cli.ts",
+    description: "Classify an origin issue\u2019s upstream backlinks: ok, missing, or wrong heading",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["network"]]
+  },
+  "report:lint": {
+    script: "scripts/report/report-lint-cli.ts",
+    description: "Check a two-layer work summary on stdin against its mechanical format rules",
+    category: "AI tools",
+    reference: ["(reads stdin)", "automation", ["none"]]
+  },
+  cases: {
+    script: "scripts/cases/cases-cli.ts",
+    description: "Read changed paths and print the I/O boundaries crossed and their mandatory abnormal cases: network | process | fs | none",
+    category: "AI tools",
+    reference: ["<path...>", "automation", ["files"]]
+  }
+};
+
+// scripts/josh/josh-commands-maintenance.ts
+var MAINTENANCE_COMMANDS = {
+  doctor: {
+    script: "scripts/doctor/doctor.ts",
+    description: "Diagnose PATH shadowing of the global josh and show the discovered repository map (--fix reclaims a stale shim)",
+    category: "Maintenance",
+    reference: ["[--fix]", "developer", ["files"]],
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS
+  },
+  overrides: {
+    script: "scripts/overrides/overrides-check.ts",
+    description: "Check pnpm overrides for drift",
+    category: "Maintenance",
+    reference: ["[--save]", "maintainer", ["files"]]
+  },
+  audit: {
+    script: "scripts/security/security-audit.ts",
+    description: "Run security audit",
+    category: "Maintenance",
+    reference: ["", "developer", ["processes"]]
+  },
+  "audit:provision": {
+    script: "scripts/security/security-audit-provision.ts",
+    description: "Install the pinned osv-scanner when the audit cannot find one (no-op if present)",
+    category: "Maintenance",
+    reference: ["", "automation", ["files", "network"]]
+  },
+  "reconcile-templates": {
+    script: "scripts/sync/reconcile-templates.ts",
+    description: "Record template source hashes (--check to verify drift)",
+    category: "Maintenance",
+    reference: ["", "maintainer", ["files"]]
+  },
+  latest: {
+    shell: [
+      "sh",
+      "-c",
+      "export NODE_AUTH_TOKEN=$(gh auth token) && pnpm josh latest:guard && pnpm josh latest:corepack && pnpm josh latest:update && pnpm josh ranges && pnpm josh audit && pnpm josh latest:scope --record"
+    ],
+    description: "Update pnpm, dependencies, and run security audit",
+    category: "Maintenance",
+    reference: ["", "maintainer", ["files", "network", "processes"]],
+    argument_targets: ["latest:corepack", "latest:update", "audit"]
+  },
+  "latest:scope": {
+    script: "scripts/version/latest-scope-cli.ts",
+    description: "Say whether this run has to update dependencies, from when josh latest last finished (--record notes a run)",
+    category: "Maintenance",
+    reference: ["[--record] [--json]", "automation", ["files"]],
+    // `JOSH_LATEST_MAX_AGE_HOURS` is documented as a project setting, so it has to be readable
+    // where the project keeps its settings — a variable that only works when exported from the
+    // shell is one a user follows the documentation for and gets the default from, silently.
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS
+  },
+  "latest:guard": {
+    script: "scripts/version/latest-lane-guard.ts",
+    description: "Refuse josh latest inside a lane (the update stamp is keyed to the project root)",
+    category: "Maintenance",
+    reference: ["", "automation", ["files"]]
+  },
+  "latest:corepack": {
+    script: "scripts/version/latest-corepack.ts",
+    description: "Update pnpm via corepack to the latest release on the current major",
+    category: "Maintenance",
+    reference: ["", "maintainer", ["files", "network"]]
+  },
+  "latest:update": {
+    script: "scripts/version/latest-update.ts",
+    description: "Update all dependencies to latest",
+    category: "Maintenance",
+    reference: ["", "maintainer", ["files", "network"]]
+  }
+};
+
+// scripts/josh/josh-commands-project.ts
+var PROJECT_COMMANDS = {
+  init: {
+    script: "scripts/init/init.ts",
+    description: "Initialize config in a new project",
+    category: "Project",
+    reference: ["", "developer", ["files", "processes"]]
+  },
+  sync: {
+    script: "scripts/sync/sync.ts",
+    description: "Sync config files",
+    category: "Project",
+    reference: ["", "developer", ["files"]]
+  },
+  "sync:scope": {
+    script: "scripts/sync/managed-config-scope-cli.ts",
+    description: "Say whether this change touches a file josh sync distributes",
+    category: "Project",
+    reference: ["[--staged] [--json]", "automation", ["none"]]
+  },
+  "sonar:hotspots": {
+    script: "scripts/sonar/sonar-hotspots-cli.ts",
+    description: "Fetch SonarCloud hotspots on a pull request and print each one's Step B disposition",
+    category: "Project",
+    reference: ["<PR>", "automation", ["network"]]
+  },
+  "ui:routes": {
+    script: "scripts/ui/ui-routes-cli.ts",
+    description: "List the screenshot-target routes the current change touches",
+    category: "Project",
+    reference: ["[--staged]", "automation", ["none"]]
+  },
+  propagate: {
+    script: "scripts/propagate/propagate.ts",
+    description: "Carry the published release into every consumer repository next to this one",
+    category: "Project",
+    reference: ["[--dry-run] [--skip-publish-wait]", "maintainer", ["files", "network"]]
+  },
+  adopt: {
+    script: "scripts/adopt/adopt.ts",
+    description: "Upgrade every installed @joshuafolkken toolkit here and open the pull request",
+    category: "Project",
+    reference: ["[--dry-run]", "developer", ["files", "git", "network", "processes"]]
+  }
+};
+
+// scripts/josh/josh-commands-versioning.ts
+var VERSIONING_COMMANDS = {
+  bump: {
+    script: "scripts/version/bump-version.ts",
+    description: "Bump package version",
+    category: "Versioning",
+    reference: ["[major|minor|patch]", "maintainer", ["files"]]
+  },
+  version: {
+    script: "scripts/version/version-check.ts",
+    description: "Show kit versions; --upgrade updates the global and project install",
+    category: "Versioning",
+    reference: ["[--upgrade]", "developer", ["files", "network", "processes"]]
+  },
+  // A `script` entry, not a shell one: script paths resolve against the kit package root, so this
+  // keeps working from a consumer repo where the file lives under node_modules. The registry
+  // probes need NODE_AUTH_TOKEN for any `@joshuafolkken/*` dependency; `josh latest` exports it
+  // before chaining here, exactly as it already does for `latest:update`.
+  ranges: {
+    script: "scripts/version/publishable-range-check.ts",
+    description: "Check that every published dependency range still resolves for a consumer",
+    category: "Versioning",
+    reference: ["", "developer", ["network"]]
+  },
+  // The one place that decides a version (joshuafolkken/kit#1169). A `script` entry for the same
+  // reason `ranges` is one: script paths resolve against the kit package root, so it keeps working
+  // from a consumer repository where the file lives under node_modules.
+  release: {
+    script: "scripts/release/release-cli.ts",
+    description: "Release the merges main has taken since the version last changed",
+    category: "Versioning",
+    reference: ["[version]", "maintainer", ["git", "network", "release"]]
+  },
+  // The read-only half of the one above (joshuafolkken/kit#1582). `release --dry-run` cannot
+  // answer this question: it refuses off the default branch and on a dirty tree, which is every
+  // position a run asks it from. A `script` entry for the same reason `release` is one.
+  "release:scope": {
+    script: "scripts/release/release-scope-cli.ts",
+    description: "Say whether a release is owed, from the unreleased merges on main",
+    category: "Versioning",
+    reference: ["[--json]", "automation", ["none"]]
+  }
+};
+
+// scripts/josh/josh-commands-workflow.ts
+var GIT_WORKFLOW_SCRIPT = "scripts-ai/git-workflow.ts";
+var GIT_MESSAGE_ARGUMENTS = "[-y] <message>";
+var WORKFLOW_COMMANDS = {
+  git: {
+    script: GIT_WORKFLOW_SCRIPT,
+    description: "Git workflow helper",
+    category: "Workflow",
+    reference: [GIT_MESSAGE_ARGUMENTS, "developer", ["git", "network"]]
+  },
+  pr: {
+    script: GIT_WORKFLOW_SCRIPT,
+    description: "Create PR only (skip commit and push)",
+    category: "Workflow",
+    // Not `GIT_MESSAGE_ARGUMENTS`: `-y` is already in the default arguments below, so advertising
+    // it would document a flag that cannot change what this command does.
+    reference: ["<message>", "developer", ["network"]],
+    default_script_arguments: ["-y", "--skip-commit", "--skip-push"]
+  },
+  // **The optional form, on both** (joshuafolkken/kit#1564). These two were the last commands
+  // passing the mandatory `--env-file=.env`, which node resolves before the script's first line: on
+  // a machine with no `.env` they died as `.env: not found` with exit code 9, even where
+  // `TELEGRAM_BOT_TOKEN` and `TELEGRAM_CHAT_ID` existed as real environment variables — a cloud
+  // session, and `followup` with them the merge step of every `fullrun` there. `doctor` was moved to
+  // this form for the same reason in joshuafolkken/kit#869.
+  //
+  // Nothing is lost by relaxing it: both scripts already call `load_optional_environment()`
+  // themselves, so the file is read either way and node's precedence — an existing environment
+  // variable wins over the file — is node's own in both spellings.
+  //
+  // **What the mandatory flag was accidentally providing was noise**, and that is replaced rather
+  // than dropped: `telegram_notify.send` now throws on missing credentials and on a failed send, so
+  // `josh notify` exits non-zero instead of warning and answering 0.
+  followup: {
+    script: "scripts-ai/git-followup-workflow.ts",
+    description: "Follow-up git workflow",
+    category: "Workflow",
+    reference: [
+      "<title> [--notify-message <text>]",
+      "automation",
+      ["git", "network", "notifications"]
+    ],
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS
+  },
+  notify: {
+    script: "scripts-ai/telegram-test.ts",
+    description: "Send Telegram notification",
+    category: "Workflow",
+    reference: ["--task-type <type> --body <text>", "automation", ["notifications"]],
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS
+  },
+  // The observation ledger's only commit path (joshuafolkken/kit#1756). `pnpm josh git` excludes the
+  // ledger from what it stages, so without this command a parent's appended line has no route to the
+  // default branch at all — and the recurrence count the promotion rule reads is a count of main.
+  "observations:flush": {
+    script: "scripts/observations/observations-flush-cli.ts",
+    description: "Commit the observation ledger as a pull request of its own, and merge it",
+    category: "Workflow",
+    reference: ["", "automation", ["git", "network"]]
+  },
+  // After a behavior-change Issue merges, re-run its declared baseline and print before/after; a value
+  // that did not move appends a refuted-premise line to the observation ledger (joshuafolkken/kit#2212).
+  "measure:rerun": {
+    script: "scripts/issue/measure-rerun-cli.ts",
+    description: "Re-run a merged issue\u2019s baseline command and print the before/after pair",
+    category: "Workflow",
+    reference: ["<path>", "automation", ["processes", "files"]]
+  },
+  // A script rather than an `sh -c` chain, because it has a precondition to enforce: run inside a
+  // linked work tree it would hijack the default branch from every other one (joshuafolkken/kit#1535).
+  "main:sync": {
+    script: "scripts/git/main-sync.ts",
+    description: "Checkout default branch and pull latest (refuses inside a lane)",
+    category: "Workflow",
+    reference: ["", "developer", ["git", "network"]]
+  },
+  // A script rather than an `sh -c` chain, because the strategy has to be named rather than left to
+  // the caller's git configuration: the `git pull` this replaced aborted with `Need to specify how
+  // to reconcile divergent branches` on exactly the diverged branch the command exists for
+  // (joshuafolkken/kit#1659).
+  "main:merge": {
+    script: "scripts/git/main-merge.ts",
+    description: "Merge origin default branch into the current branch",
+    category: "Workflow",
+    reference: ["", "developer", ["git", "network"]]
+  }
+};
+
+// scripts/josh/josh-command-map.ts
+var COMMAND_MAP = {
+  ...DEV_COMMANDS,
+  ...PROJECT_COMMANDS,
+  ...WORKFLOW_COMMANDS,
+  ...VERSIONING_COMMANDS,
+  ...MAINTENANCE_COMMANDS,
+  ...HOOKS_COMMANDS,
+  ...AI_COMMANDS,
+  ...LINT_COMMANDS,
+  ...CLONE_COMMANDS
+};
+var ALIASES = {
+  ga: "gate",
+  l: "lint",
+  lr: "lint:related",
+  ln: "lines",
+  by: "bytes",
+  f: "format",
+  fd: "format:edited",
+  bg: "batch:guard",
+  sd: "cspell:dot",
+  t: "test",
+  tu: "test:unit",
+  tr: "test:related",
+  td: "test:declared",
+  te: "test:e2e",
+  er: "e2e:retry-check",
+  sl: "session:lang",
+  c: "check",
+  pt: "port",
+  i: "init",
+  sy: "sync",
+  sys: "sync:scope",
+  g: "git",
+  gp: "pr",
+  fu: "followup",
+  nf: "notify",
+  obf: "observations:flush",
+  mrr: "measure:rerun",
+  ms: "main:sync",
+  mm: "main:merge",
+  bp: "bump",
+  re: "release",
+  res: "release:scope",
+  v: "version",
+  r: "ranges",
+  dr: "doctor",
+  pg: "propagate",
+  ad: "adopt",
+  ov: "overrides",
+  a: "audit",
+  ap: "audit:provision",
+  rt: "reconcile-templates",
+  u: "latest",
+  lg: "latest:guard",
+  lc: "latest:corepack",
+  lu: "latest:update",
+  ls: "latest:scope",
+  pm: "prevent-main-commit",
+  cm: "check-commit-message",
+  ss: "secretlint-scan",
+  ppu: "pre-push-unit",
+  ptc: "pre-commit-type-check",
+  ird: "issue:read",
+  ist: "issue:state",
+  isc: "issue:scout",
+  isf: "issue:fold",
+  ici: "issue:cite",
+  pks: "pkg:scout",
+  iln: "issue:lint",
+  ibl: "issue:backlinks",
+  rl: "report:lint",
+  ep: "epic",
+  ec: "epic:check",
+  en: "epic:next",
+  ea: "epic:audit",
+  eb: "epic:bundle",
+  ao: "auto-ok:next",
+  bl: "backlog:next",
+  blo: "backlog:offer",
+  blp: "backlog:plan",
+  bb: "backlog:budget",
+  co: "cost",
+  ds: "doc:section",
+  rs: "read:set",
+  dcr: "doc:read",
+  rf: "read:files",
+  rfs: "refactor:scan",
+  tm: "time",
+  rb: "review:brief",
+  r2: "review:round2",
+  ra: "review:attest",
+  dp: "disposition",
+  dg: "delegate",
+  rh: "run:hold",
+  rr: "run:release",
+  rc: "run:carry",
+  rw: "run:wake",
+  rct: "run:cut",
+  rv: "run:liveness",
+  red: "run:ending",
+  rg: "run:progress",
+  rp: "run:prep",
+  rst: "run:status",
+  rn: "run:next",
+  rsp: "run:step",
+  rpy: "repo:party",
+  rmg: "run:merge",
+  rrp: "run:report",
+  rrv: "run:review",
+  rev: "run:event",
+  sp: "stash:pop",
+  lno: "lane:open",
+  lnc: "lane:close",
+  lnl: "lane:list",
+  lnp: "lane:prune",
+  lnv: "lane:output",
+  lnd: "lane:dispatch",
+  lna: "lane:await",
+  lnla: "lane:launch",
+  rwg: "run:watcher:guard",
+  ig: "investigation:guard",
+  rug: "rule:guard",
+  ruv: "rule:value",
+  ptg: "pretool:guard",
+  sg: "stop:guard",
+  ev: "eval",
+  ol: "oracle:list",
+  sa: "split:assess",
+  shs: "sonar:hotspots",
+  uir: "ui:routes",
+  cs: "clone:scan",
+  ca: "cases"
+};
+function canonical_command(name) {
+  if (!Object.hasOwn(ALIASES, name)) return name;
+  return ALIASES[name] ?? name;
+}
+
+// scripts/time-runtime/time-shell.ts
+var BASH_SEPARATOR = ": ";
+var WHITESPACE_PATTERN = /\s+/u;
+var SEGMENT_PATTERN = /&&|\|\||;|\|/u;
+var PIPE_PATTERN = /(?<!\|)\|(?!\|)/u;
+var CHAIN_PATTERN = /&&|\|\||;/u;
+var QUOTED_SPAN_PATTERN = /'[^']*'|"[^"]*"/gu;
+var PIPEFAIL_PATTERN = /\bset\s+-[a-z]*o\s+pipefail\b/u;
+var COMMAND_WORD_PATTERN = /^[\w./@:+][\w./@:+-]*$/u;
+var ASSIGNMENT_PATTERN = /^\w+=/u;
+var SUBSHELL_OPENER = "$(";
+var FLAG_PREFIX = "-";
+var WRAPPER_COMMANDS = /* @__PURE__ */ new Set(["time", "env", "sudo"]);
+var NAVIGATION_COMMANDS = /* @__PURE__ */ new Set(["cd", "pushd", "popd", "export", "source", "set", "."]);
+var JOSH_PATTERN = /^(?:pnpm\s+(?:exec\s+)?)?josh\s+([a-z][\w:-]*)/u;
+var JOSH_PREFIX = "josh ";
+var COMMAND_KEY2 = "command";
+function bash_command(input) {
+  if (!json_value.is_record(input)) return "";
+  const command = input[COMMAND_KEY2];
+  return typeof command === "string" ? command : "";
+}
+function is_skippable(word) {
+  if (word.startsWith(FLAG_PREFIX)) return true;
+  return ASSIGNMENT_PATTERN.test(word) || WRAPPER_COMMANDS.has(word);
+}
+function command_words(segment) {
+  const words = segment.replaceAll(SUBSHELL_OPENER, " ").trim().split(WHITESPACE_PATTERN);
+  const start = words.findIndex((word) => !is_skippable(word));
+  return start === -1 ? [] : words.slice(start);
+}
+function segment_command(segment) {
+  const [head] = command_words(segment);
+  if (head === void 0 || NAVIGATION_COMMANDS.has(head)) return "";
+  return COMMAND_WORD_PATTERN.test(head) ? head : "";
+}
+function command_segment(command) {
+  return command.split(SEGMENT_PATTERN).find((segment) => segment_command(segment) !== "") ?? "";
+}
+function leading_word(command) {
+  return segment_command(command_segment(command));
+}
+function unquoted(command) {
+  return command.replaceAll(QUOTED_SPAN_PATTERN, " ");
+}
+function discarded_commands(command) {
+  const plain = unquoted(command);
+  if (PIPEFAIL_PATTERN.test(plain)) return [];
+  return plain.split(PIPE_PATTERN).slice(0, -1).map((segment) => segment.split(CHAIN_PATTERN).at(-1) ?? "");
+}
+function bash_label(command) {
+  const word = leading_word(command);
+  return word === "" ? cost_blocks.BASH_TOOL : `${cost_blocks.BASH_TOOL}${BASH_SEPARATOR}${word}`;
+}
+function josh_command_of_segment(segment) {
+  const name = JOSH_PATTERN.exec(command_words(segment).join(" "))?.[1];
+  return name === void 0 ? "" : `${JOSH_PREFIX}${canonical_command(name)}`;
+}
+function josh_command_of(command) {
+  return josh_command_of_segment(command_segment(command));
+}
+function josh_commands_of(command) {
+  return unquoted(command).split(SEGMENT_PATTERN).map((segment) => josh_command_of_segment(segment)).filter((name) => name !== "");
+}
+var REDIRECTION_CHARACTERS = ["<", ">"];
+function is_redirection(word) {
+  return REDIRECTION_CHARACTERS.some((character) => word.includes(character));
+}
+function ends_in_redirection(word) {
+  return REDIRECTION_CHARACTERS.some((character) => word.endsWith(character));
+}
+function drop_redirections(words) {
+  const kept = [];
+  let is_target2 = false;
+  for (const word of words) {
+    const is_dropped = is_target2 || is_redirection(word);
+    is_target2 = ends_in_redirection(word);
+    if (!is_dropped) kept.push(word);
+  }
+  return kept;
+}
+function josh_arguments(command) {
+  const text = command_words(command_segment(command)).join(" ");
+  const match = JOSH_PATTERN.exec(text);
+  if (match === null) return [];
+  const words = text.slice(match[0].length).split(WHITESPACE_PATTERN).filter((word) => word !== "");
+  return drop_redirections(words);
+}
+var time_shell = {
+  JOSH_PREFIX,
+  bash_command,
+  bash_label,
+  command_segment,
+  discarded_commands,
+  josh_arguments,
+  josh_command_of,
+  josh_commands_of,
+  leading_word,
+  unquoted
+};
+
+// scripts/time-runtime/time-background.ts
+var NO_BACKGROUND = "";
+var NO_FINISH = 0;
+var LAUNCH_PATTERN = /running in background with ID:\s*([\w-]+)/iu;
+var FINISH_PATTERN = /^<task-notification>[\s\S]*?<task-id>([\w-]+)<\/task-id>/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(text) {
+  return LAUNCH_PATTERN.exec(text)?.[1] ?? NO_BACKGROUND;
+}
+function finished_id(text) {
+  return FINISH_PATTERN.exec(text)?.[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(all) {
+  return all.filter((run) => run.is_read).toSorted((left, right) => right.started_ms - left.started_ms);
+}
+function own_run(span, all) {
+  return is_launch(span) ? all.find((run) => run.id === span.background_id) : void 0;
+}
+function placed(span, all, ordered) {
+  const own = own_run(span, all);
+  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 all = runs(spans);
+  if (all.length === 0) return [...spans];
+  const ordered = latest_first(all);
+  return spans.map((span) => placed(span, all, 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,
+  finished_id,
+  finished_at,
+  read_id,
+  read_id_of,
+  runs,
+  positioned,
+  unread_phases
+};
+
+// scripts/time-runtime/time-bundle-call.ts
+var { BASH_TOOL: BASH_TOOL2 } = 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_PATTERN2 = /\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_PREFIX2 = "-";
+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_PATTERN2).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_PREFIX2) || word.length < MIN_TARGET_LENGTH) return false;
+  return word.includes(PATH_SEPARATOR) || has_extension(word);
+}
+function targets_in(text) {
+  return words_of(text).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 value = input[field];
+  return typeof value === "string" ? value : "";
+}
+function field_targets(input) {
+  if (!json_value.is_record(input)) return [];
+  const value = input[TARGET_ARRAY_FIELD];
+  return Array.isArray(value) ? value.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_TOOL2) 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` (joshuafolkken/kit#1854), 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` (joshuafolkken/kit#1472), 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 (joshuafolkken/kit#1390), so the two scanners
+  // cannot come to disagree about where one word of a shell line ends and the next begins.
+  words_of,
+  // Exported for `time-writes.ts` (joshuafolkken/kit#1509), 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` (joshuafolkken/kit#1875), which pins that
+  // every name here is a real `josh` command and none of them writes.
+  READ_JOSH_SUBCOMMANDS
+};
+
+// scripts/time-runtime/time-format.ts
+var MS_PER_MINUTE = 6e4;
+var MS_PER_SECOND = 1e3;
+var MINUTE_DECIMALS = 1;
+var SECOND_DECIMALS = 1;
+var PERCENT_SCALE = 100;
+var PERCENT_DECIMALS = 1;
+var LABEL_WIDTH = 24;
+var MINUTES_WIDTH = 9;
+var NOT_MEASURED = "not measured";
+var NO_CALLS = "no tool call to divide";
+var NAKED_PREFIX = "naked ";
+var MODEL_LABEL = "model wait";
+var TOOL_LABEL = "tool execution";
+var HUMAN_LABEL = "human wait";
+var CI_LABEL = "CI wait";
+var MAX_ROWS = 15;
+var SUFFIX_SEPARATOR = " \xB7 ";
+var RANGE_SEPARATOR = " \u2013 ";
+var RUN_UNIT = "run(s)";
+var CLOCK_START = 11;
+var CLOCK_END = 19;
+var WINDOW_ARROW = " \u2192 ";
+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_minutes(duration_ms) {
+  return `${(duration_ms / MS_PER_MINUTE).toFixed(MINUTE_DECIMALS)} min`;
+}
+function format_seconds(duration_ms) {
+  return `${(duration_ms / MS_PER_SECOND).toFixed(SECOND_DECIMALS)} s`;
+}
+function format_share(part, whole) {
+  if (whole === 0) return "n/a";
+  return `${(part / whole * PERCENT_SCALE).toFixed(PERCENT_DECIMALS)}%`;
+}
+function usd(amount, decimals) {
+  return `$${amount.toFixed(decimals)}`;
+}
+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, format_minutes(duration_ms), suffix);
+}
+function unmeasured_row(label) {
+  return format_columns(label, "", NOT_MEASURED);
+}
+function format_spread(min, max, sample_count) {
+  const range = `${min}${RANGE_SEPARATOR}${max}`;
+  return `${range}${SUFFIX_SEPARATOR}${String(sample_count)} ${RUN_UNIT}`;
+}
+function format_clock(timestamp_ms) {
+  return new Date(timestamp_ms).toISOString().slice(CLOCK_START, CLOCK_END);
+}
+function format_window(started_ms3, ended_ms) {
+  return `${format_clock(started_ms3)}${WINDOW_ARROW}${format_clock(ended_ms)}`;
+}
+function note_lines(notes) {
+  return notes.map((note) => `  ${note}`);
+}
+var time_format = {
+  MAX_ROWS,
+  NO_CALLS,
+  NAKED_PREFIX,
+  SUFFIX_SEPARATOR,
+  NOT_MEASURED,
+  MODEL_LABEL,
+  TOOL_LABEL,
+  HUMAN_LABEL,
+  CI_LABEL,
+  overflow_line,
+  format_minutes,
+  format_seconds,
+  format_share,
+  usd,
+  format_columns,
+  format_row,
+  format_spread,
+  // `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.
+  format_window,
+  unmeasured_row,
+  note_lines
+};
+
+// scripts/git/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",
+  coderabbit_comments: "coderabbit-comments",
+  ai_review_comments: "ai-review-comments",
+  telegram: "telegram",
+  merge: "merge",
+  completion_and_epic_close: "completion-and-epic-close",
+  // 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"
+};
+function new_log() {
+  return { stages: [], last_ms: performance.now() };
+}
+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 line of format_stages(log)) console.info(line);
+}
+var git_followup_stages = {
+  STAGE,
+  STAGE_LINE_PREFIX,
+  STAGE_TOTAL_PREFIX,
+  new_log,
+  lap,
+  total_ms,
+  format_stages,
+  print_stages
+};
+
+// scripts/time-runtime/time-followup-stage.ts
+var LINE_SEPARATOR = "\n";
+var SECONDS_SUFFIX = " s";
+var DIGIT_OR_POINT = /[\d.]/u;
+var MS_PER_SECOND2 = 1e3;
+var NO_STAGES = [];
+function stage_body(line) {
+  const trimmed = line.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 text = body.trimEnd();
+  if (!text.endsWith(SECONDS_SUFFIX)) return void 0;
+  const head = text.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_SECOND2 };
+}
+function read_stages(text) {
+  if (!text.includes(git_followup_stages.STAGE_LINE_PREFIX)) return NO_STAGES;
+  return text.split(LINE_SEPARATOR).map((line) => stage_body(line)).filter((body) => body !== void 0).map((body) => to_stage(body)).filter((stage) => stage !== void 0);
+}
+var time_followup_stage = { NO_STAGES, read_stages };
+
+// 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(record) {
+  const declared = record.issue ?? UNATTRIBUTED_KEY;
+  return declared === UNATTRIBUTED_KEY ? issue_from_branch(record.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(value) {
+  return value !== void 0 && value !== 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((record) => record.issue ?? UNATTRIBUTED_KEY),
+    false
+  );
+}
+function attribute(records) {
+  const declared = records.map((record) => declared_issue(record));
+  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, record] of records.entries()) {
+    const bucket = grouped.get(issues[index] ?? UNATTRIBUTED_KEY) ?? [];
+    bucket.push(record);
+    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,
+  fill,
+  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_KEY = "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_LABELS_PATTERN = /repos\/\S+\/issues\/(\d+)\/labels\b(?!\/)/u;
+var IN_PROGRESS_FIELD = "labels[]=in-progress";
+var NO_ISSUE = cost_attribute.UNATTRIBUTED_KEY;
+function string_field(input, key) {
+  if (!json_value.is_record(input)) return "";
+  const value = input[key];
+  return typeof value === "string" ? value : "";
+}
+function skill_name(input) {
+  return string_field(input, SKILL_KEY);
+}
+function agent_marker(input) {
+  const prompt = string_field(input, PROMPT_KEY);
+  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_in_progress_label(command) {
+  return ISSUE_LABELS_PATTERN.test(command) && command.includes(IN_PROGRESS_FIELD);
+}
+var COMMAND_SEPARATOR = /&&|\|\||;/u;
+function label_issue(part) {
+  const matched = ISSUE_LABELS_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_in_progress_label(part)) return label_issue(part);
+  }
+  return NO_ISSUE;
+}
+function bash_marker(command) {
+  if (is_in_progress_label(command)) return WORKFLOW_MARKER;
+  return is_api_body_write(command) || is_issue_comment(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/lib/status-icons.ts
+var FAIL_ICON = "\u2717";
+var PASS_ICON = "\u2714";
+var status_icons = { FAIL_ICON, PASS_ICON };
+
+// scripts/josh/josh-verdict.ts
+var { FAIL_ICON: FAIL_ICON2, PASS_ICON: PASS_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 PASSED_VERDICT = "passed";
+var FAILED_VERDICT = "failed";
+function format_gate_passed(step_count, total) {
+  return `${GATE_PASSED_PREFIX} (${step_count} checks) 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(line) {
+  const trimmed = line.trimStart();
+  return trimmed.startsWith(GATE_OPENING_PREFIX) && trimmed.includes(GATE_OPENING_MARK);
+}
+function read_verdict(line) {
+  const trimmed = line.trimStart();
+  if (trimmed.startsWith(GATE_FAILED_PREFIX)) return FAILED_VERDICT;
+  if (trimmed.startsWith(GATE_PASSED_PREFIX)) return PASSED_VERDICT;
+  return void 0;
+}
+var josh_verdict = {
+  PASSED_VERDICT,
+  FAILED_VERDICT,
+  format_gate_passed,
+  format_gate_failed,
+  GATE_OPENING_MARK,
+  GATE_OPENING_PREFIX,
+  is_gate_opening,
+  read_verdict
+};
+
+// scripts/time-runtime/time-reported-failure.ts
+import { z as z3 } from "zod";
+var TEXT_BLOCK_SCHEMA = z3.object({ text: z3.string().nullish() });
+var CONTENT_SCHEMA = z3.union([z3.string(), z3.array(z3.unknown())]);
+var LINE_SEPARATOR2 = "\n";
+function block_text(block) {
+  const parsed = TEXT_BLOCK_SCHEMA.safeParse(block);
+  return parsed.success ? parsed.data.text ?? "" : "";
+}
+function result_text2(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_SEPARATOR2);
+}
+function is_failure_line(line) {
+  return line.trimStart().startsWith(status_icons.FAIL_ICON);
+}
+function is_failed_verdict(line) {
+  return josh_verdict.read_verdict(line) === josh_verdict.FAILED_VERDICT;
+}
+function is_passed_verdict(line) {
+  return josh_verdict.read_verdict(line) === josh_verdict.PASSED_VERDICT;
+}
+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, line) {
+  if (is_passed_verdict(line)) {
+    close_region(scan);
+    return;
+  }
+  if (is_failure_line(line)) {
+    note_failure(scan);
+    return;
+  }
+  if (josh_verdict.is_gate_opening(line)) scan.is_region_open = true;
+}
+function scan_body(lines) {
+  const scan = new_scan();
+  for (const line of lines) scan_line(scan, line);
+  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_text2(content).split(LINE_SEPARATOR2);
+  if (lines.some((line) => is_failed_verdict(line))) 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: result_text2, has_failure_line, is_reported_failure };
+
+// 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 = { CHECK_COMMANDS, NO_CHECK, check_key };
+
+// scripts/time-runtime/time-transcript-line.ts
+import { z as z4 } from "zod";
+var BLOCK_SCHEMA2 = z4.object({
+  type: z4.string().nullish(),
+  name: z4.string().nullish(),
+  id: z4.string().nullish(),
+  tool_use_id: z4.string().nullish(),
+  input: z4.unknown().nullish(),
+  // Whether the harness wrote this result back as a failure (joshuafolkken/kit#1309). Present on a
+  // `tool_result` block and on nothing else, and absent even there for the tools that never report
+  // one — which is why it is read as three answers rather than as a boolean with a default.
+  is_error: z4.boolean().nullish(),
+  // What the call printed. Read only to recover the outcome a pipeline threw away
+  // (joshuafolkken/kit#1361): it is kept as flattened text rather than as blocks, because that is
+  // the whole of what `time-reported-failure.ts` asks of it.
+  content: z4.unknown().nullish()
+});
+var CONTENT_SCHEMA2 = z4.union([z4.string(), z4.array(BLOCK_SCHEMA2)]);
+var MESSAGE_SCHEMA3 = z4.object({ id: z4.string().nullish(), content: CONTENT_SCHEMA2.nullish() });
+var LINE_SCHEMA2 = z4.object({
+  type: z4.string().nullish(),
+  timestamp: z4.string().nullish(),
+  // The branch the line was written on, which is where the issue number lives — `josh git` names a
+  // branch `<N>-<slug>`. Read here rather than re-parsed by a second reader so `josh time --issue`
+  // and `josh cost --issue` answer from the same field (joshuafolkken/kit#1268).
+  gitBranch: z4.string().nullish(),
+  // The two fields outside `message` that the harness writes an end-of-task notice on
+  // (joshuafolkken/kit#1696). **Both are read as `unknown` rather than as strings**: a schema
+  // insisting on a string here would reject every line whose `content` is a list of blocks — which is
+  // most of them — and a rejected line is dropped from the timeline entirely, so the shares would stop
+  // reconstructing the elapsed time. The shape is checked at the read below instead.
+  content: z4.unknown().nullish(),
+  attachment: z4.unknown().nullish(),
+  message: MESSAGE_SCHEMA3.nullish()
+});
+var UNKNOWN_BRANCH2 = "";
+var PROMPT_KEY2 = "prompt";
+var NO_MESSAGE_ID = "";
+var ERROR_TEXT_LIMIT = 256;
+var REFUSAL_MARKER = "\u26D4";
+function block_names(raw) {
+  return {
+    type: raw.type ?? "",
+    name: raw.name ?? "",
+    id: raw.id ?? "",
+    result_id: raw.tool_use_id ?? ""
+  };
+}
+function guard_from_refusal(text) {
+  const trimmed = text.trimStart();
+  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 to_block2(raw) {
+  const text = 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(text),
+    followup_stages: time_followup_stage.read_stages(text),
+    error_text: is_error === true ? text.slice(0, ERROR_TEXT_LIMIT) : "",
+    refusal_guard: is_error === true ? guard_from_refusal(text) : "",
+    background_id: time_background.launch_id(text)
+  };
+}
+function to_blocks2(content) {
+  return typeof content === "string" || content === null || content === void 0 ? [] : content.map((block) => to_block2(block));
+}
+function message_fields(message) {
+  return { message_id: message?.id ?? NO_MESSAGE_ID, blocks: to_blocks2(message?.content) };
+}
+function notice_text(data) {
+  const attachment = json_value.is_record(data.attachment) ? data.attachment[PROMPT_KEY2] : void 0;
+  const carried = [data.message?.content, data.content, attachment];
+  return carried.find((one) => typeof one === "string") ?? "";
+}
+function to_line(data) {
+  const timestamp_ms = time_instant.parse_instant(data.timestamp);
+  if (timestamp_ms === void 0) return void 0;
+  return {
+    type: data.type ?? "",
+    timestamp_ms,
+    branch: data.gitBranch ?? UNKNOWN_BRANCH2,
+    finished_background: time_background.finished_id(notice_text(data)),
+    ...message_fields(data.message)
+  };
+}
+function parse_line3(line) {
+  const parsed = LINE_SCHEMA2.safeParse(json_value.parse_or_undefined(line));
+  return parsed.success ? to_line(parsed.data) : void 0;
+}
+var time_transcript_line = {
+  ERROR_TEXT_LIMIT,
+  REFUSAL_MARKER,
+  NO_MESSAGE_ID,
+  guard_from_refusal,
+  parse_line: parse_line3
+};
+
+// 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-spans.ts
+var { NO_MESSAGE_ID: NO_MESSAGE_ID2, parse_line: parse_line4 } = time_transcript_line;
+var ASSISTANT_TYPE2 = "assistant";
+var USER_TYPE = "user";
+var UNKNOWN_TOOL = "unknown";
+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
+};
+var NO_CALL = {
+  label: "",
+  josh_command: "",
+  josh_commands: [],
+  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: [],
+  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: [],
+    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_shell.josh_command_of(command);
+  return {
+    label: time_shell.bash_label(command),
+    josh_command,
+    josh_commands: time_shell.josh_commands_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);
+}
+function tool_use_blocks(lines) {
+  return lines.flatMap(
+    (line) => line.blocks.filter((block) => block.type === cost_blocks.TOOL_USE_TYPE && block.id !== "").map((block) => ({ block, message_id: line.message_id }))
+  );
+}
+function collect_calls(lines) {
+  return new Map(
+    tool_use_blocks(lines).map(({ block, message_id }) => [
+      block.id,
+      to_tool_call(block.name, block.input, message_id)
+    ])
+  );
+}
+function result_block(line) {
+  return line.blocks.find((block) => block.type === cost_blocks.TOOL_RESULT_TYPE);
+}
+function event_of(line, category, call, result = NO_RESULT) {
+  return { timestamp_ms: line.timestamp_ms, branch: line.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(line, calls) {
+  const result = result_block(line);
+  if (result === void 0) return event_of(line, HUMAN_CATEGORY, NO_CALL);
+  const call = calls.get(result.result_id) ?? UNKNOWN_CALL;
+  return event_of(line, TOOL_CATEGORY, call, facts_of(result, call));
+}
+function to_event(line, calls) {
+  if (line.type === ASSISTANT_TYPE2) {
+    return event_of(line, MODEL_CATEGORY, { ...NO_CALL, message_id: line.message_id });
+  }
+  return line.type === USER_TYPE ? user_event(line, calls) : void 0;
+}
+function to_events(lines, calls) {
+  return lines.map((line) => to_event(line, 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,
+    check_key: event.check_key,
+    marker: event.marker,
+    is_bundleable: event.is_bundleable,
+    targets: event.targets,
+    is_writing: event.is_writing,
+    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(text) {
+  const lines = text.split("\n").map((line) => parse_line4(line)).filter((line) => line !== 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** (joshuafolkken/kit#1662): 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: ASSISTANT_TYPE2,
+  MODEL_CATEGORY,
+  TOOL_CATEGORY,
+  HUMAN_CATEGORY,
+  OK_OUTCOME,
+  FAILED_OUTCOME,
+  UNKNOWN_OUTCOME,
+  NO_MESSAGE_ID: NO_MESSAGE_ID2,
+  UNKNOWN_TOOL,
+  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 (joshuafolkken/kit#1344).
+  bash_label: time_shell.bash_label,
+  josh_command_of: time_shell.josh_command_of,
+  josh_commands_of: time_shell.josh_commands_of,
+  to_tool_call,
+  parse_line: parse_line4,
+  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 since joshuafolkken/kit#1406, 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 since joshuafolkken/kit#1385, 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 since joshuafolkken/kit#1309, 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,
+  // The four below are exported since joshuafolkken/kit#1406, when the model-gap walk moved to
+  // `time-model-gaps.ts` and needed the same predicates and the same opener test this walk uses. A
+  // private copy there would be the clone `CLAUDE.md` prohibits, in the one place a drift would have
+  // the distribution and the count disagreeing about what a round trip is.
+  is_call,
+  is_model,
+  opens_round_trip,
+  per_round_trip,
+  started_ms: started_ms2
+};
+
+// scripts/time-runtime/time-density.ts
+var MIN_ROUND_TRIPS = 10;
+var NOTICE_INTERVAL_MS = 3e5;
+var ONE_CALL = 1;
+var NONE2 = 0;
+function has_whole_tail(text) {
+  const last = text.split("\n").findLast((line) => line.trim() !== "");
+  return last !== void 0 && time_spans.parse_line(last) !== void 0;
+}
+function assistant_lines(text) {
+  return text.split("\n").map((line) => time_spans.parse_line(line)).filter((line) => line?.type === time_spans.ASSISTANT_TYPE);
+}
+function last_turn_calls(text) {
+  if (!has_whole_tail(text)) return NONE2;
+  const lines = assistant_lines(text);
+  const message_id = lines.at(-1)?.message_id;
+  if (message_id === void 0 || message_id === time_spans.NO_MESSAGE_ID) return NONE2;
+  return lines.filter((line) => line.message_id === message_id).flatMap((line) => line.blocks).filter((block) => block.type === cost_blocks.TOOL_USE_TYPE).length;
+}
+function read_window(text) {
+  const { spans } = time_spans.parse_timeline(text);
+  const round_trip_count = time_round_trips.count_round_trips(spans);
+  const call_count = time_round_trips.count_calls(spans);
+  return {
+    density: time_round_trips.per_round_trip(call_count, round_trip_count),
+    round_trip_count,
+    turn_calls: last_turn_calls(text)
+  };
+}
+function is_due(reading, since_last_ms) {
+  if (reading.round_trip_count < MIN_ROUND_TRIPS || reading.turn_calls !== ONE_CALL || !time_round_trips.is_below_floor(reading.density)) {
+    return false;
+  }
+  return since_last_ms >= NOTICE_INTERVAL_MS;
+}
+function format_notice(reading) {
+  const density = time_round_trips.format_density(reading.density);
+  const floor = time_round_trips.format_density(time_round_trips.CALLS_PER_ROUND_TRIP_FLOOR);
+  return `\u26A0 batching: ${density} calls per round trip over the last ${String(reading.round_trip_count)}, under the ${floor} floor, and this turn issued one call. Independent reads, greps, gh queries and edits go out together; the criterion is whether this call's input needs another call's result, not what kind of call it is \u2014 prompts/collaboration-workflow/turn-batching.md.`;
+}
+var time_density = {
+  MIN_ROUND_TRIPS,
+  NOTICE_INTERVAL_MS,
+  format_notice,
+  is_due,
+  last_turn_calls,
+  read_window
+};
+
+// scripts/time-runtime/time-density-hook.ts
+var TAIL_BYTES = 262144;
+var FILE_START = 0;
+var NOTICE_PREFIX = "josh-density-notice-";
+var NEVER_MS = 0;
+var payload_schema = z5.object({
+  transcript_path: z5.string().min(1).optional(),
+  // **`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 silence the line for every
+  // edit of the main line — the opposite of this module's stated failure direction.
+  agent_id: z5.string().nullish()
+});
+var notice_schema = z5.object({ notified_at_ms: z5.number() });
+function parse_transcript_path(raw_payload) {
+  const parsed = payload_schema.safeParse(JSON.parse(raw_payload));
+  if (!parsed.success || parsed.data.transcript_path === void 0) return void 0;
+  return time_hook_transcript.transcript_of(parsed.data.transcript_path, parsed.data.agent_id);
+}
+function read_tail(file_path, max_bytes = TAIL_BYTES) {
+  const descriptor = openSync(file_path, "r");
+  try {
+    const { size } = fstatSync(descriptor);
+    const length = Math.min(size, max_bytes);
+    const buffer = Buffer.alloc(length);
+    const read = readSync(descriptor, buffer, FILE_START, length, size - length);
+    return buffer.subarray(FILE_START, read).toString("utf8");
+  } finally {
+    closeSync(descriptor);
+  }
+}
+function notice_path(transcript_path) {
+  return stamp_file.stamp_path(NOTICE_PREFIX, transcript_path);
+}
+function last_notice_ms(source) {
+  const raw = stamp_file.read_stamp_text(source);
+  if (raw === void 0) return NEVER_MS;
+  try {
+    return notice_schema.parse(JSON.parse(raw)).notified_at_ms;
+  } catch {
+    return NEVER_MS;
+  }
+}
+function arm_throttle(target, now_ms) {
+  try {
+    stamp_file.write_stamp(target, { notified_at_ms: now_ms });
+  } catch {
+  }
+}
+function notice_for(raw_payload, now_ms) {
+  const transcript_path = parse_transcript_path(raw_payload);
+  if (transcript_path === void 0) return void 0;
+  const reading = time_density.read_window(read_tail(transcript_path));
+  const target = notice_path(transcript_path);
+  if (!time_density.is_due(reading, now_ms - last_notice_ms(target))) return void 0;
+  arm_throttle(target, now_ms);
+  return time_density.format_notice(reading);
+}
+function density_notice(raw_payload, now_ms = Date.now()) {
+  try {
+    return notice_for(raw_payload, now_ms);
+  } catch {
+    return void 0;
+  }
+}
+var time_density_hook = {
+  NOTICE_PREFIX,
+  TAIL_BYTES,
+  density_notice,
+  notice_path,
+  read_tail
+};
+
+export {
+  stamp_file,
+  json_value,
+  cost_blocks,
+  ESLINT_EDIT_CACHE_FLAGS,
+  time_shell,
+  time_bundle_call,
+  time_format,
+  time_transcript_line,
+  time_spans,
+  time_round_trips,
+  lane_paths,
+  cost_transcript,
+  time_hook_transcript,
+  time_density_hook
+};