@event4u/agent-config 9.10.0 → 9.11.0

package/dist/cli-delegate/chunk-736JCWLM.js

@@ -0,0 +1,1104 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  resolvePackageRoot
+} from "./chunk-MCJYCQPF.js";
+import {
+  __export
+} from "./chunk-J55WI3RR.js";
+
+// src/scripts/_cli/cmd_refresh.ts
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
+import { spawnSync } from "node:child_process";
+import process3 from "node:process";
+import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL3 } from "node:url";
+
+// src/scripts/_lib/cli_wrapper.ts
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var _PACKAGE_ROOT = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+  "..",
+  ".."
+);
+var _TEMPLATE = path.join(
+  _PACKAGE_ROOT,
+  "src",
+  "templates",
+  "agent-config-wrapper.sh"
+);
+function _is_file(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function _target(project_root) {
+  return path.join(project_root, "agent-config");
+}
+function needs_refresh(project_root) {
+  if (!_is_file(_TEMPLATE)) return false;
+  const target = _target(project_root);
+  if (!_is_file(target)) return true;
+  try {
+    return fs.readFileSync(target, "utf-8") !== fs.readFileSync(_TEMPLATE, "utf-8");
+  } catch {
+    return true;
+  }
+}
+function install_cli_wrapper(project_root) {
+  if (!_is_file(_TEMPLATE)) return null;
+  const target = _target(project_root);
+  fs.copyFileSync(_TEMPLATE, target);
+  fs.chmodSync(target, 493);
+  return target;
+}
+
+// src/scripts/sync_gitignore.ts
+var sync_gitignore_exports = {};
+__export(sync_gitignore_exports, {
+  DEFAULT_GITIGNORE: () => DEFAULT_GITIGNORE,
+  DEFAULT_TEMPLATE: () => DEFAULT_TEMPLATE,
+  LEGACY_PATTERNS: () => LEGACY_PATTERNS,
+  SECTION_FOOTER: () => SECTION_FOOTER,
+  SECTION_HEADER: () => SECTION_HEADER,
+  TemplateNotFoundError: () => TemplateNotFoundError,
+  block_entries: () => block_entries,
+  build_fresh_block: () => build_fresh_block,
+  cleanup_legacy: () => cleanup_legacy,
+  find_block: () => find_block,
+  format_file: () => format_file,
+  load_template: () => load_template,
+  main: () => main,
+  render_diff: () => render_diff,
+  sync_block: () => sync_block,
+  template_entries: () => template_entries,
+  unified_diff: () => unified_diff
+});
+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),
+    _splitlinesKeepends(new_text),
+    p,
+    p,
+    3
+  ).join("");
+}
+function _splitlinesKeepends(text) {
+  if (text === "") return [];
+  const out = [];
+  let buf = "";
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    buf += ch;
+    if (ch === "\n") {
+      out.push(buf);
+      buf = "";
+    } else if (ch === "\r") {
+      if (text[i + 1] === "\n") {
+        buf += "\n";
+        i += 1;
+      }
+      out.push(buf);
+      buf = "";
+    }
+  }
+  if (buf !== "") out.push(buf);
+  return out;
+}
+function _matchingBlocks(a, b) {
+  const b2j = /* @__PURE__ */ new Map();
+  for (let i = 0; i < b.length; i += 1) {
+    const el = b[i];
+    const arr = b2j.get(el);
+    if (arr) arr.push(i);
+    else b2j.set(el, [i]);
+  }
+  function findLongest(alo, ahi, blo, bhi) {
+    let besti = alo;
+    let bestj = blo;
+    let bestsize = 0;
+    let j2len = /* @__PURE__ */ new Map();
+    for (let i = alo; i < ahi; i += 1) {
+      const newj2len = /* @__PURE__ */ new Map();
+      const js = b2j.get(a[i]) ?? [];
+      for (const j of js) {
+        if (j < blo) continue;
+        if (j >= bhi) break;
+        const k = (j2len.get(j - 1) ?? 0) + 1;
+        newj2len.set(j, k);
+        if (k > bestsize) {
+          besti = i - k + 1;
+          bestj = j - k + 1;
+          bestsize = k;
+        }
+      }
+      j2len = newj2len;
+    }
+    return [besti, bestj, bestsize];
+  }
+  const queue = [[0, a.length, 0, b.length]];
+  const blocks = [];
+  while (queue.length > 0) {
+    const [alo, ahi, blo, bhi] = queue.pop();
+    const [i, j, k] = findLongest(alo, ahi, blo, bhi);
+    if (k > 0) {
+      blocks.push([i, j, k]);
+      if (alo < i && blo < j) queue.push([alo, i, blo, j]);
+      if (i + k < ahi && j + k < bhi) queue.push([i + k, ahi, j + k, bhi]);
+    }
+  }
+  blocks.sort((x, y) => x[0] - y[0] || x[1] - y[1]);
+  blocks.push([a.length, b.length, 0]);
+  return blocks;
+}
+function _getOpcodes(a, b) {
+  let i = 0;
+  let j = 0;
+  const answer = [];
+  for (const [ai, bj, size] of _matchingBlocks(a, b)) {
+    let tag = "";
+    if (i < ai && j < bj) tag = "replace";
+    else if (i < ai) tag = "delete";
+    else if (j < bj) tag = "insert";
+    if (tag) answer.push({ tag, i1: i, i2: ai, j1: j, j2: bj });
+    i = ai + size;
+    j = bj + size;
+    if (size > 0) answer.push({ tag: "equal", i1: ai, i2: i, j1: bj, j2: j });
+  }
+  return answer;
+}
+function _getGroupedOpcodes(a, b, n) {
+  let codes = _getOpcodes(a, b);
+  if (codes.length === 0) {
+    codes = [{ tag: "equal", i1: 0, i2: 1, j1: 0, j2: 1 }];
+  }
+  if (codes[0].tag === "equal") {
+    const c = codes[0];
+    codes[0] = {
+      tag: c.tag,
+      i1: Math.max(c.i1, c.i2 - n),
+      i2: c.i2,
+      j1: Math.max(c.j1, c.j2 - n),
+      j2: c.j2
+    };
+  }
+  const last = codes[codes.length - 1];
+  if (last.tag === "equal") {
+    codes[codes.length - 1] = {
+      tag: last.tag,
+      i1: last.i1,
+      i2: Math.min(last.i2, last.i1 + n),
+      j1: last.j1,
+      j2: Math.min(last.j2, last.j1 + n)
+    };
+  }
+  const nn = n + n;
+  const groups = [];
+  let group = [];
+  for (const code of codes) {
+    let { i1, j1 } = code;
+    const { tag, i2, j2 } = code;
+    if (tag === "equal" && i2 - i1 > nn) {
+      group.push({ tag, i1, i2: Math.min(i2, i1 + n), j1, j2: Math.min(j2, j1 + n) });
+      groups.push(group);
+      group = [];
+      i1 = Math.max(i1, i2 - n);
+      j1 = Math.max(j1, j2 - n);
+    }
+    group.push({ tag, i1, i2, j1, j2 });
+  }
+  if (group.length > 0 && !(group.length === 1 && group[0].tag === "equal")) {
+    groups.push(group);
+  }
+  return groups;
+}
+function _formatRangeUnified(start, stop) {
+  let beginning = start + 1;
+  const length = stop - start;
+  if (length === 1) return `${beginning}`;
+  if (length === 0) beginning -= 1;
+  return `${beginning},${length}`;
+}
+function unified_diff(a, b, fromfile, tofile, n) {
+  const out = [];
+  let started = false;
+  for (const group of _getGroupedOpcodes(a, b, n)) {
+    if (!started) {
+      started = true;
+      out.push(`--- ${fromfile}
+`);
+      out.push(`+++ ${tofile}
+`);
+    }
+    const first = group[0];
+    const last = group[group.length - 1];
+    const file1Range = _formatRangeUnified(first.i1, last.i2);
+    const file2Range = _formatRangeUnified(first.j1, last.j2);
+    out.push(`@@ -${file1Range} +${file2Range} @@
+`);
+    for (const { tag, i1, i2, j1, j2 } of group) {
+      if (tag === "equal") {
+        for (const line of a.slice(i1, i2)) out.push(" " + line);
+        continue;
+      }
+      if (tag === "replace" || tag === "delete") {
+        for (const line of a.slice(i1, i2)) out.push("-" + line);
+      }
+      if (tag === "replace" || tag === "insert") {
+        for (const line of b.slice(j1, j2)) out.push("+" + line);
+      }
+    }
+  }
+  return out;
+}
+var _PROG = "sync_gitignore.py";
+function _argError(usage, msg) {
+  process.stderr.write(usage);
+  process.stderr.write(`${_PROG}: error: ${msg}
+`);
+  process.exit(2);
+}
+function parse_args(argv) {
+  const args = {
+    path: DEFAULT_GITIGNORE,
+    template: DEFAULT_TEMPLATE,
+    dry_run: false,
+    replace: false,
+    cleanup_legacy: false,
+    quiet: false
+  };
+  const usage = "usage: sync_gitignore.py [-h] [--path PATH] [--template TEMPLATE]\n                         [--dry-run] [--replace] [--cleanup-legacy]\n                         [--quiet]\n";
+  const valueFlags = {
+    "--path": "path",
+    "--template": "template"
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "-h" || arg === "--help") {
+      process.stdout.write(usage);
+      process.exit(0);
+    } else if (arg === "--dry-run") {
+      args.dry_run = true;
+    } else if (arg === "--replace") {
+      args.replace = true;
+    } else if (arg === "--cleanup-legacy") {
+      args.cleanup_legacy = true;
+    } else if (arg === "--quiet") {
+      args.quiet = true;
+    } else if (valueFlags[arg] !== void 0) {
+      const next = argv[i + 1];
+      if (next === void 0) {
+        _argError(usage, `argument ${arg}: expected one argument`);
+      }
+      args[valueFlags[arg]] = next;
+      i += 1;
+    } else {
+      const eq = arg.indexOf("=");
+      const flag = eq === -1 ? arg : arg.slice(0, eq);
+      if (eq !== -1 && valueFlags[flag] !== void 0) {
+        args[valueFlags[flag]] = arg.slice(eq + 1);
+      } else {
+        _argError(usage, `unrecognized arguments: ${arg}`);
+      }
+    }
+  }
+  return args;
+}
+function main(argv) {
+  const args = parse_args(argv);
+  let template_lines;
+  try {
+    template_lines = load_template(args.template);
+  } catch (exc) {
+    if (exc instanceof TemplateNotFoundError) {
+      process.stderr.write(`error: ${exc.message}
+`);
+      return 2;
+    }
+    throw exc;
+  }
+  const target = args.path;
+  let existing_text;
+  let existing_lines;
+  if (_isFile(target)) {
+    existing_text = fs2.readFileSync(target, "utf-8");
+    existing_lines = _splitlines(existing_text).map(_strip);
+  } else {
+    existing_text = "";
+    existing_lines = [];
+  }
+  let removed_legacy = [];
+  if (args.cleanup_legacy) {
+    [existing_lines, removed_legacy] = cleanup_legacy(existing_lines);
+  }
+  const [new_lines, added] = sync_block(existing_lines, template_lines, { replace: args.replace });
+  const new_text = format_file(new_lines);
+  if (new_text === existing_text) {
+    if (!args.quiet) {
+      process.stdout.write(
+        `\u2705  ${target}: block already in sync (${template_entries(template_lines).length} entries)
+`
+      );
+    }
+    return 0;
+  }
+  if (args.dry_run) {
+    const diff = render_diff(existing_text, new_text, target);
+    process.stdout.write(diff);
+    if (!args.quiet) {
+      process.stderr.write(
+        `
+(dry-run) would add ${added.length} entr${added.length === 1 ? "y" : "ies"} to ${target}
+`
+      );
+      if (removed_legacy.length > 0) {
+        process.stderr.write(
+          `(dry-run) would remove ${removed_legacy.length} legacy entr${removed_legacy.length === 1 ? "y" : "ies"}: ${removed_legacy.join(", ")}
+`
+        );
+      }
+    }
+    return 0;
+  }
+  fs2.mkdirSync(path2.dirname(path2.resolve(target)), { recursive: true });
+  fs2.writeFileSync(target, new_text, "utf-8");
+  if (!args.quiet) {
+    const action = args.replace ? "replaced" : "updated";
+    process.stdout.write(
+      `\u2705  ${target}: ${action} block (${added.length} entr${added.length === 1 ? "y" : "ies"} added)
+`
+    );
+    if (removed_legacy.length > 0) {
+      process.stdout.write(
+        `   removed ${removed_legacy.length} legacy entr${removed_legacy.length === 1 ? "y" : "ies"}: ${removed_legacy.join(", ")}
+`
+      );
+    }
+  }
+  return 0;
+}
+function _isCliEntry() {
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL(path2.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs2.realpathSync(fileURLToPath2(import.meta.url));
+    const argv = fs2.realpathSync(path2.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry() || process.argv[1] === _HERE) {
+  process.exit(main(process.argv.slice(2)));
+}
+
+// src/scripts/sync_gitattributes.ts
+var sync_gitattributes_exports = {};
+__export(sync_gitattributes_exports, {
+  DEFAULT_GITATTRIBUTES: () => DEFAULT_GITATTRIBUTES,
+  DEFAULT_TEMPLATE: () => DEFAULT_TEMPLATE2,
+  SECTION_FOOTER: () => SECTION_FOOTER2,
+  SECTION_HEADER: () => SECTION_HEADER2,
+  TemplateNotFoundError: () => TemplateNotFoundError2,
+  block_entries: () => block_entries2,
+  build_fresh_block: () => build_fresh_block2,
+  find_block: () => find_block2,
+  format_file: () => format_file2,
+  load_template: () => load_template2,
+  main: () => main2,
+  sync_block: () => sync_block2,
+  template_entries: () => template_entries2
+});
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+import process2 from "node:process";
+import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
+var SECTION_HEADER2 = "# --- BEGIN agent-config managed: memory merge attributes ---";
+var SECTION_FOOTER2 = "# --- END agent-config managed: memory merge attributes ---";
+var DEFAULT_GITATTRIBUTES = ".gitattributes";
+var _HERE2 = fileURLToPath3(import.meta.url);
+var DEFAULT_TEMPLATE2 = path3.join(
+  path3.dirname(_HERE2),
+  "..",
+  "agent-src",
+  "templates",
+  "agents",
+  ".gitattributes.fragment"
+);
+function _strip2(ln) {
+  return ln.replace(/\n+$/, "").replace(/\s+$/, "");
+}
+function _is_entry2(ln) {
+  const s = _strip2(ln).replace(/^\s+/, "");
+  return Boolean(s) && !s.startsWith("#");
+}
+var TemplateNotFoundError2 = class extends Error {
+  constructor(p) {
+    super(`template not found: ${p}`);
+    this.name = "TemplateNotFoundError";
+  }
+};
+function _isFile2(p) {
+  try {
+    return fs3.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function _splitlines2(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_template2(p) {
+  if (!_isFile2(p)) {
+    throw new TemplateNotFoundError2(p);
+  }
+  const text = fs3.readFileSync(p, "utf-8");
+  return _splitlines2(text).map(_strip2);
+}
+function find_block2(lines) {
+  for (let i = 0; i < lines.length; i += 1) {
+    if (_strip2(lines[i]) === SECTION_HEADER2) {
+      for (let j = i + 1; j < lines.length; j += 1) {
+        if (_strip2(lines[j]) === SECTION_FOOTER2) {
+          return [i, j + 1];
+        }
+      }
+      return [i, lines.length];
+    }
+  }
+  return null;
+}
+function block_entries2(block_lines) {
+  return block_lines.filter((ln) => _is_entry2(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+/, ""));
+}
+function build_fresh_block2(template_lines) {
+  return [SECTION_HEADER2, ...template_lines, SECTION_FOOTER2];
+}
+function sync_block2(existing_lines, template_lines) {
+  const loc = find_block2(existing_lines);
+  const fresh = build_fresh_block2(template_lines);
+  if (loc === null) {
+    const newLines = [...existing_lines];
+    if (newLines.length > 0 && _strip2(newLines[newLines.length - 1]) !== "") {
+      newLines.push("");
+    }
+    newLines.push(...fresh);
+    return [newLines, template_entries2(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);
+  const existing_entries = new Set(block_entries2(block));
+  const missing = template_entries2(template_lines).filter((e) => !existing_entries.has(e));
+  if (missing.length === 0) {
+    return [[...existing_lines], []];
+  }
+  let insert_at;
+  if (block.length > 0 && _strip2(block[block.length - 1]) === SECTION_FOOTER2) {
+    insert_at = block.length - 1;
+  } else {
+    block = [...block, SECTION_FOOTER2];
+    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 format_file2(lines) {
+  const text = lines.join("\n");
+  return text.replace(/\n+$/, "") + "\n";
+}
+var _PROG2 = "sync_gitattributes";
+function _argError2(usage, msg) {
+  process2.stderr.write(usage);
+  process2.stderr.write(`${_PROG2}: error: ${msg}
+`);
+  process2.exit(2);
+}
+function parse_args2(argv) {
+  const args = {
+    path: DEFAULT_GITATTRIBUTES,
+    template: DEFAULT_TEMPLATE2,
+    check: false,
+    quiet: false
+  };
+  const usage = "usage: sync_gitattributes [-h] [--path PATH] [--template TEMPLATE] [--check] [--quiet]\n";
+  const valueFlags = {
+    "--path": "path",
+    "--template": "template"
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "-h" || arg === "--help") {
+      process2.stdout.write(usage);
+      process2.exit(0);
+    } else if (arg === "--check") {
+      args.check = true;
+    } else if (arg === "--quiet") {
+      args.quiet = true;
+    } else if (valueFlags[arg] !== void 0) {
+      const next = argv[i + 1];
+      if (next === void 0) {
+        _argError2(usage, `argument ${arg}: expected one argument`);
+      }
+      args[valueFlags[arg]] = next;
+      i += 1;
+    } else {
+      const eq = arg.indexOf("=");
+      const flag = eq === -1 ? arg : arg.slice(0, eq);
+      if (eq !== -1 && valueFlags[flag] !== void 0) {
+        args[valueFlags[flag]] = arg.slice(eq + 1);
+      } else {
+        _argError2(usage, `unrecognized arguments: ${arg}`);
+      }
+    }
+  }
+  return args;
+}
+function main2(argv) {
+  const args = parse_args2(argv);
+  let template_lines;
+  try {
+    template_lines = load_template2(args.template);
+  } catch (exc) {
+    if (exc instanceof TemplateNotFoundError2) {
+      process2.stderr.write(`error: ${exc.message}
+`);
+      return 2;
+    }
+    throw exc;
+  }
+  const target = args.path;
+  let existing_text;
+  let existing_lines;
+  if (_isFile2(target)) {
+    existing_text = fs3.readFileSync(target, "utf-8");
+    existing_lines = _splitlines2(existing_text).map(_strip2);
+  } else {
+    existing_text = "";
+    existing_lines = [];
+  }
+  const [new_lines, added] = sync_block2(existing_lines, template_lines);
+  const new_text = format_file2(new_lines);
+  if (new_text === existing_text) {
+    if (!args.quiet) {
+      process2.stdout.write(
+        `\u2705  ${target}: block already in sync (${template_entries2(template_lines).length} entries)
+`
+      );
+    }
+    return 0;
+  }
+  if (args.check) {
+    if (!args.quiet) {
+      process2.stderr.write(
+        `\u26A0\uFE0F  ${target}: missing ${added.length} managed entr${added.length === 1 ? "y" : "ies"} \u2014 run without --check to apply
+`
+      );
+    }
+    return 1;
+  }
+  fs3.mkdirSync(path3.dirname(path3.resolve(target)), { recursive: true });
+  fs3.writeFileSync(target, new_text, "utf-8");
+  if (!args.quiet) {
+    process2.stdout.write(
+      `\u2705  ${target}: updated block (${added.length} entr${added.length === 1 ? "y" : "ies"} added)
+`
+    );
+  }
+  return 0;
+}
+function _isCliEntry2() {
+  if (process2.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL2(path3.resolve(process2.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs3.realpathSync(fileURLToPath3(import.meta.url));
+    const argv = fs3.realpathSync(path3.resolve(process2.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry2() || process2.argv[1] === _HERE2) {
+  process2.exit(main2(process2.argv.slice(2)));
+}
+
+// src/scripts/_cli/cmd_refresh.ts
+var PACKAGE_ROOT = resolvePackageRoot(import.meta.url);
+var _HERE3 = fileURLToPath4(import.meta.url);
+var ArgparseExit = class extends Error {
+  constructor(code) {
+    super(`argparse-exit-${code}`);
+    this.code = code;
+  }
+  code;
+};
+var _stdout = { write: (t) => process3.stdout.write(t) };
+var _stderr = { write: (t) => process3.stderr.write(t) };
+function _print(out, line = "") {
+  out.write(line + "\n");
+}
+function _isFile3(p) {
+  try {
+    return fs4.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function _isDir(p) {
+  try {
+    return fs4.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function _exists(p) {
+  try {
+    fs4.statSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function _readText(p) {
+  return fs4.readFileSync(p, { encoding: "utf-8" });
+}
+function _writeText(p, text) {
+  fs4.writeFileSync(p, text, { encoding: "utf-8" });
+}
+var CONSUMER_BRIDGE_MARKER_RELPATH = path4.join("agents", ".event4u-bridge.yml");
+var SRC_MARKER_DIR = ".agent-src.uncondensed";
+function _remove_legacy_consumer_bridge_marker(project_root, env = null) {
+  const env_map = env ?? process3.env;
+  if (env_map["AGENT_CONFIG_DEV_MODE"] === "1") return null;
+  if (_isDir(path4.join(project_root, SRC_MARKER_DIR))) return null;
+  const target = path4.join(project_root, CONSUMER_BRIDGE_MARKER_RELPATH);
+  if (!_isFile3(target)) return null;
+  try {
+    fs4.rmSync(target);
+  } catch {
+    return null;
+  }
+  return target;
+}
+function _default_runner(cmd) {
+  const r = spawnSync(cmd[0], cmd.slice(1), { stdio: "inherit" });
+  if (r.error) {
+    _stderr.write(`agent-config refresh: cannot run ${cmd[0]}: ${osErrorStr(r.error)}
+`);
+    return 1;
+  }
+  return r.status ?? 1;
+}
+function osErrorStr(exc) {
+  if (exc && typeof exc === "object" && "message" in exc) {
+    return String(exc.message);
+  }
+  return String(exc);
+}
+function _refresh_global(runner, out, err) {
+  const install_sh = path4.join(PACKAGE_ROOT, "src", "scripts", "install");
+  if (!_isFile3(install_sh)) {
+    _print(err, `\u274C  agent-config refresh: installer not found at ${install_sh}`);
+    return 1;
+  }
+  _print(out, "\u2192 refreshing global install (scripts/install --global)");
+  const rc = runner(["bash", install_sh, "--global"]);
+  if (rc !== 0) {
+    _print(err, `\u274C  agent-config refresh --global: install failed (exit ${rc})`);
+    return 1;
+  }
+  _print(out, "\u2705  global install refreshed.");
+  return 0;
+}
+function _is_source_repo(project_root) {
+  if (_isDir(path4.join(project_root, "dist/agent-src"))) {
+    return true;
+  }
+  if (_glob_packages_uncondensed(project_root).length > 0) {
+    return true;
+  }
+  const pkg = path4.join(project_root, "package.json");
+  if (_isFile3(pkg)) {
+    try {
+      const data = JSON.parse(_readText(pkg));
+      if (data["name"] === "@event4u/agent-config") {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+function _glob_packages_uncondensed(project_root) {
+  const packages = path4.join(project_root, "packages");
+  let entries;
+  try {
+    entries = fs4.readdirSync(packages);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of entries) {
+    const candidate = path4.join(packages, name, SRC_MARKER_DIR);
+    if (_exists(candidate)) {
+      out.push(candidate);
+    }
+  }
+  return out;
+}
+function _refresh_project(project_root, out, err) {
+  if (_is_source_repo(project_root)) {
+    _print(
+      out,
+      "\u2139\uFE0F  refresh --project skipped: this is the agent-config package itself (or a checkout of it). Maintainers use AGENT_CONFIG_DEV_MODE=1, not a consumer refresh."
+    );
+    return 0;
+  }
+  const removed = _remove_legacy_consumer_bridge_marker(project_root);
+  if (removed !== null) {
+    _print(out, `\u2705  removed legacy bridge marker: ${removed}`);
+  }
+  const overrides = path4.join(project_root, "agents", "overrides");
+  fs4.mkdirSync(overrides, { recursive: true });
+  const keep = path4.join(overrides, "README.md");
+  if (!_exists(keep)) {
+    _writeText(
+      keep,
+      "# Project overrides\n\nProject-local overrides/extensions of shared skills, rules, and commands. The only project-side agent surface ADR-020 permits. See the `override-management` skill.\n"
+    );
+  }
+  _print(out, `\u2705  overrides scaffold: ${overrides}`);
+  const wrapper = install_cli_wrapper(project_root);
+  if (wrapper !== null) {
+    _print(out, `\u2705  ./agent-config wrapper refreshed: ${wrapper}`);
+  }
+  const rc = _sync_gitignore(project_root, out, err);
+  if (rc !== 0) {
+    return rc;
+  }
+  _sync_gitattributes(project_root, out, err);
+  _print(out, "\u2705  refresh --project complete.");
+  return 0;
+}
+function _sync_gitignore(project_root, out, err) {
+  let mod;
+  try {
+    mod = sync_gitignore_exports;
+  } catch (exc) {
+    _print(err, `\u26A0\uFE0F  refresh --project: gitignore sync unavailable (${osErrorStr(exc)})`);
+    return 0;
+  }
+  const rc = mod.main(["--path", path4.join(project_root, ".gitignore")]);
+  if (rc !== 0 && rc !== null && rc !== void 0) {
+    _print(err, `\u26A0\uFE0F  refresh --project: gitignore sync returned ${rc}`);
+  } else {
+    _print(out, "\u2705  .gitignore agents/ block synced.");
+  }
+  return 0;
+}
+function _sync_gitattributes(project_root, out, err) {
+  let mod;
+  try {
+    mod = sync_gitattributes_exports;
+  } catch (exc) {
+    _print(err, `\u26A0\uFE0F  refresh --project: gitattributes sync unavailable (${osErrorStr(exc)})`);
+    return 0;
+  }
+  const rc = mod.main(["--path", path4.join(project_root, ".gitattributes")]);
+  if (rc !== 0 && rc !== null && rc !== void 0) {
+    _print(err, `\u26A0\uFE0F  refresh --project: gitattributes sync returned ${rc}`);
+  } else {
+    _print(out, "\u2705  .gitattributes memory merge-safety block synced.");
+  }
+  return 0;
+}
+var PROG = "agent-config refresh";
+var USAGE = `usage: ${PROG} [-h] [--global] [--project]
+`;
+function _argError3(msg) {
+  _stderr.write(USAGE);
+  _stderr.write(`${PROG}: error: ${msg}
+`);
+  throw new ArgparseExit(2);
+}
+function _parse(argv) {
+  const args = { is_global: false, is_project: false };
+  const positionals = [];
+  let i = 0;
+  while (i < argv.length) {
+    const a = argv[i];
+    if (a === "-h" || a === "--help") {
+      _stdout.write(USAGE);
+      throw new ArgparseExit(0);
+    }
+    const eq = a.startsWith("--") ? a.indexOf("=") : -1;
+    const flag = eq >= 0 ? a.slice(0, eq) : a;
+    const inlineVal = eq >= 0 ? a.slice(eq + 1) : null;
+    if (flag === "--global") {
+      if (inlineVal !== null) {
+        _argError3(`argument --global: ignored explicit argument '${inlineVal}'`);
+      }
+      args.is_global = true;
+      i += 1;
+      continue;
+    }
+    if (flag === "--project") {
+      if (inlineVal !== null) {
+        _argError3(`argument --project: ignored explicit argument '${inlineVal}'`);
+      }
+      args.is_project = true;
+      i += 1;
+      continue;
+    }
+    if (a.startsWith("-") && a !== "-") {
+      _argError3(`unrecognized arguments: ${a}`);
+    }
+    positionals.push(a);
+    i += 1;
+  }
+  if (positionals.length > 0) {
+    _argError3(`unrecognized arguments: ${positionals.join(" ")}`);
+  }
+  return args;
+}
+function main3(argv = null, options = {}) {
+  const runner = options.runner ?? _default_runner;
+  const out = options.out ?? _stdout;
+  const err = options.err ?? _stderr;
+  const args = _parse(argv ?? process3.argv.slice(2));
+  if (!args.is_global && !args.is_project) {
+    _print(
+      err,
+      "\u274C  agent-config refresh: specify a scope \u2014 --global and/or --project (never a silent default)."
+    );
+    return 1;
+  }
+  const root = options.project_root ?? process3.cwd();
+  let rc = 0;
+  if (args.is_global) {
+    rc = _refresh_global(runner, out, err) || rc;
+  }
+  if (args.is_project && rc === 0) {
+    rc = _refresh_project(root, out, err) || rc;
+  }
+  return rc;
+}
+function _isCliEntry3() {
+  if (process3.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL3(path4.resolve(process3.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs4.realpathSync(fileURLToPath4(import.meta.url));
+    const argv = fs4.realpathSync(path4.resolve(process3.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry3() || process3.argv[1] === _HERE3) {
+  try {
+    process3.exitCode = main3(process3.argv.slice(2));
+  } catch (e) {
+    if (e instanceof ArgparseExit) {
+      process3.exitCode = e.code;
+    } else {
+      throw e;
+    }
+  }
+}
+
+export {
+  needs_refresh,
+  install_cli_wrapper,
+  SECTION_HEADER2 as SECTION_HEADER,
+  DEFAULT_GITATTRIBUTES,
+  ArgparseExit,
+  _remove_legacy_consumer_bridge_marker,
+  _default_runner,
+  _refresh_global,
+  _is_source_repo,
+  _refresh_project,
+  _sync_gitignore,
+  _sync_gitattributes,
+  _parse,
+  main3 as main
+};