@agentprojectcontext/apx 1.80.2 → 1.89.1

package/src/core/apc/agent-rename-refs.js

@@ -0,0 +1,187 @@
+// Repointing every LIVE reference to an agent's slug, in one place.
+//
+// The slug is the agent's physical key: it names the definition file and the
+// runtime dir (agent-write.js moves those), but it is ALSO written into stores
+// that live nowhere near the agent — a group roster, a Telegram route, a task's
+// assignee, a delivery waiting to be crossed off. Moving the files and stopping
+// there is what made a rename look successful and quietly break half the
+// install: the agent kept its chats and lost its rooms, its telegram channel,
+// its queue and its open tasks.
+//
+// The line this module draws: a POINTER is repointed, a RECORD is not.
+//   pointer — something that has to resolve to a live agent for the system to
+//             work (roster, route, assignee, queue key, RAG scope). Repointed.
+//   record  — something that says what happened at a moment (`agent_slug` on a
+//             ledger row, the attribution on a past turn, a2a thread keys).
+//             Left alone: rewriting it would falsify history, and nothing
+//             resolves it to act.
+//
+// Everything here is best-effort per store: a project with no routines, no
+// queue or no telegram config is the normal case, and one unreadable store must
+// never abort a rename that already moved files.
+import fs from "node:fs";
+import path from "node:path";
+
+import { renameRoutineAgent } from "#core/stores/routines.js";
+import { renameGroupParticipant } from "#core/stores/messages.js";
+import { listTasks, patchTask } from "#core/stores/tasks.js";
+import { renameDeliveryAgent } from "#core/stores/deliveries.js";
+import { listCodeSessions, updateCodeSession } from "#core/stores/code-sessions.js";
+import { readConfig, writeConfig } from "#core/config/index.js";
+import { readJson, writeJson } from "#core/util/json-file.js";
+import { apcProjectConfigFile } from "./paths.js";
+
+/** Registry entries reach us either as daemon entries (`storagePath`) or as the
+ *  `projects.list()` shape (`storage_path`). Accept both, drop the useless. */
+function normalizeProjects(list) {
+  return (Array.isArray(list) ? list : [])
+    .map((e) => ({
+      id: e?.id,
+      path: e?.path || null,
+      storagePath: e?.storagePath || e?.storage_path || null,
+    }))
+    .filter((e) => e.storagePath || e.path);
+}
+
+const samePath = (a, b) => {
+  if (!a || !b) return false;
+  try { return path.resolve(a) === path.resolve(b); } catch { return false; }
+};
+
+/**
+ * Repoint every live pointer that names `oldSlug` in this project.
+ *
+ * @param {{id?:any, path:string, storagePath?:string, apxId?:string}} project
+ * @param {string} oldSlug
+ * @param {string} newSlug
+ * @param {{projects?:object[]}} [opts]  the daemon's registry, when the caller
+ *   has one. It buys two things nothing else can: rooms hosted by ANOTHER
+ *   project that include this agent, and knowing which project a Telegram
+ *   channel without an explicit `project` would fall back to.
+ * @returns {Promise<Record<string, number>>} what moved, per store — the route
+ *   logs it and the tests assert on it.
+ */
+export async function repointAgentReferences(project, oldSlug, newSlug, { projects = null } = {}) {
+  const storage = project?.storagePath || project?.path;
+  const registry = normalizeProjects(projects);
+  const moved = {
+    routines: 0, groups: 0, tasks: 0, deliveries: 0,
+    code_sessions: 0, telegram: 0, project_config: 0, memory_index: 0,
+  };
+  if (!storage || !oldSlug || !newSlug || oldSlug === newSlug) return moved;
+
+  // 1) Routines — `spec.agent` is what the scheduler executes.
+  try { moved.routines = renameRoutineAgent(storage, oldSlug, newSlug); } catch { /* no store */ }
+
+  // 2) Group rooms. The roster is the latest control row; here, plus any room
+  //    hosted by another project whose `homes` map says this agent lives here.
+  try {
+    moved.groups += renameGroupParticipant(storage, oldSlug, newSlug, {
+      homeId: project?.id ?? null, hostId: project?.id ?? null,
+    });
+  } catch { /* no ledger */ }
+  for (const entry of registry) {
+    if (project?.id == null || String(entry.id) === String(project.id)) continue;
+    const otherStore = entry.storagePath || entry.path;
+    if (!otherStore || samePath(otherStore, storage)) continue;
+    try {
+      moved.groups += renameGroupParticipant(otherStore, oldSlug, newSlug, {
+        homeId: project.id, hostId: entry.id,
+      });
+    } catch { /* skip a project we cannot read */ }
+  }
+
+  // 3) Tasks — the assignee, in every state. A done task assigned to this agent
+  //    is still assigned to this agent; only its slug changed.
+  try {
+    for (const t of listTasks(storage, { state: "all", agent: oldSlug })) {
+      patchTask(storage, t.id, { agent: newSlug });
+      moved.tasks += 1;
+    }
+  } catch { /* no task log */ }
+
+  // 4) The delivery queue.
+  try { moved.deliveries = renameDeliveryAgent(storage, oldSlug, newSlug); } catch { /* no queue */ }
+
+  // 5) Code sessions owned by this agent.
+  try {
+    for (const s of listCodeSessions(storage)) {
+      if (s.agentSlug !== oldSlug) continue;
+      updateCodeSession(storage, s.id, { agentSlug: newSlug });
+      moved.code_sessions += 1;
+    }
+  } catch { /* no code sessions */ }
+
+  // 6) Telegram routing in the global config. A channel names its project by
+  //    path, so only a channel pointing HERE is repointed — two projects may
+  //    each own an agent with this slug. The bare `telegram.route_to_agent` is
+  //    only live in env-only mode (resolveChannels falls back to it when no
+  //    channels are configured), and it targets the first registered project.
+  try {
+    const cfg = readConfig();
+    const tg = cfg.telegram || {};
+    let touched = 0;
+    const channels = Array.isArray(tg.channels) ? tg.channels : [];
+    for (const c of channels) {
+      if (c?.route_to_agent === oldSlug && samePath(c.project, project?.path)) {
+        c.route_to_agent = newSlug;
+        touched += 1;
+      }
+    }
+    if (
+      !channels.length && tg.route_to_agent === oldSlug &&
+      registry.length && samePath(registry[0].path, project?.path)
+    ) {
+      tg.route_to_agent = newSlug;
+      touched += 1;
+    }
+    if (touched) {
+      cfg.telegram = tg;
+      writeConfig(cfg);
+      moved.telegram = touched;
+    }
+  } catch { /* config unreadable — leave it alone */ }
+
+  // 7) The project's own `.apc/config.json`: its telegram override and any
+  //    declarative routine. Project-scoped by definition, so no path matching.
+  try {
+    const file = apcProjectConfigFile(project.path);
+    if (fs.existsSync(file)) {
+      const cfg = readJson(file, null);
+      let touched = 0;
+      if (cfg && typeof cfg === "object") {
+        if (cfg.telegram?.route_to_agent === oldSlug) {
+          cfg.telegram.route_to_agent = newSlug;
+          touched += 1;
+        }
+        for (const r of Array.isArray(cfg.routines) ? cfg.routines : []) {
+          if (r?.agent === oldSlug) {
+            r.agent = newSlug;
+            touched += 1;
+          }
+        }
+        if (touched) {
+          writeJson(file, cfg);
+          moved.project_config = touched;
+        }
+      }
+    }
+  } catch { /* not a valid project config */ }
+
+  // 8) The RAG index. Agent memory is indexed under `agent:<projdir>:<slug>`;
+  //    the next pass re-indexes memory.md under the new key on its own, so what
+  //    is left to do is DROP the old rows — otherwise they linger unreachable
+  //    and, worse, get inherited by whoever takes that slug next.
+  //    Imported lazily: agent-write is on the CLI's load path and the memory
+  //    subsystem (sqlite, embedders) has no business being pulled in with it.
+  const apxId = project?.apxId || project?.apx_id || null;
+  if (apxId) {
+    try {
+      const { getMemoryStore } = await import("#core/memory/index.js");
+      const store = await getMemoryStore();
+      moved.memory_index = store?.dropChannel?.(`agent:${apxId}:${oldSlug}`) || 0;
+    } catch { /* memory disabled or unavailable */ }
+  }
+
+  return moved;
+}

