@aiwg/cli 2026.9.2 → 2026.9.4

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.2",
+  "version": "2026.9.4",
   "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;