@aiwg/cli 2026.9.1 → 2026.9.3

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', '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 11 providers');
+            throw new Error('Provider model capability registry must cover all registered providers');
         }
     }
     return registryCache;
@@ -153,12 +153,15 @@ 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' };
         default: return {};

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:
@@ -489,7 +534,7 @@ providers:
       agent_teams: false
       tasks: false
       mcp: false
-      behaviors: false
+      behaviors: true
       mission_control: false
       daemon: false
     emulation:
@@ -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') };
+}

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