package/src/core/apc/agent-write.js

@@ -0,0 +1,312 @@
+// Creating and re-prompting a project agent — the write side of the agent
+// lifecycle, in ONE place (rule 8). The daemon route (host/daemon/api/agents.js)
+// and the super-agent's `create_agent` / `set_agent_prompt` tools both call
+// here, so slug validation, avatar assignment and field normalization can never
+// drift between the surfaces.
+//
+// The super-agent used to have NO native way to build an agent: asked to create
+// one, it shelled out to `apx agent add` (awkward for a long, multi-line system
+// prompt) and, when that produced a body-less agent, patched over it by hand-
+// writing the `.md` — the exact anti-pattern the apx-agent skill warns against.
+// These functions are what the native tools stand on so that never has to happen.
+import fs from "node:fs";
+import path from "node:path";
+import { readAgents } from "#core/apc/parser.js";
+import { apcAgentFile } from "#core/apc/paths.js";
+import { writeAgentFile, ensureAgentDir, removeImportedAgent } from "#core/apc/scaffold.js";
+import { ensureAgentRuntimeDir, agentMemoryPath, agentRuntimeDir, readAgentMemory, writeAgentMemory } from "#core/agent/memory.js";
+import { isBlobKey, normalizeAgentType, pickBlob } from "#core/apc/agent-identity.js";
+import { readOrganization, resolveAreaSlug } from "#core/stores/organization.js";
+import { repointAgentReferences } from "./agent-rename-refs.js";
+import { PERMISSION_MODES } from "#core/constants/permissions.js";
+
+export const AGENT_SLUG_RE = /^[a-z][a-z0-9_-]*$/;
+
+// Autonomy mirrors the super-agent permission modes (total/automatico/permiso).
+// An invalid value is dropped rather than persisted so a typo can't silently
+// widen an agent's autonomy.
+const AUTONOMY_VALUES = new Set(Object.values(PERMISSION_MODES));
+export function normalizeAutonomy(v) {
+  if (v === undefined) return undefined;
+  if (v === null || v === "") return null;
+  return AUTONOMY_VALUES.has(v) ? v : undefined;
+}
+
+// Build the frontmatter fields for a NEW agent from a loose spec. Throws on an
+// invalid `type`. `roster` is the existing agent list, used to pick an avatar
+// blob this project isn't already using so a team stays distinguishable.
+export function buildNewAgentFields(projectPath, spec = {}, roster = []) {
+  const {
+    name, role, model, language, description, skills, tools,
+    is_master, parent, type, area, emoji, icon, autonomy,
+  } = spec;
+  const typeVal = normalizeAgentType(type);
+  if (type && !typeVal) throw new Error(`invalid type "${type}"`);
+  // Every agent gets a face. A caller that doesn't care (CLI, MCP, super-agent)
+  // leaves icon empty and one is picked from the blobs this project isn't using.
+  const iconVal = isBlobKey(icon)
+    ? icon
+    : pickBlob({ taken: roster.map((a) => a.fields?.Icon).filter(Boolean) });
+  return {
+    Name: name || null,
+    Role: role || null,
+    Model: model || null,
+    Language: language || null,
+    Description: description || null,
+    Skills: skills || [],
+    // Omitted tools ⇒ leave the field UNDECLARED. A declared list is a
+    // deliberate narrowing that wins forever, so stamping a snapshot of "the
+    // defaults" at creation quietly freezes the agent. Undeclared means the
+    // broad default (see resolveAgentAllowedTools).
+    Tools: Array.isArray(tools) ? tools : null,
+    Master: is_master || typeVal === "orchestrator" ? true : null,
+    Parent: parent || null,
+    Type: typeVal,
+    Area: resolveAreaSlug(area, readOrganization(projectPath)),
+    Emoji: emoji || null,
+    Icon: iconVal,
+    Autonomy: normalizeAutonomy(autonomy) || null,
+  };
+}
+
+/**
+ * Create a project agent, writing its `.apc/agents/<slug>.md` (frontmatter +
+ * system prompt) and provisioning its runtime dir. Does NOT rebuild the daemon
+ * projects registry — that is the caller's job (route/tool), since the registry
+ * is a runtime object, not core.
+ *
+ * @param {{path:string}} project  project descriptor (needs .path; passed
+ *   through to ensureAgentRuntimeDir for the runtime/memory dir)
+ * @param {object} spec  { slug, system, name?, role?, ... }
+ * @param {{requireSystem?:boolean}} opts  when true, a missing/empty `system`
+ *   throws instead of writing a body-less agent (the super-agent tool sets this)
+ * @returns {string} the created slug
+ */
+export function createAgent(project, spec = {}, { requireSystem = false } = {}) {
+  const { slug, system } = spec;
+  if (!slug) throw new Error("slug required");
+  if (!AGENT_SLUG_RE.test(slug)) throw new Error(`invalid slug "${slug}"`);
+  if (requireSystem && (typeof system !== "string" || !system.trim())) {
+    throw new Error(
+      "an agent needs a system prompt: pass `system` with the agent's instructions. " +
+      "Creating one without a body leaves it unable to do anything.",
+    );
+  }
+  const roster = readAgents(project.path);
+  if (roster.find((a) => a.slug === slug)) throw new Error(`agent ${slug} already exists`);
+  const fields = buildNewAgentFields(project.path, spec, roster);
+  writeAgentFile(project.path, slug, fields, typeof system === "string" ? system : "");
+  ensureAgentDir(project.path, slug);
+  ensureAgentRuntimeDir(project, slug);
+  return slug;
+}
+
+// Strip a trailing " (2)" / "-2" style copy marker so cloning a clone doesn't
+// stack them ("candela (2) (3)"): it re-derives the base and picks the next free
+// index instead.
+const stripNameCopy = (name) => name.replace(/\s*\(\d+\)\s*$/, "").trim();
+const stripSlugCopy = (slug) => slug.replace(/-\d+$/, "");
+
+/**
+ * Duplicate an existing agent into a fresh slug. Copies every frontmatter field
+ * and the system prompt verbatim, appending " (n)" to the display Name and "-n"
+ * to the slug — n being the lowest index that keeps both unique — and carries
+ * the agent's memory across so the clone starts where the original was. Throws
+ * if the source doesn't exist. Caller rebuilds the registry.
+ *
+ * @param {{path:string}} project
+ * @param {string} slug  source agent slug
+ * @returns {string} the new (cloned) slug
+ */
+export function cloneAgent(project, slug) {
+  if (!slug) throw new Error("slug required");
+  const roster = readAgents(project.path);
+  const source = roster.find((a) => a.slug === slug);
+  if (!source) throw new Error(`agent ${slug} not found`);
+
+  const taken = new Set(roster.map((a) => a.slug));
+  const baseSlug = stripSlugCopy(source.slug) || source.slug;
+  let n = 2;
+  while (taken.has(`${baseSlug}-${n}`)) n += 1;
+  const newSlug = `${baseSlug}-${n}`;
+  if (!AGENT_SLUG_RE.test(newSlug)) throw new Error(`cannot derive a valid slug from "${slug}"`);
+
+  const fields = { ...(source.fields || {}) };
+  const baseName = stripNameCopy(fields.Name || source.name || source.slug);
+  fields.Name = `${baseName} (${n})`;
+
+  writeAgentFile(project.path, newSlug, fields, source.body || "");
+  ensureAgentDir(project.path, newSlug);
+  ensureAgentRuntimeDir(project, newSlug);
+  const memory = readAgentMemory(project, source.slug);
+  if (memory && memory.trim()) writeAgentMemory(project, newSlug, memory);
+  return newSlug;
+}
+
+/**
+ * Replace an existing agent's system prompt (its `.md` body), keeping every
+ * frontmatter field. Throws if the agent doesn't exist. Caller rebuilds.
+ *
+ * @param {{path:string}} project
+ * @param {string} slug
+ * @param {string} system  the new system prompt (required, non-empty)
+ * @returns {string} the slug
+ */
+export function setAgentPrompt(project, slug, system) {
+  if (!slug) throw new Error("slug required");
+  if (typeof system !== "string" || !system.trim()) {
+    throw new Error("system prompt required: pass `system` with the agent's new instructions.");
+  }
+  const existing = readAgents(project.path).find((a) => a.slug === slug);
+  if (!existing) throw new Error(`agent ${slug} not found`);
+  writeAgentFile(project.path, slug, existing.fields || {}, system);
+  ensureAgentDir(project.path, slug);
+  ensureAgentRuntimeDir(project, slug);
+  return slug;
+}
+
+/**
+ * Merge frontmatter fields into an existing agent (model, type, area, skills,
+ * role, …), keeping its body unless `patch.system` is given. Mirrors the PATCH
+ * route so the route and the configure_agent tool share one normalization.
+ * A field set to null/"" is removed; `undefined` leaves it untouched.
+ *
+ * @param {{path:string}} project
+ * @param {string} slug
+ * @param {object} patch
+ * @returns {string} the slug
+ */
+export function setAgentConfig(project, slug, patch = {}) {
+  const existing = readAgents(project.path).find((a) => a.slug === slug);
+  if (!existing) throw new Error(`agent ${slug} not found`);
+  const fields = { ...(existing.fields || {}) };
+  const setStr = (key, val) => {
+    if (val === undefined) return;
+    if (val === null || val === "") delete fields[key];
+    else fields[key] = val;
+  };
+  setStr("Name", patch.name);
+  setStr("Role", patch.role);
+  setStr("Model", patch.model);
+  setStr("Language", patch.language);
+  setStr("Description", patch.description);
+  setStr("Parent", patch.parent);
+  if (patch.type !== undefined && patch.type !== null && patch.type !== "") {
+    const t = normalizeAgentType(patch.type);
+    if (!t) throw new Error(`invalid type "${patch.type}"`);
+    fields.Type = t;
+  } else {
+    setStr("Type", patch.type);
+  }
+  if (patch.area !== undefined) {
+    const resolved = patch.area === null || patch.area === ""
+      ? null
+      : resolveAreaSlug(patch.area, readOrganization(project.path));
+    setStr("Area", resolved);
+  }
+  setStr("Emoji", patch.emoji);
+  setStr("Icon", patch.icon);
+  const auto = normalizeAutonomy(patch.autonomy);
+  if (auto !== undefined) setStr("Autonomy", auto);
+  if (patch.skills !== undefined) fields.Skills = Array.isArray(patch.skills) ? patch.skills : [];
+  if (patch.tools !== undefined) fields.Tools = Array.isArray(patch.tools) ? patch.tools : [];
+  if (patch.is_master !== undefined) {
+    if (patch.is_master) fields.Master = true;
+    else { delete fields.Master; delete fields.Primary; }
+  }
+  const body = patch.system !== undefined ? patch.system : (existing.body || "");
+  writeAgentFile(project.path, slug, fields, body);
+  ensureAgentDir(project.path, slug);
+  ensureAgentRuntimeDir(project, slug);
+  return slug;
+}
+
+/**
+ * Rename an agent's slug — the agent's physical key. The slug names the
+ * definition file (`.apc/agents/<slug>.md`) and the runtime dir (memory,
+ * conversations, sessions under `agents/<slug>/`); it is ALSO written into
+ * other agents' `Parent` field and into stores that live nowhere near the agent
+ * (group rosters, telegram routes, tasks, deliveries, code sessions, the RAG
+ * scope). This moves the files and repoints every one of those, in ONE place so
+ * the route and any tool share the same behavior — see agent-rename-refs.js for
+ * which references are pointers (repointed) and which are records (left alone:
+ * a ledger row's `agent_slug` says who spoke, it does not resolve to anyone).
+ *
+ * Caller rebuilds the daemon registry afterwards.
+ *
+ * @param {{id?:any, path:string, storagePath?:string, apxId?:string}} project
+ * @param {string} oldSlug  current slug
+ * @param {string} newSlug  desired slug (already slugified/validated by caller,
+ *   re-validated here against AGENT_SLUG_RE)
+ * @param {{projects?:object[]}} [opts]  the daemon registry when the caller has
+ *   one — reaches rooms hosted by other projects and telegram fallbacks.
+ * @returns {Promise<string>} the final slug (equal to oldSlug when it's a no-op)
+ */
+export async function renameAgent(project, oldSlug, newSlug, opts = {}) {
+  if (!oldSlug) throw new Error("current slug required");
+  if (!newSlug) throw new Error("new slug required");
+  if (!AGENT_SLUG_RE.test(newSlug)) throw new Error(`invalid slug "${newSlug}"`);
+  if (newSlug === oldSlug) return oldSlug; // nothing to do
+
+  const roster = readAgents(project.path);
+  const source = roster.find((a) => a.slug === oldSlug);
+  if (!source) throw new Error(`agent ${oldSlug} not found`);
+  if (roster.find((a) => a.slug === newSlug)) throw new Error(`agent ${newSlug} already exists`);
+
+  // 1) Move the definition file. If it's missing — the agent lived only in the
+  //    runtime, or only in the VAULT (imported: no local file at all, resolved
+  //    through `.apc/project.json`'s `agents.imported`) — re-materialize it
+  //    under the new slug from what we parsed. Either way the old slug must
+  //    stop resolving, so the import entry goes with it: left behind, the vault
+  //    template kept answering to the old slug and the rename read as a
+  //    DUPLICATE — one card with the chats, one with the history.
+  const oldFile = apcAgentFile(project.path, oldSlug);
+  ensureAgentDir(project.path, newSlug);
+  if (fs.existsSync(oldFile)) fs.renameSync(oldFile, apcAgentFile(project.path, newSlug));
+  else writeAgentFile(project.path, newSlug, source.fields || {}, source.body || "");
+  removeImportedAgent(project.path, oldSlug);
+
+  // 2) Move the runtime dir (memory, conversations, sessions) wholesale.
+  const oldDir = agentRuntimeDir(project, oldSlug);
+  const newDir = agentRuntimeDir(project, newSlug);
+  if (fs.existsSync(oldDir)) {
+    if (fs.existsSync(newDir)) throw new Error(`runtime data for ${newSlug} already exists`);
+    fs.renameSync(oldDir, newDir);
+  }
+
+  // 3) Repoint child agents whose Parent pointed at the old slug.
+  for (const child of roster) {
+    if (child.slug === oldSlug) continue;
+    if (child.fields?.Parent === oldSlug) {
+      writeAgentFile(project.path, child.slug, { ...child.fields, Parent: newSlug }, child.body || "");
+    }
+  }
+
+  // 4) Repoint every other live reference — routines, group rosters, tasks,
+  //    deliveries, code sessions, telegram routes, the project's own
+  //    `.apc/config.json` and the RAG scope. Best-effort per store: the files
+  //    have already moved, so one unreadable store must not fail the rename.
+  try { await repointAgentReferences(project, oldSlug, newSlug, opts); } catch { /* best-effort */ }
+
+  return newSlug;
+}
+
+/**
+ * Delete an agent: its `.apc/agents/<slug>.md` definition and its runtime dir
+ * (memory, conversations, sessions). Throws if neither exists. Caller rebuilds.
+ *
+ * @param {{path:string}} project
+ * @param {string} slug
+ * @returns {string} the slug
+ */
+export function removeAgent(project, slug) {
+  if (!slug) throw new Error("slug required");
+  const file = apcAgentFile(project.path, slug);
+  const runtimeDir = path.dirname(agentMemoryPath(project, slug));
+  if (!fs.existsSync(file) && !fs.existsSync(runtimeDir)) {
+    throw new Error(`agent ${slug} not found`);
+  }
+  if (fs.existsSync(file)) fs.rmSync(file);
+  if (fs.existsSync(runtimeDir)) fs.rmSync(runtimeDir, { recursive: true, force: true });
+  return slug;
+}

