@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-7Z25RNTV.js

@@ -0,0 +1,516 @@
+import {
+  eslint_warm
+} from "./chunk-AAIZ2H66.js";
+import {
+  format_steps
+} from "./chunk-XBXY3R4K.js";
+import {
+  eslint_daemon,
+  eslint_daemon_calls
+} from "./chunk-KTV2HNWB.js";
+import {
+  run_board_usage_rusage
+} from "./chunk-FCINBCKB.js";
+import {
+  time_batch_guard
+} from "./chunk-ZMWL7LZM.js";
+import {
+  time_round_trips,
+  time_spans
+} from "./chunk-NXWVWI4U.js";
+import {
+  cost_blocks
+} from "./chunk-LHKXJD6L.js";
+import {
+  time_hook_transcript,
+  transcript_tail
+} from "./chunk-2OMIHPPE.js";
+import {
+  ESLINT_EDIT_CACHE_FLAGS
+} from "./chunk-TBIX5FRN.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  direct_launch
+} from "./chunk-SVV4U5AR.js";
+import {
+  HOOK_PROCESS_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/time-runtime/time-density-hook.ts
+import { z } from "zod";
+
+// scripts/time-runtime/time-density.ts
+var MIN_ROUND_TRIPS = 10;
+var NOTICE_INTERVAL_MS = 3e5;
+var ONE_CALL = 1;
+var NONE = 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 NONE;
+  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 NONE;
+  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, candidates = "") {
+  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.${candidates}`;
+}
+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 NOTICE_PREFIX = "josh-density-notice-";
+var NEVER_MS = 0;
+var payload_schema = z.object({
+  transcript_path: z.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: z.string().nullish()
+});
+var notice_schema = z.object({ notified_at_ms: z.number() });
+var call_schema = z.object({ tool_name: z.string().min(1), tool_input: z.unknown() });
+function parse_transcript_path(raw_payload) {
+  const payload = json_value.parse_with(raw_payload, payload_schema);
+  if (payload?.transcript_path === void 0) return void 0;
+  return time_hook_transcript.transcript_of(payload.transcript_path, payload.agent_id);
+}
+function parse_call(raw_payload) {
+  const call = json_value.parse_with(raw_payload, call_schema);
+  if (call === void 0) return void 0;
+  return { name: call.tool_name, input: call.tool_input };
+}
+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;
+  return json_value.parse_with(raw, notice_schema)?.notified_at_ms ?? 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 tail = transcript_tail.read_tail(transcript_path);
+  const reading = time_density.read_window(tail);
+  const target = notice_path(transcript_path);
+  if (!time_density.is_due(reading, now_ms - last_notice_ms(target))) return void 0;
+  const candidates = time_batch_guard.pairing_candidates(tail, parse_call(raw_payload));
+  if (candidates === "") return void 0;
+  arm_throttle(target, now_ms);
+  return time_density.format_notice(reading, candidates);
+}
+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 = {
+  density_notice,
+  notice_path,
+  parse_call,
+  parse_transcript_path
+};
+
+// scripts/hooks/format-edited-file.ts
+import { existsSync as existsSync2 } from "node:fs";
+import path2 from "node:path";
+
+// scripts/lint/eslint-trim.ts
+var FOOTPRINT_LIMIT_MB = 600;
+var BYTES_PER_KB = 1024;
+var BYTES_PER_MB = BYTES_PER_KB * BYTES_PER_KB;
+function default_reader() {
+  return run_board_usage_rusage.rusage_reader(process.platform, run_board_usage_rusage.load_builtin);
+}
+function is_heavy(project_root, reader) {
+  const pid = eslint_daemon_calls.pid_of(eslint_daemon.read_record(project_root).daemon);
+  if (pid === void 0 || reader === void 0) return false;
+  const footprint_bytes = reader(Number(pid))?.footprint_bytes ?? 0;
+  return footprint_bytes > FOOTPRINT_LIMIT_MB * BYTES_PER_MB;
+}
+async function trim(project_root, reader = default_reader()) {
+  if (!is_heavy(project_root, reader) || !await eslint_daemon.stop(project_root)) return false;
+  eslint_warm.start(project_root);
+  return true;
+}
+var eslint_trim = { trim, BYTES_PER_MB, FOOTPRINT_LIMIT_MB };
+
+// scripts/hooks/format-edited-file.ts
+import { execa as execa2 } from "execa";
+import { z as z2 } from "zod";
+
+// scripts/hooks/edited-cspell.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { execa } from "execa";
+var CSPELL_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".svelte",
+  ".md",
+  ".mdx",
+  ".txt",
+  ".json",
+  ".jsonc",
+  ".yml",
+  ".yaml",
+  ".html",
+  ".css"
+]);
+var CSPELL_ARGS = [
+  "lint",
+  "--words-only",
+  "--unique",
+  "--no-progress",
+  "--no-summary"
+];
+var CSPELL_BIN = "cspell";
+var STDIN_SCHEME = "stdin://";
+var HEADER = "The edit hook found words cspell does not know; fix them or add them to `cspell.config.yaml` now rather than at the gate:";
+var MAX_DIAGNOSTIC_CHARS = 4e3;
+var TRUNCATION_NOTICE = "\n\u2026(unknown words truncated)";
+function is_checkable(file_path, project_root) {
+  if (!existsSync(file_path) || !CSPELL_EXTENSIONS.has(path.extname(file_path).toLowerCase())) {
+    return false;
+  }
+  const relative = path.relative(path.resolve(project_root), path.resolve(file_path));
+  return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function cspell_command(project_root) {
+  return direct_launch(project_root, ["exec", CSPELL_BIN]);
+}
+async function run_cspell(request) {
+  const launch = cspell_command(request.project_root);
+  const target = `${STDIN_SCHEME}${path.resolve(request.file_path)}`;
+  const result = await execa(launch.file, [...launch.args, ...CSPELL_ARGS, target], {
+    reject: false,
+    cwd: request.project_root,
+    input: request.text,
+    stdout: "pipe",
+    stderr: "ignore",
+    timeout: HOOK_PROCESS_TIMEOUT_MS
+  });
+  return result.stdout;
+}
+function format_unknown_words(stdout) {
+  const words = stdout.split("\n").map((word) => word.trim()).filter((word) => word.length > 0);
+  if (words.length === 0) return void 0;
+  const joined = words.join("\n");
+  const body = joined.length > MAX_DIAGNOSTIC_CHARS ? `${joined.slice(0, MAX_DIAGNOSTIC_CHARS)}${TRUNCATION_NOTICE}` : joined;
+  return `${HEADER}
+${body}`;
+}
+async function spelling_diagnostics(file_path, project_root, text, runner = run_cspell) {
+  if (file_path === void 0 || !is_checkable(file_path, project_root)) return void 0;
+  try {
+    return format_unknown_words(await runner({ file_path, project_root, text }));
+  } catch {
+    return void 0;
+  }
+}
+var edited_cspell = { cspell_command, format_unknown_words, run_cspell, spelling_diagnostics };
+
+// scripts/hooks/format-rewrite-notice.ts
+var MAX_REWRITE_CHARS = 600;
+var REWRITE_TRUNCATION_NOTICE = "\n\u2026(truncated)";
+var REWRITE_HEADER = "The format hook rewrote this file, so your copy is stale; re-read these lines before the next Edit.";
+var REWRITE_RANGE_PREFIX = "Lines ";
+var LINE_SEPARATOR = "\n";
+var FIRST_LINE = 1;
+function common_prefix_length(before, after) {
+  const limit = Math.min(before.length, after.length);
+  let index = 0;
+  while (index < limit && before[index] === after[index]) index += 1;
+  return index;
+}
+function common_suffix_length(before, after, prefix) {
+  const limit = Math.min(before.length, after.length) - prefix;
+  let index = 0;
+  while (index < limit && before.at(-1 - index) === after.at(-1 - index)) index += 1;
+  return index;
+}
+function changed_range(before, after) {
+  const before_lines = before.split(LINE_SEPARATOR);
+  const after_lines = after.split(LINE_SEPARATOR);
+  const prefix = common_prefix_length(before_lines, after_lines);
+  const last = after_lines.length - common_suffix_length(before_lines, after_lines, prefix);
+  return {
+    start_line: prefix + FIRST_LINE,
+    end_line: Math.max(prefix + FIRST_LINE, last),
+    body: after_lines.slice(prefix, last).join(LINE_SEPARATOR)
+  };
+}
+function cap_body(body, budget) {
+  if (body.length <= budget) return body;
+  return `${body.slice(0, Math.max(0, budget - REWRITE_TRUNCATION_NOTICE.length))}${REWRITE_TRUNCATION_NOTICE}`;
+}
+function build(before, after) {
+  if (before === after) return void 0;
+  const range = changed_range(before, after);
+  const head = `${REWRITE_HEADER}
+${REWRITE_RANGE_PREFIX}${String(range.start_line)}-${String(range.end_line)}:
+`;
+  return `${head}${cap_body(range.body, MAX_REWRITE_CHARS - head.length)}`;
+}
+function read_text(file_path) {
+  return file_path === void 0 ? "" : file_reader.read_if_readable(file_path) ?? "";
+}
+var rewrite_notice = { build, read_text };
+
+// scripts/hooks/format-edited-file.ts
+var hook_payload_schema = z2.object({
+  tool_input: z2.object({ file_path: z2.string().min(1) }).optional()
+});
+var PRETTIER_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".svelte",
+  ".json",
+  ".jsonc",
+  ".md",
+  ".yml",
+  ".yaml",
+  ".css",
+  ".html"
+]);
+var ESLINT_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".svelte"]);
+var EXCLUDED_ANYWHERE = /* @__PURE__ */ new Set(["node_modules", ".git"]);
+var EXCLUDED_AT_ROOT = /* @__PURE__ */ new Set(["dist", "build"]);
+var PARENT_SEGMENT = "..";
+var PRETTIER_BIN = "prettier";
+var PRETTIER_ARGUMENTS = ["--write", "--ignore-unknown"];
+var ESLINT_BIN = "eslint";
+var ESLINT_ARGUMENTS = [
+  "--fix",
+  "--no-error-on-unmatched-pattern",
+  ...ESLINT_EDIT_CACHE_FLAGS
+];
+var { ESLINT_DAEMON } = eslint_daemon;
+var DAEMON_RESTART = "restart";
+var DIAGNOSTIC_HEADER = "The edit hook could not auto-fix these lint problems; address them now rather than at the gate:";
+var MAX_DIAGNOSTIC_CHARS2 = 4e3;
+var DIAGNOSTIC_TRUNCATION_NOTICE = "\n\u2026(diagnostics truncated)";
+var SECTION_SEPARATOR = "\n\n";
+function parse_edited_path(raw_payload) {
+  return json_value.parse_with(raw_payload, hook_payload_schema)?.tool_input?.file_path;
+}
+function is_excluded(relative_path) {
+  const segments = relative_path.split(path2.sep);
+  return segments.some((segment) => EXCLUDED_ANYWHERE.has(segment)) || EXCLUDED_AT_ROOT.has(segments[0] ?? "");
+}
+function relative_to_root(project_root, file_path) {
+  const relative = path2.relative(path2.resolve(project_root), path2.resolve(file_path));
+  const is_inside_root = relative !== "" && relative.split(path2.sep)[0] !== PARENT_SEGMENT && !path2.isAbsolute(relative);
+  return is_inside_root ? relative : void 0;
+}
+function is_formattable(file_path, project_root) {
+  const relative = relative_to_root(project_root, file_path);
+  return relative !== void 0 && !is_excluded(relative) && existsSync2(file_path);
+}
+function plan_commands(file_path, project_root) {
+  if (!is_formattable(file_path, project_root)) return [];
+  const extension = path2.extname(file_path).toLowerCase();
+  const commands = [];
+  if (ESLINT_EXTENSIONS.has(extension)) {
+    commands.push({ bin: ESLINT_BIN, command_arguments: [...ESLINT_ARGUMENTS, file_path] });
+  }
+  if (PRETTIER_EXTENSIONS.has(extension)) {
+    commands.push({ bin: PRETTIER_BIN, command_arguments: [...PRETTIER_ARGUMENTS, file_path] });
+  }
+  return commands;
+}
+function select_invocation(command, routes) {
+  if (routes.daemon_cli !== void 0) {
+    return {
+      bin: process.execPath,
+      command_arguments: [routes.daemon_cli, ...command.command_arguments]
+    };
+  }
+  return { bin: routes.launch.file, command_arguments: routes.launch.args };
+}
+var DAEMON_BINS = /* @__PURE__ */ new Set([ESLINT_BIN, ESLINT_DAEMON]);
+function resolve_daemon_cli(bin, project_root) {
+  if (!DAEMON_BINS.has(bin)) return void 0;
+  return eslint_daemon.resolve_daemon_cli(project_root);
+}
+function plan_daemon_restart(file_path, project_root) {
+  const relative = relative_to_root(project_root, file_path);
+  if (relative === void 0 || !eslint_daemon.is_config_input(relative) || resolve_daemon_cli(ESLINT_DAEMON, project_root) === void 0) {
+    return [];
+  }
+  return [{ bin: ESLINT_DAEMON, command_arguments: [DAEMON_RESTART] }];
+}
+function resolve_invocations(command, project_root) {
+  const routes = {
+    daemon_cli: resolve_daemon_cli(command.bin, project_root),
+    launch: direct_launch(project_root, ["exec", command.bin, ...command.command_arguments])
+  };
+  const without_daemon = select_invocation(command, { ...routes, daemon_cli: void 0 });
+  if (routes.daemon_cli === void 0) return [without_daemon];
+  return [select_invocation(command, routes), without_daemon];
+}
+function is_start_failure(outcome) {
+  return outcome.exit_code !== 0 && outcome.stdout.length === 0;
+}
+async function spawn_invocation(invocation, project_root) {
+  const result = await execa2(invocation.bin, [...invocation.command_arguments], {
+    reject: false,
+    cwd: project_root,
+    env: eslint_daemon.launch_environment(),
+    stdout: "pipe",
+    stderr: "ignore",
+    timeout: HOOK_PROCESS_TIMEOUT_MS
+  });
+  return { exit_code: result.exitCode ?? 1, stdout: result.stdout };
+}
+async function run_command(command, project_root) {
+  let outcome = { exit_code: 0, stdout: "" };
+  for (const invocation of resolve_invocations(command, project_root)) {
+    outcome = await spawn_invocation(invocation, project_root);
+    if (!is_start_failure(outcome)) return outcome;
+  }
+  return outcome;
+}
+function eslint_unfixed(command, outcome) {
+  if (command.bin !== ESLINT_BIN || outcome.exit_code === 0 || outcome.stdout.length === 0) {
+    return void 0;
+  }
+  return outcome.stdout;
+}
+function format_diagnostics(unfixed) {
+  if (unfixed === void 0) return void 0;
+  const is_over = unfixed.length > MAX_DIAGNOSTIC_CHARS2;
+  const body = is_over ? `${unfixed.slice(0, MAX_DIAGNOSTIC_CHARS2)}${DIAGNOSTIC_TRUNCATION_NOTICE}` : unfixed;
+  return `${DIAGNOSTIC_HEADER}
+${body}`;
+}
+async function collect_unfixed(plan, runner, project_root) {
+  const results = await format_steps.in_order(plan, async (command) => {
+    try {
+      return eslint_unfixed(command, await runner(command, project_root));
+    } catch {
+      return "";
+    }
+  });
+  return results.findLast(Boolean) ?? "";
+}
+function linted_path(plan, file_path, project_root) {
+  if (plan.every((command) => command.bin !== ESLINT_BIN)) return void 0;
+  return relative_to_root(project_root, file_path);
+}
+async function record_lint(project_root) {
+  const call = { caller: eslint_daemon_calls.DAEMON_CALLER.EDIT_HOOK, files: 1 };
+  eslint_daemon.record_call(project_root, call);
+  await eslint_trim.trim(project_root);
+}
+async function format_edited_file(raw_payload, runner, project_root) {
+  const file_path = parse_edited_path(raw_payload);
+  if (file_path === void 0) return void 0;
+  const plan = [
+    ...plan_commands(file_path, project_root),
+    ...plan_daemon_restart(file_path, project_root)
+  ];
+  const daemon_before = eslint_daemon.read_record(project_root);
+  const unfixed = await collect_unfixed(plan, runner, project_root);
+  const linted = linted_path(plan, file_path, project_root);
+  eslint_daemon.remember_after_edit(project_root, daemon_before, linted);
+  if (linted !== void 0) await record_lint(project_root);
+  return format_diagnostics(unfixed === "" ? void 0 : unfixed);
+}
+async function format_edited_payload(raw_payload, project_root) {
+  return await format_edited_file(raw_payload, run_command, project_root);
+}
+var HOOK_EVENT_NAME = "PostToolUse";
+function build_envelope(additional_context) {
+  return JSON.stringify({
+    hookSpecificOutput: { hookEventName: HOOK_EVENT_NAME, additionalContext: additional_context }
+  });
+}
+function compose_context(notice, diagnostics) {
+  const sections = [notice, diagnostics].filter(
+    (section) => section !== void 0
+  );
+  return sections.length === 0 ? void 0 : sections.join(SECTION_SEPARATOR);
+}
+function report_no_payload() {
+  process.stderr.write(
+    "format:edited reads a Claude Code PostToolUse payload on stdin; it is not run by hand.\n"
+  );
+}
+async function run_hook(payload) {
+  const notice = time_density_hook.density_notice(payload);
+  const file_path = parse_edited_path(payload);
+  const before = rewrite_notice.read_text(file_path);
+  const pending_spelling = edited_cspell.spelling_diagnostics(file_path, process.cwd(), before);
+  const lint = await format_edited_payload(payload, process.cwd());
+  const rewrite = rewrite_notice.build(before, rewrite_notice.read_text(file_path));
+  const spelling = await pending_spelling;
+  const parts = compose_context(rewrite, compose_context(lint, spelling));
+  const context = compose_context(notice, parts);
+  if (context !== void 0) process.stdout.write(`${build_envelope(context)}
+`);
+}
+
+export {
+  time_density_hook,
+  format_edited_payload,
+  build_envelope,
+  compose_context,
+  report_no_payload,
+  run_hook
+};

package/dist/commands/chunk-A73RWSHJ.js

@@ -0,0 +1,126 @@
+import {
+  run_hold
+} from "./chunk-NQ4D2XZY.js";
+import {
+  lane_state
+} from "./chunk-V36OV7AP.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/run/run-halfrun-resume.ts
+var MARKED = "marked";
+var FOREIGN = "foreign";
+var UNREADABLE = "unreadable";
+function hold_of(read) {
+  return read.kind === "held" || read.kind === "stale" ? read.hold : void 0;
+}
+function is_stop_record(read, issue) {
+  const hold = hold_of(read);
+  return hold?.issue === issue && hold.is_halfrun_stop === true;
+}
+function is_halfrun_stop(read, issue, is_dirty) {
+  return is_dirty && is_stop_record(read, issue);
+}
+function is_own_record(read, issue) {
+  const hold = hold_of(read);
+  return hold === void 0 || hold.issue === issue || hold.issue === run_hold.UNNUMBERED_ISSUE;
+}
+function mark_stop_at(target, issue, mark = run_hold.HALFRUN_STOP_FIELDS) {
+  const read = run_hold.read_hold(target);
+  if (read.kind === "unreadable") return UNREADABLE;
+  if (!is_own_record(read, issue)) return FOREIGN;
+  run_hold.release_hold(target);
+  return run_hold.create_stop_hold(target, issue, mark) ? MARKED : FOREIGN;
+}
+function take_over(target, issue) {
+  run_hold.release_hold(target);
+  return run_hold.create_hold(target, issue, /* @__PURE__ */ new Date(), true);
+}
+function reopen_at(target, issue) {
+  const read = run_hold.read_hold(target);
+  if (read.kind === "unreadable") return UNREADABLE;
+  if (!is_stop_record(read, issue)) return FOREIGN;
+  run_hold.release_hold(target);
+  return run_hold.create_hold(target, issue) ? MARKED : FOREIGN;
+}
+async function resume_lane(issue, command) {
+  const lane = await lane_state.read_state(issue);
+  if (lane?.state === "human-review") {
+    await lane_state.record_change({ issue, state: "running", command });
+  }
+}
+async function reopen(target, issue) {
+  const mark = reopen_at(target, issue);
+  if (mark === MARKED) await resume_lane(issue, "run:hold --halfrun-round");
+  return mark;
+}
+function no_stop_message(issue) {
+  return `run:hold: this tree holds no stopped \`halfrun\` of ${session_cite.issue(issue)} \u2014 a fix round re-opens only that record.`;
+}
+function adopt_at(target, issue, is_dirty) {
+  if (!is_halfrun_stop(run_hold.read_hold(target), issue, is_dirty)) return false;
+  return take_over(target, issue);
+}
+async function hold_target() {
+  try {
+    const directory = await run_hold.worktree_directory();
+    return directory === void 0 ? void 0 : run_hold.hold_path(directory);
+  } catch {
+    return void 0;
+  }
+}
+async function is_pending(issue) {
+  const target = await hold_target();
+  if (target === void 0) return false;
+  return is_halfrun_stop(run_hold.read_hold(target), issue, await run_hold.is_tree_dirty());
+}
+async function adopt(issue) {
+  const target = await hold_target();
+  if (target === void 0) return false;
+  const is_adopted = adopt_at(target, issue, await run_hold.is_tree_dirty());
+  if (is_adopted) await resume_lane(issue, "run:entry");
+  return is_adopted;
+}
+var run_halfrun_resume = {
+  FOREIGN,
+  MARKED,
+  UNREADABLE,
+  adopt,
+  adopt_at,
+  hold_of,
+  hold_target,
+  is_pending,
+  mark_stop_at,
+  no_stop_message,
+  reopen,
+  reopen_at,
+  take_over
+};
+
+// scripts/run/hold/run-hold-session.ts
+function is_same_start(recorded, own) {
+  return recorded === void 0 || own === void 0 || recorded === own;
+}
+function is_session_hold(hold, owner = run_hold.session_owner()) {
+  if (hold.owner_pid === void 0 || owner.owner_pid === void 0) return true;
+  return hold.owner_pid === owner.owner_pid && is_same_start(hold.owner_start, owner.owner_start);
+}
+function is_notified_since(hold, pause_start) {
+  if (pause_start === void 0 || hold.notified_at === void 0) return false;
+  return Date.parse(hold.notified_at) >= Date.parse(pause_start);
+}
+function mark_notified(target, now = /* @__PURE__ */ new Date()) {
+  const hold = run_halfrun_resume.hold_of(run_hold.read_hold(target, now));
+  if (hold === void 0) return;
+  stamp_file.write_stamp(target, { ...hold, notified_at: now.toISOString() });
+}
+var run_hold_session = { is_notified_since, is_session_hold, mark_notified };
+
+export {
+  run_halfrun_resume,
+  run_hold_session
+};

