cognitive-modules-cli 2.2.11 → 2.2.12

package/dist/commands/conformance.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Conformance Command
+ *
+ * Goal: make "official vectors" runnable as a stable contract surface.
+ * This is intentionally offline and deterministic: it validates static vectors
+ * against the JSON Schemas in `spec/`.
+ */
+import type { CommandContext, CommandResult } from '../types.js';
+type ConformanceLevel = 1 | 2 | 3;
+type ConformanceSuite = 'envelope' | 'stream' | 'registry' | 'runtime' | 'all';
+export type ConformanceFailurePhase = 'read' | 'parse' | 'schema' | 'entry' | 'event' | 'end.result' | 'runtime.invoke' | 'runtime.expect';
+export type ConformanceVectorResult = {
+    file: string;
+    name: string;
+    expects: 'accept' | 'reject';
+    level: number;
+    passed: boolean;
+    isValid: boolean;
+    phase?: ConformanceFailurePhase;
+    error?: string;
+};
+export type ConformanceRunResult = {
+    spec_dir: string;
+    suite: ConformanceSuite;
+    level: ConformanceLevel;
+    total: number;
+    passed: number;
+    failed: number;
+    results: ConformanceVectorResult[];
+};
+export type ConformanceOptions = {
+    specDir?: string;
+    suite?: ConformanceSuite;
+    level?: number;
+    verbose?: boolean;
+    json?: boolean;
+};
+export declare function conformance(ctx: CommandContext, options?: ConformanceOptions): Promise<CommandResult>;
+export {};

package/dist/commands/conformance.js

