@sentropic/artifacts 0.1.4 → 0.2.1

package/dist/index.d.ts

@@ -23,3 +23,5 @@ export * from './content/api-profile.js';
 export * from './server/runtime.js';
 export * from './server/reader-profile.js';
 export * from './http.js';
+export * from './server/commit-contract.js';
+export * from './server/outcome-contract.js';

package/dist/index.js

@@ -27,3 +27,5 @@ export * from './content/api-profile.js';
 export * from './server/runtime.js';
 export * from './server/reader-profile.js';
 export * from './http.js';
+export * from './server/commit-contract.js';
+export * from './server/outcome-contract.js';

package/dist/mcp-core.d.ts

@@ -1,62 +1,55 @@
-/**
- * L-5e — reusable artifacts MCP provider (spec-v8 §9 5e, review B3).
- *
- * Part 1: identity, the 15 exact `artifacts_*` tool specs with closed input
- * schemas, and the platform manifest. The logical provider ID is
- * `sentropic.artifacts`; the generic provider hardcodes no application
- * OAuth vocabulary — a host binds its invocation scope through the
- * manifest factory before digests freeze (§3.5). Part 2 adds the tool
- * executor over the same HTTP app direct calls use; part 3 adds the
- * platform adapter and the kernel registry definition (§3).
- */
-import type { AppConnectorProviderAdapter, AppMcpProviderManifest, CapabilityTool } from '@sentropic/mcp-platform';
+/** Platform-free provider composition over the shared typed HTTP application. */
+import type { AppConnectorProviderAdapter, AppMcpProviderManifest, AppToolInvocation } from '@sentropic/mcp-platform';
 import type { ProviderParameterSchema } from '@sentropic/mcp-platform/registry';
-import type { HttpRequest, HttpResponse } from './http.js';
+import type { ArtifactApp, HttpResponse } from './http.js';
+import { type CompiledArtifactsProfile } from './profile/index.js';
+import type { ArtifactInvocationContext } from './server/commit/types.js';
+import { type ArtifactOutcome, type ArtifactHostFailureMapper } from './server/failures.js';
+export * from './profile/index.js';
+export { createRadarKeyDerivation } from './server/command-identity.js';
+export type { ArtifactKeyDerivationBinding } from './server/command-identity.js';
 export declare const ARTIFACTS_PROVIDER_ID = "sentropic.artifacts";
 export declare const ARTIFACTS_APP_ID = "sentropic-artifacts";
-export declare const ARTIFACTS_PROVIDER_VERSION = "0.1.4";
+export declare const ARTIFACTS_PROVIDER_VERSION = "0.2.1";
 export declare const ARTIFACTS_TOOL_NAMES: readonly ["artifacts_get_template", "artifacts_get_api_guide", "artifacts_ensure", "artifacts_publish", "artifacts_create_upload", "artifacts_commit_upload", "artifacts_list", "artifacts_get", "artifacts_get_source", "artifacts_fork", "artifacts_set_access", "artifacts_promote", "artifacts_renew", "artifacts_delete", "artifacts_restore"];
 export type ArtifactsToolName = (typeof ARTIFACTS_TOOL_NAMES)[number];
-type Schema = Record<string, unknown>;
-interface ToolSpec {
-    name: ArtifactsToolName;
+export declare const ARTIFACTS_TOOL_SPECS: {
+    name: "artifacts_ensure" | "artifacts_publish" | "artifacts_get_template" | "artifacts_get_api_guide" | "artifacts_create_upload" | "artifacts_commit_upload" | "artifacts_list" | "artifacts_get" | "artifacts_get_source" | "artifacts_fork" | "artifacts_set_access" | "artifacts_promote" | "artifacts_renew" | "artifacts_delete" | "artifacts_restore";
     description: string;
-    inputSchema: Schema;
-    mutability: CapabilityTool['mutability'];
-    idempotent?: boolean;
-    confirm?: boolean;
-}
-export declare const ARTIFACTS_TOOL_SPECS: readonly ToolSpec[];
-/** Kernel provider parameter schema (typed non-secret host settings). */
+    mutability: import("@sentropic/mcp-platform").Mutability;
+}[];
 export declare const ARTIFACTS_PARAMETER_SCHEMA: ProviderParameterSchema;
 export interface ArtifactsManifestOptions {
-    /** Host authorization profile: scope bound to every tool invocation. */
+    profile: CompiledArtifactsProfile;
     invocationScope?: string;
     displayName?: string;
 }
