@cleocode/lafs-protocol 1.4.0 → 1.4.1

package/README.md

@@ -4,7 +4,7 @@
 
 LAFS defines a standard envelope format for structured responses from LLM-powered agents and tools. It complements transport protocols like [MCP](https://modelcontextprotocol.io/) and [A2A](https://github.com/google/A2A) by standardizing what comes back — not how it gets there.
 
-**Current version:** 1.4.0 | [📚 Documentation](https://codluv.gitbook.io/lafs-protocol/) | [Spec](lafs.md) | [Migration Guides](migrations/)
+**Current version:** 1.4.1 | [📚 Documentation](https://codluv.gitbook.io/lafs-protocol/) | [Spec](lafs.md) | [Migration Guides](migrations/)
 
 [![GitBook](https://img.shields.io/badge/docs-gitbook-blue)](https://codluv.gitbook.io/lafs-protocol/)
 [![npm](https://img.shields.io/npm/v/@cleocode/lafs-protocol)](https://www.npmjs.com/package/@cleocode/lafs-protocol)

package/dist/schemas/v1/conformance-profiles.json

@@ -0,0 +1,35 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "version": "1.0.0",
+    "tiers": {
+        "core": [
+            "envelope_schema_valid",
+            "envelope_invariants",
+            "error_code_registered"
+        ],
+        "standard": [
+            "envelope_schema_valid",
+            "envelope_invariants",
+            "error_code_registered",
+            "transport_mapping_consistent",
+            "meta_mvi_present",
+            "meta_strict_present",
+            "strict_mode_behavior",
+            "pagination_mode_consistent",
+            "strict_mode_enforced"
+        ],
+        "complete": [
+            "envelope_schema_valid",
+            "envelope_invariants",
+            "error_code_registered",
+            "transport_mapping_consistent",
+            "context_mutation_failure",
+            "context_preservation_valid",
+            "meta_mvi_present",
+            "meta_strict_present",
+            "strict_mode_behavior",
+            "pagination_mode_consistent",
+            "strict_mode_enforced"
+        ]
+    }
+}

package/dist/src/a2a/bindings/index.d.ts

@@ -29,3 +29,7 @@ export declare const A2A_ERROR_MAPPINGS: ReadonlyMap<A2AErrorType, ErrorCodeMapp
  */
 export declare function getErrorCodeMapping(errorType: A2AErrorType): ErrorCodeMapping;
 export { A2A_GRPC_ERROR_REASONS } from './grpc.js';
+export declare const SUPPORTED_A2A_VERSIONS: readonly ["1.0"];
+export declare const DEFAULT_A2A_VERSION: "1.0";
+export declare function parseA2AVersionHeader(headerValue: string | undefined): string[];
+export declare function negotiateA2AVersion(requestedVersions: string[]): string | null;

package/dist/src/a2a/bindings/index.js

@@ -52,3 +52,28 @@ export function getErrorCodeMapping(errorType) {
 // Also export A2A_GRPC_ERROR_REASONS for convenience (re-exported from grpc.ts via *)
 // but explicitly reference it here so the cross-binding module is self-documenting
 export { A2A_GRPC_ERROR_REASONS } from './grpc.js';
+// ============================================================================
+// Version Negotiation
+// ============================================================================
+export const SUPPORTED_A2A_VERSIONS = ['1.0'];
+export const DEFAULT_A2A_VERSION = '1.0';
+export function parseA2AVersionHeader(headerValue) {
+    if (!headerValue)
+        return [];
+    return headerValue
+        .split(',')
+        .map((v) => v.trim())
+        .filter(Boolean);
+}
+export function negotiateA2AVersion(requestedVersions) {
+    if (requestedVersions.length === 0) {
+        return DEFAULT_A2A_VERSION;
+    }
+    const supported = new Set(SUPPORTED_A2A_VERSIONS);
+    for (const version of requestedVersions) {
+        if (supported.has(version)) {
+            return version;
+        }
+    }
+    return null;
+}

package/dist/src/a2a/bridge.d.ts

@@ -6,7 +6,8 @@
  *
  * Reference: specs/external/specification.md
  */
-import type { Task, TaskState, TaskStatus, Artifact, Part, Message, AgentCard, MessageSendConfiguration, SendMessageResponse, SendMessageSuccessResponse, JSONRPCErrorResponse, AGENT_CARD_PATH, HTTP_EXTENSION_HEADER } from '@a2a-js/sdk';
+import { AGENT_CARD_PATH, HTTP_EXTENSION_HEADER } from '@a2a-js/sdk';
+import type { Task, TaskState, TaskStatus, Artifact, Part, Message, AgentCard, MessageSendConfiguration, SendMessageResponse, SendMessageSuccessResponse, JSONRPCErrorResponse } from '@a2a-js/sdk';
 import type { LAFSEnvelope } from '../types.js';
 /**
  * Configuration for LAFS A2A integration

package/dist/src/a2a/bridge.js

@@ -7,6 +7,10 @@
  * Reference: specs/external/specification.md
  */
 // ============================================================================
+// Imports - Use official A2A SDK types
+// ============================================================================
+import { AGENT_CARD_PATH, HTTP_EXTENSION_HEADER, } from '@a2a-js/sdk';
+// ============================================================================
 // Result Wrapper
 // ============================================================================
 /**
@@ -267,3 +271,16 @@ export function isExtensionRequired(agentCard, extensionUri) {
 export function getExtensionParams(agentCard, extensionUri) {
     return agentCard.capabilities?.extensions?.find(ext => ext.uri === extensionUri)?.params;
 }
+// ============================================================================
+// Constants
+// ============================================================================
+/**
+ * A2A Agent Card well-known path
+ * Reference: specs/external/agent-discovery.md
+ */
+export { AGENT_CARD_PATH };
+/**
+ * HTTP header for A2A Extensions
+ * Reference: specs/external/extensions.md
+ */
+export { HTTP_EXTENSION_HEADER };

package/dist/src/a2a/extensions.d.ts

@@ -17,7 +17,9 @@ export interface LafsExtensionParams {
     supportsContextLedger: boolean;
     supportsTokenBudgets: boolean;
     envelopeSchema: string;
+    kind?: ExtensionKind;
 }
+export type ExtensionKind = 'data-only' | 'profile' | 'method' | 'state-machine';
 /** Result of extension negotiation between client and agent */
 export interface ExtensionNegotiationResult {
     /** URIs requested by the client */
@@ -28,6 +30,8 @@ export interface ExtensionNegotiationResult {
     unsupported: string[];
     /** Agent-required URIs not present in client request */
     missingRequired: string[];
+    /** Activated extensions grouped by declared kind (when provided) */
+    activatedByKind: Partial<Record<ExtensionKind, string[]>>;
 }
 /**
  * Parse A2A-Extensions header value into URI array.
@@ -57,6 +61,19 @@ export interface BuildLafsExtensionOptions {
  * Suitable for inclusion in Agent Card capabilities.extensions[].
  */
 export declare function buildLafsExtension(options?: BuildLafsExtensionOptions): AgentExtension;
+export interface BuildExtensionOptions {
+    uri: string;
+    description: string;
+    required?: boolean;
+    kind: ExtensionKind;
+    params?: Record<string, unknown>;
+}
+export declare function buildExtension(options: BuildExtensionOptions): AgentExtension;
+export declare function isValidExtensionKind(kind: string): kind is ExtensionKind;
+export declare function validateExtensionDeclaration(extension: AgentExtension): {
+    valid: boolean;
+    error?: string;
+};
 /**
  * Error thrown when required A2A extensions are not supported by the client.
  * Code -32008 (not in SDK, which stops at -32007).

package/dist/src/a2a/extensions.js

@@ -18,6 +18,7 @@ export const A2A_EXTENSIONS_HEADER = 'A2A-Extensions';
  * Middleware checks both for SDK compatibility.
  */
 const SDK_EXTENSIONS_HEADER = 'x-a2a-extensions';
+const VALID_EXTENSION_KINDS = ['data-only', 'profile', 'method', 'state-machine'];
 // ============================================================================
 // Functions
 // ============================================================================
@@ -57,7 +58,21 @@ export function negotiateExtensions(requestedUris, agentExtensions) {
             missingRequired.push(ext.uri);
         }
     }
-    return { requested: requestedUris, activated, unsupported, missingRequired };
+    const activatedByKind = {};
+    for (const uri of activated) {
+        const ext = declared.get(uri);
+        const kind = ext?.params && typeof ext.params === 'object'
+            ? ext.params['kind']
+            : undefined;
+        if (typeof kind === 'string' && VALID_EXTENSION_KINDS.includes(kind)) {
+            const typedKind = kind;
+            if (!activatedByKind[typedKind]) {
+                activatedByKind[typedKind] = [];
+            }
+            activatedByKind[typedKind].push(uri);
+        }
+    }
+    return { requested: requestedUris, activated, unsupported, missingRequired, activatedByKind };
 }
 /**
  * Format activated extension URIs into header value.
@@ -79,9 +94,36 @@ export function buildLafsExtension(options) {
             supportsContextLedger: options?.supportsContextLedger ?? false,
             supportsTokenBudgets: options?.supportsTokenBudgets ?? false,
             envelopeSchema: options?.envelopeSchema ?? 'https://lafs.dev/schemas/v1/envelope.schema.json',
+            kind: 'profile',
         },
     };
 }
+export function buildExtension(options) {
+    return {
+        uri: options.uri,
+        description: options.description,
+        required: options.required ?? false,
+        params: {
+            kind: options.kind,
+            ...(options.params ?? {}),
+        },
+    };
+}
+export function isValidExtensionKind(kind) {
+    return VALID_EXTENSION_KINDS.includes(kind);
+}
+export function validateExtensionDeclaration(extension) {
+    const kind = extension.params && typeof extension.params === 'object'
+        ? extension.params['kind']
+        : undefined;
+    if (kind === undefined) {
+        return { valid: true };
+    }
+    if (typeof kind !== 'string' || !isValidExtensionKind(kind)) {
+        return { valid: false, error: `invalid extension kind: ${String(kind)}` };
+    }
+    return { valid: true };
+}
 // ============================================================================
 // Error Class
 // ============================================================================

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

@@ -31,7 +31,9 @@
 export { LafsA2AResult, createLafsArtifact, createTextArtifact, createFileArtifact, isExtensionRequired, getExtensionParams, AGENT_CARD_PATH, HTTP_EXTENSION_HEADER, } from './bridge.js';
 export { LAFS_EXTENSION_URI, A2A_EXTENSIONS_HEADER, parseExtensionsHeader, negotiateExtensions, formatExtensionsHeader, buildLafsExtension, ExtensionSupportRequiredError, extensionNegotiationMiddleware, } from './extensions.js';
 export type { LafsExtensionParams, ExtensionNegotiationResult, BuildLafsExtensionOptions, ExtensionNegotiationMiddlewareOptions, } from './extensions.js';
-export { TERMINAL_STATES, INTERRUPTED_STATES, VALID_TRANSITIONS, isValidTransition, isTerminalState, isInterruptedState, InvalidStateTransitionError, TaskImmutabilityError, TaskNotFoundError, TaskManager, attachLafsEnvelope, } from './task-lifecycle.js';
+export { TERMINAL_STATES, INTERRUPTED_STATES, VALID_TRANSITIONS, isValidTransition, isTerminalState, isInterruptedState, InvalidStateTransitionError, TaskImmutabilityError, TaskNotFoundError, TaskRefinementError, TaskManager, attachLafsEnvelope, } from './task-lifecycle.js';
+export { TaskEventBus, PushNotificationConfigStore, PushNotificationDispatcher, TaskArtifactAssembler, streamTaskEvents, } from './streaming.js';
+export type { TaskStreamEvent, StreamIteratorOptions, PushNotificationDeliveryResult, PushTransport, } from './streaming.js';
 export type { CreateTaskOptions, ListTasksOptions, ListTasksResult, } from './task-lifecycle.js';
 export * from './bindings/index.js';
 export type { LafsA2AConfig, LafsSendMessageParams, } from './bridge.js';

package/dist/src/a2a/index.js

@@ -37,7 +37,9 @@ LafsA2AResult,
 // Artifact helpers
 createLafsArtifact, createTextArtifact, createFileArtifact, 
 // Extension helpers
-isExtensionRequired, getExtensionParams, } from './bridge.js';
+isExtensionRequired, getExtensionParams, 
+// Constants
+AGENT_CARD_PATH, HTTP_EXTENSION_HEADER, } from './bridge.js';
 // ============================================================================
 // Extensions (T098)
 // ============================================================================
@@ -59,12 +61,16 @@ TERMINAL_STATES, INTERRUPTED_STATES, VALID_TRANSITIONS,
 // State functions
 isValidTransition, isTerminalState, isInterruptedState, 
 // Error classes
-InvalidStateTransitionError, TaskImmutabilityError, TaskNotFoundError, 
+InvalidStateTransitionError, TaskImmutabilityError, TaskNotFoundError, TaskRefinementError, 
 // Task manager
 TaskManager, 
 // LAFS integration
 attachLafsEnvelope, } from './task-lifecycle.js';
 // ============================================================================
+// Streaming and Async (T101)
+// ============================================================================
+export { TaskEventBus, PushNotificationConfigStore, PushNotificationDispatcher, TaskArtifactAssembler, streamTaskEvents, } from './streaming.js';
+// ============================================================================
 // Protocol Bindings (T100)
 // ============================================================================
 export * from './bindings/index.js';

package/dist/src/a2a/streaming.d.ts

@@ -0,0 +1,74 @@
+/**
+ * A2A streaming and async runtime primitives (T101).
+ *
+ * Provides an in-memory event bus for task status/artifact updates and
+ * push-notification config storage helpers.
+ */
+import type { Artifact, PushNotificationConfig, TaskArtifactUpdateEvent, TaskStatusUpdateEvent } from "@a2a-js/sdk";
+export type TaskStreamEvent = TaskStatusUpdateEvent | TaskArtifactUpdateEvent;
+type StreamListener = (event: TaskStreamEvent) => void;
+/**
+ * In-memory event bus for task lifecycle streaming events.
+ */
+export declare class TaskEventBus {
+    private history;
+    private listeners;
+    publishStatusUpdate(event: TaskStatusUpdateEvent): void;
+    publishArtifactUpdate(event: TaskArtifactUpdateEvent): void;
+    publish(event: TaskStreamEvent): void;
+    subscribe(taskId: string, listener: StreamListener): () => void;
+    getHistory(taskId: string): TaskStreamEvent[];
+}
+export interface StreamIteratorOptions {
+    timeoutMs?: number;
+}
+/**
+ * Build an async iterator for real-time task stream events.
+ */
+export declare function streamTaskEvents(bus: TaskEventBus, taskId: string, options?: StreamIteratorOptions): AsyncGenerator<TaskStreamEvent>;
+/**
+ * In-memory manager for async push-notification configs.
+ */
+export declare class PushNotificationConfigStore {
+    private configs;
+    set(taskId: string, configId: string, config: PushNotificationConfig): void;
+    get(taskId: string, configId: string): PushNotificationConfig | undefined;
+    list(taskId: string): PushNotificationConfig[];
+    delete(taskId: string, configId: string): boolean;
+}
+export interface PushNotificationDeliveryResult {
+    configId: string;
+    ok: boolean;
+    status?: number;
+    error?: string;
+}
+export type PushTransport = (input: string, init?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+}>;
+/**
+ * Deliver task updates to registered push-notification webhooks.
+ */
+export declare class PushNotificationDispatcher {
+    private readonly store;
+    private readonly transport;
+    constructor(store: PushNotificationConfigStore, transport?: PushTransport);
+    dispatch(taskId: string, event: TaskStreamEvent): Promise<PushNotificationDeliveryResult[]>;
+    private buildHeaders;
+}
+/**
+ * Applies append/lastChunk artifact deltas into task-local snapshots.
+ */
+export declare class TaskArtifactAssembler {
+    private artifacts;
+    applyUpdate(event: TaskArtifactUpdateEvent): Artifact;
+    get(taskId: string, artifactId: string): Artifact | undefined;
+    list(taskId: string): Artifact[];
+    private mergeArtifact;
+    private withLastChunk;
+}
+export {};

package/dist/src/a2a/streaming.js

@@ -0,0 +1,265 @@
+/**
+ * A2A streaming and async runtime primitives (T101).
+ *
+ * Provides an in-memory event bus for task status/artifact updates and
+ * push-notification config storage helpers.
+ */
+function resolveTaskId(event) {
+    const candidate = event;
+    const taskId = candidate.taskId ?? candidate.task?.id;
+    if (!taskId) {
+        throw new Error("Task stream event is missing task identifier");
+    }
+    return taskId;
+}
+/**
+ * In-memory event bus for task lifecycle streaming events.
+ */
+export class TaskEventBus {
+    history = new Map();
+    listeners = new Map();
+    publishStatusUpdate(event) {
+        this.publish(event);
+    }
+    publishArtifactUpdate(event) {
+        this.publish(event);
+    }
+    publish(event) {
+        const taskId = resolveTaskId(event);
+        const events = this.history.get(taskId) ?? [];
+        events.push(event);
+        this.history.set(taskId, events);
+        const listeners = this.listeners.get(taskId);
+        if (listeners) {
+            for (const listener of listeners) {
+                listener(event);
+            }
+        }
+    }
+    subscribe(taskId, listener) {
+        let set = this.listeners.get(taskId);
+        if (!set) {
+            set = new Set();
+            this.listeners.set(taskId, set);
+        }
+        set.add(listener);
+        return () => {
+            const active = this.listeners.get(taskId);
+            if (!active)
+                return;
+            active.delete(listener);
+            if (active.size === 0) {
+                this.listeners.delete(taskId);
+            }
+        };
+    }
+    getHistory(taskId) {
+        return [...(this.history.get(taskId) ?? [])];
+    }
+}
+/**
+ * Build an async iterator for real-time task stream events.
+ */
+export async function* streamTaskEvents(bus, taskId, options = {}) {
+    const queue = [];
+    let wakeUp = null;
+    const unsubscribe = bus.subscribe(taskId, (event) => {
+        queue.push(event);
+        if (wakeUp) {
+            wakeUp();
+            wakeUp = null;
+        }
+    });
+    const timeoutMs = options.timeoutMs ?? 30_000;
+    try {
+        // Emit existing history first for catch-up behavior.
+        for (const event of bus.getHistory(taskId)) {
+            yield event;
+        }
+        while (true) {
+            if (queue.length > 0) {
+                const event = queue.shift();
+                if (event) {
+                    yield event;
+                    continue;
+                }
+            }
+            await new Promise((resolve) => {
+                const timer = setTimeout(() => {
+                    if (wakeUp === resolve) {
+                        wakeUp = null;
+                    }
+                    resolve();
+                }, timeoutMs);
+                wakeUp = () => {
+                    clearTimeout(timer);
+                    resolve();
+                };
+            });
+        }
+    }
+    finally {
+        unsubscribe();
+    }
+}
+/**
+ * In-memory manager for async push-notification configs.
+ */
+export class PushNotificationConfigStore {
+    configs = new Map();
+    set(taskId, configId, config) {
+        let taskConfigs = this.configs.get(taskId);
+        if (!taskConfigs) {
+            taskConfigs = new Map();
+            this.configs.set(taskId, taskConfigs);
+        }
+        taskConfigs.set(configId, config);
+    }
+    get(taskId, configId) {
+        return this.configs.get(taskId)?.get(configId);
+    }
+    list(taskId) {
+        return [...(this.configs.get(taskId)?.values() ?? [])];
+    }
+    delete(taskId, configId) {
+        const taskConfigs = this.configs.get(taskId);
+        if (!taskConfigs) {
+            return false;
+        }
+        const removed = taskConfigs.delete(configId);
+        if (taskConfigs.size === 0) {
+            this.configs.delete(taskId);
+        }
+        return removed;
+    }
+}
+/**
+ * Deliver task updates to registered push-notification webhooks.
+ */
+export class PushNotificationDispatcher {
+    store;
+    transport;
+    constructor(store, transport = async (input, init) => {
+        if (typeof fetch !== "function") {
+            throw new Error("Global fetch is not available for push dispatch");
+        }
+        return fetch(input, init);
+    }) {
+        this.store = store;
+        this.transport = transport;
+    }
+    async dispatch(taskId, event) {
+        const configs = this.store.list(taskId);
+        if (configs.length === 0) {
+            return [];
+        }
+        const payload = {
+            taskId,
+            event,
+            timestamp: new Date().toISOString(),
+        };
+        const deliveries = configs.map(async (config, index) => {
+            const configId = config.id ?? `${taskId}:${index}`;
+            if (!config.url) {
+                return {
+                    configId,
+                    ok: false,
+                    error: "Push notification config is missing url",
+                };
+            }
+            const headers = this.buildHeaders(config);
+            try {
+                const response = await this.transport(config.url, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify(payload),
+                });
+                return {
+                    configId,
+                    ok: response.ok,
+                    status: response.status,
+                    ...(response.ok ? {} : { error: `HTTP ${response.status}` }),
+                };
+            }
+            catch (error) {
+                return {
+                    configId,
+                    ok: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        });
+        return Promise.all(deliveries);
+    }
+    buildHeaders(config) {
+        const headers = {
+            "content-type": "application/json",
+        };
+        if (config.token) {
+            headers["x-a2a-task-token"] = config.token;
+        }
+        const scheme = config.authentication?.schemes?.[0];
+        const credentials = config.authentication?.credentials;
+        if (scheme && credentials) {
+            headers.authorization = `${scheme} ${credentials}`;
+        }
+        else if (config.token) {
+            headers.authorization = `Bearer ${config.token}`;
+        }
+        return headers;
+    }
+}
+/**
+ * Applies append/lastChunk artifact deltas into task-local snapshots.
+ */
+export class TaskArtifactAssembler {
+    artifacts = new Map();
+    applyUpdate(event) {
+        if (!event.artifact?.artifactId) {
+            throw new Error("Task artifact update is missing artifactId");
+        }
+        const taskId = resolveTaskId(event);
+        const artifactId = event.artifact.artifactId;
+        let taskArtifacts = this.artifacts.get(taskId);
+        if (!taskArtifacts) {
+            taskArtifacts = new Map();
+            this.artifacts.set(taskId, taskArtifacts);
+        }
+        const prior = taskArtifacts.get(artifactId);
+        const merged = this.mergeArtifact(prior, event);
+        taskArtifacts.set(artifactId, merged);
+        return merged;
+    }
+    get(taskId, artifactId) {
+        return this.artifacts.get(taskId)?.get(artifactId);
+    }
+    list(taskId) {
+        return [...(this.artifacts.get(taskId)?.values() ?? [])];
+    }
+    mergeArtifact(prior, event) {
+        const next = event.artifact;
+        const append = Boolean(event.append);
+        const lastChunk = Boolean(event.lastChunk);
+        if (!append || !prior) {
+            return {
+                ...next,
+                metadata: this.withLastChunk(next.metadata, lastChunk),
+            };
+        }
+        return {
+            ...prior,
+            ...next,
+            parts: [...(prior.parts ?? []), ...(next.parts ?? [])],
+            metadata: this.withLastChunk({
+                ...(prior.metadata ?? {}),
+                ...(next.metadata ?? {}),
+            }, lastChunk),
+        };
+    }
+    withLastChunk(metadata, lastChunk) {
+        return {
+            ...(metadata ?? {}),
+            "a2a:last_chunk": lastChunk,
+        };
+    }
+}

package/dist/src/a2a/task-lifecycle.d.ts

@@ -38,10 +38,17 @@ export declare class TaskNotFoundError extends Error {
     readonly taskId: string;
     constructor(taskId: string);
 }
+/** Thrown when a refinement/follow-up task references invalid parent tasks */
+export declare class TaskRefinementError extends Error {
+    readonly referenceTaskIds: string[];
+    constructor(message: string, referenceTaskIds: string[]);
+}
 /** Options for creating a new task */
 export interface CreateTaskOptions {
     contextId?: string;
     metadata?: Record<string, unknown>;
+    referenceTaskIds?: string[];
+    parallelFollowUp?: boolean;
 }
 /** Options for listing tasks */
 export interface ListTasksOptions {
@@ -64,6 +71,8 @@ export declare class TaskManager {
     private contextIndex;
     /** Create a new task in the submitted state */
     createTask(options?: CreateTaskOptions): Task;
+    /** Create a refinement/follow-up task referencing existing task(s). */
+    createRefinedTask(referenceTaskIds: string[], options?: Omit<CreateTaskOptions, 'referenceTaskIds'>): Task;
     /** Get a task by ID. Throws TaskNotFoundError if not found. */
     getTask(taskId: string): Task;
     /** List tasks with optional filtering and pagination */
@@ -90,6 +99,8 @@ export declare class TaskManager {
     getTasksByContext(contextId: string): Task[];
     /** Check if a task is in a terminal state */
     isTerminal(taskId: string): boolean;
+    private resolveContextForReferenceTasks;
+    private validateReferenceTasks;
 }
 /**
  * Attach a LAFS envelope as an artifact to an A2A task.

package/dist/src/a2a/task-lifecycle.js

@@ -86,6 +86,15 @@ export class TaskNotFoundError extends Error {
         this.taskId = taskId;
     }
 }
+/** Thrown when a refinement/follow-up task references invalid parent tasks */
+export class TaskRefinementError extends Error {
+    referenceTaskIds;
+    constructor(message, referenceTaskIds) {
+        super(message);
+        this.name = 'TaskRefinementError';
+        this.referenceTaskIds = referenceTaskIds;
+    }
+}
 // ============================================================================
 // ID Generation
 // ============================================================================
@@ -106,7 +115,15 @@ export class TaskManager {
     /** Create a new task in the submitted state */
     createTask(options) {
         const id = generateId();
-        const contextId = options?.contextId ?? generateId();
+        const resolvedContextId = options?.contextId ?? this.resolveContextForReferenceTasks(options?.referenceTaskIds) ?? generateId();
+        const contextId = resolvedContextId;
+        const referenceTaskIds = options?.referenceTaskIds ?? [];
+        this.validateReferenceTasks(referenceTaskIds, contextId);
+        const metadata = {
+            ...(options?.metadata ?? {}),
+            ...(referenceTaskIds.length > 0 ? { referenceTaskIds } : {}),
+            ...(options?.parallelFollowUp ? { parallelFollowUp: true } : {}),
+        };
         const task = {
             id,
             contextId,
@@ -115,7 +132,7 @@ export class TaskManager {
                 state: 'submitted',
                 timestamp: new Date().toISOString(),
             },
-            ...(options?.metadata && { metadata: options.metadata }),
+            ...(Object.keys(metadata).length > 0 && { metadata }),
         };
         this.tasks.set(id, task);
         // Index by contextId
@@ -127,6 +144,14 @@ export class TaskManager {
         contextTasks.add(id);
         return structuredClone(task);
     }
+    /** Create a refinement/follow-up task referencing existing task(s). */
+    createRefinedTask(referenceTaskIds, options) {
+        return this.createTask({
+            ...options,
+            referenceTaskIds,
+            parallelFollowUp: options?.parallelFollowUp,
+        });
+    }
     /** Get a task by ID. Throws TaskNotFoundError if not found. */
     getTask(taskId) {
         const task = this.tasks.get(taskId);
@@ -249,6 +274,31 @@ export class TaskManager {
         }
         return isTerminalState(task.status.state);
     }
+    resolveContextForReferenceTasks(referenceTaskIds) {
+        if (!referenceTaskIds || referenceTaskIds.length === 0) {
+            return undefined;
+        }
+        const firstId = referenceTaskIds[0];
+        if (!firstId) {
+            return undefined;
+        }
+        const first = this.tasks.get(firstId);
+        return first?.contextId;
+    }
+    validateReferenceTasks(referenceTaskIds, contextId) {
+        if (referenceTaskIds.length === 0) {
+            return;
+        }
+        for (const refId of referenceTaskIds) {
+            const refTask = this.tasks.get(refId);
+            if (!refTask) {
+                throw new TaskRefinementError(`Referenced task not found: ${refId}`, referenceTaskIds);
+            }
+            if (refTask.contextId !== contextId) {
+                throw new TaskRefinementError(`Referenced task ${refId} has different contextId (${refTask.contextId}) than refinement (${contextId})`, referenceTaskIds);
+            }
+        }
+    }
 }
 // ============================================================================
 // LAFS Integration

package/dist/src/conformance.d.ts

@@ -1,3 +1,7 @@
 import type { ConformanceReport, FlagInput } from "./types.js";
-export declare function runEnvelopeConformance(envelope: unknown): ConformanceReport;
+import { type ConformanceTier } from "./conformanceProfiles.js";
+export interface EnvelopeConformanceOptions {
+    tier?: ConformanceTier;
+}
+export declare function runEnvelopeConformance(envelope: unknown, options?: EnvelopeConformanceOptions): ConformanceReport;
 export declare function runFlagConformance(flags: FlagInput): ConformanceReport;

package/dist/src/conformance.js

@@ -1,10 +1,11 @@
-import { isRegisteredErrorCode } from "./errorRegistry.js";
+import { getTransportMapping, isRegisteredErrorCode } from "./errorRegistry.js";
 import { resolveOutputFormat, LAFSFlagError } from "./flagSemantics.js";
+import { getChecksForTier } from "./conformanceProfiles.js";
 import { validateEnvelope } from "./validateEnvelope.js";
 function pushCheck(checks, name, pass, detail) {
     checks.push({ name, pass, ...(detail ? { detail } : {}) });
 }
-export function runEnvelopeConformance(envelope) {
+export function runEnvelopeConformance(envelope, options = {}) {
     const checks = [];
     const validation = validateEnvelope(envelope);
     pushCheck(checks, "envelope_schema_valid", validation.valid, validation.valid ? undefined : validation.errors.join("; "));
@@ -30,6 +31,50 @@ export function runEnvelopeConformance(envelope) {
     else {
         pushCheck(checks, "error_code_registered", true, "error field absent or null — skipped (optional when success=true)");
     }
+    // transport_mapping_consistent: when an error is present, ensure the code has
+    // a transport-specific mapping in the registry for the declared transport.
+    if (typed.error) {
+        if (typed._meta.transport === "sdk") {
+            pushCheck(checks, "transport_mapping_consistent", true, "sdk transport does not require external status-code mapping");
+        }
+        else {
+            const mapping = getTransportMapping(typed.error.code, typed._meta.transport);
+            const mappingOk = mapping !== null;
+            pushCheck(checks, "transport_mapping_consistent", mappingOk, mappingOk
+                ? undefined
+                : `no ${typed._meta.transport} mapping found for code ${typed.error.code}`);
+        }
+    }
+    else {
+        pushCheck(checks, "transport_mapping_consistent", true, "no error present — mapping check skipped");
+    }
+    // context_mutation_failure: if the producer marks context as required for a
+    // mutation operation, missing context must fail with a context error code.
+    {
+        const ext = (typed._extensions ?? {});
+        const contextObj = (ext["context"] ?? {});
+        const lafsObj = (ext["lafs"] ?? {});
+        const contextRequired = ext["lafsContextRequired"] === true ||
+            contextObj["required"] === true ||
+            lafsObj["contextRequired"] === true;
+        if (!contextRequired) {
+            pushCheck(checks, "context_mutation_failure", true, "context not marked required — skipped");
+        }
+        else {
+            const hasContextIdentity = typed._meta.contextVersion > 0 || Boolean(typed._meta.sessionId);
+            if (typed.success) {
+                const pass = hasContextIdentity;
+                pushCheck(checks, "context_mutation_failure", pass, pass ? undefined : "context required but missing identity (expect E_CONTEXT_MISSING)");
+            }
+            else {
+                const code = typed.error?.code;
+                const pass = code === "E_CONTEXT_MISSING" || code === "E_CONTEXT_STALE";
+                pushCheck(checks, "context_mutation_failure", pass, pass
+                    ? undefined
+                    : `context required failures should return E_CONTEXT_MISSING or E_CONTEXT_STALE, got ${String(code)}`);
+            }
+        }
+    }
     const validMviLevels = ["minimal", "standard", "full", "custom"];
     pushCheck(checks, "meta_mvi_present", validMviLevels.includes(typed._meta.mvi), validMviLevels.includes(typed._meta.mvi) ? undefined : `invalid mvi level: ${String(typed._meta.mvi)}`);
     pushCheck(checks, "meta_strict_present", typeof typed._meta.strict === "boolean");
@@ -72,6 +117,9 @@ export function runEnvelopeConformance(envelope) {
         }
         pushCheck(checks, "pagination_mode_consistent", consistent, consistent ? undefined : detail);
     }
+    else {
+        pushCheck(checks, "pagination_mode_consistent", true, "page absent — skipped");
+    }
     // strict_mode_enforced: verify the schema enforces additional-property rules.
     // When strict=true, extra top-level properties must be rejected by validation.
     // When strict=false, extra top-level properties must be allowed.
@@ -85,7 +133,59 @@ export function runEnvelopeConformance(envelope) {
             pushCheck(checks, "strict_mode_enforced", extraResult.valid, !extraResult.valid ? "strict=false but additional properties were rejected" : undefined);
         }
     }
-    return { ok: checks.every((check) => check.pass), checks };
+    // context_preservation_valid: validate monotonic context version behavior and
+    // context-constraint integrity when a context ledger extension is present.
+    {
+        const ext = (typed._extensions ?? {});
+        const ledger = (ext["contextLedger"] ?? ext["context"]);
+        if (!ledger || typeof ledger !== "object") {
+            pushCheck(checks, "context_preservation_valid", true, "context ledger absent — skipped");
+        }
+        else {
+            const version = ledger["version"];
+            const previousVersion = ledger["previousVersion"];
+            const removedConstraints = ledger["removedConstraints"];
+            const hasNumericVersion = typeof version === "number";
+            const matchesEnvelopeVersion = hasNumericVersion && version === typed._meta.contextVersion;
+            const monotonicFromPrevious = typeof previousVersion !== "number" || (hasNumericVersion && version >= previousVersion);
+            const constraintsPreserved = !Array.isArray(removedConstraints) || removedConstraints.length === 0 || !typed.success;
+            let pass = matchesEnvelopeVersion && monotonicFromPrevious && constraintsPreserved;
+            let detail;
+            if (!hasNumericVersion) {
+                pass = false;
+                detail = "context ledger version must be numeric";
+            }
+            else if (!matchesEnvelopeVersion) {
+                detail = `context version mismatch: ledger=${String(version)} envelope=${typed._meta.contextVersion}`;
+            }
+            else if (!monotonicFromPrevious) {
+                detail = `non-monotonic context version: previous=${String(previousVersion)} current=${String(version)}`;
+            }
+            else if (!constraintsPreserved) {
+                detail = "context constraint removal detected on successful response";
+            }
+            // Error-path validation for stale/missing context signaling.
+            if (!typed.success && typed.error && ledger["required"] === true) {
+                const stale = ledger["stale"] === true;
+                if (stale && typed.error.code !== "E_CONTEXT_STALE") {
+                    pass = false;
+                    detail = `stale context should return E_CONTEXT_STALE, got ${typed.error.code}`;
+                }
+                if (!stale && typed.error.code !== "E_CONTEXT_MISSING" && typed.error.code !== "E_CONTEXT_STALE") {
+                    pass = false;
+                    detail = `required context failure should return E_CONTEXT_MISSING or E_CONTEXT_STALE, got ${typed.error.code}`;
+                }
+            }
+            pushCheck(checks, "context_preservation_valid", pass, detail);
+        }
+    }
+    const tier = options.tier;
+    if (!tier) {
+        return { ok: checks.every((check) => check.pass), checks };
+    }
+    const allowed = new Set(getChecksForTier(tier));
+    const tierChecks = checks.filter((check) => allowed.has(check.name));
+    return { ok: tierChecks.every((check) => check.pass), checks: tierChecks };
 }
 export function runFlagConformance(flags) {
     const checks = [];

package/dist/src/conformanceProfiles.d.ts

@@ -0,0 +1,11 @@
+export type ConformanceTier = "core" | "standard" | "complete";
+export interface ConformanceProfiles {
+    version: string;
+    tiers: Record<ConformanceTier, string[]>;
+}
+export declare function getConformanceProfiles(): ConformanceProfiles;
+export declare function getChecksForTier(tier: ConformanceTier): string[];
+export declare function validateConformanceProfiles(availableChecks: string[]): {
+    valid: boolean;
+    errors: string[];
+};

package/dist/src/conformanceProfiles.js

@@ -0,0 +1,34 @@
+import profilesJson from "../schemas/v1/conformance-profiles.json" with { type: "json" };
+export function getConformanceProfiles() {
+    return profilesJson;
+}
+export function getChecksForTier(tier) {
+    const profiles = getConformanceProfiles();
+    return profiles.tiers[tier] ?? [];
+}
+export function validateConformanceProfiles(availableChecks) {
+    const profiles = getConformanceProfiles();
+    const errors = [];
+    const core = new Set(profiles.tiers.core);
+    const standard = new Set(profiles.tiers.standard);
+    const complete = new Set(profiles.tiers.complete);
+    for (const check of core) {
+        if (!standard.has(check)) {
+            errors.push(`standard tier must include core check: ${check}`);
+        }
+    }
+    for (const check of standard) {
+        if (!complete.has(check)) {
+            errors.push(`complete tier must include standard check: ${check}`);
+        }
+    }
+    const known = new Set(availableChecks);
+    for (const [tier, checks] of Object.entries(profiles.tiers)) {
+        for (const check of checks) {
+            if (!known.has(check)) {
+                errors.push(`unknown check in ${tier} tier: ${check}`);
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}

package/dist/src/deprecationRegistry.d.ts

@@ -0,0 +1,13 @@
+import type { LAFSEnvelope, Warning } from "./types.js";
+export interface DeprecationEntry {
+    id: string;
+    code: string;
+    message: string;
+    deprecated: string;
+    replacement?: string;
+    removeBy: string;
+    detector: (envelope: LAFSEnvelope) => boolean;
+}
+export declare function getDeprecationRegistry(): DeprecationEntry[];
+export declare function detectDeprecatedEnvelopeFields(envelope: LAFSEnvelope): Warning[];
+export declare function emitDeprecationWarnings(envelope: LAFSEnvelope): LAFSEnvelope;

package/dist/src/deprecationRegistry.js

@@ -0,0 +1,39 @@
+const DEPRECATION_REGISTRY = [
+    {
+        id: "meta-mvi-boolean",
+        code: "W_DEPRECATED_META_MVI_BOOLEAN",
+        message: "_meta.mvi boolean values are deprecated",
+        deprecated: "1.0.0",
+        replacement: "Use _meta.mvi as one of: minimal|standard|full|custom",
+        removeBy: "2.0.0",
+        detector: (envelope) => typeof envelope._meta.mvi === "boolean",
+    },
+];
+export function getDeprecationRegistry() {
+    return DEPRECATION_REGISTRY;
+}
+export function detectDeprecatedEnvelopeFields(envelope) {
+    return getDeprecationRegistry()
+        .filter((entry) => entry.detector(envelope))
+        .map((entry) => ({
+        code: entry.code,
+        message: entry.message,
+        deprecated: entry.deprecated,
+        replacement: entry.replacement,
+        removeBy: entry.removeBy,
+    }));
+}
+export function emitDeprecationWarnings(envelope) {
+    const detected = detectDeprecatedEnvelopeFields(envelope);
+    if (detected.length === 0) {
+        return envelope;
+    }
+    const existingWarnings = envelope._meta.warnings ?? [];
+    return {
+        ...envelope,
+        _meta: {
+            ...envelope._meta,
+            warnings: [...existingWarnings, ...detected],
+        },
+    };
+}

package/dist/src/errorRegistry.d.ts

@@ -11,5 +11,11 @@ export interface ErrorRegistry {
     version: string;
     codes: RegistryCode[];
 }
+export type TransportMapping = {
+    transport: "http" | "grpc" | "cli";
+    value: number | string;
+};
 export declare function getErrorRegistry(): ErrorRegistry;
 export declare function isRegisteredErrorCode(code: string): boolean;
+export declare function getRegistryCode(code: string): RegistryCode | undefined;
+export declare function getTransportMapping(code: string, transport: "http" | "grpc" | "cli"): TransportMapping | null;

package/dist/src/errorRegistry.js

@@ -6,3 +6,19 @@ export function isRegisteredErrorCode(code) {
     const registry = getErrorRegistry();
     return registry.codes.some((item) => item.code === code);
 }
+export function getRegistryCode(code) {
+    return getErrorRegistry().codes.find((item) => item.code === code);
+}
+export function getTransportMapping(code, transport) {
+    const registryCode = getRegistryCode(code);
+    if (!registryCode) {
+        return null;
+    }
+    if (transport === "http") {
+        return { transport, value: registryCode.httpStatus };
+    }
+    if (transport === "grpc") {
+        return { transport, value: registryCode.grpcStatus };
+    }
+    return { transport, value: registryCode.cliExit };
+}

package/dist/src/index.d.ts

@@ -1,9 +1,11 @@
 export * from "./types.js";
 export * from "./errorRegistry.js";
+export * from "./deprecationRegistry.js";
 export * from "./validateEnvelope.js";
 export * from "./envelope.js";
 export * from "./flagSemantics.js";
 export * from "./conformance.js";
+export * from "./conformanceProfiles.js";
 export * from "./compliance.js";
 export * from "./tokenEstimator.js";
 export * from "./budgetEnforcement.js";
@@ -12,6 +14,6 @@ export * from "./discovery.js";
 export * from "./health/index.js";
 export * from "./shutdown/index.js";
 export * from "./circuit-breaker/index.js";
-export { LafsA2AResult, createLafsArtifact, createTextArtifact, createFileArtifact, isExtensionRequired, getExtensionParams, AGENT_CARD_PATH, HTTP_EXTENSION_HEADER, LAFS_EXTENSION_URI, A2A_EXTENSIONS_HEADER, parseExtensionsHeader, negotiateExtensions, formatExtensionsHeader, buildLafsExtension, ExtensionSupportRequiredError, extensionNegotiationMiddleware, TERMINAL_STATES, INTERRUPTED_STATES, VALID_TRANSITIONS, isValidTransition, isTerminalState, isInterruptedState, InvalidStateTransitionError, TaskImmutabilityError, TaskNotFoundError, TaskManager, attachLafsEnvelope, } from "./a2a/index.js";
-export type { LafsA2AConfig, LafsSendMessageParams, LafsExtensionParams, ExtensionNegotiationResult, BuildLafsExtensionOptions, ExtensionNegotiationMiddlewareOptions, CreateTaskOptions, ListTasksOptions, ListTasksResult, } from "./a2a/index.js";
+export { LafsA2AResult, createLafsArtifact, createTextArtifact, createFileArtifact, isExtensionRequired, getExtensionParams, AGENT_CARD_PATH, HTTP_EXTENSION_HEADER, LAFS_EXTENSION_URI, A2A_EXTENSIONS_HEADER, parseExtensionsHeader, negotiateExtensions, formatExtensionsHeader, buildLafsExtension, ExtensionSupportRequiredError, extensionNegotiationMiddleware, TERMINAL_STATES, INTERRUPTED_STATES, VALID_TRANSITIONS, isValidTransition, isTerminalState, isInterruptedState, InvalidStateTransitionError, TaskImmutabilityError, TaskNotFoundError, TaskRefinementError, TaskManager, attachLafsEnvelope, TaskEventBus, PushNotificationConfigStore, PushNotificationDispatcher, TaskArtifactAssembler, streamTaskEvents, } from "./a2a/index.js";
+export type { LafsA2AConfig, LafsSendMessageParams, LafsExtensionParams, ExtensionNegotiationResult, BuildLafsExtensionOptions, ExtensionNegotiationMiddlewareOptions, CreateTaskOptions, ListTasksOptions, ListTasksResult, TaskStreamEvent, StreamIteratorOptions, PushNotificationDeliveryResult, PushTransport, } from "./a2a/index.js";
 export type { Task, TaskState, TaskStatus, Artifact, Part, Message, PushNotificationConfig, MessageSendConfiguration, TaskStatusUpdateEvent, TaskArtifactUpdateEvent, SendMessageResponse, SendMessageSuccessResponse, JSONRPCErrorResponse, TextPart, DataPart, FilePart, } from "./a2a/index.js";

package/dist/src/index.js

@@ -1,9 +1,11 @@
 export * from "./types.js";
 export * from "./errorRegistry.js";
+export * from "./deprecationRegistry.js";
 export * from "./validateEnvelope.js";
 export * from "./envelope.js";
 export * from "./flagSemantics.js";
 export * from "./conformance.js";
+export * from "./conformanceProfiles.js";
 export * from "./compliance.js";
 export * from "./tokenEstimator.js";
 export * from "./budgetEnforcement.js";
@@ -19,8 +21,10 @@ export * from "./circuit-breaker/index.js";
 // For full A2A types, import from '@cleocode/lafs-protocol/a2a'.
 export { 
 // Bridge
-LafsA2AResult, createLafsArtifact, createTextArtifact, createFileArtifact, isExtensionRequired, getExtensionParams, 
+LafsA2AResult, createLafsArtifact, createTextArtifact, createFileArtifact, isExtensionRequired, getExtensionParams, AGENT_CARD_PATH, HTTP_EXTENSION_HEADER, 
 // Extensions (T098)
 LAFS_EXTENSION_URI, A2A_EXTENSIONS_HEADER, parseExtensionsHeader, negotiateExtensions, formatExtensionsHeader, buildLafsExtension, ExtensionSupportRequiredError, extensionNegotiationMiddleware, 
 // Task Lifecycle (T099)
-TERMINAL_STATES, INTERRUPTED_STATES, VALID_TRANSITIONS, isValidTransition, isTerminalState, isInterruptedState, InvalidStateTransitionError, TaskImmutabilityError, TaskNotFoundError, TaskManager, attachLafsEnvelope, } from "./a2a/index.js";
+TERMINAL_STATES, INTERRUPTED_STATES, VALID_TRANSITIONS, isValidTransition, isTerminalState, isInterruptedState, InvalidStateTransitionError, TaskImmutabilityError, TaskNotFoundError, TaskRefinementError, TaskManager, attachLafsEnvelope, 
+// Streaming and Async (T101)
+TaskEventBus, PushNotificationConfigStore, PushNotificationDispatcher, TaskArtifactAssembler, streamTaskEvents, } from "./a2a/index.js";

package/lafs.md

@@ -1,7 +1,7 @@
 # LAFS: LLM-Agent-First Specification
 
 > 📚 **Documentation:** https://codluv.gitbook.io/lafs-protocol/  
-> **Version:** 1.4.0 | **Status:** Production Ready
+> **Version:** 1.4.1 | **Status:** Production Ready
 
 ## 1. Scope
 
@@ -412,6 +412,16 @@ Returns checksum and version for validation.
 - **Validation**: Use `mode=summary` to verify sync state
 - **Default recommendation**: `delta` mode for agent-optimal behavior
 
+### 8.2 Lazy Context Retrieval
+
+To reduce token and I/O overhead, implementations SHOULD support lazy retrieval semantics:
+
+- Clients SHOULD start with `mode=summary` and request `mode=delta` only when `version` or `checksum` changes.
+- Delta responses SHOULD be bounded by `limit` and MAY return paged deltas.
+- Servers SHOULD treat context retrieval as task-scoped and MUST NOT leak entries across `contextId` domains.
+- When a consumer requests additional context beyond MVI defaults, servers MAY return progressive context slices rather than full ledgers.
+- If requested context scope cannot be satisfied within declared budget, servers SHOULD fail with `E_MVI_BUDGET_EXCEEDED`.
+
 ---
 
 ## 9. MVI and Progressive Disclosure
@@ -447,6 +457,9 @@ Clients MAY request expanded/nested data via the `_expand` request parameter.
 - List operations SHOULD return deterministic `page` metadata.
 - Pagination mode (offset or cursor) MUST be documented.
 - Mixed pagination modes in one request MUST fail validation.
+- `page.limit` SHOULD represent the effective item window after `_fields`/`_expand` processing.
+- When `_meta.mvi` is `minimal` and projected payload size exceeds budget, servers SHOULD reduce `page.limit` rather than silently truncate item content.
+- If limit reduction still cannot satisfy declared budget, servers MUST fail with `E_MVI_BUDGET_EXCEEDED`.
 
 ### 9.5 Token Budget Signaling
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cleocode/lafs-protocol",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "private": false,
   "type": "module",
   "description": "LLM-Agent-First Specification schemas and conformance tooling",
@@ -26,7 +26,8 @@
     "./schemas/v1/envelope.schema.json": "./schemas/v1/envelope.schema.json",
     "./schemas/v1/error-registry.json": "./schemas/v1/error-registry.json",
     "./schemas/v1/context-ledger.schema.json": "./schemas/v1/context-ledger.schema.json",
-    "./schemas/v1/discovery.schema.json": "./schemas/v1/discovery.schema.json"
+    "./schemas/v1/discovery.schema.json": "./schemas/v1/discovery.schema.json",
+    "./schemas/v1/conformance-profiles.json": "./schemas/v1/conformance-profiles.json"
   },
   "files": [
     "dist",

package/schemas/v1/conformance-profiles.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "version": "1.0.0",
+  "tiers": {
+    "core": [
+      "envelope_schema_valid",
+      "envelope_invariants",
+      "error_code_registered"
+    ],
+    "standard": [
+      "envelope_schema_valid",
+      "envelope_invariants",
+      "error_code_registered",
+      "transport_mapping_consistent",
+      "meta_mvi_present",
+      "meta_strict_present",
+      "strict_mode_behavior",
+      "pagination_mode_consistent",
+      "strict_mode_enforced"
+    ],
+    "complete": [
+      "envelope_schema_valid",
+      "envelope_invariants",
+      "error_code_registered",
+      "transport_mapping_consistent",
+      "context_mutation_failure",
+      "context_preservation_valid",
+      "meta_mvi_present",
+      "meta_strict_present",
+      "strict_mode_behavior",
+      "pagination_mode_consistent",
+      "strict_mode_enforced"
+    ]
+  }
+}