@aiwg/cli 2026.9.2 → 2026.9.3

package/dist/src/cli/handlers/init.js

@@ -20,6 +20,7 @@ import { askString as sharedAskString, askYesNo as sharedAskYesNo } from '../pro
 import { writeNormalizedAiwgMd } from '../../smiths/context-pipeline/finalization.js';
 import { ensureWorkspaceContext } from '../../smiths/context-pipeline/workspace-context.js';
 const PROVIDER_LABELS = {
+    antigravity: 'Google Antigravity .agents/',
     claude: 'Claude Code       .claude/',
     copilot: 'GitHub Copilot    .github/',
     cursor: 'Cursor            .cursor/',
@@ -30,6 +31,7 @@ const PROVIDER_LABELS = {
     codex: 'OpenAI Codex      ~/.codex/',
     openclaw: 'OpenClaw          ~/.openclaw/',
     hermes: 'Hermes (MCP)      aiwg mcp',
+    omp: 'Oh My Pi         .omp/ + .agents/skills/',
     pi: 'Pi Coding Agent   .pi/ + .agents/skills/',
 };
 // Local aliases for the shared prompt utilities. These preserve existing

package/dist/src/cli/handlers/models.js

@@ -10,7 +10,7 @@ import { load as loadYaml } from 'js-yaml';
 import { compileModelPolicy, validateCanonicalModelPolicy, validateUserProjectModelConfig, } from '../../models/provider-policy.js';
 const TIERS = new Set(['economy', 'standard', 'premium', 'max-quality']);
 const PROVIDERS = new Set([
-    'claude', 'codex', 'copilot', 'cursor', 'factory', 'hermes',
+    'antigravity', 'claude', 'codex', 'copilot', 'cursor', 'factory', 'hermes',
     'opencode', 'openclaw', 'openhuman', 'warp', 'windsurf',
 ]);
 function parseArgs(args) {

package/dist/src/cli/handlers/runtime-info.js

@@ -88,8 +88,13 @@ async function handleRuntimeInfo(args, cwd = process.cwd()) {
     if (hasProviders) {
         const { collectProviderInventory } = await import('../../providers/provider-inventory.js');
         const inventory = await collectProviderInventory(cwd);
+        const selected = args[args.indexOf('--provider') + 1];
+        const ompSelected = args.includes('--provider') && ['omp', 'oh-my-pi'].includes(selected);
+        const ompRuntime = ompSelected
+            ? await (await import('../../providers/omp-diagnostics.mjs')).diagnoseOmpRuntime({ cwd })
+            : undefined;
         if (hasJson) {
-            console.log(JSON.stringify(inventory, null, 2));
+            console.log(JSON.stringify({ ...inventory, ...(ompRuntime ? { ompRuntime } : {}) }, null, 2));
         }
         else {
             console.log('\nProvider Inventory');
@@ -109,6 +114,8 @@ async function handleRuntimeInfo(args, cwd = process.cwd()) {
                 for (const reason of provider.reasons)
                     console.log(`  note: ${reason}`);
             }
+            if (ompRuntime)
+                console.log(`\nOMP runtime: ${JSON.stringify(ompRuntime, null, 2)}`);
         }
         return;
     }

package/dist/src/cli/handlers/session.js

@@ -26,6 +26,7 @@ import { readAiwgConfig, getDeploymentSummary, VALID_PROVIDERS, } from '../../co
 import { getProviderConfig, isSpawnableProvider, PROVIDER_CONFIGS, } from '../agent-spawn.js';
 import { useHandler as useFrameworkHandler } from './use.js';
 import { debug } from '../log.js';
+import { normalizeProviderDefinitionId } from '../../providers/provider-definitions.js';
 // ── Provider resolution ──────────────────────────────────────────────────────
 /**
  * Resolve which provider to target.
@@ -33,11 +34,11 @@ import { debug } from '../log.js';
  */
 async function resolveProvider(explicitProvider, cwd) {
     if (explicitProvider) {
-        if (!VALID_PROVIDERS.includes(explicitProvider)) {
-            console.warn(`  WARN  Unknown provider '${explicitProvider}' — falling back to 'claude'`);
-            return 'claude';
+        const normalized = normalizeProviderDefinitionId(explicitProvider);
+        if (!normalized || normalized === 'generic' || !VALID_PROVIDERS.includes(normalized)) {
+            throw new Error(`Unsupported provider '${explicitProvider}'`);
         }
-        return explicitProvider;
+        return normalized;
     }
     const config = await readAiwgConfig(cwd);
     if (config?.providers?.[0]) {

package/dist/src/cli/handlers/sessions.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, realpathSync, statSync, } from 'node:fs';
 import { dirname, isAbsolute, resolve, } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { CLAUDE_ADAPTER_VERSION, ClaudeSessionAdapter, CODEX_ADAPTER_VERSION, CodexSessionAdapter, COPILOT_ADAPTER_VERSION, CopilotSessionAdapter, CURSOR_ADAPTER_VERSION, CursorSessionAdapter, FACTORY_ADAPTER_VERSION, FactorySessionAdapter, HERMES_ADAPTER_VERSION, HermesSessionAdapter, OPENCODE_ADAPTER_VERSION, OpenCodeSessionAdapter, OPENCLAW_ADAPTER_VERSION, OpenClawSessionAdapter, OPENHUMAN_ADAPTER_VERSION, OpenHumanSessionAdapter, PI_ADAPTER_VERSION, PiSessionAdapter, WARP_ADAPTER_VERSION, WarpSessionAdapter, DEVIN_DESKTOP_ADAPTER_VERSION, DevinDesktopSessionAdapter, CandidateExtractionService, GENERIC_ADAPTER_VERSION, GenericSessionInterchangeAdapter, IncrementalSessionImporter, ImportLeaseContentionError, FilesystemMemoryDestination, FilesystemPromotionDispositionCoordinator, MemoryPromotionGateway, SESSION_CONTRACT_VERSION, SESSION_PROVIDER_IDS, SessionContractError, SessionRepository, SessionSourceSchema, StructuralCandidateExtractor, resolveMemoryConsumerManifest, assertSessionProviderId, acquireImportLease, defaultDiscoveryManifestPath, discoverWorkspaceHistories, deriveSessionTimeline, importDiscoveryManifest, previewDiscoveryImport, publicDiscoveryManifest, readDiscoveryManifest, redactSourceLocator, sha256, parseTimelineGap, writeDiscoveryManifest, } from '../../sessions/index.js';
+import { CLAUDE_ADAPTER_VERSION, ClaudeSessionAdapter, CODEX_ADAPTER_VERSION, CodexSessionAdapter, COPILOT_ADAPTER_VERSION, CopilotSessionAdapter, CURSOR_ADAPTER_VERSION, CursorSessionAdapter, FACTORY_ADAPTER_VERSION, FactorySessionAdapter, HERMES_ADAPTER_VERSION, HermesSessionAdapter, OPENCODE_ADAPTER_VERSION, OpenCodeSessionAdapter, OPENCLAW_ADAPTER_VERSION, OpenClawSessionAdapter, OPENHUMAN_ADAPTER_VERSION, OpenHumanSessionAdapter, PI_ADAPTER_VERSION, PiSessionAdapter, OmpSessionAdapter, OMP_ADAPTER_VERSION, WARP_ADAPTER_VERSION, WarpSessionAdapter, DEVIN_DESKTOP_ADAPTER_VERSION, DevinDesktopSessionAdapter, CandidateExtractionService, GENERIC_ADAPTER_VERSION, GenericSessionInterchangeAdapter, IncrementalSessionImporter, ImportLeaseContentionError, FilesystemMemoryDestination, FilesystemPromotionDispositionCoordinator, MemoryPromotionGateway, SESSION_CONTRACT_VERSION, SESSION_PROVIDER_IDS, SessionContractError, SessionRepository, SessionSourceSchema, StructuralCandidateExtractor, resolveMemoryConsumerManifest, assertSessionProviderId, acquireImportLease, defaultDiscoveryManifestPath, discoverWorkspaceHistories, deriveSessionTimeline, importDiscoveryManifest, previewDiscoveryImport, publicDiscoveryManifest, readDiscoveryManifest, redactSourceLocator, sha256, parseTimelineGap, writeDiscoveryManifest, } from '../../sessions/index.js';
 const JSON_CONTRACT_VERSION = '1.0.0';
 async function createLineMemoryPromotionDestination(projectRoot, manifestPath) {
     const modulePath = resolve(dirname(manifestPath), 'commands', 'line-memory.mjs');
@@ -54,6 +54,7 @@ Options:
   --manifest <path>  Override the discovery manifest path
   --provider-home <path>  Override the provider home root (testing/portable homes)
   --codex-root <path>  Explicitly authorize a shared Codex sessions/export root
+  --omp-root <path>  Explicitly authorize an OMP profile sessions root
   --confirm, --yes  Confirm a persistent discovered batch import
   --lock-wait-ms <n>  Maximum import-lease wait (default 5000)
   --inactivity-threshold <duration>  Historical inactivity threshold (default 24h)
@@ -622,7 +623,7 @@ async function importSource(ctx, args) {
     if (provider !== 'generic' && provider !== 'claude' && provider !== 'codex'
         && provider !== 'copilot' && provider !== 'cursor' && provider !== 'factory'
         && provider !== 'hermes' && provider !== 'opencode' && provider !== 'openclaw'
-        && provider !== 'openhuman' && provider !== 'pi' && provider !== 'warp' && provider !== 'devin-desktop') {
+        && provider !== 'openhuman' && provider !== 'pi' && provider !== 'omp' && provider !== 'warp' && provider !== 'devin-desktop') {
         throw new CliError('UNSUPPORTED_OPERATION', `session import is not implemented for ${provider}`, EXIT.unsupported);
     }
     const sourceId = requiredValue(args, '--source-id');
@@ -639,9 +640,10 @@ async function importSource(ctx, args) {
     const isOpenClaw = provider === 'openclaw';
     const isOpenHuman = provider === 'openhuman';
     const isPi = provider === 'pi';
+    const isOmp = provider === 'omp';
     const isWarp = provider === 'warp';
     const isDevinDesktop = provider === 'devin-desktop';
-    const adapter = isClaude
+    const adapter = isOmp ? new OmpSessionAdapter() : isClaude
         ? new ClaudeSessionAdapter()
         : isCodex
             ? new CodexSessionAdapter()
@@ -666,7 +668,7 @@ async function importSource(ctx, args) {
                                                 : isDevinDesktop
                                                     ? new DevinDesktopSessionAdapter()
                                                     : new GenericSessionInterchangeAdapter();
-    const locatorClass = isClaude
+    const locatorClass = isOmp ? 'omp-session-v3-jsonl' : isClaude
         ? (input.endsWith('.hooks.jsonl') ? 'claude-hook-jsonl' : 'claude-transcript-jsonl')
         : isCodex
             ? (input.endsWith('.app-server.jsonl') ? 'codex-app-server-jsonl' : 'codex-rollout-jsonl')
@@ -698,7 +700,7 @@ async function importSource(ctx, args) {
     const probe = await adapter.inspect(selectedSource);
     const source = SessionSourceSchema.parse({
         contractVersion: SESSION_CONTRACT_VERSION, sourceId, provider,
-        providerProfile: isClaude
+        providerProfile: isOmp ? 'native-title-slot-v3' : isClaude
             ? 'documented-local-jsonl'
             : isCodex
                 ? 'app-server-v2-rollout-fallback'
@@ -722,7 +724,7 @@ async function importSource(ctx, args) {
                                                     ? 'opt-in-cascade-transcript-hook'
                                                     : 'manual-interchange',
         locatorClass, redactedLocator: redactSourceLocator(input),
-        adapterVersion: isClaude
+        adapterVersion: isOmp ? OMP_ADAPTER_VERSION : isClaude
             ? CLAUDE_ADAPTER_VERSION
             : isCodex
                 ? CODEX_ADAPTER_VERSION
@@ -749,11 +751,11 @@ async function importSource(ctx, args) {
         disposition: isWarp
             ? 'manual-only'
             : isClaude || isCodex || isCopilot || isCursor || isFactory || isHermes
-                || isOpenCode || isOpenClaw || isOpenHuman || isDevinDesktop
+                || isOpenCode || isOpenClaw || isOpenHuman || isDevinDesktop || isOmp
                 ? 'implemented' : 'manual-only',
         operationalState: probe.operationalState,
         consistency: probe.consistency, authorizedAt: new Date().toISOString(),
-        extensions: isClaude
+        extensions: isOmp ? { 'native.omp': {} } : isClaude
             ? { 'native.claude': {} }
             : isCodex
                 ? { 'native.codex': {} }
@@ -817,6 +819,8 @@ async function discoverWorkspace(ctx, args) {
         providerHome: args.values.has('--provider-home')
             ? resolve(ctx.cwd, args.values.get('--provider-home'))
             : undefined,
+        ompRoot: args.values.has('--omp-root')
+            ? resolve(ctx.cwd, args.values.get('--omp-root')) : undefined,
         codexRoot: args.values.has('--codex-root')
             ? resolve(ctx.cwd, args.values.get('--codex-root'))
             : undefined,
@@ -1012,6 +1016,19 @@ function providerDisposition(provider) {
             },
         };
     }
+    if (provider === 'omp') {
+        return {
+            provider, disposition: 'implemented', operationalState: 'available',
+            supportedOperations: ['discover', 'inspect', 'stream'],
+            acquisitionModes: ['jsonl'], reasonCode: null,
+            remediation: 'Authorize the selected OMP profile sessions root or an explicit native JSONL file.',
+            evidence: {
+                adapterVersion: OMP_ADAPTER_VERSION,
+                verifiedAt: '2026-09-04',
+                documentation: 'https://github.com/can1357/oh-my-pi/blob/main/packages/coding-agent/src/session/session-entries.ts',
+            },
+        };
+    }
     if (provider === 'pi') {
         return {
             provider, disposition: 'implemented', operationalState: 'available',
@@ -1121,7 +1138,7 @@ function parseArgs(argv) {
         '--entity', '--sensitivity', '--extraction-state', '--page-size', '--max-documents',
         '--state', '--reviewer', '--reason', '--policy-version', '--min-confidence',
         '--consumer', '--actor-class', '--reason-code', '--dependent-action', '--basis',
-        '--manifest', '--provider-home', '--codex-root', '--lock-wait-ms', '--min-coverage', '--gap',
+        '--manifest', '--provider-home', '--codex-root', '--omp-root', '--lock-wait-ms', '--min-coverage', '--gap',
         '--inactivity-threshold',
         '--control-events',
         '--session', '--status', '--actor', '--group-by',

package/dist/src/cli/handlers/setup.js

@@ -5,6 +5,7 @@ import { AiwgError, EXIT_CODES } from '../errors.js';
 import { askChoice, askString, askYesNo, createPromptInterface } from '../prompt-utils.js';
 import * as ui from '../ui.js';
 import { projectAiwgPath } from '../../config/project-artifacts.js';
+import { normalizeProviderDefinitionId } from '../../providers/provider-definitions.js';
 const DELIVERY_MODES = ['pr-required', 'feature-branch', 'direct'];
 const FORCE_PUSH_POLICIES = ['never', 'own-branch-only', 'allowed'];
 const ISSUE_PROVIDERS = ['gitea', 'github', 'local'];
@@ -56,7 +57,10 @@ function parseStringList(raw) {
 }
 function parseProviders(raw, fallback) {
     const providers = parseStringList(raw);
-    return providers && providers.length > 0 ? providers : fallback;
+    return providers && providers.length > 0 ? normalizeProviders(providers) : fallback;
+}
+function normalizeProviders(providers) {
+    return providers.map(provider => normalizeProviderDefinitionId(provider) ?? provider);
 }
 export function parseSetupProjectOptions(ctx) {
     const args = ctx.args;
@@ -88,7 +92,10 @@ export function parseSetupProjectOptions(ctx) {
         trackerActorVia: parseEnum(flagValue(args, '--tracker-actor-via'), TRACKER_VIA, '--tracker-actor-via'),
         customerTrackerActorLogin: flagValue(args, '--customer-tracker-actor-login'),
         customerTrackerActorVia: parseEnum(flagValue(args, '--customer-tracker-actor-via'), TRACKER_VIA, '--customer-tracker-actor-via'),
-        providers: parseStringList(flagValue(args, '--providers')),
+        providers: (() => {
+            const providers = parseStringList(flagValue(args, '--providers'));
+            return providers ? normalizeProviders(providers) : undefined;
+        })(),
     };
 }
 export function detectGitRemotes(projectDir) {

package/dist/src/cli/handlers/steward.js

@@ -82,7 +82,18 @@ function formatProvider(id, provider, matrix, meta) {
         if (feat?.description)
             lines.push(`    ${feat.description}`);
         if (isNative) {
-            if (feat?.native_example)
+            if (id === 'omp' && featureId === 'mcp') {
+                lines.push('    OMP supplies the native client. AIWG persistent injection/removal is available for project and profile scope; ephemeral injection is unsupported.');
+                lines.push('    example: aiwg mcp inject --provider omp --servers local-tools');
+            }
+            else if (id === 'omp' && featureId === 'behaviors') {
+                lines.push('    AIWG bridges selected handlers through an OMP extension; no default policy is installed. Permission-request and pre-compaction enforcement are unsupported.');
+            }
+            else if (id === 'omp' && (featureId === 'tasks' || featureId === 'agent_teams')) {
+                lines.push('    OMP native leaf tasks use AIWG workspace admission limits and verified child results; nested requests share the same scheduler.');
+                lines.push('    example: aiwg team run --provider omp --body-file tasks.json');
+            }
+            else if (feat?.native_example)
                 lines.push(`    example: ${feat.native_example}`);
         }
         else if (isExternalStrategy(emulation)) {
@@ -195,7 +206,7 @@ async function handleSteward(args, ctx) {
     aiwg steward permissions migrate --apply      Back up and atomically normalize config
 
   Providers:
-    claude-code, codex, copilot, cursor, factory, opencode, pi, warp, windsurf, hermes, openclaw
+    antigravity (agy), claude-code, codex, copilot, cursor, factory, opencode, pi, omp, warp, windsurf, hermes, openclaw
 
   Features:
     cron, agent_teams, tasks, mcp, behaviors, mission_control, daemon

package/dist/src/cli/handlers/subcommands.js

@@ -689,6 +689,17 @@ export const removeHandler = {
     category: "framework",
     aliases: [],
     async execute(ctx) {
+        // Explicit provider removal is separate from framework removal. The native
+        // adapter validates receipt hashes and preserves operator modifications.
+        const nativeRemovalProvider = parseRemoveProvider(ctx.args);
+        if (firstRemovePositional(ctx.args) === 'omp' && nativeRemovalProvider.provider === 'omp') {
+            const { uninstall } = await import('../../../tools/agents/providers/omp.mjs');
+            const { getProjectDir } = await import('../../config/aiwg-config.js');
+            const dryRun = ctx.args.includes('--dry-run');
+            const scope = ctx.args.includes('--user') || isScopeUser(ctx.args) ? 'user' : 'project';
+            const count = uninstall(getProjectDir({ cwd: ctx.cwd }, ctx.args), { dryRun, scope });
+            return { exitCode: 0, message: `${dryRun ? 'Would remove' : 'Removed'} ${count} unchanged OMP-owned files; operator files preserved.` };
+        }
         // #1156 Phase 1 — `--scope user` / `--user`: revert the user-scope mirror
         // for the given framework. Independent of any project; reads the per-user
         // registry at ~/.aiwg/installed.json to find what was deployed, deletes

package/dist/src/cli/handlers/team.js

@@ -1,10 +1,10 @@
 /**
  * Team Command Handler
  *
- * Extends Claude Code's native agent teams feature to all 9 AIWG providers.
+ * Routes declared teams across AIWG providers, including bounded native OMP tasks.
  * Provides a provider-agnostic abstraction for declaring, deploying, and
  * invoking agent teams. On Claude Code, delegates to native team mechanisms.
- * On all other providers, emulates via aiwg mc (Mission Control) orchestration.
+ * OMP executes explicit task files; other providers use aiwg mc orchestration.
  *
  * Subcommands: run, list, info
  *
@@ -12,13 +12,15 @@
  */
 import * as ui from '../ui.js';
 import { promises as fs } from 'node:fs';
-import { join, basename } from 'node:path';
+import { join, basename, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { projectAiwgPath } from '../../config/project-artifacts.js';
+import { normalizeProviderDefinitionId } from '../../providers/provider-definitions.js';
 // ── Provider Detection ───────────────────────────────────────
 function detectProvider(args) {
     const providerFlag = parseFlag(args, '--provider');
     if (providerFlag)
-        return providerFlag;
+        return normalizeProviderDefinitionId(providerFlag) ?? providerFlag;
     // Claude Code sets CLAUDE_CODE_VERSION; API key presence is secondary heuristic
     const isClaudeCode = process.env.CLAUDE_CODE_VERSION !== undefined ||
         process.env.ANTHROPIC_API_KEY !== undefined;
@@ -103,7 +105,57 @@ async function listAllTeams(frameworkRoot, cwd) {
     return teams;
 }
 // ── Subcommand: run ──────────────────────────────────────────
+/** Public OMP dispatch delegates to the same bounded native runtime used by conformance. */
+async function teamRunOmp(ctx) {
+    const allowed = new Set(['--provider', '--body-file', '--cwd', '--output-root', '--max-parallel', '--model', '--profile']);
+    const values = {};
+    for (let i = 0; i < ctx.args.length; i++) {
+        const flag = ctx.args[i];
+        if (flag === '--json')
+            continue;
+        if (!allowed.has(flag) || !ctx.args[i + 1] || ctx.args[i + 1].startsWith('--')) {
+            ui.error('OMP usage: aiwg team run --provider omp --body-file tasks.json [--cwd DIR] [--output-root DIR] [--max-parallel N] [--model provider/model] [--profile NAME]');
+            return { exitCode: 1 };
+        }
+        values[flag] = ctx.args[++i];
+    }
+    if (!values['--body-file']) {
+        ui.error('OMP native team dispatch requires --body-file tasks.json with explicit task ownership and tools.');
+        return { exitCode: 1 };
+    }
+    const maxParallel = values['--max-parallel'] === undefined ? 4 : Number(values['--max-parallel']);
+    if (!Number.isInteger(maxParallel) || maxParallel < 1) {
+        ui.error('OMP --max-parallel must be a positive integer.');
+        return { exitCode: 1 };
+    }
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    process.once('SIGINT', abort);
+    process.once('SIGTERM', abort);
+    try {
+        const payload = JSON.parse(await fs.readFile(resolve(ctx.cwd, values['--body-file']), 'utf8'));
+        const { runOmpTeam } = await import(pathToFileURL(join(ctx.frameworkRoot, 'tools/providers/omp-teams.mjs')).href);
+        const result = await runOmpTeam({
+            tasks: payload.tasks,
+            cwd: values['--cwd'] ? resolve(ctx.cwd, values['--cwd']) : ctx.cwd,
+            outputDir: values['--output-root'] ? resolve(ctx.cwd, values['--output-root']) : undefined,
+            maxParallel, model: values['--model'], profile: values['--profile'], signal: controller.signal,
+        });
+        console.log(JSON.stringify(result, null, 2));
+        return { exitCode: result.results.every((task) => task.status === 'completed') ? 0 : 1 };
+    }
+    catch (error) {
+        ui.error(error instanceof SyntaxError ? 'OMP task body is invalid JSON.' : error instanceof Error ? error.message : 'OMP team dispatch failed.');
+        return { exitCode: 1 };
+    }
+    finally {
+        process.removeListener('SIGINT', abort);
+        process.removeListener('SIGTERM', abort);
+    }
+}
 async function teamRun(ctx) {
+    if (['omp', 'oh-my-pi'].includes(detectProvider(ctx.args)))
+        return teamRunOmp(ctx);
     const positional = getPositionalArgs(ctx.args);
     const slug = positional[0];
     if (!slug) {
@@ -186,7 +238,7 @@ async function teamList(ctx) {
         ui.info('No teams found. Deploy the sdlc-complete framework with: aiwg use sdlc');
         return { exitCode: 0 };
     }
-    const backend = isNativeTeamsProvider(provider)
+    const backend = ['omp', 'oh-my-pi'].includes(provider) ? 'native (Oh My Pi)' : isNativeTeamsProvider(provider)
         ? 'native (Claude Code)'
         : `aiwg mc emulation (${provider})`;
     ui.blank();
@@ -277,21 +329,30 @@ function showTeamHelp() {
   ${ui.bold('Usage:')} aiwg team <subcommand> [options]
 
   ${ui.bold('Subcommands:')}
-    run <name>             Execute a team (native on Claude Code, aiwg mc on others)
+    run <name>             Run a declared team (Claude native guidance or aiwg mc)
+    run --provider omp --body-file tasks.json   Execute bounded native OMP tasks
     list                   List available teams
     info <name>            Show team definition and agent roster
 
   ${ui.bold('Options:')}
-    --provider <p>         Override provider: claude|warp|copilot|cursor|windsurf|opencode|factory|codex|openclaw
+    --provider <p>         Override provider: antigravity|agy|claude|warp|copilot|cursor|windsurf|opencode|factory|codex|openclaw|omp|oh-my-pi
     --objective "<text>"   Set objective passed to mc dispatch agents
+    --body-file <file>    OMP task JSON with explicit ownership and tools
+    --cwd <dir>          OMP working directory (defaults to current workspace)
+    --output-root <dir>  OMP result and control artifact directory
+    --max-parallel <n>   OMP requested worker cap (workspace ceiling still applies)
+    --model <id>         OMP coordinator/worker model selector
+    --profile <name>     OMP native profile
     --json                 Machine-readable output
 
   ${ui.bold('Provider Routing:')}
     Claude Code            Native agent team dispatch (@agent-name invocation)
+    Oh My Pi               Bounded native task execution from --body-file
     All others             aiwg mc emulation (Mission Control sequential/parallel dispatch)
 
   ${ui.bold('Examples:')}
     aiwg team run sdlc-review
+    aiwg team run --provider omp --body-file tasks.json
     aiwg team run sdlc-review --provider cursor --objective "Phase gate review"
     aiwg team run security-review --objective "Pre-release audit"
     aiwg team list

package/dist/src/cli/handlers/use.js

@@ -12,6 +12,8 @@
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
+import { pathToFileURL } from 'node:url';
+import { resolveOmpPaths } from '../../providers/omp-paths.mjs';
 import YAML from 'yaml';
 import { createScriptRunner } from './script-runner.js';
 import { getFrameworkRoot, getVersionInfo } from '../../channel/manager.mjs';
@@ -1041,10 +1043,10 @@ async function reconcileDeployedSkillAssets(bundlePath, target, provider, option
     }
     const paths = getProviderPaths(provider);
     const kernelSkillsPath = getProviderKernelSkillsPath(provider);
-    const deployRoots = [...new Set([
-            paths.skills,
-            kernelSkillsPath,
-        ].filter((value) => Boolean(value)).map(value => resolveDeployPath(target, value)))];
+    const deployRoots = provider === 'omp' && options.scope === 'user'
+        ? [path.join(resolveOmpPaths({ cwd: target }).agentDir, 'skills')]
+        : [...new Set([paths.skills, kernelSkillsPath]
+                .filter((value) => Boolean(value)).map(value => resolveDeployPath(target, value)))];
     for (const skillName of skillDirs) {
         const sourceSkillDir = path.join(skillsRoot, skillName);
         const sourceSkillMd = path.join(sourceSkillDir, 'SKILL.md');
@@ -1055,6 +1057,8 @@ async function reconcileDeployedSkillAssets(bundlePath, target, provider, option
         catch {
             continue;
         }
+        if (options.skipUndeployed && !(await Promise.all(deployRoots.map(root => fileExists(path.join(root, skillName, 'SKILL.md'))))).some(Boolean))
+            continue;
         const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---/)?.[1] ?? '';
         const declaredEntrypoint = frontmatter
             .match(/^[ \t]+entrypoint:\s*["']?([^"'\s]+)["']?\s*$/m)?.[1];
@@ -1097,6 +1101,11 @@ async function reconcileDeployedSkillAssets(bundlePath, target, provider, option
             if (!deployedSkillRoot)
                 throw new Error(`deployed skill '${skillName}' not found while reconciling support assets`);
             const destination = path.join(deployedSkillRoot, skillName, ...normalized.split('/'));
+            if (provider === 'omp') {
+                const adapter = await import(pathToFileURL(path.join(await getFrameworkRoot(), 'tools/agents/providers/omp.mjs')).href);
+                adapter.deploySkillSupportAsset(source, destination, { quiet: true });
+                continue;
+            }
             await fs.mkdir(path.dirname(destination), { recursive: true });
             await fs.copyFile(source, destination);
             const mode = (await fs.stat(source)).mode & 0o777;
@@ -1348,6 +1357,18 @@ async function deployProjectLocalBundles(opts) {
             }
         }
     }
+    // Automatic reconciliation (also used by refresh/upgrade) must restore the
+    // project search cache for existing bundles, just as a named local install
+    // does. Named installs refresh once after all selected providers finish.
+    if (deployed > 0 && !dryRun && !onlyBundleId) {
+        try {
+            await rebuildExternalBundleIndex(projectDir, 'project', verbose);
+        }
+        catch (error) {
+            failed++;
+            ui.warn(`Project-local index refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     // Refresh the project kernel quickref from either legacy operator input or
     // managed project-local discovery whenever bundles deploy.
     const { hasProjectQuickref, deployProjectQuickref } = await import('../../extensions/project-quickref.js');
@@ -1968,6 +1989,65 @@ async function rebuildExternalBundleIndex(projectDir, graph, verbose) {
     }
     ui.dim(`  Refreshed ${graph}-scope capability index`);
 }
+/** User OMP writes use native ownership receipts instead of an unconditional copy. */
+async function deployOmpUserSource(opts) {
+    const adapter = await import(pathToFileURL(path.join(opts.frameworkRoot, 'tools/agents/providers/omp.mjs')).href);
+    await adapter.deploy({ srcRoot: opts.source, target: opts.target, provider: 'omp', scope: 'user',
+        mode: opts.mode ?? 'general', deployCommands: true, deploySkills: true, deployRules: true,
+        copyStandardSkills: opts.copyAll, quiet: true, deployVersion: (await getVersionInfo()).version });
+    const sourceBundles = new Set([opts.source]);
+    const { resourceDirs } = resolveOmpPaths({ cwd: opts.target });
+    const entries = {
+        agents: [], commands: [], skills: [], rules: [], behaviors: [],
+    };
+    const belongsToBundle = (entry) => {
+        if (entry.provider !== 'omp' || typeof entry.source !== 'string')
+            return false;
+        if (entry.transformation === 'omp-extension')
+            return true;
+        const relative = path.relative(opts.source, entry.source);
+        return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+    };
+    const locations = resourceDirs;
+    for (const kind of Object.keys(entries)) {
+        const directory = locations[kind];
+        if (kind === 'skills') {
+            let children;
+            try {
+                children = await fs.readdir(directory);
+            }
+            catch {
+                continue;
+            }
+            for (const child of children) {
+                try {
+                    const receipt = JSON.parse(await fs.readFile(path.join(directory, child, '.aiwg-manifest.json'), 'utf8'));
+                    if (receipt.managed?.['SKILL.md'] && belongsToBundle(receipt.managed['SKILL.md'])) {
+                        entries.skills.push(child);
+                        const source = receipt.managed['SKILL.md'].source;
+                        if (typeof source === 'string')
+                            sourceBundles.add(path.dirname(path.dirname(path.dirname(source))));
+                    }
+                }
+                catch { /* operator resources have no OMP receipt */ }
+            }
+        }
+        else {
+            try {
+                const receipt = JSON.parse(await fs.readFile(path.join(directory, '.aiwg-manifest.json'), 'utf8'));
+                entries[kind] = Object.entries(receipt.managed ?? {}).filter(([, entry]) => belongsToBundle(entry)).map(([name]) => name);
+            }
+            catch { /* no deployed resources of this kind */ }
+        }
+    }
+    for (const source of sourceBundles)
+        await reconcileDeployedSkillAssets(source, opts.target, 'omp', { strictReferences: false, scope: 'user', skipUndeployed: !opts.copyAll });
+    const { recordUserDeploy } = await import('../../config/user-registry.js');
+    await recordUserDeploy({ framework: opts.bundle, provider: 'omp',
+        version: (await getVersionInfo()).version, source: 'bundled',
+        counts: { agents: entries.agents.length, commands: entries.commands.length,
+            skills: entries.skills.length, rules: entries.rules.length }, entries });
+}
 async function mirrorProjectLocalBundleToUserScope(opts) {
     const paths = getProviderPaths(opts.provider);
     const resolveProjectPath = (value) => !value ? '' : path.isAbsolute(value) ? value : path.join(opts.target, value);
@@ -2701,10 +2781,25 @@ export class UseHandler {
         if (isAddon || isExtension) {
             const providerIdx = remainingArgs.findIndex(a => a === '--provider' || a === '--platform');
             const explicitAddonProvider = providerIdx >= 0 && remainingArgs[providerIdx + 1] ? remainingArgs[providerIdx + 1] : null;
-            const provider = explicitAddonProvider ?? (config?.providers?.[0] ?? 'claude');
+            const provider = resolveBuiltInProviderForUse(explicitAddonProvider ?? (config?.providers?.[0] ?? 'claude')).provider;
             const targetIdx = remainingArgs.findIndex(a => a === '--target');
             const target = targetIdx >= 0 && remainingArgs[targetIdx + 1] ? remainingArgs[targetIdx + 1] : process.cwd();
             const dryRunAddon = remainingArgs.includes('--dry-run');
+            let addonScope;
+            try {
+                addonScope = detectScope(remainingArgs);
+                if (addonScope === 'project' && remainingArgs.includes('--user'))
+                    addonScope = 'user';
+            }
+            catch (error) {
+                return { exitCode: 1, message: `Error: ${error instanceof Error ? error.message : String(error)}` };
+            }
+            if (addonScope === 'user' && !USER_SCOPE_PATHS[provider]) {
+                return {
+                    exitCode: 1,
+                    message: `--scope user not supported for provider '${provider}' — see docs/customization/user-scope-deployment.md for the supported list`,
+                };
+            }
             const runner = createScriptRunner(frameworkRoot);
             const addonBaseArgs = ['--deploy-commands', '--deploy-skills', '--deploy-rules'];
             // An explicitly selected upstream addon must be self-contained in the
@@ -2797,6 +2892,14 @@ export class UseHandler {
                     };
                 }
             }
+            if (!dryRunAddon && provider === 'omp' && (detectScope(remainingArgs) === 'user' || remainingArgs.includes('--user'))) {
+                try {
+                    await deployOmpUserSource({ frameworkRoot, source: addonSource, target, bundle: framework, copyAll: true });
+                }
+                catch (error) {
+                    return { exitCode: 1, message: `OMP user deployment failed: ${error instanceof Error ? error.message : String(error)}` };
+                }
+            }
             // Register only artifacts actually written by a confirmed deployment.
             if (!dryRunAddon) {
                 try {
@@ -2922,7 +3025,7 @@ export class UseHandler {
             catch {
                 // Profile selection is optional — don't fail deployment
             }
-            if (framework === 'aiwg-utils' && provider !== 'pi' && !remainingArgs.includes('--dry-run')) {
+            if (framework === 'aiwg-utils' && !['pi', 'omp'].includes(provider) && !remainingArgs.includes('--dry-run')) {
                 const wrapperValidation = await validateDeployedModelWrappers({
                     provider: normalizeProviderDefinitionId(provider) ?? provider,
                     target,
@@ -3025,7 +3128,7 @@ export class UseHandler {
             ? withProviderOverride(deployFilteredArgs, provider)
             : deployFilteredArgs;
         const bulkKernelOnly = framework === 'all'
-            && provider !== 'pi'
+            && !['pi', 'omp'].includes(provider)
             && !remainingArgs.includes('--copy-all')
             && !remainingArgs.includes('--copy-standard-skills');
         if (bulkKernelOnly)
@@ -3234,7 +3337,7 @@ export class UseHandler {
         // Pi model selection/headless routing is delivered by #2151. Until that
         // adapter exists, do not require model-wrapper artifacts that Pi cannot
         // load; resource deployment remains independently valid.
-        if (!dryRun && !skipUtils && !bulkKernelOnly && provider !== 'pi') {
+        if (!dryRun && !skipUtils && !bulkKernelOnly && !['pi', 'omp'].includes(provider)) {
             const wrapperValidation = await validateDeployedModelWrappers({
                 provider,
                 target,
@@ -3424,7 +3527,16 @@ export class UseHandler {
         // mirror, record the deploy in the per-user registry at
         // ~/.aiwg/installed.json so `aiwg list --scope user` and `aiwg remove
         // --scope user` can find it from any cwd.
-        if (scope === 'user' && provider !== 'openhuman' && !dryRun) {
+        if (scope === 'user' && provider === 'omp' && !dryRun) {
+            try {
+                await deployOmpUserSource({ frameworkRoot, source: frameworkRoot, target, bundle: framework, mode,
+                    copyAll: remainingArgs.includes('--copy-all') || remainingArgs.includes('--copy-standard-skills') });
+            }
+            catch (error) {
+                return { exitCode: 1, message: `OMP user deployment failed: ${error instanceof Error ? error.message : String(error)}` };
+            }
+        }
+        if (scope === 'user' && provider !== 'openhuman' && provider !== 'omp' && !dryRun) {
             try {
                 const paths = getProviderPaths(provider);
                 const resolveProjectPath = (p) => !p ? '' : path.isAbsolute(p) ? p : path.join(target, p);

package/dist/src/cli/scope-resolver.js

@@ -9,6 +9,7 @@
  * Per ADR-4 §2 path map. Per ADR-4 §1: `--scope user` and `--scope
  * project` are mutually exclusive; default is `project`.
  */
+import { resolveOmpPaths } from '../providers/omp-paths.mjs';
 import { homedir } from 'node:os';
 import * as path from 'node:path';
 import { resolveHermesHome, resolveHermesHomePath } from '../providers/hermes-home.js';
@@ -57,6 +58,12 @@ export const USER_SCOPE_PATHS = {
         rules: '',
         behaviors: '',
     },
+    get omp() {
+        const { agentDir } = resolveOmpPaths();
+        return { agents: path.join(agentDir, 'agents'), skills: path.join(agentDir, 'skills'),
+            commands: path.join(agentDir, 'prompts'), rules: path.join(agentDir, 'rules'),
+            behaviors: path.join(agentDir, 'extensions') };
+    },
     pi: {
         // Pi's global resource root is configurable. Unlike project deployment,
         // user-scope resources belong under the effective agent directory. Keep