@joshuafolkken/kit 1.2114.0 → 1.3000.0

package/dist/commands/rule-value-cli.js

@@ -0,0 +1,908 @@
+#!/usr/bin/env tsx
+import {
+  rule_value_cache
+} from "./chunk-QGAERR7D.js";
+import {
+  guard_rephrase
+} from "./chunk-6FWV56B3.js";
+import {
+  guard_rule_rows
+} from "./chunk-OKKQI4ZG.js";
+import {
+  rule_rewrite
+} from "./chunk-Q5N2J2UF.js";
+import "./chunk-MMXZKLDU.js";
+import {
+  delivered_rules,
+  piped_verification
+} from "./chunk-S7XWXG4M.js";
+import {
+  decision_oracle
+} from "./chunk-HOGFJHBT.js";
+import "./chunk-RRQFITJE.js";
+import "./chunk-FB3D7CX5.js";
+import "./chunk-AS3GWVAN.js";
+import "./chunk-RS764ZMU.js";
+import "./chunk-RGDFWJPZ.js";
+import "./chunk-RGGEQM6G.js";
+import "./chunk-GQHUFNXN.js";
+import "./chunk-KUJQWO6M.js";
+import "./chunk-PF22VUWB.js";
+import "./chunk-LMSS4ARB.js";
+import "./chunk-FVVZIJUC.js";
+import "./chunk-GW4UWR3O.js";
+import "./chunk-DKM4UJQU.js";
+import "./chunk-3ZEO3KOM.js";
+import "./chunk-XMBRXCIE.js";
+import "./chunk-RIUPRMLW.js";
+import "./chunk-CA6F5OXK.js";
+import "./chunk-QWX7EBC6.js";
+import "./chunk-6I2JM5UX.js";
+import "./chunk-BYSPYVLD.js";
+import "./chunk-UWLLZQJB.js";
+import "./chunk-3WWQFCGX.js";
+import "./chunk-LAYSCY4L.js";
+import "./chunk-32SNWQJP.js";
+import "./chunk-AVUGMOHZ.js";
+import "./chunk-KVSSLDA3.js";
+import "./chunk-6CJXLPRI.js";
+import {
+  time_transcript_line
+} from "./chunk-GPMSYXYO.js";
+import "./chunk-E2ZCUKHT.js";
+import "./chunk-WVR4RUFP.js";
+import "./chunk-LE2T3FGJ.js";
+import {
+  hook_context
+} from "./chunk-LQXFVZTS.js";
+import "./chunk-F2HFWLQR.js";
+import "./chunk-6NV2F7QH.js";
+import "./chunk-RK4HE5NW.js";
+import "./chunk-O26Y2FOJ.js";
+import "./chunk-XH6BGVVP.js";
+import "./chunk-RXAZJMSZ.js";
+import "./chunk-3PEXBHRN.js";
+import "./chunk-RZ4OKKPM.js";
+import "./chunk-PBOS7MTW.js";
+import "./chunk-2NSB5ZYQ.js";
+import "./chunk-2MJ4OCDL.js";
+import "./chunk-IW6NWCSN.js";
+import "./chunk-UCI4AL3Q.js";
+import "./chunk-TKGBF75Y.js";
+import "./chunk-RIQ75QWR.js";
+import "./chunk-6WTVAL4D.js";
+import "./chunk-F22G3VDB.js";
+import {
+  shell_segments
+} from "./chunk-W4YH2DF3.js";
+import {
+  cost_blocks,
+  time_shell
+} from "./chunk-LHKXJD6L.js";
+import "./chunk-ROJXMBXP.js";
+import "./chunk-7HCPRVMB.js";
+import "./chunk-JTU5A4JI.js";
+import {
+  document_section
+} from "./chunk-BEE7OAQ5.js";
+import "./chunk-UCQJDYE3.js";
+import "./chunk-65E4OZJ7.js";
+import "./chunk-NFKULY26.js";
+import "./chunk-LRS2OS5J.js";
+import "./chunk-AI5K4QJO.js";
+import "./chunk-7S6VRZOH.js";
+import "./chunk-LULJUD6P.js";
+import "./chunk-TBNQIFWL.js";
+import "./chunk-P4CWLRT2.js";
+import "./chunk-XFPEUYDV.js";
+import "./chunk-5ZTQX7OS.js";
+import "./chunk-HCA5QG2U.js";
+import "./chunk-C2SEDMZ3.js";
+import "./chunk-LRA3PXHS.js";
+import "./chunk-6OP63TBT.js";
+import "./chunk-TVZXG4Y4.js";
+import "./chunk-FIUCHMCF.js";
+import "./chunk-XXNEY4B3.js";
+import "./chunk-4PUKDAXL.js";
+import "./chunk-EWVR5AEX.js";
+import "./chunk-C6QSVO5K.js";
+import "./chunk-W3FX7FYN.js";
+import "./chunk-ZBFNQUY7.js";
+import "./chunk-U3IVVR4W.js";
+import "./chunk-O3NDWYNT.js";
+import "./chunk-34LAULSC.js";
+import "./chunk-5Y7QQYTU.js";
+import "./chunk-34DND4BA.js";
+import "./chunk-NSAVEXVR.js";
+import "./chunk-P4KIQRSL.js";
+import "./chunk-QQBMVC5W.js";
+import "./chunk-QAHFPCFR.js";
+import "./chunk-66TGK5XL.js";
+import "./chunk-EZSO25UZ.js";
+import "./chunk-2DJLAUYB.js";
+import "./chunk-EW4NPUMQ.js";
+import "./chunk-BF6YX4HE.js";
+import "./chunk-3LZXX5GL.js";
+import "./chunk-W2IA2LV3.js";
+import "./chunk-OHNP3QL2.js";
+import "./chunk-X7PN54LZ.js";
+import {
+  stamped_memo
+} from "./chunk-MDKDJF2K.js";
+import "./chunk-HQ2HSZBN.js";
+import "./chunk-6HRRZANN.js";
+import "./chunk-I63RNFFR.js";
+import "./chunk-MPGJ4ONJ.js";
+import {
+  cost_transcript
+} from "./chunk-6WKJ3GDA.js";
+import "./chunk-YIA6FC3K.js";
+import "./chunk-JQXPLMCO.js";
+import "./chunk-66NX6EXR.js";
+import "./chunk-3NWAGIA6.js";
+import "./chunk-2FE3C4PH.js";
+import "./chunk-HLUS2M3D.js";
+import "./chunk-SBGTCT2C.js";
+import "./chunk-AKK56GNX.js";
+import "./chunk-TBIX5FRN.js";
+import "./chunk-IGD6QJPH.js";
+import "./chunk-FFHEGWPK.js";
+import "./chunk-R6QE5VJG.js";
+import "./chunk-4ZHWTTQW.js";
+import "./chunk-RDRN56E4.js";
+import "./chunk-XDF25GSU.js";
+import "./chunk-EBVS2LKX.js";
+import "./chunk-AQ3PMSXK.js";
+import "./chunk-QVOFWFWC.js";
+import "./chunk-G6BXCWPH.js";
+import "./chunk-CDY4NFQG.js";
+import "./chunk-OKYFQJW3.js";
+import "./chunk-HHBC6QZE.js";
+import "./chunk-QWWTC3XR.js";
+import "./chunk-ILGPZ47M.js";
+import "./chunk-3CCGKX7Y.js";
+import {
+  atomic_write
+} from "./chunk-KSR23NYN.js";
+import "./chunk-G47ZNQVG.js";
+import "./chunk-V5FD7DVV.js";
+import "./chunk-36LOGVJ7.js";
+import "./chunk-ENFPR7J2.js";
+import "./chunk-F7XLEK55.js";
+import "./chunk-UGCUSRZF.js";
+import "./chunk-AKQYYHP2.js";
+import "./chunk-CJKPF5DJ.js";
+import "./chunk-RBU2NKHF.js";
+import "./chunk-NKKH3PBE.js";
+import "./chunk-B77ZMVHS.js";
+import "./chunk-B5GXZK3E.js";
+import "./chunk-KTLR4Y32.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+import "./chunk-VJE3RJAX.js";
+import "./chunk-WPAQUMHC.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/rules/rule-value-cli.ts
+import { dirname as __josh_dirname3 } from "node:path";
+import { fileURLToPath as __josh_file_path3 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+
+// scripts/rules/hook-context-line.ts
+var HOOK_CONTEXT_TYPE = "hook_additional_context";
+function strings_of(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((one) => typeof one === "string");
+}
+function hook_contexts_of(line) {
+  if (!line.includes(HOOK_CONTEXT_TYPE)) return [];
+  const parsed = json_value.parse_or_undefined(line);
+  const attachment = json_value.is_record(parsed) ? parsed["attachment"] : void 0;
+  if (!json_value.is_record(attachment) || attachment["type"] !== HOOK_CONTEXT_TYPE) return [];
+  return strings_of(attachment["content"]);
+}
+var hook_context_line = { HOOK_CONTEXT_TYPE, hook_contexts_of };
+
+// scripts/rules/rule-value.ts
+var REASON_SIGNATURE_LENGTH = 48;
+var PERCENT = 100;
+function blank_states() {
+  const entries = delivered_rules.MEASURED_RULES.map((rule) => [
+    rule.id,
+    {
+      is_kept: false,
+      is_reached: false,
+      is_triggered: false,
+      is_refused: false,
+      is_rewritten: false
+    }
+  ]);
+  return new Map(entries);
+}
+function keeps_the_rule(rule, call, context) {
+  return rule.keeps?.(call, context.turn, context.run) === true;
+}
+function is_the_trigger(rule, call) {
+  return rule.is_trigger?.(call, hook_context.from_process()) === true;
+}
+function observe_before_trigger(rule, state, call, context) {
+  if (state.is_triggered) return;
+  if (keeps_the_rule(rule, call, context)) state.is_kept = true;
+  if (is_the_trigger(rule, call)) state.is_triggered = true;
+}
+function observe_call(rule, state, call, context) {
+  if (rule.reaches?.(call, context.turn, context.run) === true) state.is_reached = true;
+  observe_before_trigger(rule, state, call, context);
+}
+function calls_of(parsed) {
+  return parsed.blocks.filter((block) => block.type === cost_blocks.TOOL_USE_TYPE).map((block) => ({ name: block.name, input: block.input }));
+}
+function errors_of(parsed) {
+  return parsed.blocks.filter((block) => block.is_error === true).map((block) => block.error_text).filter((text) => text !== "");
+}
+function refusals_of(parsed) {
+  const errors = errors_of(parsed);
+  return parsed.stop_feedback === "" ? errors : [...errors, parsed.stop_feedback];
+}
+function dated_line(line) {
+  const parsed = line === "" ? void 0 : time_transcript_line.parse_line(line);
+  if (parsed === void 0) return void 0;
+  return {
+    at_ms: parsed.timestamp_ms,
+    message_id: parsed.message_id,
+    calls: calls_of(parsed),
+    errors: refusals_of(parsed),
+    contexts: hook_context_line.hook_contexts_of(line)
+  };
+}
+function turn_key(entry, index) {
+  if (entry.message_id === time_transcript_line.NO_MESSAGE_ID) return `#${String(index)}`;
+  return entry.message_id;
+}
+function turns_by_key(entries) {
+  const turns = /* @__PURE__ */ new Map();
+  for (const [index, entry] of entries.entries()) {
+    const key = turn_key(entry, index);
+    const opened = turns.get(key);
+    if (opened === void 0) turns.set(key, [...entry.calls]);
+    else opened.push(...entry.calls);
+  }
+  return turns;
+}
+function refused_id(text) {
+  const body = time_transcript_line.refusal_body(text);
+  const found = delivered_rules.MEASURED_RULES.find(
+    (rule) => [rule.reason, ...rule.former_reasons ?? [], ...rule.stop_reasons ?? []].some(
+      (reason) => body.startsWith(reason.slice(0, REASON_SIGNATURE_LENGTH))
+    )
+  );
+  return found?.id;
+}
+function observe_error(states, text) {
+  const id = refused_id(text);
+  const state = id === void 0 ? void 0 : states.get(id);
+  if (state === void 0) return;
+  state.is_refused = true;
+  state.is_triggered = true;
+}
+function rewritten_id(text) {
+  const found = delivered_rules.MEASURED_RULES.find((rule) => {
+    const note = rule.rewrite_note;
+    return note !== void 0 && text.trimStart().startsWith(note.slice(0, REASON_SIGNATURE_LENGTH));
+  });
+  return found?.id;
+}
+function observe_note(states, text) {
+  const id = rewritten_id(text);
+  const state = id === void 0 ? void 0 : states.get(id);
+  if (state === void 0) return;
+  state.is_rewritten = true;
+  state.is_triggered = true;
+}
+function observe_rewrite(states, text) {
+  for (const note of text.split(rule_rewrite.NOTE_SEPARATOR)) observe_note(states, note);
+}
+function observe_for_rule(rule, state, calls, context) {
+  for (const call of calls) observe_call(rule, state, call, context);
+}
+function observe_calls(states, calls, context) {
+  for (const rule of delivered_rules.MEASURED_RULES) {
+    const state = states.get(rule.id);
+    if (state !== void 0) observe_for_rule(rule, state, calls, context);
+  }
+}
+function observe_line(states, entry, context) {
+  observe_calls(states, entry.calls, context);
+  for (const text of entry.errors) observe_error(states, text);
+  for (const text of entry.contexts) observe_rewrite(states, text);
+}
+function dated_lines_of(text) {
+  return text.split("\n").map((line) => dated_line(line)).filter((entry) => entry !== void 0);
+}
+function timeline_of(texts) {
+  return texts.flatMap((text) => dated_lines_of(text)).toSorted((left, right) => left.at_ms - right.at_ms);
+}
+function read_run(texts) {
+  const states = blank_states();
+  const entries = timeline_of(texts);
+  const turns = turns_by_key(entries);
+  const run = entries.flatMap((entry) => entry.calls);
+  for (const [index, entry] of entries.entries()) {
+    const turn = turns.get(turn_key(entry, index)) ?? entry.calls;
+    observe_line(states, entry, { turn, run });
+  }
+  return states;
+}
+function credit(reading, state) {
+  reading.sessions += 1;
+  reading.unaided_kept += state.is_kept ? 1 : 0;
+  reading.refusals += state.is_refused ? 1 : 0;
+  reading.rewrites += state.is_rewritten ? 1 : 0;
+}
+function is_credited(state) {
+  return state.is_triggered || state.is_reached;
+}
+function reading_to_credit(readings, id, state) {
+  return is_credited(state) ? readings.get(id) : void 0;
+}
+function apply_run(readings, states) {
+  for (const [id, state] of states) {
+    const reading = reading_to_credit(readings, id, state);
+    if (reading !== void 0) credit(reading, state);
+  }
+}
+function blank_readings() {
+  const entries = delivered_rules.MEASURED_RULES.map((rule) => [
+    rule.id,
+    {
+      id: rule.id,
+      sessions: 0,
+      unaided_kept: 0,
+      refusals: 0,
+      rewrites: 0,
+      is_measurable: rule.keeps !== void 0
+    }
+  ]);
+  return new Map(entries);
+}
+function unaided_rate(reading) {
+  if (!reading.is_measurable || reading.sessions === 0) return void 0;
+  return Math.round(reading.unaided_kept / reading.sessions * PERCENT);
+}
+function* states_of(runs) {
+  for (const texts of runs) yield read_run(texts);
+}
+function measure_states(runs) {
+  const readings = blank_readings();
+  for (const states of runs) apply_run(readings, states);
+  return delivered_rules.MEASURED_RULES.map((rule) => readings.get(rule.id)).filter(
+    (reading) => reading !== void 0
+  );
+}
+function measure(runs) {
+  return measure_states(states_of(runs));
+}
+var rule_value = {
+  REASON_SIGNATURE_LENGTH,
+  is_credited,
+  measure,
+  measure_states,
+  read_run,
+  unaided_rate
+};
+
+// scripts/rules/piped-verification-shapes.ts
+var SHAPE = {
+  head: "head",
+  grep: "grep",
+  script: "awk|sed|tee",
+  chain: "chain",
+  other: "other"
+};
+var HEAD_FILTER = /^head\b/u;
+var SCRIPT_FILTER = /^(?:awk|sed|tee)\b/u;
+var SIGNATURE = piped_verification.PIPED_VERIFICATION_REASON.slice(
+  0,
+  rule_value.REASON_SIGNATURE_LENGTH
+);
+var CHEAP_MARK = "piped verification: a pipeline exits";
+var HEADING = "piped-verification refusals by shape:";
+var SHAPE_GAP = " \xB7 ";
+function filter_shape(filters) {
+  if (filters.some((piece) => HEAD_FILTER.test(piece))) return SHAPE.head;
+  if (filters.some((piece) => piped_verification.EARLY_EXIT_GREP.test(piece))) return SHAPE.grep;
+  return filters.some((piece) => SCRIPT_FILTER.test(piece)) ? SHAPE.script : void 0;
+}
+function shape_of(command) {
+  const by_filter = filter_shape(piped_verification.check_filters(command));
+  if (by_filter !== void 0) return by_filter;
+  const segments = shell_segments.segments_of(time_shell.unquoted(command));
+  return segments.length > 1 ? SHAPE.chain : SHAPE.other;
+}
+function is_refusal(block) {
+  if (block.error_text === "") return false;
+  return time_transcript_line.refusal_body(block.error_text).startsWith(SIGNATURE);
+}
+function pair_block(block, pairing) {
+  if (block.id !== "") pairing.commands.set(block.id, time_shell.bash_command(block.input));
+  if (is_refusal(block)) pairing.refused.push(block.result_id);
+}
+function blocks_of(text) {
+  return text.split("\n").flatMap((line) => time_transcript_line.parse_line(line)?.blocks ?? []);
+}
+function refused_commands(text) {
+  if (!text.includes(CHEAP_MARK)) return [];
+  const pairing = { commands: /* @__PURE__ */ new Map(), refused: [] };
+  for (const block of blocks_of(text)) pair_block(block, pairing);
+  return pairing.refused.map((id) => pairing.commands.get(id) ?? "").filter((command) => command !== "");
+}
+function count(text, counts) {
+  for (const command of refused_commands(text)) {
+    const shape = shape_of(command);
+    counts.set(shape, (counts.get(shape) ?? 0) + 1);
+  }
+}
+function render(counts) {
+  const cells = Object.values(SHAPE).map(
+    (shape) => `${shape} ${(counts.get(shape) ?? 0).toString()}`
+  );
+  return `${HEADING} ${cells.join(SHAPE_GAP)}`;
+}
+var piped_verification_shapes = { HEADING, SHAPE, count, refused_commands, render, shape_of };
+
+// scripts/rules/rule-rephrase.ts
+function guards_of(rule) {
+  const reasons = [rule.reason, ...rule.former_reasons ?? []];
+  return [...new Set(reasons.map((reason) => time_transcript_line.guard_from_refusal(reason)))];
+}
+var GUARDS_OF_RULE = new Map(
+  delivered_rules.MEASURED_RULES.map((rule) => [rule.id, guards_of(rule)])
+);
+function rephrased_in(text) {
+  return guard_rephrase.rephrased_guards(time_transcript_line.parse_text(text));
+}
+function count_run(texts, counts) {
+  const guards = new Set(texts.flatMap((text) => rephrased_in(text)));
+  for (const guard of guards) counts.set(guard, (counts.get(guard) ?? 0) + 1);
+}
+function rephrased_of(rule_id, counts) {
+  const guards = GUARDS_OF_RULE.get(rule_id) ?? [];
+  return guards.reduce((total, guard) => total + (counts.get(guard) ?? 0), 0);
+}
+var rule_rephrase = { count_run, rephrased_of };
+
+// scripts/rules/rule-value-candidates.ts
+var MIN_RUNS_FOR_RETIREMENT = 20;
+var SEPARATOR = ", ";
+var NONE = "none";
+function retire_candidates(readings, runs) {
+  if (runs < MIN_RUNS_FOR_RETIREMENT) return [];
+  return readings.filter((reading) => reading.is_measurable && reading.sessions === 0).map((reading) => reading.id);
+}
+function is_enforced_on_every_occurrence(id, rules) {
+  return rules.some((rule) => rule.id === id && rule.decide !== void 0);
+}
+function condense_candidates(readings, rules = delivered_rules.MEASURED_RULES) {
+  return readings.filter((reading) => reading.refusals > 0).filter((reading) => is_enforced_on_every_occurrence(reading.id, rules)).map((reading) => reading.id);
+}
+function judge(readings, runs, rules = delivered_rules.MEASURED_RULES) {
+  return {
+    retire: retire_candidates(readings, runs),
+    condense: condense_candidates(readings, rules)
+  };
+}
+function listed(ids) {
+  return ids.length === 0 ? NONE : ids.join(SEPARATOR);
+}
+function render2(candidates, runs) {
+  const window = `${runs.toString()} runs, threshold ${MIN_RUNS_FOR_RETIREMENT.toString()}`;
+  return [
+    "candidates:",
+    `  retire (reached 0; ${window}): ${listed(candidates.retire)}`,
+    `  condense (refused on every occurrence by its hook): ${listed(candidates.condense)}`
+  ].join("\n");
+}
+var rule_value_candidates = {
+  condense_candidates,
+  judge,
+  render: render2,
+  retire_candidates,
+  MIN_RUNS_FOR_RETIREMENT,
+  NONE
+};
+
+// scripts/rules/rule-value-prose.ts
+import { globSync, readFileSync } from "node:fs";
+import path from "node:path";
+var PROSE_GLOBS = ["prompts/**/*.md", ".claude/skills/**/*.md", "CLAUDE.md"];
+var ENFORCED = "\u5F37\u5236\u3042\u308A";
+var MEASURED = "\u8A08\u6E2C\u306E\u307F";
+var PROSE_ONLY = "\u6587\u7AE0\u3060\u3051";
+var RULE_LINE = /^(?<marker>\s*(?:[-*]|\d+\.) )?\*\*(?<label>[^*]+)/u;
+var SOURCE_ARROW = "\u2192";
+var CITE_MARKS = /["`]/gu;
+var MARKDOWN_EXTENSION = ".md";
+var LABEL_WIDTH = 80;
+var COLUMN_GAP = "  ";
+var LINE_BASE = 1;
+function opens_rule(lines, index, marker) {
+  return marker !== void 0 || (lines[index - LINE_BASE] ?? "").trim() === "";
+}
+function opening_label(lines, index) {
+  const groups = RULE_LINE.exec(lines[index] ?? "")?.groups ?? {};
+  return opens_rule(lines, index, groups["marker"]) ? groups["label"] : void 0;
+}
+function rule_at(file, lines, index) {
+  const label = opening_label(lines, index);
+  if (label === void 0) return void 0;
+  return { file, line: index + LINE_BASE, label: label.trim().slice(0, LABEL_WIDTH) };
+}
+function rules_of({ file, markdown }) {
+  const lines = markdown.split("\n");
+  const fenced = document_section.fenced_flags(lines);
+  return lines.map((_line, index) => fenced[index] === true ? void 0 : rule_at(file, lines, index)).filter((rule) => rule !== void 0);
+}
+function is_cited_file(file, cited) {
+  return file === cited || file.endsWith(`/${cited}`);
+}
+function span_of(document, heading) {
+  const lines = document.markdown.split("\n");
+  if (heading === "") return { file: document.file, first_line: 0, last_line: lines.length };
+  const found = document_section.section(document.markdown, heading);
+  if (found === void 0) return void 0;
+  return { file: document.file, first_line: found.first_line, last_line: found.last_line };
+}
+function bare(text) {
+  return text.replaceAll(CITE_MARKS, "").trim();
+}
+function spans_of(source, documents) {
+  const [head = "", ...rest] = source.split(SOURCE_ARROW);
+  const cited = bare(head);
+  if (!cited.endsWith(MARKDOWN_EXTENSION)) return [];
+  const heading = bare(rest.join(SOURCE_ARROW));
+  return documents.filter((document) => is_cited_file(document.file, cited)).map((document) => span_of(document, heading)).filter((span) => span !== void 0);
+}
+function all_spans(sources, documents) {
+  return sources.flatMap((source) => spans_of(source, documents));
+}
+function is_covered(rule, spans) {
+  const index = rule.line - LINE_BASE;
+  return spans.some(
+    (span) => span.file === rule.file && span.first_line <= index && index <= span.last_line
+  );
+}
+function classify(documents, sources) {
+  const guard_spans = all_spans(sources.guards, documents);
+  const oracle_spans = all_spans(sources.oracles, documents);
+  const rules = documents.flatMap((document) => rules_of(document));
+  return rules.map(function audited(rule) {
+    if (is_covered(rule, guard_spans)) return { ...rule, class: ENFORCED };
+    return { ...rule, class: is_covered(rule, oracle_spans) ? MEASURED : PROSE_ONLY };
+  });
+}
+function documents_in(cwd) {
+  return globSync(PROSE_GLOBS, { cwd }).toSorted((left, right) => left.localeCompare(right)).map((file) => ({ file, markdown: readFileSync(path.join(cwd, file), "utf8") }));
+}
+function registered_sources() {
+  return {
+    // The rows `rule:list` prints.
+    guards: guard_rule_rows.rows().map((row2) => row2.about.topic),
+    oracles: decision_oracle.DECISION_ORACLES.map((oracle) => oracle.single_source)
+  };
+}
+function audit(cwd = process.cwd()) {
+  return classify(documents_in(cwd), registered_sources());
+}
+function count_of(audited, wanted) {
+  return `${wanted} ${audited.filter((rule) => rule.class === wanted).length.toString()}`;
+}
+function render3(audited) {
+  const rows = audited.map(
+    (rule) => [rule.class, `${rule.file}:${rule.line.toString()}`, rule.label].join(COLUMN_GAP)
+  );
+  const classes = [ENFORCED, MEASURED, PROSE_ONLY];
+  const totals = classes.map((wanted) => count_of(audited, wanted));
+  return [...rows, "", totals.join(" \xB7 ")].join("\n");
+}
+var rule_value_prose = { audit, classify, render: render3, ENFORCED, MEASURED, PROSE_ONLY };
+
+// scripts/rules/rule-value-runs.ts
+import { dirname as __josh_dirname2 } from "node:path";
+import { fileURLToPath as __josh_file_path2 } from "node:url";
+import { createHash } from "node:crypto";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// scripts/lib/import-closure.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import { existsSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../scripts/lib/import-closure.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 SCRIPTS_DIR = path2.join(path2.dirname(fileURLToPath(__josh_source_url)), "..");
+var TOOLS_DIR = path2.join(SCRIPTS_DIR, "..", "tools");
+var ALIAS_DIRECTORIES = [
+  ["#scripts/", SCRIPTS_DIR],
+  ["#tools/", TOOLS_DIR]
+];
+function value_import_specs(source) {
+  const runtime = source.replaceAll(/import\s+type\s+[^\n]*/gu, "");
+  return [...runtime.matchAll(/from\s+['"]([^'"]+)['"]/gu)].map((match) => match[1]).filter((spec) => spec !== void 0);
+}
+function resolve_spec(spec, from_file) {
+  const aliased = ALIAS_DIRECTORIES.find(([alias]) => spec.startsWith(alias));
+  if (aliased !== void 0) return path2.join(aliased[1], `${spec.slice(aliased[0].length)}.ts`);
+  if (spec.startsWith(".")) return `${path2.resolve(path2.dirname(from_file), spec)}.ts`;
+  return void 0;
+}
+function imports_of(file) {
+  if (!existsSync(file) || statSync(file).isDirectory()) return [];
+  return value_import_specs(readFileSync2(file, "utf8")).map((spec) => resolve_spec(spec, file)).filter((resolved) => resolved !== void 0);
+}
+function closure(seeds) {
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [...seeds];
+  while (queue.length > 0) {
+    const file = queue.shift();
+    if (file === void 0 || visited.has(file)) continue;
+    visited.add(file);
+    queue.push(...imports_of(file));
+  }
+  return visited;
+}
+var import_closure = { closure, imports_of };
+
+// scripts/lib/stamped-store.ts
+import { z } from "zod";
+function stored_schema(schema) {
+  const remembered = z.object({ stamp: z.string(), value: schema });
+  const entry = z.tuple([z.string(), remembered]);
+  return z.object({ version: z.string(), entries: z.array(entry) });
+}
+function load(file, version, schema) {
+  const text = file_reader.read_if_readable(file) ?? "";
+  const stored = json_value.parse_with(text, stored_schema(schema));
+  return new Map(stored?.version === version ? stored.entries : []);
+}
+function write(file, version, entries) {
+  try {
+    atomic_write.replace_file(file, JSON.stringify({ version, entries: [...entries] }));
+  } catch {
+  }
+}
+function open(file, version, schema) {
+  const memo = stamped_memo.create();
+  const known = load(file, version, schema);
+  for (const [key, { stamp, value }] of known) memo.of(key, stamp, () => value);
+  return {
+    of(key, stamp, compute) {
+      const value = memo.of(key, stamp, compute);
+      known.set(key, { stamp, value });
+      return value;
+    },
+    keep(keys) {
+      memo.keep(keys);
+      for (const key of known.keys()) if (!keys.has(key)) known.delete(key);
+    },
+    save() {
+      write(file, version, known);
+    }
+  };
+}
+var stamped_store = { open };
+
+// scripts/rules/rule-value-runs.ts
+import { z as z2 } from "zod";
+var __josh_meta2 = import.meta;
+var __josh_source_url2 = new URL("../../scripts/rules/rule-value-runs.ts", __josh_meta2.url).href;
+var __josh_source_filename2 = __josh_file_path2(__josh_source_url2);
+var __josh_source_dirname2 = __josh_dirname2(__josh_source_filename2);
+var STORE_FILE = "rule-value-runs.json";
+var HASH = "sha256";
+var LINE = "\n";
+var PAIR = "=";
+var UNREAD = { is_read: false, states: [], shapes: [], rephrased: [] };
+var state_schema = z2.object({
+  is_kept: z2.boolean(),
+  is_reached: z2.boolean(),
+  is_triggered: z2.boolean(),
+  is_refused: z2.boolean(),
+  is_rewritten: z2.boolean()
+});
+var state_entry = z2.tuple([z2.string(), state_schema]);
+var shape_entry = z2.tuple([z2.enum(piped_verification_shapes.SHAPE), z2.number()]);
+var count_entry = z2.tuple([z2.string(), z2.number()]);
+var summary_schema = z2.object({
+  is_read: z2.boolean(),
+  states: z2.array(state_entry),
+  shapes: z2.array(shape_entry),
+  rephrased: z2.array(count_entry)
+});
+function summarize(texts) {
+  if (texts.length === 0) return UNREAD;
+  const shapes = /* @__PURE__ */ new Map();
+  const rephrased = /* @__PURE__ */ new Map();
+  for (const text of texts) piped_verification_shapes.count(text, shapes);
+  rule_rephrase.count_run(texts, rephrased);
+  const states = [...rule_value.read_run(texts)].filter(
+    ([, state]) => rule_value.is_credited(state)
+  );
+  return { is_read: true, states, shapes: [...shapes], rephrased: [...rephrased] };
+}
+function readable_texts(files) {
+  return files.map((file) => cost_transcript.read_optional(file)).filter((text) => text !== void 0);
+}
+function run_stamp(files) {
+  return files.map((file) => file.path).toSorted((left, right) => left.localeCompare(right)).map((file) => `${file}${PAIR}${stamped_memo.file_stamp(file)}`).join(LINE);
+}
+function summaries_of(runs, memo) {
+  memo.keep(new Set(runs.keys()));
+  return [...runs].map(
+    ([owner, files]) => memo.of(owner, run_stamp(files), () => summarize(readable_texts(files)))
+  );
+}
+function add(counts, entries) {
+  for (const [key, count2] of entries) counts.set(key, (counts.get(key) ?? 0) + count2);
+}
+function tally(summaries) {
+  const read = [...summaries].filter((summary) => summary.is_read);
+  const shapes = /* @__PURE__ */ new Map();
+  const rephrased = /* @__PURE__ */ new Map();
+  for (const summary of read) {
+    add(shapes, summary.shapes);
+    add(rephrased, summary.rephrased);
+  }
+  const readings = rule_value.measure_states(read.map((summary) => new Map(summary.states)));
+  return { runs: read.length, readings, shapes, rephrased };
+}
+function counting_sources() {
+  return [...import_closure.closure([fileURLToPath2(__josh_source_url2)])].toSorted(
+    (left, right) => left.localeCompare(right)
+  );
+}
+function version_of(sources) {
+  const ids = delivered_rules.MEASURED_RULES.map((rule) => rule.id).join(LINE);
+  const hash = createHash(HASH).update(ids);
+  for (const source of sources) {
+    hash.update(LINE).update(file_reader.read_if_readable(source) ?? "");
+  }
+  return hash.digest("hex");
+}
+function open2(cwd, sources = counting_sources()) {
+  if (rule_value_cache.is_linked_work_tree(cwd)) return void 0;
+  const file = rule_value_cache.cache_path(cwd, STORE_FILE);
+  return stamped_store.open(file, version_of(sources), summary_schema);
+}
+var rule_value_runs = { counting_sources, open: open2, summaries_of, summarize, tally, version_of };
+
+// scripts/rules/rule-value-cli.ts
+var __josh_meta3 = import.meta;
+var __josh_source_url3 = new URL("../../scripts/rules/rule-value-cli.ts", __josh_meta3.url).href;
+var __josh_source_filename3 = __josh_file_path3(__josh_source_url3);
+var __josh_source_dirname3 = __josh_dirname3(__josh_source_filename3);
+var ARGV_OFFSET = 2;
+var REFRESH_FLAG = "--refresh";
+var FRESH_FLAG = "--fresh";
+var PROSE_FLAG = "--prose";
+var CACHED_NOTE = "cached reading taken at";
+var PERCENT_SIGN = "%";
+var COLUMN_GAP2 = "  ";
+var NO_TARGETS = "no measurement targets";
+var UNMEASURED = "unmeasured";
+var UNREACHED = "unreached";
+function group_by_run(files) {
+  const runs = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const owner = cost_transcript.owning_session_id(file);
+    const owned = runs.get(owner) ?? [];
+    owned.push(file);
+    runs.set(owner, owned);
+  }
+  return runs;
+}
+function gather_summaries(cwd) {
+  const directories = cost_transcript.transcript_directories(cwd);
+  const runs = group_by_run(cost_transcript.list_sessions_across(directories));
+  const store = rule_value_runs.open(cwd);
+  const summaries = rule_value_runs.summaries_of(runs, store ?? stamped_memo.create());
+  store?.save();
+  return summaries;
+}
+function* summarized(runs) {
+  for (const texts of runs) yield rule_value_runs.summarize(texts);
+}
+var ID_WIDTH = Math.max(...delivered_rules.MEASURED_RULES.map((rule) => rule.id.length));
+function rate_text(reading) {
+  if (!reading.is_measurable) return UNMEASURED;
+  const rate = rule_value.unaided_rate(reading);
+  if (rate === void 0) return UNREACHED;
+  return `${rate.toString()}${PERCENT_SIGN} unaided`;
+}
+function optional_column(label, value) {
+  return value > 0 ? [`${label} ${value.toString()}`] : [];
+}
+function row(reading, rephrased = 0) {
+  const id = reading.id.padEnd(ID_WIDTH);
+  const reached = `reached ${reading.sessions.toString()}`;
+  const refused = `refused ${reading.refusals.toString()}`;
+  const rewritten = optional_column("rewritten", reading.rewrites);
+  return [
+    id,
+    reached,
+    rate_text(reading),
+    refused,
+    ...rewritten,
+    ...optional_column("rephrased", rephrased)
+  ].join(COLUMN_GAP2);
+}
+function render_summaries(summaries) {
+  const { runs, readings, shapes, rephrased } = rule_value_runs.tally(summaries);
+  if (runs === 0) return { table: NO_TARGETS };
+  const judged = rule_value_candidates.judge(readings, runs);
+  return {
+    table: readings.map((reading) => row(reading, rule_rephrase.rephrased_of(reading.id, rephrased))).join("\n"),
+    candidates: `${rule_value_candidates.render(judged, runs)}
+${piped_verification_shapes.render(shapes)}`
+  };
+}
+function render_parts(runs) {
+  return render_summaries(summarized(runs));
+}
+function render4(runs) {
+  return render_parts(runs).table;
+}
+function cached_text(fresh) {
+  const taken_at = fresh.taken_at.toISOString();
+  return `${fresh.text.trimEnd()}
+
+${CACHED_NOTE} ${taken_at} \u2014 ${FRESH_FLAG} to measure now, with candidates`;
+}
+function print_measured(cwd) {
+  const { table, candidates } = render_summaries(gather_summaries(cwd));
+  process.stdout.write(`${[table, candidates].filter(Boolean).join("\n\n")}
+`);
+}
+function print_reading(argv, cwd) {
+  const fresh = argv.includes(FRESH_FLAG) ? void 0 : rule_value_cache.read_fresh(cwd);
+  if (fresh === void 0) print_measured(cwd);
+  else process.stdout.write(`${cached_text(fresh)}
+`);
+}
+function print_prose(cwd) {
+  process.stdout.write(`${rule_value_prose.render(rule_value_prose.audit(cwd))}
+`);
+}
+function print_transcripts(argv, cwd) {
+  if (argv.includes(REFRESH_FLAG)) {
+    rule_value_cache.store(render_summaries(gather_summaries(cwd)).table, cwd);
+  } else print_reading(argv, cwd);
+}
+function run_rule_value(argv = [], cwd = process.cwd()) {
+  if (argv.includes(PROSE_FLAG)) print_prose(cwd);
+  else print_transcripts(argv, cwd);
+  return 0;
+}
+if (process.argv[1] === fileURLToPath3(__josh_source_url3)) {
+  process.exitCode = run_rule_value(process.argv.slice(ARGV_OFFSET));
+}
+var rule_value_cli = {
+  group_by_run,
+  render: render4,
+  render_parts,
+  render_summaries,
+  row,
+  run_rule_value,
+  CACHED_NOTE,
+  NO_TARGETS,
+  UNMEASURED,
+  UNREACHED
+};
+export {
+  rule_value_cli
+};