package/dist/commands/chunk-AAIZ2H66.js

@@ -0,0 +1,58 @@
+import {
+  eslint_daemon,
+  eslint_daemon_calls
+} from "./chunk-KTV2HNWB.js";
+import {
+  resolve_tsx_runner
+} from "./chunk-4NIHTEGD.js";
+import {
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+import {
+  LINT_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lint/eslint-warm.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../scripts/lint/eslint-warm.ts", __josh_meta.url).href;
+var __josh_source_filename = __josh_file_path(__josh_source_url);
+var __josh_source_dirname = __josh_dirname(__josh_source_filename);
+var WARM_CLI = fileURLToPath(new URL("eslint-warm-cli.ts", __josh_source_url));
+var TYPED_SOURCES = ["ls-files", "--", "*.ts", ":!*.d.ts"];
+var FALLBACK_TARGET = "eslint.config.js";
+var LINE_SEPARATOR = "\n";
+function warm_target(project_root) {
+  const listed = git_spawn_sync.read(TYPED_SOURCES, { cwd: project_root }) ?? "";
+  const [first] = listed.split(LINE_SEPARATOR);
+  return first === void 0 || first === "" ? FALLBACK_TARGET : first;
+}
+async function warm(project_root) {
+  await eslint_daemon.run(["exec", "eslint", warm_target(project_root)], {
+    project_root,
+    timeout_ms: LINT_TIMEOUT_MS,
+    call: { caller: eslint_daemon_calls.DAEMON_CALLER.WARM, files: 1 }
+  });
+}
+function ignore_error() {
+}
+function start(project_root) {
+  if (process.env["VITEST"] !== void 0) return;
+  try {
+    const runner = resolve_tsx_runner();
+    const options = { cwd: project_root, detached: true, stdio: "ignore" };
+    const child = spawn(runner.executable, [...runner.leading_arguments, WARM_CLI], options);
+    child.on("error", ignore_error);
+    child.unref();
+  } catch {
+    ignore_error();
+  }
+}
+var eslint_warm = { start, warm };
+
+export {
+  eslint_warm
+};