@aiwg/cli 2026.9.2 → 2026.9.3

package/dist/src/providers/provider-definitions.js

@@ -12,6 +12,7 @@ const ArtifactPathsSchema = z.object({
 });
 const ProviderDefinitionSchema = z.object({
     id: z.enum([
+        'antigravity',
         'claude',
         'codex',
         'copilot',
@@ -22,6 +23,7 @@ const ProviderDefinitionSchema = z.object({
         'openclaw',
         'openhuman',
         'pi',
+        'omp',
         'warp',
         'windsurf',
         'generic',
@@ -123,6 +125,7 @@ const ProviderDefinitionSchema = z.object({
     }),
 });
 export const PROVIDER_IDS = [
+    'antigravity',
     'claude',
     'codex',
     'copilot',
@@ -133,12 +136,24 @@ export const PROVIDER_IDS = [
     'openclaw',
     'openhuman',
     'pi',
+    'omp',
     'warp',
     'windsurf',
     'generic',
 ];
 const VERIFIED_ON = '2026-07-21';
 const CONTEXT_CONTRACTS = {
+    antigravity: {
+        startupFiles: ['AGENTS.md', 'GEMINI.md'],
+        precedence: ['provider/system', 'project AGENTS.md or GEMINI.md', 'nested project context when selected by the CLI'],
+        loadMode: 'prose-directive', includeSyntax: null, configRegistration: null,
+        bootstrapTargets: ['AGENTS.md'], maxContextBytes: null, recommendedMaxLines: null, nestedContext: true, support: 'supported',
+        verification: {
+            method: 'official Antigravity CLI documentation and sanitized 1.1.26 help evidence',
+            source: 'https://antigravity.google/docs/cli/overview/',
+            lastVerified: '2026-09-04',
+        },
+    },
     claude: {
         startupFiles: ['CLAUDE.md', '.claude/CLAUDE.md'], precedence: ['provider/system', 'nested CLAUDE.md', 'root CLAUDE.md'],
         loadMode: 'native-include', includeSyntax: '@WORKSPACE.md\n@AIWG.md', configRegistration: null,
@@ -193,6 +208,17 @@ const CONTEXT_CONTRACTS = {
         bootstrapTargets: ['AGENTS.md'], maxContextBytes: null, recommendedMaxLines: null, nestedContext: false, support: 'degraded',
         verification: { method: 'AIWG mixed-scope adapter contract; host loading remains capability-dependent', source: 'agentic/code/providers/capability-matrix.yaml', lastVerified: VERIFIED_ON },
     },
+    omp: {
+        startupFiles: ['.omp/AGENTS.md', 'AGENTS.md'],
+        precedence: ['provider/system', 'native nearest nonempty .omp', 'compatibility context ordered by depth; exact paragraph deduplication'],
+        loadMode: 'native-include', includeSyntax: '@<relative-path>', configRegistration: null,
+        bootstrapTargets: ['.omp/AGENTS.md'], maxContextBytes: null, recommendedMaxLines: null, nestedContext: true, support: 'supported',
+        verification: {
+            method: 'OMP 18.1.10 source and live context import smoke',
+            source: 'https://github.com/can1357/oh-my-pi/blob/5964a0f7649275bcde818f20073193fd032451f2/packages/coding-agent/src/system-prompt.ts#L451',
+            lastVerified: '2026-09-04',
+        },
+    },
     pi: {
         startupFiles: ['AGENTS.override.md', 'AGENTS.md', 'CLAUDE.md'],
         precedence: ['provider/system', 'root-to-cwd context chain', 'AGENTS.override.md supersedes same-directory AGENTS.md and CLAUDE.md'],
@@ -223,6 +249,42 @@ const CONTEXT_CONTRACTS = {
     },
 };
 const BUILT_IN_SEEDS = [
+    {
+        id: 'antigravity',
+        displayName: 'Google Antigravity CLI',
+        aliases: ['agy'],
+        status: 'experimental',
+        builtIn: true,
+        surfaces: {
+            primary: 'antigravity',
+            compatibility: ['agy'],
+            precedence: ['AGENTS.md', 'GEMINI.md', '.agents/agents/', '.agents/skills/'],
+            related: [],
+        },
+        detection: { env: [], process: ['agy'], capabilityId: 'antigravity' },
+        paths: {
+            deployTarget: 'project',
+            artifacts: {
+                agents: '.agents/agents', commands: null, skills: '.agents/.aiwg/skills', rules: null, behaviors: null,
+            },
+            kernelSkills: '.agents/skills',
+            contextDiscovery: { agents: '.agents/agents', skills: '.agents/skills', rules: null, behaviors: null },
+            configFile: 'AGENTS.md',
+            contextFiles: { aiwgMd: true, agentsMd: true, claudeMdHook: false, hookFile: null, contextFile: 'AGENTS.md' },
+        },
+        smithPaths: {
+            agents: '.agents/agents', commands: null, skills: '.agents/skills', rules: null,
+            fileExtension: '.md', configFile: 'AGENTS.md', aggregated: false,
+        },
+        skillNamespace: {
+            deploymentGroup: 'deep-recursion', pathType: 'project', skillsBaseDir: '.agents/skills', subdirLayout: true,
+        },
+        adapters: {
+            agentFormat: 'antigravity-markdown', hookBridge: null, mcpInjection: 'antigravity',
+            contextAggregation: 'agents-md', ruleFormat: null,
+        },
+        matrixRef: 'antigravity',
+    },
     {
         id: 'claude',
         displayName: 'Claude Code',
@@ -669,6 +731,27 @@ const BUILT_IN_SEEDS = [
         },
         matrixRef: 'openhuman',
     },
+    {
+        id: 'omp',
+        aliases: ['oh-my-pi'],
+        builtIn: true,
+        surfaces: {
+            primary: 'omp', compatibility: ['oh-my-pi'],
+            precedence: ['.omp/AGENTS.md', 'AGENTS.md', '.agents/skills/', '.omp/skills/', '.omp/prompts/'], related: [],
+        },
+        detection: { env: [], process: ['omp', '@oh-my-pi/pi-coding-agent'], capabilityId: 'omp' },
+        paths: {
+            artifacts: { agents: '.omp/agents', commands: '.omp/prompts', skills: '.agents/skills', rules: '.omp/rules', behaviors: '.omp/extensions' },
+            kernelSkills: '.agents/skills',
+            contextDiscovery: { agents: '.omp/agents', skills: '.agents/skills', rules: '.omp/rules', behaviors: '.omp/extensions' },
+            configFile: '.omp/AGENTS.md',
+            contextFiles: { aiwgMd: true, agentsMd: false, claudeMdHook: false, hookFile: '.omp/AGENTS.md', contextFile: '.omp/AGENTS.md' },
+        },
+        smithPaths: { agents: '.omp/agents', commands: '.omp/prompts', skills: '.agents/skills', rules: '.omp/rules', fileExtension: '.md', configFile: '.omp/AGENTS.md', aggregated: false },
+        skillNamespace: { deploymentGroup: 'one-level', pathType: 'project', skillsBaseDir: '.omp/skills', subdirLayout: false },
+        adapters: { agentFormat: 'omp-markdown', hookBridge: 'omp', mcpInjection: 'omp', contextAggregation: 'agents-md', ruleFormat: 'omp-markdown' },
+        matrixRef: 'omp',
+    },
     {
         id: 'pi',
         aliases: ['pi-coding-agent'],

package/dist/src/providers/provider-definitions.mjs

@@ -1,7 +1,24 @@
+import { resolveOmpPaths } from './omp-paths.mjs';
 import { homedir } from 'os';
 import { resolve } from 'path';
 
 const MCP_INJECTION_DEFINITIONS = [
+  {
+    id: 'antigravity', aliases: ['agy'],
+    mcp: { providerId: 'antigravity', includeInSupportedProviders: true, configFormat: 'json',
+      serverConfigFormat: 'antigravity', serversKey: 'mcpServers',
+      configPath: { scope: 'project', path: '.agents/mcp_config.json' },
+      supportsEphemeral: false,
+      unsupportedReason: 'Antigravity uses project or user persistent MCP configuration; temporary injection is not qualified.' },
+  },
+  {
+    id: 'omp', aliases: ['oh-my-pi'],
+    mcp: { providerId: 'omp', includeInSupportedProviders: true, configFormat: 'json',
+      serverConfigFormat: 'standard', serversKey: 'mcpServers',
+      configPath: { scope: 'project', path: '.omp/mcp.json' },
+      supportsEphemeral: false,
+      unsupportedReason: 'OMP uses owned persistent MCP configuration; temporary injection is not supported.' },
+  },
   {
     id: 'claude',
     aliases: ['claude-code'],
@@ -147,7 +164,14 @@ export function listMcpInjectProviderIds() {
     .map((definition) => definition.providerId);
 }
 
-export function resolveMcpConfigPath(provider, projectDir = '.') {
+export function resolveMcpConfigPath(provider, projectDir = '.', options = {}) {
+  if (normalizeRuntimeProviderId(provider) === 'antigravity' && options.scope === 'user') {
+    const home = process.env.HOME || process.env.USERPROFILE || homedir();
+    return resolve(home, '.gemini/config/mcp_config.json');
+  }
+  if (normalizeRuntimeProviderId(provider) === 'omp' && options.scope === 'user') {
+    return resolve(resolveOmpPaths(options).agentDir, 'mcp.json');
+  }
   const definition = getMcpInjectionDefinition(provider);
   if (!definition) return '';
 

package/dist/src/providers/provider-inventory.js

@@ -5,6 +5,7 @@ import { readAiwgConfig } from '../config/aiwg-config.js';
 import { resolveActiveProvider } from '../cli/provider-resolution.js';
 import { listProviderDefinitions, normalizeProviderDefinitionId, resolveProviderPathValue, } from './provider-definitions.js';
 const PROVIDER_EXECUTABLES = {
+    antigravity: ['agy'],
     claude: ['claude'],
     codex: ['codex'],
     copilot: ['github-copilot-cli', 'copilot'],
@@ -15,6 +16,7 @@ const PROVIDER_EXECUTABLES = {
     openclaw: ['openclaw'],
     openhuman: ['openhuman'],
     pi: ['pi'],
+    omp: ['omp'],
     warp: ['warp'],
     windsurf: ['windsurf'],
 };

package/dist/src/sessions/adapters/omp.js

@@ -0,0 +1,203 @@
+import { opendir } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { z } from 'zod';
+import { SessionContractError, } from '../contracts.js';
+import { readBoundedJsonLines, streamBoundedJsonLines } from '../readers.js';
+export const OMP_ADAPTER_VERSION = '1.0.0';
+export const OMP_SOURCE_SCHEMA_VERSION = '3.0.0';
+const Title = z.object({ type: z.literal('title'), v: z.literal(1), title: z.string(), source: z.enum(['auto', 'user']).optional(), updatedAt: z.string(), pad: z.string() });
+const Header = z.object({ type: z.literal('session'), version: z.number().int(), id: z.string().min(1),
+    timestamp: z.string().datetime({ offset: true }), cwd: z.string(), parentSession: z.string().optional() }).passthrough();
+const Entry = z.object({ type: z.string().min(1), id: z.string().min(1),
+    parentId: z.string().nullable(), timestamp: z.string().datetime({ offset: true }) }).passthrough();
+export class OmpSessionAdapter {
+    limits;
+    maxFiles;
+    provider = 'omp';
+    sourceSchemaMajor = 3;
+    adapterVersion = OMP_ADAPTER_VERSION;
+    disposition = 'implemented';
+    supportedOperations = ['discover', 'inspect', 'stream'];
+    acquisitionModes = ['jsonl'];
+    constructor(limits, maxFiles = 10_000) {
+        this.limits = limits;
+        this.maxFiles = maxFiles;
+    }
+    async *discover(scope) {
+        if (!scope.allowedRoots.length)
+            throw new SessionContractError('SOURCE_NOT_AUTHORIZED', 'OMP discovery requires an authorized sessions root');
+        let count = 0;
+        for (const root of [...scope.allowedRoots].sort()) {
+            for await (const locator of jsonlFiles(resolve(root))) {
+                if (++count > this.maxFiles)
+                    throw new SessionContractError('RESOURCE_LIMIT_EXCEEDED', 'OMP discovery file limit exceeded');
+                yield { provider: 'omp', locator, locatorClass: 'omp-session-v3-jsonl' };
+            }
+        }
+    }
+    async inspect(source) {
+        let input;
+        try {
+            input = await readBoundedJsonLines({ selectedPath: source.locator,
+                allowedRoots: source.authorizedScope.allowedRoots }, { consistency: 'provisional', limits: this.limits });
+        }
+        catch (error) {
+            throw normalizeAuthorizationError(error);
+        }
+        const header = parseHeader(input.records[titleOffset(input.records[0]) ? 1 : 0]?.value);
+        if (input.incompleteTail)
+            throw new SessionContractError('TRUNCATED_SOURCE', 'OMP session has a truncated JSONL tail');
+        return { sourceSchemaVersion: `${header.version}.0.0`, consistency: 'complete', operationalState: 'available' };
+    }
+    async *stream(source, cursor) {
+        let input;
+        try {
+            input = await streamBoundedJsonLines({ selectedPath: source.locator,
+                allowedRoots: source.authorizedScope.allowedRoots }, { consistency: 'provisional', limits: this.limits });
+        }
+        catch (error) {
+            throw normalizeAuthorizationError(error);
+        }
+        let sessionId = '';
+        let header = {};
+        let prefix = true;
+        const start = cursor?.value.replace(/^byte:/, '') ?? '0';
+        if (!/^\d+$/.test(start))
+            throw new SessionContractError('SCHEMA_DRIFT', 'invalid OMP cursor');
+        let end = 0;
+        const ids = new Set();
+        for await (const line of input) {
+            end = line.byteOffset + line.byteLength;
+            if (Number(start) > line.byteOffset && Number(start) < end) {
+                throw new SessionContractError('SCHEMA_DRIFT', 'OMP cursor is not a record boundary');
+            }
+            if (prefix) {
+                prefix = false;
+                if (titleOffset(line))
+                    continue;
+            }
+            if (!sessionId) {
+                header = parseHeader(line.value);
+                sessionId = String(header.id);
+                continue;
+            }
+            const parsed = Entry.safeParse(line.value);
+            if (!parsed.success)
+                throw new SessionContractError('MALFORMED_SOURCE', 'OMP session entry is malformed');
+            const entry = parsed.data;
+            if (ids.has(entry.id))
+                throw new SessionContractError('DUPLICATE_NATIVE_ID', 'OMP session contains a duplicate entry id');
+            ids.add(entry.id);
+            if (end <= Number(start))
+                continue;
+            const message = object(entry.message);
+            const role = string(message.role) ?? roleFor(entry.type);
+            const sensitive = role === 'toolResult' || ['custom', 'custom_message', 'session_init', 'credential_pin'].includes(entry.type) || !KNOWN.has(entry.type);
+            const text = sensitive ? '[redacted provider content]' : entryText(entry, message);
+            yield { nativeSessionId: sessionId, nativeEventId: entry.id, sequence: line.sequence,
+                kind: kindFor(entry.type, role), role, toolName: sensitive ? string(message.toolName) : undefined,
+                toolCallId: sensitive ? string(message.toolCallId) : undefined,
+                occurredAt: entry.timestamp, text, model: string(entry.model) ?? string(message.model), sourceCursor: `byte:${end}`,
+                sourceBytes: line.byteLength, rawReference: { locatorClass: 'omp-session-v3-jsonl', offset: line.byteOffset },
+                activityBoundary: entry.type === 'compaction' ? 'continuation' : undefined,
+                activityBoundaryBasis: entry.type === 'compaction' ? 'pi-session:compaction' : undefined,
+                activityBoundaryConfidence: entry.type === 'compaction' ? 'high' : undefined,
+                extensions: { provenance: { acquisition: 'omp-session-v3', parentId: entry.parentId, parentSession: header.parentSession, previousSessionFiles: header.previousSessionFiles, cwd: header.cwd, additionalDirectories: header.additionalDirectories },
+                    opaque: !KNOWN.has(entry.type), redacted: sensitive,
+                    nativeType: entry.type, parentId: entry.parentId, ...metadata(entry, message) } };
+        }
+        if (!sessionId)
+            throw new SessionContractError('MALFORMED_SOURCE', 'OMP session header is missing');
+        if (Number(start) > end)
+            throw new SessionContractError('SCHEMA_DRIFT', 'OMP cursor exceeds source size');
+        if (input.incompleteTail)
+            throw new SessionContractError('TRUNCATED_SOURCE', 'OMP session has a truncated JSONL tail');
+    }
+    async mutablePrefixBytes(source) {
+        const input = await streamBoundedJsonLines({ selectedPath: source.locator, allowedRoots: source.authorizedScope.allowedRoots }, { consistency: 'provisional', limits: this.limits });
+        for await (const line of input)
+            return titleOffset(line);
+        return 0;
+    }
+}
+const KNOWN = new Set(['message', 'thinking_level_change', 'model_change', 'compaction',
+    'branch_summary', 'custom', 'label', 'session_info', 'custom_message', 'model_usage', 'title_change', 'service_tier_change', 'reset_boundary', 'ttsr_injection', 'credential_pin', 'session_init', 'mode_change']);
+function parseHeader(value) {
+    const parsed = Header.safeParse(value);
+    if (!parsed.success)
+        throw new SessionContractError('MALFORMED_SOURCE', 'OMP session header is malformed');
+    if (parsed.data.version !== 3)
+        throw new SessionContractError('UNKNOWN_SCHEMA_MAJOR', `unsupported OMP session version: ${parsed.data.version}`);
+    return parsed.data;
+}
+function object(value) { return value && typeof value === 'object' ? value : {}; }
+function string(value) { return typeof value === 'string' && value ? value : undefined; }
+function roleFor(type) { return type === 'compaction' || type === 'branch_summary' ? 'system' : undefined; }
+function kindFor(type, role) { return type === 'message' ? `message.${role ?? 'unknown'}` : `omp.${type}`; }
+function entryText(entry, message) {
+    const value = entry.type === 'message' ? message.content : entry.summary ?? entry.title ?? entry.name ?? entry.label ?? '';
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value))
+        return value.flatMap(part => typeof part === 'string' ? part : string(object(part).text) ?? []).join('\n');
+    return '';
+}
+async function* jsonlFiles(root) {
+    let directory;
+    try {
+        directory = await opendir(root);
+    }
+    catch {
+        return;
+    }
+    for await (const entry of directory) {
+        const path = resolve(root, entry.name);
+        if (entry.isDirectory())
+            yield* jsonlFiles(path);
+        else if (entry.isFile() && entry.name.endsWith('.jsonl'))
+            yield path;
+    }
+}
+function normalizeAuthorizationError(error) {
+    if (error instanceof SessionContractError && (error.code === 'SOURCE_OUTSIDE_ALLOWED_ROOT'
+        || error.code === 'SOURCE_SYMLINK' || error.code === 'SOURCE_NOT_REGULAR_FILE')) {
+        return new SessionContractError('SOURCE_NOT_AUTHORIZED', 'OMP source is not an authorized regular file');
+    }
+    return error;
+}
+function titleOffset(line) {
+    if (object(line?.value).type !== 'title')
+        return 0;
+    if (!Title.safeParse(line?.value).success || line?.byteLength !== 256) {
+        throw new SessionContractError('MALFORMED_SOURCE', 'OMP title slot is malformed');
+    }
+    return 256;
+}
+function metadata(entry, message) {
+    const result = {};
+    for (const key of ['fromId', 'firstKeptEntryId', 'providerReplayThroughEntryId', 'tokensBefore', 'tokensAfter', 'method', 'role', 'resolvedModelIsFallback', 'purpose', 'provider', 'api', 'stopReason']) {
+        if (['string', 'number', 'boolean'].includes(typeof entry[key]))
+            result[key] = entry[key];
+    }
+    const usage = object(entry.usage ?? message.usage);
+    const numbers = Object.fromEntries(Object.entries(usage).filter(([, v]) => typeof v === 'number' && Number.isFinite(v)));
+    const cost = Object.fromEntries(Object.entries(object(usage.cost)).filter(([, v]) => typeof v === 'number' && Number.isFinite(v)));
+    if (Object.keys(numbers).length || Object.keys(cost).length)
+        result.usage = { ...numbers, cost };
+    return result;
+}
+/** Read only the bounded native preamble; never infer OMP from version alone. */
+export async function readOmpSessionHeader(source) {
+    const input = await streamBoundedJsonLines({ selectedPath: source.locator, allowedRoots: source.authorizedScope.allowedRoots }, { consistency: 'provisional', limits: { maxRecords: 2, maxRecordBytes: 1024 * 1024 } });
+    let first = true;
+    for await (const line of input) {
+        if (first) {
+            first = false;
+            if (titleOffset(line))
+                continue;
+        }
+        return parseHeader(line.value);
+    }
+    throw new SessionContractError('MALFORMED_SOURCE', 'OMP header is missing');
+}
+//# sourceMappingURL=omp.js.map

package/dist/src/sessions/batch-import.js

@@ -1,3 +1,4 @@
+import { OmpSessionAdapter, OMP_ADAPTER_VERSION } from './adapters/omp.js';
 import { stat } from 'node:fs/promises';
 import { CLAUDE_ADAPTER_VERSION, ClaudeSessionAdapter, } from './adapters/claude.js';
 import { CODEX_ADAPTER_VERSION, CodexSessionAdapter, } from './adapters/codex.js';
@@ -197,6 +198,8 @@ async function assertManifestSourceUnchanged(source) {
     }
 }
 function adapterFor(provider) {
+    if (provider === 'omp')
+        return new OmpSessionAdapter();
     if (provider === 'claude')
         return new ClaudeSessionAdapter();
     if (provider === 'codex')
@@ -226,6 +229,8 @@ async function sessionSource(selected, adapter) {
     });
 }
 function adapterVersion(provider) {
+    if (provider === 'omp')
+        return OMP_ADAPTER_VERSION;
     if (provider === 'claude')
         return CLAUDE_ADAPTER_VERSION;
     if (provider === 'codex')
@@ -237,6 +242,8 @@ function adapterVersion(provider) {
     return '1.0.0';
 }
 function providerProfile(provider, locatorClass) {
+    if (provider === 'omp')
+        return 'native-title-slot-v3';
     if (provider === 'claude')
         return 'documented-local-jsonl';
     if (provider === 'codex')

package/dist/src/sessions/contracts.js

@@ -3,7 +3,7 @@ import { z } from 'zod';
 export const SESSION_CONTRACT_VERSION = '1.0.0';
 export const SESSION_PROVIDER_IDS = [
     'claude', 'codex', 'copilot', 'cursor', 'factory', 'hermes',
-    'opencode', 'openclaw', 'openhuman', 'pi', 'warp', 'devin-desktop', 'generic',
+    'opencode', 'openclaw', 'openhuman', 'pi', 'omp', 'warp', 'devin-desktop', 'generic',
 ];
 export const SessionProviderIdSchema = z.enum(SESSION_PROVIDER_IDS);
 export const SESSION_PROVIDER_ALIASES = Object.freeze({

package/dist/src/sessions/importer.js

@@ -22,7 +22,7 @@ export class IncrementalSessionImporter {
         this.repository = repository;
     }
     async import(request) {
-        assertSupportedSchemaMajor(request.source.sourceSchemaVersion);
+        assertSupportedSchemaMajor(request.source.sourceSchemaVersion, request.adapter.sourceSchemaMajor ?? 1);
         if (request.inactivityThresholdMs !== undefined
             && (!Number.isFinite(request.inactivityThresholdMs) || request.inactivityThresholdMs < 0)) {
             throw new SessionContractError('INVALID_ARGUMENT', 'session inactivity threshold must be a non-negative duration');
@@ -435,6 +435,7 @@ async function sourceContinuity(request, previous) {
         selectedPath: request.selectedSource.locator,
         allowedRoots: request.selectedSource.authorizedScope.allowedRoots,
     };
+    const skipPrefixBytes = await request.adapter.mutablePrefixBytes?.(request.selectedSource) ?? 0;
     const metadata = await fingerprintSourcePrefix(authorization, 0);
     if (previous?.sourceSize !== undefined) {
         if (metadata.size < previous.sourceSize) {
@@ -444,12 +445,12 @@ async function sourceContinuity(request, previous) {
             && previous.sourceFileIdentity !== metadata.fileIdentity) {
             throw new SessionContractError('SCHEMA_DRIFT', 'session source file generation was replaced or rotated');
         }
-        const priorPrefix = await fingerprintSourcePrefix(authorization, previous.sourceSize);
+        const priorPrefix = await fingerprintSourcePrefix(authorization, previous.sourceSize, skipPrefixBytes);
         if (previous.prefixDigest && priorPrefix.digest !== previous.prefixDigest) {
             throw new SessionContractError('SCHEMA_DRIFT', 'session source prefix was rewritten before its durable checkpoint');
         }
     }
-    const current = await fingerprintSourcePrefix(authorization, metadata.size);
+    const current = await fingerprintSourcePrefix(authorization, metadata.size, skipPrefixBytes);
     const generation = previous?.sourceGeneration ?? sha256([
         sourceGenerationDigest(request),
         metadata.fileIdentity,

package/dist/src/sessions/index.js

@@ -31,4 +31,5 @@ export * from './adapters/openhuman.js';
 export * from './adapters/pi.js';
 export * from './adapters/warp.js';
 export * from './adapters/windsurf.js';
+export * from './adapters/omp.js';
 //# sourceMappingURL=index.js.map

package/dist/src/sessions/readers.js

@@ -132,16 +132,17 @@ export async function fingerprintSourceFile(authorization) {
     }
     return { digest: `sha256:${hash.digest('hex')}`, size: allowed.size };
 }
-export async function fingerprintSourcePrefix(authorization, length) {
+export async function fingerprintSourcePrefix(authorization, length, skipPrefixBytes = 0) {
     const allowed = await authorizeSourceFile(authorization);
-    if (!Number.isSafeInteger(length) || length < 0 || length > allowed.size) {
+    if (!Number.isSafeInteger(length) || length < 0 || length > allowed.size
+        || !Number.isSafeInteger(skipPrefixBytes) || skipPrefixBytes < 0 || skipPrefixBytes > allowed.size) {
         throw new SessionContractError('SCHEMA_DRIFT', 'checkpoint source position is beyond the current source size');
     }
     const handle = await open(allowed.canonicalPath, 'r');
     const hash = createHash('sha256');
     try {
         const buffer = Buffer.allocUnsafe(64 * 1024);
-        let position = 0;
+        let position = skipPrefixBytes;
         while (position < length) {
             const result = await handle.read(buffer, 0, Math.min(buffer.length, length - position), position);
             if (result.bytesRead === 0)

package/dist/src/sessions/workspace-discovery.js

@@ -7,6 +7,8 @@ import { ClaudeSessionAdapter } from './adapters/claude.js';
 import { CodexSessionAdapter } from './adapters/codex.js';
 import { CursorSessionAdapter } from './adapters/cursor.js';
 import { FactorySessionAdapter } from './adapters/factory.js';
+import { OmpSessionAdapter, readOmpSessionHeader } from './adapters/omp.js';
+import { resolveOmpPaths } from '../providers/omp-paths.mjs';
 import { PiSessionAdapter } from './adapters/pi.js';
 import { SESSION_PROVIDER_IDS, sha256, } from './contracts.js';
 import { redactSourceLocator } from './discovery.js';
@@ -23,6 +25,9 @@ export async function discoverWorkspaceHistories(options) {
     const keyWithLeadingDash = workspaceKey(workspacePath, true);
     const keyWithoutLeadingDash = workspaceKey(workspacePath, false);
     const discoverable = [
+        { provider: 'omp', adapter: new OmpSessionAdapter(), roots: options.ompRoot
+                ? [resolve(options.ompRoot)] : options.providerHome
+                ? [resolveOmpPaths({ home: resolve(options.providerHome), cwd: workspacePath }).sessionsDir] : [] },
         {
             provider: 'claude',
             adapter: new ClaudeSessionAdapter(),
@@ -70,12 +75,12 @@ export async function discoverWorkspaceHistories(options) {
                 availableRoots.push(await canonicalPath(root));
         }
         if (availableRoots.length === 0) {
-            const codexNeedsAuthorization = entry.provider === 'codex'
+            const codexNeedsAuthorization = (entry.provider === 'codex' || entry.provider === 'omp')
                 && entry.roots.length === 0;
             reports.set(entry.provider, providerReport(entry.provider, codexNeedsAuthorization ? 'export-required' : 'unavailable', codexNeedsAuthorization ? 'manual-export' : 'discoverable', [], codexNeedsAuthorization
                 ? 'SHARED_ROOT_AUTHORIZATION_REQUIRED'
                 : 'PROVIDER_ROOT_UNAVAILABLE', codexNeedsAuthorization
-                ? 'Pass --codex-root with an explicitly authorized Codex sessions or App Server export root.'
+                ? `Pass --${entry.provider}-root with an explicitly authorized sessions root.`
                 : `No authorized ${entry.provider} workspace history root was found.`));
             continue;
         }
@@ -89,6 +94,9 @@ export async function discoverWorkspaceHistories(options) {
             if (entry.provider === 'codex'
                 && !await codexSourceMatchesWorkspace(locator, workspacePath))
                 continue;
+            const ompHeader = entry.provider === 'omp' ? await readOmpSessionHeader({ ...descriptor, sourceId: 'discovery', authorizedScope: scope }) : undefined;
+            if (ompHeader && resolve(ompHeader.cwd) !== workspacePath)
+                continue;
             const details = await stat(locator);
             const authorizedRoot = scope.allowedRoots.find((root) => locator === root || locator.startsWith(`${root}/`));
             if (!authorizedRoot)
@@ -102,6 +110,8 @@ export async function discoverWorkspaceHistories(options) {
                 continue;
             seen.add(dedupeKey);
             const source = sourceFromDescriptor(descriptor, locator, authorizedRoot, details, fingerprint.digest);
+            if (ompHeader)
+                source.sourceId = sha256(['omp-native-source-v1', workspaceId, ompHeader.id].join('\0'));
             providerSources.push(source);
             candidates.push(source);
         }

package/dist/src/skills/deployer.js

@@ -289,6 +289,16 @@ function readDeploymentSidecar(targetPath, expectedName, expectedProvider) {
         return undefined;
     }
 }
+/**
+ * Codex and Antigravity intentionally consume the same portable project skill
+ * surface. A projection written for either provider is managed ownership for
+ * the other when the desired payload is otherwise byte-identical.
+ */
+function providersShareProjectionSurface(actual, expected) {
+    return actual === expected
+        || (actual === 'codex' && expected === 'antigravity')
+        || (actual === 'antigravity' && expected === 'codex');
+}
 function buildProjectionPlan(record, options) {
     const policy = resolvePolicy(options.target, options);
     const targetPath = path.join(policy.root, record.name);
@@ -339,12 +349,15 @@ function isManagedTarget(targetPath, expectedName, expectedProvider) {
     try {
         const targetStat = fs.lstatSync(targetPath);
         const marker = path.join(targetPath, AGENT_SKILL_MANAGED_MARKER);
+        const sidecar = readDeploymentSidecar(targetPath, expectedName);
         return (targetStat.isDirectory()
             && !targetStat.isSymbolicLink()
             && fs.lstatSync(marker).isFile()
             && !fs.lstatSync(marker).isSymbolicLink()
             && fs.readFileSync(marker, 'utf8') === MARKER_CONTENT
-            && readDeploymentSidecar(targetPath, expectedName, expectedProvider) !== undefined);
+            && sidecar !== undefined
+            && (expectedProvider === undefined
+                || providersShareProjectionSurface(sidecar.provider, expectedProvider)));
     }
     catch {
         return false;
@@ -381,6 +394,13 @@ function targetMatches(targetPath, desired, name, provider) {
     if (actual.size !== desired.length)
         return false;
     return desired.every((entry) => {
+        if (entry.kind === 'file'
+            && entry.relativePath === AGENT_SKILL_DEPLOYMENT_SIDECAR) {
+            const sidecar = readDeploymentSidecar(targetPath, name);
+            return sidecar !== undefined
+                && providersShareProjectionSurface(sidecar.provider, provider)
+                && sidecar.sourceDigest === JSON.parse(entry.bytes.toString('utf8')).sourceDigest;
+        }
         const value = actual.get(entry.relativePath);
         return entry.kind === 'directory'
             ? value === 'directory'

package/dist/src/smiths/agentsmith/generator.js

@@ -423,6 +423,7 @@ export class AgentGenerator {
                 model,
                 modelRole: modelPolicy.role,
                 modelTier: modelPolicy.tier,
+                ...(platform === 'omp' && effort ? { thinkingLevel: effort } : {}),
                 tools,
                 category: category,
                 version,

package/dist/src/smiths/context-pipeline/parallelism-section.js

@@ -18,6 +18,8 @@ export const PARALLELISM_BLOCK_START = '<!-- AIWG-PARALLELISM-CAP:START -->';
 export const PARALLELISM_BLOCK_END = '<!-- AIWG-PARALLELISM-CAP:END -->';
 function delegationSupport(provider) {
     switch (provider) {
+        case 'antigravity':
+            return '**Provider behavior (antigravity)**: AIWG team execution uses aiwg-mc emulation. The conservative cap is four workers; native Antigravity subagent limits and heterogeneous model pinning remain unqualified.';
         case 'claude':
         case 'codex':
         case 'copilot':

package/dist/src/smiths/context-pipeline/provider-policy.js

@@ -46,8 +46,8 @@ export function shouldEmitAiwgMd(provider) {
 }
 /**
  * Whether to emit AGENTS.md at project root. True for the AGENTS-MD
- * provider set (codex, copilot, cursor, windsurf, hermes, warp, factory,
- * opencode). False for claude (uses CLAUDE.md hook instead), openclaw,
+ * provider set (antigravity, codex, copilot, cursor, windsurf, hermes, warp,
+ * factory, opencode). False for claude (uses CLAUDE.md hook instead), openclaw,
  * and generic.
  */
 export function shouldEmitAgentsMd(provider) {

package/dist/src/smiths/context-pipeline/workspace-context.js

@@ -430,8 +430,8 @@ export function buildProviderBootstrapBlock(provider) {
         ? [
             'Load the canonical project context first, then the generated AIWG framework context:',
             '',
-            '@WORKSPACE.md',
-            '@AIWG.md',
+            provider === 'omp' ? '@../WORKSPACE.md' : '@WORKSPACE.md',
+            provider === 'omp' ? '@../AIWG.md' : '@AIWG.md',
         ]
         : contract.loadMode === 'config-registration'
             ? [