@aiwg/cli 2026.9.2 → 2026.9.3

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.

package/dist/src/providers/capability-matrix.yaml

@@ -361,7 +361,7 @@ providers:
 
   hermes:
     display_name: Hermes
-    status: experimental
+    status: stable
     daemon_tier: unsupported
     daemon_pty_adapter: false
     artifact_paths:
@@ -470,6 +470,51 @@ providers:
     deploy_target: mixed
     aggregated_output: true
 
+  antigravity:
+    display_name: Google Antigravity CLI
+    aliases:
+      - agy
+    status: experimental
+    executable: agy
+    qualified_version: 1.1.26
+    qualification_evidence: agentic/code/providers/antigravity/provider-contract.v1.json
+    daemon_tier: unsupported
+    daemon_pty_adapter: false
+    artifact_paths:
+      agents: .agents/agents/
+      commands: "(not deployed; no qualified native command surface)"
+      skills: .agents/skills/
+      rules: AGENTS.md
+      behaviors: "(not supported)"
+      mcp_project: .agents/mcp_config.json
+      mcp_user: "~/.gemini/config/mcp_config.json"
+    native_features:
+      cron: false
+      agent_teams: false
+      tasks: false
+      mcp: true
+      behaviors: false
+      mission_control: false
+      daemon: false
+    emulation:
+      cron: external-trigger
+      agent_teams: aiwg-mc
+      tasks: aiwg-mc
+      mcp: native
+      behaviors: null
+      mission_control: aiwg-mc
+      daemon: null
+    hook_wiring:
+      at_link_support: false
+      fallback: full-inject
+      context_file: AGENTS.md
+    interaction:
+      structured_questions: none
+      fallback: markdown
+      notes: No stable structured-question tool contract was qualified for CLI 1.1.26.
+    deploy_target: project
+    aggregated_output: false
+
   pi:
     display_name: Pi Coding Agent
     aliases:
@@ -511,6 +556,47 @@ providers:
     deploy_target: project
     aggregated_output: false
 
+  omp:
+    display_name: Oh My Pi
+    aliases:
+      - oh-my-pi
+    status: experimental
+    daemon_tier: unsupported
+    daemon_pty_adapter: false
+    artifact_paths:
+      agents: .omp/agents/
+      commands: .omp/prompts/
+      skills: .agents/skills/
+      skills_cross_agent: .agents/skills/
+      rules: .omp/rules/
+      behaviors: .omp/extensions/
+    native_features:
+      cron: false
+      agent_teams: true
+      tasks: true
+      mcp: true
+      behaviors: true
+      mission_control: false
+      daemon: false
+    emulation:
+      cron: external-trigger
+      agent_teams: null
+      tasks: null
+      mcp: null
+      behaviors: null
+      mission_control: aiwg-mc
+      daemon: null
+    hook_wiring:
+      at_link_support: true
+      fallback: full-inject
+      context_file: .omp/AGENTS.md
+    interaction:
+      structured_questions: none
+      fallback: markdown
+      notes: OMP integration uses Markdown questions; native UI questions require an interactive runtime.
+    deploy_target: project
+    aggregated_output: false
+
 # Feature definitions — documents what each feature key means and
 # what emulation strategies are available when native support is absent.
 features:

package/dist/src/providers/omp-agent.mjs

@@ -0,0 +1,40 @@
+import path from 'node:path';
+import YAML from 'yaml';
+function parse(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+  return match ? { metadata: YAML.parse(match[1]) || {}, body: match[2] } : { metadata: {}, body: content };
+}
+const render = (metadata, body) => `---\n${YAML.stringify(metadata)}---\n\n${body.trim()}\n`;
+function diagnostic(opts, message) { opts.diagnostics?.push(message); if (!opts.quiet) console.warn(`OMP: ${message}`); }
+export function mapModel(model, config = {}) {
+  if (!model || model === 'inherit') return undefined;
+  const mapped = config.omp?.[model]?.model || config.omp?.[model];
+  if (typeof mapped === 'string') return mapped;
+  if (['opus', 'sonnet', 'haiku', 'reasoning', 'coding', 'efficiency', 'heavy', 'medium', 'light'].includes(model)) return undefined;
+  return model;
+}
+const toolMap = { Read: 'read', Write: 'write', Edit: 'edit', MultiEdit: 'edit', Bash: 'bash', Grep: 'grep', Glob: 'glob', WebSearch: 'web_search', Task: 'task', TodoWrite: 'todo' };
+const nativeTools = new Set(['read','security_scan','bash','edit','ast_grep','ast_edit','ask','debug','eval','github','glob','grep','lsp','checkpoint','rewind','task','hub','todo','web_search','write','memory_edit','retain','recall','reflect','learn','manage_skill','think','yield','goal']);
+const array = value => Array.isArray(value) ? value : typeof value === 'string' ? value.split(',').map(s => s.trim()).filter(Boolean) : [];
+export function transformAgent(src, content, opts = {}) {
+  const { metadata: m, body } = parse(content);
+  const agentName = m.name ?? path.basename(src, '.md');
+  if (typeof agentName !== 'string' || !agentName.trim()) throw new Error('OMP agent name must be a nonempty string');
+  const out = { name: agentName.trim(), description: String(m.description || `AIWG ${path.basename(src, '.md')} agent`) };
+  if (['main','sub'].includes(out.name.toLowerCase())) throw new Error(`OMP reserves agent name ${out.name}`);
+  const tools = array(m.tools).flatMap(tool => {
+    const mapped = toolMap[tool] || (nativeTools.has(tool) ? tool : undefined);
+    if (!mapped) diagnostic(opts, `${out.name}: unsupported tool ${tool}; omitted (degraded)`);
+    return mapped ? [mapped] : [];
+  });
+  // OMP treats empty spawns as undefined; remove task unless explicit delegation is configured.
+  out.spawns = m.spawns === '*' ? '*' : array(m.spawns);
+  out.tools = [...new Set(tools)].filter(tool => tool !== 'task' || out.spawns === '*' || out.spawns.length > 0);
+  if (m.model) {
+    const models = array(m.model).flatMap(model => { const mapped = mapModel(model, opts.modelsConfig || opts.modelConfig || {}); if (!mapped && model !== 'inherit') diagnostic(opts, `${out.name}: unmapped model role ${model}; inherits session model (degraded)`); return mapped ? [mapped] : []; });
+    if (models.length) out.model = models.length === 1 ? models[0] : models;
+  }
+  for (const key of ['thinkingLevel', 'blocking', 'output', 'autoloadSkills', 'readSummarize', 'prewalk', 'advisor']) if (m[key] !== undefined) out[key] = m[key];
+  if (!out.thinkingLevel && m.thinking) out.thinkingLevel = m.thinking;
+  return render(out, body);
+}

