@aiwg/cli 2026.9.0 → 2026.9.2

package/dist/src/dataset/projections.js

@@ -0,0 +1,192 @@
+import { computeLedgerEventDigest, createLedgerEvent } from './ledger.js';
+function result(profile, value, items) { return { value, loss: { profile, lossless: items.length === 0, items } }; }
+function loss(path, reason, severity = 'information', context) {
+    return {
+        path,
+        reason,
+        severity,
+        ...(context?.privacy ? { sourcePrivacy: context.privacy } : {}),
+        ...(context?.retentionPolicy ? { retentionPolicy: context.retentionPolicy } : {}),
+    };
+}
+function event(record, sequence, context) {
+    return createLedgerEvent({ eventId: `urn:aiwg:event:${encodeURIComponent(record.id)}`, sequence, recordedAt: context.recordedAt, producer: context.producer, ...(context.runId ? { runId: context.runId } : {}), record });
+}
+function fileLocator(path, line) { return line === undefined ? { scheme: 'file', value: path } : { scheme: 'line-column', value: path, line }; }
+const PRIVACY_ORDER = { public: 0, internal: 1, confidential: 2, restricted: 3 };
+export function preventPrivacyDowngrade(source, projected) {
+    if (PRIVACY_ORDER[projected] < PRIVACY_ORDER[source])
+        throw new Error(`PROVENANCE_PRIVACY_DOWNGRADE: ${source} cannot be projected as ${projected}`);
+}
+export function projectResearchProvenance(record, context) {
+    const privacy = context.privacy ?? 'internal';
+    const events = [];
+    events.push(event({ recordType: 'agent', id: record.agent.id, principalKind: record.agent.type === 'software_agent' ? 'software' : 'person' }, 1, context));
+    events.push(event({ recordType: 'entity', id: record.entity.id, entityType: record.entity.type, privacy, ...(context.retentionPolicy ? { retentionPolicy: context.retentionPolicy } : {}) }, 2, context));
+    events.push(event({ recordType: 'activity', id: record.activity.id, activityType: record.activity.type, startedAt: record.activity.startedAt, endedAt: record.activity.endedAt, ...(context.runId ? { runId: context.runId } : {}) }, 3, context));
+    for (const sourceId of record.relationships.wasDerivedFrom ?? []) {
+        if (!events.some((item) => item.record.id === sourceId))
+            events.push(event({ recordType: 'entity', id: sourceId, entityType: 'research-source', privacy, ...(context.retentionPolicy ? { retentionPolicy: context.retentionPolicy } : {}) }, events.length + 1, context));
+    }
+    if (record.relationships.wasGeneratedBy && record.relationships.wasGeneratedBy !== record.activity.id)
+        events.push(event({ recordType: 'activity', id: record.relationships.wasGeneratedBy, activityType: 'referenced-research-activity' }, events.length + 1, context));
+    for (const agentId of [record.relationships.wasAttributedTo, record.relationships.wasAssociatedWith]) {
+        if (agentId && !events.some((item) => item.record.id === agentId))
+            events.push(event({ recordType: 'agent', id: agentId, principalKind: 'software' }, events.length + 1, context));
+    }
+    const assertions = [];
+    if (record.relationships.wasGeneratedBy)
+        assertions.push({ subjectId: record.entity.id, predicate: 'wasGeneratedBy', objectId: record.relationships.wasGeneratedBy, activityId: record.activity.id });
+    for (const sourceId of record.relationships.wasDerivedFrom ?? [])
+        assertions.push({ subjectId: record.entity.id, predicate: 'wasDerivedFrom', objectId: sourceId, activityId: record.activity.id });
+    if (record.relationships.wasAttributedTo)
+        assertions.push({ subjectId: record.entity.id, predicate: 'wasAttributedTo', objectId: record.relationships.wasAttributedTo });
+    if (record.relationships.wasAssociatedWith)
+        assertions.push({ subjectId: record.activity.id, predicate: 'wasAssociatedWith', objectId: record.relationships.wasAssociatedWith, activityId: record.activity.id });
+    for (const [index, assertion] of assertions.entries())
+        events.push(event({ recordType: 'assertion', id: `assertion:${record.id}:${index + 1}`, ...assertion, basis: 'imported', evidenceIds: [], privacy, ...(context.retentionPolicy ? { retentionPolicy: context.retentionPolicy } : {}) }, events.length + 1, context));
+    return result('research-provenance/v1', events, [loss('/entity/attributes', 'arbitrary research entity attributes are not in the canonical vocabulary', 'information', context), loss('/activity/attributes', 'arbitrary research activity attributes require a governed extension', 'information', context)]);
+}
+export function projectMarketplaceProvenance(graph, context) {
+    const privacy = context.privacy ?? 'internal';
+    const events = [];
+    const items = [];
+    let sequence = 1;
+    for (const agent of graph.agents)
+        events.push(event({ recordType: 'agent', id: agent.id, principalKind: agent.type === 'catalog' ? 'service' : agent.type }, sequence++, context));
+    for (const entity of graph.entities)
+        events.push(event({ recordType: 'entity', id: entity.id, entityType: entity.type, privacy, ...(context.retentionPolicy ? { retentionPolicy: context.retentionPolicy } : {}), ...(entity.digest ? { digest: { algorithm: 'sha256', value: entity.digest.replace(/^sha256:/, '') } } : {}) }, sequence++, context));
+    for (const activity of graph.activities)
+        events.push(event({ recordType: 'activity', id: activity.id, activityType: activity.type, startedAt: activity.startedAt, endedAt: activity.endedAt }, sequence++, context));
+    for (const relation of graph.relations)
+        events.push(event({ recordType: 'assertion', id: `marketplace:${sequence}:${relation.subject}:${relation.object}`, subjectId: relation.subject, predicate: relation.type, objectId: relation.object, basis: 'imported', evidenceIds: [], privacy, ...(context.retentionPolicy ? { retentionPolicy: context.retentionPolicy } : {}) }, sequence++, context));
+    if (graph.entities.some((entry) => entry.attributes))
+        items.push(loss('/entities/*/attributes', 'non-core marketplace attributes require a governed extension', 'information', context));
+    return result('marketplace-provenance/v1', events, items);
+}
+export function projectFortemiProvenance(record, context) {
+    const privacy = record.privacy.classification === 'public' ? 'public' : record.privacy.classification === 'private' ? 'confidential' : 'internal';
+    const events = [];
+    const items = [];
+    let sequence = 1;
+    events.push(event({ recordType: 'agent', id: context.producer.id, principalKind: 'software', version: context.producer.version }, sequence++, context));
+    events.push(event({ recordType: 'entity', id: record.id, entityType: record.type, revision: record.source.checksum, privacy, ...(context.retentionPolicy ? { retentionPolicy: context.retentionPolicy } : {}) }, sequence++, context));
+    const agentIds = new Set((record.provenance_events ?? []).flatMap((item) => item.agent ? [item.agent] : []));
+    agentIds.delete(context.producer.id);
+    for (const id of agentIds)
+        events.push(event({ recordType: 'agent', id, principalKind: 'software' }, sequence++, context));
+    for (const item of record.provenance_events ?? []) {
+        const activityId = item.id ?? `activity:${record.id}:${sequence}`;
+        events.push(event({ recordType: 'activity', id: activityId, activityType: item.activity, startedAt: item.started_at, endedAt: item.ended_at, ...(context.runId ? { runId: context.runId } : {}) }, sequence++, context));
+        if (item.agent)
+            events.push(event({ recordType: 'assertion', id: `assertion:${activityId}:agent`, subjectId: activityId, predicate: 'wasAssociatedWith', objectId: item.agent, basis: 'imported', evidenceIds: [], privacy, ...(context.retentionPolicy ? { retentionPolicy: context.retentionPolicy } : {}) }, sequence++, context));
+        if (item.attributes)
+            items.push(loss(`/provenance_events/${activityId}/attributes`, 'Fortemi activity attributes require a governed extension', 'information', { ...context, privacy }));
+    }
+    const sourceEntities = new Set();
+    for (const item of record.provenance) {
+        const sourceEntityId = `urn:aiwg:source:${encodeURIComponent(item.path)}`;
+        if (!sourceEntities.has(sourceEntityId)) {
+            events.push(event({ recordType: 'entity', id: sourceEntityId, entityType: 'source-record', privacy, ...(context.retentionPolicy ? { retentionPolicy: context.retentionPolicy } : {}) }, sequence++, context));
+            sourceEntities.add(sourceEntityId);
+        }
+        const evidenceId = `evidence:${record.id}:${sequence}`;
+        events.push(event({ recordType: 'evidence', id: evidenceId, source: fileLocator(item.path), target: { scheme: 'json-pointer', value: record.id, field: item.field }, method: `fortemi-field-provenance:${item.source}`, confidence: item.confidence === 'source' || item.confidence === 'reviewed' ? 1 : 0.5, privacy, ...(context.retentionPolicy ? { retentionPolicy: context.retentionPolicy } : {}), ...(context.runId ? { runId: context.runId } : {}), responsibleAgentId: context.producer.id, observedAt: context.recordedAt }, sequence++, context));
+        events.push(event({ recordType: 'assertion', id: `assertion:${record.id}:${sequence}`, subjectId: record.id, predicate: 'wasDerivedFrom', objectId: sourceEntityId, basis: context.runId ? 'observed' : 'imported', evidenceIds: [evidenceId], ...(context.runId ? { runId: context.runId } : {}), field: item.field, privacy, ...(context.retentionPolicy ? { retentionPolicy: context.retentionPolicy } : {}) }, sequence++, context));
+    }
+    items.push(loss('/search', 'search projection is not provenance', 'information', { ...context, privacy }));
+    if (record.relationships.length)
+        items.push(loss('/relationships', 'relationships require separate evidence-bearing conversion when source evidence is absent', 'semantic', { ...context, privacy }));
+    return result('fortemi-index-export/v2', events, items);
+}
+export function projectOperationalState(state, recordId, context) {
+    const items = [];
+    const privacy = context.privacy ?? 'internal';
+    const agentId = state.observer ?? context.producer.id;
+    const locator = state.evidence_path ? fileLocator(state.evidence_path) : state.evidence_url ? { scheme: 'uri', value: state.evidence_url } : undefined;
+    if (!locator)
+        items.push(loss('/evidence', 'operational state has no evidence locator', 'semantic', context));
+    if (state.supersedes?.length)
+        items.push(loss('/supersedes', 'referenced operational revisions require separately imported ledger entities', 'semantic', context));
+    if (state.contradicts?.length)
+        items.push(loss('/contradicts', 'referenced operational revisions require separately imported ledger entities', 'semantic', context));
+    const events = [event({ recordType: 'agent', id: agentId, principalKind: 'software' }, 1, context), event({ recordType: 'entity', id: recordId, entityType: state.source_kind ?? 'operational-state', privacy, ...(context.retentionPolicy ? { retentionPolicy: context.retentionPolicy } : {}) }, 2, context)];
+    if (locator)
+        events.push(event({ recordType: 'evidence', id: `evidence:${recordId}`, source: locator, method: 'operational-observation', confidence: state.confidence === 'source' || state.confidence === 'reviewed' ? 1 : 0.5, privacy, ...(context.retentionPolicy ? { retentionPolicy: context.retentionPolicy } : {}), ...(context.runId ? { runId: context.runId } : {}), responsibleAgentId: agentId, observedAt: state.observed_at ?? context.recordedAt }, 3, context));
+    return result('operational-state/v1', events, items);
+}
+export function projectMentionEdge(edge, context) {
+    const privacy = context.privacy ?? 'internal';
+    const agentId = context.producer.id;
+    return result('mention-edge/v1', [
+        event({ recordType: 'agent', id: agentId, principalKind: 'software', version: context.producer.version }, 1, context),
+        event({ recordType: 'entity', id: edge.sourcePath, entityType: 'file', privacy, ...(context.retentionPolicy ? { retentionPolicy: context.retentionPolicy } : {}) }, 2, context),
+        event({ recordType: 'entity', id: edge.targetPath, entityType: 'file', privacy, ...(context.retentionPolicy ? { retentionPolicy: context.retentionPolicy } : {}) }, 3, context),
+        event({ recordType: 'evidence', id: `evidence:mention:${edge.sourcePath}:${edge.targetPath}`, source: fileLocator(edge.sourcePath, edge.line), target: fileLocator(edge.targetPath), method: edge.method ?? 'mention', confidence: edge.confidence ?? 1, privacy, ...(context.retentionPolicy ? { retentionPolicy: context.retentionPolicy } : {}), ...(context.runId ? { runId: context.runId } : {}), responsibleAgentId: agentId, observedAt: context.recordedAt }, 4, context),
+        event({ recordType: 'assertion', id: `assertion:mention:${edge.sourcePath}:${edge.targetPath}`, subjectId: edge.sourcePath, predicate: edge.method === 'markdown-link' ? 'links-to' : 'mentions', objectId: edge.targetPath, basis: 'inferred', evidenceIds: [`evidence:mention:${edge.sourcePath}:${edge.targetPath}`], ...(context.runId ? { runId: context.runId } : {}), privacy, ...(context.retentionPolicy ? { retentionPolicy: context.retentionPolicy } : {}) }, 5, context),
+    ], []);
+}
+export function projectSdlcTraceLink(link, context) {
+    const projected = projectMentionEdge({ sourcePath: link.targetPath, targetPath: link.requirementId, method: 'mention', line: link.line, confidence: link.confidence }, context);
+    const assertion = projected.value.at(-1);
+    const observed = link.verified && context.runId !== undefined;
+    assertion.record = { ...assertion.record, predicate: `implements:${link.targetType}`, basis: observed ? 'observed' : 'inferred' };
+    const { eventDigest: _eventDigest, ...content } = assertion;
+    assertion.eventDigest = computeLedgerEventDigest(content);
+    return result('sdlc-traceability/v1', projected.value, [
+        ...projected.loss.items,
+        ...(link.verified && !context.runId ? [loss('/runId', 'verified SDLC link lacks run identity and remains inferred', 'semantic', context)] : []),
+    ]);
+}
+export function projectLedgerToDependencyGraph(events) {
+    const graph = {};
+    const items = [];
+    for (const event of events)
+        if (event.record.recordType === 'assertion') {
+            const assertion = event.record;
+            graph[assertion.subjectId] ??= { upstream: [], downstream: [] };
+            graph[assertion.objectId] ??= { upstream: [], downstream: [] };
+            graph[assertion.subjectId].upstream.push({ path: assertion.objectId, type: assertion.predicate });
+            graph[assertion.objectId].downstream.push({ path: assertion.subjectId, type: assertion.predicate });
+            items.push({ ...loss(`/events/${event.eventId}`, 'DependencyGraph drops basis, evidence, run, field, privacy, and retention', 'semantic'), sourcePrivacy: assertion.privacy, ...(assertion.retentionPolicy ? { retentionPolicy: assertion.retentionPolicy } : {}) });
+        }
+    return result('dependency-graph/v1', graph, items);
+}
+export function projectLedgerToW3cProv(events) {
+    const value = { entity: {}, activity: {}, agent: {}, wasDerivedFrom: [], wasGeneratedBy: [], used: [], wasAssociatedWith: [], wasAttributedTo: [] };
+    const items = [];
+    for (const event of events) {
+        const record = event.record;
+        if (record.recordType === 'entity') {
+            value.entity[record.id] = { type: record.entityType, revision: record.revision, privacy: record.privacy };
+            if (record.digest || record.retentionPolicy)
+                items.push({ ...loss(`/records/${record.id}`, 'core W3C projection omits canonical digest or retention metadata', 'information'), sourcePrivacy: record.privacy, ...(record.retentionPolicy ? { retentionPolicy: record.retentionPolicy } : {}) });
+        }
+        else if (record.recordType === 'activity')
+            value.activity[record.id] = { type: record.activityType, startedAt: record.startedAt, endedAt: record.endedAt };
+        else if (record.recordType === 'agent')
+            value.agent[record.id] = { type: record.principalKind, version: record.version };
+        else if (record.recordType === 'evidence')
+            items.push({ ...loss(`/records/${record.id}`, 'core W3C relation view references evidence IDs but omits canonical locator and observation detail', 'information'), sourcePrivacy: record.privacy, ...(record.retentionPolicy ? { retentionPolicy: record.retentionPolicy } : {}) });
+        else if (record.recordType === 'assertion') {
+            if (record.predicate === 'wasDerivedFrom')
+                value.wasDerivedFrom.push({ generatedEntity: record.subjectId, usedEntity: record.objectId, evidence: record.evidenceIds });
+            else if (record.predicate === 'wasGeneratedBy')
+                value.wasGeneratedBy.push({ entity: record.subjectId, activity: record.objectId });
+            else if (record.predicate === 'used')
+                value.used.push({ activity: record.subjectId, entity: record.objectId, evidence: record.evidenceIds });
+            else if (record.predicate === 'wasAssociatedWith')
+                value.wasAssociatedWith.push({ activity: record.subjectId, agent: record.objectId });
+            else if (record.predicate === 'wasAttributedTo')
+                value.wasAttributedTo.push({ entity: record.subjectId, agent: record.objectId });
+            else
+                items.push(loss(`/records/${record.id}`, `predicate ${record.predicate} has no core W3C projection`, 'semantic'));
+            if (record.basis !== 'declared' || record.runId || record.field || record.retentionPolicy)
+                items.push({ ...loss(`/records/${record.id}/qualifiers`, 'core W3C relation view omits canonical basis, run, field, or retention qualifiers', 'information'), sourcePrivacy: record.privacy, ...(record.retentionPolicy ? { retentionPolicy: record.retentionPolicy } : {}) });
+        }
+        else if (record.recordType === 'correction' || record.recordType === 'supersession')
+            items.push(loss(`/records/${record.id}`, 'ledger history operation requires an extension namespace'));
+    }
+    return result('w3c-prov/core', value, items);
+}
+//# sourceMappingURL=projections.js.map

