nexakit 0.1.0 → 0.2.0

package/skills/web-design-guidelines/AGENTS.md

@@ -0,0 +1,156 @@
+Concise rules for building accessible, fast, delightful UIs. Use MUST/SHOULD/NEVER to guide decisions.
+
+## Interactions
+
+### Keyboard
+
+- MUST: Full keyboard support per [WAI-ARIA APG](https://www.w3.org/WAI/ARIA/apg/patterns/)
+- MUST: Visible, unobscured focus rings (`:focus-visible`; group with `:focus-within`); sticky/fixed elements never cover focus
+- MUST: Manage focus (trap, move, return) per APG patterns
+- NEVER: `outline: none` without visible focus replacement
+
+### Targets & Input
+
+- MUST: Hit target ≥24px (mobile ≥44px); if visual <24px, expand hit area
+- MUST: Mobile `<input>` font-size ≥16px to prevent iOS zoom
+- NEVER: Disable browser zoom (`user-scalable=no`, `maximum-scale=1`)
+- MUST: `touch-action: manipulation` to prevent double-tap zoom
+- SHOULD: Set `-webkit-tap-highlight-color` to match design
+
+### Forms
+
+- MUST: Hydration-safe inputs (no lost focus/value)
+- NEVER: Block paste in `<input>`/`<textarea>`
+- MUST: Loading buttons show spinner and keep original label
+- MUST: Enter submits focused input; in `<textarea>`, ⌘/Ctrl+Enter submits
+- MUST: Keep submit enabled until request starts; then disable with spinner
+- MUST: Accept free text, validate after—don't block typing
+- MUST: Allow incomplete form submission to surface validation
+- MUST: Errors inline next to fields; on submit, focus first error
+- MUST: `autocomplete` + meaningful `name`; correct `type` and `inputmode`
+- SHOULD: Disable spellcheck for emails/codes/usernames
+- SHOULD: Placeholders end with `…` and show example pattern
+- MUST: Warn on unsaved changes before navigation
+- MUST: Compatible with password managers & 2FA; allow pasting codes
+- MUST: Trim values to handle text expansion trailing spaces
+- MUST: No dead zones on checkboxes/radios; label+control share one hit target
+
+### State & Navigation
+
+- MUST: URL reflects state (deep-link filters/tabs/pagination/expanded panels)
+- MUST: Back/Forward restores scroll position
+- MUST: Links use `<a>`/`<Link>` for navigation (support Cmd/Ctrl/middle-click)
+- NEVER: Use `<div onClick>` for navigation
+
+### Feedback
+
+- SHOULD: Optimistic UI; reconcile on response; on failure rollback or offer Undo
+- MUST: Confirm destructive actions or provide Undo window
+- MUST: Use polite `aria-live` for toasts/inline validation
+- SHOULD: Ellipsis (`…`) for options opening follow-ups ("Rename…") and loading states ("Loading…")
+
+### Touch & Drag
+
+- MUST: Generous targets, clear affordances; avoid finicky interactions
+- MUST: Delay first tooltip; subsequent peers instant
+- MUST: `overscroll-behavior: contain` in modals/drawers
+- SHOULD: When suppressing page rubber-band bounce, set `overscroll-behavior: none` on `<html>` inside `@media (pointer: fine)`; keep coarse-pointer page defaults for pull-to-refresh. Test hybrid touch devices: `pointer` describes the primary input, and `none` also disables scroll chaining and native swipe navigation
+- MUST: During drag, disable text selection and set `inert` on dragged elements
+- MUST: Drag/swipe/pinch/path gestures have a tap/click and keyboard alternative unless essential
+- MUST: If it looks clickable, it must be clickable
+
+### Autofocus
+
+- SHOULD: Autofocus on desktop with single primary input; rarely on mobile
+
+## Animation
+
+- MUST: Honor `prefers-reduced-motion` (provide reduced variant or disable)
+- SHOULD: Prefer CSS > Web Animations API > JS libraries
+- MUST: Animate compositor-friendly props (`transform`, `opacity`) only
+- NEVER: Animate layout props (`top`, `left`, `width`, `height`)
+- NEVER: `transition: all`—list properties explicitly
+- SHOULD: Animate only to clarify cause/effect or add deliberate delight
+- SHOULD: Choose easing to match the change (size/distance/trigger)
+- MUST: Animations interruptible and input-driven; autoplay only for muted, non-essential loops
+- MUST: Autoplay motion >5s alongside other content has pause, stop, or hide controls
+- MUST: Correct `transform-origin` (motion starts where it "physically" should)
+- MUST: SVG transforms on `<g>` wrapper with `transform-box: fill-box`
+
+## Layout
+
+- SHOULD: Optical alignment; adjust ±1px when perception beats geometry
+- MUST: Deliberate alignment to grid/baseline/edges—no accidental placement
+- SHOULD: Balance icon/text lockups (weight/size/spacing/color)
+- MUST: Verify mobile, laptop, ultra-wide (simulate ultra-wide at 50% zoom)
+- MUST: Respect safe areas (`env(safe-area-inset-*)`)
+- MUST: Avoid unwanted scrollbars; fix overflows
+- SHOULD: Flex/grid over JS measurement for layout
+
+## Content & Accessibility
+
+- SHOULD: Inline help first; tooltips last resort
+- MUST: Skeletons mirror final content to avoid layout shift
+- MUST: `<title>` matches current context
+- MUST: No dead ends; always offer next step/recovery
+- MUST: Design empty/sparse/dense/error states
+- SHOULD: Curly quotes (“ ”); avoid widows/orphans (`text-wrap: balance`)
+- MUST: `font-variant-numeric: tabular-nums` for number comparisons
+- MUST: Redundant status cues (not color-only); icons have text labels
+- MUST: Accessible names exist even when visuals omit labels
+- MUST: Use `…` character (not `...`)
+- MUST: `scroll-margin-top` on headings; "Skip to content" link; hierarchical `<h1>`–`<h6>`
+- MUST: Resilient to user-generated content (short/avg/very long)
+- MUST: Locale-aware dates/times/numbers (`Intl.DateTimeFormat`, `Intl.NumberFormat`)
+- SHOULD: `translate="no"` on brand names, code tokens, & identifiers to prevent garbled auto-translation
+- MUST: Accurate `aria-label`; decorative elements `aria-hidden`
+- MUST: Icon-only buttons have descriptive `aria-label`
+- MUST: Prefer native semantics (`button`, `a`, `label`, `table`) before ARIA
+- MUST: Media has captions/transcripts/descriptions as applicable; controls are keyboard-operable; decorative media hidden from assistive tech
+- MUST: Non-breaking spaces: `10&nbsp;MB`, `⌘&nbsp;K`, brand names
+
+## Content Handling
+
+- MUST: Text containers handle long content (`truncate`, `line-clamp-*`, `break-words`)
+- MUST: Flex children need `min-w-0` to allow truncation
+- MUST: Handle empty states—no broken UI for empty strings/arrays
+
+## Performance
+
+- SHOULD: Test iOS Low Power Mode and macOS Safari
+- MUST: Measure reliably (disable extensions that skew runtime)
+- MUST: Track and minimize re-renders (React DevTools/React Scan)
+- MUST: Profile with CPU/network throttling
+- MUST: Batch layout reads/writes; avoid reflows/repaints
+- MUST: Mutations (`POST`/`PATCH`/`DELETE`) target <500ms
+- SHOULD: Prefer uncontrolled inputs; controlled inputs cheap per keystroke
+- MUST: Virtualize large lists (>50 items)
+- MUST: Preload above-fold images; lazy-load the rest
+- MUST: Prevent CLS (explicit image dimensions)
+- SHOULD: `<link rel="preconnect">` for CDN domains
+- SHOULD: Critical fonts: `<link rel="preload" as="font">` with `font-display: swap`
+- SHOULD: `<video autoplay muted loop playsinline>` over animated GIF; provide still/reduced-motion alternative
+- SHOULD: Short non-essential loops include a Safari H.264 MP4 `<picture>` source, `prefers-reduced-motion` media condition, and still fallback
+
+## Dark Mode & Theming
+
+- MUST: `color-scheme: dark` on `<html>` for dark themes
+- SHOULD: `<meta name="theme-color">` matches page background
+- MUST: Native `<select>`: explicit `background-color` and `color` (Windows fix)
+
+## Hydration
+
+- MUST: Inputs with `value` need `onChange` (or use `defaultValue`)
+- SHOULD: Guard date/time rendering against hydration mismatch
+
+## Design
+
+- SHOULD: Layered shadows (ambient + direct)
+- SHOULD: Crisp edges via semi-transparent borders + shadows
+- SHOULD: Nested radii: child ≤ parent; concentric
+- SHOULD: Hue consistency: tint borders/shadows/text toward bg hue
+- MUST: Accessible charts (color-blind-friendly palettes)
+- MUST: Meet contrast—prefer [APCA](https://apcacontrast.com/) over WCAG 2
+- MUST: Increase contrast on `:hover`/`:active`/`:focus`
+- SHOULD: Match browser UI to bg
+- SHOULD: Avoid dark color gradient banding (use background images when needed)

package/skills/{spec-driven-development → web-design-guidelines}/LICENSE.txt

@@ -1,11 +1,6 @@
-Adaptación parcial en español para Agent Toolkit a partir de prácticas de
-Superpowers 7.0.1 (https://github.com/obra/superpowers, skills `brainstorming`
-y `writing-plans`). Se conserva íntegro el aviso de copyright y licencia MIT
-del origen:
-
 MIT License
 
-Copyright (c) 2025 Jesse Vincent
+Copyright (c) 2025 Vercel Labs
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/skills/web-design-guidelines/SKILL.md

@@ -1,39 +1,29 @@
 ---
 name: web-design-guidelines
-description: Review UI code for Web Interface Guidelines compliance. Use when asked to "review my UI", "check accessibility", "audit design", "review UX", or "check my site against best practices".
-metadata:
-  author: vercel
-  version: "1.0.0"
-  argument-hint: <file-or-pattern>
+license: Reglas de Vercel Labs con licencia MIT en LICENSE.txt; estas instrucciones, MIT de nexakit
+description: Revisa código de interfaz web contra las Web Interface Guidelines (accesibilidad, foco, formularios, animación, tipografía, rendimiento y tema oscuro). Úsala cuando pidan revisar la UI, la accesibilidad o la UX, o auditar una página contra buenas prácticas.
 ---
 
-# Web Interface Guidelines
+# Pautas de interfaz web
 
-Review files for compliance with Web Interface Guidelines.
+Revisa archivos de interfaz contra las reglas de [`AGENTS.md`](AGENTS.md): las Web Interface Guidelines de
+Vercel Labs, copiadas tal cual del commit `434b7f9` de
+[vercel-labs/web-interface-guidelines](https://github.com/vercel-labs/web-interface-guidelines) con su
+licencia MIT en [`LICENSE.txt`](LICENSE.txt). Las reglas están fijadas en esta carpeta: no se descargan
+en cada revisión.
 
-## How It Works
+## Cómo revisar
 
-1. Fetch the latest guidelines from the source URL below
-2. Read the specified files (or prompt user for files/pattern)
-3. Check against all rules in the fetched guidelines
-4. Output findings in the terse `file:line` format
+1. Si no te dicen qué revisar, pregunta por los archivos o el patrón (por ejemplo `src/**/*.tsx`).
+2. Lee `AGENTS.md` completo y los archivos indicados.
+3. Comprueba cada archivo contra las reglas. `MUST` y `NEVER` son obligatorias; `SHOULD`, recomendaciones.
+4. Informa cada hallazgo en una línea: `archivo:línea — regla — qué cambiar`. Agrupa por archivo y ordena
+   primero los `MUST`/`NEVER`.
+5. Si un archivo cumple, dilo en una línea; no inventes hallazgos para llenar el informe.
 
-## Guidelines Source
+## Límites
 
-Fetch fresh guidelines before each review:
-
-```
-https://raw.githubusercontent.com/vercel-labs/web-interface-guidelines/main/command.md
-```
-
-Use WebFetch to retrieve the latest rules. The fetched content contains all the rules and output format instructions.
-
-## Usage
-
-When a user provides a file or pattern argument:
-1. Fetch guidelines from the source URL above
-2. Read the specified files
-3. Apply all rules from the fetched guidelines
-4. Output findings using the format specified in the guidelines
-
-If no files specified, ask the user which files to review.
+- Es una revisión estática del código: no sustituye probar con teclado, lector de pantalla o en un móvil real.
+  Dilo al final del informe.
+- Algunas reglas son de React/Next.js; en otros frameworks aplica su equivalente o márcalas como no aplicables.
+- Para diseñar o rediseñar, usa `frontend-design`; esta skill revisa lo que ya existe.

package/src/agent-models.js

@@ -6,31 +6,71 @@ import { getStaticTOMLValue, parseTOML } from "toml-eslint-parser";
 // Claude Code accepts stable aliases; Codex publishes its catalog in models_cache.json.
 const CLAUDE = [
   { model: "haiku", category: "ligero", efforts: ["low", "medium", "high", "xhigh", "max"] },
-  { model: "sonnet", category: "trabajo diario", efforts: ["low", "medium", "high", "xhigh", "max"] },
-  { model: "opus", category: "más capaz", efforts: ["low", "medium", "high", "xhigh", "max"] }
+  { model: "sonnet", category: "uso diario", efforts: ["low", "medium", "high", "xhigh", "max"] },
+  { model: "opus", category: "el más capaz", efforts: ["low", "medium", "high", "xhigh", "max"] }
 ];
 const LEVELS = [
   { level: "Ligero", total: "0–2", category: "ligero", effort: "low" },
-  { level: "Normal", total: "3–4", category: "trabajo diario", effort: "medium" },
-  { level: "Exigente", total: "5–6", category: "trabajo diario", effort: "high" },
-  { level: "Alto", total: "7–10", category: "más capaz", effort: "high" }
+  { level: "Normal", total: "3–4", category: "uso diario", effort: "medium" },
+  { level: "Exigente", total: "5–6", category: "uso diario", effort: "high" },
+  { level: "Alto", total: "7–10", category: "el más capaz", effort: "high" }
 ];
+const FAMILY_ROLES = Object.freeze({
+  luna: "ligero",
+  flash: "ligero",
+  haiku: "ligero",
+  terra: "uso diario",
+  sol: "uso diario",
+  sonnet: "uso diario",
+  astra: "el más capaz",
+  argon: "el más capaz",
+  opus: "el más capaz"
+});
 
-function category(description = "") {
-  if (/\b(older|previous)\b/iu.test(description)) return "anterior";
+export function roleFromDescription(description = "") {
   if (/\b(fast and (affordable|efficient)|easier tasks|lightweight)\b/iu.test(description)) return "ligero";
-  if (/\b(frontier|most demanding)\b/iu.test(description)) return "más capaz";
-  if (/\b(workhorse|everyday|balanced)\b/iu.test(description)) return "trabajo diario";
-  return "otro";
+  if (/\b(frontier|most demanding)\b/iu.test(description)) return "el más capaz";
+  if (/\b(workhorse|everyday|balanced|straightforward work)\b/iu.test(description)) return "uso diario";
+  return null;
+}
+
+export function familyOfModel(slug = "") {
+  const base = String(slug).replace(/-(?:low|medium|high|xhigh|max|ultra)$/iu, "");
+  const known = base.match(/\b(luna|terra|sol|astra|flash|argon|haiku|sonnet|opus)\b/iu);
+  if (known) return known[1].toLowerCase();
+  const family = base.match(/^(?:gpt|gemini|claude)-\d+(?:\.\d+)*-([a-z][a-z0-9]*)$/iu);
+  return family ? family[1].toLowerCase() : null;
+}
+
+export function classifyModelRole(slug = "", description = "", familyRoles = new Map(Object.entries(FAMILY_ROLES))) {
+  if (/\b(older|previous)\b/iu.test(description)) return "anterior";
+  const direct = roleFromDescription(description);
+  if (direct) return direct;
+  const family = familyOfModel(slug);
+  if (family && familyRoles.has(family)) return familyRoles.get(family);
+  return "sin clasificar";
+}
+
+export function buildFamilyRoleMap(items = []) {
+  const map = new Map(Object.entries(FAMILY_ROLES));
+  for (const item of items) {
+    const family = familyOfModel(item.slug ?? item.model ?? "");
+    const role = roleFromDescription(item.description ?? "");
+    if (family && role) map.set(family, role);
+  }
+  return map;
 }
 
 async function codexCatalog(codexHome) {
   let cache;
   try { cache = JSON.parse(await fs.readFile(path.join(codexHome, "models_cache.json"), "utf8")); }
   catch { return { available: false, models: [] }; }
-  const models = (Array.isArray(cache?.models) ? cache.models : [])
-    .filter(item => item && typeof item.slug === "string" && (item.visibility ?? "list") === "list")
-    .map(item => ({ model: item.slug, description: String(item.description ?? "").slice(0, 120), category: category(item.description),
+  const visible = (Array.isArray(cache?.models) ? cache.models : [])
+    .filter(item => item && typeof item.slug === "string" && (item.visibility ?? "list") === "list");
+  const familyRoles = buildFamilyRoleMap(visible);
+  const models = visible
+    .map(item => ({ model: item.slug, description: String(item.description ?? "").slice(0, 120),
+      category: classifyModelRole(item.slug, item.description, familyRoles),
       priority: Number.isFinite(item.priority) ? item.priority : 999,
       efforts: (item.supported_reasoning_levels ?? []).map(level => level?.effort).filter(effort => typeof effort === "string") }));
   return { available: true, fetchedAt: cache.fetched_at ?? null, models };

package/src/brand.js

@@ -0,0 +1,117 @@
+// La marca de nexakit en la terminal: el logo de píxeles, la paleta y el nivel de color que admite cada terminal.
+// Sin color (NO_COLOR, salida que no es una terminal, TERM=dumb) no hay logo ni paleta: se usa texto plano.
+
+// Fuente de píxeles de 5×7. Cada letra es una columna de 5 píxeles más 1 de separación.
+const GLYPHS = {
+  N: ['10001', '11001', '10101', '10011', '10001', '10001', '10001'],
+  E: ['11111', '10000', '10000', '11110', '10000', '10000', '11111'],
+  X: ['10001', '10001', '01010', '00100', '01010', '10001', '10001'],
+  A: ['01110', '10001', '10001', '11111', '10001', '10001', '10001'],
+  K: ['10001', '10010', '10100', '11000', '10100', '10010', '10001'],
+  I: ['11111', '00100', '00100', '00100', '00100', '00100', '11111'],
+  T: ['11111', '00100', '00100', '00100', '00100', '00100', '00100'],
+};
+const WORD = 'NEXAKIT';
+const HEIGHT = 7;
+const FACE = [...Array(HEIGHT).keys()].map((row) =>
+  [...[...WORD].map((letter) => GLYPHS[letter][row]).join('0')].map(Number),
+);
+const PIXEL_WIDTH = FACE[0].length;
+
+// La sombra cae un píxel a la derecha y uno abajo, como en el logo original: 41 columnas de letras + 1 de sombra.
+export const LOGO_WIDTH = PIXEL_WIDTH + 1;
+export const LOGO_ROWS = Math.ceil((HEIGHT + 1) / 2);
+
+const pixel = (row, column, shadow) => {
+  if (FACE[row]?.[column]) return 'face';
+  return shadow && FACE[row - 1]?.[column - 1] ? 'shadow' : null;
+};
+
+// Dos píxeles por celda con medios bloques: arriba ▀, abajo ▄, los dos █.
+export function logoArt() {
+  const lines = [];
+  for (let row = 0; row < HEIGHT + 1; row += 2) {
+    let line = '';
+    for (let column = 0; column < PIXEL_WIDTH; column++) {
+      const top = pixel(row, column, false);
+      const bottom = pixel(row + 1, column, false);
+      line += top && bottom ? '█' : top ? '▀' : bottom ? '▄' : ' ';
+    }
+    lines.push(line.trimEnd());
+  }
+  return lines;
+}
+
+// none: sin color · 16: colores básicos · 256: paleta de 256 · truecolor: 24 bits.
+export function colorLevel(output, env = process.env) {
+  if (!output?.isTTY || env.NO_COLOR || env.TERM === 'dumb') return 'none';
+  if (env.COLORTERM === 'truecolor' || env.COLORTERM === '24bit') return 'truecolor';
+  if (/256color/u.test(env.TERM ?? '')) return '256';
+  return '16';
+}
+// Quien llama con el antiguo true/false sigue funcionando.
+export const levelOf = (color) => (color === true ? 'truecolor' : !color ? 'none' : color);
+
+const PALETTE = {
+  truecolor: {
+    face: { fg: '38;2;236;232;244', bg: '48;2;236;232;244' },
+    shadow: { fg: '38;2;62;48;110', bg: '48;2;62;48;110' },
+    accent: '38;2;167;139;250',
+    soft: '38;2;196;181;253',
+    chip: '48;2;54;44;98;38;2;221;214;254',
+  },
+  256: {
+    face: { fg: '38;5;255', bg: '48;5;255' },
+    shadow: { fg: '38;5;60', bg: '48;5;60' },
+    accent: '38;5;141',
+    soft: '38;5;183',
+    chip: '48;5;60;38;5;189',
+  },
+  16: {
+    face: { fg: '97', bg: '107' },
+    shadow: { fg: '35', bg: '45' },
+    accent: '95',
+    soft: '35',
+    chip: '45;97',
+  },
+};
+
+export function renderLogo(level) {
+  const colors = PALETTE[level];
+  if (!colors) return null;
+  const lines = [];
+  for (let row = 0; row < HEIGHT + 1; row += 2) {
+    let line = '';
+    for (let column = 0; column < LOGO_WIDTH; column++) {
+      const top = pixel(row, column, true);
+      const bottom = pixel(row + 1, column, true);
+      if (!top && !bottom) line += ' ';
+      else if (!top) line += `\x1b[${colors[bottom].fg}m▄\x1b[0m`;
+      else if (!bottom) line += `\x1b[${colors[top].fg}m▀\x1b[0m`;
+      else if (top === bottom) line += `\x1b[${colors[top].fg}m█\x1b[0m`;
+      else line += `\x1b[${colors[top].fg};${colors[bottom].bg}m▀\x1b[0m`;
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+
+// Los estilos de texto de las pantallas. Sin color, cada uno devuelve el texto tal cual.
+export function paint(level) {
+  const colors = PALETTE[level];
+  if (!colors) {
+    const same = (text) => String(text);
+    return { accent: same, soft: same, chip: same, bold: same, dim: same, green: same, yellow: same, red: same };
+  }
+  const wrap = (open, close) => (text) => `\x1b[${open}m${text}\x1b[${close}m`;
+  return {
+    accent: (text) => `\x1b[1;${colors.accent}m${text}\x1b[22;39m`,
+    soft: wrap(colors.soft, 39),
+    chip: (text) => `\x1b[${colors.chip}m ${text} \x1b[0m`,
+    bold: wrap(1, 22),
+    dim: wrap(2, 22),
+    green: wrap(32, 39),
+    yellow: wrap(33, 39),
+    red: wrap(31, 39),
+  };
+}

package/src/cli-executable.js

@@ -36,7 +36,9 @@ async function packageInvocation(directory, name, io, expectedScript) {
 }
 
 export async function resolveCliInvocation({ name, override, environment = process.env, fileIo = fs } = {}) {
-  if (!Object.hasOwn(PACKAGES, name)) unavailable();
+  // agy (Antigravity) is a native executable, not an npm package: only found as such on the PATH.
+  const native = name === "agy";
+  if (!native && !Object.hasOwn(PACKAGES, name)) unavailable();
   if (override) {
     const absolute = path.resolve(override);
     let stat;
@@ -48,7 +50,7 @@ export async function resolveCliInvocation({ name, override, environment = proce
     }
     const extension = path.extname(absolute).toLowerCase();
     if ([".exe", ".com"].includes(extension)) return { executable: absolute, argsPrefix: [] };
-    if (extension === ".cmd" || NODE_EXTENSIONS.has(extension)) {
+    if (!native && (extension === ".cmd" || NODE_EXTENSIONS.has(extension))) {
       const directories = [path.dirname(absolute)];
       // Explicit npm bin scripts may live inside the CLI package itself.
       if (NODE_EXTENSIONS.has(extension)) {
@@ -77,7 +79,7 @@ export async function resolveCliInvocation({ name, override, environment = proce
         if (stat.isFile() && (IS_WINDOWS || ((stat.mode & 0o111) && !(stat.mode & 0o022)))) return { executable, argsPrefix: [] };
       } catch {}
     }
-    if (IS_WINDOWS) {
+    if (IS_WINDOWS && !native) {
       const result = await packageInvocation(directory, name, fileIo);
       if (result) return result;
     }

package/src/cli.js

@@ -39,7 +39,7 @@ Opciones de doctor:
   --strict           Devuelve error cuando existan advertencias.
 
 Opciones de connect:
-  --agent <agente>   Agente a conectar: codex o claude.
+  --agent <agente>   Agente a conectar: codex, claude o antigravity.
   --manifest <ruta>  Selecciona un manifiesto concreto.
   --apply            Aplica el plan; sin esta opción solo previsualiza.
 
@@ -87,9 +87,16 @@ Evita editar o sincronizar la memoria durante --apply: su bloqueo no controla
 editores externos. Ni record ni apply crean commits o hacen push. apply puede
 quedar parcial entre notas: no revierte ni registra automáticamente el PR.`;
 
+// Invoked as `npx nexakit memoria`, the help names that command and keeps project-memory as the compatible executable.
+const DEFAULT_COMMAND = "project-memory";
+function helpFor(commandName = DEFAULT_COMMAND) {
+  if (commandName === DEFAULT_COMMAND) return HELP;
+  return `${HELP.replaceAll(DEFAULT_COMMAND, commandName)}\n\nEl ejecutable ${DEFAULT_COMMAND} es compatible y acepta los mismos subcomandos.`;
+}
+
 export async function runCli(argv, io = defaultIo(), context = {}) {
   if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
-    io.out(HELP);
+    io.out(helpFor(context.commandName));
     return 0;
   }
 
@@ -103,11 +110,11 @@ export async function runCli(argv, io = defaultIo(), context = {}) {
   }
 
   if (command === "connect") {
-    return runConnectCommand(rest, io);
+    return runConnectCommand(rest, io, context);
   }
 
   if (command === "status") {
-    return runStatusCommand(rest, io);
+    return runStatusCommand(rest, io, context);
   }
 
   if (command === "sync") {
@@ -115,7 +122,7 @@ export async function runCli(argv, io = defaultIo(), context = {}) {
   }
 
   io.err(`Comando desconocido: ${command}`);
-  io.err(HELP);
+  io.err(helpFor(context.commandName));
   return 2;
 }
 
@@ -319,7 +326,7 @@ async function runSyncApplyCommand(args, io, context) {
   }
 }
 
-async function runStatusCommand(rest, io) {
+async function runStatusCommand(rest, io, context = {}) {
   const options = {
     targetPath: process.cwd()
   };
@@ -366,7 +373,7 @@ async function runStatusCommand(rest, io) {
 
   let report;
   try {
-    report = await inspectMemoryStatus(options);
+    report = await inspectMemoryStatus(options, context);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     io.err(`No se pudo inspeccionar el estado: ${message}`);
@@ -388,7 +395,7 @@ async function runStatusCommand(rest, io) {
   return 0;
 }
 
-async function runConnectCommand(rest, io) {
+async function runConnectCommand(rest, io, context = {}) {
   const options = {
     apply: false,
     targetPath: process.cwd()
@@ -435,7 +442,7 @@ async function runConnectCommand(rest, io) {
 
   let report;
   try {
-    report = await connectMemory(options);
+    report = await connectMemory(options, context);
   } catch (error) {
     if (error instanceof ConnectionError) {
       for (const detail of error.details) {

package/src/connect.js

@@ -42,14 +42,20 @@ const ADAPTERS = Object.freeze({
   },
   claude: {
     skillDirectory: ".claude/skills"
+  },
+  antigravity: {
+    skillDirectory: ".gemini/antigravity-cli/skills"
   }
 });
+// The command each agent is driven with.
+const AGENT_COMMANDS = Object.freeze({ codex: "codex", claude: "claude", antigravity: "agy" });
+const MEMORY_SCRIPT = path.join("bin", "project-memory-mcp.js");
 
 export async function connectMemory(options, context = {}) {
   const config = loadConfig(options, context);
-  const runner = context.runCommand ?? (IS_WINDOWS ? await windowsCommandRunner(config.agentId) : runCommand);
+  const runner = context.runCommand ?? (IS_WINDOWS ? await windowsCommandRunner(AGENT_COMMANDS[config.agentId]) : runCommand);
   const skill = inspectSkill(config);
-  const connection = inspectConnection(config, runner);
+  const connection = inspectConnection(config, runner, context);
   const components = [skill, ...connection.components];
   const report = createReport(config, components, options.apply === true);
 
@@ -94,7 +100,7 @@ function loadConfig(options, context) {
     errors.push("No se encontró project-memory.json.");
   }
   if (!ADAPTERS[agentId]) {
-    errors.push("--agent debe ser codex o claude.");
+    errors.push("--agent debe ser codex, claude o antigravity.");
   }
   if (errors.length > 0) {
     throw new ConnectionError(errors);
@@ -221,10 +227,13 @@ function inspectSkill(config) {
   };
 }
 
-function inspectConnection(config, runner) {
+function inspectConnection(config, runner, context) {
   if (config.agentId === "codex") {
     return inspectCodex(config, runner);
   }
+  if (config.agentId === "antigravity") {
+    return inspectAntigravity(config, runner, context);
+  }
   return inspectClaude(config, runner);
 }
 
@@ -364,6 +373,49 @@ function inspectClaude(config, runner) {
   };
 }
 
+// Antigravity cannot restrict the tools of an MCP server, so it gets nexakit's own memory server, which only has
+// read tools, run from the active nexakit root. Its configuration is read from mcp_config.json, which keeps the
+// exact arguments (the text of `agy mcp list` does not separate paths with spaces).
+function inspectAntigravity(config, runner, context) {
+  const probe = runner("agy", ["mcp", "list"]);
+  if (probe.errorCode === "ENOENT") {
+    const unavailable = unavailableCommand("agy");
+    unavailable.components = unavailable.components.filter((item) => item.id === "mcp");
+    return unavailable;
+  }
+  const nodePath = context.nodePath ?? process.execPath;
+  const script = path.join(path.resolve(context.toolkitRoot ?? path.resolve(SOURCE_DIRECTORY, "..")), MEMORY_SCRIPT);
+  const manifestPath = fs.realpathSync(config.manifestPath);
+  const configPath = path.join(config.homeDirectory, ".gemini", "config", "mcp_config.json");
+  let current;
+  if (pathEntryExists(configPath)) {
+    if (fs.lstatSync(configPath).isSymbolicLink()) {
+      return { components: [component("mcp", "conflict", "La configuración de Antigravity es un enlace simbólico y no se reemplazará.")], apply() {} };
+    }
+    current = readJson(configPath, "configuración de Antigravity").mcpServers?.[config.mcpName];
+  }
+  const same = current && Array.isArray(current.args) && current.args.length === 3 &&
+    samePath(current.args[0], script) && current.args[1] === "--manifest" && samePath(current.args[2], manifestPath) &&
+    typeof current.command === "string" && /^node(\.exe)?$/iu.test(path.basename(current.command));
+  const mcp = !current
+    ? component("mcp", "create", "Registrar la memoria de solo lectura en Antigravity.")
+    : same
+      ? component("mcp", "unchanged", "Antigravity ya usa esta memoria.")
+      : component("mcp", "conflict", "Antigravity tiene un MCP homónimo diferente.");
+  mcp.path = configPath;
+  return {
+    components: [mcp],
+    apply() {
+      if (mcp.action === "create") {
+        requireSuccess(
+          runner("agy", ["mcp", "add", config.mcpName, "--", nodePath, script, "--manifest", manifestPath]),
+          "No se pudo registrar el MCP en Antigravity."
+        );
+      }
+    }
+  };
+}
+
 function unavailableCommand(command) {
   return {
     components: [