package/dist/src/providers/omp-diagnostics.mjs

@@ -0,0 +1,15 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { resolveOmpPaths } from './omp-paths.mjs';
+const execute = promisify(execFile);
+/** Reports only parsed version and non-secret paths; never reflects runtime output. */
+export async function diagnoseOmpRuntime({ cwd = process.cwd(), env = process.env, binary = env.AIWG_OMP_BIN || 'omp', runner = execute } = {}) {
+  const paths = resolveOmpPaths({ cwd, env });
+  const result = { executable: binary, available: false, version: null, paths, reason: 'OMP executable unavailable; install the supported binary or set AIWG_OMP_BIN.' };
+  try {
+    const output = await runner(binary, ['--version'], { cwd, env: { PATH: env.PATH || '', PI_CODING_AGENT_DIR: paths.agentDir, NO_COLOR: '1', ...(env.SystemRoot ? { SystemRoot: env.SystemRoot } : {}) }, timeout: 5000, maxBuffer: 16384, encoding: 'utf8' });
+    const version = output.stdout.trim().match(/^(?:omp\/)?(\d+\.\d+\.\d+(?:[-+][a-zA-Z0-9.-]+)?)$/)?.[1];
+    if (!version) { result.reason = 'OMP returned an unrecognized version; verify the selected executable.'; return result; }
+    return { ...result, available: true, version, reason: null };
+  } catch { return result; }
+}

package/dist/src/providers/omp-paths.mjs

@@ -0,0 +1,38 @@
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+
+/** OMP 18.1.10 profile contract; independent of original Pi configuration. */
+export function normalizeOmpProfile(value) {
+  const name = value?.trim();
+  if (!name || name === 'default') return undefined;
+  if (!/^[a-z0-9][a-z0-9._-]{0,63}$/.test(name) || name.endsWith('.')
+    || /^(?:con|prn|aux|nul|com[0-9]|lpt[0-9])(?:\..*)?$/i.test(name)) {
+    throw new Error('Invalid OMP profile: use 1–64 lowercase letters, digits, dots, hyphens or underscores; reserved device names are forbidden');
+  }
+  return name;
+}
+
+/** Resolve without reading credentials or importing the OMP runtime. */
+export function resolveOmpPaths({ env = process.env, home = homedir(), cwd = process.cwd(),
+  platform = process.platform, exists = existsSync } = {}) {
+  const profile = normalizeOmpProfile(env.OMP_PROFILE !== undefined ? env.OMP_PROFILE : env.PI_PROFILE);
+  const directory = env.PI_CONFIG_DIR || '.omp';
+  const base = path.join(home, directory);
+  const configRoot = profile ? path.join(base, 'profiles', profile) : base;
+  const defaultAgent = path.join(configRoot, 'agent');
+  const agentDir = !profile && env.PI_CODING_AGENT_DIR
+    ? path.resolve(cwd, env.PI_CODING_AGENT_DIR) : defaultAgent;
+  const xdg = (variable) => {
+    if (!['linux', 'darwin'].includes(platform) || agentDir !== defaultAgent || !env[variable]) return undefined;
+    const root = path.join(env[variable], 'omp');
+    const candidate = profile ? path.join(root, 'profiles', profile) : root;
+    return exists(candidate) ? candidate : undefined;
+  };
+  const dataDir = xdg('XDG_DATA_HOME') || agentDir;
+  const stateDir = xdg('XDG_STATE_HOME') || agentDir;
+  const cacheDir = xdg('XDG_CACHE_HOME') || agentDir;
+  const resourceDirs = { agents: path.join(defaultAgent, 'agents'), skills: path.join(agentDir, 'skills'), commands: path.join(agentDir, 'prompts'), rules: path.join(agentDir, 'rules'), behaviors: path.join(agentDir, 'extensions') };
+  return { profile, configRoot, agentDir, resourceDirs, projectDir: path.join(cwd, '.omp'),
+    dataDir, stateDir, cacheDir, sessionsDir: path.join(dataDir, 'sessions') };
+}