package/dist/src/dataset/schema-governance.d.ts

@@ -0,0 +1,71 @@
+import { SchemaResolver } from '../schema/index.js';
+import type { CompatibilityStatus } from '../schema/compatibility.js';
+import type { SchemaBinding, DatasetDiagnostic, Digest } from './types.js';
+export declare const DATASET_CONTRACT_SCHEMA_ID = "https://aiwg.io/schemas/dataset/dataset-contracts.v1.schema.json";
+export declare const DATASET_GOVERNANCE_SCHEMA_ID = "https://aiwg.io/schemas/dataset/dataset-schema-governance.v1.schema.json";
+export declare const DATASET_GOVERNANCE_VERSION: "aiwg.dataset-schema-governance/v1";
+export type DatasetBoundary = 'adapter-config' | 'discovered-record' | 'checkpoint' | 'processing-plan' | 'processing-run' | 'run-receipt' | 'lineage' | 'exchange';
+export interface DatasetSchemaCandidate {
+    schemaVersion: typeof DATASET_GOVERNANCE_VERSION;
+    kind: 'DatasetSchemaCandidate';
+    id: string;
+    status: 'candidate';
+    sourceRevisionId: string;
+    inferredSchema: Record<string, unknown>;
+    inferredSchemaDigest: Digest;
+    inference: {
+        method: string;
+        tool: string;
+        toolVersion: string;
+        runId?: string;
+    };
+    observedAt: string;
+}
+export interface DatasetSchemaPromotionReceipt {
+    schemaVersion: typeof DATASET_GOVERNANCE_VERSION;
+    kind: 'DatasetSchemaPromotionReceipt';
+    id: string;
+    status: 'promoted';
+    candidateId: string;
+    candidateDigest: Digest;
+    promotedSchema: Required<SchemaBinding>;
+    reviewer: string;
+    reviewedAt: string;
+    decisionEvidence: string;
+    compatibility: {
+        status: CompatibilityStatus;
+        baseline?: string;
+        reasons: string[];
+    };
+}
+export interface DatasetSchemaImpactTarget {
+    target: 'adapter' | 'checkpoint-state' | 'processing-plan' | 'index' | 'derived-artifact' | 'consumer';
+    disposition: 'compatible' | 'review-required' | 'migration-required';
+    reason: string;
+}
+export interface DatasetSchemaImpactReport {
+    schemaVersion: typeof DATASET_GOVERNANCE_VERSION;
+    kind: 'DatasetSchemaImpactReport';
+    schemaId: string;
+    baseline: string;
+    compatibility: {
+        status: CompatibilityStatus;
+        reasons: string[];
+    };
+    targets: DatasetSchemaImpactTarget[];
+}
+export type DatasetSchemaGovernanceRecord = DatasetSchemaCandidate | DatasetSchemaPromotionReceipt | DatasetSchemaImpactReport;
+export declare function createDatasetSchemaCandidate(input: Omit<DatasetSchemaCandidate, 'schemaVersion' | 'kind' | 'status' | 'inferredSchemaDigest'>): DatasetSchemaCandidate;
+export declare function promoteDatasetSchemaCandidate(candidate: DatasetSchemaCandidate, review: Omit<DatasetSchemaPromotionReceipt, 'schemaVersion' | 'kind' | 'status' | 'candidateId' | 'candidateDigest'>): DatasetSchemaPromotionReceipt;
+export declare function assessDatasetSchemaImpact(schemaId: string, baseline: string, before: unknown, after: unknown): DatasetSchemaImpactReport;
+export declare function validateDatasetGovernanceRecord(value: unknown): DatasetDiagnostic[];
+/** Catalog-backed validation for every dataset trust boundary. */
+export declare class DatasetBoundaryValidator {
+    readonly rootDir: string;
+    readonly resolver: SchemaResolver;
+    private readonly validator;
+    constructor(rootDir?: string);
+    validate(boundary: DatasetBoundary, binding: SchemaBinding, value: unknown): DatasetDiagnostic[];
+    validateBinding(boundary: DatasetBoundary, binding: SchemaBinding): DatasetDiagnostic[];
+}
+//# sourceMappingURL=schema-governance.d.ts.map

