@rbbtsn0w/adg 0.3.0-beta.1 → 0.3.0-beta.3

package/dist/bin/adg.js

@@ -49,7 +49,7 @@ const FLAGS = {
     dir: { type: "string", short: "d", hint: "<dir>", help: "install into an explicit directory" },
     global: { type: "boolean", short: "g", help: "use ~/.agents/plugins (across all projects)" },
     project: { type: "boolean", help: "use <repo>/.agents/plugins (default)" },
-    target: { type: "string", short: "t", hint: "claude|codex|all", help: "runtime(s) to adapt for" },
+    target: { type: "string", short: "t", hint: "claude|codex|antigravity|all", help: "runtime(s) to adapt for" },
     all: { type: "boolean", short: "a", help: "select all available plugins" },
     plugin: { type: "string", short: "p", multiple: true, hint: "<name>", help: "select a specific plugin (repeatable)" },
     "no-deps": { type: "boolean", short: "n", help: "don't install dependencies" },
@@ -137,7 +137,7 @@ const PLUGIN_COMMANDS = {
     },
     link: {
         summary: "link installed plugins into a runtime",
-        synopsis: "adg plugins link --target claude|codex",
+        synopsis: "adg plugins link --target claude|codex|antigravity",
         flags: ["target", ...SCOPE],
     },
     migrate: {
@@ -253,12 +253,20 @@ function reportAgents(agents, verb) {
             console.log(ui.warn(`note: \`${r.agent}\` CLI not found — run \`adg plugins link --target ${r.agent}\` after installing it.`));
     }
 }
+/** Friendly `--target` aliases mapped onto canonical adapter target ids. */
+const TARGET_ALIASES = {
+    anthropic: "claude",
+    openai: "codex",
+    agy: "antigravity",
+    gemini: "antigravity",
+};
 function resolveTargets(target) {
     if (!target || target === "all")
         return [...ADAPTER_TARGETS];
-    if (target === "claude" || target === "codex")
-        return [target];
-    fail(`invalid --target "${String(target)}" (expected claude|codex|all)`);
+    const t = TARGET_ALIASES[target] ?? target;
+    if (ADAPTER_TARGETS.includes(t))
+        return [t];
+    fail(`invalid --target "${target}" (expected ${[...ADAPTER_TARGETS, "all"].join("|")})`);
 }
 /** Parse a `--only skills,commands` list into validated component types. */
 function resolveComponents(only) {
@@ -461,9 +469,10 @@ async function runPlugins(rawVerb, rest) {
         }
         case "link": {
             const { values } = parseVerb(verb, cmd.flags, rest);
-            const target = values.target;
-            if (target !== "claude" && target !== "codex")
-                fail("plugins link requires --target claude|codex");
+            if (values.target === undefined || values.target === "all") {
+                fail(`plugins link requires a single --target (${ADAPTER_TARGETS.join("|")})`);
+            }
+            const target = resolveTargets(values.target)[0]; // validates + maps aliases (agy → antigravity); always non-empty
             const res = linkPlugins({ pluginsDir: resolveScopeDir(values), target, global: Boolean(values.global) });
             for (const a of res.actions) {
                 console.log(`${ui.ok("linked")} ${ui.name(a.name)} ${ui.meta(`[${res.target}]`)}${a.linkedTo ? ui.meta(` -> ${a.linkedTo}`) : ""}`);
@@ -584,7 +593,7 @@ Commands:
   adg plugins marketplace list [--verbose] [--global | --project | --dir <dir>]
         Group installed plugins by source. --verbose expands each plugin to its
         components (skills, agents, commands, …).
-  adg plugins marketplace upgrade [<source>] [--all] [--target claude|codex|all] [--global | --project | --dir <dir>]
+  adg plugins marketplace upgrade [<source>] [--all] [--target claude|codex|antigravity|all] [--global | --project | --dir <dir>]
         Re-fetch a source and update its installed plugins (--all also installs
         anything new it now offers). No <source> upgrades every remote source.
   adg plugins marketplace remove <source> [--force] [--global | --project | --dir <dir>]

package/dist/src/adapters/anthropic.js

@@ -1,5 +1,5 @@
 import { join } from "node:path";
-import { resolveSkills } from "../skills.js";
+import { resolveProjectedSkills } from "../skills.js";
 import { isExposed } from "../components.js";
 /**
  * Generate a Claude (.claude-plugin/plugin.json) manifest from an ADG manifest.
@@ -31,24 +31,16 @@ export function toAnthropicManifest(pluginDir, manifest, selection) {
         out.hooks = manifest.hooks;
     if (manifest.mcp && isExposed(selection, "mcp"))
         out.mcp = manifest.mcp;
-    if (selection) {
-        // Partial install: always an explicit (possibly empty) skill list.
+    // Claude's array form is already `./skills/<id>` paths, so a strict array is
+    // passed through verbatim; an explicit id list (selection or strict:false) is
+    // mapped to paths and marks the manifest non-strict.
+    const projected = resolveProjectedSkills(pluginDir, manifest, selection, { passthroughArray: true });
+    if (projected.explicit) {
         out.strict = false;
-        const names = isExposed(selection, "skills")
-            ? selection.skills ?? resolveSkills(pluginDir, manifest)
-            : [];
-        out.skills = names.map((name) => `./skills/${name}`);
+        out.skills = projected.skills.map((name) => `./skills/${name}`);
     }
     else {
-        const strict = manifest.strict !== false;
-        if (strict && manifest.skills !== undefined) {
-            out.skills = manifest.skills;
-        }
-        else {
-            // skill-bundle form: explicit list, strict:false
-            out.strict = false;
-            out.skills = resolveSkills(pluginDir, manifest).map((name) => `./skills/${name}`);
-        }
+        out.skills = projected.skills;
     }
     return { defaultPath: join(".claude-plugin", "plugin.json"), manifest: out };
 }

package/dist/src/adapters/antigravity.js

@@ -0,0 +1,18 @@
+import { join } from "node:path";
+/** Projection subdirectory that holds the self-contained agy plugin root. */
+export const ANTIGRAVITY_PROJECTION_DIR = ".antigravity-plugin";
+/**
+ * Generate an Antigravity (`agy`) plugin.json from an ADG manifest.
+ *
+ * Antigravity's manifest is minimal: it reads only `name` from a `plugin.json`
+ * and discovers components by convention (sibling `skills/`, `agents/`,
+ * `commands/`, `hooks/` directories plus a `mcp_config.json`) — all resolved
+ * relative to the directory handed to `agy plugin install`, with no manifest
+ * path indirection. We therefore project a self-contained agy plugin root under
+ * `.antigravity-plugin/`: this pure transform emits its `plugin.json`, while the
+ * agent materializes the rest (mcp_config.json + symlinked component dirs), so a
+ * partial-install `selection` is not expressible for this target.
+ */
+export function toAntigravityManifest(_pluginDir, manifest, _selection) {
+    return { defaultPath: join(ANTIGRAVITY_PROJECTION_DIR, "plugin.json"), manifest: { name: manifest.name } };
+}

package/dist/src/adapters/{openai.js → codex.js}

@@ -1,6 +1,5 @@
 import { join } from "node:path";
-import { resolveSkills } from "../skills.js";
-import { isExposed } from "../components.js";
+import { resolveProjectedSkills } from "../skills.js";
 /**
  * Generate a Codex (.codex-plugin/plugin.json) manifest from an ADG manifest.
  *
@@ -14,18 +13,9 @@ import { isExposed } from "../components.js";
  * rather than passed through. Codex only consumes skills.
  */
 export function toCodexManifest(pluginDir, manifest, selection) {
-    let skills;
-    if (selection) {
-        skills = isExposed(selection, "skills")
-            ? selection.skills ?? resolveSkills(pluginDir, manifest)
-            : [];
-    }
-    else {
-        const strict = manifest.strict !== false;
-        skills = strict && typeof manifest.skills === "string"
-            ? manifest.skills
-            : resolveSkills(pluginDir, manifest);
-    }
+    // Codex's array form is bare ids, so a strict skills *array* is resolved to
+    // ids rather than passed through; only a declared root string passes through.
+    const { skills } = resolveProjectedSkills(pluginDir, manifest, selection, { passthroughArray: false });
     const out = {
         name: manifest.name,
         version: manifest.version,

package/dist/src/adapters/index.js

@@ -1,21 +1,30 @@
 import { toAnthropicManifest } from "./anthropic.js";
-import { toCodexManifest } from "./openai.js";
+import { toCodexManifest } from "./codex.js";
+import { toAntigravityManifest } from "./antigravity.js";
+// `anthropic` is kept as a synonym because Claude's plugin.json *is* the
+// "anthropic" manifest shape. There is deliberately no `openai` key: the runtime
+// is Codex, and an `openai` alias would imply OpenAI support that does not exist.
 export const ADAPTERS = {
     claude: toAnthropicManifest,
     anthropic: toAnthropicManifest,
     codex: toCodexManifest,
-    openai: toCodexManifest,
+    antigravity: toAntigravityManifest,
+    agy: toAntigravityManifest,
+    gemini: toAntigravityManifest,
 };
-export const ADAPTER_TARGETS = ["claude", "codex"];
+export const ADAPTER_TARGETS = ["claude", "codex", "antigravity"];
 /**
  * Component categories each adapter target can actually express, mirroring what
  * the adapters emit: the Claude manifest carries skills/agents/commands/hooks/mcp
  * (`toAnthropicManifest`), while Codex only consumes skills (`toCodexManifest`).
- * `apps` is emitted by neither, so it maps to no target. Used to derive which
- * agents a plugin is adaptable to from its exposed component types.
+ * Antigravity (`agy`) discovers the same superset as Claude via convention
+ * (skills/agents/commands/hooks dirs + mcp_config.json). `apps` is emitted by
+ * none, so it maps to no target. Used to derive which agents a plugin is
+ * adaptable to from its exposed component types.
  */
 export const ADAPTER_COMPONENTS = {
     claude: ["skills", "agents", "commands", "hooks", "mcp"],
     codex: ["skills"],
+    antigravity: ["skills", "agents", "commands", "hooks", "mcp"],
 };
-export { toAnthropicManifest, toCodexManifest };
+export { toAnthropicManifest, toCodexManifest, toAntigravityManifest };

package/dist/src/adapters/reverse.js

@@ -1,5 +1,6 @@
 import { ADG_SCHEMA_VERSION } from "../types.js";
 import { validateManifest } from "../manifest.js";
+import { toPosix } from "../fsutil.js";
 /**
  * Reverse-adapt a runtime-native manifest (.claude-plugin/plugin.json or
  * .codex-plugin/plugin.json) into a canonical ADG manifest. This is the inverse
@@ -7,8 +8,14 @@ import { validateManifest } from "../manifest.js";
  *
  * Missing `version` falls back to 0.0.0 (callers may override with a git SHA);
  * skills normalize to the manifest's array/string or the default ./skills/.
+ *
+ * `kind` disambiguates the two native skills-array conventions: Claude arrays are
+ * already `./skills/<id>` paths, while Codex arrays are bare ids. Both canonicalize
+ * to ADG's path-array contract so a later cross-adapt (e.g. codex → ADG → claude)
+ * emits valid `./skills/<id>` entries instead of leaking bare ids into a Claude
+ * manifest.
  */
-export function fromNativeManifest(raw, _kind) {
+export function fromNativeManifest(raw, kind) {
     if (typeof raw !== "object" || raw === null) {
         throw new Error("native manifest must be a JSON object");
     }
@@ -35,9 +42,16 @@ export function fromNativeManifest(raw, _kind) {
     else if (typeof n.author === "string") {
         manifest.author = { name: n.author };
     }
-    if (typeof n.skills === "string" || isStringArray(n.skills)) {
+    if (typeof n.skills === "string") {
         manifest.skills = n.skills;
     }
+    else if (isStringArray(n.skills)) {
+        // Codex arrays are bare ids; map them to ADG's `./skills/<id>` path form.
+        // Claude arrays are already paths, but a Windows-authored manifest may use
+        // backslashes, so normalize separators to keep ADG manifests POSIX-pathed
+        // (downstream `resolveSkillEntries` splits on `/`).
+        manifest.skills = kind === "codex" ? n.skills.map(toSkillPath) : n.skills.map(toPosix);
+    }
     else {
         manifest.skills = "./skills/";
     }
@@ -51,3 +65,12 @@ function copyIfString(src, dst, key) {
 function isStringArray(v) {
     return Array.isArray(v) && v.every((x) => typeof x === "string");
 }
+/**
+ * Canonicalize a skill reference (bare id or path) to ADG's `./skills/<id>` form.
+ * Accepts both `/` and `\` separators so a Windows-authored native manifest
+ * (e.g. `skills\\foo`) still yields a valid `./skills/foo` entry.
+ */
+function toSkillPath(ref) {
+    const name = ref.replace(/[\\/]+$/, "").split(/[\\/]/).pop() || ref;
+    return `./skills/${name}`;
+}

package/dist/src/agents/antigravity.js

@@ -0,0 +1,185 @@
+import { spawnSync } from "node:child_process";
+import { cpSync, existsSync, rmSync, statSync, symlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, relative } from "node:path";
+import { ensureDir, writeJson } from "../fsutil.js";
+import { readManifest } from "../manifest.js";
+import { resolveSkillEntries } from "../skills.js";
+import { isExposed } from "../components.js";
+import { installedPluginDir, lockPath } from "../paths.js";
+import { readLock } from "../lock.js";
+import { ANTIGRAVITY_PROJECTION_DIR } from "../adapters/antigravity.js";
+/**
+ * Antigravity (`agy`) agent.
+ *
+ * Antigravity discovers a plugin by convention relative to the directory handed
+ * to `agy plugin install` — `plugin.json` plus sibling `skills/`, `agents/`,
+ * `commands/`, `hooks/` dirs and a `mcp_config.json`, with no manifest path
+ * indirection. We therefore project a self-contained agy plugin root under
+ * `<store>/.antigravity-plugin/`: generated `plugin.json` + `mcp_config.json`
+ * (the ADG `mcp/.mcp.json` shape is exactly agy's, so it passes through) and
+ * *symlinks* to the real component dirs one level up, so nothing is duplicated
+ * on disk. agy follows these symlinks; where the platform forbids them (e.g.
+ * Windows without privilege) we fall back to a copy. We then drive
+ * `agy plugin install/uninstall` (which owns `~/.gemini/antigravity-cli`).
+ */
+const ID = "antigravity";
+/**
+ * Single-directory component fields: agy reads each as a sibling dir named by
+ * convention. `skills` is handled separately because it can be a path-list and
+ * supports per-skill subsetting.
+ */
+const DIR_FIELDS = ["agents", "commands", "hooks"];
+function geminiHome(env) {
+    return env.GEMINI_HOME?.trim() || join(homedir(), ".gemini");
+}
+/**
+ * agy's config/store home: `<GEMINI_HOME>/antigravity-cli` (defaulting to
+ * `~/.gemini/antigravity-cli`). Exported so the resolver itself is testable
+ * without depending on the host filesystem state.
+ */
+export function antigravityHome(env = process.env) {
+    return join(geminiHome(env), "antigravity-cli");
+}
+function available() {
+    // `--help` is rejected by `install` (it parses it as a target), so probe the
+    // plugin command group with its own `help` subcommand instead.
+    return spawnSync("agy", ["plugin", "help"], { stdio: "ignore" }).status === 0;
+}
+function run(args) {
+    const r = spawnSync("agy", args, { encoding: "utf8" });
+    const ok = r.status === 0;
+    // Surface the CLI's own diagnostics on failure instead of swallowing them.
+    if (!ok && r.stderr)
+        console.error(r.stderr.trim());
+    return { ok, out: `${r.stdout ?? ""}${r.stderr ?? ""}` };
+}
+/** Resolve a plugin's on-disk store directory and selection from the lock's provenance. */
+function pluginStore(pluginsDir, name) {
+    const entry = readLock(lockPath(pluginsDir)).plugins[name];
+    if (!entry)
+        return undefined;
+    const dir = installedPluginDir(pluginsDir, name, entry.origin);
+    return existsSync(dir) ? { dir, selection: entry.selection } : undefined;
+}
+/** First on-disk top segment of a declared component path (e.g. "./agents/" -> "agents"). */
+function componentSegment(value) {
+    const first = Array.isArray(value) ? value[0] : value;
+    if (typeof first !== "string")
+        return undefined;
+    const seg = first.replace(/^\.?[/\\]/, "").split(/[/\\]/)[0];
+    return seg || undefined;
+}
+/**
+ * Symlink `linkPath` at `absTarget` (target stored relative so the projection
+ * survives the whole plugin dir being moved), copying instead where symlinks are
+ * unavailable (e.g. Windows without privilege). Idempotent.
+ */
+function linkOrCopy(linkPath, absTarget) {
+    rmSync(linkPath, { recursive: true, force: true });
+    ensureDir(dirname(linkPath));
+    try {
+        symlinkSync(relative(dirname(linkPath), absTarget), linkPath, "dir");
+    }
+    catch {
+        cpSync(absTarget, linkPath, { recursive: true });
+    }
+}
+/**
+ * Build the agy-native projection under `<dir>/.antigravity-plugin/`: a
+ * `plugin.json` (name only), a `mcp_config.json` copied verbatim from the
+ * manifest's mcp file when present, and relative symlinks (copy fallback) to the
+ * declared component dirs named for agy's convention.
+ *
+ * An optional `selection` (the plugin's partial install) narrows what is
+ * projected: component categories outside it are dropped, and `skills` is pinned
+ * to the selected subset. `skills` is also projected per-skill into a real
+ * `skills/` dir, so a path-list spanning multiple roots is fully honored rather
+ * than collapsing to its first root. Idempotent; safe to re-run.
+ */
+export function writeAntigravityProjection(dir, selection) {
+    const manifest = readManifest(dir);
+    const stage = join(dir, ANTIGRAVITY_PROJECTION_DIR);
+    ensureDir(stage);
+    writeJson(join(stage, "plugin.json"), { name: manifest.name });
+    const mcpConfig = join(stage, "mcp_config.json");
+    rmSync(mcpConfig, { force: true });
+    if (manifest.mcp && isExposed(selection, "mcp")) {
+        const mcpFile = join(dir, manifest.mcp);
+        // The ADG mcp file shape is exactly agy's `mcp_config.json`, so copy it
+        // verbatim — preserving formatting and avoiding a parse/re-serialize round-trip.
+        if (existsSync(mcpFile))
+            cpSync(mcpFile, mcpConfig);
+    }
+    const skillsDir = join(stage, "skills");
+    rmSync(skillsDir, { recursive: true, force: true });
+    if (manifest.skills !== undefined && isExposed(selection, "skills")) {
+        const pick = selection?.skills;
+        for (const e of resolveSkillEntries(dir, manifest)) {
+            if (pick && !pick.includes(e.name))
+                continue;
+            if (!e.skillMd)
+                continue;
+            const srcSkillDir = dirname(e.skillMd);
+            if (existsSync(srcSkillDir) && statSync(srcSkillDir).isDirectory()) {
+                linkOrCopy(join(skillsDir, e.name), srcSkillDir);
+            }
+        }
+    }
+    for (const field of DIR_FIELDS) {
+        const link = join(stage, field);
+        rmSync(link, { recursive: true, force: true });
+        if (!isExposed(selection, field))
+            continue;
+        const seg = componentSegment(manifest[field]);
+        if (!seg)
+            continue;
+        const srcDir = join(dir, seg);
+        // agy reads the component by its convention name (`field`); point that at
+        // the real source dir so a non-conventional source name still resolves.
+        if (existsSync(srcDir))
+            linkOrCopy(link, srcDir);
+    }
+}
+export const antigravityAgent = {
+    id: ID,
+    displayName: "Antigravity",
+    adaptTarget: "antigravity",
+    detect: (env = process.env) => existsSync(antigravityHome(env)),
+    available,
+    activate(ctx) {
+        if (!available())
+            return { agent: ID, affected: [], skipped: true };
+        const affected = [];
+        for (const p of ctx.plugins) {
+            // Isolate each plugin: a malformed manifest or a filesystem error must not
+            // abort activation of the remaining (valid) plugins.
+            try {
+                const store = pluginStore(ctx.pluginsDir, p);
+                if (!store)
+                    continue;
+                writeAntigravityProjection(store.dir, store.selection);
+                if (run(["plugin", "install", join(store.dir, ANTIGRAVITY_PROJECTION_DIR)]).ok)
+                    affected.push(p);
+            }
+            catch (err) {
+                console.error(`failed to enable "${p}" in Antigravity:`, err);
+            }
+        }
+        return { agent: ID, affected, skipped: false };
+    },
+    deactivate(ctx) {
+        if (!available())
+            return { agent: ID, affected: [], skipped: true };
+        const affected = [];
+        for (const p of ctx.plugins) {
+            if (run(["plugin", "uninstall", p]).ok)
+                affected.push(p);
+        }
+        return { agent: ID, affected, skipped: false };
+    },
+    // `agy plugin install` re-imports the source dir, so re-running it is the refresh.
+    refresh(ctx) {
+        return antigravityAgent.activate(ctx);
+    },
+};

package/dist/src/agents/claude.js

@@ -2,7 +2,7 @@ import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, relative } from "node:path";
-import { writeJson } from "../fsutil.js";
+import { toPosix, writeJson } from "../fsutil.js";
 import { readManifest } from "../manifest.js";
 import { installedPluginDir, lockPath } from "../paths.js";
 import { readLock } from "../lock.js";
@@ -15,9 +15,6 @@ import { readLock } from "../lock.js";
  * versions) rather than hand-editing Claude's internal state.
  */
 const MARKETPLACE = "adg";
-function toPosix(p) {
-    return p.split("\\").join("/");
-}
 function claudeHome(env) {
     return env.CLAUDE_CONFIG_DIR?.trim() || join(homedir(), ".claude");
 }

package/dist/src/agents/index.js

@@ -1,10 +1,12 @@
 import { registerAgent } from "./registry.js";
 import { claudeAgent } from "./claude.js";
 import { codexAgent } from "./codex.js";
+import { antigravityAgent } from "./antigravity.js";
 // Built-in agents register on import. Third-party agents can `registerAgent()`
 // their own implementation (stage 2: discover from config without core edits).
 registerAgent(claudeAgent);
 registerAgent(codexAgent);
+registerAgent(antigravityAgent);
 export * from "./types.js";
 export { registerAgent, getAgent, allAgents, detectedAgents, resolveAgents, agentsForComponents } from "./registry.js";
 export { writeClaudeCatalog } from "./claude.js";

package/dist/src/commands/install.js

@@ -4,9 +4,9 @@ import { basename, join, relative, resolve } from "node:path";
 import { ADAPTER_TARGETS } from "../adapters/index.js";
 import { fromNativeManifest } from "../adapters/reverse.js";
 import { adaptPlugin } from "./adapt.js";
-import { copyPluginDir, writeJson } from "../fsutil.js";
+import { copyPluginDir, toPosix, writeJson } from "../fsutil.js";
 import { folderHash } from "../hash.js";
-import { packageFilter } from "../package.js";
+import { packageFilter, PROJECTION_DIRS } from "../package.js";
 import { lockPath, marketplacePath, marketplaceSourcePath, pluginDir } from "../paths.js";
 import { readLock, upsertEntry, writeLock } from "../lock.js";
 import { ADG_MANIFEST_PATH, readManifest } from "../manifest.js";
@@ -17,10 +17,8 @@ import { sameSource, COMPONENT_TYPES } from "../types.js";
 import { pluginContents, presentComponents } from "../components.js";
 import { skillDescriptionLoader } from "../skills.js";
 import { resolveAgents } from "../agents/index.js";
-const HASH_IGNORE = [".claude-plugin", ".codex-plugin"];
-function toPosix(p) {
-    return p.split("\\").join("/");
-}
+// Generated runtime projections never count toward a plugin's content hash.
+const HASH_IGNORE = PROJECTION_DIRS;
 /**
  * Install a single local plugin directory into a plugins directory: copy the
  * source, generate adapter manifests, compute the folder hash, and update both

package/dist/src/commands/update.js

@@ -1,10 +1,11 @@
 import { existsSync } from "node:fs";
 import { folderHash } from "../hash.js";
-import { packageFilter } from "../package.js";
+import { packageFilter, PROJECTION_DIRS } from "../package.js";
 import { lockPath, installedPluginDir } from "../paths.js";
 import { readLock, writeLock } from "../lock.js";
 import { readManifest } from "../manifest.js";
 import { adaptPlugin } from "./adapt.js";
+import { ADAPTER_TARGETS } from "../adapters/index.js";
 import { resolveAgents } from "../agents/index.js";
 /**
  * Re-scan installed plugins in a plugins directory, refreshing each lock
@@ -29,14 +30,16 @@ export function updateLock(pluginsDir, now = new Date().toISOString(), opts = {}
             continue;
         }
         const manifest = readManifest(dir);
-        const hash = folderHash(dir, [".claude-plugin", ".codex-plugin"], packageFilter(manifest, { includeProjections: false }));
+        const hash = folderHash(dir, PROJECTION_DIRS, packageFilter(manifest, { includeProjections: false }));
         const changed = hash !== entry.folderHash || manifest.version !== entry.version;
         if (changed) {
             entry.folderHash = hash;
             entry.version = manifest.version;
             entry.updatedAt = now;
             // Regenerate runtime manifests from the updated source, honoring selection.
-            adaptPlugin(dir, ["claude", "codex"], entry.selection);
+            // Covers every registered adapter target (claude/codex/antigravity) so a
+            // projection can't go stale after an update.
+            adaptPlugin(dir, [...ADAPTER_TARGETS], entry.selection);
             changedNames.push(name);
         }
         results.push({ name, changed, version: manifest.version, folderHash: hash });

package/dist/src/fsutil.js

@@ -3,6 +3,10 @@ import { dirname, relative } from "node:path";
 export function ensureDir(dir) {
     mkdirSync(dir, { recursive: true });
 }
+/** Normalize a path to forward slashes (stable across Windows and POSIX hosts). */
+export function toPosix(p) {
+    return p.split("\\").join("/");
+}
 export function writeJson(file, value) {
     ensureDir(dirname(file));
     writeFileSync(file, JSON.stringify(value, null, 2) + "\n");

package/dist/src/package.js

@@ -11,7 +11,7 @@
 /** Top-level metadata files always shipped with a plugin, matched case-insensitively. */
 const META_RE = /^(README|LICEN[CS]E|CHANGELOG|NOTICE)(\..+)?$/i;
 /** Generated runtime projections — shipped, but excluded from the content hash. */
-export const PROJECTION_DIRS = [".claude-plugin", ".codex-plugin"];
+export const PROJECTION_DIRS = [".claude-plugin", ".codex-plugin", ".antigravity-plugin"];
 /** Extract the first path segment of a manifest component value (e.g. "./skills/" -> "skills"). */
 function topSegment(p) {
     return p.replace(/^\.?[/\\]/, "").split(/[/\\]/)[0] ?? "";

package/dist/src/semver.js

@@ -19,6 +19,82 @@ export function compare(a, b) {
     }
     return 0;
 }
+/**
+ * Extract the dot-separated pre-release identifiers from a version string.
+ *
+ * Returns the segment after the first `-` (and before any `+` build metadata),
+ * with numeric-only identifiers coerced to `number`. A stable version (no
+ * pre-release) yields `[]`.
+ */
+export function parsePrerelease(v) {
+    // Drop build metadata first so a hyphen inside it (e.g. `1.2.3+build-1`) is
+    // not mistaken for the pre-release separator.
+    const withoutBuild = v.split("+")[0] ?? "";
+    const dashIndex = withoutBuild.indexOf("-");
+    if (dashIndex === -1)
+        return [];
+    const pre = withoutBuild.slice(dashIndex + 1);
+    if (pre === "")
+        return [];
+    return pre.split(".").map((id) => (/^\d+$/.test(id) ? Number(id) : id));
+}
+/**
+ * Compare two pre-release identifier lists per SemVer §11.
+ *
+ * A stable version (empty list) outranks any pre-release. Otherwise identifiers
+ * are compared left to right: numeric identifiers rank below alphanumeric ones,
+ * numerics compare numerically, strings compare by ASCII, and when every shared
+ * field is equal the longer list wins.
+ */
+export function comparePrerelease(a, b) {
+    if (a.length === 0 && b.length === 0)
+        return 0;
+    if (a.length === 0)
+        return 1; // stable > pre-release
+    if (b.length === 0)
+        return -1;
+    const len = Math.min(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+        const x = a[i];
+        const y = b[i];
+        if (x === y)
+            continue;
+        const xNum = typeof x === "number";
+        const yNum = typeof y === "number";
+        if (xNum && yNum)
+            return x < y ? -1 : 1;
+        if (xNum !== yNum)
+            return xNum ? -1 : 1; // numeric < alphanumeric
+        return x < y ? -1 : 1;
+    }
+    // All shared fields equal: the list with more fields has higher precedence.
+    return a.length === b.length ? 0 : a.length < b.length ? -1 : 1;
+}
+/**
+ * Full version comparison including pre-release precedence.
+ *
+ * Unlike {@link compare}, this honors the pre-release suffix so that, e.g.,
+ * `0.3.0-beta.2 < 0.3.0-beta.3 < 0.3.0`. Used by the update check; range
+ * matching ({@link satisfies}) deliberately ignores pre-release.
+ */
+export function compareVersions(a, b) {
+    const core = compare(parseVersion(a), parseVersion(b));
+    if (core !== 0)
+        return core;
+    return comparePrerelease(parsePrerelease(a), parsePrerelease(b));
+}
+/**
+ * Return the pre-release channel of a version — its first non-numeric
+ * pre-release identifier (e.g. `0.3.0-beta.2` -> `"beta"`), or `null` for a
+ * stable version. Used to pick the matching npm dist-tag.
+ */
+export function prereleaseChannel(v) {
+    for (const id of parsePrerelease(v)) {
+        if (typeof id === "string")
+            return id;
+    }
+    return null;
+}
 export function satisfies(version, range) {
     const v = parseVersion(version);
     const r = range.trim();

package/dist/src/skills.js

@@ -42,6 +42,37 @@ export function resolveSkillEntries(pluginDir, manifest) {
 export function resolveSkills(pluginDir, manifest) {
     return resolveSkillEntries(pluginDir, manifest).map((e) => e.name);
 }
+/**
+ * Decide the skills a forward adapter should project from an ADG manifest, the
+ * one strict/selection decision both adapters share (previously copy-pasted, so
+ * it could drift — see the Codex/Claude strict regression that motivated it).
+ *
+ * In the default strict case the declared skills *root* string is passed through
+ * (the runtime discovers skills from the directory); an omitted `skills` is
+ * treated as the default `./skills/` root so the strict default stays
+ * directory-discovery rather than an explicit enumeration. A `selection` or
+ * `strict: false` always yields an explicit resolved id list. A declared `skills`
+ * *array* is runtime-dependent: `passthroughArray` keeps it verbatim (Claude,
+ * whose entries are already `./skills/<id>` paths), otherwise it resolves to ids
+ * (Codex, whose array form is bare ids).
+ */
+export function resolveProjectedSkills(pluginDir, manifest, selection, opts) {
+    if (selection) {
+        const skills = selection.components.includes("skills")
+            ? selection.skills ?? resolveSkills(pluginDir, manifest)
+            : [];
+        return { skills, explicit: true };
+    }
+    const strict = manifest.strict !== false;
+    // An omitted `skills` defaults to the `./skills/` root, so a strict manifest
+    // without a declaration keeps directory discovery instead of being forced to
+    // an explicit `strict: false` enumeration.
+    const declared = manifest.skills ?? "./skills/";
+    const passthrough = strict && (typeof declared === "string" || (opts.passthroughArray && Array.isArray(declared)));
+    if (passthrough)
+        return { skills: declared, explicit: false };
+    return { skills: resolveSkills(pluginDir, manifest), explicit: true };
+}
 /** Read a SKILL.md's `description` from its YAML frontmatter (undefined if absent). */
 export function readSkillDescription(skillMd) {
     try {

package/dist/src/sources.js

@@ -105,11 +105,11 @@ function walkNative(current, out) {
         return;
     }
     if (existsSync(claude)) {
-        out.push({ dir: current, kind: "anthropic", manifestFile: claude });
+        out.push({ dir: current, kind: "claude", manifestFile: claude });
         return;
     }
     if (existsSync(codex)) {
-        out.push({ dir: current, kind: "openai", manifestFile: codex });
+        out.push({ dir: current, kind: "codex", manifestFile: codex });
         return;
     }
     for (const entry of readdirSync(current, { withFileTypes: true })) {

package/dist/src/update-check.js

@@ -10,12 +10,20 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import https from "node:https";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { compare, parseVersion } from "./semver.js";
+import { compareVersions, prereleaseChannel } from "./semver.js";
 const PACKAGE_NAME = "@rbbtsn0w/adg";
 // URL-encode the slash in the scoped package name for the npm registry API.
-const REGISTRY_URL = `https://registry.npmjs.org/@rbbtsn0w%2Fadg/latest`;
+// The abbreviated packument (vnd.npm.install-v1+json) is small and exposes
+// `dist-tags`, which we need to follow the caller's release channel (e.g. the
+// `beta` dist-tag for pre-release users, not just `latest`).
+const REGISTRY_URL = `https://registry.npmjs.org/@rbbtsn0w%2Fadg`;
+const REGISTRY_ACCEPT = "application/vnd.npm.install-v1+json";
 const CACHE_FILENAME = "update-check.json";
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+// Cap the accumulated response body. The abbreviated packument is small, but a
+// registry that ignores the abbreviated Accept header (or returns an unexpected
+// payload) could stream a much larger body; abort rather than grow unbounded.
+const MAX_RESPONSE_BYTES = 1024 * 1024; // 1 MiB
 /** Resolve the directory that holds the update-check cache file. */
 export function updateCacheDir(env = process.env) {
     const stateHome = env.XDG_STATE_HOME ?? join(homedir(), ".local", "state");
@@ -46,6 +54,29 @@ export function writeUpdateCache(cache, env = process.env) {
         // Ignore write errors (read-only FS, permissions, etc.)
     }
 }
+/**
+ * Pick the newest version relevant to the caller's release channel from the
+ * registry's `dist-tags`.
+ *
+ * Always considers `latest` (stable). When `currentVersion` is a pre-release
+ * (e.g. `0.3.0-beta.2`) it also considers the matching channel tag (e.g.
+ * `beta`), so pre-release users are notified of newer pre-releases as well as a
+ * newer stable. Returns the max candidate by pre-release-aware comparison, or
+ * `undefined` when no usable tag is present.
+ */
+export function resolveLatestForChannel(currentVersion, distTags) {
+    if (!distTags)
+        return undefined;
+    const candidates = [];
+    if (typeof distTags.latest === "string")
+        candidates.push(distTags.latest);
+    const channel = prereleaseChannel(currentVersion);
+    if (channel && typeof distTags[channel] === "string")
+        candidates.push(distTags[channel]);
+    if (candidates.length === 0)
+        return undefined;
+    return candidates.reduce((best, v) => (compareVersions(v, best) > 0 ? v : best));
+}
 /**
  * Fire-and-forget background fetch of the latest version from the npm registry.
  * The socket is unreffed so Node can exit naturally without waiting for the
@@ -53,14 +84,26 @@ export function writeUpdateCache(cache, env = process.env) {
  */
 export function scheduleUpdateCacheRefresh(currentVersion, env = process.env) {
     try {
-        const req = https.get(REGISTRY_URL, { headers: { "User-Agent": `adg/${currentVersion}`, Accept: "application/json" } }, (res) => {
+        const req = https.get(REGISTRY_URL, { headers: { "User-Agent": `adg/${currentVersion}`, Accept: REGISTRY_ACCEPT } }, (res) => {
             let body = "";
-            res.on("data", (chunk) => { body += String(chunk); });
+            let byteCount = 0;
+            res.on("data", (chunk) => {
+                byteCount += Buffer.byteLength(chunk);
+                if (byteCount > MAX_RESPONSE_BYTES) {
+                    // Oversized payload: stop reading and abort so we neither buffer
+                    // unbounded memory nor parse a partial body.
+                    body = "";
+                    req.destroy();
+                    return;
+                }
+                body += String(chunk);
+            });
             res.on("end", () => {
                 try {
                     const data = JSON.parse(body);
-                    if (typeof data.version === "string") {
-                        writeUpdateCache({ latestVersion: data.version, checkedAt: new Date().toISOString() }, env);
+                    const latestVersion = resolveLatestForChannel(currentVersion, data["dist-tags"]);
+                    if (latestVersion !== undefined) {
+                        writeUpdateCache({ latestVersion, checkedAt: new Date().toISOString() }, env);
                     }
                 }
                 catch {
@@ -103,9 +146,7 @@ export function checkForUpdate(currentVersion, env = process.env, refresh = sche
     if (!cache)
         return undefined;
     try {
-        const current = parseVersion(currentVersion);
-        const latest = parseVersion(cache.latestVersion);
-        return compare(latest, current) > 0 ? cache.latestVersion : undefined;
+        return compareVersions(cache.latestVersion, currentVersion) > 0 ? cache.latestVersion : undefined;
     }
     catch {
         return undefined;
@@ -113,6 +154,11 @@ export function checkForUpdate(currentVersion, env = process.env, refresh = sche
 }
 /** Format an update notice for display on stderr. */
 export function formatUpdateNotice(currentVersion, latestVersion) {
+    // A pre-release suggestion lives on its channel dist-tag (e.g. `beta`), not
+    // `latest`; installing `@latest` would pull the stable release instead of the
+    // advertised version. Pin to the exact version so the right artifact installs.
+    const channel = prereleaseChannel(latestVersion);
+    const installTarget = channel ? latestVersion : "latest";
     return (`\n  Update available: ${currentVersion} → ${latestVersion}\n` +
-        `  Run: npm install -g ${PACKAGE_NAME}@latest\n`);
+        `  Run: npm install -g ${PACKAGE_NAME}@${installTarget}\n`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rbbtsn0w/adg",
-  "version": "0.3.0-beta.1",
+  "version": "0.3.0-beta.3",
   "description": "Agent Directory Group (ADG) toolkit — two domains: plugins and skills.",
   "type": "module",
   "license": "MIT",