@aiwg/cli 2026.8.28 → 2026.9.1

package/dist/src/schema/diagnostics.js

@@ -0,0 +1,36 @@
+export const SCHEMA_DIAGNOSTIC_CODES = {
+    invalidCatalog: 'SCHEMA_CATALOG_INVALID',
+    invalidManifest: 'SCHEMA_MANIFEST_INVALID',
+    duplicateId: 'SCHEMA_DUPLICATE_ID',
+    duplicateNameVersion: 'SCHEMA_DUPLICATE_NAME_VERSION',
+    duplicateAuthority: 'SCHEMA_DUPLICATE_AUTHORITY',
+    missingPath: 'SCHEMA_PATH_MISSING',
+    pathOutsideRoot: 'SCHEMA_PATH_OUTSIDE_ROOT',
+    digestMismatch: 'SCHEMA_DIGEST_MISMATCH',
+    unresolvedDependency: 'SCHEMA_DEPENDENCY_UNRESOLVED',
+    undeclaredCanonical: 'SCHEMA_CANONICAL_UNREGISTERED',
+    undeclaredMirror: 'SCHEMA_MIRROR_UNDECLARED',
+    expiredException: 'SCHEMA_POLICY_EXCEPTION_EXPIRED',
+};
+export function createDiagnostic(code, message, options = {}) {
+    return {
+        code,
+        severity: options.severity ?? 'error',
+        message,
+        ...(options.artifactId === undefined ? {} : { artifactId: options.artifactId }),
+        ...(options.path === undefined ? {} : { path: options.path }),
+        ...(options.details === undefined ? {} : { details: options.details }),
+    };
+}
+export function hasSchemaErrors(diagnostics) {
+    return diagnostics.some((diagnostic) => diagnostic.severity === 'error');
+}
+export class SchemaCatalogError extends Error {
+    diagnostics;
+    constructor(message, diagnostics) {
+        super(message);
+        this.name = 'SchemaCatalogError';
+        this.diagnostics = diagnostics;
+    }
+}
+//# sourceMappingURL=diagnostics.js.map

package/dist/src/schema/index.js

@@ -0,0 +1,8 @@
+export * from './types.js';
+export * from './diagnostics.js';
+export * from './policy.js';
+export * from './catalog.js';
+export * from './resolver.js';
+export * from './validator.js';
+export * from './compatibility.js';
+//# sourceMappingURL=index.js.map

package/dist/src/schema/policy.js