package/dist/src/dataset/schema-governance.js

@@ -0,0 +1,135 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import { analyzeBackwardCompatibility, loadSchemaCatalog, SchemaResolver, SchemaValidator } from '../schema/index.js';
+export const DATASET_CONTRACT_SCHEMA_ID = 'https://aiwg.io/schemas/dataset/dataset-contracts.v1.schema.json';
+export const DATASET_GOVERNANCE_SCHEMA_ID = 'https://aiwg.io/schemas/dataset/dataset-schema-governance.v1.schema.json';
+export const DATASET_GOVERNANCE_VERSION = 'aiwg.dataset-schema-governance/v1';
+function packageRoot(start) {
+    let current = resolve(start);
+    for (;;) {
+        try {
+            const pkg = JSON.parse(readFileSync(join(current, 'package.json'), 'utf8'));
+            // The release packager renames the installed package to `@aiwg/cli`.
+            // Keep schema lookup valid in both the source and packaged layouts.
+            if (pkg.name === 'aiwg' || pkg.name === '@aiwg/cli')
+                return current;
+        }
+        catch { /* keep walking */ }
+        const parent = dirname(current);
+        if (parent === current)
+            throw new Error('dataset schema governance: could not locate package root');
+        current = parent;
+    }
+}
+const defaultRoot = packageRoot(dirname(fileURLToPath(import.meta.url)));
+const governanceSchema = JSON.parse(readFileSync(join(defaultRoot, 'schemas/dataset/dataset-schema-governance.v1.schema.json'), 'utf8'));
+const governanceAjv = new Ajv2020({ strict: true, allErrors: true });
+addFormats(governanceAjv);
+const validateGovernanceSchema = governanceAjv.compile(governanceSchema);
+function diagnostic(code, message, path) {
+    return { code, message, ...(path ? { path } : {}) };
+}
+function sha256(value) {
+    const canonical = JSON.stringify(canonicalize(value));
+    return { algorithm: 'sha256', value: createHash('sha256').update(canonical).digest('hex') };
+}
+function canonicalize(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (typeof value !== 'object' || value === null)
+        return value;
+    return Object.fromEntries(Object.keys(value).sort().map(key => [key, canonicalize(value[key])]));
+}
+export function createDatasetSchemaCandidate(input) {
+    return {
+        schemaVersion: DATASET_GOVERNANCE_VERSION,
+        kind: 'DatasetSchemaCandidate',
+        status: 'candidate',
+        ...input,
+        inferredSchemaDigest: sha256(input.inferredSchema),
+    };
+}
+export function promoteDatasetSchemaCandidate(candidate, review) {
+    if (candidate.status !== 'candidate')
+        throw new Error('DATASET_SCHEMA_NOT_CANDIDATE');
+    const actual = sha256(candidate.inferredSchema);
+    if (actual.value !== candidate.inferredSchemaDigest.value)
+        throw new Error('DATASET_SCHEMA_CANDIDATE_DIGEST_MISMATCH');
+    if (!review.reviewer || !review.decisionEvidence)
+        throw new Error('DATASET_SCHEMA_REVIEW_REQUIRED');
+    if (!review.promotedSchema.digest)
+        throw new Error('DATASET_SCHEMA_BINDING_DIGEST_REQUIRED');
+    if (review.compatibility.status === 'unknown' && review.compatibility.reasons.length === 0)
+        throw new Error('DATASET_SCHEMA_COMPATIBILITY_EVIDENCE_REQUIRED');
+    return {
+        schemaVersion: DATASET_GOVERNANCE_VERSION,
+        kind: 'DatasetSchemaPromotionReceipt',
+        status: 'promoted',
+        candidateId: candidate.id,
+        candidateDigest: candidate.inferredSchemaDigest,
+        ...review,
+    };
+}
+export function assessDatasetSchemaImpact(schemaId, baseline, before, after) {
+    const compatibility = analyzeBackwardCompatibility(before, after);
+    const disposition = compatibility.status === 'compatible' ? 'compatible' : compatibility.status === 'breaking' ? 'migration-required' : 'review-required';
+    const targets = ['adapter', 'checkpoint-state', 'processing-plan', 'index', 'derived-artifact', 'consumer'];
+    return {
+        schemaVersion: DATASET_GOVERNANCE_VERSION,
+        kind: 'DatasetSchemaImpactReport',
+        schemaId,
+        baseline,
+        compatibility: { status: compatibility.status, reasons: compatibility.reasons },
+        targets: targets.map(target => ({ target, disposition, reason: `${target} must be assessed against ${schemaId}; ${compatibility.reasons.join('; ')}` })),
+    };
+}
+export function validateDatasetGovernanceRecord(value) {
+    const valid = validateGovernanceSchema(value);
+    if (!valid)
+        return (validateGovernanceSchema.errors ?? []).map((error) => diagnostic('DATASET_GOVERNANCE_SCHEMA_INVALID', error.message ?? 'governance record is invalid', error.instancePath || '/'));
+    const record = value;
+    if (record.kind === 'DatasetSchemaCandidate') {
+        const actual = sha256(record.inferredSchema);
+        if (actual.value !== record.inferredSchemaDigest.value)
+            return [diagnostic('DATASET_SCHEMA_CANDIDATE_DIGEST_MISMATCH', 'candidate digest does not match the inferred schema', '/inferredSchemaDigest')];
+    }
+    return [];
+}
+/** Catalog-backed validation for every dataset trust boundary. */
+export class DatasetBoundaryValidator {
+    rootDir;
+    resolver;
+    validator;
+    constructor(rootDir = defaultRoot) {
+        this.rootDir = rootDir;
+        const loaded = loadSchemaCatalog({ rootDir });
+        if (!loaded.valid || !loaded.catalog)
+            throw new Error(`DATASET_SCHEMA_CATALOG_INVALID: ${loaded.diagnostics.map(item => item.code).join(',')}`);
+        this.resolver = new SchemaResolver(loaded.catalog, { rootDir });
+        this.validator = new SchemaValidator(this.resolver, { rootDir });
+    }
+    validate(boundary, binding, value) {
+        const bindingDiagnostics = this.validateBinding(boundary, binding);
+        if (bindingDiagnostics.length)
+            return bindingDiagnostics;
+        return this.validator.validate(binding.id, value).diagnostics.map(item => diagnostic(item.code, item.message, item.path));
+    }
+    validateBinding(boundary, binding) {
+        const entry = this.resolver.resolve(binding.id);
+        if (!entry)
+            return [diagnostic('DATASET_SCHEMA_BINDING_UNKNOWN', `unknown schema binding ${binding.id}`, '/schema/id')];
+        if (binding.version !== entry.artifact.version)
+            return [diagnostic('DATASET_SCHEMA_BINDING_VERSION_MISMATCH', `schema binding version ${binding.version} does not match governed version ${entry.artifact.version}`, '/schema/version')];
+        if (!binding.digest)
+            return [diagnostic('DATASET_SCHEMA_BINDING_DIGEST_REQUIRED', `schema digest is required at ${boundary} boundary`, '/schema/digest')];
+        const expected = entry.digest?.replace(/^sha256:/, '');
+        if (!expected || binding.digest.algorithm !== 'sha256' || binding.digest.value !== expected)
+            return [diagnostic('DATASET_SCHEMA_BINDING_DIGEST_MISMATCH', `schema digest does not match governed authority at ${boundary} boundary`, '/schema/digest')];
+        return [];
+    }
+}
+//# sourceMappingURL=schema-governance.js.map