@@ -0,0 +1,517 @@
+/**
+ * Conformance Command
+ *
+ * Goal: make "official vectors" runnable as a stable contract surface.
+ * This is intentionally offline and deterministic: it validates static vectors
+ * against the JSON Schemas in `spec/`.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import _Ajv from 'ajv';
+const Ajv = _Ajv.default || _Ajv;
+import _addFormats from 'ajv-formats';
+const addFormats = _addFormats.default || _addFormats;
+import { runModule } from '../modules/runner.js';
+import { resolveExecutionPolicy } from '../profile.js';
+function findJsonFiles(dir) {
+    const out = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            out.push(...findJsonFiles(full));
+        else if (entry.isFile() && entry.name.endsWith('.json'))
+            out.push(full);
+    }
+    return out.sort();
+}
+function detectSpecDir(startCwd) {
+    // Search upward for `<root>/spec/response-envelope.schema.json`.
+    let cur = startCwd;
+    for (let i = 0; i < 20; i++) {
+        const specDir = path.join(cur, 'spec');
+        const schema = path.join(specDir, 'response-envelope.schema.json');
+        if (fs.existsSync(schema))
+            return specDir;
+        const parent = path.dirname(cur);
+        if (parent === cur)
+            break;
+        cur = parent;
+    }
+    return null;
+}
+function normalizeSpecDir(specDirRaw) {
+    const p = path.resolve(specDirRaw);
+    // Accept either `<root>/spec` or `<root>` (and normalize to `<root>/spec`).
+    if (path.basename(p) !== 'spec') {
+        const candidate = path.join(p, 'spec');
+        if (fs.existsSync(path.join(candidate, 'response-envelope.schema.json')))
+            return candidate;
+    }
+    return p;
+}
+function readJson(p) {
+    const raw = fs.readFileSync(p, 'utf8');
+    return JSON.parse(raw);
+}
+function relFromSpec(specDir, file) {
+    // Prefer paths like `spec/test-vectors/...` instead of absolute paths.
+    const root = path.dirname(specDir);
+    return path.relative(root, file);
+}
+function clampLevel(n) {
+    const v = Number(n ?? 1);
+    if (v === 1 || v === 2 || v === 3)
+        return v;
+    throw new Error(`Invalid conformance level: ${String(n)} (expected 1|2|3)`);
+}
+function clampSuite(s) {
+    const v = (s ?? 'envelope').trim();
+    if (v === 'envelope' || v === 'stream' || v === 'registry' || v === 'runtime' || v === 'all')
+        return v;
+    throw new Error(`Invalid --suite: ${v} (expected envelope|stream|registry|runtime|all)`);
+}
+function formatAjvErrors(errors) {
+    const list = errors ?? [];
+    return list.map(e => `${e.instancePath ?? ''} ${e.message ?? ''}`.trim()).join('; ');
+}
+function validateEnvelopeVectors(specDir, level) {
+    const schemaPath = path.join(specDir, 'response-envelope.schema.json');
+    const vectorsDir = path.join(specDir, 'test-vectors');
+    const ajv = new Ajv({ allErrors: true, strict: false });
+    addFormats(ajv);
+    const schema = readJson(schemaPath);
+    const validate = ajv.compile(schema);
+    const files = fs.existsSync(vectorsDir) ? findJsonFiles(vectorsDir) : [];
+    const results = [];
+    for (const file of files) {
+        let meta;
+        let envelope;
+        try {
+            const parsed = readJson(file);
+            meta = parsed?.$test ?? {};
+            envelope = parsed?.envelope ?? {};
+        }
+        catch (e) {
+            results.push({
+                file: relFromSpec(specDir, file),
+                name: path.basename(file),
+                expects: 'reject',
+                level: 1,
+                passed: false,
+                isValid: false,
+                phase: 'parse',
+                error: e instanceof Error ? e.message : String(e),
+            });
+            continue;
+        }
+        const vecLevel = Number(meta?.conformance_level ?? 1);
+        if (vecLevel > level)
+            continue;
+        const expects = (meta?.expects ?? 'accept');
+        const name = (meta?.name ?? path.basename(file, '.json'));
+        const valid = Boolean(validate(envelope));
+        const error = valid ? undefined : formatAjvErrors(validate.errors);
+        const passed = expects === 'accept' ? valid : !valid;
+        results.push({
+            file: relFromSpec(specDir, file),
+            name,
+            expects,
+            level: vecLevel,
+            passed,
+            isValid: valid,
+            phase: valid ? undefined : 'schema',
+            error,
+        });
+    }
+    return results;
+}
+function validateStreamVectors(specDir, level) {
+    const eventsSchemaPath = path.join(specDir, 'stream-events.schema.json');
+    const envelopeSchemaPath = path.join(specDir, 'response-envelope.schema.json');
+    const vectorsDir = path.join(specDir, 'stream-vectors');
+    const ajv = new Ajv({ allErrors: true, strict: false });
+    addFormats(ajv);
+    const eventsSchema = readJson(eventsSchemaPath);
+    const envelopeSchema = readJson(envelopeSchemaPath);
+    const validateEvent = ajv.compile(eventsSchema);
+    const validateEnvelope = ajv.compile(envelopeSchema);
+    const files = fs.existsSync(vectorsDir) ? findJsonFiles(vectorsDir) : [];
+    const results = [];
+    for (const file of files) {
+        let vector;
+        try {
+            vector = readJson(file);
+        }
+        catch (e) {
+            results.push({
+                file: relFromSpec(specDir, file),
+                name: path.basename(file),
+                expects: 'reject',
+                level: 1,
+                passed: false,
+                isValid: false,
+                phase: 'parse',
+                error: e instanceof Error ? e.message : String(e),
+            });
+            continue;
+        }
+        const meta = vector?.$test ?? {};
+        const expects = (meta?.expects ?? 'accept');
+        const vecLevel = Number(meta?.conformance_level ?? 1);
+        if (vecLevel > level)
+            continue;
+        const name = (meta?.name ?? path.basename(file, '.json'));
+        let ok = true;
+        let err = '';
+        let phase;
+        try {
+            if (!Array.isArray(vector?.events)) {
+                throw new Error('events must be an array');
+            }
+            for (const ev of vector.events) {
+                if (!validateEvent(ev)) {
+                    phase = 'event';
+                    throw new Error(`event invalid: ${formatAjvErrors(validateEvent.errors)}`);
+                }
+                const evAny = ev;
+                if (evAny?.type === 'end') {
+                    const env = evAny?.result;
+                    if (!validateEnvelope(env)) {
+                        phase = 'end.result';
+                        throw new Error(`end.result invalid envelope: ${formatAjvErrors(validateEnvelope.errors)}`);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            ok = false;
+            err = e instanceof Error ? e.message : String(e);
+        }
+        const passed = expects === 'accept' ? ok : !ok;
+        results.push({
+            file: relFromSpec(specDir, file),
+            name,
+            expects,
+            level: vecLevel,
+            passed,
+            isValid: ok,
+            phase: ok ? undefined : (phase ?? 'schema'),
+            error: ok ? undefined : err,
+        });
+    }
+    return results;
+}
+function validateRegistryVectors(specDir, level) {
+    const registrySchemaPath = path.join(specDir, 'registry.schema.json');
+    const entrySchemaPath = path.join(specDir, 'registry-entry.schema.json');
+    const vectorsDir = path.join(specDir, 'registry-vectors');
+    const repoRoot = path.dirname(specDir);
+    const ajv = new Ajv({ allErrors: true, strict: false });
+    addFormats(ajv);
+    const registrySchema = readJson(registrySchemaPath);
+    const entrySchema = readJson(entrySchemaPath);
+    // The registry schema references the entry schema via $ref. Add aliases so Ajv resolves offline.
+    ajv.addSchema(entrySchema, 'https://cognitive-modules.dev/schema/registry-entry-v1.json');
+    ajv.addSchema(entrySchema, 'registry-entry.schema.json');
+    ajv.addSchema(entrySchema, 'https://cognitive-modules.dev/schema/registry-entry.schema.json');
+    const validateRegistry = ajv.compile(registrySchema);
+    const validateEntry = ajv.compile(entrySchema);
+    const files = fs.existsSync(vectorsDir) ? findJsonFiles(vectorsDir) : [];
+    // Also validate the repo's published registry file (if present).
+    const publishedRegistryPath = path.join(repoRoot, 'cognitive-registry.v2.json');
+    if (fs.existsSync(publishedRegistryPath))
+        files.unshift(publishedRegistryPath);
+    const results = [];
+    for (const file of files) {
+        let parsed;
+        try {
+            parsed = readJson(file);
+        }
+        catch (e) {
+            results.push({
+                file: relFromSpec(specDir, file),
+                name: path.basename(file),
+                expects: 'reject',
+                level: 1,
+                passed: false,
+                isValid: false,
+                phase: 'parse',
+                error: e instanceof Error ? e.message : String(e),
+            });
+            continue;
+        }
+        const isVector = parsed && typeof parsed === 'object' && '$test' in parsed && 'registry' in parsed;
+        const meta = (isVector ? parsed.$test : null) ?? { name: path.basename(file), expects: 'accept', conformance_level: 1 };
+        const expects = (meta?.expects ?? 'accept');
+        const vecLevel = Number(meta?.conformance_level ?? 1);
+        if (vecLevel > level)
+            continue;
+        const name = (meta?.name ?? path.basename(file, '.json'));
+        let ok = true;
+        let err = '';
+        let phase;
+        try {
+            const registryObj = isVector ? parsed.registry : parsed;
+            if (!registryObj || typeof registryObj !== 'object')
+                throw new Error('registry must be an object');
+            if (!validateRegistry(registryObj)) {
+                phase = 'schema';
+                throw new Error(`registry invalid: ${formatAjvErrors(validateRegistry.errors)}`);
+            }
+            const modules = registryObj.modules ?? {};
+            if (typeof modules !== 'object' || Array.isArray(modules)) {
+                phase = 'schema';
+                throw new Error('registry.modules must be an object map');
+            }
+            for (const [modName, entry] of Object.entries(modules)) {
+                if (!validateEntry(entry)) {
+                    phase = 'entry';
+                    throw new Error(`entry '${modName}' invalid: ${formatAjvErrors(validateEntry.errors)}`);
+                }
+            }
+        }
+        catch (e) {
+            ok = false;
+            err = e instanceof Error ? e.message : String(e);
+        }
+        const passed = expects === 'accept' ? ok : !ok;
+        results.push({
+            file: relFromSpec(specDir, file),
+            name,
+            expects,
+            level: vecLevel,
+            passed,
+            isValid: ok,
+            phase: ok ? undefined : (phase ?? 'schema'),
+            error: ok ? undefined : err,
+        });
+    }
+    return results;
+}
+class VectorProvider {
+    name = 'vector';
+    calls = 0;
+    caps;
+    queue;
+    constructor(caps, queue) {
+        this.caps = caps;
+        this.queue = [...queue];
+    }
+    isConfigured() {
+        return true;
+    }
+    getCapabilities() {
+        return this.caps;
+    }
+    async invoke() {
+        this.calls++;
+        const next = this.queue.shift();
+        if (!next)
+            return { content: '' };
+        if (next.error)
+            throw new Error(next.error);
+        return { content: String(next.content ?? '') };
+    }
+}
+async function validateRuntimeVectors(specDir, level) {
+    const envelopeSchemaPath = path.join(specDir, 'response-envelope.schema.json');
+    const vectorsDir = path.join(specDir, 'runtime-vectors');
+    const validDir = path.join(vectorsDir, 'valid');
+    const invalidDir = path.join(vectorsDir, 'invalid');
+    const ajv = new Ajv({ allErrors: true, strict: false });
+    addFormats(ajv);
+    const envelopeSchema = readJson(envelopeSchemaPath);
+    const validateEnvelope = ajv.compile(envelopeSchema);
+    // Only treat `valid/` and `invalid/` as vectors (ignore fixtures and other JSON files).
+    const files = [
+        ...(fs.existsSync(validDir) ? findJsonFiles(validDir) : []),
+        ...(fs.existsSync(invalidDir) ? findJsonFiles(invalidDir) : []),
+    ];
+    const results = [];
+    for (const file of files) {
+        let vector;
+        try {
+            vector = readJson(file);
+        }
+        catch (e) {
+            results.push({
+                file: relFromSpec(specDir, file),
+                name: path.basename(file),
+                expects: 'reject',
+                level: 1,
+                passed: false,
+                isValid: false,
+                phase: 'parse',
+                error: e instanceof Error ? e.message : String(e),
+            });
+            continue;
+        }
+        const meta = vector?.$test ?? {};
+        const expects = (meta?.expects ?? 'accept');
+        const vecLevel = Number(meta?.conformance_level ?? 2);
+        if (vecLevel > level)
+            continue;
+        const name = (meta?.name ?? path.basename(file, '.json'));
+        let ok = true;
+        let err = '';
+        let phase;
+        try {
+            const rt = vector.runtime;
+            if (!rt)
+                throw new Error('runtime must be present');
+            const policy = resolveExecutionPolicy({
+                profile: rt.policy?.profile ?? 'standard',
+                validate: rt.policy?.validate ?? null,
+                noValidate: rt.policy?.noValidate ?? false,
+                audit: rt.policy?.audit ?? false,
+                structured: rt.policy?.structured ?? null,
+            });
+            const moduleFromVec = rt.module ?? {};
+            // Allow vectors to reference repo-relative module locations so the suite is portable.
+            const repoRoot = path.dirname(specDir);
+            const locRaw = moduleFromVec.location ?? file;
+            const loc = typeof locRaw === 'string' && locRaw.trim() && !path.isAbsolute(locRaw)
+                ? path.resolve(repoRoot, locRaw)
+                : locRaw;
+            const mod = {
+                name: moduleFromVec.name ?? 'vector',
+                version: moduleFromVec.version ?? '0.0.0',
+                responsibility: moduleFromVec.responsibility ?? 'vector',
+                prompt: moduleFromVec.prompt ?? 'Return JSON only.',
+                excludes: moduleFromVec.excludes ?? [],
+                format: moduleFromVec.format ?? 'v2',
+                formatVersion: moduleFromVec.formatVersion ?? 'v2.2',
+                tier: moduleFromVec.tier ?? 'decision',
+                ...moduleFromVec,
+                // Ensure the resolved location wins over the raw vector string.
+                location: loc,
+            };
+            const caps = rt.provider?.capabilities ?? { structuredOutput: 'prompt', streaming: false };
+            const provider = new VectorProvider(caps, rt.provider?.responses ?? []);
+            const res = await runModule(mod, provider, {
+                args: rt.args,
+                input: rt.input,
+                useV22: true,
+                policy,
+            });
+            if (!validateEnvelope(res)) {
+                phase = 'schema';
+                throw new Error(`result invalid envelope: ${formatAjvErrors(validateEnvelope.errors)}`);
+            }
+            const exp = rt.expect ?? {};
+            if (typeof exp.invocations === 'number' && provider.calls !== exp.invocations) {
+                phase = 'runtime.expect';
+                throw new Error(`expected invocations=${exp.invocations}, got=${provider.calls}`);
+            }
+            if (typeof exp.ok === 'boolean' && res.ok !== exp.ok) {
+                phase = 'runtime.expect';
+                throw new Error(`expected ok=${String(exp.ok)}, got=${String(res.ok)}`);
+            }
+            if (exp.error_code) {
+                const code = res?.error?.code;
+                if (code !== exp.error_code) {
+                    phase = 'runtime.expect';
+                    throw new Error(`expected error.code=${exp.error_code}, got=${String(code)}`);
+                }
+            }
+            if (typeof exp.parse_retries === 'number') {
+                const retries = res?.meta?.policy?.parse?.retries;
+                if (retries !== exp.parse_retries) {
+                    phase = 'runtime.expect';
+                    throw new Error(`expected meta.policy.parse.retries=${exp.parse_retries}, got=${String(retries)}`);
+                }
+            }
+            if (exp.parse_strategy) {
+                const strategy = res?.meta?.policy?.parse?.strategy;
+                if (strategy !== exp.parse_strategy) {
+                    phase = 'runtime.expect';
+                    throw new Error(`expected meta.policy.parse.strategy=${exp.parse_strategy}, got=${String(strategy)}`);
+                }
+            }
+            if (typeof exp.parse_retry_attempted === 'boolean') {
+                const attempted = res?.error?.details?.parse_retry?.attempted;
+                if (attempted !== exp.parse_retry_attempted) {
+                    phase = 'runtime.expect';
+                    throw new Error(`expected error.details.parse_retry.attempted=${String(exp.parse_retry_attempted)}, got=${String(attempted)}`);
+                }
+            }
+        }
+        catch (e) {
+            ok = false;
+            err = e instanceof Error ? e.message : String(e);
+        }
+        const passed = expects === 'accept' ? ok : !ok;
+        results.push({
+            file: relFromSpec(specDir, file),
+            name,
+            expects,
+            level: vecLevel,
+            passed,
+            isValid: ok,
+            phase: ok ? undefined : (phase ?? 'runtime.expect'),
+            error: ok ? undefined : err,
+        });
+    }
+    return results;
+}
+export async function conformance(ctx, options = {}) {
+    const suite = clampSuite(options.suite);
+    const level = clampLevel(options.level);
+    const specDir = options.specDir ? normalizeSpecDir(options.specDir) : (detectSpecDir(ctx.cwd) ?? '');
+    if (!specDir) {
+        return {
+            success: false,
+            error: 'Spec directory not found. Run from a repo checkout or pass --spec-dir <path-to-repo-or-spec>.',
+        };
+    }
+    const envelopeSchema = path.join(specDir, 'response-envelope.schema.json');
+    if (!fs.existsSync(envelopeSchema)) {
+        return {
+            success: false,
+            error: `Spec directory is missing response-envelope.schema.json: ${specDir}`,
+        };
+    }
+    let results = [];
+    try {
+        if (suite === 'envelope' || suite === 'all') {
+            results = results.concat(validateEnvelopeVectors(specDir, level));
+        }
+        if (suite === 'stream' || suite === 'all') {
+            results = results.concat(validateStreamVectors(specDir, level));
+        }
+        if (suite === 'registry' || suite === 'all') {
+            results = results.concat(validateRegistryVectors(specDir, level));
+        }
+        if (suite === 'runtime' || suite === 'all') {
+            results = results.concat(await validateRuntimeVectors(specDir, level));
+        }
+    }
+    catch (e) {
+        return { success: false, error: e instanceof Error ? e.message : String(e) };
+    }
+    const passed = results.filter(r => r.passed).length;
+    const failed = results.length - passed;
+    const data = {
+        spec_dir: specDir,
+        suite,
+        level,
+        total: results.length,
+        passed,
+        failed,
+        results,
+    };
+    if (options.verbose && failed > 0) {
+        for (const r of results) {
+            if (r.passed)
+                continue;
+            // eslint-disable-next-line no-console
+            console.error(`FAIL [${r.phase ?? 'unknown'}] ${r.file}: ${r.error ?? 'invalid'}`);
+        }
+    }
+    return {
+        success: failed === 0,
+        data,
+        error: failed === 0 ? undefined : `${failed} conformance vector(s) failed`,
+    };
+}

package/dist/commands/index.d.ts

@@ -13,5 +13,6 @@ export * from './compose.js';
 export * from './validate.js';
 export * from './migrate.js';
 export * from './test.js';
+export * from './conformance.js';
 export * from './search.js';
 export * from './core.js';

package/dist/commands/index.js

@@ -13,5 +13,6 @@ export * from './compose.js';
 export * from './validate.js';
 export * from './migrate.js';
 export * from './test.js';
+export * from './conformance.js';
 export * from './search.js';
 export * from './core.js';

package/dist/commands/pipe.js

@@ -28,7 +28,7 @@ export async function pipe(ctx, options) {
             const errorEnvelope = attachContext(makeErrorEnvelope({
                 code: ErrorCodes.INVALID_INPUT,
                 message: `Certified profile requires v2.2 modules; got: ${module.formatVersion ?? 'unknown'} (${module.format})`,
-                suggestion: "Migrate the module to v2.2, or run with `--profile strict` / `--profile default`",
+                suggestion: "Migrate the module to v2.2, or rerun with `--profile standard`",
             }), { module: options.module, provider: ctx.provider.name });
             console.log(JSON.stringify(errorEnvelope));
             return { success: false, error: errorEnvelope.error.message, data: errorEnvelope };
@@ -56,26 +56,11 @@ export async function pipe(ctx, options) {
         catch {
             // Not JSON, use as args
         }
-        const validate = (() => {
-            if (options.noValidate)
-                return false;
-            if (!policy)
-                return true;
-            if (policy.validate === 'off')
-                return false;
-            if (policy.validate === 'on')
-                return true;
-            return policy.profile !== 'core';
-        })();
-        const enableRepair = policy?.enableRepair ?? true;
         // Run module with v2.2 envelope format
         const result = await runModule(module, ctx.provider, {
             args: inputData ? undefined : input,
             input: inputData,
-            validateInput: validate,
-            validateOutput: validate,
             useV22: true, // Always use v2.2 envelope
-            enableRepair,
             policy,
         });
         const output = attachContext(result, {

package/dist/commands/run.js

@@ -44,7 +44,7 @@ export async function run(moduleName, ctx, options = {}) {
             const errorEnvelope = attachContext(makeErrorEnvelope({
                 code: ErrorCodes.INVALID_INPUT,
                 message: `Certified profile requires v2.2 modules; got: ${fv ?? 'unknown'} (${module.format})`,
-                suggestion: "Migrate the module to v2.2 (module.yaml + prompt.md + schema.json), or use `--profile strict` / `--profile default`",
+                suggestion: "Migrate the module to v2.2 (module.yaml + prompt.md + schema.json), or rerun with `--profile standard`",
             }), { module: moduleName, provider: ctx.provider.name });
             return { success: false, error: errorEnvelope.error.message, data: errorEnvelope };
         }
@@ -71,21 +71,6 @@ export async function run(moduleName, ctx, options = {}) {
                 };
             }
         }
-        // Resolve validation/repair policy.
-        // Priority: explicit --no-validate > policy.validate > default(true)
-        const validate = (() => {
-            if (options.noValidate)
-                return false;
-            if (!policy)
-                return true;
-            if (policy.validate === 'off')
-                return false;
-            if (policy.validate === 'on')
-                return true;
-            // auto
-            return policy.profile !== 'core';
-        })();
-        const enableRepair = policy?.enableRepair ?? true;
         if (options.stream) {
             // Stream NDJSON events to stdout. Final exit code is determined by the end event.
             let finalOk = null;
@@ -93,10 +78,7 @@ export async function run(moduleName, ctx, options = {}) {
             for await (const ev of runModuleStream(module, ctx.provider, {
                 args: options.args,
                 input: inputData,
-                validateInput: validate,
-                validateOutput: validate,
                 useV22: true,
-                enableRepair,
                 policy,
             })) {
                 // Write each event as one JSON line (NDJSON).
@@ -132,10 +114,7 @@ export async function run(moduleName, ctx, options = {}) {
                 args: options.args,
                 input: inputData,
                 verbose: options.verbose || ctx.verbose,
-                validateInput: validate,
-                validateOutput: validate,
                 useV22: true, // Always use v2.2 envelope
-                enableRepair,
                 policy,
             });
             const output = attachContext(result, {

package/dist/modules/composition.d.ts

@@ -185,9 +185,9 @@ export declare class CompositionOrchestrator {
     private provider;
     private cwd;
     private searchPaths;
-    private validateInput;
-    private validateOutput;
-    private enableRepair;
+    private validateInput?;
+    private validateOutput?;
+    private enableRepair?;
     private policy?;
     constructor(provider: Provider, cwd?: string, enforcement?: {
         validateInput?: boolean;

package/dist/modules/composition.js

@@ -585,9 +585,10 @@ export class CompositionOrchestrator {
         this.provider = provider;
         this.cwd = cwd;
         this.searchPaths = getDefaultSearchPaths(cwd);
-        this.validateInput = enforcement.validateInput ?? true;
-        this.validateOutput = enforcement.validateOutput ?? true;
-        this.enableRepair = enforcement.enableRepair ?? true;
+        // Leave undefined by default so the runner can apply policy-driven defaults (validate=auto).
+        this.validateInput = enforcement.validateInput;
+        this.validateOutput = enforcement.validateOutput;
+        this.enableRepair = enforcement.enableRepair;
         this.policy = enforcement.policy;
     }
     /**