@shadowob/cloud 1.1.6-dev.311

package/dist/agent-pack-LF3O5TR4.js

@@ -0,0 +1,1236 @@
+#!/usr/bin/env node
+import {
+  AGENT_PACK_SLASH_INDEXER_SCRIPT
+} from "./chunk-ZUYL3W53.js";
+import {
+  definePlugin
+} from "./chunk-CTNUKOQE.js";
+import "./chunk-AD3JTIU3.js";
+
+// src/plugins/agent-pack/index.ts
+import * as __typia_transform__validateReport from "typia/lib/internal/_validateReport";
+import * as __typia_transform__createStandardSchema from "typia/lib/internal/_createStandardSchema";
+
+// src/plugins/agent-pack/k8s.ts
+var AGENT_PACK_IMAGE = "node:22-bookworm";
+var SLASH_INDEXER_PATH = "/tmp/agent-pack-slash-indexer.mjs";
+var AGENT_PACK_SCRIPT_MOUNT_PATH = "/opt/shadow-agent-pack";
+var AGENT_PACK_HELPER_SECURITY_CONTEXT = {
+  runAsNonRoot: true,
+  runAsUser: 1e3,
+  runAsGroup: 1e3,
+  allowPrivilegeEscalation: false,
+  capabilities: { drop: ["ALL"] }
+};
+var AGENT_PACK_TOOL_CHECKS = [
+  'command -v git >/dev/null 2>&1 || { echo "[agent-pack] git is missing from helper image" >&2; exit 127; }',
+  'command -v node >/dev/null 2>&1 || { echo "[agent-pack] node is missing from helper image" >&2; exit 127; }'
+];
+var DEFAULT_INSTRUCTION_FILES = [
+  "AGENTS.override.md",
+  "AGENTS.md",
+  "CLAUDE.md",
+  "GEMINI.md",
+  ".cursorrules",
+  ".windsurfrules",
+  ".clinerules"
+];
+function parsePollInterval(input) {
+  if (input == null) return 0;
+  if (typeof input === "number") return Math.max(0, Math.floor(input));
+  const m = /^(\d+)\s*(s|m|h)?$/.exec(input.trim());
+  if (!m) return 0;
+  const n = Number(m[1]);
+  const unit = m[2] ?? "s";
+  switch (unit) {
+    case "h":
+      return n * 3600;
+    case "m":
+      return n * 60;
+    default:
+      return n;
+  }
+}
+function sanitizeId(s) {
+  return s.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 63);
+}
+function agentPackSlashCommandsIndexPath(mountPath) {
+  return `${mountPath}/.shadow/slash-commands.json`;
+}
+function shQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function buildSlashCommandIndexSnippet(mountPath, options) {
+  if (!options?.enabled) return "";
+  const rulesJson = JSON.stringify(options.rules ?? []);
+  return [
+    `cat > ${SLASH_INDEXER_PATH} <<'SHADOW_AGENT_PACK_SLASH_INDEXER'`,
+    AGENT_PACK_SLASH_INDEXER_SCRIPT,
+    "SHADOW_AGENT_PACK_SLASH_INDEXER",
+    [
+      `node ${SLASH_INDEXER_PATH}`,
+      `--mount-path ${shQuote(mountPath)}`,
+      `--output ${shQuote(options.outputPath)}`,
+      `--infer-interactions ${options.inferInteractions === false ? "false" : "true"}`,
+      `--include-scripts ${options.includeScripts === false ? "false" : "true"}`,
+      `--generate-script-skills ${options.generateScriptSkills === false ? "false" : "true"}`,
+      `--max-script-commands-per-pack ${Math.max(0, Math.floor(options.maxScriptCommandsPerPack ?? 80))}`,
+      `--rules-json ${shQuote(rulesJson)}`
+    ].join(" ")
+  ].join("\n");
+}
+function buildMountCopySnippet(pack, mount, scratch, destBase) {
+  const from = mount.from === "." || mount.from === "" ? scratch : `${scratch}/${mount.from}`;
+  const dest = `${destBase}/${mount.kind}`;
+  const cmds = [`mkdir -p "${dest}"`];
+  switch (mount.kind) {
+    case "skills":
+    case "commands":
+    case "agents": {
+      const descriptorName = mount.kind === "agents" ? "AGENT.md" : "SKILL.md";
+      const rootSkillSlug = sanitizeId(pack.id);
+      const codexAgentSkillWrapper = `printf '%s\\n' '---' 'description: Codex custom agent definition imported from an agent pack.' 'user-invocable: false' '---' '' '# Codex custom agent' '' 'Read the bundled AGENT.toml before using this custom agent definition. Treat it as agent configuration, not as a free-form prompt.' > "${dest}/$slug/SKILL.md"`;
+      const descriptorCopies = mount.kind === "agents" ? `case "$f" in *.toml) cp "$f" "${dest}/$slug/AGENT.toml"; ${codexAgentSkillWrapper} ;; *) cp "$f" "${dest}/$slug/${descriptorName}"; cp "$f" "${dest}/$slug/SKILL.md" ;; esac` : `cp "$f" "${dest}/$slug/${descriptorName}"`;
+      const stripSkillSuffix = mount.kind === "skills" ? `slug="$(printf '%s' "$slug" | sed 's/-SKILL$//')"; ` : "";
+      const normalizeTopLevelFile = `base="$(basename "$f")"; base="\${base%.md}"; base="\${base%.toml}"; if [ "$base" = "SKILL" ]; then slug="${rootSkillSlug}"; else slug="$base"; fi; ${stripSkillSuffix}slug="$(printf '%s' "$slug" | tr -cs 'A-Za-z0-9._-' '-' | sed 's/^-//;s/-$//')"; [ -n "$slug" ] || slug="item"; mkdir -p "${dest}/$slug"; ${descriptorCopies}`;
+      const normalizeNestedSkillDir = `d="$(dirname "$f")"; rel="$d"; case "$rel" in "${from}"/*) rel="\${rel#${from}/}" ;; *) rel="$(basename "$d")" ;; esac; slug="$(basename "$d")"; slug="$(printf '%s' "$slug" | sed 's/-SKILL$//' | tr -cs 'A-Za-z0-9._-' '-' | sed 's/^-//;s/-$//')"; [ -n "$slug" ] || slug="${rootSkillSlug}"; if [ -e "${dest}/$slug" ]; then slug="$(printf '%s' "$rel" | sed 's/-SKILL$//' | tr '/ ' '--' | tr -cs 'A-Za-z0-9._-' '-' | sed 's/^-//;s/-$//')"; fi; [ -n "$slug" ] || slug="${rootSkillSlug}"; mkdir -p "${dest}/$slug"; cp -r "$d/." "${dest}/$slug/"`;
+      if (mount.include && mount.include.length > 0) {
+        for (const name of mount.include) {
+          cmds.push(
+            `if [ -d "${from}/${name}" ]; then cp -r "${from}/${name}" "${dest}/"; elif [ -f "${from}/${name}" ]; then f="${from}/${name}"; ${normalizeTopLevelFile}; else echo "[agent-pack] missing ${mount.kind} ${name} in ${pack.id}"; fi`
+          );
+        }
+      } else {
+        const hasDescriptor = mount.kind === "skills" ? `[ -f "$d/SKILL.md" ]` : mount.kind === "agents" ? `[ -n "$(find "$d" -maxdepth 1 -type f \\( -name '*.md' -o -name '*.toml' \\) -print -quit 2>/dev/null)" ]` : `[ -n "$(find "$d" -maxdepth 1 -type f -name '*.md' -print -quit 2>/dev/null)" ]`;
+        cmds.push(
+          `find "${from}" -mindepth 1 -maxdepth 1 -type d 2>/dev/null | while read -r d; do if ${hasDescriptor}; then cp -r "$d" "${dest}/"; fi; done`
+        );
+        if (mount.kind === "skills") {
+          cmds.push(
+            `if [ -f "${from}/SKILL.md" ]; then mkdir -p "${dest}/${rootSkillSlug}"; cp "${from}/SKILL.md" "${dest}/${rootSkillSlug}/SKILL.md"; fi`
+          );
+          cmds.push(
+            `find "${from}" -mindepth 1 -maxdepth 1 -type f \\( -name 'SKILL.md' -o -name '*-SKILL.md' \\) 2>/dev/null | while read -r f; do ${normalizeTopLevelFile}; done`
+          );
+          cmds.push(
+            `find "${from}" -path '*/.git/*' -prune -o -mindepth 2 -maxdepth 6 -type f -name 'SKILL.md' -print 2>/dev/null | while read -r f; do ${normalizeNestedSkillDir}; done`
+          );
+        }
+        if (mount.kind === "commands" || mount.kind === "agents") {
+          const pathSegment = mount.kind;
+          const fileGlob = mount.kind === "agents" ? `\\( -name '*.md' -o -name '*.toml' \\)` : `-name '*.md'`;
+          cmds.push(
+            `find "${from}" -mindepth 1 -maxdepth 1 -type f ${fileGlob} 2>/dev/null | while read -r f; do ${normalizeTopLevelFile}; done`
+          );
+          cmds.push(
+            `find "${from}" -path '*/.git/*' -prune -o -path "*/${pathSegment}/*" -type f ${fileGlob} -print 2>/dev/null | while read -r f; do ${normalizeTopLevelFile}; done`
+          );
+        }
+      }
+      break;
+    }
+    case "instructions": {
+      for (const f of pack.instructionFiles) {
+        cmds.push(`cp "${scratch}/${f}" "${dest}/" 2>/dev/null || true`);
+      }
+      if (mount.from !== "." && mount.from !== "") {
+        cmds.push(
+          `if [ -f "${from}" ]; then cp "${from}" "${dest}/" 2>/dev/null || true; elif [ -d "${from}" ]; then find "${from}" -mindepth 1 -maxdepth 3 -type f \\( -name '*.md' -o -name '*.mdc' -o -name '*.txt' \\) -exec cp {} "${dest}/" \\; 2>/dev/null || true; fi`
+        );
+      }
+      break;
+    }
+    case "mcp": {
+      cmds.push(
+        `if [ -f "${from}" ]; then cp "${from}" "${dest}/$(basename "${from}")"; elif [ -d "${from}" ]; then find "${from}" -mindepth 1 -maxdepth 1 -name '*.json' -exec cp {} "${dest}/" \\; ; fi`
+      );
+      break;
+    }
+    case "hooks":
+    case "scripts":
+    case "files": {
+      if (mount.include && mount.include.length > 0) {
+        for (const name of mount.include) {
+          cmds.push(`cp -r "${from}/${name}" "${dest}/" 2>/dev/null || true`);
+        }
+      } else {
+        cmds.push(
+          `if [ -d "${from}" ]; then cp -r "${from}/." "${dest}/" 2>/dev/null || true; elif [ -f "${from}" ]; then cp "${from}" "${dest}/" 2>/dev/null || true; fi`
+        );
+      }
+      if (mount.kind === "scripts") {
+        cmds.push(`find "${dest}" -type f -exec chmod +x {} \\; 2>/dev/null || true`);
+      }
+      break;
+    }
+  }
+  return cmds.join(" && ");
+}
+function buildPackCloneSnippet(pack, mountPath) {
+  const safeId = sanitizeId(pack.id);
+  const scratch = `/tmp/agent-pack-src-${safeId}`;
+  const destBase = `${mountPath}/${safeId}`;
+  const summary = pack.mounts.map((m) => m.kind).join(",") || "none";
+  const lines = [
+    `echo "[agent-pack] cloning ${pack.url}@${pack.ref} (mounts: ${summary}) -> ${destBase}"`,
+    `rm -rf "${scratch}"`,
+    `git clone --depth ${pack.depth} --branch "${pack.ref}" "${pack.url}" "${scratch}"`,
+    `mkdir -p "${destBase}"`
+  ];
+  for (const m of pack.mounts) {
+    lines.push(buildMountCopySnippet(pack, m, scratch, destBase));
+  }
+  const manifest = JSON.stringify({
+    id: pack.id,
+    url: pack.url,
+    ref: pack.ref,
+    autoDetect: pack.autoDetect ?? false,
+    autoImportProfiles: pack.autoImportProfiles ?? [],
+    kinds: pack.mounts.map((m) => m.kind)
+  });
+  lines.push(`echo '${manifest.replace(/'/g, "'\\''")}' > "${destBase}/.pack.json"`);
+  lines.push(`echo "[agent-pack] ${pack.id} ready"`);
+  return lines.join(" && ");
+}
+function buildAgentPackInitContainer(packs, mountPath, volumeName, scriptVolumeName, slashCommandIndex) {
+  return {
+    name: "agent-pack-clone",
+    image: AGENT_PACK_IMAGE,
+    imagePullPolicy: "IfNotPresent",
+    command: ["/bin/sh", `${AGENT_PACK_SCRIPT_MOUNT_PATH}/init.sh`],
+    volumeMounts: [
+      { name: volumeName, mountPath },
+      { name: scriptVolumeName, mountPath: AGENT_PACK_SCRIPT_MOUNT_PATH, readOnly: true }
+    ],
+    resources: {
+      requests: { cpu: "25m", memory: "64Mi" },
+      limits: { cpu: "250m", memory: "256Mi" }
+    },
+    securityContext: AGENT_PACK_HELPER_SECURITY_CONTEXT
+  };
+}
+function buildAgentPackSyncSidecar(opts) {
+  const { volumeName, scriptVolumeName, intervalSec } = opts;
+  if (!intervalSec || intervalSec <= 0) return void 0;
+  return {
+    name: "agent-pack-sync",
+    image: AGENT_PACK_IMAGE,
+    imagePullPolicy: "IfNotPresent",
+    command: ["/bin/sh", `${AGENT_PACK_SCRIPT_MOUNT_PATH}/sync.sh`],
+    volumeMounts: [
+      { name: volumeName, mountPath: opts.mountPath },
+      { name: scriptVolumeName, mountPath: AGENT_PACK_SCRIPT_MOUNT_PATH, readOnly: true }
+    ],
+    resources: {
+      requests: { cpu: "25m", memory: "64Mi" },
+      limits: { cpu: "250m", memory: "256Mi" }
+    },
+    securityContext: AGENT_PACK_HELPER_SECURITY_CONTEXT
+  };
+}
+function buildAgentPackInitScript(packs, mountPath, slashCommandIndex) {
+  return [
+    "set -e",
+    ...AGENT_PACK_TOOL_CHECKS,
+    ...packs.map((p) => buildPackCloneSnippet(p, mountPath)),
+    buildSlashCommandIndexSnippet(mountPath, slashCommandIndex)
+  ].filter(Boolean).join("\n");
+}
+function buildAgentPackSyncScript(opts) {
+  const { packs, mountPath, intervalSec, slashCommandIndex } = opts;
+  const cloneAll = packs.map((p) => buildPackCloneSnippet(p, mountPath)).join("\n");
+  const indexCommands = buildSlashCommandIndexSnippet(mountPath, slashCommandIndex);
+  return `
+set -e
+${AGENT_PACK_TOOL_CHECKS.join("\n")}
+RUN_SCRIPT() {
+${cloneAll}
+${indexCommands}
+}
+while true; do
+  RUN_SCRIPT || echo "[agent-pack-sync] iteration failed, will retry"
+  date -u +%FT%TZ > "${mountPath}/.agent-pack-synced-at" || true
+  sleep ${intervalSec}
+done
+`.trim();
+}
+
+// src/plugins/agent-pack/manifest.json
+var manifest_default = {
+  id: "agent-pack",
+  name: "Agent Pack",
+  description: "Pure mechanism for pulling AI-agent customisation packs from any git repo at deploy time. Standards-based auto-import handles Agent Skills, Claude Code, Codex, and MCP layouts; templates can opt into scripts or declare exact mounts for repo-specific layouts.",
+  version: "1.0.0",
+  category: "code",
+  icon: "package",
+  auth: {
+    type: "token",
+    fields: [
+      {
+        key: "GITHUB_TOKEN",
+        label: "Git Token (HTTPS)",
+        description: "Optional personal access token for private agent-pack repositories",
+        required: false,
+        sensitive: true,
+        placeholder: "ghp_..."
+      }
+    ]
+  },
+  config: {
+    type: "object",
+    properties: {
+      packs: {
+        type: "array",
+        description: "Agent packs to mount into the container",
+        items: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "Unique pack id within the agent (used for mount subdir). Auto-derived from url when omitted."
+            },
+            url: { type: "string", description: "Repository URL (HTTPS or SSH). Required." },
+            ref: {
+              type: "string",
+              description: "Branch, tag, or commit SHA. Defaults to 'main'."
+            },
+            depth: { type: "number", description: "Shallow clone depth. Defaults to 1." },
+            autoDetect: {
+              type: "boolean",
+              description: "Back-compat flag for standards-based auto-import. Defaults to true when mounts are omitted."
+            },
+            autoImport: {
+              description: "Select which standard-compatible layout profiles to import automatically. Defaults to ['standard', 'claude', 'codex', 'mcp'] when mounts are omitted.",
+              oneOf: [
+                { type: "boolean" },
+                {
+                  type: "string",
+                  enum: ["standard", "claude", "codex", "mcp", "scripts", "legacy-broad"]
+                },
+                {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    enum: ["standard", "claude", "codex", "mcp", "scripts", "legacy-broad"]
+                  }
+                }
+              ]
+            },
+            mounts: {
+              type: "array",
+              description: "Per-kind mount declarations. Optional when autoDetect is enabled; use this for custom repo layouts.",
+              items: {
+                type: "object",
+                properties: {
+                  kind: {
+                    type: "string",
+                    enum: [
+                      "skills",
+                      "commands",
+                      "instructions",
+                      "hooks",
+                      "mcp",
+                      "scripts",
+                      "agents",
+                      "files"
+                    ],
+                    description: "Kind of artifact this mount contributes."
+                  },
+                  from: {
+                    type: "string",
+                    description: "Source path inside the cloned repo. Use '.' for repo root."
+                  },
+                  include: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional whitelist of immediate child names to copy."
+                  }
+                },
+                required: ["kind", "from"]
+              }
+            },
+            instructionFiles: {
+              type: "array",
+              items: { type: "string" },
+              description: "Override the curated root-level agent instruction filenames (default: AGENTS.override.md, AGENTS.md, CLAUDE.md, GEMINI.md, and common rule files)."
+            },
+            tokenSecret: {
+              type: "string",
+              description: "K8s secret name (or ${env:VAR}) for HTTPS token"
+            },
+            sshKeySecret: {
+              type: "string",
+              description: "K8s secret name for SSH private key"
+            }
+          },
+          required: ["url"]
+        }
+      },
+      mountPath: {
+        type: "string",
+        default: "/agent-packs",
+        description: "Container path where pack subdirs are mounted"
+      },
+      poll: {
+        type: "string",
+        description: "Optional poll interval (e.g. '5m', '30s', '1h') for live refresh sidecar. Omit to disable."
+      },
+      slashCommands: {
+        type: "object",
+        description: "Controls automatic Shadow slash command registration for mounted upstream commands and skills.",
+        properties: {
+          autoRegister: {
+            type: "boolean",
+            default: true,
+            description: "Register discovered upstream commands with Shadow."
+          },
+          inferInteractions: {
+            type: "boolean",
+            default: true,
+            description: "Derive form interactions from upstream AskUserQuestion-style markdown."
+          },
+          includeScripts: {
+            type: "boolean",
+            default: true,
+            description: "Register executable helper scripts from mounted script directories as slash commands."
+          },
+          generateScriptSkills: {
+            type: "boolean",
+            default: true,
+            description: "Generate lightweight SKILL.md wrappers for discovered scripts so OpenClaw can load script-backed capabilities."
+          },
+          maxScriptCommandsPerPack: {
+            type: "number",
+            default: 80,
+            description: "Maximum number of script-backed commands to expose per pack."
+          },
+          rules: {
+            type: "array",
+            description: "Optional generic command match rules for aliases or explicit interaction metadata.",
+            items: { type: "object" }
+          }
+        }
+      }
+    }
+  },
+  capabilities: ["config-builder"],
+  tags: ["agent-pack", "skills", "claude", "git", "mechanism", "built-in"],
+  popularity: 90
+};
+
+// src/plugins/agent-pack/index.ts
+var VOLUME_NAME = "agent-packs";
+var SCRIPT_VOLUME_NAME = "agent-pack-scripts";
+var DEFAULT_MOUNT = "/agent-packs";
+var SKILL_LIKE_KINDS = /* @__PURE__ */ new Set(["skills", "commands", "agents"]);
+var validateAgentPackOptions = (() => {
+  const _io0 = (input) => (void 0 === input.packs || Array.isArray(input.packs) && input.packs.every((elem) => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _io1(elem))) && (void 0 === input.mountPath || "string" === typeof input.mountPath) && (void 0 === input.poll || "string" === typeof input.poll || "number" === typeof input.poll) && (void 0 === input.slashCommands || "object" === typeof input.slashCommands && null !== input.slashCommands && false === Array.isArray(input.slashCommands) && _io3(input.slashCommands));
+  const _io1 = (input) => (void 0 === input.id || "string" === typeof input.id) && (void 0 === input.url || "string" === typeof input.url) && (void 0 === input.ref || "string" === typeof input.ref) && (void 0 === input.depth || "number" === typeof input.depth) && (void 0 === input.autoDetect || "boolean" === typeof input.autoDetect) && (null !== input.autoImport && (void 0 === input.autoImport || "standard" === input.autoImport || "claude" === input.autoImport || "codex" === input.autoImport || "mcp" === input.autoImport || "scripts" === input.autoImport || "legacy-broad" === input.autoImport || "boolean" === typeof input.autoImport || Array.isArray(input.autoImport) && input.autoImport.every((elem) => "standard" === elem || "claude" === elem || "codex" === elem || "mcp" === elem || "scripts" === elem || "legacy-broad" === elem))) && (void 0 === input.mounts || Array.isArray(input.mounts) && input.mounts.every((elem) => "object" === typeof elem && null !== elem && _io2(elem))) && (void 0 === input.instructionFiles || Array.isArray(input.instructionFiles) && input.instructionFiles.every((elem) => "string" === typeof elem));
+  const _io2 = (input) => ("mcp" === input.kind || "scripts" === input.kind || "skills" === input.kind || "commands" === input.kind || "instructions" === input.kind || "hooks" === input.kind || "agents" === input.kind || "files" === input.kind) && "string" === typeof input.from && (void 0 === input.include || Array.isArray(input.include) && input.include.every((elem) => "string" === typeof elem));
+  const _io3 = (input) => (void 0 === input.autoRegister || "boolean" === typeof input.autoRegister) && (void 0 === input.inferInteractions || "boolean" === typeof input.inferInteractions) && (void 0 === input.includeScripts || "boolean" === typeof input.includeScripts) && (void 0 === input.generateScriptSkills || "boolean" === typeof input.generateScriptSkills) && (void 0 === input.maxScriptCommandsPerPack || "number" === typeof input.maxScriptCommandsPerPack) && (void 0 === input.rules || Array.isArray(input.rules) && input.rules.every((elem) => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _io4(elem)));
+  const _io4 = (input) => (void 0 === input.match || "object" === typeof input.match && null !== input.match && false === Array.isArray(input.match) && _io5(input.match)) && (void 0 === input.aliases || Array.isArray(input.aliases) && input.aliases.every((elem) => "string" === typeof elem)) && (void 0 === input.interaction || "object" === typeof input.interaction && null !== input.interaction && _io6(input.interaction));
+  const _io5 = (input) => (void 0 === input.packId || "string" === typeof input.packId) && (void 0 === input.name || "string" === typeof input.name) && (void 0 === input.names || Array.isArray(input.names) && input.names.every((elem) => "string" === typeof elem)) && (void 0 === input.namePattern || "string" === typeof input.namePattern) && (null !== input.sourcePathIncludes && (void 0 === input.sourcePathIncludes || "string" === typeof input.sourcePathIncludes || Array.isArray(input.sourcePathIncludes) && input.sourcePathIncludes.every((elem) => "string" === typeof elem)));
+  const _io6 = (input) => ("buttons" === input.kind || "select" === input.kind || "form" === input.kind || "approval" === input.kind) && (void 0 === input.id || "string" === typeof input.id) && (void 0 === input.prompt || "string" === typeof input.prompt) && (void 0 === input.submitLabel || "string" === typeof input.submitLabel) && (void 0 === input.responsePrompt || "string" === typeof input.responsePrompt) && (void 0 === input.approvalCommentLabel || "string" === typeof input.approvalCommentLabel) && (void 0 === input.oneShot || "boolean" === typeof input.oneShot) && (void 0 === input.fields || Array.isArray(input.fields) && input.fields.every((elem) => "object" === typeof elem && null !== elem && _io7(elem)));
+  const _io7 = (input) => "string" === typeof input.id && (void 0 === input.kind || "number" === input.kind || "select" === input.kind || "text" === input.kind || "textarea" === input.kind || "checkbox" === input.kind) && "string" === typeof input.label && (void 0 === input.placeholder || "string" === typeof input.placeholder) && (void 0 === input.defaultValue || "string" === typeof input.defaultValue) && (void 0 === input.required || "boolean" === typeof input.required) && (void 0 === input.maxLength || "number" === typeof input.maxLength);
+  const _vo0 = (input, _path, _exceptionable = true) => [void 0 === input.packs || (Array.isArray(input.packs) || _report(_exceptionable, {
+    path: _path + ".packs",
+    expected: "(Array<PackOption> | undefined)",
+    value: input.packs
+  })) && input.packs.map((elem, _index11) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || _report(_exceptionable, {
+    path: _path + ".packs[" + _index11 + "]",
+    expected: "PackOption",
+    value: elem
+  })) && _vo1(elem, _path + ".packs[" + _index11 + "]", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".packs[" + _index11 + "]",
+    expected: "PackOption",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".packs",
+    expected: "(Array<PackOption> | undefined)",
+    value: input.packs
+  }), void 0 === input.mountPath || "string" === typeof input.mountPath || _report(_exceptionable, {
+    path: _path + ".mountPath",
+    expected: "(string | undefined)",
+    value: input.mountPath
+  }), void 0 === input.poll || "string" === typeof input.poll || "number" === typeof input.poll || _report(_exceptionable, {
+    path: _path + ".poll",
+    expected: "(number | string | undefined)",
+    value: input.poll
+  }), void 0 === input.slashCommands || ("object" === typeof input.slashCommands && null !== input.slashCommands && false === Array.isArray(input.slashCommands) || _report(_exceptionable, {
+    path: _path + ".slashCommands",
+    expected: "(__type | undefined)",
+    value: input.slashCommands
+  })) && _vo3(input.slashCommands, _path + ".slashCommands", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".slashCommands",
+    expected: "(__type | undefined)",
+    value: input.slashCommands
+  })].every((flag) => flag);
+  const _vo1 = (input, _path, _exceptionable = true) => [void 0 === input.id || "string" === typeof input.id || _report(_exceptionable, {
+    path: _path + ".id",
+    expected: "(string | undefined)",
+    value: input.id
+  }), void 0 === input.url || "string" === typeof input.url || _report(_exceptionable, {
+    path: _path + ".url",
+    expected: "(string | undefined)",
+    value: input.url
+  }), void 0 === input.ref || "string" === typeof input.ref || _report(_exceptionable, {
+    path: _path + ".ref",
+    expected: "(string | undefined)",
+    value: input.ref
+  }), void 0 === input.depth || "number" === typeof input.depth || _report(_exceptionable, {
+    path: _path + ".depth",
+    expected: "(number | undefined)",
+    value: input.depth
+  }), void 0 === input.autoDetect || "boolean" === typeof input.autoDetect || _report(_exceptionable, {
+    path: _path + ".autoDetect",
+    expected: "(boolean | undefined)",
+    value: input.autoDetect
+  }), (null !== input.autoImport || _report(_exceptionable, {
+    path: _path + ".autoImport",
+    expected: '("claude" | "codex" | "legacy-broad" | "mcp" | "scripts" | "standard" | Array<AgentPackAutoImportProfile> | boolean | undefined)',
+    value: input.autoImport
+  })) && (void 0 === input.autoImport || "standard" === input.autoImport || "claude" === input.autoImport || "codex" === input.autoImport || "mcp" === input.autoImport || "scripts" === input.autoImport || "legacy-broad" === input.autoImport || "boolean" === typeof input.autoImport || (Array.isArray(input.autoImport) || _report(_exceptionable, {
+    path: _path + ".autoImport",
+    expected: '("claude" | "codex" | "legacy-broad" | "mcp" | "scripts" | "standard" | Array<AgentPackAutoImportProfile> | boolean | undefined)',
+    value: input.autoImport
+  })) && input.autoImport.map((elem, _index12) => "standard" === elem || "claude" === elem || "codex" === elem || "mcp" === elem || "scripts" === elem || "legacy-broad" === elem || _report(_exceptionable, {
+    path: _path + ".autoImport[" + _index12 + "]",
+    expected: '("claude" | "codex" | "legacy-broad" | "mcp" | "scripts" | "standard")',
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".autoImport",
+    expected: '("claude" | "codex" | "legacy-broad" | "mcp" | "scripts" | "standard" | Array<AgentPackAutoImportProfile> | boolean | undefined)',
+    value: input.autoImport
+  })), void 0 === input.mounts || (Array.isArray(input.mounts) || _report(_exceptionable, {
+    path: _path + ".mounts",
+    expected: "(Array<PackMountOption> | undefined)",
+    value: input.mounts
+  })) && input.mounts.map((elem, _index13) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+    path: _path + ".mounts[" + _index13 + "]",
+    expected: "PackMountOption",
+    value: elem
+  })) && _vo2(elem, _path + ".mounts[" + _index13 + "]", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".mounts[" + _index13 + "]",
+    expected: "PackMountOption",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".mounts",
+    expected: "(Array<PackMountOption> | undefined)",
+    value: input.mounts
+  }), void 0 === input.instructionFiles || (Array.isArray(input.instructionFiles) || _report(_exceptionable, {
+    path: _path + ".instructionFiles",
+    expected: "(Array<string> | undefined)",
+    value: input.instructionFiles
+  })) && input.instructionFiles.map((elem, _index14) => "string" === typeof elem || _report(_exceptionable, {
+    path: _path + ".instructionFiles[" + _index14 + "]",
+    expected: "string",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".instructionFiles",
+    expected: "(Array<string> | undefined)",
+    value: input.instructionFiles
+  })].every((flag) => flag);
+  const _vo2 = (input, _path, _exceptionable = true) => ["mcp" === input.kind || "scripts" === input.kind || "skills" === input.kind || "commands" === input.kind || "instructions" === input.kind || "hooks" === input.kind || "agents" === input.kind || "files" === input.kind || _report(_exceptionable, {
+    path: _path + ".kind",
+    expected: '("agents" | "commands" | "files" | "hooks" | "instructions" | "mcp" | "scripts" | "skills")',
+    value: input.kind
+  }), "string" === typeof input.from || _report(_exceptionable, {
+    path: _path + ".from",
+    expected: "string",
+    value: input.from
+  }), void 0 === input.include || (Array.isArray(input.include) || _report(_exceptionable, {
+    path: _path + ".include",
+    expected: "(Array<string> | undefined)",
+    value: input.include
+  })) && input.include.map((elem, _index15) => "string" === typeof elem || _report(_exceptionable, {
+    path: _path + ".include[" + _index15 + "]",
+    expected: "string",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".include",
+    expected: "(Array<string> | undefined)",
+    value: input.include
+  })].every((flag) => flag);
+  const _vo3 = (input, _path, _exceptionable = true) => [void 0 === input.autoRegister || "boolean" === typeof input.autoRegister || _report(_exceptionable, {
+    path: _path + ".autoRegister",
+    expected: "(boolean | undefined)",
+    value: input.autoRegister
+  }), void 0 === input.inferInteractions || "boolean" === typeof input.inferInteractions || _report(_exceptionable, {
+    path: _path + ".inferInteractions",
+    expected: "(boolean | undefined)",
+    value: input.inferInteractions
+  }), void 0 === input.includeScripts || "boolean" === typeof input.includeScripts || _report(_exceptionable, {
+    path: _path + ".includeScripts",
+    expected: "(boolean | undefined)",
+    value: input.includeScripts
+  }), void 0 === input.generateScriptSkills || "boolean" === typeof input.generateScriptSkills || _report(_exceptionable, {
+    path: _path + ".generateScriptSkills",
+    expected: "(boolean | undefined)",
+    value: input.generateScriptSkills
+  }), void 0 === input.maxScriptCommandsPerPack || "number" === typeof input.maxScriptCommandsPerPack || _report(_exceptionable, {
+    path: _path + ".maxScriptCommandsPerPack",
+    expected: "(number | undefined)",
+    value: input.maxScriptCommandsPerPack
+  }), void 0 === input.rules || (Array.isArray(input.rules) || _report(_exceptionable, {
+    path: _path + ".rules",
+    expected: "(Array<PluginSlashCommandRule> | undefined)",
+    value: input.rules
+  })) && input.rules.map((elem, _index16) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || _report(_exceptionable, {
+    path: _path + ".rules[" + _index16 + "]",
+    expected: "PluginSlashCommandRule",
+    value: elem
+  })) && _vo4(elem, _path + ".rules[" + _index16 + "]", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".rules[" + _index16 + "]",
+    expected: "PluginSlashCommandRule",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".rules",
+    expected: "(Array<PluginSlashCommandRule> | undefined)",
+    value: input.rules
+  })].every((flag) => flag);
+  const _vo4 = (input, _path, _exceptionable = true) => [void 0 === input.match || ("object" === typeof input.match && null !== input.match && false === Array.isArray(input.match) || _report(_exceptionable, {
+    path: _path + ".match",
+    expected: "(__type.o1 | undefined)",
+    value: input.match
+  })) && _vo5(input.match, _path + ".match", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".match",
+    expected: "(__type.o1 | undefined)",
+    value: input.match
+  }), void 0 === input.aliases || (Array.isArray(input.aliases) || _report(_exceptionable, {
+    path: _path + ".aliases",
+    expected: "(Array<string> | undefined)",
+    value: input.aliases
+  })) && input.aliases.map((elem, _index17) => "string" === typeof elem || _report(_exceptionable, {
+    path: _path + ".aliases[" + _index17 + "]",
+    expected: "string",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".aliases",
+    expected: "(Array<string> | undefined)",
+    value: input.aliases
+  }), void 0 === input.interaction || ("object" === typeof input.interaction && null !== input.interaction || _report(_exceptionable, {
+    path: _path + ".interaction",
+    expected: "(PluginSlashCommandInteraction | undefined)",
+    value: input.interaction
+  })) && _vo6(input.interaction, _path + ".interaction", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".interaction",
+    expected: "(PluginSlashCommandInteraction | undefined)",
+    value: input.interaction
+  })].every((flag) => flag);
+  const _vo5 = (input, _path, _exceptionable = true) => [void 0 === input.packId || "string" === typeof input.packId || _report(_exceptionable, {
+    path: _path + ".packId",
+    expected: "(string | undefined)",
+    value: input.packId
+  }), void 0 === input.name || "string" === typeof input.name || _report(_exceptionable, {
+    path: _path + ".name",
+    expected: "(string | undefined)",
+    value: input.name
+  }), void 0 === input.names || (Array.isArray(input.names) || _report(_exceptionable, {
+    path: _path + ".names",
+    expected: "(Array<string> | undefined)",
+    value: input.names
+  })) && input.names.map((elem, _index18) => "string" === typeof elem || _report(_exceptionable, {
+    path: _path + ".names[" + _index18 + "]",
+    expected: "string",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".names",
+    expected: "(Array<string> | undefined)",
+    value: input.names
+  }), void 0 === input.namePattern || "string" === typeof input.namePattern || _report(_exceptionable, {
+    path: _path + ".namePattern",
+    expected: "(string | undefined)",
+    value: input.namePattern
+  }), (null !== input.sourcePathIncludes || _report(_exceptionable, {
+    path: _path + ".sourcePathIncludes",
+    expected: "(Array<string> | string | undefined)",
+    value: input.sourcePathIncludes
+  })) && (void 0 === input.sourcePathIncludes || "string" === typeof input.sourcePathIncludes || (Array.isArray(input.sourcePathIncludes) || _report(_exceptionable, {
+    path: _path + ".sourcePathIncludes",
+    expected: "(Array<string> | string | undefined)",
+    value: input.sourcePathIncludes
+  })) && input.sourcePathIncludes.map((elem, _index19) => "string" === typeof elem || _report(_exceptionable, {
+    path: _path + ".sourcePathIncludes[" + _index19 + "]",
+    expected: "string",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".sourcePathIncludes",
+    expected: "(Array<string> | string | undefined)",
+    value: input.sourcePathIncludes
+  }))].every((flag) => flag);
+  const _vo6 = (input, _path, _exceptionable = true) => ["buttons" === input.kind || "select" === input.kind || "form" === input.kind || "approval" === input.kind || _report(_exceptionable, {
+    path: _path + ".kind",
+    expected: '("approval" | "buttons" | "form" | "select")',
+    value: input.kind
+  }), void 0 === input.id || "string" === typeof input.id || _report(_exceptionable, {
+    path: _path + ".id",
+    expected: "(string | undefined)",
+    value: input.id
+  }), void 0 === input.prompt || "string" === typeof input.prompt || _report(_exceptionable, {
+    path: _path + ".prompt",
+    expected: "(string | undefined)",
+    value: input.prompt
+  }), void 0 === input.submitLabel || "string" === typeof input.submitLabel || _report(_exceptionable, {
+    path: _path + ".submitLabel",
+    expected: "(string | undefined)",
+    value: input.submitLabel
+  }), void 0 === input.responsePrompt || "string" === typeof input.responsePrompt || _report(_exceptionable, {
+    path: _path + ".responsePrompt",
+    expected: "(string | undefined)",
+    value: input.responsePrompt
+  }), void 0 === input.approvalCommentLabel || "string" === typeof input.approvalCommentLabel || _report(_exceptionable, {
+    path: _path + ".approvalCommentLabel",
+    expected: "(string | undefined)",
+    value: input.approvalCommentLabel
+  }), void 0 === input.oneShot || "boolean" === typeof input.oneShot || _report(_exceptionable, {
+    path: _path + ".oneShot",
+    expected: "(boolean | undefined)",
+    value: input.oneShot
+  }), void 0 === input.fields || (Array.isArray(input.fields) || _report(_exceptionable, {
+    path: _path + ".fields",
+    expected: "(Array<PluginSlashCommandInteractionField> | undefined)",
+    value: input.fields
+  })) && input.fields.map((elem, _index20) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+    path: _path + ".fields[" + _index20 + "]",
+    expected: "PluginSlashCommandInteractionField",
+    value: elem
+  })) && _vo7(elem, _path + ".fields[" + _index20 + "]", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".fields[" + _index20 + "]",
+    expected: "PluginSlashCommandInteractionField",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".fields",
+    expected: "(Array<PluginSlashCommandInteractionField> | undefined)",
+    value: input.fields
+  })].every((flag) => flag);
+  const _vo7 = (input, _path, _exceptionable = true) => ["string" === typeof input.id || _report(_exceptionable, {
+    path: _path + ".id",
+    expected: "string",
+    value: input.id
+  }), void 0 === input.kind || "number" === input.kind || "select" === input.kind || "text" === input.kind || "textarea" === input.kind || "checkbox" === input.kind || _report(_exceptionable, {
+    path: _path + ".kind",
+    expected: '("checkbox" | "number" | "select" | "text" | "textarea" | undefined)',
+    value: input.kind
+  }), "string" === typeof input.label || _report(_exceptionable, {
+    path: _path + ".label",
+    expected: "string",
+    value: input.label
+  }), void 0 === input.placeholder || "string" === typeof input.placeholder || _report(_exceptionable, {
+    path: _path + ".placeholder",
+    expected: "(string | undefined)",
+    value: input.placeholder
+  }), void 0 === input.defaultValue || "string" === typeof input.defaultValue || _report(_exceptionable, {
+    path: _path + ".defaultValue",
+    expected: "(string | undefined)",
+    value: input.defaultValue
+  }), void 0 === input.required || "boolean" === typeof input.required || _report(_exceptionable, {
+    path: _path + ".required",
+    expected: "(boolean | undefined)",
+    value: input.required
+  }), void 0 === input.maxLength || "number" === typeof input.maxLength || _report(_exceptionable, {
+    path: _path + ".maxLength",
+    expected: "(number | undefined)",
+    value: input.maxLength
+  })].every((flag) => flag);
+  const __is = (input) => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input);
+  let errors;
+  let _report;
+  return __typia_transform__createStandardSchema._createStandardSchema((input) => {
+    if (false === __is(input)) {
+      errors = [];
+      _report = __typia_transform__validateReport._validateReport(errors);
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 && false === Array.isArray(input2) || _report(true, {
+        path: _path + "",
+        expected: "AgentPackOptions",
+        value: input2
+      })) && _vo0(input2, _path + "", true) || _report(true, {
+        path: _path + "",
+        expected: "AgentPackOptions",
+        value: input2
+      }))(input, "$input", true);
+      const success = 0 === errors.length;
+      return success ? {
+        success,
+        data: input
+      } : {
+        success,
+        errors,
+        data: input
+      };
+    }
+    return {
+      success: true,
+      data: input
+    };
+  });
+})();
+var DEFAULT_AUTO_IMPORT_PROFILES = [
+  "standard",
+  "claude",
+  "codex",
+  "mcp"
+];
+var AUTO_MOUNT_PROFILES = {
+  standard: [
+    // Agent Skills / OpenClaw-compatible SKILL.md layouts.
+    { kind: "skills", from: "." },
+    { kind: "skills", from: "skills" },
+    { kind: "skills", from: ".agents/skills" },
+    { kind: "skills", from: "agent-skills" },
+    { kind: "skills", from: "agent_skills" },
+    { kind: "skills", from: "openclaw/skills" }
+  ],
+  claude: [
+    // Claude Code skills, commands, subagents, hooks, and root instructions.
+    { kind: "skills", from: ".claude/skills" },
+    { kind: "commands", from: "commands" },
+    { kind: "commands", from: ".claude/commands" },
+    { kind: "agents", from: "agents" },
+    { kind: "agents", from: ".claude/agents" },
+    { kind: "hooks", from: "hooks" },
+    { kind: "instructions", from: "." },
+    { kind: "hooks", from: ".claude/hooks" },
+    { kind: "hooks", from: ".claude/settings.json" }
+  ],
+  codex: [
+    // Codex repo skills, AGENTS.md guidance, and custom agent TOML files.
+    { kind: "skills", from: ".codex/skills" },
+    { kind: "skills", from: ".agents/skills" },
+    { kind: "agents", from: ".codex/agents" },
+    { kind: "instructions", from: "." }
+  ],
+  mcp: [
+    { kind: "mcp", from: ".mcp.json" },
+    { kind: "mcp", from: ".mcp" },
+    { kind: "mcp", from: ".claude/mcp.json" },
+    { kind: "mcp", from: ".cursor/mcp.json" },
+    { kind: "mcp", from: ".vscode/mcp.json" },
+    { kind: "mcp", from: "mcp.json" },
+    { kind: "mcp", from: "mcp" }
+  ],
+  scripts: [
+    { kind: "scripts", from: "bin" },
+    { kind: "scripts", from: "scripts" },
+    { kind: "scripts", from: "setup" },
+    { kind: "scripts", from: "setup.sh" },
+    { kind: "scripts", from: "install" },
+    { kind: "scripts", from: "install.sh" },
+    { kind: "scripts", from: "bootstrap" },
+    { kind: "scripts", from: "bootstrap.sh" }
+  ],
+  "legacy-broad": [
+    // Historical broad scan profile. Kept as an explicit opt-in for templates
+    // that intentionally treat a whole repo as an agent pack.
+    { kind: "skills", from: "skills" },
+    { kind: "skills", from: ".agents/skills" },
+    { kind: "skills", from: ".codex/skills" },
+    { kind: "skills", from: ".claude/skills" },
+    { kind: "skills", from: ".claude/plugins" },
+    { kind: "skills", from: ".cursor/skills" },
+    { kind: "skills", from: ".gemini/skills" },
+    { kind: "skills", from: ".windsurf/skills" },
+    { kind: "skills", from: "openclaw/skills" },
+    { kind: "skills", from: "agent-skills" },
+    { kind: "skills", from: "agent_skills" },
+    { kind: "skills", from: "claude-skills" },
+    { kind: "skills", from: "claude/skills" },
+    { kind: "skills", from: "scientific-skills" },
+    { kind: "skills", from: "plugins" },
+    { kind: "skills", from: "extensions" },
+    { kind: "skills", from: "." },
+    // Slash-command and subagent workspaces.
+    { kind: "commands", from: "commands" },
+    { kind: "commands", from: "slash-commands" },
+    { kind: "commands", from: ".agents/commands" },
+    { kind: "commands", from: ".codex/commands" },
+    { kind: "commands", from: ".claude/commands" },
+    { kind: "commands", from: ".cursor/commands" },
+    { kind: "commands", from: ".gemini/commands" },
+    { kind: "commands", from: ".windsurf/commands" },
+    { kind: "commands", from: "plugins" },
+    { kind: "commands", from: "extensions" },
+    { kind: "agents", from: "agents" },
+    { kind: "agents", from: ".agents" },
+    { kind: "agents", from: ".agents/agents" },
+    { kind: "agents", from: ".codex/agents" },
+    { kind: "agents", from: ".claude/agents" },
+    { kind: "agents", from: ".claude/subagents" },
+    { kind: "agents", from: ".cursor/agents" },
+    { kind: "agents", from: ".gemini/agents" },
+    { kind: "agents", from: ".windsurf/agents" },
+    { kind: "agents", from: "subagents" },
+    { kind: "agents", from: "plugins" },
+    { kind: "agents", from: "extensions" },
+    // Human-readable methodology and project context.
+    { kind: "instructions", from: "." },
+    { kind: "instructions", from: "context" },
+    { kind: "instructions", from: "docs" },
+    { kind: "instructions", from: "openclaw" },
+    { kind: "instructions", from: ".agents" },
+    { kind: "instructions", from: ".codex" },
+    { kind: "instructions", from: ".claude" },
+    { kind: "instructions", from: ".github/copilot-instructions.md" },
+    { kind: "instructions", from: ".github/instructions" },
+    { kind: "instructions", from: ".github/prompts" },
+    { kind: "instructions", from: ".github/chatmodes" },
+    { kind: "instructions", from: ".cursor/rules" },
+    { kind: "instructions", from: ".cursorrules" },
+    { kind: "instructions", from: ".windsurf/rules" },
+    { kind: "instructions", from: ".windsurfrules" },
+    { kind: "instructions", from: ".clinerules" },
+    { kind: "instructions", from: "rules" },
+    { kind: "instructions", from: "rules.md" },
+    { kind: "instructions", from: "instructions" },
+    { kind: "instructions", from: "prompts" },
+    { kind: "instructions", from: "playbooks" },
+    { kind: "instructions", from: "specs" },
+    { kind: "instructions", from: "workflow" },
+    { kind: "instructions", from: "workflows" },
+    { kind: "instructions", from: "knowledge" },
+    { kind: "instructions", from: "knowledge-base" },
+    { kind: "instructions", from: "memory-bank" },
+    { kind: "instructions", from: "memory" },
+    { kind: "instructions", from: "second-brain" },
+    { kind: "instructions", from: "strategy" },
+    { kind: "instructions", from: "ops" },
+    { kind: "instructions", from: ".claude/commands" },
+    { kind: "instructions", from: ".claude/agents" },
+    // Hooks, MCP, helper binaries, and heavier repo assets.
+    { kind: "hooks", from: "hooks" },
+    { kind: "hooks", from: ".agents/hooks" },
+    { kind: "hooks", from: ".codex/hooks" },
+    { kind: "hooks", from: ".claude/hooks" },
+    { kind: "hooks", from: ".claude/settings.json" },
+    { kind: "hooks", from: ".claude/settings.local.json" },
+    { kind: "hooks", from: ".cursor/hooks" },
+    { kind: "hooks", from: ".cursor/hooks.json" },
+    { kind: "mcp", from: ".mcp.json" },
+    { kind: "mcp", from: ".mcp" },
+    { kind: "mcp", from: ".claude/mcp.json" },
+    { kind: "mcp", from: ".cursor/mcp.json" },
+    { kind: "mcp", from: ".vscode/mcp.json" },
+    { kind: "mcp", from: "mcp.json" },
+    { kind: "mcp", from: "mcp" },
+    { kind: "scripts", from: "bin" },
+    { kind: "scripts", from: "scripts" },
+    { kind: "scripts", from: "setup" },
+    { kind: "scripts", from: "setup.sh" },
+    { kind: "scripts", from: "install" },
+    { kind: "scripts", from: "install.sh" },
+    { kind: "scripts", from: "bootstrap" },
+    { kind: "scripts", from: "bootstrap.sh" },
+    { kind: "files", from: "data_sources" },
+    { kind: "files", from: "data-sources" },
+    { kind: "files", from: "data" },
+    { kind: "files", from: "examples" },
+    { kind: "files", from: "templates" },
+    { kind: "files", from: "notebooks" }
+  ]
+};
+function deriveIdFromUrl(url) {
+  const m = url.match(/[/:]([^/:]+)\/([^/]+?)(\.git)?\/?$/);
+  if (m)
+    return sanitizeId(`${m[1]}-${m[2]}`);
+  return sanitizeId(url);
+}
+function readOptions(agent) {
+  const entry = agent.use?.find((u) => u.plugin === "agent-pack");
+  if (!entry?.options)
+    return null;
+  return entry.options;
+}
+function normalizeAutoImportProfiles(pack) {
+  if (pack.autoImport === false || pack.autoDetect === false)
+    return [];
+  const configured = pack.autoImport;
+  if (configured === true)
+    return [...DEFAULT_AUTO_IMPORT_PROFILES];
+  if (typeof configured === "string")
+    return [configured];
+  if (Array.isArray(configured))
+    return configured;
+  if (pack.autoDetect === true || !pack.mounts?.length)
+    return [...DEFAULT_AUTO_IMPORT_PROFILES];
+  return [];
+}
+function dedupeMounts(mounts) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const mount of mounts) {
+    const key = `${mount.kind}:${mount.from}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    out.push(mount);
+  }
+  return out;
+}
+function buildAgentPackPrompt(packs, mountPath) {
+  const lines = [
+    "## Mounted Agent Packs",
+    "",
+    "Treat the following mounted packs as source-of-truth context whenever they are relevant to the user request:",
+    ""
+  ];
+  for (const pack of packs) {
+    if (pack.autoDetect) {
+      const profiles = pack.autoImportProfiles?.length ? pack.autoImportProfiles.join(", ") : "standard-compatible";
+      lines.push(`- **${pack.id}** \u2014 auto-imported ${profiles} layouts under \`${mountPath}/${pack.id}/{skills,commands,agents,instructions,hooks,mcp,scripts,files}\``);
+      continue;
+    }
+    const mountDirs = /* @__PURE__ */ new Map();
+    for (const mount of pack.mounts) {
+      const dirs = mountDirs.get(mount.kind) ?? /* @__PURE__ */ new Set();
+      dirs.add(`${mountPath}/${pack.id}/${mount.kind}`);
+      mountDirs.set(mount.kind, dirs);
+    }
+    const mountSummary = [...mountDirs.entries()].flatMap(([kind, dirs]) => [...dirs].map((dir) => `${kind}: \`${dir}\``)).join("; ");
+    lines.push(`- **${pack.id}** \u2014 ${mountSummary}`);
+  }
+  lines.push("", "When one of these packs is relevant:", "1. Read the most relevant markdown files under that pack's `instructions/` directory before answering, when present.", "2. If direct pack paths are unavailable in the model sandbox, read the consolidated workspace file `PACK_INSTRUCTIONS.md`.", "3. Use the mounted pack skills, commands, or sub-agents instead of improvising from memory.", "4. If the pack exposes `hooks/bootstrap.md` or `hooks/teardown.md`, follow those procedures when applicable.", "5. Run helper scripts from the mounted `scripts/` directory using absolute paths when they are useful.", "6. Cite the pack id and the exact skill, instruction file, or procedure you relied on.");
+  return lines.join("\n");
+}
+function resolvePacks(opts) {
+  const packs = opts.packs ?? [];
+  const resolved = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const p of packs) {
+    if (!p.url)
+      continue;
+    const id = sanitizeId(p.id ?? deriveIdFromUrl(p.url));
+    if (seen.has(id))
+      continue;
+    seen.add(id);
+    const autoImportProfiles = normalizeAutoImportProfiles(p);
+    const autoDetect = autoImportProfiles.length > 0;
+    const mounts = dedupeMounts([
+      ...(p.mounts ?? []).map((m) => ({
+        kind: m.kind,
+        from: m.from,
+        include: m.include
+      })),
+      ...autoImportProfiles.flatMap((profile) => (AUTO_MOUNT_PROFILES[profile] ?? []).map((mount) => ({ ...mount })))
+    ]);
+    if (mounts.length === 0)
+      continue;
+    resolved.push({
+      id,
+      url: p.url,
+      ref: p.ref ?? "main",
+      depth: p.depth ?? 1,
+      autoDetect,
+      autoImportProfiles,
+      mounts,
+      instructionFiles: p.instructionFiles ?? DEFAULT_INSTRUCTION_FILES
+    });
+  }
+  return resolved;
+}
+var agentPackK8sProvider = {
+  buildK8s(agent, _ctx) {
+    const entry = agent.use?.find((u) => u.plugin === "agent-pack");
+    if (!entry?.options)
+      return void 0;
+    const opts = entry.options;
+    const packs = resolvePacks(opts);
+    if (packs.length === 0)
+      return void 0;
+    const mountPath = opts.mountPath ?? DEFAULT_MOUNT;
+    const slashCommands = opts.slashCommands ?? {};
+    const autoRegisterSlashCommands = slashCommands.autoRegister ?? true;
+    const slashCommandIndex = autoRegisterSlashCommands ? {
+      enabled: true,
+      outputPath: agentPackSlashCommandsIndexPath(mountPath),
+      inferInteractions: slashCommands.inferInteractions ?? true,
+      includeScripts: slashCommands.includeScripts ?? true,
+      generateScriptSkills: slashCommands.generateScriptSkills ?? true,
+      maxScriptCommandsPerPack: slashCommands.maxScriptCommandsPerPack,
+      rules: slashCommands.rules
+    } : void 0;
+    const initContainer = buildAgentPackInitContainer(packs, mountPath, VOLUME_NAME, SCRIPT_VOLUME_NAME, slashCommandIndex);
+    const scriptConfigMapName = `${agent.id}-agent-pack-scripts`;
+    const byKind = /* @__PURE__ */ new Map();
+    for (const p of packs) {
+      for (const m of p.mounts) {
+        const dirs = byKind.get(m.kind) ?? /* @__PURE__ */ new Set();
+        dirs.add(`${mountPath}/${p.id}/${m.kind}`);
+        byKind.set(m.kind, dirs);
+      }
+    }
+    const envVars = [];
+    const envForKind = {
+      skills: "SHADOW_PACK_SKILLS_DIRS",
+      instructions: "SHADOW_PACK_INSTRUCTIONS_DIRS",
+      commands: "SHADOW_PACK_COMMANDS_DIRS",
+      hooks: "SHADOW_PACK_HOOKS_DIRS",
+      mcp: "SHADOW_PACK_MCP_DIRS",
+      scripts: "SHADOW_PACK_SCRIPTS_DIRS",
+      files: "SHADOW_PACK_FILES_DIRS",
+      agents: "SHADOW_PACK_AGENTS_DIRS"
+    };
+    for (const [kind, dirs] of byKind) {
+      const name = envForKind[kind];
+      if (name)
+        envVars.push({ name, value: [...dirs].join(":") });
+    }
+    envVars.push({ name: "SHADOW_PACK_MOUNT_ROOT", value: mountPath });
+    const result = {
+      initContainers: [initContainer],
+      configMaps: [
+        {
+          name: scriptConfigMapName,
+          data: {
+            "init.sh": buildAgentPackInitScript(packs, mountPath, slashCommandIndex),
+            "sync.sh": buildAgentPackSyncScript({
+              packs,
+              mountPath,
+              intervalSec: parsePollInterval(opts.poll),
+              slashCommandIndex
+            })
+          },
+          labels: {
+            app: "shadowob-cloud",
+            agent: agent.id
+          }
+        }
+      ],
+      volumes: [
+        { name: VOLUME_NAME, spec: { emptyDir: {} } },
+        {
+          name: SCRIPT_VOLUME_NAME,
+          spec: {
+            configMap: {
+              name: scriptConfigMapName,
+              defaultMode: 493
+            }
+          }
+        }
+      ],
+      volumeMounts: [{ name: VOLUME_NAME, mountPath, readOnly: false }],
+      envVars,
+      labels: {
+        "agent-pack.packs": packs.map((p) => p.id).join("_").slice(0, 63)
+      }
+    };
+    const sidecar = buildAgentPackSyncSidecar({
+      packs,
+      mountPath,
+      volumeName: VOLUME_NAME,
+      scriptVolumeName: SCRIPT_VOLUME_NAME,
+      intervalSec: parsePollInterval(opts.poll),
+      slashCommandIndex
+    });
+    if (sidecar)
+      result.sidecars = [sidecar];
+    return result;
+  }
+};
+var plugin = definePlugin(manifest_default, (api) => {
+  api.onBuildConfig((context) => {
+    const opts = readOptions(context.agent);
+    if (!opts)
+      return {};
+    const packs = resolvePacks(opts);
+    if (packs.length === 0)
+      return {};
+    const mountPath = opts.mountPath ?? DEFAULT_MOUNT;
+    const extraDirs = [];
+    for (const p of packs) {
+      for (const m of p.mounts) {
+        if (SKILL_LIKE_KINDS.has(m.kind)) {
+          extraDirs.push(`${mountPath}/${p.id}/${m.kind}`);
+        }
+      }
+    }
+    if (extraDirs.length === 0)
+      return {};
+    return {
+      skills: {
+        load: { extraDirs: [...new Set(extraDirs)] }
+      }
+    };
+  });
+  api.onBuildPrompt((context) => {
+    const opts = readOptions(context.agent);
+    if (!opts)
+      return;
+    const packs = resolvePacks(opts);
+    if (packs.length === 0)
+      return;
+    const mountPath = opts.mountPath ?? DEFAULT_MOUNT;
+    return buildAgentPackPrompt(packs, mountPath);
+  });
+  api.onBuildRuntime((context) => {
+    const opts = readOptions(context.agent);
+    if (!opts)
+      return;
+    const packs = resolvePacks(opts);
+    if (packs.length === 0)
+      return;
+    const slashCommands = opts.slashCommands ?? {};
+    const autoRegister = slashCommands.autoRegister ?? true;
+    if (!autoRegister)
+      return;
+    return {
+      artifacts: [
+        {
+          kind: "shadow.slashCommands",
+          path: agentPackSlashCommandsIndexPath(opts.mountPath ?? DEFAULT_MOUNT),
+          mediaType: "application/json"
+        }
+      ]
+    };
+  });
+  api.onValidate((context) => {
+    const opts = readOptions(context.agent);
+    if (!opts)
+      return;
+    const shape = validateAgentPackOptions(opts);
+    const packs = opts.packs ?? [];
+    const errors = [];
+    if (!shape.success) {
+      errors.push(...shape.errors.map((error) => ({
+        path: `use.agent-pack.options${error.path}`,
+        message: error.expected,
+        severity: "error"
+      })));
+    }
+    packs.forEach((p, i) => {
+      if (!p.url) {
+        errors.push({
+          path: `use.agent-pack.packs[${i}].url`,
+          message: 'Each pack must specify a git "url".',
+          severity: "error"
+        });
+      }
+      const autoImportDisabled = p.autoDetect === false || p.autoImport === false || Array.isArray(p.autoImport) && p.autoImport.length === 0;
+      if ((!p.mounts || p.mounts.length === 0) && autoImportDisabled) {
+        errors.push({
+          path: `use.agent-pack.packs[${i}].mounts`,
+          message: "Each pack must declare at least one mount when automatic import is disabled.",
+          severity: "error"
+        });
+      } else if (p.mounts) {
+        p.mounts.forEach((m, j) => {
+          if (!m.kind || m.from == null) {
+            errors.push({
+              path: `use.agent-pack.packs[${i}].mounts[${j}]`,
+              message: 'Each mount requires both "kind" and "from".',
+              severity: "error"
+            });
+          }
+        });
+      }
+    });
+    if (errors.length > 0)
+      return { valid: false, errors };
+  });
+});
+plugin.k8s = agentPackK8sProvider;
+var agent_pack_default = plugin;
+export {
+  buildAgentPackPrompt,
+  agent_pack_default as default,
+  resolvePacks,
+  validateAgentPackOptions
+};