@event4u/agent-config 16.3.0 → 16.4.0

package/dist/cli-delegate/chunk-6V5FMA3P.js

@@ -0,0 +1,186 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  settings_layer_states,
+  template_defaults,
+  user_global_settings_paths
+} from "./chunk-H76PHZBI.js";
+
+// src/scripts/_lib/git_convention.ts
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import * as fs from "node:fs";
+var _require = createRequire(import.meta.url);
+var GIT_CONVENTION_KEYS = ["commit_format", "branch_pattern", "update_strategy"];
+var GIT_CONVENTION_ENUMS = {
+  commit_format: ["ticket-scope", "ticket-conventional"],
+  update_strategy: ["merge", "rebase"]
+};
+function _parse(p) {
+  let text;
+  try {
+    if (!fs.statSync(p).isFile()) return { parsed: "absent", data: null };
+    text = fs.readFileSync(p, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") return { parsed: "absent", data: null };
+    return { parsed: "malformed", data: null, why: "the file cannot be read" };
+  }
+  return parseLayerText(text);
+}
+function _parseFailure(text, err) {
+  const line = err.linePos?.[0]?.line;
+  if (line === void 0) return "the file does not parse";
+  const quote = (text.split("\n")[line - 1] ?? "").includes("{") ? `; a value containing \`{\` must be quoted, e.g. ${_quoteExample("branch_pattern")}` : "";
+  return `the file does not parse at line ${line}${quote}`;
+}
+function _quoteExample(key) {
+  return `${key}: "${key === "branch_pattern" ? "{ticket}-{slug}" : GIT_CONVENTION_ENUMS[key]?.[0] ?? "\u2026"}"`;
+}
+function parseLayerText(text) {
+  let data;
+  try {
+    const YAML = _require("yaml");
+    data = YAML.parse(text, { version: "1.1" });
+  } catch (err) {
+    return { parsed: "malformed", data: null, why: _parseFailure(text, err) };
+  }
+  if (data === null || data === void 0) return { parsed: "valid", data: {} };
+  if (typeof data !== "object" || Array.isArray(data)) return { parsed: "malformed", data: null, why: "the document is not a map" };
+  return { parsed: "valid", data };
+}
+function fileSource(files) {
+  return {
+    layers: () => [
+      ...(files.userGlobal ?? []).map((p) => ({ path: p, carries: false, ..._parse(p) })),
+      ...(files.developer ?? []).map((p) => ({ path: p, carries: true, ..._parse(p) }))
+    ]
+  };
+}
+function checkoutSource(cwd) {
+  return {
+    layers: () => {
+      const userGlobalCount = user_global_settings_paths().length;
+      const all = settings_layer_states({ cwd }).map((l) => l.path);
+      return fileSource({ userGlobal: all.slice(0, userGlobalCount), developer: all.slice(userGlobalCount) }).layers();
+    }
+  };
+}
+function _lookup(data, key) {
+  if (data === null || typeof data !== "object") return { present: false };
+  const git = data.git;
+  if (git === void 0 || git === null) return { present: false };
+  if (typeof git !== "object" || Array.isArray(git)) return { present: true, notAMap: true };
+  const value = git[key];
+  if (value === void 0 || value === null) return { present: false };
+  return { present: true, value };
+}
+var BRANCH_PLACEHOLDERS = ["type", "ticket", "slug"];
+var BRANCH_SAMPLE = {
+  type: "feat",
+  ticket: "DEV-1234",
+  slug: "sample-change"
+};
+var BRANCH_LITERAL = /^[A-Za-z0-9._/-]*$/;
+function renderBranchSample(pattern) {
+  return pattern.replace(/\{(type|ticket|slug)\}/g, (_m, name) => BRANCH_SAMPLE[name]);
+}
+function _branchPatternReason(pattern) {
+  if (pattern === "") return "the pattern is empty";
+  const literal = pattern.replace(/\{([^{}]*)\}/g, (match, name) => {
+    return BRANCH_PLACEHOLDERS.includes(name) ? "" : `\0${match}`;
+  });
+  const unknown = /\u0000(\{[^{}]*\})/.exec(literal);
+  if (unknown !== null) {
+    return `unknown placeholder ${unknown[1]}; allowed: ${BRANCH_PLACEHOLDERS.map((p) => `{${p}}`).join(", ")}`;
+  }
+  if (/[{}]/.test(literal)) return "an unbalanced brace";
+  if (!BRANCH_LITERAL.test(literal)) {
+    const bad = [...new Set(literal.replace(/[A-Za-z0-9._/-]/g, ""))].join("");
+    return `literal character(s) ${JSON.stringify(bad)} outside [A-Za-z0-9._/-]`;
+  }
+  if (!pattern.includes("{slug}")) return "the pattern must contain {slug}";
+  const sample = renderBranchSample(pattern);
+  const check = spawnSync("git", ["check-ref-format", "--branch", sample], { encoding: "utf8" });
+  if (check.error === void 0 && check.status !== 0) {
+    return `the sample \`${sample}\` fails git check-ref-format --branch`;
+  }
+  return null;
+}
+function invalidReason(key, value) {
+  if (value !== value.trim()) return `\`${value}\` has leading or trailing whitespace`;
+  const allowed = GIT_CONVENTION_ENUMS[key];
+  if (allowed !== void 0) {
+    if (allowed.includes(value)) return null;
+    const caseOnly = allowed.includes(value.toLowerCase()) ? " (values are case-sensitive)" : "";
+    return `\`${value}\` is not one of ${allowed.map((v) => `\`${v}\``).join(", ")}${caseOnly}`;
+  }
+  return _branchPatternReason(value);
+}
+function _defaults() {
+  const git = template_defaults().git ?? {};
+  const out = {};
+  for (const key of GIT_CONVENTION_KEYS) {
+    if (typeof git[key] === "string") out[key] = git[key];
+  }
+  return out;
+}
+function conventionDefault(key) {
+  return _defaults()[key] ?? null;
+}
+function conventionReading(key, state, value, source, detail = null) {
+  const reason = isRefusal(state) ? `git-convention-${state}` : null;
+  return { key, value, source, state, reason, detail };
+}
+function readGitConventionKey(key, source, defaults = _defaults()) {
+  const layers = source.layers();
+  const fallback = defaults[key] ?? null;
+  for (const layer of [...layers].reverse().filter((l) => l.carries)) {
+    if (layer.parsed === "malformed") {
+      return conventionReading(key, "malformed", null, layer.path, `${layer.why ?? "the file cannot be read"}, so the value it may set is unknown`);
+    }
+    if (layer.shapeError !== void 0) return conventionReading(key, "invalid", null, layer.path, layer.shapeError);
+    const found = _lookup(layer.data, key);
+    if (!found.present) continue;
+    if ("notAMap" in found) return conventionReading(key, "invalid", null, layer.path, "`git:` is not a map");
+    if (typeof found.value !== "string") {
+      const shown = typeof found.value === "object" && found.value !== null ? JSON.stringify(found.value) : String(found.value);
+      return conventionReading(key, "invalid", shown, layer.path, `the value is not a string \u2014 quote the value, e.g. ${_quoteExample(key)}`);
+    }
+    const value = found.value;
+    const why = invalidReason(key, value);
+    return why === null ? conventionReading(key, "valid", value, layer.path) : conventionReading(key, "invalid", value, layer.path, why);
+  }
+  for (const layer of [...layers].reverse().filter((l) => !l.carries && l.parsed === "valid")) {
+    const found = _lookup(layer.data, key);
+    if (!found.present || "notAMap" in found) continue;
+    const value = typeof found.value === "string" ? found.value : String(found.value);
+    if (fallback !== null && value === fallback) continue;
+    return conventionReading(
+      key,
+      "discarded",
+      value,
+      layer.path,
+      "user-global files do not carry git.* keys; set it in the project settings file"
+    );
+  }
+  return conventionReading(key, "absent", fallback, null);
+}
+var REFUSAL_STATES = ["malformed", "invalid", "discarded", "unresolvable"];
+function isRefusal(state) {
+  return REFUSAL_STATES.includes(state);
+}
+function describeRefusal(reading) {
+  return `${reading.reason ?? "git-convention-ok"}: git.${reading.key} in ${reading.source ?? "(no file)"} \u2014 ${reading.detail ?? reading.state}`;
+}
+
+export {
+  GIT_CONVENTION_KEYS,
+  parseLayerText,
+  fileSource,
+  checkoutSource,
+  invalidReason,
+  conventionDefault,
+  conventionReading,
+  readGitConventionKey,
+  isRefusal,
+  describeRefusal
+};

package/dist/cli-delegate/chunk-6YQC2HLF.js

@@ -0,0 +1,415 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  atomicAppendLine
+} from "./chunk-MDPPKQCQ.js";
+
+// src/install/txlog.ts
+import { createGzip } from "node:zlib";
+import { createReadStream, createWriteStream, existsSync, readFileSync, renameSync, statSync, unlinkSync } from "node:fs";
+import { pipeline } from "node:stream/promises";
+var ROTATION_MAX_BYTES = 10 * 1024 * 1024;
+var ROTATION_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+var RECOVERY_DEPTH_CAP = 500;
+function appendTxLog(logPath, entry) {
+  if (shouldRotate(logPath)) {
+    rotateLogSync(logPath);
+  }
+  atomicAppendLine(logPath, JSON.stringify(entry));
+}
+function readRecentEntries(logPath) {
+  if (!existsSync(logPath)) {
+    return [];
+  }
+  const raw = readFileSync(logPath, "utf8");
+  const lines = raw.split("\n").filter((l) => l.length > 0);
+  const tail = lines.slice(-RECOVERY_DEPTH_CAP);
+  const out = [];
+  for (const line of tail) {
+    const parsed = tryParseEntry(line);
+    if (parsed !== null) {
+      out.push(parsed);
+    }
+  }
+  return out;
+}
+function shouldRotate(logPath, now = /* @__PURE__ */ new Date()) {
+  if (!existsSync(logPath)) {
+    return false;
+  }
+  let size = 0;
+  try {
+    size = statSync(logPath).size;
+  } catch {
+    return false;
+  }
+  if (size >= ROTATION_MAX_BYTES) {
+    return true;
+  }
+  const firstTs = readFirstTimestamp(logPath);
+  if (firstTs === null) {
+    return false;
+  }
+  return now.getTime() - firstTs >= ROTATION_MAX_AGE_MS;
+}
+function rotateLogSync(logPath) {
+  if (!existsSync(logPath)) {
+    return;
+  }
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const rotated = logPath.replace(/\.jsonl$/, `.${stamp}.jsonl`);
+  renameSync(logPath, rotated);
+  void gzipInPlace(rotated).catch(() => {
+  });
+}
+async function gzipInPlace(source) {
+  const target = `${source}.gz`;
+  await pipeline(createReadStream(source), createGzip(), createWriteStream(target));
+  try {
+    unlinkSync(source);
+  } catch {
+  }
+}
+function readFirstTimestamp(logPath) {
+  try {
+    const raw = readFileSync(logPath, "utf8");
+    const firstLine = raw.split("\n", 1)[0] ?? "";
+    const parsed = tryParseEntry(firstLine);
+    if (parsed === null) return null;
+    const t = Date.parse(parsed.ts);
+    return Number.isFinite(t) ? t : null;
+  } catch {
+    return null;
+  }
+}
+function tryParseEntry(line) {
+  try {
+    const obj = JSON.parse(line);
+    if (typeof obj.ts !== "string" || typeof obj.kind !== "string" || typeof obj.path !== "string") {
+      return null;
+    }
+    return obj;
+  } catch {
+    return null;
+  }
+}
+
+// src/scripts/_lib/thin_rules.ts
+import { createHash } from "node:crypto";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/scripts/_lib/rule_law_section.ts
+var IRON_LAW_RE = /\biron\s+laws?\b/i;
+var HEADING_RE = /^(#{1,6})\s+(.+?)\s*$/;
+var FENCE_RE = /^\s*```/;
+function splitFrontmatter(text) {
+  if (text.startsWith("---\n")) {
+    const end = text.indexOf("\n---\n", 4);
+    if (end !== -1) {
+      return [text.slice(0, end + 5), text.slice(end + 5)];
+    }
+  }
+  return ["", text];
+}
+function ruleBody(text) {
+  const [, body] = splitFrontmatter(text);
+  return body.replace(/<!--[\s\S]*?-->/g, "").trim();
+}
+function lawSections(body) {
+  const lines = body.split("\n");
+  let inFence = false;
+  const headings = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    const raw = lines[i];
+    if (FENCE_RE.test(raw)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+    const m = HEADING_RE.exec(raw);
+    if (m) headings.push({ i, depth: m[1].length, title: m[2].trim() });
+  }
+  const out = [];
+  for (let k = 0; k < headings.length; k += 1) {
+    const h = headings[k];
+    if (!IRON_LAW_RE.test(h.title)) continue;
+    let end = lines.length;
+    for (let j = k + 1; j < headings.length; j += 1) {
+      const n = headings[j];
+      if (n.depth <= h.depth) {
+        end = n.i;
+        break;
+      }
+    }
+    out.push({
+      title: h.title,
+      depth: h.depth,
+      line: h.i + 1,
+      text: lines.slice(h.i, end).join("\n").trim()
+    });
+  }
+  return out;
+}
+function lawText(body) {
+  const sections = lawSections(body);
+  if (sections.length === 0) return null;
+  return sections.map((s) => s.text).join("\n\n");
+}
+
+// src/scripts/_lib/rule_consequence_class.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+var CLASS_CONFIG_REL = "src/config/rule-consequence-class.json";
+function readConsequenceClass(repoRoot) {
+  const raw = JSON.parse(fs.readFileSync(path.join(repoRoot, CLASS_CONFIG_REL), "utf-8"));
+  return {
+    criterion_ref: raw.criterion_ref ?? "",
+    members: raw.members ?? {},
+    no_stub: raw.no_stub ?? {},
+    excluded: raw.excluded ?? {}
+  };
+}
+function stubLawIds(cfg) {
+  return new Set(Object.keys(cfg.members).filter((id) => cfg.no_stub[id] === void 0));
+}
+
+// src/scripts/_lib/rule_injection.ts
+var PATH_TRIGGER_KINDS = ["path_prefix", "file_pattern"];
+function tierEntries(router, tier) {
+  const raw = router[tier];
+  if (!Array.isArray(raw)) return [];
+  return raw.map((r) => ({
+    id: String(r["id"] ?? ""),
+    triggers: Array.isArray(r["triggers"]) ? r["triggers"] : []
+  }));
+}
+function allTierRules(router) {
+  const out = [];
+  for (const tier of ["tier_1", "tier_2"]) {
+    for (const e of tierEntries(router, tier)) out.push({ ...e, tier });
+  }
+  return out;
+}
+function pathOnlyRuleIds(router) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const r of allTierRules(router)) {
+    if (r.triggers.length === 0) continue;
+    const allPath = r.triggers.every(
+      (t) => PATH_TRIGGER_KINDS.some((k) => k in t)
+    );
+    if (allPath) ids.add(r.id);
+  }
+  return ids;
+}
+function triggerlessRuleIds(router) {
+  return allTierRules(router).filter((r) => r.triggers.length === 0).map((r) => r.id);
+}
+
+// src/scripts/_lib/thin_rules.ts
+var _HERE = fileURLToPath(import.meta.url);
+var REPO_ROOT = path2.resolve(path2.dirname(_HERE), "..", "..", "..");
+var RULES_SOURCE = path2.join(REPO_ROOT, "dist/agent-src", "rules");
+var ROUTER = path2.join(REPO_ROOT, "dist", "router.json");
+function _globSortedMd(dir) {
+  let names;
+  try {
+    names = fs2.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const out = names.filter((n) => n.endsWith(".md")).map((n) => path2.join(dir, n));
+  out.sort();
+  return out;
+}
+function kernel_ids(routerPath = ROUTER) {
+  const data = JSON.parse(fs2.readFileSync(routerPath, "utf-8"));
+  const kernel = data.kernel;
+  if (Array.isArray(kernel)) {
+    return new Set(kernel.map((x) => String(x)));
+  }
+  return /* @__PURE__ */ new Set();
+}
+function _router(routerPath = ROUTER) {
+  return JSON.parse(fs2.readFileSync(routerPath, "utf-8"));
+}
+function path_only_ids(routerPath = ROUTER) {
+  return pathOnlyRuleIds(_router(routerPath));
+}
+function no_trigger_ids(routerPath = ROUTER) {
+  return new Set(triggerlessRuleIds(_router(routerPath)));
+}
+function rule_workspaces_map(routerPath = ROUTER) {
+  const data = JSON.parse(fs2.readFileSync(routerPath, "utf-8"));
+  const map = /* @__PURE__ */ new Map();
+  for (const tier of ["tier_1", "tier_2"]) {
+    const entries = data[tier];
+    if (!Array.isArray(entries)) continue;
+    for (const e of entries) {
+      const obj = e;
+      const ws = Array.isArray(obj.workspaces) ? obj.workspaces.map((w) => String(w)) : [];
+      map.set(String(obj.id), ws);
+    }
+  }
+  return map;
+}
+function id_in_scope(rule_id, scope, kernel, wsMap, fallback_ws = []) {
+  if (scope === null || kernel.has(rule_id)) {
+    return true;
+  }
+  const ws = wsMap.get(rule_id) ?? fallback_ws;
+  if (ws.length === 0) {
+    return true;
+  }
+  return ws.some((w) => scope.includes(w));
+}
+function fm_workspaces(text) {
+  const [fm] = split_frontmatter(text);
+  const flow = /^workspaces:[ \t]*\[([^\]]*)\]/m.exec(fm);
+  if (flow) {
+    return flow[1].split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter((s) => s.length > 0);
+  }
+  const m = /^workspaces:[ \t]*\n((?:[ \t]+-[ \t]+.*(?:\n|$))+)/m.exec(fm);
+  if (!m) {
+    return [];
+  }
+  return [...m[1].matchAll(/-[ \t]+(\S+)/g)].map((x) => x[1]);
+}
+function split_frontmatter(text) {
+  if (text.startsWith("---\n")) {
+    const end = text.indexOf("\n---\n", 4);
+    if (end !== -1) {
+      return [text.slice(0, end + 5), text.slice(end + 5)];
+    }
+  }
+  return ["", text];
+}
+function _description(fm) {
+  const m = /^description:\s*"?(.+?)"?\s*$/m.exec(fm);
+  return m ? m[1].trim() : "";
+}
+var _TRIGGER_HINT_LIMIT = 6;
+function _trigger_hint(fm) {
+  const hits = [];
+  const re = /^\s*-\s*(?:keyword|phrase):\s*"?(.+?)"?\s*$/gm;
+  let m;
+  while ((m = re.exec(fm)) !== null) {
+    hits.push(m[1].trim());
+    if (hits.length >= _TRIGGER_HINT_LIMIT) {
+      break;
+    }
+  }
+  return hits.join(", ");
+}
+function _title(s) {
+  return s.replace(/[A-Za-z]+/g, (w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase());
+}
+var THIN_ENTRY_MARKER = "> Load the body on a match.";
+var THIN_BODY_POINTER_PREFIX = "Body: ";
+var THIN_BODY_POINTER_RE = (() => {
+  const lit = THIN_BODY_POINTER_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`${lit}((?:(?!${lit}).)+\\.md)\\s*$`, "m");
+})();
+var BODY_LINK_PREFIX = "../../dist/agent-src/rules/";
+function absoluteBodyLinkPrefix(packageRoot) {
+  return `${path2.join(path2.resolve(packageRoot), "dist", "agent-src", "rules")}${path2.sep}`;
+}
+function thin_entry(rule_id, text, bodyLinkPrefix = BODY_LINK_PREFIX) {
+  const [fm] = split_frontmatter(text);
+  const desc = _description(fm);
+  const hint = _trigger_hint(fm);
+  const title = _title(rule_id.replace(/-/g, " "));
+  const fires = hint ? ` Fires on: ${hint}.` : "";
+  return `## ${title}
+${THIN_ENTRY_MARKER}${fires} ${desc} ${THIN_BODY_POINTER_PREFIX}${bodyLinkPrefix}${rule_id}.md
+`;
+}
+var STUB_LAW_OPEN = "<!-- law: byte-copied from the rule, sha256 ";
+var STUB_LAW_CLOSE = "<!-- /law -->";
+function lawDigest(law) {
+  return createHash("sha256").update(law, "utf-8").digest("hex").slice(0, 16);
+}
+var StubLawError = class extends Error {
+  ruleId;
+  constructor(ruleId, message) {
+    super(message);
+    this.name = "StubLawError";
+    this.ruleId = ruleId;
+  }
+};
+var STUB_LAW_MAX_CHARS = 2e3;
+function thin_entry_with_law(rule_id, text, bodyLinkPrefix = BODY_LINK_PREFIX) {
+  const law = lawText(ruleBody(text));
+  if (law === null) {
+    throw new StubLawError(
+      rule_id,
+      `${rule_id} is a high-consequence class member with no law section \u2014 write one, or record it under \`no_stub\` in src/config/rule-consequence-class.json with the reason`
+    );
+  }
+  if (law.length > STUB_LAW_MAX_CHARS) {
+    throw new StubLawError(
+      rule_id,
+      `${rule_id} is a high-consequence class member whose law section is ${law.length} chars, over the ${STUB_LAW_MAX_CHARS} ceiling \u2014 a stub never ships a shortened copy, so either the law moves under the ceiling or the rule is recorded under \`no_stub\` in src/config/rule-consequence-class.json with the reason`
+    );
+  }
+  return thin_entry(rule_id, text, bodyLinkPrefix) + `
+${STUB_LAW_OPEN}${lawDigest(law)} -->
+${law}
+${STUB_LAW_CLOSE}
+`;
+}
+function build_thin(rules_dir = RULES_SOURCE, scope = null, announce = null, consequenceClass = null, roots = null) {
+  const routerPath = roots?.routerPath ?? (roots?.packageRoot === void 0 ? ROUTER : path2.join(roots.packageRoot, "dist", "router.json"));
+  const classRoot = roots?.packageRoot ?? REPO_ROOT;
+  const bodyLinkPrefix = roots?.bodyLinkPrefix ?? BODY_LINK_PREFIX;
+  const kernel = kernel_ids(routerPath);
+  const noTrigger = no_trigger_ids(routerPath);
+  const pathOnly = path_only_ids(routerPath);
+  const cls = consequenceClass ?? readConsequenceClass(classRoot);
+  const lawInStub = stubLawIds(cls);
+  const wsMap = scope !== null ? rule_workspaces_map(routerPath) : /* @__PURE__ */ new Map();
+  const out = /* @__PURE__ */ new Map();
+  for (const p of _globSortedMd(rules_dir)) {
+    const text = fs2.readFileSync(p, "utf-8");
+    const stem = path2.basename(p).replace(/\.md$/, "");
+    if (!id_in_scope(stem, scope, kernel, wsMap, fm_workspaces(text))) {
+      continue;
+    }
+    const noStub = cls.no_stub[stem] !== void 0;
+    const full = kernel.has(stem) || noTrigger.has(stem) || pathOnly.has(stem) || noStub;
+    if (announce !== null && noTrigger.has(stem) && !kernel.has(stem)) {
+      announce(`D3: trigger-less auto rule ${path2.basename(p)} \u2014 kept full-bodied, never thinned`);
+    }
+    if (announce !== null && pathOnly.has(stem) && !kernel.has(stem) && !noTrigger.has(stem)) {
+      announce(
+        `E2: path-only auto rule ${path2.basename(p)} \u2014 kept full-bodied; its only triggers are path-shaped and the delivery concern is not bound on pre_tool_use`
+      );
+    }
+    if (full) {
+      out.set(path2.basename(p), text);
+      continue;
+    }
+    if (lawInStub.has(stem)) {
+      if (announce !== null) {
+        announce(
+          `LAW: high-consequence rule ${path2.basename(p)} \u2014 stub carries its own law section, byte-copied`
+        );
+      }
+      out.set(path2.basename(p), thin_entry_with_law(stem, text, bodyLinkPrefix));
+      continue;
+    }
+    out.set(path2.basename(p), thin_entry(stem, text, bodyLinkPrefix));
+  }
+  return out;
+}
+
+export {
+  appendTxLog,
+  readRecentEntries,
+  splitFrontmatter,
+  ruleBody,
+  split_frontmatter,
+  THIN_ENTRY_MARKER,
+  absoluteBodyLinkPrefix,
+  build_thin
+};