@@ -0,0 +1,58 @@
+import { createDiagnostic, SCHEMA_DIAGNOSTIC_CODES } from './diagnostics.js';
+export const DEFAULT_SCHEMA_POLICY = {
+    strict: true,
+    remoteReferences: 'deny',
+    compatibility: 'unknown',
+    requireFixtures: false,
+    requireDigest: false,
+    exceptions: [],
+};
+export function resolveEffectivePolicy(repositoryPolicy, domain, artifact) {
+    const layers = [repositoryPolicy, domain.policy, artifact.policy];
+    const merged = {};
+    for (const layer of layers) {
+        if (layer === undefined)
+            continue;
+        if (layer.strict !== undefined)
+            merged.strict = layer.strict;
+        if (layer.remoteReferences !== undefined)
+            merged.remoteReferences = layer.remoteReferences;
+        if (layer.compatibility !== undefined)
+            merged.compatibility = layer.compatibility;
+        if (layer.requireFixtures !== undefined)
+            merged.requireFixtures = layer.requireFixtures;
+        if (layer.requireDigest !== undefined)
+            merged.requireDigest = layer.requireDigest;
+        if (layer.exceptions !== undefined)
+            merged.exceptions = [...(merged.exceptions ?? []), ...layer.exceptions];
+    }
+    if (artifact.compatibility?.mode !== undefined && artifact.policy?.compatibility === undefined) {
+        merged.compatibility = artifact.compatibility.mode;
+    }
+    return {
+        strict: merged.strict ?? DEFAULT_SCHEMA_POLICY.strict,
+        remoteReferences: merged.remoteReferences ?? DEFAULT_SCHEMA_POLICY.remoteReferences,
+        compatibility: merged.compatibility ?? DEFAULT_SCHEMA_POLICY.compatibility,
+        requireFixtures: merged.requireFixtures ?? DEFAULT_SCHEMA_POLICY.requireFixtures,
+        requireDigest: merged.requireDigest ?? DEFAULT_SCHEMA_POLICY.requireDigest,
+        exceptions: [...(merged.exceptions ?? [])].sort((left, right) => `${left.rule}\0${left.expires}`.localeCompare(`${right.rule}\0${right.expires}`)),
+        provenance: [
+            ...(repositoryPolicy === undefined ? [] : [{ source: 'repository', value: repositoryPolicy }]),
+            ...(domain.policy === undefined
+                ? []
+                : [{ source: 'domain', domain: domain.domain, value: domain.policy }]),
+            ...(artifact.policy === undefined ? [] : [{ source: 'artifact', value: artifact.policy }]),
+        ],
+    };
+}
+export function diagnosePolicy(policy, artifactId, now = new Date()) {
+    const diagnostics = [];
+    for (const exception of policy.exceptions) {
+        const expires = new Date(exception.expires);
+        if (Number.isNaN(expires.getTime()) || expires.getTime() <= now.getTime()) {
+            diagnostics.push(createDiagnostic(SCHEMA_DIAGNOSTIC_CODES.expiredException, `Policy exception ${exception.rule} expired on ${exception.expires}`, { artifactId, details: { rule: exception.rule, owner: exception.owner, expires: exception.expires } }));
+        }
+    }
+    return diagnostics;
+}
+//# sourceMappingURL=policy.js.map

package/dist/src/schema/resolver.js