package/dist/src/dataset/standards-types.d.ts

@@ -0,0 +1,66 @@
+import type { RunLedgerSnapshot } from './ledger-types.js';
+export declare const STANDARDS_EXCHANGE_VERSION: "aiwg.dataset-standards-exchange/v1";
+export type StandardId = 'w3c-prov-json' | 'openlineage' | 'dcat' | 'croissant' | 'data-package' | 'ro-crate';
+export type ProfileDirection = 'import' | 'export' | 'round-trip';
+export type ProfileMaturity = 'stable' | 'candidate' | 'descriptor-only';
+export type UnknownExtensionPolicy = 'preserve' | 'report' | 'reject';
+export interface GovernedSchemaReference {
+    id: string;
+    version: string;
+}
+export interface StandardsProfileDescriptor {
+    id: string;
+    standard: StandardId;
+    version: string;
+    direction: ProfileDirection;
+    inputSchema: GovernedSchemaReference;
+    outputSchema: GovernedSchemaReference;
+    mappingImplementation: string;
+    supportedFeatures: readonly string[];
+    roundTripFields: readonly string[];
+    extensionNamespace: string;
+    unknownExtensionPolicy: UnknownExtensionPolicy;
+    maturity: ProfileMaturity;
+    useCases: readonly string[];
+    coverageBoundary: string;
+}
+export type LossCategory = 'mapped' | 'omitted' | 'synthesized' | 'unsupported' | 'extension-carried';
+export interface StandardsLossItem {
+    category: LossCategory;
+    sourcePath?: string;
+    targetPath?: string;
+    reason: string;
+    extensionNamespace?: string;
+}
+export interface StandardsLossReport {
+    schemaVersion: typeof STANDARDS_EXCHANGE_VERSION;
+    profileId: string;
+    profileVersion: string;
+    direction: 'import' | 'export';
+    sourceDigest: {
+        algorithm: 'sha256';
+        value: string;
+    };
+    items: StandardsLossItem[];
+    counts: Record<LossCategory, number>;
+}
+export interface StandardsExchange<T> {
+    schemaVersion: typeof STANDARDS_EXCHANGE_VERSION;
+    profile: {
+        id: string;
+        version: string;
+    };
+    value: T;
+    loss: StandardsLossReport;
+}
+export interface StandardAdapter {
+    descriptor: StandardsProfileDescriptor;
+    importDocument(document: unknown): StandardsExchange<RunLedgerSnapshot>;
+    exportDocument(snapshot: RunLedgerSnapshot): StandardsExchange<unknown>;
+}
+export type StandardsDiagnosticCode = 'DATASET_STANDARD_PROFILE_NOT_FOUND' | 'DATASET_STANDARD_UNSUPPORTED_VERSION' | 'DATASET_STANDARD_UNSUPPORTED_CAPABILITY' | 'DATASET_STANDARD_INVALID_INPUT' | 'DATASET_STANDARD_INVALID_OUTPUT' | 'DATASET_STANDARD_EXTENSION_COLLISION' | 'DATASET_STANDARD_IDENTITY_CONFLICT' | 'DATASET_STANDARD_EVIDENCE_ESCALATION';
+export declare class StandardsProfileError extends Error {
+    readonly code: StandardsDiagnosticCode;
+    constructor(code: StandardsDiagnosticCode, message: string);
+}
+//# sourceMappingURL=standards-types.d.ts.map