-/** Build the sentropic.artifacts manifest (host scope bound pre-freeze). */
-export declare function createArtifactsManifest(options?: ArtifactsManifestOptions): AppMcpProviderManifest;
-export interface ArtifactsApp {
-    handle(request: HttpRequest): Promise<HttpResponse>;
-}
+export type ArtifactsManifest = AppMcpProviderManifest & {
+    audit: AppMcpProviderManifest['audit'] & {
+        artifactsProfileDigest: string;
+    };
+};
+export declare function createArtifactsManifest(options: ArtifactsManifestOptions): ArtifactsManifest;
+export type ArtifactsApp = Pick<ArtifactApp, 'execute' | 'selectedCapabilities' | 'profileDigest'>;
 export interface ArtifactsInvokeInput {
     tool: string;
-    actorId: string;
-    /** Trusted host scope; tool arguments cannot select storage. */
-    storageScopeId?: string;
-    args: Record<string, unknown>;
+    invocation: ArtifactInvocationContext;
+    args: unknown;
+    idempotencyKey?: string;
 }
-/** Create the 15-tool executor over any conforming artifacts HTTP app. */
 export declare function createArtifactsToolExecutor(deps: {
     app: ArtifactsApp;
-    defaultStorageScopeId?: string;
+    profile: CompiledArtifactsProfile;
+    mapHostError?: ArtifactHostFailureMapper;
 }): {
+    execute: (input: ArtifactsInvokeInput) => Promise<ArtifactOutcome<HttpResponse>>;
     invoke(input: ArtifactsInvokeInput): Promise<HttpResponse>;
 };
 export interface ArtifactsAdapterOptions extends ArtifactsManifestOptions {
+    /** Trusted mapping for failures in the MCP host binding. */
+    mapHostError?: ArtifactHostFailureMapper;
     app: ArtifactsApp;
-    defaultStorageScopeId?: string;
+    /** Bind verified principal/scope and request authorization in trusted host code. */
+    createInvocation(request: AppToolInvocation): ArtifactInvocationContext | Promise<ArtifactInvocationContext>;
 }
-/** Create the platform adapter driving the 15 tools over the shared app. */
 export declare function createArtifactsAdapter(options: ArtifactsAdapterOptions): AppConnectorProviderAdapter;
-export {};

package/dist/mcp-core.js

@@ -1,272 +1,111 @@
-import { TEXT_MIME_PATTERN } from './http.js';
+import { assertArtifactsTransportProfile } from './http.js';
+import { ARTIFACT_CAPABILITY_NAMES, ArtifactProfileInputError } from './profile/index.js';
+import { ArtifactOperationError, classifyArtifactFailure } from './server/failures.js';
+import { projectArtifactHttpOutcome, projectArtifactMcpOutcome } from './server/outcome-projection.js';
+export * from './profile/index.js';
+export { createRadarKeyDerivation } from './server/command-identity.js';
 export const ARTIFACTS_PROVIDER_ID = 'sentropic.artifacts';
 export const ARTIFACTS_APP_ID = 'sentropic-artifacts';
