@aiwg/cli 2026.9.1 → 2026.9.3

package/dist/src/storage/fortemi-qualification-receipt.js

@@ -0,0 +1,206 @@
+import { createHash } from "node:crypto";
+import { link, mkdir, unlink, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { execFileSync } from "node:child_process";
+export const FORTEMI_QUALIFICATION_RECEIPT = "aiwg.fortemi-live-qualification-receipt/v1";
+const DIGEST = /^sha256:[0-9a-f]{64}$/;
+const COMMIT = /^[0-9a-f]{40}$/;
+const REF = /^(?:refs\/(?:heads|tags)\/[A-Za-z0-9._/-]+|[0-9a-f]{40})$/;
+const SHORT_REF = /^[A-Za-z0-9._/-]+$/;
+const SAFE = /^[A-Za-z0-9._:/-]+$/;
+const NAMESPACE = /^aiwg-qualification-[0-9a-f-]{36}$/;
+const REQUIRED_OPERATIONS = new Set([
+    "read",
+    "write",
+    "update",
+    "list",
+    "query",
+]);
+function hasCompleteOperationInventory(operations) {
+    const names = operations.map((operation) => operation.operation);
+    return (names.length === REQUIRED_OPERATIONS.size &&
+        new Set(names).size === REQUIRED_OPERATIONS.size &&
+        names.every((name) => REQUIRED_OPERATIONS.has(name)));
+}
+export function resolveFortemiQualificationSource(env = process.env, cwd = process.cwd()) {
+    const git = (...args) => execFileSync("git", args, {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    const aiwgCommit = env.AIWG_STORAGE_QUALIFICATION_COMMIT || git("rev-parse", "HEAD");
+    const configuredRef = env.AIWG_STORAGE_QUALIFICATION_BRANCH;
+    const aiwgRef = configuredRef
+        ? REF.test(configuredRef)
+            ? configuredRef
+            : SHORT_REF.test(configuredRef) && !configuredRef.includes("..")
+                ? `refs/heads/${configuredRef}`
+                : configuredRef
+        : (() => {
+            try {
+                return git("symbolic-ref", "-q", "HEAD");
+            }
+            catch {
+                return aiwgCommit;
+            }
+        })();
+    if (!COMMIT.test(aiwgCommit))
+        throw new Error("FORTEMI_RECEIPT_INVALID_COMMIT");
+    if (!REF.test(aiwgRef) || aiwgRef.includes(".."))
+        throw new Error("FORTEMI_RECEIPT_INVALID_REF");
+    return { aiwgCommit, aiwgRef };
+}
+function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    if (value && typeof value === "object")
+        return `{${Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`)
+            .join(",")}}`;
+    return JSON.stringify(value);
+}
+export function fortemiReceiptDigest(value) {
+    return `sha256:${createHash("sha256").update(canonical(value)).digest("hex")}`;
+}
+export function endpointFingerprint(rawUrl) {
+    const url = new URL(rawUrl);
+    url.username = "";
+    url.password = "";
+    url.hash = "";
+    return fortemiReceiptDigest(url.toString());
+}
+function receiptMaterial(receipt) {
+    const { receiptDigest: _digest, ...material } = receipt;
+    return material;
+}
+export function createFortemiQualificationReceipt(input) {
+    if (!COMMIT.test(input.aiwgCommit))
+        throw new Error("FORTEMI_RECEIPT_INVALID_COMMIT");
+    if (!REF.test(input.aiwgRef) || input.aiwgRef.includes(".."))
+        throw new Error("FORTEMI_RECEIPT_INVALID_REF");
+    if (!input.report.server.name || !SAFE.test(input.report.server.name))
+        throw new Error("FORTEMI_RECEIPT_INVALID_SERVER_NAME");
+    if (!input.report.server.version || !SAFE.test(input.report.server.version))
+        throw new Error("FORTEMI_RECEIPT_INVALID_SERVER_VERSION");
+    if (!SAFE.test(input.contractRevision))
+        throw new Error("FORTEMI_RECEIPT_INVALID_CONTRACT_REVISION");
+    if (!NAMESPACE.test(input.report.namespace))
+        throw new Error("FORTEMI_RECEIPT_INVALID_NAMESPACE");
+    if (input.report.mutationAttempted !== Boolean(input.mutationObjectId))
+        throw new Error("FORTEMI_RECEIPT_MUTATION_BINDING_MISMATCH");
+    if (input.mutationObjectId && !SAFE.test(input.mutationObjectId))
+        throw new Error("FORTEMI_RECEIPT_INVALID_OBJECT_ID");
+    const start = Date.parse(input.startedAt);
+    const end = Date.parse(input.endedAt);
+    if (!Number.isFinite(start) || !Number.isFinite(end) || end < start)
+        throw new Error("FORTEMI_RECEIPT_INVALID_TIMESTAMPS");
+    if (!Number.isInteger(input.timeoutMs) ||
+        input.timeoutMs < 250 ||
+        input.timeoutMs > 30_000 ||
+        !Number.isInteger(input.networkAttempts) ||
+        input.networkAttempts < 0)
+        throw new Error("FORTEMI_RECEIPT_INVALID_RESOURCES");
+    const operations = input.report.operations.map(({ operation, tool, compatible, code }) => {
+        if (![operation, tool, code].every((value) => SAFE.test(value)))
+            throw new Error("FORTEMI_RECEIPT_UNSAFE_OPERATION");
+        return { operation, tool, compatible, code };
+    });
+    if (!hasCompleteOperationInventory(operations))
+        throw new Error("FORTEMI_RECEIPT_OPERATION_INVENTORY_INVALID");
+    const material = {
+        contract: FORTEMI_QUALIFICATION_RECEIPT,
+        outcome: input.report.compatible ? "passed" : "failed",
+        bindings: {
+            aiwgCommit: input.aiwgCommit,
+            aiwgRef: input.aiwgRef,
+            endpointFingerprint: endpointFingerprint(input.endpointUrl),
+            toolSchemaDigest: fortemiReceiptDigest(input.toolSchemas),
+        },
+        observed: {
+            serverName: input.report.server.name,
+            serverVersion: input.report.server.version,
+            contractRevision: input.contractRevision,
+        },
+        namespace: input.report.namespace,
+        operations,
+        mutation: {
+            attempted: input.report.mutationAttempted,
+            ...(input.mutationObjectId ? { objectId: input.mutationObjectId } : {}),
+        },
+        startedAt: new Date(start).toISOString(),
+        endedAt: new Date(end).toISOString(),
+        resources: {
+            timeoutMs: input.timeoutMs,
+            durationMs: end - start,
+            networkAttempts: input.networkAttempts,
+            toolCount: operations.length,
+        },
+    };
+    return { ...material, receiptDigest: fortemiReceiptDigest(material) };
+}
+export function verifyFortemiQualificationReceipt(receipt) {
+    const errors = [];
+    if (receipt.contract !== FORTEMI_QUALIFICATION_RECEIPT)
+        errors.push("FORTEMI_RECEIPT_CONTRACT_MISMATCH");
+    if (!["passed", "failed"].includes(receipt.outcome) ||
+        receipt.outcome !==
+            (receipt.operations.every((operation) => operation.compatible)
+                ? "passed"
+                : "failed"))
+        errors.push("FORTEMI_RECEIPT_OUTCOME_INVALID");
+    if (!DIGEST.test(receipt.receiptDigest) ||
+        receipt.receiptDigest !== fortemiReceiptDigest(receiptMaterial(receipt)))
+        errors.push("FORTEMI_RECEIPT_DIGEST_MISMATCH");
+    if (!DIGEST.test(receipt.bindings.endpointFingerprint) ||
+        !DIGEST.test(receipt.bindings.toolSchemaDigest))
+        errors.push("FORTEMI_RECEIPT_BINDING_INVALID");
+    if (!COMMIT.test(receipt.bindings.aiwgCommit) ||
+        !REF.test(receipt.bindings.aiwgRef))
+        errors.push("FORTEMI_RECEIPT_SOURCE_INVALID");
+    if (!SAFE.test(receipt.observed.serverName) ||
+        !SAFE.test(receipt.observed.serverVersion) ||
+        !SAFE.test(receipt.observed.contractRevision) ||
+        !NAMESPACE.test(receipt.namespace))
+        errors.push("FORTEMI_RECEIPT_OBSERVATION_INVALID");
+    if (receipt.operations.some((item) => !SAFE.test(item.operation) ||
+        !SAFE.test(item.tool) ||
+        !SAFE.test(item.code)))
+        errors.push("FORTEMI_RECEIPT_OPERATION_INVALID");
+    if (!hasCompleteOperationInventory(receipt.operations))
+        errors.push("FORTEMI_RECEIPT_OPERATION_INVENTORY_INVALID");
+    if (receipt.mutation.attempted !== Boolean(receipt.mutation.objectId) ||
+        (receipt.mutation.objectId && !SAFE.test(receipt.mutation.objectId)))
+        errors.push("FORTEMI_RECEIPT_MUTATION_INVALID");
+    if (Date.parse(receipt.endedAt) < Date.parse(receipt.startedAt) ||
+        receipt.resources.durationMs !==
+            Date.parse(receipt.endedAt) - Date.parse(receipt.startedAt))
+        errors.push("FORTEMI_RECEIPT_TIME_INVALID");
+    if (!Number.isInteger(receipt.resources.timeoutMs) ||
+        receipt.resources.timeoutMs < 250 ||
+        receipt.resources.timeoutMs > 30_000 ||
+        !Number.isInteger(receipt.resources.networkAttempts) ||
+        receipt.resources.networkAttempts < 0 ||
+        receipt.resources.toolCount !== receipt.operations.length)
+        errors.push("FORTEMI_RECEIPT_RESOURCES_INVALID");
+    return errors;
+}
+export async function writeFortemiQualificationReceipt(path, receipt) {
+    const errors = verifyFortemiQualificationReceipt(receipt);
+    if (errors.length)
+        throw new Error(errors.join(","));
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = `${path}.tmp-${process.pid}`;
+    await writeFile(temporary, `${JSON.stringify(receipt, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+        flag: "wx",
+    });
+    try {
+        await link(temporary, path);
+    }
+    finally {
+        await unlink(temporary).catch(() => undefined);
+    }
+}
+//# sourceMappingURL=fortemi-qualification-receipt.js.map