@@ -0,0 +1,76 @@
+import { relative, resolve, sep } from 'node:path';
+export class SchemaResolver {
+    catalog;
+    rootDir;
+    index = new Map();
+    constructor(catalog, options = {}) {
+        this.catalog = catalog;
+        this.rootDir = options.rootDir === undefined ? undefined : resolve(options.rootDir);
+        for (const entry of catalog.entries) {
+            this.index.set(entry.artifact.id, entry);
+            this.index.set(`${entry.artifact.logicalName}@${entry.artifact.version}`, entry);
+            // The unqualified logical name resolves to the last deterministically
+            // ordered revision. Callers requiring reproducibility should use id or
+            // name@version.
+            this.index.set(entry.artifact.logicalName, entry);
+            for (const alias of entry.artifact.aliases ?? [])
+                this.index.set(alias, entry);
+            if (entry.artifact.authority.path) {
+                const normalized = entry.artifact.authority.path.split('\\').join('/');
+                this.index.set(normalized, entry);
+                if (this.rootDir)
+                    this.index.set(relative(this.rootDir, resolve(this.rootDir, normalized)).split(sep).join('/'), entry);
+            }
+        }
+    }
+    list(options = {}) {
+        return this.catalog.entries.filter((entry) => (options.domain === undefined || entry.domain === options.domain) &&
+            (options.lifecycle === undefined || entry.artifact.lifecycle === options.lifecycle) &&
+            (options.format === undefined || entry.artifact.format === options.format));
+    }
+    resolve(query) {
+        return this.index.get(query) ?? this.index.get(query.split('\\').join('/'));
+    }
+    require(query) {
+        const entry = this.resolve(query);
+        if (!entry)
+            throw new Error(`Unknown schema: ${query}`);
+        return entry;
+    }
+    policy(query) {
+        return this.require(query).effectivePolicy;
+    }
+    graph(query, options = {}) {
+        const direction = options.direction ?? 'both';
+        const allEdges = [];
+        for (const entry of this.catalog.entries) {
+            for (const dependency of entry.artifact.dependencies ?? [])
+                allEdges.push({ from: entry.artifact.id, to: dependency.id, kind: 'depends-on' });
+            for (const superseded of entry.artifact.supersedes ?? [])
+                allEdges.push({ from: entry.artifact.id, to: superseded, kind: 'supersedes' });
+        }
+        const selected = query === undefined ? new Set(this.catalog.entries.map((entry) => entry.artifact.id)) : this.collectConnected(this.require(query).artifact.id, allEdges, direction);
+        return {
+            nodes: this.catalog.entries.filter((entry) => selected.has(entry.artifact.id)).map((entry) => ({ id: entry.artifact.id, logicalName: entry.artifact.logicalName, version: entry.artifact.version, domain: entry.domain })).sort((a, b) => a.id.localeCompare(b.id)),
+            edges: allEdges.filter((edge) => selected.has(edge.from) && selected.has(edge.to)).sort((a, b) => `${a.from}\0${a.to}\0${a.kind}`.localeCompare(`${b.from}\0${b.to}\0${b.kind}`)),
+        };
+    }
+    collectConnected(seed, edges, direction) {
+        const result = new Set([seed]);
+        const queue = [seed];
+        while (queue.length) {
+            const current = queue.shift();
+            if (!current)
+                continue;
+            for (const edge of edges) {
+                const next = edge.from === current && direction !== 'dependents' ? edge.to : edge.to === current && direction !== 'dependencies' ? edge.from : undefined;
+                if (next && !result.has(next)) {
+                    result.add(next);
+                    queue.push(next);
+                }
+            }
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=resolver.js.map

package/dist/src/schema/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/schema/validator.js

@@ -0,0 +1,82 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import Ajv from 'ajv';
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+function depth(value, seen = new Set()) {
+    if (typeof value !== 'object' || value === null)
+        return 0;
+    if (seen.has(value))
+        return 0;
+    seen.add(value);
+    const children = Array.isArray(value) ? value : Object.values(value);
+    return children.length === 0 ? 1 : 1 + Math.max(...children.map(item => depth(item, seen)));
+}
+function errorDiagnostic(artifactId, error) {
+    return {
+        code: 'SCHEMA_INSTANCE_INVALID',
+        severity: 'error',
+        message: error.message ?? 'validation failed',
+        artifactId,
+        path: error.instancePath,
+        details: { schemaPath: error.schemaPath, keyword: error.keyword, params: error.params },
+    };
+}
+/** Offline, catalog-backed validator with bounded inputs and compiled-schema caching. */
+export class SchemaValidator {
+    resolver;
+    options;
+    cache = new Map();
+    constructor(resolver, options) {
+        this.resolver = resolver;
+        this.options = options;
+    }
+    compile(query) {
+        const entry = this.resolver.require(query);
+        if (entry.artifact.format !== 'json-schema') {
+            throw new Error(`Validation requires a JSON Schema artifact; got ${entry.artifact.format}`);
+        }
+        const key = `${entry.artifact.id}\0${entry.digest ?? entry.artifact.version}`;
+        const cached = this.cache.get(key);
+        if (cached)
+            return cached;
+        const draft2020 = entry.artifact.dialect?.includes('2020-12') ?? false;
+        const ajv = draft2020
+            ? new Ajv2020({ strict: entry.effectivePolicy.strict, allErrors: true, loadSchema: undefined })
+            : new Ajv({ strict: entry.effectivePolicy.strict, allErrors: true, loadSchema: undefined });
+        addFormats(ajv);
+        for (const candidate of this.resolver.list())
+            this.addCompatibleSchema(ajv, candidate, draft2020);
+        const compiled = ajv.getSchema(entry.artifact.id);
+        if (!compiled)
+            throw new Error(`Could not compile schema ${entry.artifact.id}`);
+        this.cache.set(key, compiled);
+        return compiled;
+    }
+    validate(query, instance) {
+        const entry = this.resolver.require(query);
+        const diagnostics = [];
+        const serialized = JSON.stringify(instance);
+        const maxBytes = this.options.limits?.maxBytes ?? 10 * 1024 * 1024;
+        const maxDepth = this.options.limits?.maxDepth ?? 128;
+        if (Buffer.byteLength(serialized) > maxBytes)
+            diagnostics.push({ code: 'SCHEMA_RESOURCE_LIMIT', severity: 'error', message: `Instance exceeds ${maxBytes} byte limit`, artifactId: entry.artifact.id });
+        if (depth(instance) > maxDepth)
+            diagnostics.push({ code: 'SCHEMA_RESOURCE_LIMIT', severity: 'error', message: `Instance exceeds depth limit ${maxDepth}`, artifactId: entry.artifact.id });
+        if (diagnostics.length)
+            return { valid: false, artifactId: entry.artifact.id, diagnostics };
+        const check = this.compile(query);
+        const valid = check(instance);
+        return { valid, artifactId: entry.artifact.id, diagnostics: (check.errors ?? []).map(error => errorDiagnostic(entry.artifact.id, error)) };
+    }
+    addCompatibleSchema(ajv, entry, draft2020) {
+        if (entry.artifact.format !== 'json-schema' || !entry.artifact.authority.path)
+            return;
+        if ((entry.artifact.dialect?.includes('2020-12') ?? false) !== draft2020)
+            return;
+        const path = resolve(this.options.rootDir, entry.artifact.authority.path);
+        const schema = JSON.parse(readFileSync(path, 'utf8'));
+        ajv.addSchema(schema, entry.artifact.id);
+    }
+}
+//# sourceMappingURL=validator.js.map

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

@@ -301,6 +301,12 @@ export const createDefaultMcpClient = async (serverName, registryOverride, envir
         async callTool(name, args) {
             return unwrapMcpToolResult(await client.callTool({ name, arguments: args }));
         },
+        async listTools() {
+            return client.listTools();
+        },
+        serverVersion() {
+            return client.getServerVersion();
+        },
         async close() {
             await client.close();
         },

package/dist/src/storage/config.js

@@ -5,10 +5,9 @@
  * v1 schema, and returns a typed `StorageConfig`. Absence of the file is
  * a no-op: every subsystem defaults to `fs` rooted under `.aiwg/`.
  *
- * Validation is hand-rolled rather than schema-validator-driven to avoid
- * adding an `ajv` dependency for a single file. The published JSON
- * Schema (`.aiwg/architecture/schemas/storage.config.v1.json`) remains
- * canonical for editor tooling and external consumers.
+ * Runtime validation is kept in parity with the canonical JSON Schema at
+ * `schemas/storage/storage.config.v1.schema.json`; the lightweight path here
+ * avoids loading the full catalog during storage bootstrap.
  *
  * @design @.aiwg/architecture/storage-design.md
  * @issue #934
@@ -98,6 +97,7 @@ export function validateStorageConfig(parsed, source = '<input>') {
             `(expected "1"). Update the AIWG CLI to read newer config versions.`);
     }
     walkRejectingCredentials(obj, source, 'storage');
+    rejectUnknownKeys(obj, ['version', 'roots', 'backends', 'fallback'], source, 'storage');
     const roots = validateRoots(obj['roots'], source);
     const backends = validateBackends(obj['backends'], source);
     let fallback;
@@ -164,19 +164,24 @@ function validateBackendConfig(raw, source) {
     // — the adapter is responsible for any further validation it needs.
     switch (type) {
         case 'fs':
+            rejectUnknownKeys(obj, ['type'], source, 'backend');
             return { type: 'fs' };
         case 'obsidian':
+            rejectUnknownKeys(obj, ['type', 'vault', 'folder', 'useCli'], source, 'backend');
             requireString(obj, 'vault', source);
             return obj;
         case 'logseq':
+            rejectUnknownKeys(obj, ['type', 'graph', 'apiUrl', 'useApi'], source, 'backend');
             requireString(obj, 'graph', source);
             return obj;
         case 'notion': {
+            rejectUnknownKeys(obj, ['type', 'parent', 'externalIdProperty'], source, 'backend');
             const parent = obj['parent'];
             if (typeof parent !== 'object' || parent === null) {
                 throw new Error(`${source}.parent must be an object with pageId or databaseId`);
             }
             const p = parent;
+            rejectUnknownKeys(p, ['pageId', 'databaseId'], source, 'parent');
             const hasPage = typeof p['pageId'] === 'string' && p['pageId'].length > 0;
             const hasDb = typeof p['databaseId'] === 'string' && p['databaseId'].length > 0;
             if (hasPage === hasDb) {
@@ -185,21 +190,30 @@ function validateBackendConfig(raw, source) {
             return obj;
         }
         case 'anythingllm':
+            rejectUnknownKeys(obj, ['type', 'baseUrl', 'workspace', 'folder'], source, 'backend');
             requireString(obj, 'baseUrl', source);
             requireString(obj, 'workspace', source);
             return obj;
         case 'fortemi':
+            rejectUnknownKeys(obj, ['type', 'mcpServer', 'scheme'], source, 'backend');
             return obj;
         case 's3':
+            rejectUnknownKeys(obj, ['type', 'bucket', 'prefix', 'region', 'endpoint'], source, 'backend');
             requireString(obj, 'bucket', source);
             return obj;
         case 'webdav':
+            rejectUnknownKeys(obj, ['type', 'url', 'basePath', 'authMode'], source, 'backend');
             requireString(obj, 'url', source);
             return obj;
         default:
             throw new Error(`${source}: unhandled backend type ${type}`);
     }
 }
+function rejectUnknownKeys(obj, allowed, source, label) {
+    const unknown = Object.keys(obj).find(key => !allowed.includes(key));
+    if (unknown)
+        throw new Error(`${source}: ${label}.${unknown} is not a supported property`);
+}
 function requireString(obj, key, source) {
     const v = obj[key];
     if (typeof v !== 'string' || v.length === 0) {

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

@@ -0,0 +1,106 @@
+import { randomUUID } from "node:crypto";
+import { FortemiAdapter } from "./backends/fortemi.js";
+export const FORTEMI_QUALIFICATION_VERSION = "aiwg.fortemi-live-qualification/v1";
+const EXPECTED = {
+    read: { tool: "get_note", required: ["note_id"], properties: ["note_id"] },
+    write: {
+        tool: "capture_knowledge",
+        required: ["note_id", "content"],
+        properties: ["note_id", "content"],
+    },
+    update: {
+        tool: "update_note",
+        required: ["note_id"],
+        properties: ["note_id", "content", "archived"],
+    },
+    list: { tool: "list_notes", required: [], properties: ["id_prefix"] },
+    query: {
+        tool: "search",
+        required: ["query"],
+        properties: ["query", "id_prefix"],
+    },
+};
+function bounded(work, timeoutMs, label) {
+    let timer;
+    return Promise.race([
+        work,
+        new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`FORTEMI_LIVE_TIMEOUT: ${label} exceeded ${timeoutMs}ms`)), timeoutMs);
+        }),
+    ]).finally(() => clearTimeout(timer));
+}
+/** Schema-first live qualification. No tool operation runs when preflight detects drift. */
+export async function qualifyLiveFortemi(client, options = {}) {
+    const timeoutMs = Math.max(250, Math.min(options.timeoutMs ?? 5_000, 30_000));
+    const namespace = `aiwg-qualification-${randomUUID()}`;
+    const report = {
+        schema: FORTEMI_QUALIFICATION_VERSION,
+        compatible: false,
+        mutationAttempted: false,
+        server: {
+            ...(client.serverVersion?.() ?? {}),
+            ...(options.contractRevision
+                ? { contractRevision: options.contractRevision }
+                : {}),
+        },
+        namespace,
+        operations: [],
+    };
+    try {
+        if (!client.listTools)
+            throw new Error("FORTEMI_TOOL_DISCOVERY_UNAVAILABLE");
+        const discovered = await bounded(client.listTools(), timeoutMs, "tools/list");
+        const tools = new Map((discovered.tools ?? []).map((tool) => [tool.name, tool]));
+        for (const [operation, expected] of Object.entries(EXPECTED)) {
+            const tool = tools.get(expected.tool);
+            const schema = tool?.inputSchema;
+            const properties = schema?.properties && typeof schema.properties === "object"
+                ? schema.properties
+                : {};
+            const required = Array.isArray(schema?.required)
+                ? schema.required.filter((value) => typeof value === "string")
+                : [];
+            const missing = expected.properties.filter((name) => !(name in properties));
+            const missingRequired = expected.required.filter((name) => !required.includes(name));
+            const compatible = Boolean(tool && schema) &&
+                missing.length === 0 &&
+                missingRequired.length === 0;
+            report.operations.push({
+                operation,
+                tool: expected.tool,
+                compatible,
+                code: compatible
+                    ? "FORTEMI_TOOL_SCHEMA_COMPATIBLE"
+                    : tool
+                        ? "FORTEMI_TOOL_SCHEMA_DRIFT"
+                        : "FORTEMI_TOOL_MISSING",
+                detail: compatible
+                    ? "expected adapter arguments are accepted"
+                    : `missing properties: ${missing.join(", ") || "none"}; not required: ${missingRequired.join(", ") || "none"}`,
+            });
+        }
+        report.compatible = report.operations.every((item) => item.compatible);
+        if (!report.compatible)
+            return report;
+        const adapter = new FortemiAdapter({
+            subsystem: namespace,
+            config: { type: "fortemi", mcpServer: "live-qualification" },
+            clientFactory: async () => client,
+        });
+        await bounded(adapter.init(), timeoutMs, "adapter init");
+        await bounded(adapter.read(randomUUID()), timeoutMs, "adapter read");
+        await bounded(adapter.list(""), timeoutMs, "adapter list");
+        await bounded(adapter.query(`aiwg qualification ${namespace}`), timeoutMs, "adapter query");
+        if (options.allowMutation) {
+            report.mutationAttempted = true;
+            await bounded(adapter.write(randomUUID(), `AIWG live qualification ${namespace}`, {
+                contentType: "text/plain",
+            }), timeoutMs, "adapter write");
+        }
+        return report;
+    }
+    finally {
+        await client.close?.();
+    }
+}
+//# sourceMappingURL=fortemi-qualification.js.map

package/dist/src/storage/index.js

@@ -21,6 +21,7 @@ export { FilesystemAdapter } from './backends/fs.js';
 export { ObsidianAdapter } from './backends/obsidian.js';
 export { LogseqAdapter } from './backends/logseq.js';
 export { FortemiAdapter } from './backends/fortemi.js';
+export { qualifyLiveFortemi, FORTEMI_QUALIFICATION_VERSION, } from './fortemi-qualification.js';
 export { STORAGE_BACKEND_CONTRACT, STORAGE_BACKEND_MATRIX, StorageCapabilityError, negotiateStorageCapabilities, } from './backend-contract.js';
 export { STORAGE_MIGRATION_PROTOCOL, MigrationProtocolError, StorageMigrationCoordinator, approvalDigest, digestRecordChunks, digestRecords, validateManifest, } from './migration-protocol.js';
 export { PostgresStorageBackend, PostgresBackendError, } from './backends/postgres.js';

package/dist/src/storage/types.js

@@ -6,7 +6,7 @@
  * conforming to `StorageAdapter`.
  *
  * @design @.aiwg/architecture/storage-design.md
- * @schema @.aiwg/architecture/schemas/storage.config.v1.json
+ * @schema @schemas/storage/storage.config.v1.schema.json
  * @issue #934
  * @issue #953
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwg/cli",
-  "version": "2026.8.28",
+  "version": "2026.9.1",
   "description": "Lightweight AIWG CLI for signed, versioned web-backed resources.",
   "type": "module",
   "license": "MIT",
@@ -28,12 +28,14 @@
     "bin/",
     "agentic/code/providers/",
     "schemas/security/",
+    "schemas/dataset/",
     "dist/src/",
     "!dist/**/*.d.ts",
     "!dist/**/*.map",
     "dist/src/api/index.d.ts",
     "dist/src/resources/index.d.ts",
     "dist/src/resources/web-release.d.ts",
+    "dist/src/dataset/**/*.d.ts",
     "tools/_resolve-impl.mjs",
     "tools/agents/deploy-agents.mjs",
     "tools/agents/providers/",
@@ -68,6 +70,7 @@
     "@fortemi/core": "2026.7.15",
     "@modelcontextprotocol/sdk": "^1.30.0",
     "ajv": "^8.20.0",
+    "ajv-formats": "^3.0.1",
     "chalk": "^4.1.2",
     "chokidar": "^4.0.3",
     "commander": "^12.1.0",

package/schemas/dataset/conformance-manifest.v1.schema.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://aiwg.io/schemas/dataset/conformance-manifest.v1.schema.json",
+  "title": "AIWG Dataset Intelligence Conformance Manifest v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["contract", "schemaVersion", "corpusVersion", "cells"],
+  "properties": {
+    "contract": { "const": "aiwg.dataset.conformance/v1" },
+    "schemaVersion": { "$ref": "#/$defs/version" },
+    "corpusVersion": { "$ref": "#/$defs/version" },
+    "cells": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/cell" } }
+  },
+  "$defs": {
+    "version": { "type": "string", "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+(?:[-+][0-9A-Za-z.-]+)?$" },
+    "digest": { "type": "string", "pattern": "^sha256:[0-9a-f]{64}$" },
+    "cell": {
+      "type": "object", "additionalProperties": false,
+      "required": ["id", "area", "requiredCapabilities", "sourceClass", "runtimeClass", "fixture", "expected", "maturity", "evidence", "resourceEnvelope"],
+      "properties": {
+        "id": { "type": "string", "pattern": "^[a-z0-9][a-z0-9.-]+$" },
+        "area": { "enum": ["adapter", "capability", "replay", "checkpoint", "provenance", "security", "offline", "parity", "standards", "migration"] },
+        "requiredCapabilities": { "type": "array", "items": { "type": "string", "minLength": 1 }, "uniqueItems": true },
+        "sourceClass": { "enum": ["synthetic", "file", "directory", "jsonl", "csv", "http", "cache", "fortemi"] },
+        "runtimeClass": { "enum": ["local", "fortemi-core", "fortemi-server"] },
+        "fixture": { "type": "object", "additionalProperties": false, "required": ["path", "digest", "revision"], "properties": { "path": { "type": "string", "pattern": "^test/fixtures/dataset-intelligence/" }, "digest": { "$ref": "#/$defs/digest" }, "revision": { "$ref": "#/$defs/version" } } },
+        "expected": { "type": "object", "additionalProperties": false, "required": ["result"], "properties": { "result": { "enum": ["pass", "reject", "pending"] }, "diagnostic": { "type": "string", "minLength": 1 } } },
+        "maturity": { "enum": ["experimental", "qualified", "stable"] },
+        "evidence": { "type": "array", "minItems": 1, "items": { "enum": ["fixture", "real-source", "cross-repo", "live-qualification"] }, "uniqueItems": true },
+        "resourceEnvelope": { "type": "object", "additionalProperties": false, "required": ["maxBytes", "maxRecords", "maxDurationMs"], "properties": { "maxBytes": { "type": "integer", "minimum": 1 }, "maxRecords": { "type": "integer", "minimum": 1 }, "maxDurationMs": { "type": "integer", "minimum": 1 } } },
+        "liveAuthorizationRequired": { "type": "boolean" }
+      }
+    }
+  }
+}

package/schemas/dataset/conformance-receipt.v1.schema.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://aiwg.io/schemas/dataset/conformance-receipt.v1.schema.json",
+  "title": "AIWG Dataset Intelligence Conformance Receipt v1",
+  "type": "object", "additionalProperties": false,
+  "required": ["contract", "schemaVersion", "corpusVersion", "manifestDigest", "resultDigest", "bindings", "startedAt", "endedAt", "results", "summary"],
+  "properties": {
+    "contract": { "const": "aiwg.dataset.conformance/v1" }, "schemaVersion": { "$ref": "#/$defs/version" }, "corpusVersion": { "$ref": "#/$defs/version" },
+    "manifestDigest": { "$ref": "#/$defs/digest" }, "resultDigest": { "$ref": "#/$defs/digest" },
+    "startedAt": { "$ref": "#/$defs/time" }, "endedAt": { "$ref": "#/$defs/time" },
+    "bindings": { "$ref": "#/$defs/bindings" },
+    "results": { "type": "array", "items": { "$ref": "#/$defs/result" } },
+    "summary": { "type": "object", "additionalProperties": false, "required": ["passed", "failed", "pending", "stableEligible"], "properties": { "passed": { "type": "integer", "minimum": 0 }, "failed": { "type": "integer", "minimum": 0 }, "pending": { "type": "integer", "minimum": 0 }, "stableEligible": { "type": "boolean" } } }
+  },
+  "$defs": {
+    "version": { "type": "string", "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+(?:[-+][0-9A-Za-z.-]+)?$" }, "digest": { "type": "string", "pattern": "^sha256:[0-9a-f]{64}$" }, "time": { "type": "string", "format": "date-time", "pattern": "Z$" },
+    "digestMap": { "type": "object", "minProperties": 1, "additionalProperties": { "$ref": "#/$defs/digest" } },
+    "bindings": { "type": "object", "additionalProperties": false, "required": ["aiwgCommit", "packageDigests", "schemaDigests", "fixtureDigest", "configurationDigest"], "properties": { "aiwgCommit": { "type": "string", "pattern": "^(?:[0-9a-f]{40}|sha256:[0-9a-f]{64})$" }, "fortemiCommit": { "type": "string", "pattern": "^[0-9a-f]{40}$" }, "packageDigests": { "$ref": "#/$defs/digestMap" }, "schemaDigests": { "$ref": "#/$defs/digestMap" }, "fixtureDigest": { "$ref": "#/$defs/digest" }, "descriptorDigest": { "$ref": "#/$defs/digest" }, "configurationDigest": { "$ref": "#/$defs/digest" } } },
+    "evidence": { "type": "object", "additionalProperties": false, "required": ["kind", "reference", "digest"], "properties": { "kind": { "enum": ["fixture", "real-source", "cross-repo", "live-qualification"] }, "reference": { "type": "string", "minLength": 1 }, "digest": { "$ref": "#/$defs/digest" } } },
+    "result": { "type": "object", "additionalProperties": false, "required": ["cellId", "status", "evidence", "observed"], "properties": { "cellId": { "type": "string", "minLength": 1 }, "status": { "enum": ["passed", "failed", "pending"] }, "diagnostic": { "type": "string", "minLength": 1 }, "evidence": { "type": "array", "items": { "$ref": "#/$defs/evidence" } }, "observed": { "type": "object", "additionalProperties": false, "required": ["networkAttempts"], "properties": { "records": { "type": "integer", "minimum": 0 }, "bytes": { "type": "integer", "minimum": 0 }, "durationMs": { "type": "integer", "minimum": 0 }, "networkAttempts": { "type": "integer", "minimum": 0 } } } } }
+  }
+}