@voce-engine/cli 0.1.0-rc.2 → 0.1.0-rc.4

package/README.md

@@ -2,8 +2,8 @@
 
 The `voce` command is the offline-first, explicit-path CLI for VOCE v0.1. It does not load lifecycle scripts, discover global packages, inspect credentials, or call a Provider unless the command explicitly selects the built-in `mock` provider.
 
-> `0.1.0-rc.2` is a release candidate, not production-ready. CLI behavior may change before `0.1.0`.
+> `0.1.0-rc.4` is a release candidate, not production-ready. CLI behavior may change before `0.1.0`.
 
 ```bash
-npm install --global @voce-engine/cli@0.1.0-rc.2
+npm install --global @voce-engine/cli@0.1.0-rc.4
 ```

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export declare const CLI_VERSION = "0.1.0-rc.2";
+export declare const CLI_VERSION = "0.1.0-rc.4";
 export declare function runCli(argv?: string[]): Promise<number>;

package/dist/index.js

@@ -2,13 +2,13 @@ import { createHash, randomUUID } from 'node:crypto';
 import { lstat, mkdir, readdir, readFile, realpath, rename, writeFile } from 'node:fs/promises';
 import * as path from 'node:path';
 import * as process from 'node:process';
-import { MOCK_IMAGE_PROFILE, MOCK_JPEG_PROFILE, MOCK_LIMITED_REFERENCE_PROFILE, compileEvaluationReport, computeExecutionRunHash, computeCompilationContextHash, computeOntologyInstanceHash, computeSemanticReviewRequestHash, createConstraintWaiver, createHumanAcceptanceDecision, compileConstraints, createScenarioPackRegistry, executeOffline, executeSemanticReview, FixtureReferenceInterpreter, FixtureSemanticReviewer, guardPromptCandidate, renderStaticTraceReport, sha256, traceModelFromExecution, validateStructuralImage, canonicalize, } from '@voce-engine/core';
+import { MOCK_IMAGE_PROFILE, MOCK_JPEG_PROFILE, MOCK_LIMITED_REFERENCE_PROFILE, compileEvaluationReport, computeExecutionRunHash, computeCompilationContextHash, computeOntologyInstanceHash, computeSemanticReviewRequestHash, createConstraintWaiver, createHumanAcceptanceDecision, compileConstraints, compilePromptIR, createReferenceCandidate, planPipeline, planReferences, createScenarioPackRegistry, executeOffline, executeSemanticReview, FixtureReferenceInterpreter, FixtureSemanticReviewer, guardPromptCandidate, renderStaticTraceReport, sha256, traceModelFromExecution, validateStructuralImage, canonicalize, VISUAL_COMPOSITION_CATALOG, computeVisualCompositionCatalogHash, expandVisualCompositionPreset, } from '@voce-engine/core';
 import { FIXTURE_M6_OPAQUE_PNG, fixtureChangeIntent, fixtureM4ConstraintInput, fixtureM5Candidate, fixtureM5ExecutionInput, fixtureM5GuardInput, fixtureM5PromptIR, fixtureM6Artifact, fixtureM6Authorization, fixtureScopePlan, } from '@voce-engine/testkit';
 import { BUNDLE_MANIFEST_SCHEMA_VERSION } from '@voce-engine/contracts';
-export const CLI_VERSION = '0.1.0-rc.2';
+export const CLI_VERSION = '0.1.0-rc.4';
 const TOOL_ID = '@voce-engine/cli';
-const CONTRACTS_VERSION = '0.1.0-rc.2';
-const CORE_VERSION = '0.1.0-rc.2';
+const CONTRACTS_VERSION = '0.1.0-rc.4';
+const CORE_VERSION = '0.1.0-rc.4';
 const SOURCE_SCHEMA = 'voce.scenario-pack-source/v1alpha1';
 const PACK_SCHEMA = 'voce.scenario-pack/v1alpha1';
 const HASH = /^sha256:[0-9a-f]{64}$/;
@@ -337,17 +337,107 @@ function probeInput(probe, resolution, caseSpec) {
     const requestedScopePlan = fixtureScopePlan(['person.identity'], 'ref-01', caseSpec.id, caseSpec.revision);
     const ontologyBase = { ...base.ontologyInstance, id: `ontology-${probe.id}`, caseId: caseSpec.id, caseRevision: caseSpec.revision, contextHash: context.contextHash, requestedScopePlanHash: requestedScopePlan.planHash, unknownPaths: probe.unknownPaths ?? [], unspecifiedPaths: [], facts: [], conflicts: [], unresolvedItems: [], decisionTrace: [] };
     const ontologyInstance = { ...ontologyBase, instanceHash: computeOntologyInstanceHash({ ...ontologyBase, instanceHash: '' }) };
-    const intents = (probe.intents ?? []).map((intent) => ({ ...fixtureChangeIntent(intent.id, intent.operation, intent.targetPath, intent.requestedValue), importance: intent.importance ?? 'required' }));
+    const intents = (probe.intents ?? []).map((intent) => ({ ...fixtureChangeIntent(intent.id, intent.operation, intent.targetPath, intent.requestedValue), importance: intent.importance ?? 'required', ...(intent.sourceHintIds === undefined ? {} : { sourceHintIds: [...intent.sourceHintIds].sort(compare) }) }));
     const waivers = probe.waiverTarget ? [createConstraintWaiver({ schemaVersion: 'voce.constraint-waiver/v1alpha1', id: `waiver-${probe.id}`, caseId: caseSpec.id, caseRevision: caseSpec.revision, contextHash: context.contextHash, targetId: probe.waiverTarget, authority: 'user', decidedBy: 'fixture-reviewer', reasonCode: 'FIXTURE_EXPLICIT_WAIVER', decidedAt: '2026-01-01T00:00:00.000Z' })] : [];
     return fixtureM4ConstraintInput({ caseId: caseSpec.id, caseRevision: caseSpec.revision, context, contextHash: context.contextHash, requestedScopePlanHash: requestedScopePlan.planHash, ontologyInstance, changeIntents: intents, effectiveScenario: resolution.effectiveScenario, waivers });
 }
