@aiwg/cli 2026.9.2 → 2026.9.3

package/dist/src/config/aiwg-config.js

@@ -89,6 +89,7 @@ export function resolveDelivery(delivery) {
  *   - unknown: conservative 4 default.
  */
 export const PROVIDER_PARALLELISM_DEFAULTS = {
+    antigravity: { max_parallel_subagents: 4, max_parallel_ralph_loops: 2, max_parallel_mc_missions: 4 },
     claude: { max_parallel_subagents: 4, max_parallel_ralph_loops: 2, max_parallel_mc_missions: 4 },
     codex: { max_parallel_subagents: 10, max_parallel_ralph_loops: 3, max_parallel_mc_missions: 6 },
     copilot: { max_parallel_subagents: 10, max_parallel_ralph_loops: 3, max_parallel_mc_missions: 6 },

package/dist/src/dataset/fortemi-live-qualification.d.ts

@@ -0,0 +1,53 @@
+import type { McpClientLike } from "../storage/backends/fortemi.js";
+export declare const FORTEMI_DATASET_LIVE_CONTRACT: "aiwg.fortemi-dataset-live-qualification/v1";
+export declare const FORTEMI_DATASET_CAPABILITIES_TOOL = "dataset_capabilities";
+export declare const FORTEMI_DATASET_EXECUTE_TOOL = "dataset_execute";
+export interface FortemiDatasetLiveReceipt {
+    contract: typeof FORTEMI_DATASET_LIVE_CONTRACT;
+    outcome: "pending" | "supported";
+    diagnostic: "CONFORMANCE_FORTEMI_DATASET_CONTRACT_UNAVAILABLE" | "CONFORMANCE_FORTEMI_DATASET_PREFLIGHT_SUPPORTED";
+    receiptDigest: string;
+    bindings: {
+        aiwgCommit: string;
+        endpointFingerprint: string;
+        toolSchemaDigest: string;
+    };
+    observed: {
+        serverName: string;
+        serverVersion: string;
+    };
+    namespace: string;
+    operations: Array<{
+        tool: string;
+        compatible: boolean;
+        code: string;
+    }>;
+    mutation: {
+        authorized: false;
+        attempted: false;
+    };
+    resources: {
+        maxDurationMs: number;
+        durationMs: number;
+        maxToolCount: number;
+        observedToolCount: number;
+        maxSchemaBytes: number;
+        observedSchemaBytes: number;
+        networkAttempts: number;
+        toolCalls: number;
+    };
+    startedAt: string;
+    endedAt: string;
+}
+/** Read-only discovery. It never invokes a Fortemi tool, even when the proposed contract is present. */
+export declare function qualifyFortemiDatasetLivePreflight(input: {
+    client: McpClientLike;
+    endpointUrl: string;
+    aiwgCommit: string;
+    maxDurationMs?: number;
+    now?: () => Date;
+}): Promise<FortemiDatasetLiveReceipt>;
+export declare function verifyFortemiDatasetLiveReceipt(value: unknown): string[];
+/** Atomically creates private evidence without replacing an existing receipt. */
+export declare function writeFortemiDatasetLiveReceipt(path: string, receipt: FortemiDatasetLiveReceipt): Promise<void>;
+//# sourceMappingURL=fortemi-live-qualification.d.ts.map

package/dist/src/dataset/fortemi-live-qualification.js

@@ -0,0 +1,297 @@
+import { randomUUID } from "node:crypto";
+import { link, mkdir, unlink, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { endpointFingerprint, fortemiReceiptDigest, } from "../storage/fortemi-qualification-receipt.js";
+export const FORTEMI_DATASET_LIVE_CONTRACT = "aiwg.fortemi-dataset-live-qualification/v1";
+export const FORTEMI_DATASET_CAPABILITIES_TOOL = "dataset_capabilities";
+export const FORTEMI_DATASET_EXECUTE_TOOL = "dataset_execute";
+const UUID_NAMESPACE = /^aiwg-dataset-qualification-[0-9a-f-]{36}$/u;
+const COMMIT = /^[0-9a-f]{40}$/u;
+const DIGEST = /^sha256:[0-9a-f]{64}$/u;
+const SAFE = /^[A-Za-z0-9._:/-]+$/u;
+const REQUIRED_TOOLS = [
+    FORTEMI_DATASET_CAPABILITIES_TOOL,
+    FORTEMI_DATASET_EXECUTE_TOOL,
+];
+const MAX_TOOL_COUNT = 256;
+const MAX_SCHEMA_BYTES = 1_048_576;
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function exactKeys(value, allowed) {
+    const keys = Object.keys(value);
+    return (keys.length === allowed.length && keys.every((key) => allowed.includes(key)));
+}
+function material(receipt) {
+    const { receiptDigest: _digest, ...rest } = receipt;
+    return rest;
+}
+function inputSchemaCompatible(schema, required) {
+    const candidate = record(schema);
+    const properties = record(candidate?.properties);
+    const declaredRequired = candidate?.required;
+    if (candidate?.type !== "object" ||
+        !properties ||
+        !Array.isArray(declaredRequired))
+        return false;
+    if (!declaredRequired.every((key) => typeof key === "string") ||
+        new Set(declaredRequired).size !== declaredRequired.length)
+        return false;
+    return Object.entries(required).every(([key, type]) => {
+        const property = record(properties[key]);
+        return declaredRequired.includes(key) && property?.type === type;
+    });
+}
+async function bounded(promise, timeoutMs) {
+    let timer;
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error("CONFORMANCE_FORTEMI_DATASET_PREFLIGHT_TIMEOUT")), timeoutMs);
+        }),
+    ]).finally(() => {
+        if (timer)
+            clearTimeout(timer);
+    });
+}
+/** Read-only discovery. It never invokes a Fortemi tool, even when the proposed contract is present. */
+export async function qualifyFortemiDatasetLivePreflight(input) {
+    if (!COMMIT.test(input.aiwgCommit))
+        throw new Error("CONFORMANCE_INVALID_AIWG_COMMIT");
+    const requestedDuration = input.maxDurationMs ?? 5_000;
+    if (!Number.isFinite(requestedDuration))
+        throw new Error("CONFORMANCE_INVALID_RESOURCE_BOUND");
+    const maxDurationMs = Math.max(250, Math.min(Math.trunc(requestedDuration), 30_000));
+    const now = input.now ?? (() => new Date());
+    const startedAt = now().toISOString();
+    const namespace = `aiwg-dataset-qualification-${randomUUID()}`;
+    let schemas = [];
+    try {
+        if (!input.client.listTools)
+            throw new Error("CONFORMANCE_FORTEMI_TOOL_DISCOVERY_UNAVAILABLE");
+        const discovered = await bounded(input.client.listTools(), maxDurationMs);
+        schemas = discovered.tools ?? [];
+        if (!Array.isArray(schemas))
+            throw new Error("CONFORMANCE_FORTEMI_TOOL_INVENTORY_INVALID");
+        const inventory = schemas;
+        const observedSchemaBytes = Buffer.byteLength(JSON.stringify(inventory), "utf8");
+        if (inventory.length > MAX_TOOL_COUNT ||
+            observedSchemaBytes > MAX_SCHEMA_BYTES)
+            throw new Error("CONFORMANCE_RESOURCE_ENVELOPE_EXCEEDED");
+        const tools = new Map(inventory.map((tool) => [tool.name, tool]));
+        const specifications = [
+            {
+                tool: FORTEMI_DATASET_CAPABILITIES_TOOL,
+                required: { contract_version: "string" },
+            },
+            {
+                tool: FORTEMI_DATASET_EXECUTE_TOOL,
+                required: {
+                    contract_version: "string",
+                    namespace: "string",
+                    plan: "object",
+                    records: "array",
+                },
+            },
+        ];
+        const checks = specifications.map(({ tool, required }) => {
+            const unique = inventory.filter((candidate) => candidate.name === tool).length === 1;
+            const compatible = unique && inputSchemaCompatible(tools.get(tool)?.inputSchema, required);
+            return {
+                tool,
+                compatible,
+                code: compatible
+                    ? "FORTEMI_DATASET_TOOL_SCHEMA_COMPATIBLE"
+                    : tools.has(tool)
+                        ? "FORTEMI_DATASET_TOOL_SCHEMA_DRIFT"
+                        : "FORTEMI_DATASET_TOOL_MISSING",
+            };
+        });
+        const supported = checks.every((check) => check.compatible);
+        const endedAt = now().toISOString();
+        const server = input.client.serverVersion?.() ?? {};
+        const safeObserved = (value) => value && SAFE.test(value) ? value : "unreported";
+        const base = {
+            contract: FORTEMI_DATASET_LIVE_CONTRACT,
+            outcome: supported ? "supported" : "pending",
+            diagnostic: supported
+                ? "CONFORMANCE_FORTEMI_DATASET_PREFLIGHT_SUPPORTED"
+                : "CONFORMANCE_FORTEMI_DATASET_CONTRACT_UNAVAILABLE",
+            bindings: {
+                aiwgCommit: input.aiwgCommit,
+                endpointFingerprint: endpointFingerprint(input.endpointUrl),
+                toolSchemaDigest: fortemiReceiptDigest(schemas),
+            },
+            observed: {
+                serverName: safeObserved(server.name),
+                serverVersion: safeObserved(server.version),
+            },
+            namespace,
+            operations: checks,
+            mutation: { authorized: false, attempted: false },
+            resources: {
+                maxDurationMs,
+                durationMs: Date.parse(endedAt) - Date.parse(startedAt),
+                maxToolCount: MAX_TOOL_COUNT,
+                observedToolCount: inventory.length,
+                maxSchemaBytes: MAX_SCHEMA_BYTES,
+                observedSchemaBytes,
+                networkAttempts: 1,
+                toolCalls: 0,
+            },
+            startedAt,
+            endedAt,
+        };
+        const receipt = { ...base, receiptDigest: fortemiReceiptDigest(base) };
+        const errors = verifyFortemiDatasetLiveReceipt(receipt);
+        if (errors.length)
+            throw new Error(errors.join(","));
+        return receipt;
+    }
+    finally {
+        await input.client.close?.();
+    }
+}
+export function verifyFortemiDatasetLiveReceipt(value) {
+    const errors = [];
+    const top = record(value);
+    if (!top)
+        return ["CONFORMANCE_RECEIPT_SHAPE_INVALID"];
+    const receipt = value;
+    if (!record(receipt.bindings) ||
+        !record(receipt.observed) ||
+        !record(receipt.mutation) ||
+        !record(receipt.resources) ||
+        !Array.isArray(receipt.operations) ||
+        !receipt.operations.every((item) => Boolean(record(item)))) {
+        return ["CONFORMANCE_RECEIPT_SHAPE_INVALID"];
+    }
+    if (!exactKeys(top, [
+        "contract",
+        "outcome",
+        "diagnostic",
+        "receiptDigest",
+        "bindings",
+        "observed",
+        "namespace",
+        "operations",
+        "mutation",
+        "resources",
+        "startedAt",
+        "endedAt",
+    ]) ||
+        !exactKeys(receipt.bindings, [
+            "aiwgCommit",
+            "endpointFingerprint",
+            "toolSchemaDigest",
+        ]) ||
+        !exactKeys(receipt.observed, [
+            "serverName",
+            "serverVersion",
+        ]) ||
+        !exactKeys(receipt.mutation, [
+            "authorized",
+            "attempted",
+        ]) ||
+        !exactKeys(receipt.resources, [
+            "maxDurationMs",
+            "durationMs",
+            "maxToolCount",
+            "observedToolCount",
+            "maxSchemaBytes",
+            "observedSchemaBytes",
+            "networkAttempts",
+            "toolCalls",
+        ]) ||
+        !receipt.operations.every((item) => exactKeys(item, [
+            "tool",
+            "compatible",
+            "code",
+        ])))
+        errors.push("CONFORMANCE_RECEIPT_SHAPE_INVALID");
+    if (receipt.contract !== FORTEMI_DATASET_LIVE_CONTRACT)
+        errors.push("CONFORMANCE_RECEIPT_CONTRACT_MISMATCH");
+    if (!COMMIT.test(receipt.bindings.aiwgCommit) ||
+        !DIGEST.test(receipt.bindings.endpointFingerprint) ||
+        !DIGEST.test(receipt.bindings.toolSchemaDigest))
+        errors.push("CONFORMANCE_RECEIPT_BINDING_INVALID");
+    if (!UUID_NAMESPACE.test(receipt.namespace))
+        errors.push("CONFORMANCE_RECEIPT_NAMESPACE_INVALID");
+    if (![
+        receipt.observed.serverName,
+        receipt.observed.serverVersion,
+        ...receipt.operations.flatMap((item) => [item.tool, item.code]),
+    ].every((value) => SAFE.test(value)))
+        errors.push("CONFORMANCE_RECEIPT_UNSAFE_VALUE");
+    if (receipt.mutation.authorized !== false ||
+        receipt.mutation.attempted !== false ||
+        receipt.resources.toolCalls !== 0 ||
+        receipt.resources.networkAttempts !== 1)
+        errors.push("CONFORMANCE_RECEIPT_MUTATION_INVALID");
+    const operationNames = receipt.operations.map((operation) => operation.tool);
+    const inventoryValid = receipt.operations.length === REQUIRED_TOOLS.length &&
+        REQUIRED_TOOLS.every((tool) => operationNames.filter((name) => name === tool).length === 1);
+    if (!inventoryValid ||
+        receipt.operations.some((operation) => operation.code !==
+            (operation.compatible
+                ? "FORTEMI_DATASET_TOOL_SCHEMA_COMPATIBLE"
+                : operation.code === "FORTEMI_DATASET_TOOL_MISSING"
+                    ? operation.code
+                    : "FORTEMI_DATASET_TOOL_SCHEMA_DRIFT")))
+        errors.push("CONFORMANCE_RECEIPT_OPERATION_INVALID");
+    const supported = inventoryValid &&
+        receipt.operations.every((operation) => operation.compatible);
+    const expectedDiagnostic = supported
+        ? "CONFORMANCE_FORTEMI_DATASET_PREFLIGHT_SUPPORTED"
+        : "CONFORMANCE_FORTEMI_DATASET_CONTRACT_UNAVAILABLE";
+    if (receipt.outcome !== (supported ? "supported" : "pending") ||
+        receipt.diagnostic !== expectedDiagnostic)
+        errors.push("CONFORMANCE_RECEIPT_OUTCOME_INVALID");
+    const start = Date.parse(receipt.startedAt);
+    const end = Date.parse(receipt.endedAt);
+    if (!Number.isFinite(start) ||
+        !Number.isFinite(end) ||
+        end < start ||
+        receipt.resources.durationMs !== end - start)
+        errors.push("CONFORMANCE_RECEIPT_TIME_INVALID");
+    if (!Number.isInteger(receipt.resources.maxDurationMs) ||
+        receipt.resources.maxDurationMs < 250 ||
+        receipt.resources.maxDurationMs > 30_000 ||
+        !Number.isInteger(receipt.resources.durationMs) ||
+        receipt.resources.durationMs < 0 ||
+        receipt.resources.maxToolCount !== MAX_TOOL_COUNT ||
+        !Number.isInteger(receipt.resources.observedToolCount) ||
+        receipt.resources.observedToolCount < 0 ||
+        receipt.resources.observedToolCount > MAX_TOOL_COUNT ||
+        receipt.resources.maxSchemaBytes !== MAX_SCHEMA_BYTES ||
+        !Number.isInteger(receipt.resources.observedSchemaBytes) ||
+        receipt.resources.observedSchemaBytes < 0 ||
+        receipt.resources.observedSchemaBytes > MAX_SCHEMA_BYTES)
+        errors.push("CONFORMANCE_RECEIPT_RESOURCES_INVALID");
+    if (!DIGEST.test(receipt.receiptDigest) ||
+        receipt.receiptDigest !== fortemiReceiptDigest(material(receipt)))
+        errors.push("CONFORMANCE_RECEIPT_DIGEST_MISMATCH");
+    return errors;
+}
+/** Atomically creates private evidence without replacing an existing receipt. */
+export async function writeFortemiDatasetLiveReceipt(path, receipt) {
+    const errors = verifyFortemiDatasetLiveReceipt(receipt);
+    if (errors.length)
+        throw new Error(errors.join(","));
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = `${path}.tmp-${process.pid}`;
+    await writeFile(temporary, `${JSON.stringify(receipt, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+        flag: "wx",
+    });
+    try {
+        await link(temporary, path);
+    }
+    finally {
+        await unlink(temporary).catch(() => undefined);
+    }
+}
+//# sourceMappingURL=fortemi-live-qualification.js.map

package/dist/src/dataset/index.d.ts

@@ -14,6 +14,7 @@ export * from './orchestration-repository.js';
 export * from './file-orchestration-repository.js';
 export * from './local-execution-backend.js';
 export * from './fortemi-execution-bridge.js';
+export * from './fortemi-live-qualification.js';
 export * from './orchestration-service.js';
 export * from './presentation.js';
 export * from './conformance-types.js';

package/dist/src/dataset/index.js

@@ -14,6 +14,7 @@ export * from './orchestration-repository.js';
 export * from './file-orchestration-repository.js';
 export * from './local-execution-backend.js';
 export * from './fortemi-execution-bridge.js';
+export * from './fortemi-live-qualification.js';
 export * from './orchestration-service.js';
 export * from './presentation.js';
 export * from './conformance-types.js';

package/dist/src/mcp/cli.mjs

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

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

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