@aiwg/cli 2026.9.1 → 2026.9.3

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

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

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

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

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';