package/dist/src/storage/fortemi-qualification.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
-import { FortemiAdapter } from "./backends/fortemi.js";
+import { FortemiAdapter, fortemiStableNoteId, } from "./backends/fortemi.js";
 export const FORTEMI_QUALIFICATION_VERSION = "aiwg.fortemi-live-qualification/v1";
-const EXPECTED = {
+const LEGACY_EXPECTED = {
     read: { tool: "get_note", required: ["note_id"], properties: ["note_id"] },
     write: {
         tool: "capture_knowledge",
@@ -20,6 +20,37 @@ const EXPECTED = {
         properties: ["query", "id_prefix"],
     },
 };
+const SOURCE_ADDRESSED_EXPECTED = {
+    read: { tool: "get_note", required: ["id"], properties: ["id"] },
+    write: {
+        tool: "upsert_external_notes",
+        required: [
+            "source_namespace",
+            "source_schema_version",
+            "import_run_id",
+            "items",
+        ],
+        properties: [
+            "source_namespace",
+            "source_schema_version",
+            "import_run_id",
+            "batch_id",
+            "policy",
+            "items",
+        ],
+    },
+    update: {
+        tool: "update_note",
+        required: ["id"],
+        properties: ["id", "content", "archived"],
+    },
+    list: { tool: "list_notes", required: [], properties: ["limit", "offset"] },
+    query: {
+        tool: "search",
+        required: ["action"],
+        properties: ["action", "query", "limit"],
+    },
+};
 function bounded(work, timeoutMs, label) {
     let timer;
     return Promise.race([
@@ -50,8 +81,19 @@ export async function qualifyLiveFortemi(client, options = {}) {
         if (!client.listTools)
             throw new Error("FORTEMI_TOOL_DISCOVERY_UNAVAILABLE");
         const discovered = await bounded(client.listTools(), timeoutMs, "tools/list");
+        options.onToolSchemas?.(discovered.tools ?? []);
         const tools = new Map((discovered.tools ?? []).map((tool) => [tool.name, tool]));
-        for (const [operation, expected] of Object.entries(EXPECTED)) {
+        const getProperties = tools.get("get_note")?.inputSchema?.properties;
+        const profile = tools.has("upsert_external_notes") &&
+            getProperties &&
+            typeof getProperties === "object" &&
+            "id" in getProperties
+            ? "source-addressed-v1"
+            : "legacy-note-id";
+        const expectedOperations = profile === "source-addressed-v1"
+            ? SOURCE_ADDRESSED_EXPECTED
+            : LEGACY_EXPECTED;
+        for (const [operation, expected] of Object.entries(expectedOperations)) {
             const tool = tools.get(expected.tool);
             const schema = tool?.inputSchema;
             const properties = schema?.properties && typeof schema.properties === "object"
@@ -62,9 +104,23 @@ export async function qualifyLiveFortemi(client, options = {}) {
                 : [];
             const missing = expected.properties.filter((name) => !(name in properties));
             const missingRequired = expected.required.filter((name) => !required.includes(name));
+            const itemProperties = operation === "write" && profile === "source-addressed-v1"
+                ? (properties.items?.items?.properties ?? {})
+                : {};
+            const missingItemProperties = operation === "write" && profile === "source-addressed-v1"
+                ? [
+                    "external_id",
+                    "content",
+                    "content_digest",
+                    "caller_stable_id",
+                    "metadata",
+                    "policy",
+                ].filter((name) => !(name in itemProperties))
+                : [];
             const compatible = Boolean(tool && schema) &&
                 missing.length === 0 &&
-                missingRequired.length === 0;
+                missingRequired.length === 0 &&
+                missingItemProperties.length === 0;
             report.operations.push({
                 operation,
                 tool: expected.tool,
@@ -76,7 +132,7 @@ export async function qualifyLiveFortemi(client, options = {}) {
                         : "FORTEMI_TOOL_MISSING",
                 detail: compatible
                     ? "expected adapter arguments are accepted"
-                    : `missing properties: ${missing.join(", ") || "none"}; not required: ${missingRequired.join(", ") || "none"}`,
+                    : `missing properties: ${missing.join(", ") || "none"}; not required: ${missingRequired.join(", ") || "none"}; missing item properties: ${missingItemProperties.join(", ") || "none"}`,
             });
         }
         report.compatible = report.operations.every((item) => item.compatible);
@@ -93,7 +149,12 @@ export async function qualifyLiveFortemi(client, options = {}) {
         await bounded(adapter.query(`aiwg qualification ${namespace}`), timeoutMs, "adapter query");
         if (options.allowMutation) {
             report.mutationAttempted = true;
-            await bounded(adapter.write(randomUUID(), `AIWG live qualification ${namespace}`, {
+            const mutationPath = randomUUID();
+            report.mutationObjectId =
+                profile === "source-addressed-v1"
+                    ? fortemiStableNoteId(namespace, mutationPath)
+                    : `${namespace}:${mutationPath}`;
+            await bounded(adapter.write(mutationPath, `AIWG live qualification ${namespace}`, {
                 contentType: "text/plain",
             }), timeoutMs, "adapter write");
         }

package/dist/src/storage/index.js

@@ -22,6 +22,7 @@ export { ObsidianAdapter } from './backends/obsidian.js';
 export { LogseqAdapter } from './backends/logseq.js';
 export { FortemiAdapter } from './backends/fortemi.js';
 export { qualifyLiveFortemi, FORTEMI_QUALIFICATION_VERSION, } from './fortemi-qualification.js';
+export { createFortemiQualificationReceipt, endpointFingerprint, fortemiReceiptDigest, verifyFortemiQualificationReceipt, writeFortemiQualificationReceipt, FORTEMI_QUALIFICATION_RECEIPT, } from './fortemi-qualification-receipt.js';
 export { STORAGE_BACKEND_CONTRACT, STORAGE_BACKEND_MATRIX, StorageCapabilityError, negotiateStorageCapabilities, } from './backend-contract.js';
 export { STORAGE_MIGRATION_PROTOCOL, MigrationProtocolError, StorageMigrationCoordinator, approvalDigest, digestRecordChunks, digestRecords, validateManifest, } from './migration-protocol.js';
 export { PostgresStorageBackend, PostgresBackendError, } from './backends/postgres.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwg/cli",
-  "version": "2026.9.1",
+  "version": "2026.9.3",
   "description": "Lightweight AIWG CLI for signed, versioned web-backed resources.",
   "type": "module",
   "license": "MIT",
@@ -39,6 +39,7 @@
     "tools/_resolve-impl.mjs",
     "tools/agents/deploy-agents.mjs",
     "tools/agents/providers/",
+    "tools/providers/antigravity-transport.mjs",
     "tools/commands/deploy-prompts-codex.mjs",
     "tools/plugin/package-plugins.mjs",
     "tools/skills/deploy-skills-codex.mjs",

package/schemas/dataset/fortemi-live-qualification-receipt.v1.schema.json

@@ -0,0 +1,132 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://aiwg.io/schemas/dataset/fortemi-live-qualification-receipt.v1.schema.json",
+  "title": "AIWG Fortemi Dataset Live Qualification Receipt v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "contract",
+    "outcome",
+    "diagnostic",
+    "receiptDigest",
+    "bindings",
+    "observed",
+    "namespace",
+    "operations",
+    "mutation",
+    "resources",
+    "startedAt",
+    "endedAt"
+  ],
+  "properties": {
+    "contract": { "const": "aiwg.fortemi-dataset-live-qualification/v1" },
+    "outcome": { "enum": ["pending", "supported"] },
+    "diagnostic": {
+      "enum": [
+        "CONFORMANCE_FORTEMI_DATASET_CONTRACT_UNAVAILABLE",
+        "CONFORMANCE_FORTEMI_DATASET_PREFLIGHT_SUPPORTED"
+      ]
+    },
+    "receiptDigest": { "$ref": "#/$defs/digest" },
+    "bindings": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["aiwgCommit", "endpointFingerprint", "toolSchemaDigest"],
+      "properties": {
+        "aiwgCommit": { "type": "string", "pattern": "^[0-9a-f]{40}$" },
+        "endpointFingerprint": { "$ref": "#/$defs/digest" },
+        "toolSchemaDigest": { "$ref": "#/$defs/digest" }
+      }
+    },
+    "observed": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["serverName", "serverVersion"],
+      "properties": {
+        "serverName": { "$ref": "#/$defs/safe" },
+        "serverVersion": { "$ref": "#/$defs/safe" }
+      }
+    },
+    "namespace": {
+      "type": "string",
+      "pattern": "^aiwg-dataset-qualification-[0-9a-f-]{36}$"
+    },
+    "operations": {
+      "type": "array",
+      "minItems": 2,
+      "maxItems": 2,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["tool", "compatible", "code"],
+        "properties": {
+          "tool": { "enum": ["dataset_capabilities", "dataset_execute"] },
+          "compatible": { "type": "boolean" },
+          "code": {
+            "enum": [
+              "FORTEMI_DATASET_TOOL_SCHEMA_COMPATIBLE",
+              "FORTEMI_DATASET_TOOL_SCHEMA_DRIFT",
+              "FORTEMI_DATASET_TOOL_MISSING"
+            ]
+          }
+        }
+      }
+    },
+    "mutation": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["authorized", "attempted"],
+      "properties": {
+        "authorized": { "const": false },
+        "attempted": { "const": false }
+      }
+    },
+    "resources": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "maxDurationMs",
+        "durationMs",
+        "maxToolCount",
+        "observedToolCount",
+        "maxSchemaBytes",
+        "observedSchemaBytes",
+        "networkAttempts",
+        "toolCalls"
+      ],
+      "properties": {
+        "maxDurationMs": {
+          "type": "integer",
+          "minimum": 250,
+          "maximum": 30000
+        },
+        "durationMs": { "type": "integer", "minimum": 0 },
+        "maxToolCount": { "const": 256 },
+        "observedToolCount": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 256
+        },
+        "maxSchemaBytes": { "const": 1048576 },
+        "observedSchemaBytes": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 1048576
+        },
+        "networkAttempts": { "const": 1 },
+        "toolCalls": { "const": 0 }
+      }
+    },
+    "startedAt": { "$ref": "#/$defs/time" },
+    "endedAt": { "$ref": "#/$defs/time" }
+  },
+  "$defs": {
+    "digest": { "type": "string", "pattern": "^sha256:[0-9a-f]{64}$" },
+    "safe": {
+      "type": "string",
+      "minLength": 1,
+      "pattern": "^[A-Za-z0-9._:/-]+$"
+    },
+    "time": { "type": "string", "format": "date-time", "pattern": "Z$" }
+  }
+}

package/tools/agents/deploy-agents.mjs

@@ -20,7 +20,7 @@
  *   --rules-only             Deploy only rules (skip agents)
  *   --dry-run                Show what would be deployed without writing
  *   --force                  Overwrite existing files
- *   --provider <name>        Target provider: claude (default), openai, codex, cursor, opencode, copilot, factory, pi, warp, devin, hermes, or openclaw
+ *   --provider <name>        Target provider: antigravity (agy), claude (default), openai, codex, cursor, opencode, copilot, factory, pi, omp, warp, devin, hermes, or openclaw
  *   --model <name>            Override model for all tiers (blanket)
  *   --reasoning-model <name> Override model for reasoning tasks
  *   --coding-model <name>    Override model for coding tasks
@@ -53,6 +53,7 @@
  *   windsurf  - Deprecated alias for devin
  *   openclaw  - OpenClaw - ~/.openclaw/agents/, ~/.openclaw/commands/, ~/.openclaw/skills/, ~/.openclaw/rules/, ~/.openclaw/behaviors/
  *   pi        - Pi Coding Agent - .agents/skills/, .pi/skills/, .pi/prompts/, AGENTS.md
+ *   omp       - Oh My Pi - .omp/agents/, .omp/prompts/, .agents/skills/, .omp/AGENTS.md
  *
  * Defaults:
  *   --source resolves relative to this script's repo root (../..)
@@ -104,15 +105,17 @@ function getDeployVersion(srcRoot) {
 // ============================================================================
 
 const PROVIDER_ALIASES = {
+  agy: 'antigravity',
   'openai': 'codex',
   'devin': 'windsurf',
   'devin-desktop': 'windsurf',
   'devin-local': 'windsurf',
   'cascade': 'windsurf',
   'pi-coding-agent': 'pi',
+  'oh-my-pi': 'omp',
 };
 
-const AVAILABLE_PROVIDERS = ['claude', 'factory', 'codex', 'opencode', 'copilot', 'cursor', 'pi', 'warp', 'windsurf', 'hermes', 'openclaw', 'openhuman'];
+const AVAILABLE_PROVIDERS = ['antigravity', 'claude', 'factory', 'codex', 'opencode', 'copilot', 'cursor', 'pi', 'omp', 'warp', 'windsurf', 'hermes', 'openclaw', 'openhuman'];
 
 const UNSUPPORTED_PROVIDER_HINTS = {
   'devin-cli': [
@@ -154,7 +157,7 @@ const MIRRORED_KERNEL_COMMAND_SKILLS = new Set([
 ]);
 
 function providerUsesSkillsNatively(providerName) {
-  return ['claude', 'cursor', 'hermes', 'openhuman', 'pi'].includes(providerName);
+  return ['antigravity', 'claude', 'cursor', 'hermes', 'openhuman', 'pi', 'omp'].includes(providerName);
 }
 
 function shouldMirrorStandardCommandSkill(skillName) {

package/tools/agents/providers/antigravity.mjs

@@ -0,0 +1,147 @@
+/** Google Antigravity CLI project resource deployment, qualified against 1.1.26. */
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  collectFrameworkArtifacts,
+  createAgentsMdFromTemplate,
+  deployFiles,
+  deploySkillsWithKernelRouting,
+  ensureDir,
+  getAddonAgentFiles,
+  getAddonSkillDirs,
+  listMdFiles,
+  listSkillDirs,
+  normalizeDeploymentMode,
+  resolveAiwgRoot,
+} from './base.mjs';
+
+export const name = 'antigravity';
+export const aliases = ['agy'];
+export const paths = { agents: '.agents/agents', commands: '', skills: '.agents/skills', rules: '' };
+export const kernelSkillsPath = '.agents/skills';
+export const support = { agents: 'degraded', commands: 'unsupported', skills: 'native', rules: 'context' };
+export const capabilities = {
+  skills: true,
+  rules: false,
+  yamlFormat: true,
+  aggregatedOutput: false,
+  homeDirectoryDeploy: false,
+  parallelCommandAndSkillSurfaces: false,
+};
+
+export const mapModel = model => model;
+
+const ANTIGRAVITY_TOOL_MAP = new Map([
+  ['Read', 'view_file'],
+  ['Write', 'write_to_file'],
+  ['Edit', 'replace_file_content'],
+  ['Grep', 'grep_search'],
+  ['Bash', 'run_command'],
+]);
+
+function mapTools(value) {
+  if (!value) return [];
+  return value
+    .replace(/^\[|\]$/g, '')
+    .split(',')
+    .map(tool => ANTIGRAVITY_TOOL_MAP.get(tool.trim()))
+    .filter(Boolean);
+}
+
+export function transformAgent(_source, content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+  if (!match) return content;
+  const frontmatter = match[1];
+  const body = match[2].trim();
+  const name = frontmatter.match(/^name:\s*(.+)$/m)?.[1]?.trim();
+  const description = frontmatter.match(/^description:\s*(.+)$/m)?.[1]?.trim();
+  const tools = mapTools(frontmatter.match(/^tools:\s*(.+)$/m)?.[1]?.trim());
+  return [
+    '---',
+    ...(name ? [`name: ${name}`] : []),
+    ...(description ? [`description: ${description}`] : []),
+    ...(tools.length ? ['tools:', ...tools.map(tool => `  - ${tool}`)] : []),
+    '---',
+    '',
+    body,
+    '',
+  ].join('\n');
+}
+
+export function deployAgents(files, target, opts = {}) {
+  const destination = path.join(target, paths.agents);
+  ensureDir(destination, opts.dryRun);
+  return deployFiles(files, destination, { ...opts, provider: name }, transformAgent);
+}
+
+export function deploySkills(dirs, target, opts = {}) {
+  return deploySkillsWithKernelRouting(
+    dirs,
+    path.join(target, '.agents/.aiwg/skills'),
+    path.join(target, kernelSkillsPath),
+    { ...opts, provider: name, copyStandardSkills: opts.copyStandardSkills === true },
+  );
+}
+
+export function deployCommands() { return 0; }
+export function deployRules() { return 0; }
+
+export function createAgentsMd(target, srcRoot, dryRun) {
+  const root = resolveAiwgRoot(srcRoot) || srcRoot;
+  createAgentsMdFromTemplate(target, root, 'antigravity/AGENTS.md.aiwg-template', dryRun);
+}
+
+export async function postDeploy(target, opts) {
+  if (opts.global || opts.user || opts.scope === 'user') {
+    throw new Error('Antigravity global skill deployment is disabled: official 1.1.26 path documentation conflicts');
+  }
+  if (opts.createAgentsMd || (!opts.commandsOnly && !opts.skillsOnly && !opts.rulesOnly)) {
+    createAgentsMd(target, opts.srcRoot, opts.dryRun);
+  }
+  if (!opts.quiet) {
+    console.log('Antigravity resources are project scoped. Restart agy after resource changes; authenticate with the provider separately.');
+  }
+}
+
+export function getFileExtension() { return '.md'; }
+
+export async function deploy(opts) {
+  if (opts.global || opts.user || opts.scope === 'user') {
+    throw new Error('Antigravity global skill deployment is disabled: official 1.1.26 path documentation conflicts');
+  }
+  const mode = normalizeDeploymentMode(opts.mode);
+  const agents = [];
+  const skills = [];
+  const directSource = ['agents', 'skills'].some(type => fs.existsSync(path.join(opts.srcRoot, type)));
+  if (directSource) {
+    agents.push(...listMdFiles(path.join(opts.srcRoot, 'agents')));
+    if (opts.deploySkills || opts.skillsOnly) skills.push(...listSkillDirs(path.join(opts.srcRoot, 'skills')));
+  } else if (['general', 'sdlc', 'both', 'all'].includes(mode)) {
+    agents.push(...getAddonAgentFiles(opts.srcRoot));
+    if (opts.deploySkills || opts.skillsOnly) skills.push(...getAddonSkillDirs(opts.srcRoot));
+  }
+  const framework = directSource ? { agents: [], skills: [] } : collectFrameworkArtifacts(opts.srcRoot, mode, {
+    includeAgents: true,
+    includeCommands: false,
+    includeSkills: opts.deploySkills || opts.skillsOnly,
+    includeRules: false,
+  });
+  agents.push(...framework.agents);
+  skills.push(...framework.skills);
+  let count = 0;
+  if (!opts.commandsOnly && !opts.skillsOnly && !opts.rulesOnly) {
+    count += deployAgents(agents, opts.target, opts).filter(action => action.type === 'deploy').length;
+  }
+  if ((opts.deploySkills || opts.skillsOnly) && !opts.commandsOnly && !opts.rulesOnly) {
+    const result = deploySkills(skills, opts.target, opts);
+    count += result.kernel + result.standardCopied;
+  }
+  await postDeploy(opts.target, opts);
+  return count;
+}
+
+export default {
+  name, aliases, paths, kernelSkillsPath, support, capabilities, mapModel,
+  transformAgent, deployAgents, deploySkills, deployCommands, deployRules,
+  createAgentsMd, postDeploy, getFileExtension, deploy,
+};

package/tools/agents/providers/omp.d.mts

@@ -0,0 +1,4 @@
+export interface OmpUninstallOptions { dryRun?: boolean; scope?: 'user' | 'project'; home?: string; env?: NodeJS.ProcessEnv; quiet?: boolean }
+export function uninstall(target: string, opts?: OmpUninstallOptions): number;
+
+export function deploySkillSupportAsset(source: string, destination: string, opts?: { dryRun?: boolean; quiet?: boolean }): number;