@event4u/agent-config 9.10.0 → 9.12.0

package/dist/cli-delegate/chunk-A3HJ6NTI.js

@@ -0,0 +1,1084 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  write_target
+} from "./chunk-NDJLNC6Q.js";
+import {
+  require_dist
+} from "./chunk-OY53J6II.js";
+import {
+  __export,
+  __toESM
+} from "./chunk-J55WI3RR.js";
+
+// src/scripts/_lib/fs_atomic.ts
+import fs from "node:fs";
+import path from "node:path";
+import { randomBytes } from "node:crypto";
+function _normalize_encoding(encoding) {
+  const compact = encoding.toLowerCase().replace(/[-_\s]/g, "");
+  const candidates = [encoding, compact];
+  if (compact === "latin1" || compact === "iso88591") candidates.push("latin1");
+  if (compact === "utf8") candidates.push("utf8");
+  if (compact === "utf16le" || compact === "utf16") candidates.push("utf16le");
+  if (compact === "usascii") candidates.push("ascii");
+  for (const c of candidates) {
+    if (Buffer.isEncoding(c)) return c;
+  }
+  throw new Error(`unknown encoding: ${encoding}`);
+}
+function write_atomic(p, data, options = {}) {
+  const encoding = options.encoding ?? "utf-8";
+  const target = path.normalize(p);
+  const parent = path.dirname(target);
+  fs.mkdirSync(parent, { recursive: true });
+  let payload;
+  if (typeof data === "string") {
+    payload = Buffer.from(data, _normalize_encoding(encoding));
+  } else if (data instanceof Uint8Array) {
+    payload = Buffer.from(data);
+  } else {
+    throw new TypeError(
+      `write_atomic: data must be str or bytes, got ${typeof data}`
+    );
+  }
+  let fd = null;
+  let tmp_path = "";
+  for (let attempt = 0; attempt < 32; attempt += 1) {
+    tmp_path = path.join(
+      parent,
+      `.${path.basename(target)}.tmp.${randomBytes(6).toString("hex")}`
+    );
+    try {
+      fd = fs.openSync(tmp_path, "wx", 384);
+      break;
+    } catch (err) {
+      if (err.code === "EEXIST") continue;
+      throw err;
+    }
+  }
+  if (fd === null) {
+    throw new Error("write_atomic: could not create a unique temp file");
+  }
+  let closed = false;
+  try {
+    let offset = 0;
+    while (offset < payload.length) {
+      offset += fs.writeSync(fd, payload, offset, payload.length - offset);
+    }
+    try {
+      fs.fsyncSync(fd);
+    } catch {
+    }
+    fs.closeSync(fd);
+    closed = true;
+    fs.renameSync(tmp_path, target);
+  } catch (err) {
+    if (!closed) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+      }
+    }
+    try {
+      fs.unlinkSync(tmp_path);
+    } catch {
+    }
+    throw err;
+  }
+  _fsync_dir(parent);
+  return target;
+}
+function _fsync_dir(directory) {
+  let dir_fd;
+  try {
+    dir_fd = fs.openSync(directory, fs.constants.O_RDONLY);
+  } catch {
+    return;
+  }
+  try {
+    try {
+      fs.fsyncSync(dir_fd);
+    } catch {
+    }
+  } finally {
+    fs.closeSync(dir_fd);
+  }
+}
+
+// src/scripts/_lib/installed_tools.ts
+import * as fs2 from "node:fs";
+import * as os from "node:os";
+import * as fsPath from "node:path";
+var MANIFEST_ENV = "AGENT_CONFIG_INSTALLED_TOOLS";
+var DEFAULT_MANIFEST_RELATIVE = fsPath.join("agents", "installed-tools.lock");
+var SCHEMA_VERSION = 2;
+var SCHEMA_VERSIONS_SUPPORTED = [1, 2];
+var _VALID_SCOPES = ["global", "project"];
+var DEFAULT_DEPLOY_ROOTS = [
+  ".augment/rules",
+  ".augment/skills",
+  ".augment/commands",
+  ".cursor/rules",
+  ".claude/skills",
+  ".claude/commands",
+  ".clinerules",
+  ".windsurf/rules"
+];
+function expanduser(p) {
+  if (p === "~") {
+    return os.homedir();
+  }
+  if (p.startsWith("~/") || process.platform === "win32" && p.startsWith("~\\")) {
+    return fsPath.join(os.homedir(), p.slice(2));
+  }
+  return p;
+}
+function manifest_path(project_root, env) {
+  const env_map = env ?? process.env;
+  const override = env_map[MANIFEST_ENV];
+  if (override) {
+    return expanduser(override);
+  }
+  return fsPath.join(project_root, DEFAULT_MANIFEST_RELATIVE);
+}
+var _TOP_KEY_RE = /^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*"?([^"\n]*?)"?\s*$/;
+var _LIST_DASH_RE = /^\s*-\s*(.+?)\s*$/;
+var _INDENT_KEY_RE = /^\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*"?([^"\n]*?)"?\s*$/;
+function read_manifest(path4) {
+  let text;
+  try {
+    text = require_read_text(path4);
+  } catch {
+    return null;
+  }
+  const data = _parse_manual(text);
+  return _normalise_v2_shape(data);
+}
+function require_read_text(path4) {
+  return fs2.readFileSync(path4, { encoding: "utf-8" });
+}
+function _normalise_v2_shape(data) {
+  if (data["tools"] === void 0 || data["tools"] === null) {
+    data["tools"] = [];
+  }
+  if (data["deploy_roots"] === void 0 || data["deploy_roots"] === null) {
+    data["deploy_roots"] = [];
+  }
+  const tools = data["tools"];
+  for (const tool of tools) {
+    if (typeof tool !== "object" || tool === null) {
+      continue;
+    }
+    const t = tool;
+    if (t["files"] === void 0 || t["files"] === null) {
+      t["files"] = [];
+    }
+    if (t["merged_keys"] === void 0 || t["merged_keys"] === null) {
+      t["merged_keys"] = [];
+    }
+  }
+  return data;
+}
+function _parse_manual(text) {
+  const data = { tools: [] };
+  const tools = data["tools"];
+  let in_tools = false;
+  let current = null;
+  let skip_until_outdent = false;
+  for (const raw of splitlines(text)) {
+    const stripped = raw.trim();
+    if (!stripped || stripped.startsWith("#")) {
+      continue;
+    }
+    if (stripped === "tools:") {
+      in_tools = true;
+      current = null;
+      skip_until_outdent = false;
+      continue;
+    }
+    if (in_tools) {
+      const indent = raw.length - lstrip_spaces(raw).length;
+      if (skip_until_outdent && indent > 4) {
+        continue;
+      }
+      skip_until_outdent = false;
+      const m = _LIST_DASH_RE.exec(raw);
+      if (m && indent === 2) {
+        const first = m[1];
+        current = {};
+        tools.push(current);
+        const inline = _TOP_KEY_RE.exec(first);
+        if (inline) {
+          current[inline[1]] = inline[2];
+        }
+        continue;
+      }
+      const mk = _INDENT_KEY_RE.exec(raw);
+      if (mk && current !== null && indent === 4) {
+        const key = mk[1];
+        const val = mk[2];
+        if ((key === "files" || key === "merged_keys") && !val) {
+          skip_until_outdent = true;
+          continue;
+        }
+        current[key] = val;
+        continue;
+      }
+    }
+    const m_top = _TOP_KEY_RE.exec(raw);
+    if (m_top) {
+      const key = m_top[1];
+      const value = m_top[2];
+      if (key === "deploy_roots" && !value) {
+        in_tools = false;
+        current = null;
+        skip_until_outdent = true;
+        continue;
+      }
+      if (key === "schema_version") {
+        const parsed = parse_int_strict(value);
+        data[key] = parsed === null ? value : parsed;
+      } else {
+        data[key] = value;
+      }
+      in_tools = false;
+      current = null;
+      skip_until_outdent = false;
+    }
+  }
+  return data;
+}
+function splitlines(text) {
+  const parts = text.split("\n");
+  if (parts.length > 0 && parts[parts.length - 1] === "") {
+    parts.pop();
+  }
+  return parts;
+}
+function lstrip_spaces(s) {
+  let i = 0;
+  while (i < s.length && s[i] === " ") {
+    i += 1;
+  }
+  return s.slice(i);
+}
+function parse_int_strict(value) {
+  if (!/^[+-]?\d+$/.test(value.trim())) {
+    return null;
+  }
+  return Number.parseInt(value, 10);
+}
+function _render(version, tools, options = {}) {
+  const deploy_roots = options.deploy_roots ?? null;
+  const lines = [
+    `schema_version: ${SCHEMA_VERSION}`,
+    `agent_config_version: "${version}"`
+  ];
+  if (deploy_roots && deploy_roots.length > 0) {
+    lines.push("deploy_roots:");
+    for (const root of deploy_roots) {
+      lines.push(`  - ${root}`);
+    }
+  }
+  lines.push("tools:");
+  for (const tool of tools) {
+    lines.push(`  - name: ${String(tool["name"])}`);
+    lines.push(`    scope: ${String(tool["scope"])}`);
+    lines.push(`    bridge_marker: ${String(tool["bridge_marker"])}`);
+    lines.push(`    installed_at: "${String(tool["installed_at"])}"`);
+    const status = tool["status"];
+    if (status) {
+      lines.push(`    status: ${String(status)}`);
+    }
+    let files = tool["files"] ?? [];
+    if (files.length > 0) {
+      files = stable_sort(files, (f) => [String(f["path"])]);
+      lines.push("    files:");
+      for (const entry of files) {
+        lines.push(`      - path: ${String(entry["path"])}`);
+        lines.push(`        kind: ${String(entry["kind"])}`);
+        const sha = entry["sha256"];
+        if (sha === null || sha === void 0) {
+          lines.push("        sha256: null");
+        } else {
+          lines.push(`        sha256: "${String(sha)}"`);
+        }
+      }
+    }
+    let merged = tool["merged_keys"] ?? [];
+    if (merged.length > 0) {
+      merged = stable_sort(merged, (e) => [
+        String(e["file"]),
+        String(e["json_pointer"])
+      ]);
+      lines.push("    merged_keys:");
+      for (const entry of merged) {
+        lines.push(`      - file: ${String(entry["file"])}`);
+        lines.push(`        json_pointer: "${String(entry["json_pointer"])}"`);
+        const vh = entry["value_hash"];
+        if (vh !== null && vh !== void 0) {
+          lines.push(`        value_hash: "${String(vh)}"`);
+        }
+      }
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function stable_sort(items, key) {
+  return items.map((item, index) => ({ item, index, k: key(item) })).sort((a, b) => {
+    const len = Math.max(a.k.length, b.k.length);
+    for (let i = 0; i < len; i += 1) {
+      const av = a.k[i] ?? "";
+      const bv = b.k[i] ?? "";
+      if (av < bv) return -1;
+      if (av > bv) return 1;
+    }
+    return a.index - b.index;
+  }).map((entry) => entry.item);
+}
+function write_manifest(path4, version, tools, options = {}) {
+  const rendered = _render(version, tools, { deploy_roots: options.deploy_roots ?? null });
+  return write_atomic(path4, rendered);
+}
+var ScopeMismatchError = class extends Error {
+  name_;
+  recorded_scope;
+  new_scope;
+  constructor(name, recorded_scope, new_scope) {
+    super(
+      `tool '${name}' is committed as scope=${recorded_scope}; refusing to change it to scope=${new_scope} without --force`
+    );
+    this.name = "ScopeMismatchError";
+    this.name_ = name;
+    this.recorded_scope = recorded_scope;
+    this.new_scope = new_scope;
+  }
+};
+function upsert_tool(existing, options) {
+  const {
+    name,
+    scope,
+    bridge_marker,
+    installed_at = null,
+    force = false,
+    files = null,
+    merged_keys = null
+  } = options;
+  if (!_VALID_SCOPES.includes(scope)) {
+    throw new ValueError(`scope must be one of ${_VALID_SCOPES.join(",")}: '${scope}'`);
+  }
+  const stamp = installed_at || _today();
+  const _build = (prior = null) => {
+    const entry = {
+      name,
+      scope,
+      bridge_marker,
+      installed_at: stamp
+    };
+    if (files !== null) {
+      entry["files"] = [...files];
+    } else if (prior !== null && Array.isArray(prior["files"]) && prior["files"].length > 0) {
+      entry["files"] = [...prior["files"]];
+    }
+    if (merged_keys !== null) {
+      entry["merged_keys"] = [...merged_keys];
+    } else if (prior !== null && Array.isArray(prior["merged_keys"]) && prior["merged_keys"].length > 0) {
+      entry["merged_keys"] = [...prior["merged_keys"]];
+    }
+    return entry;
+  };
+  const result = [];
+  let found = false;
+  for (const entry of existing) {
+    if (entry["name"] === name) {
+      found = true;
+      const recorded = String(entry["scope"] ?? "");
+      if (recorded === scope) {
+        if (files === null && merged_keys === null) {
+          result.push(entry);
+        } else {
+          const refreshed = _build(entry);
+          refreshed["installed_at"] = entry["installed_at"] ?? stamp;
+          result.push(refreshed);
+        }
+        continue;
+      }
+      if (!force) {
+        throw new ScopeMismatchError(name, recorded, scope);
+      }
+      result.push(_build(entry));
+      continue;
+    }
+    result.push(entry);
+  }
+  if (!found) {
+    result.push(_build());
+  }
+  return result;
+}
+var ValueError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValueError";
+  }
+};
+function _today() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+
+// src/install/atomic.ts
+import {
+  closeSync,
+  fsyncSync,
+  mkdirSync,
+  openSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  unlinkSync,
+  writeSync
+} from "node:fs";
+import { dirname, join as join2 } from "node:path";
+function atomicWriteFile(target, data, options = {}) {
+  const mode = options.mode ?? 420;
+  const parent = dirname(target);
+  mkdirSync(parent, { recursive: true });
+  const tmp = join2(parent, `.tmp.${process.pid}.${randSuffix()}`);
+  let fd = null;
+  try {
+    fd = openSync(tmp, "w", mode);
+    const buf = typeof data === "string" ? Buffer.from(data, "utf8") : data;
+    writeSync(fd, buf, 0, buf.length, 0);
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = null;
+    renameSync(tmp, target);
+  } catch (err) {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+function atomicAppendLine(target, line) {
+  let existing = "";
+  try {
+    existing = readFileSync2(target, "utf8");
+  } catch {
+    existing = "";
+  }
+  const sep2 = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+  atomicWriteFile(target, `${existing}${sep2}${line}
+`);
+}
+function randSuffix() {
+  return Math.floor(Math.random() * 281474976710655).toString(16).padStart(12, "0");
+}
+
+// src/scripts/_lib/claude_settings_hooks.ts
+var YAML = __toESM(require_dist(), 1);
+import * as fs3 from "node:fs";
+import * as path2 from "node:path";
+function _yaml_parse(text) {
+  return YAML.parse(text);
+}
+var MANAGED_SIGNATURE = "dispatch:hook --platform claude";
+var CorruptSettingsError = class extends Error {
+  constructor(file, cause) {
+    super(
+      `${file} exists but is not valid JSON (${cause}). Refusing to overwrite a user-owned settings file \u2014 fix or remove it, then re-run.`
+    );
+    this.name = "CorruptSettingsError";
+  }
+};
+var SettingsLockError = class extends Error {
+  constructor(lockPath) {
+    super(
+      `settings lock ${lockPath} is held by another process. Re-run when the concurrent install finishes (stale lock: delete the file).`
+    );
+    this.name = "SettingsLockError";
+  }
+};
+function build_claude_hook_matrix(manifest_path2) {
+  const raw = fs3.readFileSync(manifest_path2, "utf8");
+  const manifest = _yaml_parse(raw) ?? {};
+  const hook_spec = manifest["schema_version"] ?? 1;
+  const platforms = manifest["platforms"] ?? {};
+  const claude_events = (platforms["claude"] ?? {}) || {};
+  const aliasesAll = manifest["native_event_aliases"] ?? {};
+  const aliases = (aliasesAll["claude"] ?? {}) || {};
+  const ac_to_native = {};
+  for (const [native, ac] of Object.entries(aliases)) {
+    ac_to_native[String(ac)] = native;
+  }
+  const matrix = {};
+  for (const [ac_event, concerns] of Object.entries(claude_events)) {
+    if (!concerns || Array.isArray(concerns) && concerns.length === 0) continue;
+    const native = ac_to_native[ac_event];
+    if (native === void 0) continue;
+    matrix[native] = `BIN="$CLAUDE_PROJECT_DIR/agent-config"; [ -x "$BIN" ] || BIN=agent-config; command -v "$BIN" >/dev/null 2>&1 || exit 0; "$BIN" dispatch:hook --platform claude --event ${ac_event} --native-event ${native} --project-dir "$CLAUDE_PROJECT_DIR" --min-version ${String(hook_spec)}`;
+  }
+  return matrix;
+}
+function _is_managed_group(group) {
+  if (typeof group !== "object" || group === null || Array.isArray(group)) return false;
+  const hooks = group.hooks;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some(
+    (h) => typeof h === "object" && h !== null && typeof h.command === "string" && h.command.includes(MANAGED_SIGNATURE)
+  );
+}
+function _read_settings(settings_path) {
+  if (!fs3.existsSync(settings_path)) return {};
+  const raw = fs3.readFileSync(settings_path, "utf8");
+  if (raw.trim() === "") return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new CorruptSettingsError(settings_path, e.message);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new CorruptSettingsError(settings_path, "top level is not an object");
+  }
+  return parsed;
+}
+function _with_lock(settings_path, fn) {
+  const lockPath = settings_path + ".agent-config.lock";
+  fs3.mkdirSync(path2.dirname(lockPath), { recursive: true });
+  let fd;
+  try {
+    fd = fs3.openSync(lockPath, "wx");
+  } catch {
+    throw new SettingsLockError(lockPath);
+  }
+  try {
+    return fn();
+  } finally {
+    fs3.closeSync(fd);
+    fs3.rmSync(lockPath, { force: true });
+  }
+}
+function ensure_managed_hooks(settings_path, matrix) {
+  return _with_lock(settings_path, () => {
+    const settings = _read_settings(settings_path);
+    const before = JSON.stringify(settings);
+    const hooks = (settings["hooks"] ?? {}) || {};
+    const touched = [];
+    for (const [native, command] of Object.entries(matrix)) {
+      const existing = Array.isArray(hooks[native]) ? hooks[native] : [];
+      const user_groups = existing.filter((g) => !_is_managed_group(g));
+      const managed_group = {
+        hooks: [{ type: "command", command }]
+      };
+      const next = [...user_groups, managed_group];
+      if (JSON.stringify(next) !== JSON.stringify(existing)) touched.push(native);
+      hooks[native] = next;
+    }
+    settings["hooks"] = hooks;
+    const after = JSON.stringify(settings);
+    if (after === before) {
+      return { changed: false, events: [] };
+    }
+    atomicWriteFile(settings_path, JSON.stringify(settings, null, 2) + "\n");
+    return { changed: true, events: touched };
+  });
+}
+function remove_managed_hooks(settings_path) {
+  if (!fs3.existsSync(settings_path)) return { changed: false, events: [] };
+  return _with_lock(settings_path, () => {
+    const settings = _read_settings(settings_path);
+    const hooks = settings["hooks"];
+    if (typeof hooks !== "object" || hooks === null || Array.isArray(hooks)) {
+      return { changed: false, events: [] };
+    }
+    const hooksRec = hooks;
+    const touched = [];
+    for (const [native, groups] of Object.entries(hooksRec)) {
+      if (!Array.isArray(groups)) continue;
+      const kept = groups.filter((g) => !_is_managed_group(g));
+      if (kept.length !== groups.length) {
+        touched.push(native);
+        if (kept.length === 0) {
+          delete hooksRec[native];
+        } else {
+          hooksRec[native] = kept;
+        }
+      }
+    }
+    if (touched.length === 0) return { changed: false, events: [] };
+    if (Object.keys(hooksRec).length === 0) {
+      delete settings["hooks"];
+    }
+    atomicWriteFile(settings_path, JSON.stringify(settings, null, 2) + "\n");
+    return { changed: true, events: touched };
+  });
+}
+
+// src/scripts/_lib/global_deploy_inventory.ts
+var global_deploy_inventory_exports = {};
+__export(global_deploy_inventory_exports, {
+  INVENTORY_BASENAME: () => INVENTORY_BASENAME,
+  INVENTORY_ENV: () => INVENTORY_ENV,
+  SCHEMA_VERSION: () => SCHEMA_VERSION2,
+  expected_deploy_files: () => expected_deploy_files,
+  inventory_path: () => inventory_path,
+  is_ancestor: () => is_ancestor,
+  load_inventory: () => load_inventory,
+  reap_stale: () => reap_stale,
+  reap_tagged_orphans: () => reap_tagged_orphans,
+  record_deploy: () => record_deploy,
+  save_inventory: () => save_inventory
+});
+import { randomBytes as randomBytes2 } from "node:crypto";
+import * as fs4 from "node:fs";
+import * as os2 from "node:os";
+import * as path3 from "node:path";
+var SCHEMA_VERSION2 = 1;
+var INVENTORY_BASENAME = "deployed-files.json";
+var INVENTORY_ENV = "AGENT_CONFIG_DEPLOY_INVENTORY";
+function expanduser2(p) {
+  if (p === "~") {
+    return os2.homedir();
+  }
+  if (p.startsWith("~/") || process.platform === "win32" && p.startsWith("~\\")) {
+    return path3.join(os2.homedir(), p.slice(2));
+  }
+  return p;
+}
+function resolve_path(p) {
+  try {
+    return fs4.realpathSync(p);
+  } catch {
+    const abs = path3.resolve(p);
+    const parts = abs.split(path3.sep);
+    for (let i = parts.length; i > 0; i -= 1) {
+      const prefix = parts.slice(0, i).join(path3.sep) || path3.sep;
+      try {
+        const real = fs4.realpathSync(prefix);
+        const rest = parts.slice(i);
+        return rest.length > 0 ? path3.join(real, ...rest) : real;
+      } catch {
+        continue;
+      }
+    }
+    return abs;
+  }
+}
+function path_exists(p) {
+  try {
+    fs4.statSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function inventory_path(env) {
+  const env_map = env ?? process.env;
+  const override = env_map[INVENTORY_ENV];
+  if (override) {
+    return expanduser2(override);
+  }
+  return write_target(INVENTORY_BASENAME, { env: env ?? null });
+}
+function load_inventory(p) {
+  const target = p ?? inventory_path();
+  let data;
+  try {
+    data = JSON.parse(fs4.readFileSync(target, { encoding: "utf-8" }));
+  } catch {
+    return { schema_version: SCHEMA_VERSION2, tools: {} };
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data) || typeof data["tools"] !== "object" || data["tools"] === null || Array.isArray(data["tools"])) {
+    return { schema_version: SCHEMA_VERSION2, tools: {} };
+  }
+  return data;
+}
+function save_inventory(data, p) {
+  const target = p ?? inventory_path();
+  fs4.mkdirSync(path3.dirname(target), { recursive: true });
+  const payload = json_dumps_sorted(data, 2) + "\n";
+  const parent = path3.dirname(target);
+  let fd = null;
+  let tmp_name = "";
+  for (let attempt = 0; attempt < 32; attempt += 1) {
+    tmp_name = path3.join(parent, `${path3.basename(target)}.${randomBytes2(6).toString("hex")}`);
+    try {
+      fd = fs4.openSync(tmp_name, "wx", 384);
+      break;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        continue;
+      }
+      throw err;
+    }
+  }
+  if (fd === null) {
+    throw new Error("save_inventory: could not create a unique temp file");
+  }
+  try {
+    fs4.writeFileSync(fd, payload, { encoding: "utf-8" });
+    fs4.closeSync(fd);
+    fs4.renameSync(tmp_name, target);
+  } catch (err) {
+    try {
+      fs4.closeSync(fd);
+    } catch {
+    }
+    try {
+      fs4.unlinkSync(tmp_name);
+    } catch {
+    }
+    throw err;
+  }
+  return target;
+}
+function json_dumps_sorted(value, indent) {
+  return render_json(value, indent, 0);
+}
+function render_json(value, indent, depth) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "boolean" || typeof value === "number") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "string") {
+    return json_string_ascii(value);
+  }
+  const pad = " ".repeat(indent * (depth + 1));
+  const close_pad = " ".repeat(indent * depth);
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return "[]";
+    }
+    const items = value.map((v) => pad + render_json(v, indent, depth + 1));
+    return "[\n" + items.join(",\n") + "\n" + close_pad + "]";
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    if (keys.length === 0) {
+      return "{}";
+    }
+    const items = keys.map(
+      (k) => pad + json_string_ascii(k) + ": " + render_json(obj[k], indent, depth + 1)
+    );
+    return "{\n" + items.join(",\n") + "\n" + close_pad + "}";
+  }
+  return "null";
+}
+function json_string_ascii(s) {
+  const base = JSON.stringify(s);
+  let out = "";
+  for (let i = 0; i < base.length; i += 1) {
+    const code = base.charCodeAt(i);
+    if (code > 126) {
+      out += "\\u" + code.toString(16).padStart(4, "0");
+    } else {
+      out += base[i];
+    }
+  }
+  return out;
+}
+function expected_deploy_files(src, dest_rel, file_filter = null) {
+  const out = /* @__PURE__ */ new Set();
+  let src_stat;
+  try {
+    src_stat = fs4.statSync(src);
+  } catch {
+    return out;
+  }
+  if (!src_stat.isDirectory()) {
+    if (file_filter !== null && !file_filter(src)) {
+      return out;
+    }
+    out.add(as_posix(dest_rel));
+    return out;
+  }
+  const _walk = (node, prefix) => {
+    const entries = fs4.readdirSync(node).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    for (const name of entries) {
+      const entry = path3.join(node, name);
+      const rel = join_rel(prefix, name);
+      const lst = fs4.lstatSync(entry);
+      if (lst.isDirectory() && !lst.isSymbolicLink()) {
+        _walk(entry, rel);
+        continue;
+      }
+      let resolved_is_dir = false;
+      try {
+        resolved_is_dir = fs4.statSync(entry).isDirectory();
+      } catch {
+        resolved_is_dir = false;
+      }
+      if (resolved_is_dir) {
+        _walk(fs4.realpathSync(entry), rel);
+        continue;
+      }
+      if (file_filter !== null && !file_filter(entry)) {
+        continue;
+      }
+      out.add(as_posix(rel));
+    }
+  };
+  _walk(src, dest_rel);
+  return out;
+}
+function join_rel(prefix, name) {
+  return prefix ? path3.join(prefix, name) : name;
+}
+function as_posix(p) {
+  if (p === "") {
+    return ".";
+  }
+  return p.split(path3.sep).join("/");
+}
+function reap_stale(tool_id, anchor, current_files, inventory, dry_run = false) {
+  const tools = inventory["tools"] ?? {};
+  const entry = tools[tool_id];
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+    return [];
+  }
+  const e = entry;
+  const recorded_anchor = e["anchor"];
+  const prev_files = e["files"];
+  if (typeof recorded_anchor !== "string" || !Array.isArray(prev_files)) {
+    return [];
+  }
+  const anchor_resolved = resolve_path(expanduser2(anchor));
+  if (resolve_path(expanduser2(recorded_anchor)) !== anchor_resolved) {
+    return [];
+  }
+  const deleted = [];
+  const prune_candidates = /* @__PURE__ */ new Set();
+  const orphans = difference(prev_files, current_files);
+  for (const rel of sorted_strings(orphans)) {
+    if (typeof rel !== "string" || !rel || rel.startsWith("/") || rel.startsWith("..")) {
+      continue;
+    }
+    const target = path3.join(anchor_resolved, rel);
+    try {
+      relative_to(resolve_path(path3.dirname(target)), anchor_resolved);
+    } catch {
+      continue;
+    }
+    let lst = null;
+    try {
+      lst = fs4.lstatSync(target);
+    } catch {
+      lst = null;
+    }
+    if (lst && lst.isDirectory() && !lst.isSymbolicLink()) {
+      continue;
+    }
+    if (dry_run) {
+      if (path_exists(target) || lst !== null && lst.isSymbolicLink()) {
+        deleted.push(target);
+      }
+      continue;
+    }
+    try {
+      fs4.unlinkSync(target);
+    } catch {
+      continue;
+    }
+    deleted.push(target);
+    prune_candidates.add(path3.dirname(target));
+  }
+  prune_empty_dirs(prune_candidates, anchor_resolved);
+  return deleted;
+}
+function reap_tagged_orphans(anchor, dest_subs, current_files, package_tag, dry_run = false) {
+  const anchor_resolved = resolve_path(expanduser2(anchor));
+  const deleted = [];
+  const prune_candidates = /* @__PURE__ */ new Set();
+  const needle = `package: ${package_tag}`;
+  for (const dest_sub of dest_subs) {
+    const root = dest_sub ? path3.join(anchor_resolved, dest_sub) : anchor_resolved;
+    let root_stat;
+    try {
+      root_stat = fs4.statSync(root);
+    } catch {
+      continue;
+    }
+    if (!root_stat.isDirectory()) {
+      continue;
+    }
+    for (const md of rglob_md(root)) {
+      let md_lst;
+      try {
+        md_lst = fs4.lstatSync(md);
+      } catch {
+        continue;
+      }
+      if (md_lst.isDirectory()) {
+        continue;
+      }
+      const rel = relative_to_posix(md, anchor_resolved);
+      if (current_files.has(rel)) {
+        continue;
+      }
+      try {
+        relative_to(resolve_path(path3.dirname(md)), anchor_resolved);
+      } catch {
+        continue;
+      }
+      let head;
+      try {
+        head = fs4.readFileSync(md, { encoding: "utf-8" });
+      } catch {
+        continue;
+      }
+      if (!head.startsWith("---")) {
+        continue;
+      }
+      const end = head.indexOf("\n---", 3);
+      const block = head.slice(0, end !== -1 ? end : head.length);
+      const hit = splitlines2(block).some((line) => line.trim() === needle);
+      if (!hit) {
+        continue;
+      }
+      if (dry_run) {
+        deleted.push(md);
+        continue;
+      }
+      try {
+        fs4.unlinkSync(md);
+      } catch {
+        continue;
+      }
+      deleted.push(md);
+      prune_candidates.add(path3.dirname(md));
+    }
+  }
+  prune_empty_dirs(prune_candidates, anchor_resolved);
+  return deleted;
+}
+function record_deploy(tool_id, anchor, current_files, inventory) {
+  if (typeof inventory["tools"] !== "object" || inventory["tools"] === null || Array.isArray(inventory["tools"])) {
+    inventory["tools"] = {};
+  }
+  const tools = inventory["tools"];
+  tools[tool_id] = {
+    anchor: String(anchor),
+    files: sorted_strings([...current_files])
+  };
+  inventory["schema_version"] = SCHEMA_VERSION2;
+  return inventory;
+}
+function prune_empty_dirs(prune_candidates, anchor_resolved) {
+  const ordered = [...prune_candidates].sort(
+    (a, b) => b.split(path3.sep).length - a.split(path3.sep).length
+  );
+  for (const start of ordered) {
+    let node = start;
+    while (node !== anchor_resolved && is_ancestor(anchor_resolved, node)) {
+      try {
+        fs4.rmdirSync(node);
+      } catch {
+        break;
+      }
+      node = path3.dirname(node);
+    }
+  }
+}
+function is_ancestor(anchor, node) {
+  const rel = path3.relative(anchor, node);
+  return rel !== "" && !rel.startsWith("..") && !path3.isAbsolute(rel);
+}
+function relative_to(child, parent) {
+  if (child === parent) {
+    return "";
+  }
+  const rel = path3.relative(parent, child);
+  if (rel.startsWith("..") || path3.isAbsolute(rel)) {
+    throw new Error(`'${child}' is not in the subpath of '${parent}'`);
+  }
+  return rel;
+}
+function relative_to_posix(child, parent) {
+  return path3.relative(parent, child).split(path3.sep).join("/");
+}
+function rglob_md(root) {
+  const out = [];
+  const walk = (dir) => {
+    let names;
+    try {
+      names = fs4.readdirSync(dir).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      const full = path3.join(dir, name);
+      let lst;
+      try {
+        lst = fs4.lstatSync(full);
+      } catch {
+        continue;
+      }
+      if (lst.isDirectory() && !lst.isSymbolicLink()) {
+        walk(full);
+      } else if (name.endsWith(".md")) {
+        out.push(full);
+      }
+    }
+  };
+  walk(root);
+  return out;
+}
+function difference(prev, current) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const item of prev) {
+    if (typeof item === "string" && current.has(item)) {
+      continue;
+    }
+    if (seen.has(item)) {
+      continue;
+    }
+    seen.add(item);
+    out.push(item);
+  }
+  return out;
+}
+function sorted_strings(items) {
+  return items.filter((i) => typeof i === "string").sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+}
+function splitlines2(text) {
+  const parts = text.split("\n");
+  if (parts.length > 0 && parts[parts.length - 1] === "") {
+    parts.pop();
+  }
+  return parts;
+}
+
+export {
+  write_atomic,
+  SCHEMA_VERSIONS_SUPPORTED,
+  DEFAULT_DEPLOY_ROOTS,
+  manifest_path,
+  read_manifest,
+  write_manifest,
+  ScopeMismatchError,
+  upsert_tool,
+  atomicAppendLine,
+  MANAGED_SIGNATURE,
+  build_claude_hook_matrix,
+  ensure_managed_hooks,
+  remove_managed_hooks,
+  load_inventory,
+  save_inventory,
+  expected_deploy_files,
+  reap_stale,
+  reap_tagged_orphans,
+  record_deploy,
+  is_ancestor,
+  global_deploy_inventory_exports
+};