package/src/core/apc/agents-vault.js

@@ -9,7 +9,7 @@
 // pure transform layer so HTTP routes, CLI commands, and the super-agent
 // `import_agent` tool all agree on what fields exist.
 
-export const VAULT_PATCH_FIELDS = ["role", "model", "language", "description", "skills", "tools", "is_master"];
+export const VAULT_PATCH_FIELDS = ["role", "model", "language", "description", "skills", "tools", "is_master", "emoji", "icon"];
 
 /**
  * Normalize a user-provided vault patch:

package/src/core/apc/blob-keys.js

@@ -0,0 +1,42 @@
+// AUTO-GENERATED by scripts/export_web_assets.py — do not edit by hand.
+// Blob avatar preset keys, for the non-browser surfaces that create agents
+// (CLI, MCP server, daemon API). The renderer's copy — with eye rects and
+// image sources — is src/interfaces/web/src/components/agents/blobPresets.ts.
+
+export const BLOB_KEYS = Object.freeze([
+  "menta",
+  "parche",
+  "trino",
+  "cubi",
+  "nimbo",
+  "papa",
+  "noche",
+  "kiwi",
+  "gajo",
+  "campana",
+  "cobalto",
+  "rubi",
+  "trebol",
+  "saturno",
+  "onyx",
+  "perla",
+  "faro",
+  "brasa",
+  "aqua",
+  "coral",
+  "zafiro",
+  "pino",
+  "eclipse",
+  "peon",
+  "ovni",
+  "amatista",
+  "volcan",
+  "quad",
+  "cometa",
+  "lila",
+  "orbita",
+  "caracol",
+  "iris",
+  "laguna",
+  "carbon",
+]);