@event4u/agent-config 9.27.0 → 9.28.0

package/dist/cli-delegate/cmd_export.js

@@ -9,20 +9,20 @@ import {
   KIRO_MARKER,
   ROOCODE_MARKER,
   ZED_MARKER
-} from "./chunk-3KJIMFTB.js";
+} from "./chunk-PQSAQKHW.js";
 import "./chunk-DVRS2KVR.js";
-import "./chunk-WR6GTRHJ.js";
+import "./chunk-JXARCGVN.js";
 import "./chunk-BKO2AZ7Z.js";
 import "./chunk-63WSP6YZ.js";
 import "./chunk-GRRPEPRN.js";
 import "./chunk-NXFWFAYV.js";
+import "./chunk-GB2FSUEE.js";
+import "./chunk-NDJLNC6Q.js";
 import "./chunk-523HCFYO.js";
+import "./chunk-OY53J6II.js";
 import {
   resolvePackageRoot
 } from "./chunk-MCJYCQPF.js";
-import "./chunk-HJ6DAJHR.js";
-import "./chunk-NDJLNC6Q.js";
-import "./chunk-OY53J6II.js";
 import "./chunk-J55WI3RR.js";
 
 // src/scripts/_cli/cmd_export.ts

package/dist/cli-delegate/cmd_fleet.js

@@ -5,12 +5,12 @@ import {
 } from "./chunk-HYWSRNUX.js";
 import "./chunk-OMIVVCG2.js";
 import "./chunk-523HCFYO.js";
-import {
-  resolvePackageRoot
-} from "./chunk-MCJYCQPF.js";
 import {
   require_dist
 } from "./chunk-OY53J6II.js";
+import {
+  resolvePackageRoot
+} from "./chunk-MCJYCQPF.js";
 import {
   __toESM
 } from "./chunk-J55WI3RR.js";

package/dist/cli-delegate/cmd_handoff.js

@@ -5,13 +5,13 @@ import {
   list_sessions,
   readHookStdin,
   read_entries
-} from "./chunk-AIIUU73N.js";
+} from "./chunk-7OMQCH4V.js";
 import "./chunk-3EWYC3YK.js";
 import {
   _RAW_KEY_PREFIXES,
   hardenedSpawnEnv
 } from "./chunk-VSYT7OHO.js";
-import "./chunk-HJ6DAJHR.js";
+import "./chunk-GB2FSUEE.js";
 import "./chunk-NDJLNC6Q.js";
 import "./chunk-OY53J6II.js";
 import "./chunk-J55WI3RR.js";

package/dist/cli-delegate/cmd_mcp_available.js