package/dist/src/dataset/standards-types.js

@@ -0,0 +1,10 @@
+export const STANDARDS_EXCHANGE_VERSION = 'aiwg.dataset-standards-exchange/v1';
+export class StandardsProfileError extends Error {
+    code;
+    constructor(code, message) {
+        super(`${code}: ${message}`);
+        this.code = code;
+        this.name = 'StandardsProfileError';
+    }
+}
+//# sourceMappingURL=standards-types.js.map

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

@@ -0,0 +1,13 @@
+import type { RunLedgerSnapshot } from './ledger-types.js';
+import { type StandardAdapter, type StandardId, type StandardsExchange, type StandardsProfileDescriptor } from './standards-types.js';
+export declare const PROV_PROFILE: StandardsProfileDescriptor;
+export declare const OPENLINEAGE_PROFILE: StandardsProfileDescriptor;
+export declare const DESCRIPTOR_ONLY_PROFILES: readonly StandardsProfileDescriptor[];
+export declare const provAdapter: StandardAdapter;
+export declare const openLineageAdapter: StandardAdapter;
+export declare const standardsProfiles: readonly StandardsProfileDescriptor[];
+export declare function listStandardsProfiles(): readonly StandardsProfileDescriptor[];
+export declare function resolveStandardsProfile(standard: StandardId, version: string, capability?: 'import' | 'export'): StandardAdapter;
+export declare function importStandard(standard: StandardId, version: string, document: unknown): StandardsExchange<RunLedgerSnapshot>;
+export declare function exportStandard(standard: StandardId, version: string, snapshot: RunLedgerSnapshot): StandardsExchange<unknown>;
+//# sourceMappingURL=standards.d.ts.map