-export const ARTIFACTS_PROVIDER_VERSION = '0.1.4';
-export const ARTIFACTS_TOOL_NAMES = [
-    'artifacts_get_template', 'artifacts_get_api_guide', 'artifacts_ensure',
-    'artifacts_publish', 'artifacts_create_upload', 'artifacts_commit_upload',
-    'artifacts_list', 'artifacts_get', 'artifacts_get_source', 'artifacts_fork',
-    'artifacts_set_access', 'artifacts_promote', 'artifacts_renew',
-    'artifacts_delete', 'artifacts_restore',
-];
-const str = { type: 'string', minLength: 1 };
-const int = (minimum, maximum) => ({
-    type: 'integer', minimum, ...(maximum === undefined ? {} : { maximum }),
-});
-const obj = (properties, required = []) => ({
-    type: 'object', properties, required, additionalProperties: false,
-});
-const record = {
-    type: 'object',
-    additionalProperties: { type: ['string', 'number', 'boolean', 'null'] },
-};
-const fileBytes = { type: 'array', items: int(0, 255) };
-const fileEntry = {
-    ...obj({ path: str, mimeType: str, bytes: fileBytes, text: { type: 'string', description: 'UTF-8 text; mutually exclusive with bytes; text MIME types only.' } }, ['path', 'mimeType']),
-    oneOf: [
-        { required: ['bytes'], not: { required: ['text'] } },
-        { required: ['text'], not: { required: ['bytes'] }, properties: { mimeType: { pattern: TEXT_MIME_PATTERN } } },
-    ],
-};
-const sourceRef = obj({
-    kind: { type: 'string', enum: ['inline-original', 'base-commit', 'recipe'] },
-    commit: { type: 'string' },
-    steps: { type: 'array', items: { type: 'string' } },
-}, ['kind']);
-const idOnly = obj({ artifactId: str }, ['artifactId']);
-export const ARTIFACTS_TOOL_SPECS = [
-    { name: 'artifacts_get_template', description: 'Get an approved template kit (sources + build recipe).', inputSchema: obj({ templateId: str }, ['templateId']), mutability: 'read-only' },
-    { name: 'artifacts_get_api_guide', description: 'Get the versioned artifacts API guide.', inputSchema: obj({ version: str }), mutability: 'read-only' },
-    { name: 'artifacts_ensure', description: 'Resolve or create the private artifact view for a binding.', inputSchema: obj({ bindingName: str, storageScopeId: str, idempotencyKey: str, paramsHash: str, parameters: record }, ['bindingName', 'idempotencyKey']), mutability: 'state-transition', idempotent: true },
-    { name: 'artifacts_publish', description: 'Publish inline files as a new release.', inputSchema: obj({ artifactId: str, files: { type: 'array', minItems: 1, items: fileEntry }, profile: record, source: sourceRef, idempotencyKey: str, paramsHash: str }, ['artifactId', 'files']), mutability: 'append', idempotent: true },
-    { name: 'artifacts_create_upload', description: 'Open a bounded upload session for large bytes.', inputSchema: obj({ artifactId: str, mimeType: str, maxSize: int(1) }, ['artifactId', 'mimeType']), mutability: 'state-transition' },
-    { name: 'artifacts_commit_upload', description: 'Verify staged bytes and publish them as a release.', inputSchema: obj({ artifactId: str, uploadId: str, path: str, mimeType: str, digest: str, size: int(0), profile: record, idempotencyKey: str, paramsHash: str }, ['artifactId', 'uploadId', 'path', 'mimeType', 'digest', 'size']), mutability: 'append', idempotent: true },
-    { name: 'artifacts_list', description: 'List artifacts visible to the caller (ACL before pagination).', inputSchema: obj({ limit: int(1, 100), offset: int(0) }), mutability: 'read-only' },
-    { name: 'artifacts_get', description: 'Get artifact metadata (grants visible to the owner only).', inputSchema: idOnly, mutability: 'read-only' },
-    { name: 'artifacts_get_source', description: 'Export the attached source reference (separate right).', inputSchema: idOnly, mutability: 'read-only' },
-    { name: 'artifacts_fork', description: 'Fork privately under a fresh identity (no ACL copied).', inputSchema: idOnly, mutability: 'state-transition' },
-    { name: 'artifacts_set_access', description: 'Grant or revoke read/source access, or toggle public mode.', inputSchema: obj({ artifactId: str, action: { type: 'string', enum: ['grant', 'revoke', 'set-public'] }, principalId: str, grant: { type: 'string', enum: ['read', 'source'] }, isPublic: { type: 'boolean' } }, ['artifactId', 'action']), mutability: 'patch', confirm: true },
-    { name: 'artifacts_promote', description: 'Select a release explicitly (expected-current CAS).', inputSchema: obj({ artifactId: str, releaseId: str, expectedCurrent: str }, ['artifactId', 'releaseId', 'expectedCurrent']), mutability: 'patch' },
-    { name: 'artifacts_renew', description: 'Renew the artifact retention timestamp.', inputSchema: idOnly, mutability: 'patch' },
-    { name: 'artifacts_delete', description: 'Withdraw into pending deletion (undo via artifacts_restore).', inputSchema: idOnly, mutability: 'delete', confirm: true },
-    { name: 'artifacts_restore', description: 'Cancel a pending deletion or withdrawal before purge.', inputSchema: idOnly, mutability: 'state-transition' },
-];
-/** Kernel provider parameter schema (typed non-secret host settings). */
-export const ARTIFACTS_PARAMETER_SCHEMA = {
-    properties: {
-        defaultStorageScopeId: { type: 'string', minLength: 1, description: 'Fallback storage scope for artifacts_ensure.' },
-        uploadBudgetBytes: { type: 'integer', minimum: 1, description: 'Declared bounded-upload budget.' },
-    },
-    required: [],
-};
-/** Build the sentropic.artifacts manifest (host scope bound pre-freeze). */
-export function createArtifactsManifest(options = {}) {
+export const ARTIFACTS_PROVIDER_VERSION = '0.2.1';
+export const ARTIFACTS_TOOL_NAMES = ARTIFACT_CAPABILITY_NAMES;
+export const ARTIFACTS_TOOL_SPECS = ARTIFACTS_TOOL_NAMES.map((name) => ({ name,
+    description: `Artifacts ${name.slice('artifacts_'.length).replaceAll('_', ' ')}.`,
+    mutability: (['artifacts_list', 'artifacts_get', 'artifacts_get_template', 'artifacts_get_api_guide',
+        'artifacts_get_source'].includes(name) ? 'read-only' : name === 'artifacts_publish' ? 'append' : 'state-transition'),
+}));
+export const ARTIFACTS_PARAMETER_SCHEMA = { properties: {}, required: [] };
+export function createArtifactsManifest(options) {
+    assertArtifactsTransportProfile(options?.profile);
+    const { profile } = options;
     const scopes = options.invocationScope === undefined ? [] : [options.invocationScope];
-    const tools = ARTIFACTS_TOOL_SPECS.map((spec) => ({
-        kind: 'tool',
-        name: spec.name,
-        description: spec.description,
-        requiredScopes: [...scopes],
-        requiredClaims: [],
-        inputSchema: spec.inputSchema,
-        outputSchema: { type: 'object' },
-        redactionClass: 'low',
-        mutability: spec.mutability,
-        mutatesExternalSystem: spec.mutability !== 'read-only',
-        idempotency: spec.idempotent === true
-            ? { required: true, scope: 'principal' }
-            : { required: false },
-        gates: {
-            requiresElicitation: false,
-            requiresHumanConfirmation: spec.confirm === true,
-            requiresPrincipalGate: false,
-        },
-    }));
     return {
-        appId: ARTIFACTS_APP_ID,
-        providerId: ARTIFACTS_PROVIDER_ID,
-        version: ARTIFACTS_PROVIDER_VERSION,
+        appId: ARTIFACTS_APP_ID, providerId: ARTIFACTS_PROVIDER_ID, version: ARTIFACTS_PROVIDER_VERSION,
         displayName: options.displayName ?? 'Sentropic Artifacts',
-        resources: [],
-        tools,
-        prompts: [],
-        authz: { requiredClaims: [], scopes: [...scopes], tenantResolution: 'custom-resolver' },
-        audit: { eventKinds: ['invoke'] },
-        durability: {},
+        resources: [], prompts: [],
+        tools: ARTIFACTS_TOOL_SPECS.filter((spec) => profile.selectedCapabilities.includes(spec.name)).map((spec) => ({
+            kind: 'tool', name: spec.name,
+            description: spec.description,
+            inputSchema: profile.schemas[spec.name], outputSchema: { type: 'object' },
+            requiredScopes: [...scopes], requiredClaims: [], redactionClass: 'low',
+            mutability: spec.mutability, mutatesExternalSystem: spec.mutability !== 'read-only',
+            idempotency: profile.idempotency[spec.name] ?? { required: false },
+            gates: { requiresElicitation: false, requiresHumanConfirmation: false, requiresPrincipalGate: false },
+        })),
+        authz: { requiredClaims: [], scopes, tenantResolution: 'custom-resolver' },
+        // The existing manifest codec includes audit metadata, including for an empty tool set.
+        audit: { eventKinds: ['invoke'], artifactsProfileDigest: profile.profileDigest }, durability: {},
     };
 }
-function needString(args, name) {
-    const value = args[name];
-    if (typeof value !== 'string' || value.length === 0) {
-        throw new Error(`invalid request: missing ${name}`);
-    }
-    return value;
-}
-function optString(args, name) {
-    const value = args[name];
-    return typeof value === 'string' && value.length !== 0 ? value : undefined;
+function rejected(cause, invocationId, operation, mapHostError) {
+    return { ok: false, failure: classifyArtifactFailure(cause, { invocationId, operation,
+            phase: cause instanceof ArtifactProfileInputError ? cause.phase : 'entry', commitState: 'not_committed' }, (error) => error instanceof ArtifactProfileInputError ? new ArtifactOperationError(error.category) : mapHostError?.(error)) };
 }
-/** Create the 15-tool executor over any conforming artifacts HTTP app. */
 export function createArtifactsToolExecutor(deps) {
-    const call = (actorId, method, path, body, storageScopeId) => deps.app.handle({
-        method, path, actorId, body, storageScopeId: storageScopeId ?? deps.defaultStorageScopeId,
-    });
-    function setAccess(actorId, args) {
-        const artifactId = needString(args, 'artifactId');
-        const action = needString(args, 'action');
-        if (action === 'grant') {
-            const grant = needString(args, 'grant');
-            if (grant !== 'read' && grant !== 'source') {
-                throw new Error('invalid request: grant must be read or source');
-            }
-            return call(actorId, 'POST', '/access/grant', {
-                artifactId, principalId: needString(args, 'principalId'), grant,
-            });
-        }
-        if (action === 'revoke') {
-            return call(actorId, 'POST', '/access/revoke', {
-                artifactId, principalId: needString(args, 'principalId'),
-            });
-        }
-        if (action === 'set-public') {
-            if (typeof args['isPublic'] !== 'boolean') {
-                throw new Error('invalid request: isPublic must be a boolean');
-            }
-            return call(actorId, 'POST', '/access/public', { artifactId, isPublic: args['isPublic'] });
-        }
-        throw new Error(`invalid request: unknown set-access action ${action}`);
+    assertArtifactsTransportProfile(deps.profile);
+    const profile = deps.profile;
+    if (deps.app.profileDigest !== profile.profileDigest ||
+        JSON.stringify(deps.app.selectedCapabilities) !== JSON.stringify(profile.selectedCapabilities)) {
+        throw new Error('artifacts app/profile mismatch');
     }
-    return {
-        async invoke(input) {
-            const { actorId, args } = input;
+    async function execute(input) {
+        try {
+            const args = profile.validate(input.tool, input.args, input.idempotencyKey);
+            let request;
             switch (input.tool) {
-                case 'artifacts_get_template':
-                    return call(actorId, 'GET', `/templates/${needString(args, 'templateId')}`);
-                case 'artifacts_get_api_guide': {
-                    const version = optString(args, 'version');
-                    return call(actorId, 'GET', version === undefined ? '/api-guide' : `/api-guide/${version}`);
-                }
                 case 'artifacts_ensure':
-                    return call(actorId, 'POST', '/ensure', {
-                        bindingName: needString(args, 'bindingName'),
-                        idempotencyKey: needString(args, 'idempotencyKey'),
-                        paramsHash: optString(args, 'paramsHash') ?? '',
-                        parameters: args['parameters'] ?? {},
-                    }, input.storageScopeId);
+                    request = { method: 'POST', path: '/ensure', body: args };
+                    break;
                 case 'artifacts_publish':
-                    return call(actorId, 'POST', '/publish', {
-                        artifactId: needString(args, 'artifactId'),
-                        files: args['files'],
-                        profile: args['profile'] ?? {},
-                        source: args['source'],
-                        idempotencyKey: optString(args, 'idempotencyKey'),
-                        paramsHash: optString(args, 'paramsHash'),
-                    });
-                case 'artifacts_create_upload':
-                    return call(actorId, 'POST', '/uploads', {
-                        artifactId: needString(args, 'artifactId'),
-                        mimeType: needString(args, 'mimeType'),
-                        maxSize: args['maxSize'],
-                    });
-                case 'artifacts_commit_upload':
-                    return call(actorId, 'POST', '/uploads/commit', {
-                        artifactId: needString(args, 'artifactId'),
-                        uploadId: needString(args, 'uploadId'),
-                        path: needString(args, 'path'),
-                        mimeType: needString(args, 'mimeType'),
-                        digest: needString(args, 'digest'),
-                        size: args['size'],
-                        profile: args['profile'] ?? {},
-                        idempotencyKey: optString(args, 'idempotencyKey'),
-                        paramsHash: optString(args, 'paramsHash'),
-                    });
+                    request = { method: 'POST', path: '/publish', body: args };
+                    break;
                 case 'artifacts_list':
-                    return call(actorId, 'POST', '/list', { limit: args['limit'], offset: args['offset'] });
+                    request = { method: 'POST', path: '/list', body: args };
+                    break;
                 case 'artifacts_get':
-                    return call(actorId, 'GET', `/meta/${needString(args, 'artifactId')}`);
-                case 'artifacts_get_source':
-                    return call(actorId, 'GET', `/source/${needString(args, 'artifactId')}`);
-                case 'artifacts_fork':
-                    return call(actorId, 'POST', '/fork', { artifactId: needString(args, 'artifactId') });
-                case 'artifacts_set_access':
-                    return setAccess(actorId, args);
-                case 'artifacts_promote':
-                    return call(actorId, 'POST', '/promote', {
-                        artifactId: needString(args, 'artifactId'),
-                        releaseId: needString(args, 'releaseId'),
-                        expectedCurrent: needString(args, 'expectedCurrent'),
-                    });
-                case 'artifacts_renew':
-                    return call(actorId, 'POST', '/renew', { artifactId: needString(args, 'artifactId') });
-                case 'artifacts_delete':
-                    return call(actorId, 'POST', '/delete', { artifactId: needString(args, 'artifactId') });
-                case 'artifacts_restore':
-                    return call(actorId, 'POST', '/restore', { artifactId: needString(args, 'artifactId') });
-                default:
-                    throw new Error(`unknown artifacts tool: ${input.tool}`);
+                    request = { method: 'GET', path: `/meta/${args.artifactId}`, body: undefined };
+                    break;
+                default: throw new ArtifactProfileInputError(true);
             }
-        },
-    };
-}
-function errorCodeOf(body) {
-    if (typeof body === 'object' && body !== null) {
-        const code = body['error'];
-        if (typeof code === 'string' && code.length !== 0)
-            return code;
+            return await deps.app.execute({ ...request, actorId: input.invocation.actorId,
+                storageScopeId: input.invocation.storageScopeId, idempotencyKey: input.idempotencyKey }, input.invocation);
+        }
+        catch (cause) {
+            return rejected(cause, input.invocation?.invocationId ?? '', input.tool, deps.mapHostError);
+        }
     }
-    return 'internal_error';
+    return { execute, async invoke(input) {
+            return projectArtifactHttpOutcome(await execute(input));
+        } };
 }
-/** Create the platform adapter driving the 15 tools over the shared app. */
 export function createArtifactsAdapter(options) {
     const manifest = createArtifactsManifest(options);
-    const executor = createArtifactsToolExecutor({
-        app: options.app,
-        defaultStorageScopeId: options.defaultStorageScopeId,
-    });
+    if (typeof options.createInvocation !== 'function')
+        throw new Error('artifacts requires a trusted invocation factory');
+    const executor = createArtifactsToolExecutor(options);
     return {
-        appId: ARTIFACTS_APP_ID,
-        connectorId: ARTIFACTS_PROVIDER_ID,
-        manifest,
-        resolveTenant: (input) => Promise.resolve({
-            principalRef: input.principalSub,
-            tenantRef: input.tenantRef,
+        appId: ARTIFACTS_APP_ID, connectorId: ARTIFACTS_PROVIDER_ID, manifest,
+        resolveTenant: async (input) => ({ principalRef: input.principalSub, tenantRef: input.tenantRef,
             connectorInstanceId: input.connectorInstanceId,
-            ...(input.workspaceRef === undefined ? {} : { workspaceRef: input.workspaceRef }),
-        }),
-        listCapabilities: () => Promise.resolve([...manifest.tools]),
-        async invokeTool(req) {
-            const auditId = req.ctx.auditId;
+            ...(input.workspaceRef === undefined ? {} : { workspaceRef: input.workspaceRef }) }),
+        listCapabilities: async () => [...manifest.tools],
+        async invokeTool(request) {
+            let outcome;
             try {
-                const args = typeof req.input === 'object' && req.input !== null && !Array.isArray(req.input)
-                    ? req.input
-                    : {};
-                const res = await executor.invoke({
-                    tool: req.capabilityRef,
-                    actorId: req.ctx.principal.sub,
-                    args,
-                });
-                if (res.status >= 200 && res.status < 300) {
-                    return { ok: true, output: res.body, auditId, redactionClass: 'low' };
-                }
-                const code = errorCodeOf(res.body);
-                return {
-                    ok: false, auditId, redactionClass: 'low',
-                    error: { code, message: code, retriable: res.status >= 500 },
-                };
+                // Selection and closed input checks precede even the host invocation binding.
+                options.profile.validate(request.capabilityRef, request.input, request.idempotencyKey);
+                const invocation = await options.createInvocation(request);
+                if (invocation.actorId !== request.ctx.principal.sub)
+                    throw new ArtifactProfileInputError();
+                outcome = await executor.execute({ tool: request.capabilityRef, args: request.input,
+                    invocation, idempotencyKey: request.idempotencyKey });
             }
-            catch {
-                return {
-                    ok: false, auditId, redactionClass: 'low',
-                    error: { code: 'invalid_request', message: 'invalid_request', retriable: false },
-                };
+            catch (cause) {
+                outcome = rejected(cause, request.ctx.requestId, request.capabilityRef, options.mapHostError);
             }
+            return projectArtifactMcpOutcome(outcome, request.ctx.auditId);
         },
-        readResource: (req) => Promise.resolve({
-            ok: false,
-            auditId: req.ctx.auditId,
-            redactionClass: 'low',
-            error: { code: 'not_found', message: 'not_found', retriable: false },
-        }),
-        validateSecrets: () => Promise.resolve([]),
+        readResource: async (request) => ({ ok: false, auditId: request.ctx.auditId, redactionClass: 'low',
+            error: { code: 'not_found', message: 'not_found', retriable: false } }),
+        validateSecrets: async () => [],
     };
 }

package/dist/mcp.js

@@ -1,7 +1,7 @@
 /** Platform registry wrapper. Use /mcp-core when the platform is absent. */
 export * from './mcp-core.js';
 import { computeManifestDigest } from '@sentropic/mcp-platform/tool-configuration';
-import { createArtifactsAdapter, ARTIFACTS_TOOL_SPECS, ARTIFACTS_PARAMETER_SCHEMA, } from './mcp-core.js';
+import { createArtifactsAdapter, ARTIFACTS_PARAMETER_SCHEMA, } from './mcp-core.js';
 const EMPTY_TOOL_CONFIG = { type: 'object', properties: {}, additionalProperties: false };
 /** Build the kernel registry definition for sentropic.artifacts (§3). */
 export function createArtifactsRegistryDefinition(options) {
@@ -9,10 +9,10 @@ export function createArtifactsRegistryDefinition(options) {
     const manifest = adapter.manifest;
     const handlers = {};
     const toolValues = {};
-    for (const spec of ARTIFACTS_TOOL_SPECS) {
-        const handlerId = `${spec.name}-handler`;
-        handlers[handlerId] = { handlerId, capabilityRef: spec.name, configSchema: EMPTY_TOOL_CONFIG };
-        toolValues[spec.name] = { handlerId, values: {} };
+    for (const tool of manifest.tools) {
+        const handlerId = `${tool.name}-handler`;
+        handlers[handlerId] = { handlerId, capabilityRef: tool.name, configSchema: EMPTY_TOOL_CONFIG };
+        toolValues[tool.name] = { handlerId, values: {} };
     }
     return {
         manifest,

package/dist/profile/contracts.d.ts

@@ -0,0 +1,67 @@
+import type { JsonValue } from '../contracts.js';
+import type { EffectiveArtifactCommand } from '../server/command-identity.js';
+export declare const PROFILE_CONTRACT_VERSION: "artifacts-profile/v1";
+export declare const ARTIFACT_CAPABILITY_NAMES: readonly ["artifacts_get_template", "artifacts_get_api_guide", "artifacts_ensure", "artifacts_publish", "artifacts_create_upload", "artifacts_commit_upload", "artifacts_list", "artifacts_get", "artifacts_get_source", "artifacts_fork", "artifacts_set_access", "artifacts_promote", "artifacts_renew", "artifacts_delete", "artifacts_restore"];
+export type ArtifactCapabilityName = (typeof ARTIFACT_CAPABILITY_NAMES)[number];
+export type ArtifactSchema = Readonly<Record<string, unknown>>;
+export interface OperationProfile {
+    readonly operation: string;
+    readonly limits: Record<string, number>;
+    readonly defaults: Record<string, JsonValue | undefined>;
+}
+export interface ArtifactProfileRules {
+    readonly lengthUnit: 'utf16';
+    readonly textEncoding: 'utf8';
+    readonly callerKeyNormalization: 'none';
+    readonly rejectLoneSurrogates: true;
+    readonly provenance: 'inline-original';
+    readonly keyDerivationAlgorithm: string;
+    readonly pathMaxBytes: number;
+    readonly forbiddenPathPattern: string;
+    readonly reservedFirstSegments: readonly string[];
+    readonly mimeTypes: readonly string[];
+}
+export interface ArtifactProviderProfile {
+    readonly version: typeof PROFILE_CONTRACT_VERSION;
+    readonly selectedCapabilities: readonly string[];
+    readonly operations: readonly OperationProfile[];
+    readonly contractRevisions: Record<string, string>;
+    /** Omission selects the fixed v1 semantics, never a capability selection. */
+    readonly rules?: ArtifactProfileRules;
+}
+export interface EffectiveArtifactProfile extends ArtifactProviderProfile {
+    readonly rules: ArtifactProfileRules;
+}
+export interface CompiledArtifactsProfile extends EffectiveArtifactProfile {
+    readonly selectedCapabilities: readonly ArtifactCapabilityName[];
+    readonly profile: EffectiveArtifactProfile;
+    readonly profileDigest: string;
+    readonly validators: CompiledValidators;
+    readonly schemas: Readonly<Partial<Record<ArtifactCapabilityName, ArtifactSchema>>>;
+    readonly idempotency: Readonly<Partial<Record<ArtifactCapabilityName, {
+        readonly required: true;
+        readonly scope: 'principal';
+    }>>>;
+    validate(name: string, args: unknown, envelopeKey?: string): Readonly<Record<string, JsonValue>>;
+    assertSelected(name: string): asserts name is ArtifactCapabilityName;
+    capabilityForRoute(method: string, path: string): ArtifactCapabilityName | undefined;
+}
+export interface CompiledValidators {
+    readonly validateBindingName: (value: unknown) => boolean;
+    readonly validateCallerKey: (value: unknown) => boolean;
+    readonly validateFileEntry: (entry: unknown) => boolean;
+    readonly normalizeCommand: (command: unknown) => EffectiveArtifactCommand;
+}
+/** Projection fields are data-only; invocation correlation is added by L6. */
+export declare class ArtifactProfileInputError extends Error {
+    readonly kind: 'operational' | 'ordinary';
+    readonly status: number;
+    readonly httpStatus: number;
+    readonly variant: 'unselected_operation' | 'invalid_request';
+    readonly publicCode: string;
+    readonly category: 'invalid_request' | 'capability_unselected';
+    readonly retriable = false;
+    readonly phase: 'selection' | 'entry';
+    readonly commitState = "not_committed";
+    constructor(unselected?: boolean);
+}

package/dist/profile/contracts.js

@@ -0,0 +1,31 @@
+export const PROFILE_CONTRACT_VERSION = 'artifacts-profile/v1';
+export const ARTIFACT_CAPABILITY_NAMES = [
+    'artifacts_get_template', 'artifacts_get_api_guide', 'artifacts_ensure',
+    'artifacts_publish', 'artifacts_create_upload', 'artifacts_commit_upload',
+    'artifacts_list', 'artifacts_get', 'artifacts_get_source', 'artifacts_fork',
+    'artifacts_set_access', 'artifacts_promote', 'artifacts_renew',
+    'artifacts_delete', 'artifacts_restore',
+];
+/** Projection fields are data-only; invocation correlation is added by L6. */
+export class ArtifactProfileInputError extends Error {
+    kind;
+    status;
+    httpStatus;
+    variant;
+    publicCode;
+    category;
+    retriable = false;
+    phase;
+    commitState = 'not_committed';
+    constructor(unselected = false) {
+        super(unselected ? 'capability_unavailable' : 'invalid_request');
+        this.name = 'ArtifactProfileInputError';
+        this.kind = unselected ? 'operational' : 'ordinary';
+        this.status = unselected ? 503 : 400;
+        this.httpStatus = this.status;
+        this.variant = unselected ? 'unselected_operation' : 'invalid_request';
+        this.publicCode = this.message;
+        this.category = unselected ? 'capability_unselected' : 'invalid_request';
+        this.phase = unselected ? 'selection' : 'entry';
+    }
+}

package/dist/profile/index.d.ts

@@ -0,0 +1,6 @@
+import { type ArtifactProviderProfile, type CompiledArtifactsProfile } from './contracts.js';
+export * from './contracts.js';
+export { RADAR_ARTIFACTS_PROFILE } from './radar.js';
+export declare function assertCompiledArtifactsProfile(value: unknown): asserts value is CompiledArtifactsProfile;
+/** Compile once, before any registry, adapter, schema or integrity evidence. */
+export declare function compileArtifactsProfile(input: ArtifactProviderProfile): CompiledArtifactsProfile;