@aiwg/cli 2026.9.2 → 2026.9.4

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'
             ? [

package/dist/src/storage/backends/fortemi.js

@@ -36,6 +36,45 @@
  * @issue #961
  * @issue #972
  */
+import { createHash } from 'node:crypto';
+const FORTEMI_QUERY_LIMIT = 50;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function schemaProperties(tool) {
+    const properties = tool?.inputSchema?.properties;
+    return properties && typeof properties === 'object'
+        ? properties
+        : {};
+}
+/** Select an argument contract from discovered capabilities, never a version string. */
+export function resolveFortemiToolProfile(tools) {
+    const byName = new Map(tools.map((tool) => [tool.name, tool]));
+    const legacy = schemaProperties(byName.get('get_note'));
+    if ('note_id' in legacy)
+        return 'legacy-note-id';
+    const currentGet = schemaProperties(byName.get('get_note'));
+    const currentUpsert = schemaProperties(byName.get('upsert_external_notes'));
+    const currentItems = currentUpsert.items;
+    if ('id' in currentGet &&
+        'source_namespace' in currentUpsert &&
+        'items' in currentUpsert &&
+        currentItems?.items?.properties &&
+        'external_id' in currentItems.items.properties &&
+        'content' in currentItems.items.properties &&
+        'caller_stable_id' in currentItems.items.properties)
+        return 'source-addressed-v1';
+    throw new Error('storage(fortemi): unsupported live MCP tool contract');
+}
+/** Stable UUID used as the opaque Fortemi handle for a subsystem/path identity. */
+export function fortemiStableNoteId(subsystem, path) {
+    const bytes = createHash('sha256')
+        .update(`aiwg-storage\0${subsystem}\0${path}`)
+        .digest()
+        .subarray(0, 16);
+    bytes[6] = (bytes[6] & 0x0f) | 0x50;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = bytes.toString('hex');
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
 const DEFAULT_MCP_SERVER = 'fortemi';
 const ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
 export function resolveMcpRequestHeaders(server, environment = process.env) {
@@ -48,7 +87,8 @@ export function resolveMcpRequestHeaders(server, environment = process.env) {
         if (!value) {
             throw new Error(`storage(fortemi): required credential environment variable "${envName}" is not set`);
         }
-        headers[header] = header.toLowerCase() === 'authorization' ? `Bearer ${value}` : value;
+        headers[header] =
+            header.toLowerCase() === 'authorization' ? `Bearer ${value}` : value;
     }
     return headers;
 }
@@ -75,6 +115,11 @@ export function unwrapMcpToolResult(result) {
             ?.filter((item) => item.type === 'text' && typeof item.text === 'string')
             .map((item) => item.text)
             .join('; ');
+        if (detail &&
+            /(?:API error 404|status(?: code)? 404)/i.test(detail) &&
+            /(?:Note not found|problems\/not-found)/i.test(detail)) {
+            return { not_found: true };
+        }
         throw new Error(`storage(fortemi): MCP tool failed${detail ? `: ${detail}` : ''}`);
     }
     if (envelope.structuredContent !== undefined)
@@ -95,6 +140,7 @@ export class FortemiAdapter {
     scheme;
     clientFactory;
     client = null;
+    profile = null;
     constructor(opts) {
         this.subsystem = opts.subsystem;
         this.mcpServer = opts.config.mcpServer ?? DEFAULT_MCP_SERVER;
@@ -105,12 +151,21 @@ export class FortemiAdapter {
         if (this.client)
             return;
         this.client = await this.clientFactory(this.mcpServer);
+        if (this.client.listTools) {
+            const discovered = await this.client.listTools();
+            this.profile = resolveFortemiToolProfile(discovered.tools ?? []);
+        }
+        else {
+            // Preserve injected/older clients which predate tool discovery.
+            this.profile = 'legacy-note-id';
+        }
     }
     async close() {
         if (this.client?.close) {
             await this.client.close();
         }
         this.client = null;
+        this.profile = null;
     }
     async getClient() {
         if (!this.client)
@@ -132,17 +187,44 @@ export class FortemiAdapter {
     async read(path) {
         const id = this.noteId(path);
         const client = await this.getClient();
-        const result = (await client.callTool('get_note', { note_id: id }));
+        const result = (await client.callTool('get_note', this.profile === 'source-addressed-v1'
+            ? { id: fortemiStableNoteId(this.subsystem, path) }
+            : { note_id: id }));
         if (!result || result.not_found)
             return null;
-        const note = result.note;
+        const note = result.note ?? result;
         if (!note)
             return null;
-        return note.revised_content ?? note.content ?? null;
+        return (result.revised?.content ??
+            result.original?.content ??
+            note.revised_content ??
+            note.content ??
+            null);
     }
     async write(path, content, meta) {
         const id = this.noteId(path);
         const client = await this.getClient();
+        if (this.profile === 'source-addressed-v1') {
+            const digest = createHash('sha256').update(content).digest('hex');
+            await client.callTool('upsert_external_notes', {
+                source_namespace: `aiwg.storage.${this.subsystem}`,
+                source_schema_version: 'aiwg.storage-entry/v1',
+                import_run_id: `sha256:${digest}`,
+                batch_id: `sha256:${digest}`,
+                policy: 'replace',
+                items: [
+                    {
+                        external_id: path,
+                        content,
+                        content_digest: `sha256:${digest}`,
+                        caller_stable_id: fortemiStableNoteId(this.subsystem, path),
+                        metadata: { ...this.buildMetadata(meta), aiwg_storage_path: path },
+                        policy: 'replace',
+                    },
+                ],
+            });
+            return;
+        }
         // Try update first; if not found, capture as new. Two calls in the
         // worst case but idempotent — Fortemi's update_note increments the
         // version rather than overwriting, which matches the Phase-4 design.
@@ -171,16 +253,29 @@ export class FortemiAdapter {
         const subsystemPrefix = `${this.subsystem}:`;
         const fullPrefix = prefix.length === 0 ? subsystemPrefix : `${subsystemPrefix}${prefix}`;
         const result = (await client.callTool('list_notes', {
-            id_prefix: fullPrefix,
-            scheme: this.scheme,
+            ...(this.profile === 'source-addressed-v1'
+                ? { limit: 500, offset: 0 }
+                : { id_prefix: fullPrefix, scheme: this.scheme }),
         }));
         const notes = result?.notes ?? [];
         return notes
-            .filter((n) => typeof n.note_id === 'string' && n.note_id.startsWith(subsystemPrefix))
+            .map((n) => {
+            const current = n;
+            const path = current.metadata?.aiwg_storage_path;
+            return typeof path === 'string' &&
+                current.metadata?.subsystem === this.subsystem
+                ? {
+                    ...n,
+                    note_id: `${subsystemPrefix}${path}`,
+                    external_id: current.id,
+                }
+                : n;
+        })
+            .filter((n) => typeof n.note_id === 'string' && n.note_id.startsWith(fullPrefix))
             .map((n) => {
             const entry = {
                 path: n.note_id.slice(subsystemPrefix.length),
-                externalId: n.note_id,
+                externalId: n.external_id ?? n.note_id,
             };
             if (typeof n.size === 'number')
                 entry.size = n.size;
@@ -200,11 +295,16 @@ export class FortemiAdapter {
         // the note from list/read by archiving it).
         const id = this.noteId(path);
         const client = await this.getClient();
-        const existing = (await client.callTool('get_note', { note_id: id }));
-        if (!existing || existing.not_found || !existing.note)
+        const identityArgs = this.profile === 'source-addressed-v1'
+            ? { id: fortemiStableNoteId(this.subsystem, path) }
+            : { note_id: id };
+        const existing = (await client.callTool('get_note', identityArgs));
+        if (!existing ||
+            existing.not_found ||
+            (this.profile !== 'source-addressed-v1' && !existing.note))
             return;
         await client.callTool('update_note', {
-            note_id: id,
+            ...identityArgs,
             archived: true,
         });
     }
@@ -212,16 +312,41 @@ export class FortemiAdapter {
         const client = await this.getClient();
         const subsystemPrefix = `${this.subsystem}:`;
         const result = (await client.callTool('search', {
-            query: q,
-            id_prefix: subsystemPrefix,
-            scheme: this.scheme,
+            ...(this.profile === 'source-addressed-v1'
+                ? { action: 'text', query: q, limit: FORTEMI_QUERY_LIMIT }
+                : { query: q, id_prefix: subsystemPrefix, scheme: this.scheme }),
         }));
         const results = result?.results ?? [];
-        return results
-            .filter((r) => typeof r.note_id === 'string' && r.note_id.startsWith(subsystemPrefix))
+        const hydrated = [];
+        for (const resultItem of results.slice(0, FORTEMI_QUERY_LIMIT)) {
+            let item = resultItem;
+            if (this.profile === 'source-addressed-v1' &&
+                typeof item.id === 'string' &&
+                UUID.test(item.id) &&
+                (!item.metadata || typeof item.metadata.aiwg_storage_path !== 'string')) {
+                const detail = (await client.callTool('get_note', { id: item.id }));
+                if (!detail || detail.not_found)
+                    continue;
+                const note = detail.note;
+                if (!note || note.id !== item.id)
+                    continue;
+                item = { ...item, metadata: note.metadata };
+            }
+            hydrated.push(item);
+        }
+        return hydrated
+            .map((r) => {
+            const path = r.metadata?.aiwg_storage_path;
+            return typeof path === 'string' &&
+                r.metadata?.subsystem === this.subsystem
+                ? { ...r, note_id: `${subsystemPrefix}${path}` }
+                : r;
+        })
+            .filter((r) => typeof r.note_id === 'string' &&
+            r.note_id.startsWith(subsystemPrefix))
             .map((r) => ({
             path: r.note_id.slice(subsystemPrefix.length),
-            externalId: r.note_id,
+            externalId: r.id ?? r.note_id,
         }));
     }
     buildMetadata(meta) {

package/dist/src/storage/fortemi-qualification-receipt.js

@@ -0,0 +1,206 @@
+import { createHash } from "node:crypto";
+import { link, mkdir, unlink, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { execFileSync } from "node:child_process";
+export const FORTEMI_QUALIFICATION_RECEIPT = "aiwg.fortemi-live-qualification-receipt/v1";
+const DIGEST = /^sha256:[0-9a-f]{64}$/;
+const COMMIT = /^[0-9a-f]{40}$/;
+const REF = /^(?:refs\/(?:heads|tags)\/[A-Za-z0-9._/-]+|[0-9a-f]{40})$/;
+const SHORT_REF = /^[A-Za-z0-9._/-]+$/;
+const SAFE = /^[A-Za-z0-9._:/-]+$/;
+const NAMESPACE = /^aiwg-qualification-[0-9a-f-]{36}$/;
+const REQUIRED_OPERATIONS = new Set([
+    "read",
+    "write",
+    "update",
+    "list",
+    "query",
+]);
+function hasCompleteOperationInventory(operations) {
+    const names = operations.map((operation) => operation.operation);
+    return (names.length === REQUIRED_OPERATIONS.size &&
+        new Set(names).size === REQUIRED_OPERATIONS.size &&
+        names.every((name) => REQUIRED_OPERATIONS.has(name)));
+}
+export function resolveFortemiQualificationSource(env = process.env, cwd = process.cwd()) {
+    const git = (...args) => execFileSync("git", args, {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    const aiwgCommit = env.AIWG_STORAGE_QUALIFICATION_COMMIT || git("rev-parse", "HEAD");
+    const configuredRef = env.AIWG_STORAGE_QUALIFICATION_BRANCH;
+    const aiwgRef = configuredRef
+        ? REF.test(configuredRef)
+            ? configuredRef
+            : SHORT_REF.test(configuredRef) && !configuredRef.includes("..")
+                ? `refs/heads/${configuredRef}`
+                : configuredRef
+        : (() => {
+            try {
+                return git("symbolic-ref", "-q", "HEAD");
+            }
+            catch {
+                return aiwgCommit;
+            }
+        })();
+    if (!COMMIT.test(aiwgCommit))
+        throw new Error("FORTEMI_RECEIPT_INVALID_COMMIT");
+    if (!REF.test(aiwgRef) || aiwgRef.includes(".."))
+        throw new Error("FORTEMI_RECEIPT_INVALID_REF");
+    return { aiwgCommit, aiwgRef };
+}
+function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    if (value && typeof value === "object")
+        return `{${Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`)
+            .join(",")}}`;
+    return JSON.stringify(value);
+}
+export function fortemiReceiptDigest(value) {
+    return `sha256:${createHash("sha256").update(canonical(value)).digest("hex")}`;
+}
+export function endpointFingerprint(rawUrl) {
+    const url = new URL(rawUrl);
+    url.username = "";
+    url.password = "";
+    url.hash = "";
+    return fortemiReceiptDigest(url.toString());
+}
+function receiptMaterial(receipt) {
+    const { receiptDigest: _digest, ...material } = receipt;
+    return material;
+}
+export function createFortemiQualificationReceipt(input) {
+    if (!COMMIT.test(input.aiwgCommit))
+        throw new Error("FORTEMI_RECEIPT_INVALID_COMMIT");
+    if (!REF.test(input.aiwgRef) || input.aiwgRef.includes(".."))
+        throw new Error("FORTEMI_RECEIPT_INVALID_REF");
+    if (!input.report.server.name || !SAFE.test(input.report.server.name))
+        throw new Error("FORTEMI_RECEIPT_INVALID_SERVER_NAME");
+    if (!input.report.server.version || !SAFE.test(input.report.server.version))
+        throw new Error("FORTEMI_RECEIPT_INVALID_SERVER_VERSION");
+    if (!SAFE.test(input.contractRevision))
+        throw new Error("FORTEMI_RECEIPT_INVALID_CONTRACT_REVISION");
+    if (!NAMESPACE.test(input.report.namespace))
+        throw new Error("FORTEMI_RECEIPT_INVALID_NAMESPACE");
+    if (input.report.mutationAttempted !== Boolean(input.mutationObjectId))
+        throw new Error("FORTEMI_RECEIPT_MUTATION_BINDING_MISMATCH");
+    if (input.mutationObjectId && !SAFE.test(input.mutationObjectId))
+        throw new Error("FORTEMI_RECEIPT_INVALID_OBJECT_ID");
+    const start = Date.parse(input.startedAt);
+    const end = Date.parse(input.endedAt);
+    if (!Number.isFinite(start) || !Number.isFinite(end) || end < start)
+        throw new Error("FORTEMI_RECEIPT_INVALID_TIMESTAMPS");
+    if (!Number.isInteger(input.timeoutMs) ||
+        input.timeoutMs < 250 ||
+        input.timeoutMs > 30_000 ||
+        !Number.isInteger(input.networkAttempts) ||
+        input.networkAttempts < 0)
+        throw new Error("FORTEMI_RECEIPT_INVALID_RESOURCES");
+    const operations = input.report.operations.map(({ operation, tool, compatible, code }) => {
+        if (![operation, tool, code].every((value) => SAFE.test(value)))
+            throw new Error("FORTEMI_RECEIPT_UNSAFE_OPERATION");
+        return { operation, tool, compatible, code };
+    });
+    if (!hasCompleteOperationInventory(operations))
+        throw new Error("FORTEMI_RECEIPT_OPERATION_INVENTORY_INVALID");
+    const material = {
+        contract: FORTEMI_QUALIFICATION_RECEIPT,
+        outcome: input.report.compatible ? "passed" : "failed",
+        bindings: {
+            aiwgCommit: input.aiwgCommit,
+            aiwgRef: input.aiwgRef,
+            endpointFingerprint: endpointFingerprint(input.endpointUrl),
+            toolSchemaDigest: fortemiReceiptDigest(input.toolSchemas),
+        },
+        observed: {
+            serverName: input.report.server.name,
+            serverVersion: input.report.server.version,
+            contractRevision: input.contractRevision,
+        },
+        namespace: input.report.namespace,
+        operations,
+        mutation: {
+            attempted: input.report.mutationAttempted,
+            ...(input.mutationObjectId ? { objectId: input.mutationObjectId } : {}),
+        },
+        startedAt: new Date(start).toISOString(),
+        endedAt: new Date(end).toISOString(),
+        resources: {
+            timeoutMs: input.timeoutMs,
+            durationMs: end - start,
+            networkAttempts: input.networkAttempts,
+            toolCount: operations.length,
+        },
+    };
+    return { ...material, receiptDigest: fortemiReceiptDigest(material) };
+}
+export function verifyFortemiQualificationReceipt(receipt) {
+    const errors = [];
+    if (receipt.contract !== FORTEMI_QUALIFICATION_RECEIPT)
+        errors.push("FORTEMI_RECEIPT_CONTRACT_MISMATCH");
+    if (!["passed", "failed"].includes(receipt.outcome) ||
+        receipt.outcome !==
+            (receipt.operations.every((operation) => operation.compatible)
+                ? "passed"
+                : "failed"))
+        errors.push("FORTEMI_RECEIPT_OUTCOME_INVALID");
+    if (!DIGEST.test(receipt.receiptDigest) ||
+        receipt.receiptDigest !== fortemiReceiptDigest(receiptMaterial(receipt)))
+        errors.push("FORTEMI_RECEIPT_DIGEST_MISMATCH");
+    if (!DIGEST.test(receipt.bindings.endpointFingerprint) ||
+        !DIGEST.test(receipt.bindings.toolSchemaDigest))
+        errors.push("FORTEMI_RECEIPT_BINDING_INVALID");
+    if (!COMMIT.test(receipt.bindings.aiwgCommit) ||
+        !REF.test(receipt.bindings.aiwgRef))
+        errors.push("FORTEMI_RECEIPT_SOURCE_INVALID");
+    if (!SAFE.test(receipt.observed.serverName) ||
+        !SAFE.test(receipt.observed.serverVersion) ||
+        !SAFE.test(receipt.observed.contractRevision) ||
+        !NAMESPACE.test(receipt.namespace))
+        errors.push("FORTEMI_RECEIPT_OBSERVATION_INVALID");
+    if (receipt.operations.some((item) => !SAFE.test(item.operation) ||
+        !SAFE.test(item.tool) ||
+        !SAFE.test(item.code)))
+        errors.push("FORTEMI_RECEIPT_OPERATION_INVALID");
+    if (!hasCompleteOperationInventory(receipt.operations))
+        errors.push("FORTEMI_RECEIPT_OPERATION_INVENTORY_INVALID");
+    if (receipt.mutation.attempted !== Boolean(receipt.mutation.objectId) ||
+        (receipt.mutation.objectId && !SAFE.test(receipt.mutation.objectId)))
+        errors.push("FORTEMI_RECEIPT_MUTATION_INVALID");
+    if (Date.parse(receipt.endedAt) < Date.parse(receipt.startedAt) ||
+        receipt.resources.durationMs !==
+            Date.parse(receipt.endedAt) - Date.parse(receipt.startedAt))
+        errors.push("FORTEMI_RECEIPT_TIME_INVALID");
+    if (!Number.isInteger(receipt.resources.timeoutMs) ||
+        receipt.resources.timeoutMs < 250 ||
+        receipt.resources.timeoutMs > 30_000 ||
+        !Number.isInteger(receipt.resources.networkAttempts) ||
+        receipt.resources.networkAttempts < 0 ||
+        receipt.resources.toolCount !== receipt.operations.length)
+        errors.push("FORTEMI_RECEIPT_RESOURCES_INVALID");
+    return errors;
+}
+export async function writeFortemiQualificationReceipt(path, receipt) {
+    const errors = verifyFortemiQualificationReceipt(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-qualification-receipt.js.map