-function coreProbeEvidence(probe, resolution, caseSpec) {
-    const ir = compileConstraints(probeInput(probe, resolution, caseSpec));
-    return {
+function pathRelated(left, right) { return left === right || left.startsWith(`${right}.`) || right.startsWith(`${left}.`); }
+function referenceProbeCandidates(probe, ir) {
+    return (probe.references ?? []).map((reference) => {
+        const constraintIds = ir.constraints.filter((constraint) => reference.ontologyScopes.some((scope) => constraint.targetPaths.some((target) => pathRelated(scope, target)))).map((constraint) => constraint.id);
+        const goalIds = ir.goals.filter((goal) => typeof goal.targetPath === 'string' && reference.ontologyScopes.some((scope) => pathRelated(scope, goal.targetPath))).map((goal) => goal.id);
+        const artifact = { id: reference.assetId ?? reference.id, storeId: 'fixture-store', contentHash: sha256({ fixtureReference: reference.id }), mediaType: 'image/png', byteLength: 64, role: 'reference', resolverId: 'fixture-resolver', availability: 'available', retentionClass: 'fixture', redactionPolicy: 'hash-only' };
+        return createReferenceCandidate({ schemaVersion: 'voce.reference-candidate/v1alpha1', id: reference.id, assetId: artifact.id, artifact, contentHash: artifact.contentHash, mediaType: artifact.mediaType, byteLength: artifact.byteLength, role: reference.role, ontologyScopes: reference.ontologyScopes, importance: reference.importance, constraintIds, sourceBindingIds: reference.sourceBindingIds ?? [], goalIds, orderKey: reference.orderKey ?? reference.id });
+    });
+}
+function coreProbeEvidence(probe, resolution, caseSpec, profile) {
+    const baseInput = probeInput(probe, resolution, caseSpec);
+    const ir = compileConstraints(baseInput);
+    const presetInput = { ...baseInput, changeIntents: [...baseInput.changeIntents, ...expandVisualCompositionPreset('rule-of-thirds')] };
+    const presetIr = compileConstraints(presetInput);
+    const evidence = {
         status: ir.status, constraintHash: ir.deterministicSignature, blockingConflictCount: ir.conflicts.filter((item) => item.blocking).length,
         conflictCodes: ir.conflicts.map((item) => item.code).sort(compare), reviewRequirementCount: ir.reviewRequirements.length,
         reviewReasons: ir.reviewRequirements.map((item) => item.reasonCode).sort(compare), waivedWarnings: ir.warnings.filter((item) => item === 'REQUIRED_CONFLICT_WAIVED' || item === 'HARD_CONFLICT_CANNOT_WAIVE').sort(compare),
         degradationCount: ir.degradedPreferences.length, personIntentCount: (probe.intents ?? []).filter((item) => item.targetPath.startsWith('person.')).length,
+        constraintTargetPaths: ir.constraints.flatMap((item) => item.targetPaths).sort(compare),
+        constraintSourceIds: [...new Set(ir.constraints.flatMap((item) => item.sourceIds))].sort(compare),
+        presetId: 'rule-of-thirds', presetConstraintStatus: presetIr.status, presetConstraintHashBefore: ir.deterministicSignature, presetConstraintHashAfter: presetIr.deterministicSignature,
+    };
+    const candidates = referenceProbeCandidates(probe, ir);
+    const presetCandidates = referenceProbeCandidates(probe, presetIr);
+    const maximumReferenceCount = probe.maximumReferenceCount ?? profile.maximumReferenceCount;
+    const plan = planReferences({ schemaVersion: 'voce.reference-planning-input/v1alpha1', caseId: caseSpec.id, caseRevision: caseSpec.revision, contextHash: ir.contextHash, constraintIR: ir, candidates, dependencies: [], profile, budget: { maximumReferenceCount, usedReferenceCount: 0, byteLengthKnown: true, unknownByteLengthAssetIds: [] } });
+    const presetPlan = planReferences({ schemaVersion: 'voce.reference-planning-input/v1alpha1', caseId: caseSpec.id, caseRevision: caseSpec.revision, contextHash: presetIr.contextHash, constraintIR: presetIr, candidates: presetCandidates, dependencies: [], profile, budget: { maximumReferenceCount, usedReferenceCount: 0, byteLengthKnown: true, unknownByteLengthAssetIds: [] } });
+    evidence.referenceStatus = plan.status;
+    evidence.referencePlanHash = plan.planHash;
+    evidence.selectedRoles = plan.ordered.map((item) => item.role).sort(compare);
+    evidence.omittedRoles = plan.omitted.map((item) => candidates.find((candidate) => candidate.id === item.candidateId)?.role ?? item.candidateId).sort(compare);
+    evidence.blockedRoles = plan.blockedReferences.map((item) => candidates.find((candidate) => candidate.id === item.candidateId)?.role ?? item.candidateId).sort(compare);
+    evidence.selectedSourceBindingIds = [...new Set(plan.ordered.flatMap((item) => item.sourceBindingIds))].sort(compare);
+    evidence.presetReferenceCountBefore = plan.ordered.length;
+    evidence.presetReferenceCountAfter = presetPlan.ordered.length;
+    evidence.presetReferencePlanHashBefore = plan.planHash;
+    evidence.presetReferencePlanHashAfter = presetPlan.planHash;
+    if (!probe.references?.length)
+        return evidence;
+    if (ir.status !== 'ok' || plan.status !== 'ok') {
+        evidence.promptStatus = 'blocked';
+        return evidence;
+    }
+    const pipelineResult = planPipeline({ schemaVersion: 'voce.pipeline-planning-input/v1alpha1', caseId: caseSpec.id, caseRevision: caseSpec.revision, contextHash: ir.contextHash, outputContract: probeInput(probe, resolution, caseSpec).outputContract, constraintIR: ir, referencePlan: plan, profile });
+    if (!pipelineResult.pipelinePlan) {
+        evidence.promptStatus = 'blocked';
+        return evidence;
+    }
+    const outputContract = probeInput(probe, resolution, caseSpec).outputContract;
+    const prompt = compilePromptIR({ schemaVersion: 'voce.prompt-compilation-input/v1alpha2', caseId: caseSpec.id, caseRevision: caseSpec.revision, context: probeInput(probe, resolution, caseSpec).context, contextHash: ir.contextHash, constraintIR: ir, referencePlan: plan, pipelinePlan: pipelineResult.pipelinePlan, outputContract, targetAdapter: { id: profile.adapterId, version: profile.version, digest: profile.adapterDigest }, targetCapabilityProfile: { id: profile.id, version: profile.version, digest: profile.profileHash }, effectiveScenario: resolution.effectiveScenario });
+    evidence.promptStatus = 'ok';
+    evidence.promptHash = prompt.deterministicSignature;
+    evidence.promptTargetPaths = ir.constraints.filter((constraint) => prompt.constraintCoverage.some((coverage) => coverage.constraintId === constraint.id && (coverage.sectionIds.length > 0 || coverage.referenceMappingIds.length > 0 || coverage.parameterIds.length > 0))).flatMap((constraint) => constraint.targetPaths).sort(compare);
+    evidence.promptReferenceRoles = prompt.referenceMappings.map((mapping) => mapping.role).sort(compare);
+    return evidence;
+}
+function scenarioContributions(scenario, category) { return scenario[category].filter(isObject); }
+function contributionArray(contributions, field) { return contributions.flatMap((contribution) => Array.isArray(contribution[field]) ? contribution[field].filter(isObject) : []); }
+function semanticCriteriaForScenario(scenario) {
+    const criteria = contributionArray(scenarioContributions(scenario, 'reviewTemplates'), 'criteria').map((criterion) => {
+        const id = stringField(criterion, 'id', 'REVIEW_TEMPLATE_INVALID');
+        const kind = stringField(criterion, 'kind', 'REVIEW_TEMPLATE_INVALID');
+        const importance = criterion.importance;
+        if (importance !== 'hard' && importance !== 'required' && importance !== 'preferred')
+            throw new CliError('REVIEW_TEMPLATE_INVALID', 'Review criterion importance is invalid.', EXIT.contract);
+        if (criterion.targetPath !== undefined && typeof criterion.targetPath !== 'string')
+            throw new CliError('REVIEW_TEMPLATE_INVALID', 'Review criterion targetPath is invalid.', EXIT.contract);
+        if (criterion.prompt !== undefined && typeof criterion.prompt !== 'string')
+            throw new CliError('REVIEW_TEMPLATE_INVALID', 'Review criterion prompt is invalid.', EXIT.contract);
+        return { id, kind, importance, ...(criterion.targetPath === undefined ? {} : { targetPath: criterion.targetPath }), ...(criterion.prompt === undefined ? {} : { prompt: criterion.prompt }) };
+    });
+    const byId = new Map();
+    for (const criterion of criteria.sort((left, right) => compare(left.id, right.id))) {
+        const prior = byId.get(criterion.id);
+        if (prior && canonicalize(prior) !== canonicalize(criterion))
+            throw new CliError('REVIEW_TEMPLATE_ID_COLLISION', 'Review criteria with one ID disagree.', EXIT.contract);
+        byId.set(criterion.id, criterion);
+    }
+    return [...byId.values()];
+}
+function scenarioEvidence(scenario) {
+    const ontology = contributionArray(scenarioContributions(scenario, 'ontologyVocabulary'), 'paths');
+    const scopes = scenarioContributions(scenario, 'interpretationScopes');
+    const bindings = contributionArray(scopes, 'bindings');
+    const promptDefinitions = contributionArray(scenarioContributions(scenario, 'promptSections'), 'sections');
+    const promptPaths = promptDefinitions.flatMap((definition) => Array.isArray(definition.requiredPaths) ? definition.requiredPaths.filter((item) => typeof item === 'string') : []);
+    const promptSectionOrder = promptDefinitions.map((definition) => ({ id: String(definition.id ?? ''), order: typeof definition.order === 'number' ? definition.order : 0 })).filter((item) => item.id).sort((left, right) => left.order - right.order || compare(left.id, right.id)).map((item) => item.id);
+    const criteria = semanticCriteriaForScenario(scenario);
+    return {
+        ontologyPaths: ontology.map((item) => String(item.path ?? '')).filter(Boolean).sort(compare),
+        bindingPolicies: bindings.map((item) => `${String(item.assetRole ?? '')}|${String(item.relation ?? '')}|${String(item.targetPath ?? '')}|${String(item.priority ?? '')}`).sort(compare),
+        promptTargetPaths: [...new Set(promptPaths)].sort(compare),
+        promptSectionOrder,
+        visualComposition: { catalogId: VISUAL_COMPOSITION_CATALOG.id, catalogHash: computeVisualCompositionCatalogHash(), pathCount: VISUAL_COMPOSITION_CATALOG.paths.length, presetCount: VISUAL_COMPOSITION_CATALOG.presets.length, fullShotChanges: expandVisualCompositionPreset('full-shot').map((item) => ({ targetPath: item.targetPath, ...(item.requestedValue === undefined ? {} : { requestedValue: item.requestedValue }) })) },
+        reviewCriterionIds: criteria.map((item) => item.id).sort(compare),
+        reviewTargetPaths: criteria.map((item) => item.targetPath).filter((item) => typeof item === 'string').sort(compare),
     };
 }
 function referenceEvidence(fixture, resolution, caseSpec) {
@@ -406,13 +496,13 @@ function profileFor(id) {
 async function loadProfile(filePath) { const object = record(await readJson(path.resolve(filePath), 'PROFILE_FILE_UNSAFE'), 'PROFILE_JSON_INVALID'); return profileFor(stringField(object, 'id', 'PROFILE_INVALID')); }
 function profilePin(profile) { return { id: profile.id, version: profile.version, digest: profile.profileHash }; }
 function toolPin(id, version) { return { id, version, digest: sha256({ id, version }) }; }
-function defaultCase(doc, packId) {
+function defaultCase(doc, packId, packVersion) {
     assertKnown(doc, ['schemaVersion', 'id', 'revision', 'fixtureId', 'mode', 'scenario', 'userIntent', 'assets', 'trustedMetadata', 'policies', 'requestedOutput'], 'CASE_UNKNOWN_FIELD');
     const id = typeof doc.id === 'string' ? doc.id : `${packId}-case`;
     const revision = typeof doc.revision === 'number' ? doc.revision : 1;
     const output = isObject(doc.requestedOutput) ? doc.requestedOutput : { artifactKind: 'image', dataType: 'image', mediaTypes: ['image/png'], cardinality: { min: 1, max: 1 }, background: 'opaque', allowAlpha: false };
     const asset = { id: 'ref-01', storeId: 'fixture-store', contentHash: sha256({ fixture: `${id}:ref-01` }), mediaType: 'image/png', byteLength: 64, role: 'reference', resolverId: 'fixture-resolver', availability: 'available', retentionClass: 'fixture', redactionPolicy: 'hash-only' };
-    return { schemaVersion: 'voce.case-spec/v1alpha1', id, revision, mode: 'manual', scenario: { root: { packId, versionRange: '0.1.0' }, extensions: [] }, userIntent: typeof doc.userIntent === 'string' ? doc.userIntent : 'Offline fixture case.', assets: [asset], trustedMetadata: [], policies: { schemaVersion: 'voce.case-policies/v1alpha1', observationConfirmation: 'explicit', bindingConfirmation: 'explicit', allowDeclaredDefaults: true }, requestedOutput: output };
+    return { schemaVersion: 'voce.case-spec/v1alpha1', id, revision, mode: 'manual', scenario: { root: { packId, versionRange: packVersion }, extensions: [] }, userIntent: typeof doc.userIntent === 'string' ? doc.userIntent : 'Offline fixture case.', assets: [asset], trustedMetadata: [], policies: { schemaVersion: 'voce.case-policies/v1alpha1', observationConfirmation: 'explicit', bindingConfirmation: 'explicit', allowDeclaredDefaults: true }, requestedOutput: output };
 }
 async function compileInputs(casePath, scenarioPath, profilePath) {
     const caseDoc = record(await readJson(path.resolve(casePath), 'CASE_FILE_UNSAFE'), 'CASE_JSON_INVALID');
@@ -422,14 +512,14 @@ async function compileInputs(casePath, scenarioPath, profilePath) {
     const resolution = registry.resolve({ root: { packId: loaded.descriptor.manifest.packId, versionRange: loaded.descriptor.manifest.version }, extensions: [] });
     if (resolution.status !== 'resolved')
         throw new CliError('PACK_RESOLUTION_BLOCKED', 'ScenarioPack resolution is blocked.', EXIT.contract);
-    const caseSpec = defaultCase(caseDoc, loaded.descriptor.manifest.packId);
+    const caseSpec = defaultCase(caseDoc, loaded.descriptor.manifest.packId, loaded.descriptor.manifest.version);
     const fixtureId = typeof caseDoc.fixtureId === 'string' ? caseDoc.fixtureId : caseSpec.id;
     const fixture = loaded.fixtures.find((candidate) => candidate.id === fixtureId) ?? loaded.fixtures[0] ?? { id: fixtureId, profileId: MOCK_IMAGE_PROFILE.id };
     const profile = await loadProfile(profilePath);
     const prompt = fixtureM5Candidate(fixtureM5PromptIR(profile));
     const input = fixtureM5ExecutionInput(profile);
-    const coreProbes = Object.fromEntries((fixture.coreProbes ?? []).sort((left, right) => compare(left.id, right.id)).map((probe) => [probe.id, coreProbeEvidence(probe, resolution, caseSpec)]));
-    const acceptance = { resolution: { status: resolution.status, selectedCount: resolution.report.selected.length, effectiveScenarioHash: resolution.effectiveScenario.effectiveScenarioHash }, reference: referenceEvidence(fixture, resolution, caseSpec), coreProbes, compile: { constraintHash: input.constraintIR.deterministicSignature, referencePlanHash: input.referencePlan.planHash, pipelinePlanHash: input.pipelinePlan.planHash } };
+    const coreProbes = Object.fromEntries((fixture.coreProbes ?? []).sort((left, right) => compare(left.id, right.id)).map((probe) => [probe.id, coreProbeEvidence(probe, resolution, caseSpec, profile)]));
+    const acceptance = { resolution: { status: resolution.status, selectedCount: resolution.report.selected.length, effectiveScenarioHash: resolution.effectiveScenario.effectiveScenarioHash }, scenario: scenarioEvidence(resolution.effectiveScenario), reference: referenceEvidence(fixture, resolution, caseSpec), coreProbes, compile: { constraintHash: input.constraintIR.deterministicSignature, referencePlanHash: input.referencePlan.planHash, pipelinePlanHash: input.pipelinePlan.planHash } };
     return { loaded, resolution, caseSpec, profile, fixture, input, prompt, acceptance };
 }
 function bundlePins(profile, scenario) { return { tool: toolPin(TOOL_ID, CLI_VERSION), core: toolPin('@voce-engine/core', CORE_VERSION), contracts: toolPin('@voce-engine/contracts', CONTRACTS_VERSION), scenario: { id: scenario.descriptor.manifest.packId, version: scenario.descriptor.manifest.version, digest: scenario.descriptor.packageDigest }, profile: profilePin(profile) }; }
@@ -546,12 +636,12 @@ async function compileCommand(args) {
     const written = await writeBundle(outputPath, 'compiled', { id: result.caseSpec.id, revision: result.caseSpec.revision }, bundlePins(result.profile, result.loaded), payload);
     return outputSummary(written.manifest, { promptGuard: guard.status, scenario: result.loaded.descriptor.manifest.packId });
 }
-async function semanticForRun(run, artifacts, profile) {
+async function semanticForRun(run, artifacts, profile, criteria) {
     const reviewer = new FixtureSemanticReviewer();
     const inputHash = sha256({ runId: run.id, artifacts: artifacts.map((item) => item.contentHash).sort() });
     const model = reviewer.version;
     const adapter = { id: 'voce.fixture-semantic-reviewer-adapter', version: '1.0.0', digest: sha256({ id: 'voce.fixture-semantic-reviewer-adapter', version: '1.0.0' }) };
-    const requestBase = { schemaVersion: 'voce.semantic-review-request/v1alpha1', id: `semantic-${run.id}`, caseId: run.caseId, caseRevision: run.caseRevision, contextHash: run.contextHash, inputHash, outputArtifacts: artifacts, criteria: [{ id: 'fixture.semantic', kind: 'semantic_fidelity', importance: 'required', prompt: 'Offline fixture semantic proposal.' }], model, adapter, profile: { id: profile.id, version: profile.version, digest: profile.profileHash }, authorizationId: `semantic-auth-${run.id}`, destination: 'local', allowedEvidenceRegionIds: [], dataCategories: ['image'], budget: { schemaVersion: 'voce.budget/v1alpha1', id: `semantic-budget-${run.id}`, maximumCalls: 1, maximumRetries: 0, timeoutMs: 60_000 } };
+    const requestBase = { schemaVersion: 'voce.semantic-review-request/v1alpha1', id: `semantic-${run.id}`, caseId: run.caseId, caseRevision: run.caseRevision, contextHash: run.contextHash, inputHash, outputArtifacts: artifacts, criteria: criteria.length ? criteria : [{ id: 'fixture.semantic', kind: 'semantic_fidelity', importance: 'required', prompt: 'Offline fixture semantic proposal.' }], model, adapter, profile: { id: profile.id, version: profile.version, digest: profile.profileHash }, authorizationId: `semantic-auth-${run.id}`, destination: 'local', allowedEvidenceRegionIds: [], dataCategories: ['image'], budget: { schemaVersion: 'voce.budget/v1alpha1', id: `semantic-budget-${run.id}`, maximumCalls: 1, maximumRetries: 0, timeoutMs: 60_000 } };
     const request = { ...requestBase, requestHash: computeSemanticReviewRequestHash(requestBase) };
     const authorization = fixtureM6Authorization({ id: request.authorizationId, caseId: request.caseId, caseRevision: request.caseRevision, contextHash: request.contextHash, stepId: request.id, purpose: 'semantic_review', inputHash, artifactHashes: artifacts.map((item) => item.contentHash), adapter, profileDigest: request.profile.digest, destination: 'local', dataCategories: ['image'], budget: request.budget, modelId: model.id, modelVersion: model.version });
     const execution = await executeSemanticReview(reviewer, request, authorization);
@@ -578,11 +668,13 @@ async function runCommand(args) {
     const outputContract = { artifactKind: 'image', dataType: 'image', mediaTypes: ['image/png'], cardinality: { min: 1, max: 1 }, background: 'opaque', allowAlpha: false };
     const structural = validateStructuralImage({ schemaVersion: 'voce.structural-validation-input/v1alpha1', id: `structural-${run.id}`, artifacts: [{ artifact: structuralArtifact, bytes: FIXTURE_M6_OPAQUE_PNG }], outputContract, expectedCardinality: { min: 1, max: 1 } });
     const fixture = bundle.payload.fixture;
+    const scenario = bundle.payload.scenario?.effectiveScenario;
+    const semanticCriteria = scenario ? semanticCriteriaForScenario(scenario) : [];
     let semanticProposal;
     const semanticReceipts = [];
     const reconciliation = [];
     if (fixture?.semanticReview) {
-        const semantic = await semanticForRun(run, [structuralArtifact, ...artifacts], profileFor(String(bundle.payload.profile?.id ?? MOCK_IMAGE_PROFILE.id)));
+        const semantic = await semanticForRun(run, [structuralArtifact, ...artifacts], profileFor(String(bundle.payload.profile?.id ?? MOCK_IMAGE_PROFILE.id)), semanticCriteria);
         semanticProposal = semantic.report;
         semanticReceipts.push(semantic.receipt);
         reconciliation.push(semantic.remote);
@@ -591,7 +683,7 @@ async function runCommand(args) {
     const evaluation = compileEvaluationReport({ run: { id: run.id, technicalOutcome: run.technicalOutcome, state: run.state, contextHash: run.contextHash, pipelinePlanHash: run.pipelinePlanHash, promptArtifactHash: run.promptArtifactHash }, structural, semanticProposal, humanAcceptance: human, cleanup: result.cleanupReceipts, replay: { mode: 'artifact', status: 'available', code: 'REPLAY_AVAILABLE', artifactIds: artifacts.map((item) => item.id) }, artifacts: [structuralArtifact, ...artifacts], sourceHashes: { compiledBundle: bundle.manifest.semanticHash, executionRun: computeExecutionRunHash(run) } });
     const traceModel = traceModelFromExecution({ run, receipts: [...result.receipts, ...semanticReceipts], cleanup: result.cleanupReceipts, reconciliation: [...result.remoteCallRuns, ...reconciliation], artifacts: [structuralArtifact, ...artifacts], structural, semanticProposal, humanAcceptance: human, budgets: input.pipelinePlan.steps.map((step) => step.budget), destinations: input.pipelinePlan.dataTransfers.map((item) => item.destination), constraintHash: input.constraintIR.deterministicSignature, referencePlanHash: input.referencePlan.planHash, promptHash: input.executionAuthorization.promptArtifactHash, warnings: result.reasons });
     const acceptance = isObject(bundle.payload.acceptance) ? clone(bundle.payload.acceptance) : {};
-    const runEvidence = { executionStatus: result.status, executionCode: result.code, receiptCount: result.receipts.length + semanticReceipts.length, receiptAdapters: [...result.receipts, ...semanticReceipts].map((item) => item.adapterId).sort(compare), artifactMediaTypes: artifacts.map((item) => item.mediaType).sort(compare), artifactRoles: artifacts.map((item) => item.role).sort(compare), structuralStatus: structural.status, semanticStatus: semanticProposal?.status ?? 'absent', humanStatus: human?.status ?? 'absent', evaluationStatus: evaluation.status, traceModelPresent: true, traceModelHash: traceModel.modelHash };
+    const runEvidence = { executionStatus: result.status, executionCode: result.code, receiptCount: result.receipts.length + semanticReceipts.length, receiptAdapters: [...result.receipts, ...semanticReceipts].map((item) => item.adapterId).sort(compare), artifactMediaTypes: artifacts.map((item) => item.mediaType).sort(compare), artifactRoles: artifacts.map((item) => item.role).sort(compare), structuralStatus: structural.status, semanticStatus: semanticProposal?.status ?? 'absent', semanticCriterionIds: semanticProposal?.findings.map((item) => item.criterionId).sort(compare) ?? [], semanticFindingStatuses: semanticProposal?.findings.map((item) => item.status).sort(compare) ?? [], humanStatus: human?.status ?? 'absent', evaluationStatus: evaluation.status, traceModelPresent: true, traceModelHash: traceModel.modelHash };
     acceptance.run = runEvidence;
     const runAssertions = fixture ? assertFixtureAssertions(fixture, acceptance, 'run') : [];
     acceptance.assertions = [...(Array.isArray(acceptance.assertions) ? acceptance.assertions : []), ...runAssertions].sort((left, right) => compare(String(left.id), String(right.id)));
@@ -615,15 +707,16 @@ async function packTestCommand(source) {
     const resolution = registry.resolve({ root: { packId: loaded.descriptor.manifest.packId, versionRange: loaded.descriptor.manifest.version }, extensions: [] });
     if (resolution.status !== 'resolved')
         throw new CliError('PACK_RESOLUTION_BLOCKED', 'ScenarioPack resolution is blocked.', EXIT.contract);
+    const semanticCriteria = semanticCriteriaForScenario(resolution.effectiveScenario);
     const results = [];
     for (const fixture of loaded.fixtures) {
         const profile = profileFor(fixture.profileId ?? MOCK_IMAGE_PROFILE.id);
-        const caseSpec = defaultCase({ id: fixture.id }, loaded.descriptor.manifest.packId);
+        const caseSpec = defaultCase({ id: fixture.id }, loaded.descriptor.manifest.packId, loaded.descriptor.manifest.version);
         const input = fixtureM5ExecutionInput(profile);
         const prompt = fixtureM5Candidate(fixtureM5PromptIR(profile));
         const guard = guardPromptCandidate(fixtureM5GuardInput(fixtureM5PromptIR(profile), prompt));
-        const coreProbes = Object.fromEntries((fixture.coreProbes ?? []).sort((left, right) => compare(left.id, right.id)).map((probe) => [probe.id, coreProbeEvidence(probe, resolution, caseSpec)]));
-        const acceptance = { resolution: { status: resolution.status, selectedCount: resolution.report.selected.length, effectiveScenarioHash: resolution.effectiveScenario.effectiveScenarioHash }, reference: referenceEvidence(fixture, resolution, caseSpec), coreProbes, compile: { constraintHash: input.constraintIR.deterministicSignature, referencePlanHash: input.referencePlan.planHash, pipelinePlanHash: input.pipelinePlan.planHash, promptGuard: guard.status } };
+        const coreProbes = Object.fromEntries((fixture.coreProbes ?? []).sort((left, right) => compare(left.id, right.id)).map((probe) => [probe.id, coreProbeEvidence(probe, resolution, caseSpec, profile)]));
+        const acceptance = { resolution: { status: resolution.status, selectedCount: resolution.report.selected.length, effectiveScenarioHash: resolution.effectiveScenario.effectiveScenarioHash }, scenario: scenarioEvidence(resolution.effectiveScenario), reference: referenceEvidence(fixture, resolution, caseSpec), coreProbes, compile: { constraintHash: input.constraintIR.deterministicSignature, referencePlanHash: input.referencePlan.planHash, pipelinePlanHash: input.pipelinePlan.planHash, promptGuard: guard.status } };
         const result = executeOffline(input);
         const run = result.run ?? result.executionRun;
         if (!run)
@@ -636,7 +729,7 @@ async function packTestCommand(source) {
         const semanticReceipts = [];
         const reconciliation = [];
         if (fixture.semanticReview) {
-            const semantic = await semanticForRun(run, [structuralArtifact, ...artifacts], profile);
+            const semantic = await semanticForRun(run, [structuralArtifact, ...artifacts], profile, semanticCriteria);
             semanticProposal = semantic.report;
             semanticReceipts.push(semantic.receipt);
             reconciliation.push(semantic.remote);
@@ -645,7 +738,7 @@ async function packTestCommand(source) {
         const compiledHash = sha256({ packId: loaded.descriptor.manifest.packId, fixtureId: fixture.id });
         const evaluation = compileEvaluationReport({ run: { id: run.id, technicalOutcome: run.technicalOutcome, state: run.state, contextHash: run.contextHash, pipelinePlanHash: run.pipelinePlanHash, promptArtifactHash: run.promptArtifactHash }, structural, semanticProposal, humanAcceptance: human, cleanup: result.cleanupReceipts, replay: { mode: 'artifact', status: 'available', code: 'REPLAY_AVAILABLE', artifactIds: artifacts.map((item) => item.id) }, artifacts: [structuralArtifact, ...artifacts], sourceHashes: { compiledBundle: compiledHash, executionRun: computeExecutionRunHash(run) } });
         const traceModel = traceModelFromExecution({ run, receipts: [...result.receipts, ...semanticReceipts], cleanup: result.cleanupReceipts, reconciliation: [...result.remoteCallRuns, ...reconciliation], artifacts: [structuralArtifact, ...artifacts], structural, semanticProposal, humanAcceptance: human, budgets: input.pipelinePlan.steps.map((step) => step.budget), destinations: input.pipelinePlan.dataTransfers.map((item) => item.destination), constraintHash: input.constraintIR.deterministicSignature, referencePlanHash: input.referencePlan.planHash, promptHash: input.executionAuthorization.promptArtifactHash, warnings: result.reasons });
-        acceptance.run = { executionStatus: result.status, executionCode: result.code, receiptCount: result.receipts.length + semanticReceipts.length, receiptAdapters: [...result.receipts, ...semanticReceipts].map((item) => item.adapterId).sort(compare), artifactMediaTypes: artifacts.map((item) => item.mediaType).sort(compare), artifactRoles: artifacts.map((item) => item.role).sort(compare), structuralStatus: structural.status, semanticStatus: semanticProposal?.status ?? 'absent', humanStatus: human?.status ?? 'absent', evaluationStatus: evaluation.status, traceModelPresent: true, traceModelHash: traceModel.modelHash };
+        acceptance.run = { executionStatus: result.status, executionCode: result.code, receiptCount: result.receipts.length + semanticReceipts.length, receiptAdapters: [...result.receipts, ...semanticReceipts].map((item) => item.adapterId).sort(compare), artifactMediaTypes: artifacts.map((item) => item.mediaType).sort(compare), artifactRoles: artifacts.map((item) => item.role).sort(compare), structuralStatus: structural.status, semanticStatus: semanticProposal?.status ?? 'absent', semanticCriterionIds: semanticProposal?.findings.map((item) => item.criterionId).sort(compare) ?? [], semanticFindingStatuses: semanticProposal?.findings.map((item) => item.status).sort(compare) ?? [], humanStatus: human?.status ?? 'absent', evaluationStatus: evaluation.status, traceModelPresent: true, traceModelHash: traceModel.modelHash };
         const assertions = assertFixtureAssertions(fixture, acceptance, 'all');
         const expected = fixture.expectedStatus ?? 'completed';
         const accepted = result.status === expected || (expected === 'needs_review' && result.status === 'completed');
@@ -654,7 +747,23 @@ async function packTestCommand(source) {
     const failed = results.some((item) => item.status === 'failed');
     return { status: failed ? 'failed' : 'passed', packId: loaded.descriptor.manifest.packId, resolutionHash: resolution.report.reportHash, lockHash: resolution.lock.lockHash, effectiveScenarioHash: resolution.effectiveScenario.effectiveScenarioHash, fixtureCount: results.length, results };
 }
-async function doctorCommand() { const major = Number(process.versions.node.split('.')[0]); return { status: major >= 20 ? 'ok' : 'blocked', node: { version: process.versions.node, supported: major >= 20 }, contracts: { schemaVersion: BUNDLE_MANIFEST_SCHEMA_VERSION, packageVersion: CONTRACTS_VERSION }, paths: { explicitOnly: true }, providers: { default: 'disabled', mock: 'offline', networkProbe: false }, authProbe: { inspected: false } }; }
+async function doctorCommand() {
+    const major = Number(process.versions.node.split('.')[0]);
+    return {
+        status: major >= 20 ? 'ok' : 'blocked',
+        node: { version: process.versions.node, supported: major >= 20 },
+        contracts: { schemaVersion: BUNDLE_MANIFEST_SCHEMA_VERSION, packageVersion: CONTRACTS_VERSION },
+        paths: { explicitOnly: true },
+        providers: { default: 'disabled', mock: 'offline', networkProbe: false },
+        authProbe: { inspected: false },
+        visualComposition: {
+            catalogId: VISUAL_COMPOSITION_CATALOG.id,
+            catalogHash: computeVisualCompositionCatalogHash(),
+            pathCount: VISUAL_COMPOSITION_CATALOG.paths.length,
+            presetCount: VISUAL_COMPOSITION_CATALOG.presets.length,
+        },
+    };
+}
 function required(args, key) { if (!args[key])
     throw new CliError('ARGUMENT_MISSING', `Missing --${key}.`, EXIT.usage); return args[key]; }
 function help() { return `voce ${CLI_VERSION}\n\nOffline-first explicit-path CLI.\n\nCommands:\n  voce pack inspect --source <path> [--json]\n  voce pack validate --source <path> [--json]\n  voce pack test --source <path> [--json]\n  voce case compile --case <file> --scenario <path> --profile <file> --out <dir> [--json]\n  voce case run --bundle <dir> --provider mock --out <dir> [--json]\n  voce trace render --bundle <dir> --out <html> [--json]\n  voce compare --before <dir> --after <dir> [--out <file>] [--json]\n  voce doctor [--json]\n\nExit codes: 0 success, 2 usage, 3 input, 4 contract/hash, 5 offline/provider, 6 output, 7 internal.`; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voce-engine/cli",
-  "version": "0.1.0-rc.2",
+  "version": "0.1.0-rc.4",
   "description": "Offline-first command line tools for the VOCE v0.1 release candidate.",
   "license": "Apache-2.0",
   "type": "module",
@@ -36,9 +36,9 @@
     "tag": "next"
   },
   "dependencies": {
-    "@voce-engine/contracts": "0.1.0-rc.2",
-    "@voce-engine/core": "0.1.0-rc.2",
-    "@voce-engine/testkit": "0.1.0-rc.2"
+    "@voce-engine/contracts": "0.1.0-rc.4",
+    "@voce-engine/core": "0.1.0-rc.4",
+    "@voce-engine/testkit": "0.1.0-rc.4"
   },
   "scripts": {
     "build": "tsc -b"