@westbayberry/dg 2.2.0 → 2.3.1

package/dist/standalone/uninstall.mjs

@@ -0,0 +1,2123 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// dist.next/state/store.js
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { randomUUID } from "node:crypto";
+async function readJsonFile(path, fallback) {
+  try {
+    const content = await readFile(path, "utf8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (isNotFound(error)) {
+      return fallback;
+    }
+    if (error instanceof SyntaxError) {
+      throw new JsonStoreError(`Malformed JSON store at ${path}`, error);
+    }
+    throw error;
+  }
+}
+async function writeJsonFileAtomic(path, value) {
+  await mkdir(dirname(path), {
+    recursive: true,
+    mode: 448
+  });
+  const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  const payload = `${JSON.stringify(value, null, 2)}
+`;
+  try {
+    await writeFile(tempPath, payload, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384
+    });
+    await rename(tempPath, path);
+  } catch (error) {
+    await rm(tempPath, {
+      force: true
+    });
+    throw error;
+  }
+}
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+var JsonStoreError;
+var init_store = __esm({
+  "dist.next/state/store.js"() {
+    "use strict";
+    JsonStoreError = class extends Error {
+      cause;
+      constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "JsonStoreError";
+      }
+    };
+  }
+});
+
+// dist.next/state/locks.js
+import { closeSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { mkdir as mkdir2, open, readFile as readFile2, rename as rename2, rm as rm2, stat } from "node:fs/promises";
+import { join } from "node:path";
+function isErrno(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+async function acquireLock(paths, name, options = {}) {
+  assertLockName(name);
+  await mkdir2(paths.locksDir, {
+    recursive: true,
+    mode: 448
+  });
+  const path = join(paths.locksDir, `${name}.lock`);
+  await removeStaleLock(path, options);
+  let handle;
+  try {
+    handle = await open(path, "wx", 384);
+  } catch (error) {
+    if (isErrno(error, "EEXIST")) {
+      throw new LockBusyError(path);
+    }
+    throw error;
+  }
+  const metadata = {
+    pid: process.pid,
+    acquiredAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    await handle.writeFile(`${JSON.stringify(metadata)}
+`, "utf8");
+  } finally {
+    await handle.close();
+  }
+  return {
+    name,
+    path,
+    release: async () => {
+      await rm2(path, {
+        force: true
+      });
+    }
+  };
+}
+function acquireLockSync(paths, name, options = {}) {
+  assertLockName(name);
+  mkdirSync(paths.locksDir, {
+    recursive: true,
+    mode: 448
+  });
+  const path = join(paths.locksDir, `${name}.lock`);
+  removeStaleLockSync(path, options);
+  let fd;
+  try {
+    fd = openSync(path, "wx", 384);
+  } catch (error) {
+    if (isErrno(error, "EEXIST")) {
+      throw new LockBusyError(path);
+    }
+    throw error;
+  }
+  const metadata = {
+    pid: process.pid,
+    acquiredAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    writeFileSync(fd, `${JSON.stringify(metadata)}
+`, "utf8");
+  } finally {
+    closeSync(fd);
+  }
+  return {
+    name,
+    path,
+    release: () => {
+      rmSync(path, {
+        force: true
+      });
+    }
+  };
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !isErrno(error, "ESRCH");
+  }
+}
+function holderStateFromContent(content) {
+  let pid;
+  try {
+    pid = JSON.parse(content).pid;
+  } catch {
+    return "unknown";
+  }
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) {
+    return "unknown";
+  }
+  return isProcessAlive(pid) ? "alive" : "dead";
+}
+async function removeStaleLock(path, options) {
+  let content;
+  try {
+    content = await readFile2(path, "utf8");
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) {
+      return;
+    }
+    content = null;
+  }
+  const holder = content === null ? "unknown" : holderStateFromContent(content);
+  if (holder === "alive") {
+    return;
+  }
+  if (holder === "dead") {
+    await takeoverLock(path);
+    return;
+  }
+  if (!options.staleMs) {
+    return;
+  }
+  const details = await stat(path).catch((error) => {
+    if (isErrno(error, "ENOENT")) {
+      return null;
+    }
+    throw error;
+  });
+  if (!details) {
+    return;
+  }
+  const now = options.now?.getTime() ?? Date.now();
+  if (now - details.mtimeMs < options.staleMs) {
+    return;
+  }
+  await takeoverLock(path);
+}
+function removeStaleLockSync(path, options) {
+  let content;
+  try {
+    content = readFileSync(path, "utf8");
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) {
+      return;
+    }
+    content = null;
+  }
+  const holder = content === null ? "unknown" : holderStateFromContent(content);
+  if (holder === "alive") {
+    return;
+  }
+  if (holder === "dead") {
+    takeoverLockSync(path);
+    return;
+  }
+  if (!options.staleMs) {
+    return;
+  }
+  let details;
+  try {
+    details = statSync(path);
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) {
+      return;
+    }
+    throw error;
+  }
+  const now = options.now?.getTime() ?? Date.now();
+  if (now - details.mtimeMs < options.staleMs) {
+    return;
+  }
+  takeoverLockSync(path);
+}
+async function takeoverLock(path) {
+  const takeoverPath = `${path}.stale-${process.pid}-${++takeoverCounter}`;
+  try {
+    await rename2(path, takeoverPath);
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) {
+      return;
+    }
+    throw error;
+  }
+  await rm2(takeoverPath, {
+    force: true
+  });
+}
+function takeoverLockSync(path) {
+  const takeoverPath = `${path}.stale-${process.pid}-${++takeoverCounter}`;
+  try {
+    renameSync(path, takeoverPath);
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) {
+      return;
+    }
+    throw error;
+  }
+  rmSync(takeoverPath, {
+    force: true
+  });
+}
+function assertLockName(name) {
+  if (!/^[a-z][a-z0-9-]{0,63}$/.test(name)) {
+    throw new Error(`Invalid dg lock name: ${name}`);
+  }
+}
+var CLEANUP_REGISTRY_LOCK, takeoverCounter, LockBusyError;
+var init_locks = __esm({
+  "dist.next/state/locks.js"() {
+    "use strict";
+    CLEANUP_REGISTRY_LOCK = "cleanup-registry";
+    takeoverCounter = 0;
+    LockBusyError = class extends Error {
+      path;
+      constructor(path) {
+        super(`dg lock is already held: ${path}`);
+        this.path = path;
+        this.name = "LockBusyError";
+      }
+    };
+  }
+});
+
+// dist.next/state/cleanup-registry.js
+import { renameSync as renameSync2 } from "node:fs";
+import { rename as rename3 } from "node:fs/promises";
+function emptyCleanupRegistry() {
+  return {
+    version: 1,
+    entries: []
+  };
+}
+async function loadCleanupRegistry(paths, options = {}) {
+  let parsed;
+  try {
+    parsed = await readJsonFile(paths.cleanupRegistryPath, emptyCleanupRegistry());
+  } catch (error) {
+    if (!(error instanceof JsonStoreError)) {
+      throw error;
+    }
+    parsed = void 0;
+  }
+  if (isCleanupRegistry(parsed)) {
+    return {
+      registry: parsed
+    };
+  }
+  const preserved = await preserveCorruptRegistry(paths, options);
+  return {
+    registry: emptyCleanupRegistry(),
+    ...preserved ? { corruptPreservedPath: preserved } : {}
+  };
+}
+async function readCleanupRegistry(paths) {
+  return (await loadCleanupRegistry(paths)).registry;
+}
+async function writeCleanupRegistry(paths, registry) {
+  await writeJsonFileAtomic(paths.cleanupRegistryPath, registry);
+}
+async function recordCleanupEntry(paths, entry) {
+  const lock = await acquireLock(paths, CLEANUP_REGISTRY_LOCK);
+  try {
+    const { registry } = await loadCleanupRegistry(paths);
+    const nextEntry = {
+      ...entry,
+      installedAt: entry.installedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      owner: "dg"
+    };
+    const entries = registry.entries.filter((candidate) => !sameRegistryTarget(candidate, nextEntry));
+    const next = {
+      version: 1,
+      entries: [...entries, nextEntry]
+    };
+    await writeCleanupRegistry(paths, next);
+    return next;
+  } finally {
+    await lock.release();
+  }
+}
+async function removeCleanupEntry(paths, target) {
+  const lock = await acquireLock(paths, CLEANUP_REGISTRY_LOCK);
+  try {
+    const { registry } = await loadCleanupRegistry(paths);
+    const next = {
+      version: 1,
+      entries: registry.entries.filter((candidate) => !sameRegistryTarget(candidate, target))
+    };
+    await writeCleanupRegistry(paths, next);
+    return next;
+  } finally {
+    await lock.release();
+  }
+}
+async function preserveCorruptRegistry(paths, options) {
+  const preservedPath = `${paths.cleanupRegistryPath}.corrupt-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+  try {
+    await rename3(paths.cleanupRegistryPath, preservedPath);
+  } catch (error) {
+    if (isEnoent(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+  const stderr = options.stderr ?? process.stderr;
+  stderr.write(`dg: cleanup registry at ${paths.cleanupRegistryPath} was unreadable; preserved it at ${preservedPath}. Previously registered entries may need 'dg doctor'.
+`);
+  return preservedPath;
+}
+function preserveCorruptCleanupRegistrySync(paths, options = {}) {
+  const preservedPath = `${paths.cleanupRegistryPath}.corrupt-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+  try {
+    renameSync2(paths.cleanupRegistryPath, preservedPath);
+  } catch {
+    return void 0;
+  }
+  const stderr = options.stderr ?? process.stderr;
+  stderr.write(`dg: cleanup registry at ${paths.cleanupRegistryPath} was unreadable; preserved it at ${preservedPath}. Previously registered entries may need 'dg doctor'.
+`);
+  return preservedPath;
+}
+function isCleanupRegistry(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && value.version === 1 && Array.isArray(value.entries);
+}
+function isEnoent(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function sameRegistryTarget(left, right) {
+  return left.kind === right.kind && left.path === right.path && left.sentinel === right.sentinel;
+}
+var init_cleanup_registry = __esm({
+  "dist.next/state/cleanup-registry.js"() {
+    "use strict";
+    init_store();
+    init_locks();
+  }
+});
+
+// dist.next/util/json-file.js
+var init_json_file = __esm({
+  "dist.next/util/json-file.js"() {
+    "use strict";
+  }
+});
+
+// dist.next/state/paths.js
+import { homedir } from "node:os";
+import { isAbsolute, join as join2 } from "node:path";
+function resolveDgPaths(env = process.env) {
+  const homeDir = env.HOME && isAbsolute(env.HOME) ? env.HOME : homedir();
+  const fallbackRoot = join2(homeDir, ".dg");
+  const configDir = xdgPath(env.XDG_CONFIG_HOME, fallbackRoot);
+  const stateDir = xdgPath(env.XDG_STATE_HOME, join2(fallbackRoot, "state"));
+  const cacheDir = xdgPath(env.XDG_CACHE_HOME, join2(fallbackRoot, "cache"));
+  return {
+    homeDir,
+    configDir,
+    stateDir,
+    cacheDir,
+    sessionsDir: join2(stateDir, "sessions"),
+    cleanupRegistryPath: join2(stateDir, "cleanup-registry.json"),
+    locksDir: join2(stateDir, "locks")
+  };
+}
+function xdgPath(value, fallback) {
+  if (!value || !isAbsolute(value)) {
+    return fallback;
+  }
+  return join2(value, "dg");
+}
+var init_paths = __esm({
+  "dist.next/state/paths.js"() {
+    "use strict";
+  }
+});
+
+// dist.next/state/cooldown-held.js
+var UNKNOWN_ELIGIBILITY_TTL_MS;
+var init_cooldown_held = __esm({
+  "dist.next/state/cooldown-held.js"() {
+    "use strict";
+    init_json_file();
+    init_paths();
+    UNKNOWN_ELIGIBILITY_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+  }
+});
+
+// dist.next/state/sessions.js
+import { mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, rmSync as rmSync2, statSync as statSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+function findStaleSessionsSync(paths, options) {
+  const now = options.now?.getTime() ?? Date.now();
+  let entries;
+  try {
+    entries = readdirSync(paths.sessionsDir, {
+      withFileTypes: true
+    });
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return {
+        stale: []
+      };
+    }
+    throw error;
+  }
+  const stale = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !isValidSessionId(entry.name)) {
+      continue;
+    }
+    const dir = join3(paths.sessionsDir, entry.name);
+    let details;
+    try {
+      details = statSync2(dir);
+    } catch (error) {
+      if (isEnoent2(error)) {
+        continue;
+      }
+      throw error;
+    }
+    if (now - details.mtimeMs >= options.olderThanMs) {
+      stale.push(entry.name);
+    }
+  }
+  return {
+    stale
+  };
+}
+function sweepStaleSessionsSync(paths, options) {
+  const report = findStaleSessionsSync(paths, options);
+  for (const id of report.stale) {
+    rmSync2(join3(paths.sessionsDir, id), {
+      force: true,
+      recursive: true
+    });
+  }
+  return {
+    removed: report.stale
+  };
+}
+function isValidSessionId(id) {
+  return /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(id);
+}
+function isEnoent2(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+var DEAD_SESSION_TTL_MS;
+var init_sessions = __esm({
+  "dist.next/state/sessions.js"() {
+    "use strict";
+    init_locks();
+    init_store();
+    DEAD_SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
+  }
+});
+
+// dist.next/state/index.js
+var init_state = __esm({
+  "dist.next/state/index.js"() {
+    "use strict";
+    init_cleanup_registry();
+    init_cooldown_held();
+    init_locks();
+    init_paths();
+    init_sessions();
+    init_store();
+  }
+});
+
+// dist.next/config/settings.js
+var CONFIG_KEYS, DEFAULT_CONFIG;
+var init_settings = __esm({
+  "dist.next/config/settings.js"() {
+    "use strict";
+    init_json_file();
+    init_state();
+    CONFIG_KEYS = Object.freeze([
+      "api.baseUrl",
+      "org.id",
+      "policy.mode",
+      "policy.trustProjectAllowlists",
+      "policy.allowForceOverride",
+      "policy.scriptHardening",
+      "policy.shimFailClosed",
+      "policy.strictEgress",
+      "scriptGate.mode",
+      "scriptGate.observe",
+      "gitHook.onWarn",
+      "gitHook.onIncomplete",
+      "cooldown.age",
+      "cooldown.npm.age",
+      "cooldown.pypi.age",
+      "cooldown.cargo.age",
+      "cooldown.onUnknown",
+      "cooldown.exempt",
+      "audit.upload"
+    ]);
+    DEFAULT_CONFIG = Object.freeze({
+      version: 1,
+      api: {
+        baseUrl: "https://api.westbayberry.com"
+      },
+      org: {
+        id: ""
+      },
+      policy: {
+        mode: "block",
+        trustProjectAllowlists: false,
+        allowForceOverride: true,
+        scriptHardening: false,
+        shimFailClosed: false,
+        strictEgress: false
+      },
+      scriptGate: {
+        mode: "observe",
+        observe: false
+      },
+      gitHook: {
+        onWarn: "prompt",
+        onIncomplete: "allow"
+      },
+      cooldown: {
+        age: "24h",
+        npmAge: "",
+        pypiAge: "",
+        cargoAge: "",
+        onUnknown: "block",
+        exempt: ""
+      },
+      audit: {
+        upload: false
+      }
+    });
+  }
+});
+
+// dist.next/launcher/resolve-real-binary.js
+var init_resolve_real_binary = __esm({
+  "dist.next/launcher/resolve-real-binary.js"() {
+    "use strict";
+    init_state();
+  }
+});
+
+// dist.next/launcher/spawn-invocation.js
+var init_spawn_invocation = __esm({
+  "dist.next/launcher/spawn-invocation.js"() {
+    "use strict";
+  }
+});
+
+// dist.next/service/trust-store.js
+var init_trust_store = __esm({
+  "dist.next/service/trust-store.js"() {
+    "use strict";
+    init_json_file();
+  }
+});
+
+// dist.next/service/trust-refresh.js
+var init_trust_refresh = __esm({
+  "dist.next/service/trust-refresh.js"() {
+    "use strict";
+    init_trust_store();
+  }
+});
+
+// dist.next/service/state.js
+var SERVICE_LOCK_STALE_MS;
+var init_state2 = __esm({
+  "dist.next/service/state.js"() {
+    "use strict";
+    init_settings();
+    init_trust_store();
+    init_trust_refresh();
+    init_state();
+    SERVICE_LOCK_STALE_MS = 30 * 60 * 1e3;
+  }
+});
+
+// dist.next/setup/uninstall-standalone.js
+import { rmSync as rmSync5 } from "node:fs";
+import { join as join11 } from "node:path";
+
+// dist.next/setup/plan.js
+import { accessSync, constants, copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync4, realpathSync, renameSync as renameSync4, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename, delimiter, dirname as dirname3, join as join10, resolve, sep } from "node:path";
+import { randomBytes as randomBytes2 } from "node:crypto";
+
+// dist.next/agents/registry.js
+init_state();
+
+// dist.next/agents/claude-code.js
+import { join as join4 } from "node:path";
+
+// dist.next/auth/store.js
+init_settings();
+init_state();
+
+// dist.next/api/analyze.js
+init_settings();
+
+// dist.next/security/sanitize.js
+import { stripVTControlCharacters } from "node:util";
+var CTRL_ALL = /[\x00-\x1F\x7F-\x9F]/g;
+function sanitizeLine(s) {
+  return stripVTControlCharacters(s).replace(/[\r\n]+/g, " ").replace(CTRL_ALL, "");
+}
+
+// dist.next/api/analyze.js
+init_state();
+var BATCH_CONCURRENCY = Math.max(1, Number(process.env.DG_ANALYZE_CONCURRENCY) || 4);
+
+// dist.next/setup/optional-support.js
+var OPTIONAL_SUPPORT_GATES = Object.freeze([
+  {
+    id: "windows",
+    label: "Windows support",
+    kind: "platform",
+    status: "unclaimed",
+    message: "Windows support is gated in this release; use dg prefix mode from a supported POSIX shell or run 'dg --help' for supported commands"
+  },
+  {
+    id: "python-hook",
+    label: "Python .pth hook",
+    kind: "hook",
+    status: "unclaimed",
+    message: "Python .pth hook support is gated in this release; use 'dg pip ...', 'dg pipx ...', 'dg uv ...', or 'dg uvx ...' prefix mode instead"
+  },
+  {
+    id: "bun",
+    label: "Bun and bunx",
+    kind: "package-manager",
+    status: "unclaimed",
+    standaloneCommand: true,
+    message: "Bun support is gated in this release; use 'dg npm ...', 'dg pnpm ...', or 'dg yarn ...' for supported JavaScript installs"
+  },
+  {
+    id: "yarn-berry",
+    label: "Yarn Berry",
+    kind: "package-manager",
+    status: "unclaimed",
+    standaloneCommand: false,
+    message: "Yarn Berry support is gated in this release; use Yarn classic through 'dg yarn ...' or another supported prefix manager"
+  },
+  {
+    id: "conda",
+    label: "Conda",
+    kind: "package-manager",
+    status: "unclaimed",
+    standaloneCommand: true,
+    message: "Conda support is gated in this release; use 'dg pip ...' or 'dg uv ...' for supported Python package installs"
+  },
+  {
+    id: "mamba",
+    label: "Mamba",
+    kind: "package-manager",
+    status: "unclaimed",
+    standaloneCommand: true,
+    message: "Mamba support is gated in this release; use 'dg pip ...' or 'dg uv ...' for supported Python package installs"
+  }
+]);
+function optionalPackageManagerNames() {
+  return OPTIONAL_SUPPORT_GATES.filter((gate) => gate.kind === "package-manager" && gate.standaloneCommand === true).map((gate) => gate.id);
+}
+
+// dist.next/launcher/classify.js
+var gatedManagers = optionalPackageManagerNames();
+
+// dist.next/verify/preflight.js
+init_settings();
+
+// dist.next/audit/events.js
+init_state();
+
+// dist.next/policy/evaluate.js
+init_settings();
+
+// dist.next/verify/preflight.js
+var MAX_LOCKFILE_BYTES = 64 * 1024 * 1024;
+
+// dist.next/policy/cooldown.js
+init_settings();
+
+// dist.next/util/external-tool.js
+init_resolve_real_binary();
+init_spawn_invocation();
+
+// dist.next/util/git.js
+var DEFAULT_MAX_BUFFER = 256 * 1024 * 1024;
+
+// dist.next/project/dgfile.js
+init_json_file();
+init_state();
+
+// dist.next/project/override-trust.js
+init_state();
+
+// dist.next/launcher/install-preflight.js
+init_settings();
+
+// dist.next/decisions/remember-prompt.js
+init_settings();
+
+// dist.next/launcher/install-preflight.js
+init_spawn_invocation();
+
+// dist.next/launcher/manifest-screen.js
+var MAX_MANIFEST_BYTES = 4 * 1024 * 1024;
+
+// dist.next/launcher/agent-check.js
+function formatScreenedNote(screened) {
+  if (screened.length === 0) {
+    return "";
+  }
+  const items = screened.map((pkg) => `${pkg.name}@${pkg.version} (${pkg.ecosystem})`).join(", ");
+  const noun = screened.length === 1 ? "package" : "packages";
+  return sanitizeLine(`dg pre-screened the requested ${noun}: ${items} \u2014 no known issues (dependencies are screened at install time)`);
+}
+
+// dist.next/agents/persistence.js
+init_state();
+import { existsSync, lstatSync, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync3, rmSync as rmSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dirname as dirname2 } from "node:path";
+import { randomBytes } from "node:crypto";
+var LEGACY_AGENT_HOOK_SENTINEL = "dg-agent-hook-v1";
+function agentHookSentinel(agent) {
+  return `${LEGACY_AGENT_HOOK_SENTINEL}:${agent}`;
+}
+var AgentHookError = class extends Error {
+};
+function dirExists(path) {
+  try {
+    return lstatSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function assertSafeNode(path, role) {
+  let stats;
+  try {
+    stats = lstatSync(path);
+  } catch {
+    return;
+  }
+  if (stats.isSymbolicLink()) {
+    throw new AgentHookError(`${path} is a symlink; refusing to write through it. Edit the link target directly, then retry.`);
+  }
+  if (typeof process.getuid === "function" && stats.uid !== process.getuid()) {
+    throw new AgentHookError(`${path} (${role}) is owned by another user; refusing to write to it.`);
+  }
+  if ((stats.mode & 2) !== 0) {
+    throw new AgentHookError(`${path} (${role}) is world-writable; refusing to write to it. Tighten its permissions, then retry.`);
+  }
+}
+function assertSafeWriteTarget(path) {
+  assertSafeNode(dirname2(path), "directory");
+  assertSafeNode(path, "file");
+}
+function readSettings(path) {
+  if (!existsSync(path)) {
+    return { settings: {}, existed: false };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync3(path, "utf8"));
+  } catch {
+    throw new AgentHookError(`${path} is not valid JSON; refusing to modify it. Fix or remove it, then retry.`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new AgentHookError(`${path} is not a JSON object; refusing to modify it.`);
+  }
+  return { settings: parsed, existed: true };
+}
+function writeSettingsAtomic(path, settings) {
+  mkdirSync3(dirname2(path), { recursive: true });
+  assertSafeWriteTarget(path);
+  const tmp = `${path}.dg-${randomBytes(6).toString("hex")}.tmp`;
+  writeFileSync2(tmp, `${JSON.stringify(settings, null, 2)}
+`, { mode: 384, flag: "wx" });
+  try {
+    renameSync3(tmp, path);
+  } catch (error) {
+    rmSync3(tmp, { force: true });
+    throw error;
+  }
+}
+async function wasCreatedByDg(ctx) {
+  try {
+    const reg = await readCleanupRegistry(ctx.paths);
+    return reg.entries.some((e) => e.kind === "agent-hook" && e.path === ctx.settingsPath && e.original === "dg-created");
+  } catch {
+    return false;
+  }
+}
+async function recordHookEntry(ctx, legacySentinels, created) {
+  for (const sentinel of legacySentinels) {
+    await removeCleanupEntry(ctx.paths, { kind: "agent-hook", path: ctx.settingsPath, sentinel });
+  }
+  const dgCreated = created || await wasCreatedByDg(ctx);
+  await recordCleanupEntry(ctx.paths, {
+    kind: "agent-hook",
+    path: ctx.settingsPath,
+    mode: "mode1",
+    sentinel: agentHookSentinel(ctx.agent),
+    ...dgCreated ? { original: "dg-created" } : {}
+  });
+}
+async function removeHookEntries(ctx, legacySentinels) {
+  await removeCleanupEntry(ctx.paths, { kind: "agent-hook", path: ctx.settingsPath, sentinel: agentHookSentinel(ctx.agent) });
+  for (const sentinel of legacySentinels) {
+    await removeCleanupEntry(ctx.paths, { kind: "agent-hook", path: ctx.settingsPath, sentinel });
+  }
+}
+function findHookCommand(node, signature) {
+  if (typeof node === "string") {
+    return node.includes(signature) ? node : null;
+  }
+  if (Array.isArray(node)) {
+    for (const value of node) {
+      const found = findHookCommand(value, signature);
+      if (found) {
+        return found;
+      }
+    }
+    return null;
+  }
+  if (node && typeof node === "object") {
+    for (const value of Object.values(node)) {
+      const found = findHookCommand(value, signature);
+      if (found) {
+        return found;
+      }
+    }
+    return null;
+  }
+  return null;
+}
+function hookResolvesCheck(settings, agent) {
+  const command = findHookCommand(settings, `hook-exec ${agent}`);
+  if (!command) {
+    return null;
+  }
+  const head = command.split(/\s+hook-exec\s+/)[0] ?? command;
+  const broken = head.split(/\s+/).filter((token) => token.startsWith("/")).filter((token) => !existsSync(token));
+  return {
+    name: "hook command resolves",
+    ok: broken.length === 0,
+    detail: broken.length === 0 ? "dg path in the hook resolves" : `hook references a missing path (${broken.join(", ")}); re-run 'dg agents on ${agent}'`
+  };
+}
+function mergedJsonHook(config) {
+  const legacy = config.legacySentinels ?? [];
+  return {
+    isInstalledCheckName: config.checkName,
+    async apply(ctx) {
+      const { settings, existed } = readSettings(ctx.settingsPath);
+      writeSettingsAtomic(ctx.settingsPath, config.insert(settings, ctx.dgCommand));
+      await recordHookEntry(ctx, legacy, !existed);
+      return { created: !existed };
+    },
+    async remove(ctx) {
+      let removed = false;
+      if (existsSync(ctx.settingsPath)) {
+        let settings = null;
+        try {
+          settings = readSettings(ctx.settingsPath).settings;
+        } catch {
+          settings = null;
+        }
+        if (settings) {
+          const result = config.remove(settings);
+          if (result.changed) {
+            removed = true;
+            if (result.empty && await wasCreatedByDg(ctx)) {
+              rmSync3(ctx.settingsPath, { force: true });
+            } else {
+              writeSettingsAtomic(ctx.settingsPath, result.settings);
+            }
+          }
+        }
+      }
+      await removeHookEntries(ctx, legacy);
+      return { removed };
+    },
+    verify(ctx) {
+      const checks = [];
+      const present = existsSync(ctx.settingsPath);
+      checks.push({ name: "settings file", ok: present, detail: present ? ctx.settingsPath : `${ctx.settingsPath} (absent)` });
+      if (!present) {
+        return checks;
+      }
+      let settings = null;
+      let installed = false;
+      try {
+        settings = readSettings(ctx.settingsPath).settings;
+        installed = config.isInstalled(settings);
+      } catch {
+        installed = false;
+      }
+      checks.push({ name: config.checkName, ok: installed, detail: installed ? "installed" : "not installed" });
+      if (installed && settings) {
+        const resolves = hookResolvesCheck(settings, ctx.agent);
+        if (resolves) {
+          checks.push(resolves);
+        }
+      }
+      return checks;
+    },
+    reverseEntry(entry, removed, missing, warnings) {
+      if (!existsSync(entry.path)) {
+        missing.push(entry.path);
+        return;
+      }
+      let settings;
+      try {
+        const parsed = JSON.parse(readFileSync3(entry.path, "utf8"));
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+          warnings.push(`${entry.path}: not a JSON object; left untouched`);
+          return;
+        }
+        settings = parsed;
+      } catch {
+        warnings.push(`${entry.path}: unreadable JSON; left untouched`);
+        return;
+      }
+      const result = config.remove(settings);
+      if (!result.changed) {
+        missing.push(entry.path);
+        return;
+      }
+      if (result.empty && entry.original === "dg-created") {
+        rmSync3(entry.path, { force: true });
+      } else {
+        try {
+          writeSettingsAtomic(entry.path, result.settings);
+        } catch (error) {
+          warnings.push(`${entry.path}: ${error instanceof Error ? error.message : "could not rewrite settings"}`);
+          return;
+        }
+      }
+      removed.push(entry.path);
+    }
+  };
+}
+function ownedJsonHook(config) {
+  const sentinel = agentHookSentinel(config.agent);
+  const ownsFile = (path) => {
+    try {
+      const parsed = JSON.parse(readFileSync3(path, "utf8"));
+      return parsed?.dgSentinel === sentinel;
+    } catch {
+      return false;
+    }
+  };
+  return {
+    isInstalledCheckName: config.checkName,
+    async apply(ctx) {
+      const existed = existsSync(ctx.settingsPath);
+      if (existed && !ownsFile(ctx.settingsPath)) {
+        throw new AgentHookError(`${ctx.settingsPath} already exists and was not written by dg; refusing to overwrite it. Merge the output of 'dg agents --print ${ctx.agent}' yourself, or remove the file and retry.`);
+      }
+      writeSettingsAtomic(ctx.settingsPath, { dgSentinel: sentinel, ...config.render(ctx.dgCommand) });
+      await recordHookEntry(ctx, [], !existed);
+      return { created: !existed };
+    },
+    async remove(ctx) {
+      let removed = false;
+      if (existsSync(ctx.settingsPath) && ownsFile(ctx.settingsPath)) {
+        rmSync3(ctx.settingsPath, { force: true });
+        removed = true;
+      }
+      await removeHookEntries(ctx, []);
+      return { removed };
+    },
+    verify(ctx) {
+      const checks = [];
+      const present = existsSync(ctx.settingsPath);
+      checks.push({ name: "hook file", ok: present, detail: present ? ctx.settingsPath : `${ctx.settingsPath} (absent)` });
+      if (!present) {
+        return checks;
+      }
+      const installed = ownsFile(ctx.settingsPath);
+      checks.push({ name: config.checkName, ok: installed, detail: installed ? "installed" : "present but not dg-owned" });
+      if (installed) {
+        try {
+          const settings = JSON.parse(readFileSync3(ctx.settingsPath, "utf8"));
+          const resolves = hookResolvesCheck(settings, ctx.agent);
+          if (resolves) {
+            checks.push(resolves);
+          }
+        } catch {
+        }
+      }
+      return checks;
+    },
+    reverseEntry(entry, removed, missing, warnings) {
+      if (!existsSync(entry.path)) {
+        missing.push(entry.path);
+        return;
+      }
+      if (!ownsFile(entry.path)) {
+        warnings.push(`${entry.path}: not dg-owned; left untouched`);
+        return;
+      }
+      rmSync3(entry.path, { force: true });
+      removed.push(entry.path);
+    }
+  };
+}
+function defaultExecVersion(binary, args) {
+  try {
+    const result = spawnSync(binary, [...args], { encoding: "utf8", timeout: 1500 });
+    if (result.status !== 0 || typeof result.stdout !== "string") {
+      return null;
+    }
+    return result.stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function parseSemver(text) {
+  const match = /(\d+)\.(\d+)(?:\.(\d+))?/.exec(text);
+  if (!match) {
+    return null;
+  }
+  return [Number(match[1]), Number(match[2]), Number(match[3] ?? "0")];
+}
+function probeMinCliVersion(binary, minVersion, label, deps) {
+  const execVersion = deps?.execVersion ?? defaultExecVersion;
+  const output = execVersion(binary, ["--version"]);
+  if (!output) {
+    return { supported: false, detail: `cannot confirm ${label} >= ${minVersion} (the ${binary} CLI did not report a version)` };
+  }
+  const found = parseSemver(output);
+  const wanted = parseSemver(minVersion);
+  if (!found || !wanted) {
+    return { supported: false, detail: `cannot confirm ${label} >= ${minVersion} (unrecognized version '${output}')` };
+  }
+  for (let index = 0; index < 3; index += 1) {
+    if ((found[index] ?? 0) > (wanted[index] ?? 0)) {
+      break;
+    }
+    if ((found[index] ?? 0) < (wanted[index] ?? 0)) {
+      return { supported: false, detail: `${label} ${found.join(".")} is older than ${minVersion}, which added the hook dg needs` };
+    }
+  }
+  return { supported: true, detail: `${label} ${found.join(".")}` };
+}
+
+// dist.next/agents/claude-code.js
+var SIGNATURE = "hook-exec claude-code";
+function configPath(home) {
+  return join4(home, ".claude", "settings.json");
+}
+function isDgGroup(group) {
+  if (typeof group !== "object" || group === null) {
+    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(SIGNATURE));
+}
+function dgGroup(dgCommand) {
+  return { matcher: "Bash", hooks: [{ type: "command", command: dgCommand, timeout: 60 }] };
+}
+function insertDgHook(settings, dgCommand) {
+  const next = { ...settings };
+  const hooks = typeof next.hooks === "object" && next.hooks !== null ? { ...next.hooks } : {};
+  const pre = Array.isArray(hooks.PreToolUse) ? hooks.PreToolUse : [];
+  hooks.PreToolUse = [...pre.filter((g) => !isDgGroup(g)), dgGroup(dgCommand)];
+  next.hooks = hooks;
+  return next;
+}
+function removeDgHook(settings) {
+  const next = { ...settings };
+  if (typeof next.hooks !== "object" || next.hooks === null) {
+    return { settings: next, changed: false, empty: Object.keys(next).length === 0 };
+  }
+  const hooks = { ...next.hooks };
+  const pre = Array.isArray(hooks.PreToolUse) ? hooks.PreToolUse : [];
+  const withoutDg = pre.filter((g) => !isDgGroup(g));
+  const changed = withoutDg.length !== pre.length;
+  if (withoutDg.length > 0) {
+    hooks.PreToolUse = withoutDg;
+  } else {
+    delete hooks.PreToolUse;
+  }
+  if (Object.keys(hooks).length > 0) {
+    next.hooks = hooks;
+  } else {
+    delete next.hooks;
+  }
+  return { settings: next, changed, empty: Object.keys(next).length === 0 };
+}
+function hasDgHook(settings) {
+  const hooks = settings.hooks?.PreToolUse;
+  return Array.isArray(hooks) && hooks.some((g) => isDgGroup(g));
+}
+function parseInput(stdin) {
+  try {
+    const obj = JSON.parse(stdin);
+    const command = obj.tool_input?.command;
+    if (typeof command !== "string") {
+      return null;
+    }
+    return typeof obj.cwd === "string" ? { command, cwd: obj.cwd } : { command };
+  } catch {
+    return null;
+  }
+}
+function emitDecision(verdict) {
+  if (verdict.decision === "allow") {
+    const note = verdict.screened ? formatScreenedNote(verdict.screened) : "";
+    if (note) {
+      return {
+        stdout: JSON.stringify({
+          hookSpecificOutput: { hookEventName: "PreToolUse", additionalContext: note }
+        }),
+        exitCode: 0
+      };
+    }
+    return { stdout: "{}", exitCode: 0 };
+  }
+  return {
+    stdout: JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: verdict.decision,
+        ...verdict.reason ? { permissionDecisionReason: verdict.reason } : {}
+      }
+    }),
+    exitCode: 0
+  };
+}
+var claudeCodeIntegration = {
+  id: "claude-code",
+  label: "Claude Code",
+  kind: "merged-json",
+  maturity: "verified",
+  minVersion: null,
+  configPath,
+  detect: (home) => dirExists(join4(home, ".claude")),
+  probeHookSupport: (home) => ({
+    supported: true,
+    detail: dirExists(join4(home, ".claude")) ? "Claude Code settings directory found" : "settings hooks are supported by every Claude Code version; ~/.claude will be created"
+  }),
+  parseInput,
+  emitDecision,
+  ...mergedJsonHook({
+    checkName: "dg PreToolUse hook",
+    legacySentinels: [LEGACY_AGENT_HOOK_SENTINEL],
+    insert: insertDgHook,
+    remove: removeDgHook,
+    isInstalled: hasDgHook
+  })
+};
+
+// dist.next/agents/codex.js
+import { join as join5 } from "node:path";
+function configPath2(home) {
+  return join5(home, ".codex", "hooks.json");
+}
+function parseInput2(stdin) {
+  try {
+    const obj = JSON.parse(stdin);
+    const command = obj.tool_input?.command;
+    if (typeof command !== "string") {
+      return null;
+    }
+    return typeof obj.cwd === "string" ? { command, cwd: obj.cwd } : { command };
+  } catch {
+    return null;
+  }
+}
+function emitDecision2(verdict) {
+  if (verdict.decision === "allow") {
+    return { stdout: "", exitCode: 0 };
+  }
+  const reason = verdict.reason ?? "Dependency Guardian firewall";
+  const suffix = verdict.decision === "ask" ? " (dg flagged this for human review \u2014 not auto-approved)" : "";
+  return {
+    stdout: JSON.stringify({ decision: "block", reason: `${reason}${suffix}` }),
+    exitCode: 0
+  };
+}
+function renderHookFile(dgCommand) {
+  return {
+    hooks: {
+      PreToolUse: [
+        {
+          matcher: "Bash",
+          hooks: [{ type: "command", command: dgCommand, timeout: 60, statusMessage: "Dependency Guardian install check" }]
+        }
+      ]
+    }
+  };
+}
+function probeHookSupport(home, deps) {
+  if (!dirExists(join5(home, ".codex"))) {
+    return { supported: false, detail: "~/.codex not found (is Codex CLI installed?)" };
+  }
+  return probeMinCliVersion("codex", "0.124.0", "Codex CLI", deps);
+}
+var codexIntegration = {
+  id: "codex",
+  label: "Codex CLI",
+  kind: "owned-json",
+  maturity: "verified",
+  minVersion: "0.124.0",
+  postInstallNote: "Codex asks to trust new hooks: approve the dg hook when Codex prompts on its next start.",
+  configPath: configPath2,
+  detect: (home) => dirExists(join5(home, ".codex")),
+  probeHookSupport,
+  parseInput: parseInput2,
+  emitDecision: emitDecision2,
+  ...ownedJsonHook({
+    agent: "codex",
+    checkName: "dg PreToolUse hook",
+    render: renderHookFile
+  })
+};
+
+// dist.next/agents/copilot-cli.js
+import { join as join6 } from "node:path";
+var SIGNATURE2 = "hook-exec copilot-cli";
+function configPath3(home) {
+  return join6(home, ".copilot", "settings.json");
+}
+function isDgEntry(entry) {
+  return typeof entry === "object" && entry !== null && typeof entry.command === "string" && entry.command.includes(SIGNATURE2);
+}
+function dgEntry(dgCommand) {
+  return { type: "command", matcher: "bash", command: dgCommand, timeoutSec: 60 };
+}
+function insertDgHook2(settings, dgCommand) {
+  const next = { ...settings };
+  const hooks = typeof next.hooks === "object" && next.hooks !== null ? { ...next.hooks } : {};
+  const pre = Array.isArray(hooks.preToolUse) ? hooks.preToolUse : [];
+  hooks.preToolUse = [...pre.filter((e) => !isDgEntry(e)), dgEntry(dgCommand)];
+  next.hooks = hooks;
+  return next;
+}
+function removeDgHook2(settings) {
+  const next = { ...settings };
+  if (typeof next.hooks !== "object" || next.hooks === null) {
+    return { settings: next, changed: false, empty: Object.keys(next).length === 0 };
+  }
+  const hooks = { ...next.hooks };
+  const pre = Array.isArray(hooks.preToolUse) ? hooks.preToolUse : [];
+  const withoutDg = pre.filter((e) => !isDgEntry(e));
+  const changed = withoutDg.length !== pre.length;
+  if (withoutDg.length > 0) {
+    hooks.preToolUse = withoutDg;
+  } else {
+    delete hooks.preToolUse;
+  }
+  if (Object.keys(hooks).length > 0) {
+    next.hooks = hooks;
+  } else {
+    delete next.hooks;
+  }
+  return { settings: next, changed, empty: Object.keys(next).length === 0 };
+}
+function hasDgHook2(settings) {
+  const hooks = settings.hooks?.preToolUse;
+  return Array.isArray(hooks) && hooks.some((e) => isDgEntry(e));
+}
+function toolArgsObject(raw) {
+  if (typeof raw === "string") {
+    try {
+      const parsed = JSON.parse(raw);
+      return typeof parsed === "object" && parsed !== null ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+  return typeof raw === "object" && raw !== null ? raw : null;
+}
+function parseInput3(stdin) {
+  try {
+    const obj = JSON.parse(stdin);
+    const args = toolArgsObject(obj.toolArgs);
+    const command = args?.command;
+    if (typeof command !== "string") {
+      return null;
+    }
+    return typeof obj.cwd === "string" ? { command, cwd: obj.cwd } : { command };
+  } catch {
+    return null;
+  }
+}
+function emitDecision3(verdict) {
+  if (verdict.decision === "allow") {
+    return { stdout: "{}", exitCode: 0 };
+  }
+  return {
+    stdout: JSON.stringify({
+      permissionDecision: verdict.decision,
+      ...verdict.reason ? { permissionDecisionReason: verdict.reason } : {}
+    }),
+    exitCode: 0
+  };
+}
+function probeHookSupport2(home, deps) {
+  if (!dirExists(join6(home, ".copilot"))) {
+    return { supported: false, detail: "~/.copilot not found (is GitHub Copilot CLI installed?)" };
+  }
+  return probeMinCliVersion("copilot", "1.0.61", "GitHub Copilot CLI", deps);
+}
+var copilotCliIntegration = {
+  id: "copilot-cli",
+  label: "GitHub Copilot CLI",
+  kind: "merged-json",
+  maturity: "verified",
+  minVersion: "1.0.61",
+  configPath: configPath3,
+  detect: (home) => dirExists(join6(home, ".copilot")),
+  probeHookSupport: probeHookSupport2,
+  parseInput: parseInput3,
+  emitDecision: emitDecision3,
+  ...mergedJsonHook({
+    checkName: "dg preToolUse hook",
+    insert: insertDgHook2,
+    remove: removeDgHook2,
+    isInstalled: hasDgHook2
+  })
+};
+
+// dist.next/agents/cursor.js
+import { join as join7 } from "node:path";
+var SIGNATURE3 = "hook-exec cursor";
+function configPath4(home) {
+  return join7(home, ".cursor", "hooks.json");
+}
+function isDgEntry2(entry) {
+  return typeof entry === "object" && entry !== null && typeof entry.command === "string" && entry.command.includes(SIGNATURE3);
+}
+function hookList(settings) {
+  const hooks = settings.hooks;
+  if (typeof hooks !== "object" || hooks === null) {
+    return [];
+  }
+  const list = hooks.beforeShellExecution;
+  return Array.isArray(list) ? list : [];
+}
+function insertHook(settings, dgCommand) {
+  const next = { ...settings };
+  const hooks = typeof next.hooks === "object" && next.hooks !== null ? { ...next.hooks } : {};
+  const list = Array.isArray(hooks.beforeShellExecution) ? hooks.beforeShellExecution : [];
+  hooks.beforeShellExecution = [...list.filter((entry) => !isDgEntry2(entry)), { command: dgCommand }];
+  next.hooks = hooks;
+  if (next.version === void 0) {
+    next.version = 1;
+  }
+  return next;
+}
+function effectivelyEmpty(obj) {
+  const keys = Object.keys(obj);
+  return keys.length === 0 || keys.length === 1 && keys[0] === "version";
+}
+function removeHook(settings) {
+  const next = { ...settings };
+  if (typeof next.hooks !== "object" || next.hooks === null) {
+    return { settings: next, changed: false, empty: effectivelyEmpty(next) };
+  }
+  const hooks = { ...next.hooks };
+  const list = Array.isArray(hooks.beforeShellExecution) ? hooks.beforeShellExecution : [];
+  const withoutDg = list.filter((entry) => !isDgEntry2(entry));
+  const changed = withoutDg.length !== list.length;
+  if (withoutDg.length > 0) {
+    hooks.beforeShellExecution = withoutDg;
+  } else {
+    delete hooks.beforeShellExecution;
+  }
+  if (Object.keys(hooks).length > 0) {
+    next.hooks = hooks;
+  } else {
+    delete next.hooks;
+  }
+  return { settings: next, changed, empty: effectivelyEmpty(next) };
+}
+function hasDgHook3(settings) {
+  return hookList(settings).some((entry) => isDgEntry2(entry));
+}
+function parseInput4(stdin) {
+  try {
+    const obj = JSON.parse(stdin);
+    if (typeof obj.command !== "string") {
+      return null;
+    }
+    return typeof obj.cwd === "string" ? { command: obj.command, cwd: obj.cwd } : { command: obj.command };
+  } catch {
+    return null;
+  }
+}
+function emitDecision4(verdict) {
+  if (verdict.decision === "allow") {
+    const note = verdict.screened ? formatScreenedNote(verdict.screened) : "";
+    return {
+      stdout: JSON.stringify(note ? { permission: "allow", agent_message: note } : { permission: "allow" }),
+      exitCode: 0
+    };
+  }
+  const reason = verdict.reason ?? "Dependency Guardian firewall";
+  return {
+    stdout: JSON.stringify({ permission: verdict.decision, user_message: reason, agent_message: reason }),
+    exitCode: 0
+  };
+}
+function probeHookSupport3(home) {
+  if (!dirExists(join7(home, ".cursor"))) {
+    return { supported: false, detail: "~/.cursor not found (is Cursor installed?)" };
+  }
+  try {
+    readSettings(configPath4(home));
+  } catch {
+    return { supported: false, detail: `${configPath4(home)} exists but is not a JSON object dg can merge into` };
+  }
+  return { supported: true, detail: "requires Cursor 1.7+; dg cannot read your Cursor version from disk" };
+}
+var cursorIntegration = {
+  id: "cursor",
+  label: "Cursor",
+  kind: "merged-json",
+  maturity: "verified",
+  minVersion: "1.7",
+  configPath: configPath4,
+  detect: (home) => dirExists(join7(home, ".cursor")),
+  probeHookSupport: probeHookSupport3,
+  parseInput: parseInput4,
+  emitDecision: emitDecision4,
+  ...mergedJsonHook({
+    checkName: "dg beforeShellExecution hook",
+    insert: insertHook,
+    remove: removeHook,
+    isInstalled: hasDgHook3
+  })
+};
+
+// dist.next/agents/gemini.js
+import { join as join8 } from "node:path";
+var SIGNATURE4 = "hook-exec gemini";
+function configPath5(home) {
+  return join8(home, ".gemini", "settings.json");
+}
+function isDgGroup2(group) {
+  if (typeof group !== "object" || group === null) {
+    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(SIGNATURE4));
+}
+function dgGroup2(dgCommand) {
+  return { matcher: "run_shell_command", hooks: [{ type: "command", command: dgCommand }] };
+}
+function insertHook2(settings, dgCommand) {
+  const next = { ...settings };
+  const hooks = typeof next.hooks === "object" && next.hooks !== null ? { ...next.hooks } : {};
+  const pre = Array.isArray(hooks.BeforeTool) ? hooks.BeforeTool : [];
+  hooks.BeforeTool = [...pre.filter((g) => !isDgGroup2(g)), dgGroup2(dgCommand)];
+  next.hooks = hooks;
+  return next;
+}
+function removeHook2(settings) {
+  const next = { ...settings };
+  if (typeof next.hooks !== "object" || next.hooks === null) {
+    return { settings: next, changed: false, empty: Object.keys(next).length === 0 };
+  }
+  const hooks = { ...next.hooks };
+  const pre = Array.isArray(hooks.BeforeTool) ? hooks.BeforeTool : [];
+  const withoutDg = pre.filter((g) => !isDgGroup2(g));
+  const changed = withoutDg.length !== pre.length;
+  if (withoutDg.length > 0) {
+    hooks.BeforeTool = withoutDg;
+  } else {
+    delete hooks.BeforeTool;
+  }
+  if (Object.keys(hooks).length > 0) {
+    next.hooks = hooks;
+  } else {
+    delete next.hooks;
+  }
+  return { settings: next, changed, empty: Object.keys(next).length === 0 };
+}
+function hasDgHook4(settings) {
+  const hooks = settings.hooks?.BeforeTool;
+  return Array.isArray(hooks) && hooks.some((g) => isDgGroup2(g));
+}
+function parseInput5(stdin) {
+  try {
+    const obj = JSON.parse(stdin);
+    const command = obj.tool_args?.command ?? obj.tool_input?.command;
+    if (typeof command !== "string") {
+      return null;
+    }
+    return typeof obj.cwd === "string" ? { command, cwd: obj.cwd } : { command };
+  } catch {
+    return null;
+  }
+}
+function emitDecision5(verdict) {
+  if (verdict.decision === "allow") {
+    return { stdout: "{}", exitCode: 0 };
+  }
+  const reason = verdict.reason ?? "Dependency Guardian firewall";
+  return {
+    stdout: JSON.stringify({ decision: "block", reason }),
+    exitCode: 0
+  };
+}
+function probeHookSupport4(home, deps) {
+  if (!dirExists(join8(home, ".gemini"))) {
+    return { supported: false, detail: "~/.gemini not found (is Gemini CLI installed?)" };
+  }
+  return probeMinCliVersion("gemini", "0.26.0", "Gemini CLI", deps);
+}
+var geminiIntegration = {
+  id: "gemini",
+  label: "Gemini CLI",
+  kind: "merged-json",
+  maturity: "verified",
+  minVersion: "0.26.0",
+  configPath: configPath5,
+  detect: (home) => dirExists(join8(home, ".gemini")),
+  probeHookSupport: probeHookSupport4,
+  parseInput: parseInput5,
+  emitDecision: emitDecision5,
+  ...mergedJsonHook({
+    checkName: "dg BeforeTool hook",
+    insert: insertHook2,
+    remove: removeHook2,
+    isInstalled: hasDgHook4
+  })
+};
+
+// dist.next/agents/windsurf.js
+import { join as join9 } from "node:path";
+var SIGNATURE5 = "hook-exec windsurf";
+function configPath6(home) {
+  return join9(home, ".codeium", "windsurf", "hooks.json");
+}
+function isDgEntry3(entry) {
+  return typeof entry === "object" && entry !== null && typeof entry.command === "string" && entry.command.includes(SIGNATURE5);
+}
+function insertHook3(settings, dgCommand) {
+  const next = { ...settings };
+  const hooks = typeof next.hooks === "object" && next.hooks !== null ? { ...next.hooks } : {};
+  const list = Array.isArray(hooks.pre_run_command) ? hooks.pre_run_command : [];
+  hooks.pre_run_command = [...list.filter((entry) => !isDgEntry3(entry)), { command: dgCommand }];
+  next.hooks = hooks;
+  return next;
+}
+function removeHook3(settings) {
+  const next = { ...settings };
+  if (typeof next.hooks !== "object" || next.hooks === null) {
+    return { settings: next, changed: false, empty: Object.keys(next).length === 0 };
+  }
+  const hooks = { ...next.hooks };
+  const list = Array.isArray(hooks.pre_run_command) ? hooks.pre_run_command : [];
+  const withoutDg = list.filter((entry) => !isDgEntry3(entry));
+  const changed = withoutDg.length !== list.length;
+  if (withoutDg.length > 0) {
+    hooks.pre_run_command = withoutDg;
+  } else {
+    delete hooks.pre_run_command;
+  }
+  if (Object.keys(hooks).length > 0) {
+    next.hooks = hooks;
+  } else {
+    delete next.hooks;
+  }
+  return { settings: next, changed, empty: Object.keys(next).length === 0 };
+}
+function hasDgHook5(settings) {
+  const hooks = settings.hooks?.pre_run_command;
+  return Array.isArray(hooks) && hooks.some((entry) => isDgEntry3(entry));
+}
+function parseInput6(stdin) {
+  try {
+    const obj = JSON.parse(stdin);
+    const command = obj.tool_info?.command_line;
+    if (typeof command !== "string") {
+      return null;
+    }
+    const cwd = obj.tool_info?.cwd;
+    return typeof cwd === "string" ? { command, cwd } : { command };
+  } catch {
+    return null;
+  }
+}
+function emitDecision6(verdict) {
+  if (verdict.decision === "allow") {
+    return { stdout: "", exitCode: 0 };
+  }
+  const reason = verdict.reason ?? "Dependency Guardian firewall";
+  const suffix = verdict.decision === "ask" ? " (dg flagged this for human review \u2014 not auto-approved)" : "";
+  return { stdout: `${reason}${suffix}
+`, exitCode: 2 };
+}
+function probeHookSupport5(home) {
+  if (!dirExists(join9(home, ".codeium", "windsurf"))) {
+    return { supported: false, detail: "~/.codeium/windsurf not found (is Windsurf installed?)" };
+  }
+  return { supported: true, detail: "Windsurf config directory found; dg cannot read the app version from disk" };
+}
+var windsurfIntegration = {
+  id: "windsurf",
+  label: "Windsurf",
+  kind: "merged-json",
+  maturity: "unverified",
+  minVersion: null,
+  configPath: configPath6,
+  detect: (home) => dirExists(join9(home, ".codeium", "windsurf")),
+  probeHookSupport: probeHookSupport5,
+  parseInput: parseInput6,
+  emitDecision: emitDecision6,
+  ...mergedJsonHook({
+    checkName: "dg pre_run_command hook",
+    insert: insertHook3,
+    remove: removeHook3,
+    isInstalled: hasDgHook5
+  })
+};
+
+// dist.next/agents/registry.js
+var AGENTS = {
+  "claude-code": claudeCodeIntegration,
+  codex: codexIntegration,
+  cursor: cursorIntegration,
+  "copilot-cli": copilotCliIntegration,
+  gemini: geminiIntegration,
+  windsurf: windsurfIntegration
+};
+var AGENT_IDS = Object.keys(AGENTS);
+function isAgentId(value) {
+  return value in AGENTS;
+}
+function agentFromSentinel(sentinel) {
+  if (!sentinel || sentinel === LEGACY_AGENT_HOOK_SENTINEL) {
+    return "claude-code";
+  }
+  if (!sentinel.startsWith(`${LEGACY_AGENT_HOOK_SENTINEL}:`)) {
+    return null;
+  }
+  const id = sentinel.slice(LEGACY_AGENT_HOOK_SENTINEL.length + 1);
+  return isAgentId(id) ? id : null;
+}
+function reverseAgentHookEntry(entry, removed, missing, warnings) {
+  const agent = agentFromSentinel(entry.sentinel);
+  if (!agent) {
+    warnings.push(`${entry.path}: unrecognized agent hook entry (${entry.sentinel ?? "no sentinel"}); left untouched`);
+    return;
+  }
+  AGENTS[agent].reverseEntry(entry, removed, missing, warnings);
+}
+
+// dist.next/agents/gate-posture.js
+init_state2();
+
+// dist.next/setup/plan.js
+init_state();
+
+// dist.next/runtime/node-version.js
+var MINIMUM_NODE = Object.freeze({
+  major: 22,
+  minor: 14,
+  patch: 0
+});
+
+// dist.next/setup/plan.js
+init_settings();
+init_resolve_real_binary();
+init_state2();
+var SHIM_COMMANDS = Object.freeze(["npm", "npx", "pnpm", "pnpx", "yarn", "pip", "pip3", "pipx", "uv", "uvx", "cargo"]);
+var SHIM_SENTINEL = "dg-shim-v1";
+var RC_SENTINEL = "dg-shell-rc-v1";
+var RC_SHIM_HELPER = "__dg_shim";
+var GUARD_HOOK_SENTINEL = "dg-git-hook-v1";
+var RC_BEGIN = "# >>> dg setup >>>";
+var RC_END = "# <<< dg setup <<<";
+var LEGACY_RC_MARKERS = [
+  { begin: "# >>> dg-managed >>>", end: "# <<< dg-managed <<<" }
+];
+var LEGACY_RC_CANDIDATES = [".zshrc", ".bashrc", ".bash_profile", ".profile", join10(".config", "fish", "config.fish")];
+var LEGACY_PYTHON_HOOK_PY = "dg_pip_hook.py";
+var LEGACY_PYTHON_HOOK_PTH = "dg_pip_hook.pth";
+var LEGACY_PYTHON_HOOK_MARKER = "Dependency Guardian pip-install interceptor";
+var LEGACY_PYTHON_HOOK_PTH_MARKER = "import dg_pip_hook";
+var SETUP_UNINSTALL_LOCK = "setup-uninstall";
+var SETUP_UNINSTALL_LOCK_STALE_MS = 30 * 60 * 1e3;
+var STALE_SESSION_OLDER_THAN_MS = 24 * 60 * 60 * 1e3;
+function uninstallSetup(options) {
+  const paths = resolveDgPaths(options.env ?? process.env);
+  const hadCacheDirBeforeLock = existsSync2(paths.cacheDir);
+  const hadStateDirBeforeLock = existsSync2(paths.stateDir);
+  const lock = acquireLockSync(paths, SETUP_UNINSTALL_LOCK, {
+    staleMs: SETUP_UNINSTALL_LOCK_STALE_MS
+  });
+  try {
+    const registryRead = readRegistry(paths);
+    const removed = [];
+    const missing = [];
+    const warnings = [];
+    const staleSessions = sweepStaleSessionsSync(paths, {
+      olderThanMs: STALE_SESSION_OLDER_THAN_MS
+    }).removed;
+    if (registryRead.malformed) {
+      warnings.push(registryRead.preservedPath ? `cleanup registry was malformed: ${paths.cleanupRegistryPath} (preserved at ${registryRead.preservedPath})` : `cleanup registry is malformed: ${paths.cleanupRegistryPath}`);
+    }
+    for (const entry of registryRead.registry.entries) {
+      if (entry.owner !== "dg") {
+        continue;
+      }
+      if (entry.kind === "shim") {
+        removeShim(entry, removed, missing, warnings);
+      } else if (entry.kind === "rc") {
+        removeRcBlock(entry, removed, missing, warnings);
+      } else if (entry.kind === "git-hook") {
+        reverseGitHookEntry(entry, removed, missing, warnings);
+      } else if (entry.kind === "agent-hook") {
+        reverseAgentHookEntry(entry, removed, missing, warnings);
+      }
+    }
+    sweepLegacyRcBlocks(paths.homeDir, removed, warnings);
+    sweepLegacyPythonHooks(paths.homeDir, removed, warnings);
+    if (!options.all && !registryRead.malformed && options.keepConfig) {
+      writeRegistryWithLock(paths, {
+        version: 1,
+        entries: registryRead.registry.entries.filter((entry) => entry.owner !== "dg")
+      });
+    }
+    if (!options.keepConfig && hadCacheDirBeforeLock) {
+      removeDirectory(paths.cacheDir, removed, missing);
+    }
+    if (!options.keepConfig && hadStateDirBeforeLock) {
+      removeDirectory(paths.stateDir, removed, missing);
+    }
+    if (options.all) {
+      removeDirectory(paths.configDir, removed, missing);
+    }
+    return {
+      removed,
+      missing,
+      warnings,
+      staleSessions
+    };
+  } finally {
+    lock.release();
+  }
+}
+function writeRcFileAtomic(rcPath, content) {
+  let target = rcPath;
+  let mode = 420;
+  try {
+    target = realpathSync(rcPath);
+    mode = statSync3(target).mode & 4095;
+  } catch {
+  }
+  const tempPath = join10(dirname3(target), `.${basename(target)}.dg-${randomBytes2(6).toString("hex")}.tmp`);
+  writeFileSync3(tempPath, content, { encoding: "utf8", mode, flag: "wx" });
+  try {
+    renameSync4(tempPath, target);
+  } catch (error) {
+    rmSync4(tempPath, { force: true });
+    throw error;
+  }
+}
+function stripRcBlockDetailed(existing) {
+  let content = existing.replace(rcPairPattern(RC_BEGIN, RC_END), "");
+  const repairedLines = [];
+  for (; ; ) {
+    const lines = content.split("\n");
+    const begin = lines.indexOf(RC_BEGIN);
+    if (begin === -1) {
+      break;
+    }
+    let end = begin;
+    while (end + 1 < lines.length && isDgWrittenRcLine(lines[end + 1] ?? "")) {
+      end += 1;
+    }
+    repairedLines.push(begin === end ? `line ${begin + 1}` : `lines ${begin + 1}-${end + 1}`);
+    lines.splice(begin, end - begin + 1);
+    content = lines.join("\n");
+  }
+  return { content, repairedLines };
+}
+function rcPairPattern(begin, end) {
+  return new RegExp(`${escapeRegex(begin)}\\n(?:(?!${escapeRegex(begin)})[\\s\\S])*?${escapeRegex(end)}\\n?`, "g");
+}
+function isDgWrittenRcLine(line) {
+  return line === RC_END || line.startsWith("# dg-") || line.includes(RC_SHIM_HELPER) || line.includes(`${sep}.dg${sep}shims`);
+}
+function sweepLegacyRcBlocks(homeDir, removed, warnings) {
+  for (const rel of LEGACY_RC_CANDIDATES) {
+    const rcPath = join10(homeDir, rel);
+    const existing = readText(rcPath);
+    if (!existing) {
+      continue;
+    }
+    let next = existing;
+    for (const marker of LEGACY_RC_MARKERS) {
+      if (!next.includes(marker.begin)) {
+        continue;
+      }
+      if (!next.includes(marker.end)) {
+        warnings.push(`legacy dg block in ${rcPath} is missing its end marker; left untouched`);
+        continue;
+      }
+      next = next.replace(rcPairPattern(marker.begin, marker.end), "");
+    }
+    if (next === existing) {
+      continue;
+    }
+    try {
+      writeRcFileAtomic(rcPath, next);
+      removed.push(`${rcPath} (legacy dg block)`);
+    } catch (error) {
+      warnings.push(`could not strip legacy dg block from ${rcPath}: ${error instanceof Error ? error.message : "write error"}`);
+    }
+  }
+}
+function isLegacyPthHook(pthPath) {
+  const content = readText(pthPath);
+  return content.includes(LEGACY_PYTHON_HOOK_PTH_MARKER) || content.includes(LEGACY_PYTHON_HOOK_MARKER);
+}
+function sweepLegacyPythonHooks(homeDir, removed, warnings) {
+  for (const dir of candidateSitePackagesDirs(homeDir)) {
+    const pyPath = join10(dir, LEGACY_PYTHON_HOOK_PY);
+    const pthPath = join10(dir, LEGACY_PYTHON_HOOK_PTH);
+    const pyIsHook = readText(pyPath).includes(LEGACY_PYTHON_HOOK_MARKER);
+    const pthIsHook = isLegacyPthHook(pthPath);
+    if (!pyIsHook && !pthIsHook) {
+      continue;
+    }
+    if (pthIsHook) {
+      removePythonHookFile(pthPath, removed, warnings);
+    }
+    if (pyIsHook) {
+      removePythonHookFile(pyPath, removed, warnings);
+    }
+  }
+}
+function removePythonHookFile(path, removed, warnings) {
+  try {
+    rmSync4(path, { force: true });
+    removed.push(`${path} (legacy dg pip hook)`);
+  } catch (error) {
+    warnings.push(`could not remove legacy dg pip hook ${path}: ${error instanceof Error ? error.message : "remove error"}`);
+  }
+}
+function candidateSitePackagesDirs(homeDir) {
+  const dirs = [];
+  for (const version of safeReaddir(join10(homeDir, "Library", "Python"))) {
+    dirs.push(join10(homeDir, "Library", "Python", version, "lib", "python", "site-packages"));
+  }
+  for (const entry of safeReaddir(join10(homeDir, ".local", "lib"))) {
+    if (entry.startsWith("python")) {
+      dirs.push(join10(homeDir, ".local", "lib", entry, "site-packages"));
+    }
+  }
+  return dirs;
+}
+function safeReaddir(dir) {
+  try {
+    return readdirSync2(dir);
+  } catch {
+    return [];
+  }
+}
+function readRegistry(paths) {
+  try {
+    if (!existsSync2(paths.cleanupRegistryPath)) {
+      return {
+        registry: {
+          version: 1,
+          entries: []
+        },
+        malformed: false
+      };
+    }
+    const registry = JSON.parse(readFileSync4(paths.cleanupRegistryPath, "utf8"));
+    if (registry.version !== 1 || !Array.isArray(registry.entries)) {
+      throw new Error("unsupported cleanup registry");
+    }
+    return {
+      registry,
+      malformed: false
+    };
+  } catch {
+    const preservedPath = preserveCorruptCleanupRegistrySync(paths);
+    return {
+      registry: {
+        version: 1,
+        entries: []
+      },
+      malformed: true,
+      ...preservedPath ? { preservedPath } : {}
+    };
+  }
+}
+function writeRegistry(paths, registry) {
+  mkdirSync4(dirname3(paths.cleanupRegistryPath), {
+    recursive: true,
+    mode: 448
+  });
+  const tempPath = `${paths.cleanupRegistryPath}.${randomBytes2(6).toString("hex")}.tmp`;
+  writeFileSync3(tempPath, `${JSON.stringify(registry, null, 2)}
+`, {
+    encoding: "utf8",
+    mode: 384,
+    flag: "wx"
+  });
+  try {
+    renameSync4(tempPath, paths.cleanupRegistryPath);
+  } catch (error) {
+    rmSync4(tempPath, { force: true });
+    throw error;
+  }
+}
+function withRegistryLock(paths, action) {
+  const lock = acquireLockSync(paths, CLEANUP_REGISTRY_LOCK, {
+    staleMs: SETUP_UNINSTALL_LOCK_STALE_MS
+  });
+  try {
+    return action();
+  } finally {
+    lock.release();
+  }
+}
+function writeRegistryWithLock(paths, registry) {
+  withRegistryLock(paths, () => writeRegistry(paths, registry));
+}
+function removeShim(entry, removed, missing, warnings) {
+  if (!existsSync2(entry.path)) {
+    missing.push(entry.path);
+    return;
+  }
+  if (!validShim(entry.path, basename(entry.path))) {
+    warnings.push(`refused to remove drifted shim: ${entry.path}`);
+    return;
+  }
+  rmSync4(entry.path, {
+    force: true
+  });
+  removed.push(entry.path);
+}
+function removeRcBlock(entry, removed, missing, warnings) {
+  const existing = readText(entry.path);
+  if (!existing) {
+    missing.push(entry.path);
+    return;
+  }
+  if (!existing.includes(RC_SENTINEL)) {
+    warnings.push(`refused to edit shell rc without dg sentinel: ${entry.path}`);
+    return;
+  }
+  const stripped = stripRcBlockDetailed(existing);
+  try {
+    writeRcFileAtomic(entry.path, stripped.content);
+  } catch (error) {
+    warnings.push(`could not rewrite shell rc ${entry.path}: ${error instanceof Error ? error.message : "write error"}`);
+    return;
+  }
+  if (stripped.repairedLines.length > 0) {
+    warnings.push(`repaired an unterminated dg block in ${entry.path}: removed only dg-written lines (${stripped.repairedLines.join(", ")})`);
+  }
+  removed.push(entry.path);
+}
+function reverseGitHookEntry(entry, removed, missing, warnings) {
+  const sentinel = entry.sentinel ?? GUARD_HOOK_SENTINEL;
+  let ownsTarget = false;
+  if (!existsSync2(entry.path)) {
+    missing.push(entry.path);
+    ownsTarget = true;
+  } else if (readText(entry.path).split("\n", 2)[1]?.includes(sentinel)) {
+    rmSync4(entry.path, { force: true });
+    removed.push(entry.path);
+    ownsTarget = true;
+  } else {
+    warnings.push(`refused to remove git hook without dg sentinel: ${entry.path}`);
+  }
+  if (!ownsTarget) {
+    return;
+  }
+  if (entry.original) {
+    if (existsSync2(entry.original)) {
+      try {
+        renameSync4(entry.original, entry.path);
+        removed.push(entry.original);
+      } catch (error) {
+        warnings.push(`could not restore chained hook ${entry.original}: ${error instanceof Error ? error.message : "unknown error"}`);
+      }
+    } else {
+      missing.push(entry.original);
+    }
+  }
+}
+function removeDirectory(path, removed, missing) {
+  if (!existsSync2(path)) {
+    missing.push(path);
+    return;
+  }
+  rmSync4(path, {
+    force: true,
+    recursive: true
+  });
+  removed.push(path);
+}
+function validShim(path, command) {
+  if (!existsSync2(path)) {
+    return false;
+  }
+  return isValidShimSource(readText(path), command);
+}
+function isValidShimSource(content, command) {
+  if (!content.includes(SHIM_SENTINEL)) {
+    return false;
+  }
+  return content.includes("DG_SHIM_ACTIVE=") && content.includes('exec "') && content.includes(`" ${command} "$@"`);
+}
+function readText(path) {
+  try {
+    return readFileSync4(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// dist.next/setup/uninstall-standalone.js
+init_state();
+function run() {
+  const quiet = process.argv.includes("--quiet");
+  try {
+    const result = uninstallSetup({ keepConfig: false, all: true });
+    if (!quiet) {
+      process.stderr.write(`Dependency Guardian cleaned up ${result.removed.length} leftover item(s) after the package was removed.
+`);
+    }
+  } catch (error) {
+    if (!quiet && !(error instanceof LockBusyError)) {
+      process.stderr.write(`dg self-cleanup could not finish: ${error.message}
+`);
+    }
+  }
+  try {
+    rmSync5(join11(resolveDgPaths().homeDir, ".dg"), { recursive: true, force: true });
+  } catch {
+    return;
+  }
+}
+run();