@event4u/agent-config 16.2.0 → 16.4.0

package/dist/cli-delegate/{chunk-M2DPGFZ4.js → chunk-6V6TA25H.js}

@@ -1,4 +1,23 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  DEFAULT_GITIGNORE,
+  DEFAULT_TEMPLATE,
+  LEGACY_PATTERNS,
+  SECTION_FOOTER,
+  SECTION_HEADER,
+  TemplateNotFoundError,
+  _isFile,
+  _splitlines,
+  _strip,
+  block_entries,
+  build_fresh_block,
+  cleanup_legacy,
+  find_block,
+  format_file,
+  load_template,
+  sync_block,
+  template_entries
+} from "./chunk-ULQRUR23.js";
 import {
   resolvePackageRoot
 } from "./chunk-MCJYCQPF.js";
@@ -82,156 +101,7 @@ import * as fs2 from "node:fs";
 import * as path2 from "node:path";
 import process from "node:process";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
-var SECTION_HEADER = "# event4u/agent-config";
-var SECTION_FOOTER = "# event4u/agent-config \u2014 END";
-var DEFAULT_GITIGNORE = ".gitignore";
 var _HERE = fileURLToPath2(import.meta.url);
-var DEFAULT_TEMPLATE = path2.join(
-  path2.dirname(_HERE),
-  "..",
-  "..",
-  "src",
-  "config",
-  "gitignore-block.txt"
-);
-var LEGACY_PATTERNS = [
-  ".agent-chat-history",
-  ".agent-chat-history.bak",
-  ".agent-chat-history.*.bak",
-  ".agent-prices.md",
-  ".council-tmp/",
-  // 2.x intermediate: prices cache lived directly under agents/ before
-  // consolidating under agents/runtime/.
-  "agents/.agent-prices.md",
-  // Budget history JSONLs — previously listed explicitly at project
-  // root or under agents/; now covered by the /agents/runtime/
-  // catch-all in the managed block.
-  ".augment-budget-history.jsonl",
-  ".rule-budget-history.jsonl",
-  "agents/.augment-budget-history.jsonl",
-  "agents/.rule-budget-history.jsonl"
-];
-function _strip(ln) {
-  return ln.replace(/\n+$/, "").replace(/\s+$/, "");
-}
-function _is_entry(ln) {
-  const s = _strip(ln).replace(/^\s+/, "");
-  return Boolean(s) && !s.startsWith("#");
-}
-var TemplateNotFoundError = class extends Error {
-  constructor(p) {
-    super(`template not found: ${p}`);
-    this.name = "TemplateNotFoundError";
-  }
-};
-function _isFile(p) {
-  try {
-    return fs2.statSync(p).isFile();
-  } catch {
-    return false;
-  }
-}
-function _splitlines(text) {
-  if (text === "") return [];
-  const parts = text.split(/\r\n|\r|\n/);
-  if (parts.length > 0 && parts[parts.length - 1] === "") parts.pop();
-  return parts;
-}
-function load_template(p) {
-  if (!_isFile(p)) {
-    throw new TemplateNotFoundError(p);
-  }
-  const text = fs2.readFileSync(p, "utf-8");
-  return _splitlines(text).map(_strip);
-}
-function find_block(lines) {
-  for (let i = 0; i < lines.length; i += 1) {
-    if (_strip(lines[i]) === SECTION_HEADER) {
-      const start = i;
-      for (let j = i + 1; j < lines.length; j += 1) {
-        if (_strip(lines[j]) === SECTION_FOOTER) {
-          return [start, j + 1];
-        }
-      }
-      let end = lines.length;
-      for (let j = i + 1; j < lines.length; j += 1) {
-        const s = _strip(lines[j]).replace(/^\s+/, "");
-        if (s.startsWith("#") && !s.startsWith("# Agent config") && s !== SECTION_HEADER) {
-          end = j;
-          while (end > i + 1 && _strip(lines[end - 1]) === "") {
-            end -= 1;
-          }
-          break;
-        }
-      }
-      return [start, end];
-    }
-  }
-  return null;
-}
-function block_entries(block_lines) {
-  return block_lines.filter((ln) => _is_entry(ln)).map((ln) => _strip(ln).replace(/^\s+/, ""));
-}
-function template_entries(template_lines) {
-  return template_lines.filter((ln) => _is_entry(ln)).map((ln) => ln.replace(/^\s+/, ""));
-}
-function build_fresh_block(template_lines) {
-  return [SECTION_HEADER, ...template_lines, SECTION_FOOTER];
-}
-function sync_block(existing_lines, template_lines, options = {}) {
-  const replace = options.replace ?? false;
-  const loc = find_block(existing_lines);
-  const fresh = build_fresh_block(template_lines);
-  if (loc === null) {
-    const newLines = [...existing_lines];
-    if (newLines.length > 0 && _strip(newLines[newLines.length - 1]) !== "") {
-      newLines.push("");
-    }
-    newLines.push(...fresh);
-    return [newLines, template_entries(template_lines)];
-  }
-  const [start, end] = loc;
-  const head = existing_lines.slice(0, start);
-  let block = existing_lines.slice(start, end);
-  const tail = existing_lines.slice(end);
-  if (replace) {
-    const existing = new Set(block_entries(block));
-    const added = template_entries(template_lines).filter((e) => !existing.has(e));
-    return [[...head, ...fresh, ...tail], added];
-  }
-  const existing_entries = new Set(block_entries(block));
-  const missing = template_entries(template_lines).filter((e) => !existing_entries.has(e));
-  if (missing.length === 0) {
-    return [[...existing_lines], []];
-  }
-  let insert_at;
-  if (block.length > 0 && _strip(block[block.length - 1]) === SECTION_FOOTER) {
-    insert_at = block.length - 1;
-  } else {
-    block = [...block, SECTION_FOOTER];
-    insert_at = block.length - 1;
-  }
-  const new_block = [...block.slice(0, insert_at), ...missing, ...block.slice(insert_at)];
-  return [[...head, ...new_block, ...tail], missing];
-}
-function cleanup_legacy(lines) {
-  const legacy = new Set(LEGACY_PATTERNS);
-  const kept = [];
-  const removed = [];
-  for (const ln of lines) {
-    const s = _strip(ln).replace(/^\s+/, "");
-    if (legacy.has(s) || s.startsWith("/") && legacy.has(s.slice(1))) {
-      removed.push(s);
-      continue;
-    }
-    kept.push(ln);
-  }
-  return [kept, removed];
-}
-function format_file(lines) {
-  const text = lines.join("\n");
-  return text.replace(/\n+$/, "") + "\n";
-}
 function render_diff(old_text, new_text, p) {
   return unified_diff(
     _splitlinesKeepends(old_text),
@@ -591,7 +461,7 @@ var DEFAULT_TEMPLATE2 = path3.join(
 function _strip2(ln) {
   return ln.replace(/\n+$/, "").replace(/\s+$/, "");
 }
-function _is_entry2(ln) {
+function _is_entry(ln) {
   const s = _strip2(ln).replace(/^\s+/, "");
   return Boolean(s) && !s.startsWith("#");
 }
@@ -635,10 +505,10 @@ function find_block2(lines) {
   return null;
 }
 function block_entries2(block_lines) {
-  return block_lines.filter((ln) => _is_entry2(ln)).map((ln) => _strip2(ln).replace(/^\s+/, ""));
+  return block_lines.filter((ln) => _is_entry(ln)).map((ln) => _strip2(ln).replace(/^\s+/, ""));
 }
 function template_entries2(template_lines) {
-  return template_lines.filter((ln) => _is_entry2(ln)).map((ln) => ln.replace(/^\s+/, ""));
+  return template_lines.filter((ln) => _is_entry(ln)).map((ln) => ln.replace(/^\s+/, ""));
 }
 function build_fresh_block2(template_lines) {
   return [SECTION_HEADER2, ...template_lines, SECTION_FOOTER2];

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
 };