package/dist/cli-delegate/{chunk-E4XIZDIB.js → chunk-7HKRE54K.js}

@@ -326,66 +326,6 @@ function update_json_under_lock(target, mutate, options = {}) {
   }
 }
 
-// src/scripts/_lib/git_common_dir.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
-function realpath_or_self(p) {
-  try {
-    return fs2.realpathSync(p);
-  } catch {
-    return p;
-  }
-}
-function git_dir(project_root) {
-  const dot_git = path2.join(project_root, ".git");
-  try {
-    const st = fs2.statSync(dot_git);
-    if (st.isDirectory()) {
-      return realpath_or_self(dot_git);
-    }
-    const m = fs2.readFileSync(dot_git, "utf-8").match(/^gitdir:\s*(.+)\s*$/m);
-    if (m === null) {
-      return null;
-    }
-    return realpath_or_self(path2.resolve(project_root, m[1].trim()));
-  } catch {
-    return null;
-  }
-}
-function current_branch(project_root) {
-  const gd = git_dir(project_root);
-  if (gd === null) return null;
-  try {
-    const head = fs2.readFileSync(path2.join(gd, "HEAD"), "utf-8").trim();
-    const m = head.match(/^ref:\s*refs\/heads\/(.+)$/);
-    return m === null ? null : m[1].trim();
-  } catch {
-    return null;
-  }
-}
-function git_common_dir(project_root) {
-  const dot_git = path2.join(project_root, ".git");
-  try {
-    const st = fs2.statSync(dot_git);
-    if (st.isDirectory()) {
-      return realpath_or_self(dot_git);
-    }
-    const m = fs2.readFileSync(dot_git, "utf-8").match(/^gitdir:\s*(.+)\s*$/m);
-    if (m === null) {
-      return null;
-    }
-    const gitdir = path2.resolve(project_root, m[1].trim());
-    const commondir_file = path2.join(gitdir, "commondir");
-    if (fs2.existsSync(commondir_file)) {
-      const common = path2.resolve(gitdir, fs2.readFileSync(commondir_file, "utf-8").trim());
-      return realpath_or_self(common);
-    }
-    return realpath_or_self(gitdir);
-  } catch {
-    return null;
-  }
-}
-
 export {
   is_replay_mode,
   atomic_write_json,
@@ -395,8 +335,5 @@ export {
   prune_stale_session_states,
   prune_legacy_state_file,
   owns_session_state,
-  update_json_under_lock,
-  git_dir,
-  current_branch,
-  git_common_dir
+  update_json_under_lock
 };