@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-GAVSK6P6.js

@@ -0,0 +1,230 @@
+import {
+  git_gh_pr_read
+} from "./chunk-5IHEBIPD.js";
+import {
+  git_stash
+} from "./chunk-WROJTXWZ.js";
+import {
+  lane_registry
+} from "./chunk-NEOCCN6D.js";
+import {
+  run_hold
+} from "./chunk-F5N2QIFD.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/run-preflight.ts
+import { z } from "zod";
+var CLEAN_VERDICT = "clean";
+var RECLAIM_VERDICT = "reclaim";
+var RESUME_VERDICT = "resume";
+var PARK_VERDICT = "park";
+var NO_PR = "none";
+var OPEN_PR = "open";
+var MERGED_PR = "merged";
+var CLOSED_PR = "closed";
+var NO_CHILD_WORK = { branch_name: void 0, pr_state: NO_PR };
+var pr_info_schema = z.object({ state: z.string().optional() });
+var GH_PR_STATES = /* @__PURE__ */ new Map([
+  ["CLOSED", CLOSED_PR],
+  ["MERGED", MERGED_PR],
+  ["OPEN", OPEN_PR]
+]);
+var CLEAN_REASON = "Nothing was left behind: the tree is clean, HEAD is on the default branch, and this issue has no pull request and no branch holding work.";
+var CLEAN_ADVICE = "Start the child.";
+var RESUME_ADVICE = "Reuse the branch and run the whole verification gate from the start \u2014 refactor, `pnpm josh gate`, `/code-review` \u2014 never only the part the interrupted run had not reached. Nobody verified what it already committed.";
+var PARK_ADVICE = "Park the child: add `needs-decision` and comment what was found. Do not delete the branch, do not reopen the pull request, and do not commit on top of it.";
+var STASH_LABEL_PREFIX = "run:hold reclaimed before #";
+var { require_issue_number } = issue_number_shape;
+var UNREADABLE_PR_MESSAGE = "The pull request could not be read for branch ";
+function needs_reclaim(tree) {
+  return tree.is_dirty || tree.branch !== tree.default_branch;
+}
+function is_pr_decided(state) {
+  return state === MERGED_PR || state === CLOSED_PR;
+}
+function has_leftover_work(child) {
+  return child.branch_name !== void 0 || child.pr_state === OPEN_PR;
+}
+function to_verdict(tree, child) {
+  if (needs_reclaim(tree)) return RECLAIM_VERDICT;
+  if (is_pr_decided(child.pr_state)) return PARK_VERDICT;
+  if (has_leftover_work(child)) return RESUME_VERDICT;
+  return CLEAN_VERDICT;
+}
+function reclaim_reason(tree) {
+  const findings = [
+    tree.is_dirty ? "uncommitted changes" : void 0,
+    tree.branch === tree.default_branch ? void 0 : `HEAD on ${tree.branch}`
+  ].filter((entry) => entry !== void 0);
+  return `An earlier run left ${findings.join(" and ")} in this working tree.`;
+}
+function park_reason(state) {
+  return `The pull request for this issue is ${state}, so whether any work is still owed is a person's call.`;
+}
+function resume_reason(child) {
+  const branch_part = child.branch_name === void 0 ? "" : ` on branch ${child.branch_name}`;
+  const pr_part = child.pr_state === OPEN_PR ? ", and its pull request is still open" : "";
+  return `An earlier run left a partial implementation${branch_part}${pr_part}.`;
+}
+function to_reason(verdict, tree, child) {
+  if (verdict === RECLAIM_VERDICT) return reclaim_reason(tree);
+  if (verdict === PARK_VERDICT) return park_reason(child.pr_state);
+  if (verdict === RESUME_VERDICT) return resume_reason(child);
+  return CLEAN_REASON;
+}
+function reclaim_steps(tree, issue) {
+  if (!tree.is_dirty) return [];
+  return [
+    `pnpm josh stash:push "${STASH_LABEL_PREFIX}${issue}"`,
+    `Record the stash on ${session_cite.issue(issue)} \u2014 the comment is what gets it popped; nothing pops it for you.`
+  ];
+}
+function reclaim_advice(tree, issue) {
+  return [
+    ...reclaim_steps(tree, issue),
+    "pnpm josh ms",
+    "Then ask this command again: it is re-askable, and the clean tree gets its own answer."
+  ].join("\n");
+}
+function to_advice(verdict, issue, tree) {
+  if (verdict === RECLAIM_VERDICT) return reclaim_advice(tree, issue);
+  if (verdict === RESUME_VERDICT) return RESUME_ADVICE;
+  if (verdict === PARK_VERDICT) return PARK_ADVICE;
+  return CLEAN_ADVICE;
+}
+function decide(tree, child, issue) {
+  const verdict = to_verdict(tree, child);
+  return {
+    advice: to_advice(verdict, issue, tree),
+    reason: to_reason(verdict, tree, child),
+    verdict
+  };
+}
+function read_pr_field(raw) {
+  return json_value.parse_with(raw, pr_info_schema)?.state;
+}
+function to_pr_state(raw) {
+  const state = read_pr_field(raw);
+  return (state === void 0 ? void 0 : GH_PR_STATES.get(state)) ?? NO_PR;
+}
+async function has_stashable_work() {
+  try {
+    return await git_stash.has_stashable_changes();
+  } catch (error) {
+    error_text.trace_swallowed("run_preflight.has_stashable_work", error);
+    return true;
+  }
+}
+async function read_tree_state() {
+  const [is_dirty, current, default_branch] = await Promise.all([
+    has_stashable_work(),
+    git_command.branch(),
+    git_command.get_default_branch()
+  ]);
+  return { branch: current, default_branch, is_dirty };
+}
+async function read_pr_state(branch_name) {
+  if (!await git_gh_pr_read.pr_exists(branch_name)) return NO_PR;
+  const raw = await git_gh_pr_read.pr_view(branch_name);
+  if (raw === "") throw new Error(`${UNREADABLE_PR_MESSAGE}${branch_name}`);
+  return to_pr_state(raw);
+}
+function is_pr_open(state) {
+  return state === OPEN_PR;
+}
+async function read_pr_of_branch(branch_name) {
+  return { branch_name, pr_state: await read_pr_state(branch_name) };
+}
+function pick_child_state(reads) {
+  const decided = reads.find((read) => is_pr_decided(read.pr_state));
+  const open = reads.find((read) => is_pr_open(read.pr_state));
+  return decided ?? open ?? { branch_name: reads[0]?.branch_name, pr_state: NO_PR };
+}
+var ISSUE_BRANCH_SUFFIX = "-*";
+var ANY_REMOTE_PREFIX = "*/";
+var REMOTE_SEPARATOR = "/";
+var NOT_FOUND_INDEX = -1;
+function to_head_branch(name) {
+  const separator_index = name.indexOf(REMOTE_SEPARATOR);
+  return separator_index === NOT_FOUND_INDEX ? name : name.slice(separator_index + 1);
+}
+function group_by_head(pairs) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const [name, reference] of pairs) groups.set(name, [...groups.get(name) ?? [], reference]);
+  return groups;
+}
+async function read_branch_candidates(issue) {
+  const pattern = `${issue}${ISSUE_BRANCH_SUFFIX}`;
+  const [local, remote] = await Promise.all([
+    git_command.branch_names(pattern),
+    git_command.branch_names_remote(`${ANY_REMOTE_PREFIX}${pattern}`)
+  ]);
+  return group_by_head([
+    ...local.map((name) => [name, name]),
+    ...remote.map((reference) => [to_head_branch(reference), reference])
+  ]);
+}
+async function has_commits_beyond(base, references) {
+  const counts = await Promise.all(
+    references.map(async (reference) => await git_command.commit_count_beyond(base, reference))
+  );
+  return counts.some((count) => count > 0);
+}
+async function is_held_dirty(name, lane) {
+  if (lane?.branch !== name || lane.is_stranded) return false;
+  return await run_hold.is_tree_dirty(lane.directory);
+}
+async function read_candidate(name, references, context) {
+  const state = await read_pr_of_branch(name);
+  if (state.pr_state !== NO_PR || await has_commits_beyond(context.base, references)) return state;
+  return await is_held_dirty(name, context.lane) ? state : void 0;
+}
+async function read_child_state(issue) {
+  const candidates = await read_branch_candidates(issue);
+  if (candidates.size === 0) return NO_CHILD_WORK;
+  const [base, lane] = await Promise.all([
+    git_command.default_branch_reference(),
+    lane_registry.find_open_lane(issue)
+  ]);
+  const reads = await Promise.all(
+    [...candidates].map(
+      async ([name, references]) => await read_candidate(name, references, { base, lane })
+    )
+  );
+  return pick_child_state(reads.filter((read) => read !== void 0));
+}
+async function check(issue) {
+  require_issue_number(issue);
+  const tree = await read_tree_state();
+  if (needs_reclaim(tree)) return decide(tree, NO_CHILD_WORK, issue);
+  return decide(tree, await read_child_state(issue), issue);
+}
+var run_preflight = {
+  CLEAN_VERDICT,
+  RESUME_ADVICE,
+  MERGED_PR,
+  STASH_LABEL_PREFIX,
+  check,
+  decide,
+  read_child_state,
+  read_pr_state,
+  to_pr_state
+};
+
+export {
+  run_preflight
+};

