@aiwg/cli 2026.9.2 → 2026.9.4

package/dist/src/mcp/cli.mjs

@@ -18,6 +18,7 @@ import {
 } from './registry.mjs';
 import { McpProfileRegistry } from './profiles.mjs';
 import { getMcpInjectionDefinition } from '../providers/provider-definitions.mjs';
+import { manageOmpMcp } from './omp-config.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -38,6 +39,7 @@ Usage:
   aiwg mcp update <name> [opts]  Update a server definition
   aiwg mcp list                List registered MCP servers
   aiwg mcp inject [opts]       Inject servers into provider configs
+  aiwg mcp uninject [opts]     Remove unchanged AIWG-owned OMP server entries
   aiwg mcp profile <sub>       Manage MCP profiles (named server subsets)
 
 Server Options (for add/update):
@@ -52,7 +54,8 @@ Server Options (for add/update):
   --description <text> Optional description
 
 Inject Options:
-  --provider <name>    Target provider (claude-code, cursor, factory, codex, opencode, windsurf, warp)
+  --provider <name>    Target provider (including antigravity / agy and omp / oh-my-pi)
+  --scope <scope>      project (default) or user; provider user scope must be documented
   --all                Inject into all previously configured providers
   --servers <a,b,...>  Only inject specific servers (comma-separated names)
   --dry-run            Show what would change without writing
@@ -651,6 +654,8 @@ async function handleInject(args) {
   const serversStr = parseFlag(args, '--servers');
   const dryRun = args.includes('--dry-run');
   const projectDir = parseFlag(args, '--project') || '.';
+  const scope = parseFlag(args, '--scope') || 'project';
+  if (!['project', 'user'].includes(scope)) throw new Error('Scope must be project or user');
   const profileName = parseFlag(args, '--profile');
   const ephemeral = args.includes('--ephemeral');
   const outPath = parseFlag(args, '--out');
@@ -782,10 +787,12 @@ async function handleInject(args) {
       servers: serverFilter,
       projectDir,
       dryRun,
+      scope,
     });
 
     if (result.error) {
       console.error(`  ${p}: ${result.error}`);
+      process.exitCode = 1;
       continue;
     }
 