@@ -0,0 +1,433 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  resolve_project_root
+} from "./chunk-GB2FSUEE.js";
+import "./chunk-NDJLNC6Q.js";
+import "./chunk-J55WI3RR.js";
+
+// src/scripts/_cli/cmd_mcp_available.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+import process2 from "node:process";
+import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "node:url";
+
+// src/scripts/tool_registry.ts
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+var TOOL_REGISTRY = {
+  github: {
+    name: "github",
+    description: "GitHub API \u2014 PRs, issues, files, commits",
+    supported_actions: /* @__PURE__ */ new Set([
+      "read_pr",
+      "read_issue",
+      "create_pr",
+      "list_files",
+      "read_commit"
+    ]),
+    default_mode: "read-only",
+    requires_auth: true
+  },
+  jira: {
+    name: "jira",
+    description: "Jira API \u2014 tickets, search, comments",
+    supported_actions: /* @__PURE__ */ new Set([
+      "read_ticket",
+      "search_tickets",
+      "add_comment",
+      "transition_ticket"
+    ]),
+    default_mode: "read-only",
+    requires_auth: true
+  }
+};
+function get_tool(name) {
+  return TOOL_REGISTRY[name] ?? null;
+}
+function list_tools() {
+  return Object.values(TOOL_REGISTRY);
+}
+function validate_tool_declarations(allowed_tools, tool_permissions) {
+  const errors = [];
+  const warnings = [];
+  for (const tool_name of allowed_tools) {
+    const tool_def = get_tool(tool_name);
+    if (tool_def === null) {
+      errors.push(`Tool '${tool_name}' is not registered in the tool registry`);
+      continue;
+    }
+    if (tool_permissions && tool_name in tool_permissions) {
+      const perms = tool_permissions[tool_name];
+      const actions = perms?.actions ?? [];
+      for (const action of actions) {
+        if (!tool_def.supported_actions.has(action)) {
+          errors.push(`Tool '${tool_name}' does not support action '${action}'`);
+        }
+      }
+    }
+  }
+  if (tool_permissions) {
+    for (const tool_name of Object.keys(tool_permissions)) {
+      if (!allowed_tools.includes(tool_name)) {
+        warnings.push(`Tool '${tool_name}' has permissions but is not in allowed_tools`);
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function _jsonDumpsIndent2(obj) {
+  const pad = "  ";
+  function enc(value, depth) {
+    if (value === null) {
+      return "null";
+    }
+    if (typeof value === "boolean") {
+      return value ? "true" : "false";
+    }
+    if (typeof value === "number") {
+      return String(value);
+    }
+    if (typeof value === "string") {
+      return encStr(value);
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        return "[]";
+      }
+      const inner2 = value.map((v) => pad.repeat(depth + 1) + enc(v, depth + 1));
+      return "[\n" + inner2.join(",\n") + "\n" + pad.repeat(depth) + "]";
+    }
+    const o = value;
+    const keys = Object.keys(o);
+    if (keys.length === 0) {
+      return "{}";
+    }
+    const inner = keys.map(
+      (k) => pad.repeat(depth + 1) + encStr(k) + ": " + enc(o[k], depth + 1)
+    );
+    return "{\n" + inner.join(",\n") + "\n" + pad.repeat(depth) + "}";
+  }
+  function encStr(s) {
+    let out = '"';
+    for (const ch of s) {
+      const cp = ch.codePointAt(0);
+      if (ch === '"') out += '\\"';
+      else if (ch === "\\") out += "\\\\";
+      else if (ch === "\n") out += "\\n";
+      else if (ch === "\r") out += "\\r";
+      else if (ch === "	") out += "\\t";
+      else if (ch === "\b") out += "\\b";
+      else if (ch === "\f") out += "\\f";
+      else if (cp < 32) out += "\\u" + cp.toString(16).padStart(4, "0");
+      else if (cp < 127) out += ch;
+      else if (cp > 65535) {
+        const v = cp - 65536;
+        const hi = 55296 + (v >> 10);
+        const lo = 56320 + (v & 1023);
+        out += "\\u" + hi.toString(16).padStart(4, "0");
+        out += "\\u" + lo.toString(16).padStart(4, "0");
+      } else {
+        out += "\\u" + cp.toString(16).padStart(4, "0");
+      }
+    }
+    return out + '"';
+  }
+  return enc(obj, 0);
+}
+function _sorted(values) {
+  return [...values].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+}
+function parse_args(argv) {
+  let format = "text";
+  let validate_tools = null;
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === "--format") {
+      const value = argv[i + 1];
+      if (value === void 0) {
+        _argError("argument --format: expected one argument");
+      }
+      if (value !== "text" && value !== "json") {
+        _argError(
+          `argument --format: invalid choice: '${value}' (choose from 'text', 'json')`
+        );
+      }
+      format = value;
+      i += 2;
+      continue;
+    }
+    if (arg.startsWith("--format=")) {
+      const value = arg.slice("--format=".length);
+      if (value !== "text" && value !== "json") {
+        _argError(
+          `argument --format: invalid choice: '${value}' (choose from 'text', 'json')`
+        );
+      }
+      format = value;
+      i += 1;
+      continue;
+    }
+    if (arg === "--validate-tools") {
+      validate_tools = [];
+      i += 1;
+      while (i < argv.length && !argv[i].startsWith("-")) {
+        validate_tools.push(argv[i]);
+        i += 1;
+      }
+      continue;
+    }
+    _argError(`unrecognized arguments: ${arg}`);
+  }
+  return { format, validate_tools };
+}
+function _argError(message) {
+  process.stderr.write(
+    `usage: tool_registry [-h] [--format {text,json}] [--validate-tools [VALIDATE_TOOLS ...]]
+`
+  );
+  process.stderr.write(`tool_registry: error: ${message}
+`);
+  process.exit(2);
+}
+function main(argv = process.argv.slice(2)) {
+  const args = parse_args(argv);
+  if (args.validate_tools !== null) {
+    const result = validate_tool_declarations(args.validate_tools);
+    if (args.format === "json") {
+      process.stdout.write(
+        _jsonDumpsIndent2({
+          valid: result.valid,
+          errors: result.errors,
+          warnings: result.warnings
+        }) + "\n"
+      );
+    } else {
+      if (result.valid) {
+        process.stdout.write(
+          `\u2705  All ${args.validate_tools.length} tool declarations are valid
+`
+        );
+      } else {
+        for (const e of result.errors) {
+          process.stdout.write(`\u274C  ${e}
+`);
+        }
+        for (const w of result.warnings) {
+          process.stdout.write(`\u26A0\uFE0F  ${w}
+`);
+        }
+      }
+    }
+    return result.valid ? 0 : 1;
+  }
+  const tools = list_tools();
+  if (args.format === "json") {
+    process.stdout.write(
+      _jsonDumpsIndent2(
+        tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          actions: _sorted(t.supported_actions),
+          default_mode: t.default_mode,
+          requires_auth: t.requires_auth
+        }))
+      ) + "\n"
+    );
+  } else {
+    process.stdout.write(`Registered tools: ${tools.length}
+
+`);
+    for (const t of tools) {
+      const actions = _sorted(t.supported_actions).join(", ");
+      process.stdout.write(`  ${t.name} (${t.default_mode})
+`);
+      process.stdout.write(`    ${t.description}
+`);
+      process.stdout.write(`    Actions: ${actions}
+`);
+      process.stdout.write(`
+`);
+    }
+  }
+  return 0;
+}
+var _HERE = fileURLToPath(import.meta.url);
+function _isCliEntry() {
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs.realpathSync(fileURLToPath(import.meta.url));
+    const argv = fs.realpathSync(path.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry() || process.argv[1] === _HERE) {
+  process.exit(main());
+}
+
+// src/scripts/_cli/cmd_mcp_available.ts
+function resolveOnPath(command, pathEnv, cwd) {
+  if (command === "") return null;
+  const candidates = command.includes(path2.sep) ? [path2.resolve(cwd, command)] : pathEnv.split(path2.delimiter).filter((p) => p !== "").map((dir) => path2.join(dir, command));
+  for (const candidate of candidates) {
+    try {
+      const stat = fs2.statSync(candidate);
+      if (stat.isFile() && (stat.mode & 73) !== 0) return candidate;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function classifyServer(name, entry, pathEnv, cwd) {
+  if (typeof entry.command === "string" && entry.command !== "") {
+    const resolved = resolveOnPath(entry.command, pathEnv, cwd);
+    return {
+      name,
+      transport: "command",
+      target: entry.command,
+      launch: resolved === null ? "not-on-path" : "launchable",
+      resolved
+    };
+  }
+  if (typeof entry.url === "string" && entry.url !== "") {
+    return { name, transport: "url", target: entry.url, launch: "not-probed", resolved: null };
+  }
+  return { name, transport: "unknown", target: null, launch: "not-probed", resolved: null };
+}
+function runMcpAvailable(opts) {
+  const out = [];
+  const err = [];
+  const [projectRoot] = resolve_project_root(null, { cwd: opts.cwd });
+  const configPath = path2.join(projectRoot, "mcp.json");
+  let declared = [];
+  let configExists = true;
+  let rawText;
+  try {
+    rawText = fs2.readFileSync(configPath, "utf-8");
+  } catch {
+    configExists = false;
+    rawText = "";
+  }
+  if (configExists) {
+    let parsed;
+    try {
+      parsed = JSON.parse(rawText);
+    } catch (exc) {
+      err.push(
+        `\u274C  mcp:available \u2014 ${configPath} exists but is not valid JSON.`,
+        `    ${exc instanceof Error ? exc.message : String(exc)}`,
+        '    Refusing to report "no servers": an unparseable declaration file is a',
+        "    failure to answer, not an answer."
+      );
+      return { code: 1, out, err };
+    }
+    const servers = typeof parsed === "object" && parsed !== null ? parsed.servers ?? {} : {};
+    if (typeof servers === "object" && servers !== null && !Array.isArray(servers)) {
+      declared = Object.keys(servers).sort().map(
+        (name) => classifyServer(
+          name,
+          servers[name] ?? {},
+          opts.pathEnv,
+          projectRoot
+        )
+      );
+    }
+  }
+  const registryTools = list_tools().map((t) => t.name).sort();
+  if (opts.json) {
+    out.push(
+      JSON.stringify(
+        {
+          config: configExists ? configPath : null,
+          declared_servers: declared,
+          tool_registry: registryTools,
+          handshake_performed: false
+        },
+        null,
+        2
+      )
+    );
+    return { code: 0, out, err };
+  }
+  out.push(`declared servers   ${configExists ? configPath : "\u2014 no mcp.json in this project"}`);
+  if (declared.length === 0) {
+    out.push("  none");
+  }
+  for (const s of declared) {
+    const state = s.launch === "launchable" ? `launchable \u2014 ${s.resolved ?? ""}` : s.launch === "not-on-path" ? `NOT on PATH \u2014 \`${s.target ?? ""}\` does not resolve to an executable` : s.transport === "url" ? "remote \u2014 declared, deliberately not probed" : "malformed entry \u2014 declares neither command nor url";
+    out.push(`  ${s.name}   ${state}`);
+  }
+  out.push("");
+  out.push("tool registry      static allowlist for skill `allowed_tools` \u2014 NOT MCP, not probed");
+  out.push(`  ${registryTools.length > 0 ? registryTools.join(", ") : "none"}`);
+  out.push("");
+  out.push('\u26A0\uFE0F  No MCP handshake was performed. "launchable" means the command resolves to an');
+  out.push('    executable on PATH \u2014 strictly weaker than "the server responds". Any list of');
+  out.push("    TOOLS a server exposes can only come from a live session, never from here.");
+  return { code: 0, out, err };
+}
+function parseArgv(argv) {
+  let json = false;
+  for (const a of argv) {
+    if (a === "--json") {
+      json = true;
+    } else if (a === "-h" || a === "--help") {
+      return { ok: false, message: "usage: agent-config mcp:available [--json]" };
+    } else {
+      return { ok: false, message: `unknown argument: ${a}` };
+    }
+  }
+  return { ok: true, json };
+}
+function main2(argv = process2.argv.slice(2)) {
+  const parsed = parseArgv(argv);
+  if (!parsed.ok) {
+    process2.stderr.write(`${parsed.message ?? "usage error"}
+`);
+    return 2;
+  }
+  const result = runMcpAvailable({
+    cwd: process2.cwd(),
+    json: parsed.json === true,
+    pathEnv: process2.env["PATH"] ?? ""
+  });
+  for (const line of result.out) process2.stdout.write(`${line}
+`);
+  for (const line of result.err) process2.stderr.write(`${line}
+`);
+  return result.code;
+}
+function _isCliEntry2() {
+  if (process2.argv[1] === void 0) return false;
+  const argvUrl = pathToFileURL2(path2.resolve(process2.argv[1])).href;
+  if (import.meta.url === argvUrl) return true;
+  try {
+    return fs2.realpathSync(fileURLToPath2(import.meta.url)) === fs2.realpathSync(path2.resolve(process2.argv[1]));
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry2()) {
+  process2.exitCode = main2();
+}
+export {
+  classifyServer,
+  main2 as main,
+  parseArgv,
+  resolveOnPath,
+  runMcpAvailable
+};

package/dist/cli-delegate/cmd_migrate.js

@@ -1,10 +1,10 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
 import {
   main
-} from "./chunk-WR6GTRHJ.js";
-import "./chunk-MCJYCQPF.js";
-import "./chunk-HJ6DAJHR.js";
+} from "./chunk-JXARCGVN.js";
+import "./chunk-GB2FSUEE.js";
 import "./chunk-NDJLNC6Q.js";
+import "./chunk-MCJYCQPF.js";
 import "./chunk-J55WI3RR.js";
 export {
   main

package/dist/cli-delegate/cmd_packs_active.js

@@ -0,0 +1,153 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  ProfileError,
+  SOURCE_MISSING,
+  profile_file,
+  resolve_profile
+} from "./chunk-22GCIJ2O.js";
+import {
+  DEFAULT_PROJECT_FILE,
+  load_agent_settings,
+  resolve_project_root
+} from "./chunk-GB2FSUEE.js";
+import "./chunk-NDJLNC6Q.js";
+import "./chunk-J55WI3RR.js";
+
+// src/scripts/_cli/cmd_packs_active.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import process from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+var SOURCE_GLOSS = {
+  runtime: "set for this run (runtime override)",
+  env: "AGENT_CONFIG_PROFILE_ID environment variable",
+  "user-settings": `profile.id in ${DEFAULT_PROJECT_FILE}`,
+  pack: "declared by an installed pack",
+  default: "no settings file \u2014 package default",
+  [SOURCE_MISSING]: `settings file present but it declares no profile.id`
+};
+function profileFileFor(projectRoot, profile) {
+  if (profile.source === SOURCE_MISSING) return null;
+  const resolved = profile_file(projectRoot, profile.id);
+  return _isFile(resolved) ? resolved : null;
+}
+function _isFile(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function runPacksActive(opts) {
+  const out = [];
+  const err = [];
+  const [projectRoot] = resolve_project_root(null, { cwd: opts.cwd });
+  const settings = load_agent_settings({ cwd: opts.cwd });
+  let profile;
+  try {
+    profile = resolve_profile({ project_root: projectRoot, user_settings: settings });
+  } catch (exc) {
+    if (exc instanceof ProfileError) {
+      err.push(
+        `\u274C  packs:active \u2014 ${exc.message}`,
+        "    The profile id resolves but its file does not exist, so no pack set can be",
+        "    named. This is a broken install or a hand-edited profile.id, not an empty one."
+      );
+      return { code: 1, out, err };
+    }
+    throw exc;
+  }
+  const degraded = profile.source === SOURCE_MISSING;
+  const file = profileFileFor(projectRoot, profile);
+  const gloss = SOURCE_GLOSS[profile.source] ?? profile.source;
+  if (opts.json) {
+    out.push(
+      JSON.stringify(
+        {
+          profile_id: profile.id,
+          source: profile.source,
+          degraded,
+          packs: [...profile.packs],
+          personas: [...profile.personas],
+          profile_file: file,
+          project_root: projectRoot
+        },
+        null,
+        2
+      )
+    );
+    return { code: 0, out, err };
+  }
+  out.push(`profile   ${profile.id}   (${gloss})`);
+  out.push(
+    profile.packs.length > 0 ? `packs     ${profile.packs.join(", ")}   (${String(profile.packs.length)})` : "packs     none"
+  );
+  out.push(`file      ${file ?? "\u2014 the profile body was never loaded"}`);
+  out.push(`root      ${projectRoot}`);
+  if (degraded) {
+    out.push(
+      "",
+      "\u26A0\uFE0F  Degraded resolution \u2014 this is the answer, not a warning about it.",
+      `    A ${DEFAULT_PROJECT_FILE} exists here but declares no profile.id, so the id fell`,
+      "    back to the package default while the profile BODY was never read: zero packs,",
+      '    zero personas. Any rule that says "auto-activates when pack X is installed"',
+      "    cannot activate in this project, and nothing else reports that.",
+      "    Fix: set profile.id in the settings file, or run `agent-config use <id>`."
+    );
+  } else if (profile.packs.length === 0) {
+    out.push(
+      "",
+      `\u2139\uFE0F  The ${profile.id} profile declares no packs. Pack-gated rules stay inert here.`
+    );
+  }
+  if (profile.warning !== null && !degraded) {
+    out.push("", `\u26A0\uFE0F  ${profile.warning}`);
+  }
+  return { code: 0, out, err };
+}
+function parseArgv(argv) {
+  let json = false;
+  for (const a of argv) {
+    if (a === "--json") {
+      json = true;
+    } else if (a === "-h" || a === "--help") {
+      return { ok: false, message: "usage: agent-config packs:active [--json]" };
+    } else {
+      return { ok: false, message: `unknown argument: ${a}` };
+    }
+  }
+  return { ok: true, json };
+}
+function main(argv = process.argv.slice(2)) {
+  const parsed = parseArgv(argv);
+  if (!parsed.ok) {
+    process.stderr.write(`${parsed.message ?? "usage error"}
+`);
+    return 2;
+  }
+  const result = runPacksActive({ cwd: process.cwd(), json: parsed.json === true });
+  for (const line of result.out) process.stdout.write(`${line}
+`);
+  for (const line of result.err) process.stderr.write(`${line}
+`);
+  return result.code;
+}
+function _isCliEntry() {
+  if (process.argv[1] === void 0) return false;
+  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) return true;
+  try {
+    return fs.realpathSync(fileURLToPath(import.meta.url)) === fs.realpathSync(path.resolve(process.argv[1]));
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry()) {
+  process.exitCode = main();
+}
+export {
+  main,
+  parseArgv,
+  profileFileFor,
+  runPacksActive
+};

package/dist/cli-delegate/cmd_preflight.js

@@ -10,10 +10,10 @@ import {
 } from "./chunk-HYWSRNUX.js";
 import "./chunk-OMIVVCG2.js";
 import "./chunk-523HCFYO.js";
+import "./chunk-OY53J6II.js";
 import {
   resolvePackageRoot
 } from "./chunk-MCJYCQPF.js";
-import "./chunk-OY53J6II.js";
 import "./chunk-J55WI3RR.js";
 
 // src/scripts/_cli/cmd_preflight.ts

package/dist/cli-delegate/cmd_prune.js

@@ -1,9 +1,9 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
 import {
   PROJECT_BRIDGE_MARKERS
-} from "./chunk-3KJIMFTB.js";
+} from "./chunk-PQSAQKHW.js";
 import "./chunk-DVRS2KVR.js";
-import "./chunk-WR6GTRHJ.js";
+import "./chunk-JXARCGVN.js";
 import "./chunk-BKO2AZ7Z.js";
 import {
   manifest_path,
@@ -11,13 +11,13 @@ import {
 } from "./chunk-63WSP6YZ.js";
 import "./chunk-GRRPEPRN.js";
 import "./chunk-NXFWFAYV.js";
-import "./chunk-523HCFYO.js";
-import "./chunk-MCJYCQPF.js";
 import {
   resolve_project_root
-} from "./chunk-HJ6DAJHR.js";
+} from "./chunk-GB2FSUEE.js";
 import "./chunk-NDJLNC6Q.js";
+import "./chunk-523HCFYO.js";
 import "./chunk-OY53J6II.js";
+import "./chunk-MCJYCQPF.js";
 import "./chunk-J55WI3RR.js";
 
 // src/scripts/_cli/cmd_prune.ts