package/dist/commands/chunk-GB2BRQVL.js

@@ -0,0 +1,300 @@
+import {
+  hook_context
+} from "./chunk-CUWT6UQO.js";
+import {
+  time_hook_transcript,
+  transcript_tail
+} from "./chunk-2OMIHPPE.js";
+import {
+  josh_environment_file
+} from "./chunk-NFKULY26.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/josh/hook-payload-capture.ts
+import { mkdirSync, readdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+var CAPTURE_DIR_KEY = "JOSH_HOOK_CAPTURE_DIR";
+var NO_TOOL = "none";
+var FILE_EXTENSION = ".json";
+var UNSAFE_NAME_CHARACTERS = /[^\w.-]/gu;
+var MAX_ATTEMPTS = 32;
+var tool_schema = z.looseObject({ tool_name: z.string().min(1) });
+function safe_name(name) {
+  return name.replaceAll(UNSAFE_NAME_CHARACTERS, "-");
+}
+function tool_label(raw_payload) {
+  return safe_name(json_value.parse_with(raw_payload, tool_schema)?.tool_name ?? NO_TOOL);
+}
+function write_new(file, raw_payload) {
+  try {
+    writeFileSync(file, raw_payload, { flag: "wx" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function write_capture(directory, hook, raw_payload) {
+  const prefix = `${safe_name(hook)}-${tool_label(raw_payload)}-`;
+  const first = readdirSync(directory).filter((name) => name.startsWith(prefix)).length + 1;
+  for (let index = first; index < first + MAX_ATTEMPTS; index += 1) {
+    const file = path.join(directory, `${prefix}${String(index)}${FILE_EXTENSION}`);
+    if (write_new(file, raw_payload)) return file;
+  }
+  return void 0;
+}
+function capture(hook, raw_payload, environment = process.env) {
+  const directory = environment[CAPTURE_DIR_KEY];
+  if (directory === void 0 || directory === "") return void 0;
+  try {
+    mkdirSync(directory, { recursive: true });
+    return write_capture(directory, hook, raw_payload);
+  } catch {
+    return void 0;
+  }
+}
+var hook_payload_capture = { CAPTURE_DIR_KEY, capture };
+
+// scripts/josh/hook-decision.ts
+import { text } from "node:stream/consumers";
+import { z as z3 } from "zod";
+
+// scripts/josh/hook-envelope.ts
+var HOOK_EVENT_NAME = "PreToolUse";
+var DENY_DECISION = "deny";
+var ALLOW_DECISION = "allow";
+function deny_envelope(reason) {
+  return JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: HOOK_EVENT_NAME,
+      permissionDecision: DENY_DECISION,
+      permissionDecisionReason: reason
+    }
+  });
+}
+function rewrite_envelope(updated_input, context) {
+  return JSON.stringify({
+    systemMessage: context,
+    hookSpecificOutput: {
+      hookEventName: HOOK_EVENT_NAME,
+      permissionDecision: ALLOW_DECISION,
+      updatedInput: updated_input,
+      additionalContext: context
+    }
+  });
+}
+function flow_rewrite_envelope(updated_input, context) {
+  return JSON.stringify({
+    systemMessage: context,
+    hookSpecificOutput: {
+      hookEventName: HOOK_EVENT_NAME,
+      updatedInput: updated_input,
+      additionalContext: context
+    }
+  });
+}
+function notice_envelope(notice) {
+  return JSON.stringify({
+    systemMessage: notice,
+    hookSpecificOutput: { hookEventName: HOOK_EVENT_NAME, additionalContext: notice }
+  });
+}
+var hook_envelope = { deny_envelope, flow_rewrite_envelope, notice_envelope, rewrite_envelope };
+
+// scripts/josh/hook-tool-payload.ts
+import { z as z2 } from "zod";
+var schema = z2.object({
+  tool_name: z2.string().min(1),
+  tool_input: z2.unknown()
+});
+function parse(raw_payload) {
+  return json_value.parse_with(raw_payload, schema);
+}
+var hook_tool_payload = { parse, schema };
+
+// scripts/josh/hook-decision.ts
+var payload_schema = hook_tool_payload.schema.extend({
+  transcript_path: z3.string().min(1),
+  // **`nullish`, not `optional`.** A payload spelling the absent agent as `null` has to read as "no
+  // fork"; rejected, it would fail `safeParse` for the whole payload and take the guard off every
+  // call of the main line, in silence — the failure every other path here is written to avoid.
+  agent_id: z3.string().nullish(),
+  // The session's model where the harness hands it over (a Codex payload); Claude Code names it on
+  // the transcript's assistant entries instead (`scripts/rules/main-model.ts`).
+  model: z3.string().nullish()
+});
+var refusal_schema = z3.object({ refused_at_ms: z3.number() });
+var NEVER_MS = 0;
+var DISABLED_VALUES = ["off", "0", "false", "no"];
+function is_switch_enabled(key, environment = process.env) {
+  return !DISABLED_VALUES.includes((environment[key] ?? "").trim().toLowerCase());
+}
+var ENABLED_VALUES = ["on", "1", "true", "yes"];
+function is_switch_opt_in(key) {
+  return ENABLED_VALUES.includes((process.env[key] ?? "").trim().toLowerCase());
+}
+function parse_hook_payload(raw_payload) {
+  return json_value.parse_with(raw_payload, payload_schema);
+}
+var { deny_envelope: deny_envelope2, flow_rewrite_envelope: flow_rewrite_envelope2, notice_envelope: notice_envelope2, rewrite_envelope: rewrite_envelope2 } = hook_envelope;
+function stamp_fault(switch_key) {
+  return `\u26A0 ${switch_key}: the run is past the limit but the refusal stamp could not be written, so this call was allowed rather than refused. Without the stamp a refusal could repeat and wedge the run. Batch the calls that do not need each other anyway, and check the temp directory is writable.`;
+}
+function error_text(error) {
+  if (error instanceof Error) return error.message;
+  return typeof error === "string" ? error : "a value that is not an error";
+}
+function fault_notice(switch_key, error) {
+  if (file_reader.is_absent(error)) return void 0;
+  const detail = error_text(error);
+  return `\u26A0 ${switch_key}: the guard could not read the run's history, so this call was allowed without being checked \u2014 silence here is not evidence that the run is batching. Cause: ${detail}`;
+}
+function last_refusal_ms(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return NEVER_MS;
+  return json_value.parse_with(raw, refusal_schema)?.refused_at_ms ?? NEVER_MS;
+}
+function record_refusal(target, now_ms) {
+  try {
+    stamp_file.write_stamp(target, { refused_at_ms: now_ms });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function create_refusal_stamp(prefix) {
+  function path2(transcript_path) {
+    return stamp_file.stamp_path(prefix, transcript_path);
+  }
+  return { path: path2, last_ms: last_refusal_ms, record: record_refusal };
+}
+var { load_environment_file } = josh_environment_file;
+var NO_OUTCOME = { reason: void 0, notice: void 0, fault: void 0 };
+function fire_once(stamp, run, should_fire, switch_key) {
+  const target = stamp.path(run.transcript);
+  if (!should_fire(stamp.last_ms(target))) return { fired: false, fault: void 0 };
+  if (!stamp.record(target, run.now_ms)) return { fired: false, fault: stamp_fault(switch_key) };
+  return { fired: true, fault: void 0 };
+}
+function block_outcome(context) {
+  const { spec, stamp, tail, call, run } = context;
+  const result = fire_once(
+    stamp,
+    run,
+    (last_fired_ms) => spec.should_block(tail, call, last_fired_ms, run),
+    spec.switch_key
+  );
+  if (result.fired) return { reason: spec.reason, notice: void 0, fault: void 0 };
+  return { reason: void 0, notice: void 0, fault: result.fault };
+}
+function notify_outcome(context) {
+  const { spec, notify_stamp, tail, call, run } = context;
+  if (notify_stamp === void 0 || spec.notify === void 0) return NO_OUTCOME;
+  const { notify } = spec;
+  const result = fire_once(
+    notify_stamp,
+    run,
+    (last_fired_ms) => notify.should_notify(tail, call, last_fired_ms, run),
+    spec.switch_key
+  );
+  if (result.fired) return { reason: void 0, notice: notify.text(call, tail), fault: void 0 };
+  return { reason: void 0, notice: void 0, fault: result.fault };
+}
+function is_clear(outcome) {
+  return outcome.reason === void 0 && outcome.notice === void 0 && outcome.fault === void 0;
+}
+function guard_reason_for_payload(parts, payload, now_ms, hook) {
+  const call = { name: payload.tool_name, input: payload.tool_input };
+  if (!parts.spec.is_candidate(call, hook)) return NO_OUTCOME;
+  const transcript = time_hook_transcript.transcript_of(payload.transcript_path, payload.agent_id);
+  const tail = transcript_tail.read_tail(transcript);
+  const is_unit = typeof payload.agent_id === "string" && payload.agent_id.length > 0;
+  const run = { transcript, now_ms, model: payload.model ?? void 0, is_unit, context: hook };
+  const context = { ...parts, tail, call, run };
+  const blocked = block_outcome(context);
+  if (!is_clear(blocked)) return blocked;
+  return notify_outcome(context);
+}
+function guard_outcome(parts, raw_payload, now_ms, hook) {
+  const payload = parse_hook_payload(raw_payload);
+  if (payload === void 0 || !is_switch_enabled(parts.spec.switch_key, hook.env)) {
+    return NO_OUTCOME;
+  }
+  return guard_reason_for_payload(parts, payload, now_ms, hook);
+}
+function create_transcript_guard(spec) {
+  const stamp = create_refusal_stamp(spec.prefix);
+  const notify_stamp = spec.notify ? create_refusal_stamp(spec.notify.prefix) : void 0;
+  const parts = { spec, stamp, notify_stamp };
+  function is_enabled(environment = process.env) {
+    return is_switch_enabled(spec.switch_key, environment);
+  }
+  function outcome(raw_payload, now_ms = Date.now(), hook = hook_context.from_process()) {
+    try {
+      return guard_outcome(parts, raw_payload, now_ms, hook);
+    } catch (error) {
+      return { reason: void 0, notice: void 0, fault: fault_notice(spec.switch_key, error) };
+    }
+  }
+  function refusal(...call) {
+    return outcome(...call).reason;
+  }
+  return { is_enabled, outcome, refusal, refusal_path: stamp.path };
+}
+function emit_outcome(outcome) {
+  const { reason, notice, fault } = outcome;
+  if (reason !== void 0) process.stdout.write(`${deny_envelope2(reason)}
+`);
+  else if (notice !== void 0) process.stdout.write(`${notice_envelope2(notice)}
+`);
+  else if (fault !== void 0) process.stdout.write(`${notice_envelope2(fault)}
+`);
+}
+function report_no_payload(command) {
+  process.stderr.write(
+    `${command} reads a Claude Code hook payload on stdin; it is not run by hand.
+`
+  );
+}
+async function respond_from_stdin(command, respond) {
+  if (process.stdin.isTTY) {
+    report_no_payload(command);
+    return;
+  }
+  const raw_payload = await text(process.stdin);
+  load_environment_file();
+  hook_payload_capture.capture(command, raw_payload);
+  await respond(raw_payload);
+}
+var hook_decision = {
+  DISABLED_VALUES,
+  ENABLED_VALUES,
+  NEVER_MS,
+  create_refusal_stamp,
+  create_transcript_guard,
+  deny_envelope: deny_envelope2,
+  emit_outcome,
+  flow_rewrite_envelope: flow_rewrite_envelope2,
+  is_switch_enabled,
+  is_switch_opt_in,
+  load_environment_file,
+  notice_envelope: notice_envelope2,
+  parse_hook_payload,
+  respond_from_stdin,
+  rewrite_envelope: rewrite_envelope2,
+  stamp_fault
+};
+
+export {
+  hook_payload_capture,
+  hook_tool_payload,
+  hook_decision
+};

package/dist/commands/chunk-GBMZXFFC.js

@@ -0,0 +1,44 @@
+import {
+  lane_ledger_archive
+} from "./chunk-ESUY7KTZ.js";
+import {
+  lane_implement_rate_read
+} from "./chunk-PJYTUUTH.js";
+import {
+  lane_net_time
+} from "./chunk-SNSZ25XZ.js";
+import {
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+
+// scripts/lane/lane-net-read.ts
+var { implement_rate, measurements, read_ledger } = lane_implement_rate_read;
+async function read_events(context) {
+  if (context.events_path !== void 0) return run_event_stream.read_events(context.events_path);
+  return await run_event_stream_emit.all_events();
+}
+async function read_records(context) {
+  return {
+    entries: await lane_ledger_archive.read_history(context),
+    events: await read_events(context)
+  };
+}
+async function net_minutes_of(issue, context = {}) {
+  const events = await read_events(context);
+  return lane_net_time.net_minutes(await lane_ledger_archive.read_history(context), events, issue);
+}
+var lane_net_read = {
+  implement_rate,
+  measurements,
+  net_minutes_of,
+  read_events,
+  read_ledger,
+  read_records
+};
+
+export {
+  lane_net_read
+};

package/dist/commands/chunk-GDP7QXYE.js

@@ -0,0 +1,76 @@
+import {
+  gate_log,
+  verification_tail
+} from "./chunk-VCWNMRH7.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/test/vitest-failure-summary.ts
+import { stripVTControlCharacters } from "node:util";
+var UNIT_LOG_PREFIX = "josh-unit-log-";
+var UNIT_LOG_HEADER = "vitest";
+var FAILED_LINE = /^FAIL\s+(?<name>\S.*)$/u;
+var FAILED_HEADING = "failed tests:";
+var IMPORT_FAILURE = /^(?:Error|SyntaxError): (?:\[vitest\] No "[^"\r\n]+" export is defined on the "[^"\r\n]+" mock\.|The requested module '[^'\r\n]+' does not provide an export named|Cannot find (?:module|package) |Failed to resolve import )[^\r\n]*$/mu;
+var NONE_NAMED = "  (none named in the output \u2014 read the full output)";
+var NONE_NAMED_VERDICT = "none named";
+var FAILED_FILE = /^(?:\|[^|]*\|\s+|\S+\s{2,})?(?<file>\S+)/u;
+var RERUN_PREFIX = "rerun failed: pnpm josh test:unit ";
+function unit_log_path(vitest_arguments) {
+  const prefix = `${UNIT_LOG_PREFIX}${vitest_arguments[0] ?? UNIT_LOG_HEADER}-`;
+  return stamp_file.stamp_path(prefix, PROJECT_ROOT, gate_log.GATE_LOG_SUFFIX);
+}
+function failed_name(line) {
+  return FAILED_LINE.exec(stripVTControlCharacters(line).trim())?.groups?.["name"];
+}
+function failed_tests(output) {
+  const names = output.split("\n").map((line) => failed_name(line));
+  return [...new Set(names.filter((name) => name !== void 0))];
+}
+function import_failure(output) {
+  return IMPORT_FAILURE.exec(stripVTControlCharacters(output))?.[0];
+}
+function failed_files(names) {
+  const files = names.map((name) => FAILED_FILE.exec(name)?.groups?.["file"]);
+  return [...new Set(files.filter((file) => file !== void 0))];
+}
+function name_lines(names) {
+  if (names.length === 0) return [NONE_NAMED];
+  return [...names.map((name) => `  ${name}`), `${RERUN_PREFIX}${failed_files(names).join(" ")}`];
+}
+function format_failure_summary(output, log_path, label = UNIT_LOG_HEADER) {
+  const names = failed_tests(output);
+  const failures = `${[FAILED_HEADING, ...name_lines(names)].join("\n")}
+`;
+  const failed = names.length === 0 ? [NONE_NAMED_VERDICT] : failed_files(names);
+  const verdict = verification_tail.format_verdict(label, failed);
+  return verification_tail.format_tail({ failures, log: { path: log_path }, verdict });
+}
+function format_green_summary(log_path, label) {
+  const verdict = verification_tail.format_verdict(label, []);
+  return verification_tail.format_tail({ failures: "", log: { path: log_path }, verdict });
+}
+function report(vitest_arguments, output, exit_code, target = unit_log_path(vitest_arguments)) {
+  const header = [UNIT_LOG_HEADER, ...vitest_arguments].join(" ");
+  const log_path = gate_log.write_gate_log([{ header, output }], target);
+  const label = [UNIT_LOG_HEADER, ...vitest_arguments.slice(0, 1)].join(" ");
+  const summary = exit_code === 0 ? format_green_summary(log_path, label) : format_failure_summary(output, log_path, label);
+  process.stdout.write(summary);
+}
+var vitest_failure_summary = {
+  RERUN_PREFIX,
+  failed_files,
+  failed_tests,
+  import_failure,
+  format_failure_summary,
+  report,
+  unit_log_path
+};
+
+export {
+  vitest_failure_summary
+};