@@ -1124,6 +1131,15 @@ export async function main(args = process.argv.slice(2)) {
     }
 
     case 'install': {
+      if (['omp', 'oh-my-pi'].includes(args[1])) {
+        const scope = parseFlag(args, '--scope') || 'project';
+        if (!['project', 'user'].includes(scope)) throw new Error('Scope must be project or user');
+        const projectDir = parseFlag(args, '--project') || (args[2] && !args[2].startsWith('--') ? args[2] : '.');
+        const configPath = getProviderConfigPath('omp', projectDir, { scope });
+        const result = await manageOmpMcp(configPath, [{ name: 'aiwg', type: 'stdio', command: 'aiwg', args: ['mcp', 'serve'] }], { dryRun: args.includes('--dry-run') });
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
       // Parse install arguments (skip flags)
       const installArgs = args.slice(1).filter(a => !a.startsWith('--'));
       const target = installArgs[0] || 'claude';
@@ -1184,6 +1200,19 @@ export async function main(args = process.argv.slice(2)) {
       await handleInject(subArgs);
       break;
 
+    case 'uninject': {
+      const provider = parseFlag(subArgs, '--provider');
+      if (!['omp', 'oh-my-pi'].includes(provider)) throw new Error('uninject currently supports --provider omp');
+      const scope = parseFlag(subArgs, '--scope') || 'project';
+      if (!['project', 'user'].includes(scope)) throw new Error('Scope must be project or user');
+      const remove = (parseFlag(subArgs, '--servers') || '').split(',').map(s => s.trim()).filter(Boolean);
+      if (!remove.length) throw new Error('uninject requires --servers name[,name]');
+      const configPath = getProviderConfigPath(provider, parseFlag(subArgs, '--project') || '.', { scope });
+      const result = await manageOmpMcp(configPath, [], { remove, dryRun: subArgs.includes('--dry-run') });
+      console.log(JSON.stringify(result, null, 2));
+      break;
+    }
+
     case 'profile':
       await handleProfile(subArgs);
       break;

package/dist/src/mcp/omp-config.mjs

@@ -0,0 +1,128 @@
+import { readFile, writeFile, mkdir, rename, lstat, unlink, open } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+
+const hash = value => createHash('sha256').update(JSON.stringify(value)).digest('hex');
+const record = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+async function rejectSymlinkPath(file) {
+  let current = resolve(file);
+  for (;;) {
+    try {
+      if ((await lstat(current)).isSymbolicLink()) throw new Error('OMP MCP configuration path cannot traverse a symbolic link');
+    } catch (error) { if (error.code !== 'ENOENT') throw error; }
+    const parent = dirname(current);
+    if (parent === current) return;
+    current = parent;
+  }
+}
+async function readObject(file) {
+  await rejectSymlinkPath(file);
+  try {
+    if ((await lstat(file)).isSymbolicLink()) throw new Error('OMP MCP configuration cannot be a symbolic link');
+    const data = JSON.parse(await readFile(file, 'utf8'));
+    if (!record(data)) throw new Error('OMP MCP configuration must be an object');
+    return data;
+  } catch (error) {
+    if (error.code === 'ENOENT') return {};
+    if (error instanceof SyntaxError) throw new Error('OMP MCP configuration is invalid JSON; repair it before injection');
+    throw error;
+  }
+}
+async function atomic(file, data) {
+  await mkdir(dirname(file), { recursive: true });
+  const temporary = `${file}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, JSON.stringify(data, null, 2) + '\n', { flag: 'wx', mode: 0o600 });
+    await rename(temporary, file);
+  } finally { await unlink(temporary).catch(() => {}); }
+}
+
+export function ompServerConfig(server) {
+  const config = {};
+  for (const field of ['command', 'args', 'env', 'cwd', 'url', 'headers', 'enabled', 'timeout', 'requestIdFormat', 'auth', 'oauth', 'type']) {
+    if (server[field] !== undefined) config[field] = server[field];
+  }
+  if (!config.command && !config.url && config.enabled !== false) throw new Error(`OMP MCP server ${server.name} needs command or url`);
+  if (config.type !== undefined && !['stdio', 'http', 'sse'].includes(config.type)) throw new Error('Invalid OMP MCP transport');
+  if (config.command && config.url) throw new Error('OMP MCP server must choose command or url');
+  if (config.enabled !== false && (config.type === 'stdio' && !config.command || ['http', 'sse'].includes(config.type) && !config.url)) throw new Error('OMP MCP transport does not match endpoint');
+  for (const field of ['command', 'cwd', 'url']) {
+    if (config[field] !== undefined && typeof config[field] !== 'string') throw new Error(`Invalid OMP MCP ${field}`);
+  }
+  if (config.args !== undefined && (!Array.isArray(config.args) || config.args.some(x => typeof x !== 'string'))) throw new Error('Invalid OMP MCP args');
+  for (const field of ['env', 'headers']) {
+    if (config[field] !== undefined && (!record(config[field]) || Object.values(config[field]).some(x => typeof x !== 'string'))) throw new Error(`Invalid OMP MCP ${field}`);
+  }
+  if (config.requestIdFormat !== undefined && !['string', 'number'].includes(config.requestIdFormat)) throw new Error('Invalid OMP MCP requestIdFormat');
+  if (config.auth !== undefined && (!record(config.auth) || !['oauth', 'apikey'].includes(config.auth.type))) throw new Error('Invalid OMP MCP auth');
+  if (config.oauth !== undefined && !record(config.oauth)) throw new Error('Invalid OMP MCP oauth');
+  if (config.timeout !== undefined && (!Number.isFinite(config.timeout) || config.timeout < 0)) throw new Error('Invalid OMP MCP timeout');
+  if (config.enabled !== undefined && typeof config.enabled !== 'boolean') throw new Error('Invalid OMP MCP enabled flag');
+  for (const field of ['envPolicy', 'envLiteralKeys', 'headerPolicy']) {
+    if (server[field] !== undefined) throw new Error(`OMP native mcp.json does not enforce ${field}; this control requires the native SDK/plugin interface`);
+  }
+  for (const field of ['auth', 'oauth']) {
+    if (config[field]) for (const [key, value] of Object.entries(config[field])) {
+      if (key === 'callbackPort') { if (!Number.isInteger(value) || value < 0 || value > 65535) throw new Error('Invalid OMP MCP callbackPort'); }
+      else if (['type', 'credentialId', 'tokenUrl', 'clientId', 'clientSecret', 'resource', 'scope', 'redirectUri', 'callbackPath', 'prompt'].includes(key) && typeof value !== 'string') throw new Error(`Invalid OMP MCP ${field}.${key}`);
+    }
+  }
+  if (server.headerEnv) {
+    config.headers = { ...config.headers };
+    for (const [header, variable] of Object.entries(server.headerEnv)) {
+      if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(variable)) throw new Error('Invalid MCP header environment reference');
+      config.headers[header] = '${' + variable + '}';
+    }
+  }
+  return config;
+}
+
+/** Hash-only receipt: never saves an extra copy of operator configuration. */
+async function manageLockedOmpMcp(configPath, servers, { dryRun = false, remove = [] } = {}) {
+  const receiptPath = `${configPath}.aiwg-ownership.json`;
+  const existing = await readObject(configPath);
+  const receipt = await readObject(receiptPath);
+  if (receipt.servers !== undefined && (!record(receipt.servers) || receipt.schema !== 'aiwg.omp-mcp-ownership.v1')) throw new Error('Invalid OMP MCP ownership receipt');
+  if (existing.mcpServers !== undefined && !record(existing.mcpServers)) throw new Error('Invalid OMP mcpServers object');
+  const next = { ...(existing.mcpServers || {}) };
+  const owned = { ...(receipt.servers || {}) };
+  const result = { configPath, serversInjected: [], alreadyPresent: [], removed: [] };
+  // Validate all collisions before the first write.
+  for (const name of [...servers.map(s => s.name), ...remove]) {
+    if (typeof name !== 'string' || !name || ['__proto__', 'constructor', 'prototype'].includes(name)) throw new Error('Invalid OMP MCP server name');
+    if (Object.hasOwn(next, name) && owned[name] !== hash(next[name])) {
+      throw new Error(`OMP MCP server ${name} is operator-owned or modified; preserve it and choose a different name`);
+    }
+  }
+  for (const server of servers) {
+    if (!server.name || ['__proto__', 'constructor', 'prototype'].includes(server.name)) throw new Error('Invalid OMP MCP server name');
+    if (Object.hasOwn(next, server.name)) result.alreadyPresent.push(server.name);
+    next[server.name] = ompServerConfig(server);
+    owned[server.name] = hash(next[server.name]);
+    result.serversInjected.push(server.name);
+  }
+  for (const name of remove) {
+    if (owned[name]) { delete next[name]; delete owned[name]; result.removed.push(name); }
+  }
+  if (!dryRun) {
+    if (hash(await readObject(configPath)) !== hash(existing) || hash(await readObject(receiptPath)) !== hash(receipt)) throw new Error('OMP MCP configuration changed during injection; retry after reviewing the operator edit');
+    // If interrupted between writes, a retry fails closed on the hash mismatch.
+    await atomic(configPath, { ...existing, mcpServers: next });
+    await atomic(receiptPath, { schema: 'aiwg.omp-mcp-ownership.v1', servers: owned });
+  }
+  return result;
+}
+
+/** Serialize AIWG writers; operator edits detected before committing a replacement. */
+export async function manageOmpMcp(configPath, servers, options = {}) {
+  if (options.dryRun) return manageLockedOmpMcp(configPath, servers, options);
+  await rejectSymlinkPath(configPath);
+  const lockPath = `${configPath}.aiwg-lock`;
+  await rejectSymlinkPath(lockPath);
+  await mkdir(dirname(configPath), { recursive: true });
+  let lock;
+  try { lock = await open(lockPath, 'wx', 0o600); }
+  catch (error) { if (error.code === 'EEXIST') throw new Error('OMP MCP injection already locked; wait for the active writer or review a stale lock before retrying'); throw error; }
+  try { return await manageLockedOmpMcp(configPath, servers, options); }
+  finally { await lock.close(); await unlink(lockPath); }
+}

package/dist/src/mcp/registry.js

@@ -1,3 +1,5 @@
+import { manageOmpMcp } from './omp-config.mjs';
+import { resolveOmpPaths } from '../providers/omp-paths.mjs';
 /**
  * MCP Server Registry
  *
@@ -156,6 +158,12 @@ export class McpServerRegistry {
 function buildServerConfig(server, provider) {
     const adapter = getProviderDefinition(provider)?.adapters.mcpInjection;
     switch (adapter) {
+        case 'antigravity': {
+            if (server.type === 'stdio') {
+                return { command: server.command, args: server.args || [], ...(server.env ? { env: server.env } : {}) };
+            }
+            return { serverUrl: server.url, ...(server.headers ? { headers: server.headers } : {}) };
+        }
         case 'claude-code': {
             if (server.type === 'stdio') {
                 return {
@@ -258,9 +266,21 @@ function buildServerToml(server) {
 /**
  * Get the config file path for a provider.
  */
-export function getProviderConfigPath(provider, projectDir = '.') {
+export function getProviderConfigPath(provider, projectDir = '.', options = {}) {
+    if ((provider === 'antigravity' || provider === 'agy') && options.scope === 'user') {
+        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+        return resolve(homeDir, '.gemini/config/mcp_config.json');
+    }
+    if ((provider === 'omp' || provider === 'oh-my-pi') && options.scope !== undefined && !['user', 'project'].includes(options.scope))
+        throw new Error('OMP MCP scope must be user or project');
+    if ((provider === 'omp' || provider === 'oh-my-pi') && options.scope === 'user')
+        return resolve(resolveOmpPaths().agentDir, 'mcp.json');
     const homeDir = process.env.HOME || process.env.USERPROFILE || '';
     const pathMap = {
+        antigravity: resolve(projectDir, '.agents/mcp_config.json'),
+        agy: resolve(projectDir, '.agents/mcp_config.json'),
+        omp: resolve(projectDir, '.omp/mcp.json'),
+        'oh-my-pi': resolve(projectDir, '.omp/mcp.json'),
         'claude-code': resolve(projectDir, '.claude/settings.local.json'),
         claude: resolve(projectDir, '.claude/settings.local.json'),
         cursor: resolve(projectDir, '.cursor/mcp.json'),
@@ -281,7 +301,7 @@ export function getProviderConfigPath(provider, projectDir = '.') {
  */
 export async function injectServers(registry, provider, options = {}) {
     const { servers: serverFilter, projectDir = '.', dryRun = false } = options;
-    const configPath = getProviderConfigPath(provider, projectDir);
+    const configPath = getProviderConfigPath(provider, projectDir, options);
     const result = {
         provider,
         configPath,
@@ -297,6 +317,18 @@ export async function injectServers(registry, provider, options = {}) {
         result.error = 'No servers to inject. Use "aiwg mcp add" first.';
         return result;
     }
+    if (provider === 'omp' || provider === 'oh-my-pi') {
+        try {
+            const managed = await manageOmpMcp(configPath, allServers, { dryRun });
+            if (!dryRun)
+                for (const server of allServers)
+                    await registry.recordInjection(server.name, 'omp');
+            return { ...result, ...managed };
+        }
+        catch (error) {
+            return { ...result, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
     // Handle TOML-based providers (Codex/OpenAI) separately
     if (provider === 'codex' || provider === 'openai') {
         return injectToml(registry, allServers, configPath, provider, dryRun, result);
@@ -311,8 +343,10 @@ async function injectJson(registry, servers, configPath, provider, dryRun, resul
         const content = await readFile(configPath, 'utf-8');
         existing = JSON.parse(content);
     }
-    catch {
-        // File doesn't exist, start fresh
+    catch (error) {
+        if ((provider === 'antigravity' || provider === 'agy') && error?.code !== 'ENOENT') {
+            throw new Error(`Refusing to overwrite malformed MCP config ${configPath}: ${error.message}`);
+        }
     }
     // Determine the MCP servers key for this provider
     const mcpKey = provider === 'opencode' ? 'mcp' : 'mcpServers';
@@ -323,6 +357,8 @@ async function injectJson(registry, servers, configPath, provider, dryRun, resul
         if (existingServers[server.name]) {
             // Update existing entry in place
             result.alreadyPresent.push(server.name);
+            if (provider === 'antigravity' || provider === 'agy')
+                continue;
         }
         newServers[server.name] = buildServerConfig(server, provider);
         result.serversInjected.push(server.name);
@@ -334,7 +370,9 @@ async function injectJson(registry, servers, configPath, provider, dryRun, resul
         await writeFile(configPath, JSON.stringify(merged, null, 2) + '\n', 'utf-8');
         // Record injection in registry
         for (const server of servers) {
-            await registry.recordInjection(server.name, provider);
+            if ((provider === 'antigravity' || provider === 'agy') && !result.serversInjected.includes(server.name))
+                continue;
+            await registry.recordInjection(server.name, provider === 'agy' ? 'antigravity' : provider);
         }
     }
     return result;
@@ -378,6 +416,8 @@ function escapeRegex(str) {
 }
 /** All supported provider names for injection */
 export const SUPPORTED_PROVIDERS = [
+    'antigravity',
+    'omp',
     'claude-code',
     'cursor',
     'factory',

package/dist/src/mcp/registry.mjs

@@ -1,3 +1,5 @@
+import { manageOmpMcp } from './omp-config.mjs';
+import { resolveOmpPaths } from '../providers/omp-paths.mjs';
 /**
  * MCP Server Registry (Runtime ESM)
  *
@@ -206,6 +208,12 @@ function buildServerConfig(server, provider) {
   const mcpDefinition = getMcpInjectionDefinition(provider);
 
   switch (mcpDefinition?.serverConfigFormat) {
+    case 'antigravity': {
+      if (server.type === 'stdio') {
+        return { command: server.command, args: server.args || [], ...(server.env ? { env: server.env } : {}) };
+      }
+      return { serverUrl: server.url, ...(server.headers ? { headers: server.headers } : {}) };
+    }
     case 'standard': {
       if (server.type === 'stdio') {
         return {
@@ -281,15 +289,16 @@ function buildServerToml(server) {
   return lines.join('\n');
 }
 
-export function getProviderConfigPath(provider, projectDir = '.') {
-  return resolveMcpConfigPath(provider, projectDir);
+export function getProviderConfigPath(provider, projectDir = '.', options = {}) {
+  if (normalizeRuntimeProviderId(provider) === 'omp' && options.scope !== undefined && !['user', 'project'].includes(options.scope)) throw new Error('OMP MCP scope must be user or project');
+  return resolveMcpConfigPath(provider, projectDir, options);
 }
 
 export async function injectServers(registry, provider, options = {}) {
   const { servers: serverFilter, projectDir = '.', dryRun = false } = options;
   const normalizedProvider = normalizeRuntimeProviderId(provider);
   const mcpDefinition = getMcpInjectionDefinition(provider);
-  const configPath = getProviderConfigPath(provider, projectDir);
+  const configPath = getProviderConfigPath(provider, projectDir, options);
   const result = {
     provider,
     configPath,
@@ -312,6 +321,16 @@ export async function injectServers(registry, provider, options = {}) {
     return result;
   }
 
+  if (normalizedProvider === 'omp') {
+    try {
+      const managed = await manageOmpMcp(configPath, allServers, { dryRun });
+      if (!dryRun) for (const server of allServers) await registry.recordInjection(server.name, 'omp');
+      return { ...result, ...managed };
+    } catch (error) {
+      return { ...result, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+
   if (mcpDefinition?.configFormat === 'toml') {
     return injectToml(registry, allServers, configPath, provider, dryRun, result);
   }
@@ -324,8 +343,10 @@ async function injectJson(registry, servers, configPath, provider, dryRun, resul
   try {
     const content = await readFile(configPath, 'utf-8');
     existing = JSON.parse(content);
-  } catch {
-    // File doesn't exist
+  } catch (error) {
+    if (normalizeRuntimeProviderId(provider) === 'antigravity' && error?.code !== 'ENOENT') {
+      throw new Error(`Refusing to overwrite malformed MCP config ${configPath}: ${error.message}`);
+    }
   }
 
   const mcpKey = getMcpInjectionDefinition(provider)?.serversKey || 'mcpServers';
@@ -335,6 +356,7 @@ async function injectJson(registry, servers, configPath, provider, dryRun, resul
   for (const server of servers) {
     if (existingServers[server.name]) {
       result.alreadyPresent.push(server.name);
+      if (normalizeRuntimeProviderId(provider) === 'antigravity') continue;
     }
     newServers[server.name] = buildServerConfig(server, provider);
     result.serversInjected.push(server.name);
@@ -347,7 +369,8 @@ async function injectJson(registry, servers, configPath, provider, dryRun, resul
     await writeFile(configPath, JSON.stringify(merged, null, 2) + '\n', 'utf-8');
 
     for (const server of servers) {
-      await registry.recordInjection(server.name, provider);
+      if (normalizeRuntimeProviderId(provider) === 'antigravity' && !result.serversInjected.includes(server.name)) continue;
+      await registry.recordInjection(server.name, normalizeRuntimeProviderId(provider) || provider);
     }
   }
 

package/dist/src/models/model-capabilities.v1.json

@@ -3,6 +3,17 @@
   "version": "1.0.0",
   "verifiedAt": "2026-07-20",
   "providers": {
+    "antigravity": {
+      "agent": "native", "skill": "native", "globalChild": "inherited",
+      "identifierSyntax": "model identifier accepted by Antigravity CLI 1.1.26 --model",
+      "effortValues": ["low", "medium", "high"],
+      "inheritance": "Omitted model and effort inherit the invoking Antigravity session",
+      "invalidPinFallback": "Provider validation/error; never assume fallback",
+      "configTarget": "agy launch arguments; custom-agent model tiers are not projected from generic AIWG model ids",
+      "artifactFormat": "YAML frontmatter plus Markdown; runtime --model and --effort flags",
+      "verification": "Pinned offline contract; authenticated model selection was not executed",
+      "sourceUrl": "https://antigravity.google/docs/cli/subagents/", "verifiedAt": "2026-09-04"
+    },
     "claude": {
       "agent": "native", "skill": "native", "globalChild": "inherited",
       "identifierSyntax": "Claude alias or accepted Anthropic model ID",
@@ -76,6 +87,26 @@
       "verification": "Inspect active profile and run metadata",
       "sourceUrl": "https://docs.warp.dev/agent-platform/capabilities/agent-profiles-permissions", "verifiedAt": "2026-07-20"
     },
+    "omp": {
+      "agent": "native",
+      "skill": "inherited",
+      "globalChild": "native",
+      "identifierSyntax": "provider/model identifier accepted by OMP --model",
+      "effortValues": [
+        "minimal",
+        "low",
+        "medium",
+        "high",
+        "xhigh"
+      ],
+      "inheritance": "Omitted model and thinking level inherit the invoking Pi session",
+      "invalidPinFallback": "Pi resolves against its configured catalog and exits on invalid explicit selection",
+      "configTarget": "OMP native agent frontmatter and runtime launch arguments",
+      "artifactFormat": "model and thinkingLevel frontmatter; --model and --thinking runtime flags",
+      "verification": "Pinned OMP 18.1.10 source and live OpenRouter smoke; individual role defaults remain operator configured",
+      "sourceUrl": "https://github.com/can1357/oh-my-pi/tree/5964a0f7649275bcde818f20073193fd032451f2/packages/coding-agent",
+      "verifiedAt": "2026-09-04"
+    },
     "pi": {
       "agent": "native", "skill": "inherited", "globalChild": "native",
       "identifierSyntax": "provider/model identifier accepted by Pi --model",

package/dist/src/models/model-catalog.v1.json

@@ -4,6 +4,14 @@
   "refreshedAt": "2026-07-20",
   "staleAfterDays": 90,
   "providers": {
+    "antigravity": {
+      "roles": {
+        "reasoning": { "id": "configured/reasoning", "status": "unverified", "observed": false },
+        "coding": { "id": "configured/coding", "status": "unverified", "observed": false },
+        "efficiency": { "id": "configured/efficiency", "status": "unverified", "observed": false }
+      },
+      "sourceUrl": "https://antigravity.google/docs/cli/overview/", "verifiedAt": "2026-09-04"
+    },
     "claude": {
       "roles": {
         "reasoning": { "id": "claude-opus-4-7", "status": "active", "observed": false },
@@ -52,6 +60,27 @@
       },
       "sourceUrl": "https://opencode.ai/docs/models", "verifiedAt": "2026-07-20"
     },
+    "omp": {
+      "roles": {
+        "reasoning": {
+          "id": "configured/reasoning",
+          "status": "unverified",
+          "observed": false
+        },
+        "coding": {
+          "id": "configured/coding",
+          "status": "unverified",
+          "observed": false
+        },
+        "efficiency": {
+          "id": "configured/efficiency",
+          "status": "unverified",
+          "observed": false
+        }
+      },
+      "sourceUrl": "https://github.com/can1357/oh-my-pi/tree/5964a0f7649275bcde818f20073193fd032451f2/packages/coding-agent",
+      "verifiedAt": "2026-09-04"
+    },
     "pi": {
       "roles": {
         "reasoning": { "id": "configured/reasoning", "status": "unverified", "observed": false },

package/dist/src/models/model-discovery.js

@@ -67,6 +67,9 @@ export const PROVIDER_DISCOVERY_DECISIONS = {
         reason: 'OpenHuman profiles accept semantic model hints but expose no standardized local model-list command.',
         documentation: 'https://github.com/roctinam/openhuman',
     },
+    omp: { provider: 'omp', status: 'native', interface: 'omp models --json --no-extensions',
+        reason: 'OMP JSON catalog reports credential-available LLM models; ambient extensions are disabled by default.',
+        documentation: 'https://github.com/can1357/oh-my-pi/blob/5964a0f7649275bcde818f20073193fd032451f2/packages/coding-agent/src/commands/models.ts' },
     pi: {
         provider: 'pi',
         status: 'native',
@@ -103,7 +106,7 @@ export function classifyDiscoveryError(message) {
 export const runModelDiscoveryCommand = (command, args, options = {}) => new Promise(resolveCommand => {
     const child = spawn(command, args, {
         cwd: options.cwd,
-        env: process.env,
+        env: options.env ?? process.env,
         stdio: ['ignore', 'pipe', 'pipe'],
     });
     let stdout = '';
@@ -116,8 +119,13 @@ export const runModelDiscoveryCommand = (command, args, options = {}) => new Pro
         clearTimeout(timer);
         resolveCommand({ stdout, stderr, exitCode });
     };
-    child.stdout.on('data', chunk => { stdout += String(chunk); });
-    child.stderr.on('data', chunk => { stderr += String(chunk); });
+    child.stdout.on('data', chunk => { stdout += String(chunk); if (Buffer.byteLength(stdout) > 8 * 1024 * 1024) {
+        stdout = '';
+        stderr = 'Model catalog exceeded 8 MiB limit';
+        child.kill('SIGKILL');
+        finish(1);
+    } });
+    child.stderr.on('data', chunk => { stderr = (stderr + String(chunk)).slice(-4096); });
     child.on('error', error => {
         stderr = `${stderr}${stderr ? '\n' : ''}${error.message}`;
         finish(127);
@@ -425,7 +433,7 @@ export async function resolveDynamicModelCatalog(options) {
     const homeDir = options.homeDir ?? homedir();
     const cacheFile = options.cacheFile ?? join(homeDir, '.cache/aiwg/model-catalog.v1.json');
     const staticFile = join(options.aiwgRoot, 'agentic/code/providers/model-catalog.v1.json');
-    const signature = inventorySignature(options.inventory);
+    const signature = inventorySignature(options.inventory) + JSON.stringify({ omp: options.omp, profile: process.env.OMP_PROFILE ?? process.env.PI_PROFILE, config: process.env.PI_CONFIG_DIR, data: process.env.XDG_DATA_HOME, cache: process.env.XDG_CACHE_HOME, agent: process.env.PI_CODING_AGENT_DIR });
     const staticCatalog = await readCatalog(staticFile);
     if (!staticCatalog)
         throw new Error(`Invalid or missing static model catalog: ${staticFile}`);
@@ -487,6 +495,7 @@ export async function resolveDynamicModelCatalog(options) {
         opencode: () => discoverOpenCodeModels(),
         openclaw: () => discoverOpenClawModels(),
         pi: () => discoverPiModels(),
+        omp: () => discoverOmpModels(process.env.AIWG_OMP_BIN || 'omp', runModelDiscoveryCommand, options.omp),
     };
     const providerDiscovery = {};
     for (const provider of available) {
@@ -494,7 +503,7 @@ export async function resolveDynamicModelCatalog(options) {
         if (discoverer) {
             try {
                 providerDiscovery[provider] = await discoverer();
-                const selected = selectRoleModels(providerDiscovery[provider].models);
+                const selected = provider === 'omp' ? {} : selectRoleModels(providerDiscovery[provider].models);
                 const providerCatalog = catalog.providers[provider];
                 if (providerCatalog) {
                     for (const role of ['reasoning', 'coding', 'efficiency']) {
@@ -550,4 +559,36 @@ export async function resolveDynamicModelCatalog(options) {
     await atomicWrite(cacheFile, `${JSON.stringify(resolved, null, 2)}\n`);
     return resolved;
 }
+/** Explicit OMP discovery; no ambient extension execution unless requested. */
+export async function discoverOmpModels(command = 'omp', runner = runModelDiscoveryCommand, options = {}) {
+    const base = { provider: 'omp', source: 'native', observedAt: new Date().toISOString(), accountScope: 'local-runtime', models: [] };
+    const args = [...(options.profile ? ['--profile', options.profile] : []), 'models', '--json'];
+    if (!options.extensions)
+        args.push('--no-extensions');
+    for (const config of options.config ?? [])
+        args.push('--config', config);
+    try {
+        const result = await runner(command, args, { cwd: options.cwd ?? tmpdir(), timeoutMs: 15000 });
+        base.runtimeVersion = await runtimeVersion(command, runner);
+        if (result.exitCode !== 0)
+            return { ...base, errorKind: result.exitCode === 124 ? 'timeout' : /unknown|unsupported|not found/i.test(result.stderr) ? 'unsupported' : classifyDiscoveryError(result.stderr), error: 'OMP model discovery failed; check CLI version, selected profile/config, and credential availability.' };
+        const payload = JSON.parse(result.stdout);
+        if (!Array.isArray(payload.models) || payload.models.some((m) => !m || typeof m.id !== 'string' || !m.id || typeof m.provider !== 'string' || !m.provider))
+            throw new Error('shape');
+        base.models = payload.models.map((m) => ({ id: `${m.provider}/${m.id}`, llmProvider: m.provider, displayName: m.name, reasoningEfforts: Array.isArray(m.thinking) ? m.thinking : undefined }));
+        return base;
+    }
+    catch {
+        return { ...base, errorKind: 'invalid-output', error: 'OMP returned invalid model catalog JSON or discovery could not run.' };
+    }
+}
+/** Never guess an unrelated model when a requested mapping is unavailable. */
+export function resolveOmpRoleModel(catalog, role, mappings, explicit) {
+    if (explicit)
+        return explicit;
+    const id = mappings[role];
+    if (!id || !catalog.models.some(model => model.id === id))
+        throw new Error(`OMP ${role} model unavailable; configure a model from omp models --json or supply an explicit model.`);
+    return id;
+}
 //# sourceMappingURL=model-discovery.js.map

package/dist/src/models/provider-policy.js

@@ -26,8 +26,8 @@ function requireModelResource(filename) {
 const capabilityData = requireModelResource('model-capabilities.v1.json');
 const catalogData = requireModelResource('model-catalog.v1.json');
 const ProviderSchema = z.enum([
-    'claude', 'codex', 'copilot', 'cursor', 'factory', 'hermes',
-    'opencode', 'openclaw', 'openhuman', 'pi', 'warp', 'windsurf',
+    'antigravity', 'claude', 'codex', 'copilot', 'cursor', 'factory', 'hermes',
+    'opencode', 'openclaw', 'openhuman', 'omp', 'pi', 'warp', 'windsurf',
 ]);
 const OutcomeSchema = z.enum([
     'native', 'compiled', 'inherited', 'global-only', 'informational', 'unsupported',
@@ -107,7 +107,7 @@ export function loadProviderModelCapabilities() {
         const expected = new Set(ProviderSchema.options);
         const actual = new Set(Object.keys(registryCache.providers));
         if (actual.size !== expected.size || [...expected].some(id => !actual.has(id))) {
-            throw new Error('Provider model capability registry must cover all 12 providers');
+            throw new Error('Provider model capability registry must cover all registered providers');
         }
     }
     return registryCache;
@@ -153,12 +153,14 @@ function catalogRole(policy) {
 }
 function fieldNames(provider) {
     switch (provider) {
+        case 'antigravity': return { model: 'model', effort: 'effort' };
         case 'codex': return { model: 'model', effort: 'model_reasoning_effort' };
         case 'factory': return { model: 'model', effort: 'reasoningEffort' };
         case 'claude': return { model: 'model', effort: 'effort' };
         case 'copilot':
         case 'cursor':
         case 'opencode': return { model: 'model' };
+        case 'omp': return { model: 'model', effort: 'thinkingLevel' };
         case 'pi': return { model: 'model', effort: 'thinking' };
         case 'openhuman': return { model: 'model_hint' };
         case 'openclaw': return { model: 'subagents.model' };

package/dist/src/plugin/skill-command-translator.js

@@ -34,11 +34,13 @@ const PROVIDERS_NEEDING_COMMANDS = new Set([
  * Providers where skills are deployed natively (no command generation needed).
  */
 const SKILLS_ONLY_PROVIDERS = new Set([
+    'antigravity',
     'claude',
     'cursor',
     'hermes',
     'openhuman',
     'pi',
+    'omp',
 ]);
 /**
  * Check if a provider needs command files generated from skills.