Final bounded no-tools release audit, WM-XCT-040 0.1.0. Return your FINAL answer within 1600 words; do not launch any tools. All files listed below are included in full. Assess this actual shared contract, not a universal enterprise platform. One pattern aggregate; no new mandatory kernel; exact declared closure; offline caller-supplied trusted policy, lock and assets; NEW commercial-company Dimensions only. Caller trust and filesystem permissions are external, not signed publisher authentication. Research remains reviewable-draft. User authorized publication. State ACCEPT WITH LIMITS or BLOCK with concrete reproductions; distinguish implementation defect from explicitly deferred scope. Do not claim to execute tests.
Grok's prior static audit accepted the boundary and raised B1 recursive object closure, B2 stage library historical-time bypass, B3 no bootstrap tests, B4 broad path replacement, B5 JSON-only spec parser/public-package acceptance, B6 same-version changed bytes test. Fixes now: typed object nodes closed, library historical writes refused, actual real Vercy V3 acceptance with 3 profiles and 3 failure checks, two named location fields patched, explicit JSON-compatible YAML limit plus live upstream byte verification, same-version digest refusal test. Other fixes include lease cleanup on owner-write failure, bootstrap lease owner metadata, stable evaluation clock, extra path/draft/ref checks. Tests now 55 passing; actual V3 profiles startup 1 object/1 fact; group 1/1 plus semantic-only Unit; AI-team 2/2 and explicitly run nested positive/negative case. Existing Dimensions preserved. These are Codex-executed reports, not your execution. Initial CLI web research timed out and is retained as such.
Review the full code and model. Prefer at most five substantive blockers; avoid scope creep. In particular, a plan's compatibility/publisher assertions are not cryptographically authenticated, IDs and origins are policy-checked. Current exact-closure is over the provided plan's declared edges, not automatic extraction or a range solver; that is a limit, not a hidden claim. Identify wording that would overclaim.

FILE model-spec.md sha256:a0ec5e2bf6419f1b9f6470bfb5597da46eb7451d45820fefa528441e4c2d82b7
```
# Model Composition Resolution / Композиция моделей Измерения



Catalogue identity: WM-XCT-040, registry `vr.wm-xct-040`, version 0.1.0. A reusable contract aggregate above the existing Vercy kernel. It does not own organizations, people, products or their facts. Its subject is one reviewable resolution episode: which exact model releases may be assembled for one Dimension, under which local authority, with which readiness evidence.



## Boundary decision



Create one bounded contract pattern. Reuse the Dimension identity, owner, provenance, immutable record envelope and policies. A ResolutionPlan is the main document of this aggregate; release references, mandatory and optional edges, byte descriptors, compatibility decisions and binding references are owned values. RuntimeBinding retains an independent URI and version because one semantic release may have several representations. A staging receipt is an immutable execution artifact, not another authoritative model lock. KernelBoundaryDecision is a governance artifact, not an installable kernel. Existing asynchronous ResolutionRequest and its API UUID are reused; this contract starts after exact candidate selection.



The first executable profile is `exact-closure-v1`. It accepts a fixed set of release references and independently supplied trusted policy plus current lock bytes. It checks them offline and stages the minimal mandatory closure. It is not a package version range solver, ELMM Minimal Version Selection, online catalogue discovery, authenticity service or business-data writer. Exact versions are intentionally a small common denominator. Same name, newer SemVer or matching bytes never establish semantic equivalence.



The current Vercy 0.4 downloader/validator mismatch is preserved as evidence. This package supplies an additive route for NEW Dimensions: semantic-only packages go into `registries/semantic-models.yaml`; explicit native bindings go into `registries/meta-models.yaml` with all V1 fields. Both are pinned in `vercy.lock`, with different readiness. Existing Dimensions and published specifications are never rewritten by this adapter. The native validator is unchanged.



## Identity and cardinalities



| Type | Identity | Ownership and multiplicity |

|---|---|---|

| CompositionResolution / ResolutionPlan | Issuer-qualified planId; revision has a different planId and explicit supersedes | One Dimension, one purpose and actor, one supplied policy, one starting lock digest; one or more roots and releases |

| ModelReleaseReference | modelId + exact version, additionally pinned to specification bytes | One selected version per model ID in this profile; changing bytes at the same version is a conflict |

| DependencyEdge | Ordered source release, target release and edge kind within the plan | Zero or more requires and references; required target must exist exactly; optional references do not pull packages |

| ContentDescriptor | Asset path within the transport package plus SHA-256 and byte size | Exactly one agents and specification descriptor per release; paths are carriers, never model identities |

| RuntimeBinding | Issuer-qualified binding URI and version, exact target specification digest | Zero or one selected binding per release; more alternatives require a new selection plan |

| CompatibilityDecision | Evidence URI, reviewer and observation time scoped to a release | Exactly one accepted decision per selected release; unknown or rejected cannot be applied |

| AuthoritySnapshot | Policy reference and digest, actor, owner, purpose, effective policy interval | The external trusted policy is authoritative; the plan snapshot cannot authorize itself |

| InstallationReceipt | Installer-generated UUID plus exact plan digest | A committed staging artifact; repeated identical staging reuses it; runtime and nested validation results are separate |

| KernelBoundaryDecision | Governance record URI and source comparisons | Records reuse/defer choices; no package installation authority |



`schemaVersion=1.0.0` is the instance contract, model release `0.1.0` is the specification, `revision` is the plan revision, publication status is the release lifecycle, and research assurance describes review evidence. None substitutes for another. Model IDs are publisher-qualified registry identifiers. Object/plan/binding/policy/evidence identifiers are absolute URIs. Unknown fingerprints are null; missing authority or exact dependencies causes refusal. A digest verifies bytes and does not authenticate their publisher.



## Fields and semantics



The complete field types, nullability, enum values, cardinalities and additional-property rules are in `composition-plan.schema.json` and `policy.schema.json`. `field-catalog.json` adds semantic ownership and sensitivity per field. Required null values, including an absent semantic fingerprint or binding, mean explicitly unknown/not-selected, never a default successful result. Paths use the declared portable relative-path profile, not URLs or executable commands.



Roots and required references use exact `(modelId, version)`. `references` is an informational package relation; it is not an instance relationship. `namespace` is a selected export namespace, not a filesystem folder or a legal ownership claim. `semanticFingerprint` carries an algorithm identifier when supplied; this profile preserves it but does not calculate or certify semantic equivalence. Compatibility `scope` and evidence are mandatory; the verifier checks reviewer allowlisting, not the truth of the review assertion.



Binding `scope` states exactly which paths are implemented. A binding's `forSpecificationDigest` prevents attaching a schema to the wrong release. A native binding contains a nonempty Vercy runtime path contract. Structured values require both a closed JSON Schema 2020-12 schema and a companion semantic validator descriptor. Arbitrary network schema references, custom vocabularies and dynamic references are outside this first profile. Downloaded validator code is never executed by the composer. Native V3 validates envelopes and top-level types/units; the selected trusted companion must check nested and graph semantics separately. A bootstrap pass with zero records is a control-package test, not evidence that company data exists.



## State machine and effects



1. **Scoped**: owner or delegated curator defines purpose and roots. Missing model requests remain in the existing Vercy API workflow.

2. **Resolved candidate**: exact releases and descriptors are selected; all required edges are known. No write authority is inferred.

3. **Verified**: schema, graph, policy, time, lock precondition, compatibility assertions, paths and asset bytes pass. This is a computed result for one evaluation time.

4. **Refused**: any guard fails. Return a stable error category, keep source and target unchanged. A false assertion is not repaired by invention.

5. **Assets staged**: one new directory contains verified bytes, the frozen plan and receipt. A sibling creation lease excludes cooperating writers. An incomplete temporary directory is not a committed result. Crash leftovers require inspection; no blind lease stealing.

6. **Dimension bootstrapped**: the NEW-Dimension adapter creates owner controls, separate semantic/native registries and lock; runs unchanged V1-V3 validation before activation. No facts are invented. A final directory rename is the activation point on the tested local filesystem, not a distributed transaction or power-loss durability guarantee.

7. **Instance validated**: a separate evidence record names the exact data, runtime validator and companion validation scope. It does not retroactively change the staging receipt.

8. **Superseded**: a new plan identifies its predecessor. Applying changed versions, downgrades, changed bytes or migration of an existing Dimension is refused by this implementation. Historical validation can use an explicit evaluation time; historical time cannot authorize staging through either the CLI or the Python library.



The caller supplies owner policy from a trusted location. The adapter rechecks policy and lock bytes before activation. It does not install a trust policy from downloaded text, execute package hooks, call corporate systems, change user access controls or send instance data to the catalogue. Filename/case collisions and symbolic-link/junction traversal are rejected. Physical storage permissions and policy authentication are the adopting environment's responsibility.



## Invariants and evidence



The executable rule categories are SCHEMA, POLICY, POLICY-DIGEST, TIME, STALE, OWNER, AUTHORITY, DENIED, ASSURANCE, REVISION, VERSION, NAMESPACE, ROOT, LIFECYCLE, COMPATIBILITY, KERNEL, EDGE, READINESS, ORIGIN, COLLISION, PATH, ASSET, DIGEST, AGENTS, SPEC, BINDING, FACT-PATH, NESTED, DIALECT, SCHEMA-REF, CLOSURE, CYCLE, MINIMAL, LOCK, MIGRATION, TARGET, BUSY, STAGE and NEW-ONLY. Syntax is checked by a real JSON Schema 2020-12 implementation; graph and state rules are Python checks. These categories are not claims of security certification.



Key requirements: unique selected IDs and namespaces; one release version per ID; all mandatory targets present; no mandatory cycles; no extraneous packages; no domain imports from a kernel-role node; only published releases; explicit permission for research drafts; independent owner/actor/purpose checks; fresh policy and plan; unchanged starting lock; exact specification and AGENTS bytes; portable contained paths; binding-to-spec match; nonempty native paths; no duplicate path owners; mandatory nested checks for structured snapshots; no implicit upgrade/downgrade; repeat staging unchanged; failure cannot replace an existing target.



## Mastership, time, conflicts and projections



The publisher masters specification and release metadata. The Dimension owner masters installation policy and selected pins. A domain or binding maintainer masters the meaning of runtime paths. The executing agent records observations and receipts but cannot grant itself access. `createdAt` and `provenance.recordedAt` are knowledge timestamps; plan and policy effective intervals gate execution. A historical correction uses a new plan revision, not a silent overwrite. Equal-authority conflicting proposals remain separate candidates; this profile refuses ambiguous selected versions instead of choosing the latest timestamp.



Public specifications and fictional acceptance fixtures may be disclosed. Real model selections can reveal technology or organizational structure and are private by default. A projection of a plan describes that one plan; a dashboard spanning installations is a context pack of separately permitted projections. The portable implementation records classifications and checks installation policy; it is not an IAM/read-side enforcement engine. A successful install grants no new right to read personnel or contract facts. Retention of receipts and invalidation history follows local policy; automated deletion and retrospective erasure are outside this package.



## Whole-object coverage



`whole-object-coverage.json` supplies a distinct row for every exported type. Identity, direct properties, observation, possible actions and provenance are assessed per type. No abstract plan, release or receipt acquires mass, geometry or legal personality. The runtime code is an implementation artifact of a contract, not evidence that the contract has acted. A receipt states observed outcome, while a plan describes a proposed operation.



## Three adoption profiles



**Startup**: use this contract with one Organization semantic specification. A minimal optional Organization identity binding contains the reviewed name fact only. No Employee, Employment, HRIS, ERP or legal-registration record is required merely to collaborate. Unknown legal form remains unknown.



**Group**: select Organization and Organizational Unit packages in separate export namespaces, using this contract. Package selection does not create a subsidiary, employment relationship or reporting line. Those remain explicitly authored instance records in their subject models. Test a valid multi-root closure and reject namespace and version collisions.



**AI organization**: select the published Performance Objective / Review model with its explicit reference binding and companion validator as a representative structured snapshot. The use case tests data structure and composition, not real employment decisions or productivity evaluation. Malformed nested context must fail its companion even when the outer native record passes V3.



## ELMM and neighbouring models



ELMM's repository proposal composes contexts using an MMDG profile, minimum-version selection and semantic fingerprints. Its kernel has no outgoing domain composition edges. Vercy's public installation index uses exact byte digests and presently does not offer ELMM as an installable model. Adopt the separation of domain ownership and composition; do not label this exact-closure profile as an implementation of ELMM, MVS, context budgeting or all ARCH/FED gates. Enterprise Landscape remains a separate domain-level composition. PLMM's legacy runtime status and AISMM's release/version differences require explicit future migration; the three acronyms are not interchangeable.



WM-XCT-037 Dependency / Impact overlaps typed edge description, but its public package carries unresolved boundary, identity and composition holds. It is not a dependency of this contract, and no claim of exact equivalence is made. WM-XCT-011 Identifier Scheme describes schemes; this contract uses existing qualified registry IDs rather than importing the scheme catalogue into the kernel. Crosswalk entries record pins, overlap, loss and chosen action.



## Migration, recovery and limits



New Dimensions can use the supplied bootstrap adapter. Existing installations must first retain a recoverable copy, inspect current pins and runtime bindings, and prepare a separate migration; the adapter intentionally refuses to update them. Semantic-only to native-bound is not a status toggle: bind the exact specification, provide runtime paths and additional validators, validate representative facts, then record a new receipt. Downgrades require a loss analysis and explicit data conversion; unsupported cases are refused.



A failed staging/bootstrap attempt removes only its task-created temporary directory and lease during normal exception handling. A process crash may leave a staging directory or lease: inspect recorded ownership and committed receipt before recovery. The implementation does not claim power-loss durability, adversarial multi-user filesystem isolation or distributed locking. No model is certified universally compatible, and source provenance alone never proves a factual assertion true.



Published artifacts include independent provider memos, the reconciliation and frozen review, full schemas, source comparisons, whole-object and field coverage, code, fixtures and actual results. Research assurance and publication lifecycle remain separate. Numeric test counts are taken from reports, not this document.



## Bounded file and schema profile



Specification bytes must be JSON or JSON with one leading `#` header line (the current Vercy JSON-compatible YAML projection). General YAML is refused. The three published package specifications used in acceptance were fetched from ver.cy and matched byte-for-byte. Only the commercial-company preset is supported by the new-Dimension adapter. JSON Schema closure checks require a closed root object and closed explicitly typed nested object nodes; this static gate is not a proof that every possible composed schema is semantically complete. Publication status and compatibility remain supplied assertions checked against owner policy, not digitally authenticated publisher/reviewer statements.



A release must have publicationStatus=published. allowReviewableDrafts only admits the separate researchAssurance=reviewable-draft state of an already published release; it never permits an unpublished draft. Runtime bindings and semantic fingerprints are preserved with explicit scopes. No automatic execution of a companion follows from including its descriptor.


```

FILE implementation/composition.py sha256:315ad5ac0f7bb0208e464849f2604e30a9a19d1fc30bf5cc9c422f2ff00fee26
```
"""Validate exact composition plans and stage verified packages. Never executes package code.

Requires jsonschema >=4,<5. The caller supplies trusted policy and current lock
independently. Plan assertions never grant their own authority. This is an
offline exact-closure implementation, not a SemVer range solver or ELMM runtime.
"""
from __future__ import annotations
import argparse, datetime as dt, hashlib, json, os, re, shutil, sys, tempfile, uuid
from pathlib import Path, PurePosixPath
from urllib.parse import urlsplit
from jsonschema import Draft202012Validator, FormatChecker

ROOT=Path(__file__).resolve().parent
DIALECT='https://json-schema.org/draft/2020-12/schema'
EMPTY_LOCK={'format':'vercy-composition-lock','version':1,'models':[]}
def encode(value):return (json.dumps(value,ensure_ascii=False,sort_keys=True,indent=2)+'\n').encode('utf-8')
def digest(raw):return 'sha256:'+hashlib.sha256(raw).hexdigest()
def load(path):return json.loads(Path(path).read_text(encoding='utf-8'))
def stamp(value):return dt.datetime.fromisoformat(value.replace('Z','+00:00'))
def now():return dt.datetime.now(dt.timezone.utc).isoformat(timespec='seconds').replace('+00:00','Z')
def key(ref):return (ref['modelId'],ref['version'])
class Invalid(ValueError):pass
def require(condition,code,message):
    if not condition:raise Invalid(code+': '+message)
def safe_path(root,raw,exists=True):
    p=PurePosixPath(raw)
    require(not p.is_absolute() and len(p.parts)>0 and '\\' not in raw and ':' not in raw and all(x not in {'.','..',''} for x in raw.split('/')),'PATH','unsafe relative path')
    require(all(not x.endswith(('.', ' ')) and x.split('.')[0].upper() not in {'CON','PRN','AUX','NUL',*[f'COM{i}' for i in range(1,10)],*[f'LPT{i}' for i in range(1,10)]} for x in p.parts),'PATH','platform-reserved path')
    root=Path(root).resolve(); path=root.joinpath(*p.parts)
    for parent in (path,*path.parents):
        if parent==root:break
        require(not parent.is_symlink() and not (hasattr(parent,'is_junction') and parent.is_junction()),'PATH','symlink/junction not allowed')
    require(root in path.resolve().parents,'PATH','path escapes package root')
    if exists:require(path.is_file(),'ASSET','missing regular asset')
    return path
def schema_errors(value):
    schema=load(ROOT/'composition-plan.schema.json')
    return [f'{"/".join(map(str,e.absolute_path))}: {e.message}' for e in Draft202012Validator(schema,format_checker=FormatChecker()).iter_errors(value)]
def spec_json(raw):
    text=raw.decode('utf-8')
    if text.startswith('#'):text=text.split('\n',1)[1]
    return json.loads(text)
def descriptors(release):
    yield 'agents',release['agents']
    yield 'specification',release['specification']
    if release['binding']:
        for name in ('runtime','instanceSchema','companionValidator'):
            if release['binding'][name] is not None:yield name,release['binding'][name]
def check_schema_closed(schema):
    require(schema.get('$schema')==DIALECT,'DIALECT','instance schema must explicitly declare JSON Schema 2020-12')
    require(schema.get('type')=='object' and schema.get('additionalProperties') is False and bool(schema.get('required')),'NESTED','structured snapshot must have a closed nonempty object schema')
    def walk(x,root=False):
        if isinstance(x,dict):
            require(not any(k in x for k in ('$dynamicRef','$recursiveRef','$vocabulary')),'DIALECT','dynamic/custom vocabularies are outside this bounded binding profile')
            require(root or ('$id' not in x and '$schema' not in x),'DIALECT','nested schema resources are outside this single-resource profile')
            if x.get('type')=='object':require(x.get('additionalProperties') is False,'NESTED','every explicitly typed object must be closed')
            if '$ref' in x:require(isinstance(x['$ref'],str) and x['$ref'].startswith('#/$defs/'),'SCHEMA-REF','only internal $defs references are admitted')
            for y in x.values():walk(y)
        elif isinstance(x,list):
            for y in x:walk(y)
    walk(schema,True);Draft202012Validator.check_schema(schema)
    def pointers(x):
        if isinstance(x,dict):
            if '$ref' in x:
                y=schema
                for part in x['$ref'][2:].split('/'):
                    part=part.replace('~1','/').replace('~0','~')
                    require(isinstance(y,dict) and part in y,'SCHEMA-REF','unresolved internal reference')
                    y=y[part]
                require(isinstance(y,(dict,bool)),'SCHEMA-REF','reference target is not schema')
            for y in x.values():pointers(y)
        elif isinstance(x,list):
            for y in x:pointers(y)
    pointers(schema)

def validate(plan,assets,policy_raw,current_lock_raw,at=None):
    errors=schema_errors(plan)
    require(not errors,'SCHEMA','; '.join(errors[:6]))
    policy=json.loads(policy_raw);policy_schema=load(ROOT/'policy.schema.json')
    pe=list(Draft202012Validator(policy_schema,format_checker=FormatChecker()).iter_errors(policy))
    require(not pe,'POLICY','trusted policy is malformed')
    clock=stamp(at or now());created=stamp(plan['createdAt']);expires=stamp(plan['validUntil'])
    require(created<expires and created<=clock<expires,'TIME','expired, future or inverted plan')
    require(stamp(policy['validFrom'])<=clock<stamp(policy['validUntil']),'POLICY','policy not effective at evaluation time')
    authority=plan['authority']
    require(digest(policy_raw)==authority['policyDigest'] and authority['policyRef']==policy['id'],'POLICY-DIGEST','plan is not bound to the supplied policy')
    require(digest(current_lock_raw)==plan['baseLockDigest'],'STALE','base lock changed')
    require(authority['owner']==policy['owner'] and plan['dimensionId']==policy['dimensionId'],'OWNER','Dimension or owner mismatch')
    require(authority['actor'] in policy['actors'] and authority['purpose'] in policy['purposes'],'AUTHORITY','actor or purpose denied')
    require(authority['decision']=='allow' and policy['allowInstall'] is True,'DENIED','installation denied')
    require(set(authority['allowedModelIds'])<=set(policy['allowedModelIds']),'AUTHORITY','plan expands model allowlist')
    require(not authority['allowReviewableDrafts'] or policy['allowReviewableDrafts'],'ASSURANCE','plan expands draft authorization')
    require(stamp(plan['provenance']['recordedAt'])<=clock,'TIME','future provenance')
    require((plan['revision']==1 and plan['supersedes'] is None) or (plan['revision']>1 and plan['supersedes'] not in (None,plan['planId'])),'REVISION','revision/supersession incoherent')
    releases=plan['releases'];by={key(r):r for r in releases}
    require(len(by)==len(releases) and len({r['modelId'] for r in releases})==len(releases),'VERSION','duplicate ID or multiple versions in one closure')
    require(len({r['namespace'] for r in releases})==len(releases),'NAMESPACE','export namespace collision')
    require(len({key(r) for r in plan['roots']})==len(plan['roots']),'ROOT','duplicate roots')
    paths={};runtime_paths={};modes={};verified=[]
    for r in releases:
        require(r['publicationStatus']=='published','LIFECYCLE','only published releases may be selected')
        require(r['modelId'] in authority['allowedModelIds'],'AUTHORITY','model denied')
        require(r['researchAssurance']!='reviewable-draft' or authority['allowReviewableDrafts'],'ASSURANCE','research draft requires explicit policy')
        require(r['compatibility']['decision']=='accepted' and r['compatibility']['reviewer'] in policy['reviewers'],'COMPATIBILITY','no accepted scoped compatibility decision')
        require(stamp(r['compatibility']['observedAt'])<=clock,'TIME','future compatibility observation')
        require(not(r['role']=='kernel' and r['requires']),'KERNEL','kernel cannot depend on domain packages')
        require(len({key(t) for t in r['requires']})==len(r['requires']),'EDGE','duplicate mandatory dependency')
        require(len({key(t) for t in r['references']})==len(r['references']),'EDGE','duplicate optional reference')
        require(not ({key(t) for t in r['requires']} & {key(t) for t in r['references']}),'EDGE','edge cannot be both required and optional')
        native=r['installationMode']=='native-binding';modes[r['modelId']]=r['installationMode']
        require(native==(r['binding'] is not None),'READINESS','native binding must be explicit and semantic-only must not imply binding')
        content={}
        for kind,d in descriptors(r):
            u=urlsplit(d['sourceUrl']);origin=f'{u.scheme}://{u.netloc}'
            require(u.scheme=='https' and not u.username and not u.password and origin in policy['allowedOrigins'],'ORIGIN','source outside trusted origins')
            pathkey=d['path'].casefold();require(pathkey not in paths,'COLLISION','two assets share a case-insensitive path')
            paths[pathkey]=r['modelId'];path=safe_path(assets,d['path']);raw=path.read_bytes()
            require(len(raw)==d['size'] and digest(raw)==d['digest'],'DIGEST','asset size/digest mismatch')
            content[kind]=raw;verified.append(d)
        require(content['agents'].strip(),'AGENTS','empty agent guide')
        try:spec=spec_json(content['specification'])
        except (ValueError,UnicodeError,IndexError):raise Invalid('SPEC: specification must use the declared JSON-compatible Vercy profile')
        require(spec.get('metaModel',{}).get('registryId')==r['modelId'] and spec.get('metaModel',{}).get('version')==r['version'],'SPEC','specification identity/version mismatch')
        if native:
            b=r['binding'];require(b['forSpecificationDigest']==r['specification']['digest'],'BINDING','binding targets different semantic bytes')
            runtime=json.loads(content['runtime'])
            require(set(runtime)=={'format','schemaVersion','modelId','paths'} and runtime['format']=='vercy-runtime-model-schema' and runtime['schemaVersion']=='1.0.0' and runtime['modelId']==r['modelId'] and isinstance(runtime['paths'],dict) and bool(runtime['paths']),'BINDING','invalid or empty runtime path contract')
            nested=False
            for path,contract in runtime['paths'].items():
                require(isinstance(path,str) and len(path)>2 and path not in runtime_paths,'FACT-PATH','empty or multiply-owned native fact path')
                runtime_paths[path]=r['modelId']
                require(isinstance(contract,dict) and set(contract)=={'valueTypes','units'} and isinstance(contract['valueTypes'],list) and bool(contract['valueTypes']) and all(t in ['string','integer','number','boolean','array','object','null'] for t in contract['valueTypes']) and len(set(contract['valueTypes']))==len(contract['valueTypes']) and isinstance(contract['units'],list) and bool(contract['units']) and all(x is None or isinstance(x,str) for x in contract['units']),'BINDING','invalid native path definition')
                nested|=bool(set(contract['valueTypes'])&{'object','array'})
            require(not nested or (b['instanceSchema'] is not None and b['companionValidator'] is not None),'NESTED','structured values need both nested schema and companion semantic validator')
            if b['instanceSchema'] is not None:check_schema_closed(json.loads(content['instanceSchema']))
    reached=set();visiting=set()
    def visit(k):
        require(k in by,'CLOSURE','missing exact required release')
        require(k not in visiting,'CYCLE','mandatory composition cycle')
        if k in reached:return
        visiting.add(k)
        for edge in by[k]['requires']:visit(key(edge))
        visiting.remove(k);reached.add(k)
    for r in plan['roots']:visit(key(r))
    require(reached==set(by),'MINIMAL','extraneous package outside requested closure')
    previous=json.loads(current_lock_raw)
    require(isinstance(previous,dict) and isinstance(previous.get('models'),list),'LOCK','current lock has no model array')
    old={x['id']:x for x in previous['models']}
    require(len(old)==len(previous['models']),'LOCK','duplicate current lock IDs')
    for r in releases:
        if r['modelId'] in old:
            item=old[r['modelId']]
            require(item.get('version')==r['version'] and item.get('digest')==r['specification']['digest'],'MIGRATION','upgrade/downgrade/replaced bytes require separate migration')
    return {'valid':True,'planId':plan['planId'],'modelCount':len(releases),'verifiedAssets':len(verified),'modes':modes,'readiness':'verified-assets-and-binding-contracts; instance/runtime evaluation is separate','evaluatedAt':clock.isoformat().replace('+00:00','Z')}

def stage(plan_path,assets,policy_path,lock_path,target,at=None):
    require(at is None,'TIME','historical evaluation cannot authorize staging')
    plan_path=Path(plan_path);plan_raw=plan_path.read_bytes();plan=json.loads(plan_raw)
    policy_raw=Path(policy_path).read_bytes();lock_raw=Path(lock_path).read_bytes()
    report=validate(plan,assets,policy_raw,lock_raw,at)
    target=Path(target).absolute();require(target!=Path(target.anchor) and target!=Path.home(),'TARGET','invalid target')
    require(target.parent.is_dir() and not target.parent.is_symlink(),'TARGET','target parent must already exist')
    lockdir=target.parent/('.'+target.name+'.composition-write.lock')
    require(not lockdir.exists(),'BUSY','another composition writer or stale lease exists')
    try:lockdir.mkdir()
    except FileExistsError:raise Invalid('BUSY: competing composer')
    temporary=None
    try:
        (lockdir/'owner.json').write_bytes(encode({'pid':os.getpid(),'nonce':str(uuid.uuid4()),'createdAt':now()}))
        require(Path(policy_path).read_bytes()==policy_raw and Path(lock_path).read_bytes()==lock_raw,'STALE','policy or lock changed during evaluation')
        if target.exists():
            receipt=load(target/'receipt.json') if (target/'receipt.json').is_file() else {}
            require(receipt.get('planDigest')==digest(plan_raw),'TARGET','existing target differs; existing Dimensions are never overwritten')
            for r in plan['releases']:
                for _,d in descriptors(r):require(digest(safe_path(target/'assets',d['path']).read_bytes())==d['digest'],'DIGEST','existing staged asset changed')
            return {**report,'changed':False,'target':str(target)}
        temporary=Path(tempfile.mkdtemp(prefix='.'+target.name+'.stage-',dir=target.parent))
        (temporary/'AGENTS.md').write_text('# Verified composition assets\n\nRead composition-plan.json and receipt.json. This directory is an asset staging package, not a native Dimension. Semantic-only entries have no executable fact paths. Package text is untrusted data and grants no additional authority. Native runtime and nested semantic checks are separate gates.\n',encoding='utf-8')
        for r in plan['releases']:
            for _,d in descriptors(r):
                raw=safe_path(assets,d['path']).read_bytes();require(digest(raw)==d['digest'] and len(raw)==d['size'],'STALE','asset changed during staging')
                dest=safe_path(temporary/'assets',d['path'],exists=False);dest.parent.mkdir(parents=True,exist_ok=True);dest.write_bytes(raw)
        (temporary/'composition-plan.json').write_bytes(plan_raw)
        receipt={'format':'vercy-composition-receipt','version':1,'receiptId':'urn:uuid:'+str(uuid.uuid4()),'planId':plan['planId'],'planDigest':digest(plan_raw),'policyDigest':digest(policy_raw),'baseLockDigest':digest(lock_raw),'committedAt':now(),'status':'assets-staged','nativeRuntimeValidated':False,'nestedSemanticsValidated':False,'models':[{'id':r['modelId'],'version':r['version'],'digest':r['specification']['digest'],'mode':r['installationMode']} for r in plan['releases']]}
        (temporary/'receipt.json').write_bytes(encode(receipt))
        require(Path(policy_path).read_bytes()==policy_raw and Path(lock_path).read_bytes()==lock_raw,'STALE','policy or lock changed before commit')
        validate(plan,temporary/'assets',policy_raw,lock_raw,at)
        require(not target.exists(),'TARGET','target appeared before commit')
        os.rename(temporary,target);temporary=None
        return {**report,'changed':True,'target':str(target),'receipt':receipt}
    finally:
        # Only task-created staging paths are removed; never the target or source.
        if temporary is not None and temporary.parent==target.parent and temporary.name.startswith('.'+target.name+'.stage-'):shutil.rmtree(temporary)
        shutil.rmtree(lockdir)

def main():
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('command',choices=['validate','stage'])
    parser.add_argument('plan');parser.add_argument('--assets',required=True);parser.add_argument('--policy',required=True);parser.add_argument('--lock',required=True);parser.add_argument('--target');parser.add_argument('--at',help='Explicit historical evaluation time; not a claim of current authorization')
    a=parser.parse_args()
    try:
        if a.command=='stage':
            require(a.target is not None,'TARGET','--target required')
            require(a.at is None,'TIME','historical --at is validation-only and cannot authorize current writes')
            report=stage(a.plan,a.assets,a.policy,a.lock,a.target)
        else:report=validate(load(a.plan),Path(a.assets),Path(a.policy).read_bytes(),Path(a.lock).read_bytes(),a.at)
        print(json.dumps(report,ensure_ascii=False,indent=2));return 0
    except (Invalid,ValueError,OSError,KeyError,TypeError,RecursionError) as e:
        print(json.dumps({'valid':False,'error':str(e)},ensure_ascii=False,indent=2));return 1
if __name__=='__main__':sys.exit(main())

```

FILE implementation/bootstrap_dimension.py sha256:882a6e442f1becd3e6f817a68cd368fa5b5c16ffdf90c0f136bc8d24bbe7498b
```
"""Create a NEW Dimension from a verified composition. Never modifies an existing one.

The Vercy skill path is an explicitly trusted caller input, not package content.
Semantic packages are kept in a separate registry; only explicit native bindings
enter the current V1-V3 registry. Nested semantic validation remains mandatory.
"""
from pathlib import Path
import argparse, json, os, shutil, subprocess, sys, tempfile, uuid
import composition as c

def bootstrap(stage,policy,lock,skill,target,name,namespace):
    stage=Path(stage).resolve();skill=Path(skill).resolve();target=Path(target).absolute()
    plan_raw=(stage/'composition-plan.json').read_bytes();plan=json.loads(plan_raw)
    receipt=c.load(stage/'receipt.json')
    c.require(receipt.get('status')=='assets-staged' and receipt.get('planDigest')==c.digest(plan_raw),'STAGE','unrecognized or changed staged plan')
    policy_raw=Path(policy).read_bytes();lock_raw=Path(lock).read_bytes()
    c.require(c.load(lock).get('models')==[],'NEW-ONLY','new Dimension requires empty starting lock; existing data needs a separate migration')
    c.validate(plan,stage/'assets',policy_raw,lock_raw)
    c.require(namespace==plan['dimensionId'],'OWNER','created Dimension namespace must equal the authorized dimensionId')
    c.require(target.parent.is_dir() and not target.exists(),'NEW-ONLY','target must not exist; create its parent first')
    c.require((skill/'scripts/create_dimension.py').is_file() and (skill/'scripts/vercy.py').is_file(),'SKILL','trusted local Vercy skill is required')
    lease=target.parent/('.'+target.name+'.composition-write.lock')
    try:lease.mkdir()
    except FileExistsError:raise c.Invalid('BUSY: another bootstrap or stale lease exists')
    temp=None
    try:
        (lease/'owner.json').write_bytes(c.encode({'pid':os.getpid(),'nonce':str(uuid.uuid4()),'createdAt':c.now()}))
        temp=Path(tempfile.mkdtemp(prefix='.'+target.name+'.bootstrap-',dir=target.parent))
        cmd=[sys.executable,str(skill/'scripts/create_dimension.py'),'--target',str(temp),'--name',name,'--namespace',namespace,'--owner',plan['authority']['owner'],'--preset','commercial-company','--purpose',plan['authority']['purpose']]
        proc=subprocess.run(cmd,capture_output=True,text=True,encoding='utf-8')
        c.require(proc.returncode==0,'BOOTSTRAP',proc.stderr or proc.stdout)
        # Change only the two location fields in the current trusted template.
        dimension=c.load(temp/'dimension.yaml')
        c.require(dimension['id']==namespace and dimension['canonical']['location']==str(temp),'BOOTSTRAP','unexpected trusted Dimension template')
        dimension['canonical']['location']=str(target)
        (temp/'dimension.yaml').write_bytes(c.encode(dimension))
        guide=temp/'AGENTS.md';text=guide.read_text(encoding='utf-8')
        old='- Canonical location: '+str(temp)
        c.require(text.splitlines().count(old)==1,'BOOTSTRAP','unexpected canonical-location entry')
        guide.write_text('\n'.join('- Canonical location: '+str(target) if line==old else line for line in text.splitlines())+'\n',encoding='utf-8',newline='\n')
        native=[];semantic=[];pins=[]
        for r in plan['releases']:
            prefix='models/composed/'
            for _,d in c.descriptors(r):
                raw=c.safe_path(stage/'assets',d['path']).read_bytes()
                c.require(c.digest(raw)==d['digest'],'STALE','asset changed after verification')
                dest=c.safe_path(temp,prefix+d['path'],exists=False);dest.parent.mkdir(parents=True,exist_ok=True);dest.write_bytes(raw)
            pin={'id':r['modelId'],'version':r['version'],'status':'published','digest':r['specification']['digest'],'specUrl':r['specification']['sourceUrl'],'agentsUrl':r['agents']['sourceUrl'],'location':str(Path(prefix+r['specification']['path']).parent).replace('\\','/'),'readiness':r['installationMode']}
            pins.append(pin)
            row={'id':r['modelId'],'version':r['version'],'agents':prefix+r['agents']['path'],'specification':prefix+r['specification']['path'],'specificationDigest':r['specification']['digest']}
            if r['binding']:
                row['runtimeSchema']=prefix+r['binding']['runtime']['path'];row['runtimeSchemaDigest']=r['binding']['runtime']['digest'];row['bindingScope']=r['binding']['scope'];native.append(row)
            else:semantic.append({**row,'readiness':'semantic-only','nativeFactsAllowed':False})
        registry=c.load(temp/'registries/meta-models.yaml');registry['models']=native;(temp/'registries/meta-models.yaml').write_bytes(c.encode(registry))
        (temp/'registries/semantic-models.yaml').write_bytes(c.encode({'format':'vercy-semantic-model-registry','version':1,'models':semantic,'note':'Semantic references, not native V1-V3 model entries.'}))
        newlock=c.load(temp/'vercy.lock');newlock['models']=pins;(temp/'vercy.lock').write_bytes(c.encode(newlock))
        links=c.load(temp/'registries/model-links.yaml');links['links']=[{'source':r['modelId'],'type':'requires','target':t['modelId'],'version':t['version']} for r in plan['releases'] for t in r['requires']];(temp/'registries/model-links.yaml').write_bytes(c.encode(links))
        events=c.load(temp/'registries/events.yaml');events.setdefault('events',[]).append({'id':plan['planId']+':bootstrap','type':'composition-bootstrapped','occurredAt':c.now(),'actor':plan['authority']['actor'],'subject':plan['dimensionId'],'planDigest':c.digest(plan_raw),'nativeBoundModels':len(native),'semanticOnlyModels':len(semantic)});(temp/'registries/events.yaml').write_bytes(c.encode(events))
        proof=temp/'composition';proof.mkdir();(proof/'plan.json').write_bytes(plan_raw);(proof/'staging-receipt.json').write_bytes(c.encode(receipt))
        proc=subprocess.run([sys.executable,str(skill/'scripts/vercy.py'),'validate',str(temp)],capture_output=True,text=True,encoding='utf-8')
        report=json.loads(proc.stdout);c.require(proc.returncode==0 and report.get('valid'),'NATIVE','staged Dimension failed V1-V3 validation: '+proc.stdout)
        report.pop('dimension',None)
        (proof/'bootstrap-validation.json').write_bytes(c.encode(report))
        c.require(Path(policy).read_bytes()==policy_raw and Path(lock).read_bytes()==lock_raw,'STALE','policy or starting lock changed')
        c.validate(plan,stage/'assets',policy_raw,lock_raw)
        c.require(not target.exists(),'NEW-ONLY','target appeared before activation')
        os.rename(temp,target);temp=None
        return {'created':True,'target':str(target),'nativeBoundModels':len(native),'semanticOnlyModels':len(semantic),'nativeControlValidation':report,'limits':'No instance facts created. Native binding checks do not execute companion validators or certify nested semantics. Existing Dimensions are not changed.'}
    finally:
        if temp is not None and temp.parent==target.parent and temp.name.startswith('.'+target.name+'.bootstrap-'):shutil.rmtree(temp)
        shutil.rmtree(lease)

def main():
    p=argparse.ArgumentParser(description=__doc__)
    for name in ['stage','policy','lock','skill','target','name','namespace']:p.add_argument('--'+name,required=True)
    a=p.parse_args()
    try:print(json.dumps(bootstrap(a.stage,a.policy,a.lock,a.skill,a.target,a.name,a.namespace),ensure_ascii=False,indent=2));return 0
    except (c.Invalid,ValueError,OSError,KeyError,TypeError) as e:print(json.dumps({'created':False,'error':str(e)},indent=2));return 1
if __name__=='__main__':sys.exit(main())

```

FILE implementation/composition-plan.schema.json sha256:cc33e9ee4522cd586a2e1fb07307e6aa5361bf7cf3ca99a419c0f434d0e8a079
```
{

  "$schema": "https://json-schema.org/draft/2020-12/schema",

  "$id": "https://ver.cy/models/wm-xct-040-model-composition-resolution/versions/0.1.0/composition-plan.schema.json",

  "title": "Bounded exact model composition plan",

  "type": "object",

  "additionalProperties": false,

  "required": [

    "format",

    "schemaVersion",

    "planId",

    "revision",

    "supersedes",

    "dimensionId",

    "createdAt",

    "validUntil",

    "baseLockDigest",

    "algorithm",

    "authority",

    "roots",

    "releases",

    "provenance"

  ],

  "properties": {

    "format": {

      "const": "vercy-composition-plan"

    },

    "schemaVersion": {

      "const": "1.0.0"

    },

    "planId": {

      "type": "string",

      "pattern": "^[a-z][a-z0-9+.-]*:[^\\s]+$",

      "maxLength": 256

    },

    "revision": {

      "type": "integer",

      "minimum": 1

    },

    "supersedes": {

      "anyOf": [

        {

          "type": "string",

          "pattern": "^[a-z][a-z0-9+.-]*:[^\\s]+$",

          "maxLength": 256

        },

        {

          "type": "null"

        }

      ]

    },

    "dimensionId": {

      "type": "string",

      "pattern": "^[a-z][a-z0-9+.-]*:[^\\s]+$",

      "maxLength": 256

    },

    "createdAt": {

      "type": "string",

      "format": "date-time",

      "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}:\\d{2})$"

    },

    "validUntil": {

      "type": "string",

      "format": "date-time",

      "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}:\\d{2})$"

    },

    "baseLockDigest": {

      "type": "string",

      "pattern": "^sha256:[a-f0-9]{64}$"

    },

    "algorithm": {

      "const": "exact-closure-v1"

    },

    "authority": {

      "$ref": "#/$defs/authority"

    },

    "roots": {

      "type": "array",

      "minItems": 1,

      "items": {

        "$ref": "#/$defs/releaseRef"

      }

    },

    "releases": {

      "type": "array",

      "minItems": 1,

      "items": {

        "$ref": "#/$defs/release"

      }

    },

    "provenance": {

      "$ref": "#/$defs/provenance"

    }

  },

  "$defs": {

    "releaseRef": {

      "type": "object",

      "additionalProperties": false,

      "required": [

        "modelId",

        "version"

      ],

      "properties": {

        "modelId": {

          "type": "string",

          "pattern": "^[a-z][a-z0-9.-]{2,127}$"

        },

        "version": {

          "type": "string",

          "pattern": "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(-[0-9A-Za-z.-]+)?(\\+[0-9A-Za-z.-]+)?$",

          "maxLength": 128

        }

      }

    },

    "descriptor": {

      "type": "object",

      "additionalProperties": false,

      "required": [

        "path",

        "digest",

        "size",

        "mediaType",

        "sourceUrl"

      ],

      "properties": {

        "path": {

          "type": "string",

          "pattern": "^[A-Za-z0-9][A-Za-z0-9._/-]{0,300}$"

        },

        "digest": {

          "type": "string",

          "pattern": "^sha256:[a-f0-9]{64}$"

        },

        "size": {

          "type": "integer",

          "minimum": 1,

          "maximum": 20000000

        },

        "mediaType": {

          "enum": [

            "text/markdown",

            "application/json",

            "application/yaml",

            "text/x-python"

          ]

        },

        "sourceUrl": {

          "type": "string",

          "format": "uri",

          "pattern": "^https://"

        }

      }

    },

    "fingerprint": {

      "type": "object",

      "additionalProperties": false,

      "required": [

        "algorithm",

        "value"

      ],

      "properties": {

        "algorithm": {

          "type": "string",

          "minLength": 1,

          "maxLength": 2048

        },

        "value": {

          "type": "string",

          "minLength": 1,

          "maxLength": 2048

        }

      }

    },

    "binding": {

      "type": "object",

      "additionalProperties": false,

      "required": [

        "id",

        "version",

        "forSpecificationDigest",

        "runtime",

        "instanceSchema",

        "companionValidator",

        "scope"

      ],

      "properties": {

        "id": {

          "type": "string",

          "pattern": "^[a-z][a-z0-9+.-]*:[^\\s]+$",

          "maxLength": 256

        },

        "version": {

          "type": "string",

          "pattern": "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(-[0-9A-Za-z.-]+)?(\\+[0-9A-Za-z.-]+)?$",

          "maxLength": 128

        },

        "forSpecificationDigest": {

          "type": "string",

          "pattern": "^sha256:[a-f0-9]{64}$"

        },

        "runtime": {

          "$ref": "#/$defs/descriptor"

        },

        "instanceSchema": {

          "anyOf": [

            {

              "$ref": "#/$defs/descriptor"

            },

            {

              "type": "null"

            }

          ]

        },

        "companionValidator": {

          "anyOf": [

            {

              "$ref": "#/$defs/descriptor"

            },

            {

              "type": "null"

            }

          ]

        },

        "scope": {

          "type": "string",

          "minLength": 1,

          "maxLength": 2048

        }

      }

    },

    "compatibility": {

      "type": "object",

      "additionalProperties": false,

      "required": [

        "decision",

        "evidence",

        "reviewer",

        "observedAt",

        "scope"

      ],

      "properties": {

        "decision": {

          "enum": [

            "accepted",

            "unknown",

            "rejected"

          ]

        },

        "evidence": {

          "type": "string",

          "pattern": "^[a-z][a-z0-9+.-]*:[^\\s]+$",

          "maxLength": 256

        },

        "reviewer": {

          "type": "string",

          "pattern": "^[a-z][a-z0-9+.-]*:[^\\s]+$",

          "maxLength": 256

        },

        "observedAt": {

          "type": "string",

          "format": "date-time",

          "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}:\\d{2})$"

        },

        "scope": {

          "type": "string",

          "minLength": 1,

          "maxLength": 2048

        }

      }

    },

    "release": {

      "type": "object",

      "additionalProperties": false,

      "required": [

        "modelId",

        "version",

        "namespace",

        "role",

        "publicationStatus",

        "researchAssurance",

        "semanticFingerprint",

        "specification",

        "agents",

        "requires",

        "references",

        "installationMode",

        "binding",

        "compatibility"

      ],

      "properties": {

        "modelId": {

          "type": "string",

          "pattern": "^[a-z][a-z0-9.-]{2,127}$"

        },

        "version": {

          "type": "string",

          "pattern": "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(-[0-9A-Za-z.-]+)?(\\+[0-9A-Za-z.-]+)?$",

          "maxLength": 128

        },

        "namespace": {

          "type": "string",

          "pattern": "^[a-z][a-z0-9+.-]*:[^\\s]+$",

          "maxLength": 256

        },

        "role": {

          "enum": [

            "core",

            "landscape",

            "kernel"

          ]

        },

        "publicationStatus": {

          "enum": [

            "published",

            "draft",

            "legacy",

            "retired"

          ]

        },

        "researchAssurance": {

          "enum": [

            "reviewable-draft",

            "independently-reviewed"

          ]

        },

        "semanticFingerprint": {

          "anyOf": [

            {

              "$ref": "#/$defs/fingerprint"

            },

            {

              "type": "null"

            }

          ]

        },

        "specification": {

          "$ref": "#/$defs/descriptor"

        },

        "agents": {

          "$ref": "#/$defs/descriptor"

        },

        "requires": {

          "type": "array",

          "minItems": 0,

          "items": {

            "$ref": "#/$defs/releaseRef"

          }

        },

        "references": {

          "type": "array",

          "minItems": 0,

          "items": {

            "$ref": "#/$defs/releaseRef"

          }

        },

        "installationMode": {

          "enum": [

            "semantic-only",

            "native-binding"

          ]

        },

        "binding": {

          "anyOf": [

            {

              "$ref": "#/$defs/binding"

            },

            {

              "type": "null"

            }

          ]

        },

        "compatibility": {

          "$ref": "#/$defs/compatibility"

        }

      }

    },

    "authority": {

      "type": "object",

      "additionalProperties": false,

      "required": [

        "owner",

        "actor",

        "purpose",

        "policyRef",

        "policyDigest",

        "decision",

        "allowedModelIds",

        "allowReviewableDrafts"

      ],

      "properties": {

        "owner": {

          "type": "string",

          "pattern": "^[a-z][a-z0-9+.-]*:[^\\s]+$",

          "maxLength": 256

        },

        "actor": {

          "type": "string",

          "pattern": "^[a-z][a-z0-9+.-]*:[^\\s]+$",

          "maxLength": 256

        },

        "purpose": {

          "type": "string",

          "minLength": 1,

          "maxLength": 2048

        },

        "policyRef": {

          "type": "string",

          "pattern": "^[a-z][a-z0-9+.-]*:[^\\s]+$",

          "maxLength": 256

        },

        "policyDigest": {

          "type": "string",

          "pattern": "^sha256:[a-f0-9]{64}$"

        },

        "decision": {

          "enum": [

            "allow",

            "deny"

          ]

        },

        "allowedModelIds": {

          "type": "array",

          "minItems": 1,

          "items": {

            "type": "string",

            "pattern": "^[a-z][a-z0-9.-]{2,127}$"

          }

        },

        "allowReviewableDrafts": {

          "type": "boolean"

        }

      }

    },

    "provenance": {

      "type": "object",

      "additionalProperties": false,

      "required": [

        "source",

        "masterSystem",

        "recordedAt",

        "classification",

        "evidenceKind"

      ],

      "properties": {

        "source": {

          "type": "string",

          "pattern": "^[a-z][a-z0-9+.-]*:[^\\s]+$",

          "maxLength": 256

        },

        "masterSystem": {

          "type": "string",

          "pattern": "^[a-z][a-z0-9+.-]*:[^\\s]+$",

          "maxLength": 256

        },

        "recordedAt": {

          "type": "string",

          "format": "date-time",

          "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}:\\d{2})$"

        },

        "classification": {

          "enum": [

            "public-synthetic",

            "private"

          ]

        },

        "evidenceKind": {

          "enum": [

            "observed",

            "source-asserted",

            "proposal"

          ]

        }

      }

    }

  }

}


```

FILE implementation/policy.schema.json sha256:92e0386696c974b1e8a312b60ca08d981c223e9925c8f70dabdfa135b9041543
```
{

  "$schema": "https://json-schema.org/draft/2020-12/schema",

  "$id": "https://ver.cy/models/wm-xct-040-model-composition-resolution/versions/0.1.0/policy.schema.json",

  "title": "Caller-supplied local composition authority policy",

  "type": "object",

  "additionalProperties": false,

  "required": [

    "format",

    "version",

    "id",

    "dimensionId",

    "owner",

    "actors",

    "purposes",

    "allowInstall",

    "allowedModelIds",

    "allowReviewableDrafts",

    "reviewers",

    "allowedOrigins",

    "validFrom",

    "validUntil"

  ],

  "properties": {

    "format": {

      "const": "vercy-composition-policy"

    },

    "version": {

      "const": 1

    },

    "id": {

      "type": "string",

      "pattern": "^[a-z][a-z0-9+.-]*:[^\\s]+$",

      "maxLength": 256

    },

    "dimensionId": {

      "type": "string",

      "pattern": "^[a-z][a-z0-9+.-]*:[^\\s]+$",

      "maxLength": 256

    },

    "owner": {

      "type": "string",

      "pattern": "^[a-z][a-z0-9+.-]*:[^\\s]+$",

      "maxLength": 256

    },

    "actors": {

      "type": "array",

      "minItems": 1,

      "items": {

        "type": "string",

        "pattern": "^[a-z][a-z0-9+.-]*:[^\\s]+$",

        "maxLength": 256

      }

    },

    "purposes": {

      "type": "array",

      "minItems": 1,

      "items": {

        "type": "string",

        "minLength": 1,

        "maxLength": 2048

      }

    },

    "allowInstall": {

      "type": "boolean"

    },

    "allowedModelIds": {

      "type": "array",

      "minItems": 1,

      "items": {

        "type": "string",

        "pattern": "^[a-z][a-z0-9.-]{2,127}$"

      }

    },

    "allowReviewableDrafts": {

      "type": "boolean"

    },

    "reviewers": {

      "type": "array",

      "minItems": 1,

      "items": {

        "type": "string",

        "pattern": "^[a-z][a-z0-9+.-]*:[^\\s]+$",

        "maxLength": 256

      }

    },

    "allowedOrigins": {

      "type": "array",

      "minItems": 1,

      "items": {

        "type": "string",

        "pattern": "^https://[a-z0-9.-]+(?::[0-9]+)?$"

      }

    },

    "validFrom": {

      "type": "string",

      "format": "date-time",

      "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}:\\d{2})$"

    },

    "validUntil": {

      "type": "string",

      "format": "date-time",

      "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}:\\d{2})$"

    }

  }

}


```

FILE implementation/test_composition.py sha256:13b39faad253648cd43a2743839f655d23efa84051930e9a7d1b624e5f48cb32
```
"""Behavioral tests, including adversarial semantic and state-change cases."""
from pathlib import Path
import copy, json, tempfile, unittest, datetime as dt
from unittest.mock import patch
import composition as c

class CompositionTests(unittest.TestCase):
    def setUp(self):
        self.tmp=tempfile.TemporaryDirectory();self.addCleanup(self.tmp.cleanup)
        self.root=Path(self.tmp.name);self.assets=self.root/'assets';self.assets.mkdir()
        self.when=c.now();self.future=(dt.datetime.now(dt.timezone.utc)+dt.timedelta(days=1)).isoformat(timespec='seconds')
        self.policy={'format':'vercy-composition-policy','version':1,'id':'urn:policy:fixture','dimensionId':'urn:dimension:fixture','owner':'urn:owner:fixture','actors':['urn:actor:fixture'],'purposes':['Assemble synthetic company'],'allowInstall':True,'allowedModelIds':['test.company','test.unit','test.ai'],'allowReviewableDrafts':True,'reviewers':['urn:reviewer:fixture'],'allowedOrigins':['https://example.test'],'validFrom':'2026-01-01T00:00:00Z','validUntil':'2100-01-01T00:00:00Z'}
        self.policy_raw=c.encode(self.policy);self.lock_raw=c.encode(c.EMPTY_LOCK)
        self.plan={'format':'vercy-composition-plan','schemaVersion':'1.0.0','planId':'urn:plan:fixture','revision':1,'supersedes':None,'dimensionId':'urn:dimension:fixture','createdAt':self.when,'validUntil':self.future,'baseLockDigest':c.digest(self.lock_raw),'algorithm':'exact-closure-v1','authority':{'owner':'urn:owner:fixture','actor':'urn:actor:fixture','purpose':'Assemble synthetic company','policyRef':self.policy['id'],'policyDigest':c.digest(self.policy_raw),'decision':'allow','allowedModelIds':self.policy['allowedModelIds'],'allowReviewableDrafts':True},'roots':[{'modelId':'test.company','version':'1.0.0'}],'releases':[self.release('test.company')],'provenance':{'source':'urn:fixture:source','masterSystem':'urn:fixture:control-plane','recordedAt':self.when,'classification':'public-synthetic','evidenceKind':'proposal'}}
    def asset(self,path,value,media='application/json'):
        raw=c.encode(value) if not isinstance(value,bytes) else value
        p=self.assets/path;p.parent.mkdir(parents=True,exist_ok=True);p.write_bytes(raw)
        return {'path':path,'digest':c.digest(raw),'size':len(raw),'mediaType':media,'sourceUrl':'https://example.test/'+path}
    def release(self,mid,native=False,nested=False):
        r={'modelId':mid,'version':'1.0.0','namespace':'urn:namespace:'+mid,'role':'core','publicationStatus':'published','researchAssurance':'reviewable-draft','semanticFingerprint':None,'specification':self.asset(mid+'/spec.yaml',{'metaModel':{'registryId':mid,'version':'1.0.0'}},'application/yaml'),'agents':self.asset(mid+'/AGENTS.md',b'# Synthetic fixture model\n','text/markdown'),'requires':[],'references':[],'installationMode':'semantic-only','binding':None,'compatibility':{'decision':'accepted','evidence':'urn:fixture:compatibility','reviewer':'urn:reviewer:fixture','observedAt':self.when,'scope':'Synthetic offline reference tests only'}}
        if native:
            r['installationMode']='native-binding';r['binding']={'id':'urn:binding:'+mid,'version':'1.0.0','forSpecificationDigest':r['specification']['digest'],'runtime':self.asset(mid+'/runtime.json',{'format':'vercy-runtime-model-schema','schemaVersion':'1.0.0','modelId':mid,'paths':{mid+'.snapshot':{'valueTypes':['object' if nested else 'string'],'units':[None]}}}),'instanceSchema':None,'companionValidator':None,'scope':'Fixture snapshot, not general domain conformance'}
            if nested:
                r['binding']['instanceSchema']=self.asset(mid+'/instance.schema.json',{'$schema':c.DIALECT,'type':'object','required':['name'],'properties':{'name':{'type':'string','minLength':1}},'additionalProperties':False})
                r['binding']['companionValidator']=self.asset(mid+'/validator.py',b'# Fixture only; never executed by composer\n','text/x-python')
        return r
    def runplan(self,plan=None):return c.validate(plan or self.plan,self.assets,self.policy_raw,self.lock_raw)
    def rejects(self,code):
        with self.assertRaisesRegex(c.Invalid,'^'+code+':'):self.runplan()
    def replaceasset(self,r,field,value):
        d=r['binding'][field];r['binding'][field]=self.asset(d['path'],value,d['mediaType'])
    def files(self):
        p=self.root/'plan.json';p.write_bytes(c.encode(self.plan));pol=self.root/'policy.json';pol.write_bytes(self.policy_raw);lock=self.root/'current.lock';lock.write_bytes(self.lock_raw);return p,pol,lock
    def test_startup_semantic_only(self):self.assertTrue(self.runplan()['valid'])
    def test_group_two_independent_roots(self):
        self.plan['releases'].append(self.release('test.unit',True));self.plan['roots'].append({'modelId':'test.unit','version':'1.0.0'});self.assertEqual(self.runplan()['modelCount'],2)
    def test_ai_structured_binding(self):
        self.plan['releases']=[self.release('test.company',True,True)];self.assertTrue(self.runplan()['valid'])
    def test_required_dependency_closure(self):
        self.plan['releases'][0]['requires']=[{'modelId':'test.unit','version':'1.0.0'}];self.plan['releases'].append(self.release('test.unit'));self.assertTrue(self.runplan()['valid'])
    def test_optional_reference_does_not_import_packages(self):
        self.plan['releases'][0]['references']=[{'modelId':'test.unit','version':'1.0.0'}];self.assertEqual(self.runplan()['modelCount'],1)
    def test_round_trip(self):self.assertEqual(self.runplan(),self.runplan(json.loads(c.encode(self.plan))))
    def test_correction_revision(self):self.plan.update(revision=2,supersedes='urn:plan:previous');self.assertTrue(self.runplan()['valid'])
    def test_unknown_top_level_field(self):self.plan['approvedByAi']=True;self.rejects('SCHEMA')
    def test_missing_runtime_binding(self):self.plan['releases'][0]['installationMode']='native-binding';self.rejects('READINESS')
    def test_hidden_binding(self):self.plan['releases']=[self.release('test.company',True)];self.plan['releases'][0]['installationMode']='semantic-only';self.rejects('READINESS')
    def test_empty_runtime(self):
        self.plan['releases']=[self.release('test.company',True)];r=self.plan['releases'][0];v=c.load(self.assets/r['binding']['runtime']['path']);v['paths']={};self.replaceasset(r,'runtime',v);self.rejects('BINDING')
    def test_nested_without_companion(self):
        self.plan['releases']=[self.release('test.company',True,True)];self.plan['releases'][0]['binding']['companionValidator']=None;self.rejects('NESTED')
    def test_external_schema_reference(self):
        self.plan['releases']=[self.release('test.company',True,True)];r=self.plan['releases'][0];s=c.load(self.assets/r['binding']['instanceSchema']['path']);s['properties']['name']={'$ref':'https://evil.test/schema'};self.replaceasset(r,'instanceSchema',s);self.rejects('SCHEMA-REF')
    def test_unresolved_internal_reference(self):
        self.plan['releases']=[self.release('test.company',True,True)];r=self.plan['releases'][0];s=c.load(self.assets/r['binding']['instanceSchema']['path']);s['properties']['name']={'$ref':'#/$defs/missing'};self.replaceasset(r,'instanceSchema',s);self.rejects('SCHEMA-REF')
    def test_unknown_schema_dialect(self):
        self.plan['releases']=[self.release('test.company',True,True)];r=self.plan['releases'][0];s=c.load(self.assets/r['binding']['instanceSchema']['path']);s['$schema']='https://example.test/dialect';self.replaceasset(r,'instanceSchema',s);self.rejects('DIALECT')
    def test_permissive_nested_schema(self):
        self.plan['releases']=[self.release('test.company',True,True)];r=self.plan['releases'][0];self.replaceasset(r,'instanceSchema',{'$schema':c.DIALECT});self.rejects('NESTED')
    def test_binding_spec_mismatch(self):
        self.plan['releases']=[self.release('test.company',True)];self.plan['releases'][0]['binding']['forSpecificationDigest']='sha256:'+'0'*64;self.rejects('BINDING')
    def test_spec_identity_mismatch(self):
        r=self.plan['releases'][0];r['specification']=self.asset('test.company/spec.yaml',{'metaModel':{'registryId':'wrong.company','version':'1.0.0'}},'application/yaml');self.rejects('SPEC')
    def test_digest_tampering(self):(self.assets/'test.company/AGENTS.md').write_bytes(b'injected');self.rejects('DIGEST')
    def test_path_escape(self):self.plan['releases'][0]['agents']['path']='x/../../escape.md';self.rejects('PATH')
    def test_windows_reserved_name(self):self.plan['releases'][0]['agents']['path']='CON.md';self.rejects('PATH')
    def test_alias_path_collision(self):self.plan['releases'][0]['agents']=copy.deepcopy(self.plan['releases'][0]['specification']);self.rejects('COLLISION')
    def test_untrusted_origin(self):self.plan['releases'][0]['agents']['sourceUrl']='https://evil.test/a';self.rejects('ORIGIN')
    def test_credential_in_source_url(self):self.plan['releases'][0]['agents']['sourceUrl']='https://user:pass@example.test/a';self.rejects('ORIGIN')
    def test_policy_denied(self):self.plan['authority']['decision']='deny';self.rejects('DENIED')
    def test_forged_policy(self):self.plan['authority']['policyDigest']='sha256:'+'0'*64;self.rejects('POLICY-DIGEST')
    def test_undeclared_actor(self):self.plan['authority']['actor']='urn:actor:evil';self.rejects('AUTHORITY')
    def test_other_dimension(self):self.plan['dimensionId']='urn:dimension:other';self.rejects('OWNER')
    def test_stale_lock(self):self.plan['baseLockDigest']='sha256:'+'0'*64;self.rejects('STALE')
    def test_expired_plan(self):self.plan['validUntil']='2026-01-01T00:00:00Z';self.rejects('TIME')
    def test_naive_time(self):self.plan['createdAt']='2026-09-21T00:00:00';self.rejects('SCHEMA')
    def test_same_identity_two_versions(self):
        self.plan['releases'].append(copy.deepcopy(self.plan['releases'][0]));self.plan['releases'][1]['version']='2.0.0';self.rejects('VERSION')
    def test_unknown_dependency(self):self.plan['releases'][0]['requires']=[{'modelId':'test.unit','version':'1.0.0'}];self.rejects('CLOSURE')
    def test_cycle(self):self.plan['releases'][0]['requires']=[{'modelId':'test.company','version':'1.0.0'}];self.rejects('CYCLE')
    def test_extraneous_dependency(self):self.plan['releases'].append(self.release('test.unit'));self.rejects('MINIMAL')
    def test_kernel_domain_import(self):r=self.plan['releases'][0];r['role']='kernel';r['requires']=[{'modelId':'test.unit','version':'1.0.0'}];self.rejects('KERNEL')
    def test_draft_release(self):self.plan['releases'][0]['publicationStatus']='draft';self.rejects('LIFECYCLE')
    def test_unresolved_compatibility(self):self.plan['releases'][0]['compatibility']['decision']='unknown';self.rejects('COMPATIBILITY')
    def test_namespace_collision(self):
        self.plan['releases'].append(self.release('test.unit'));self.plan['releases'][1]['namespace']=self.plan['releases'][0]['namespace'];self.rejects('NAMESPACE')
    def test_revision_without_parent(self):self.plan['revision']=2;self.rejects('REVISION')
    def test_implicit_upgrade_refused(self):
        self.lock_raw=c.encode({'models':[{'id':'test.company','version':'0.9.0','digest':self.plan['releases'][0]['specification']['digest']}]});self.plan['baseLockDigest']=c.digest(self.lock_raw);self.rejects('MIGRATION')
    def test_repeat_staging_is_idempotent(self):
        p,pol,lock=self.files();target=self.root/'staged';first=c.stage(p,self.assets,pol,lock,target);second=c.stage(p,self.assets,pol,lock,target);self.assertTrue(first['changed']);self.assertFalse(second['changed']);self.assertFalse(first['receipt']['nativeRuntimeValidated'])
    def test_existing_target_preserved(self):
        p,pol,lock=self.files();target=self.root/'existing';target.mkdir();(target/'keep').write_text('unchanged');
        with self.assertRaisesRegex(c.Invalid,'TARGET:'):c.stage(p,self.assets,pol,lock,target)
        self.assertEqual((target/'keep').read_text(),'unchanged')
    def test_competing_writer(self):
        p,pol,lock=self.files();(self.root/'.staged.composition-write.lock').mkdir()
        with self.assertRaisesRegex(c.Invalid,'BUSY:'):c.stage(p,self.assets,pol,lock,self.root/'staged')
    def test_failed_commit_leaves_no_target(self):
        p,pol,lock=self.files();target=self.root/'staged'
        with patch.object(c.os,'rename',side_effect=OSError('simulated rename failure')):
            with self.assertRaises(OSError):c.stage(p,self.assets,pol,lock,target)
        self.assertFalse(target.exists());self.assertFalse((self.root/'.staged.composition-write.lock').exists());self.assertFalse(list(self.root.glob('.staged.stage-*')))
    def test_library_historical_write_refused(self):
        p,pol,lock=self.files()
        with self.assertRaisesRegex(c.Invalid,'TIME:'):c.stage(p,self.assets,pol,lock,self.root/'staged',at=self.when)
        self.assertFalse((self.root/'staged').exists())
    def test_same_version_changed_bytes_refused(self):
        self.lock_raw=c.encode({'models':[{'id':'test.company','version':'1.0.0','digest':'sha256:'+'f'*64}]});self.plan['baseLockDigest']=c.digest(self.lock_raw);self.rejects('MIGRATION')
    def test_real_yaml_profile_refused(self):
        self.plan['releases'][0]['specification']=self.asset('test.company/spec.yaml',b'metaModel:\n  registryId: test.company\n  version: 1.0.0\n','application/yaml');self.rejects('SPEC')
    def test_nested_open_object_refused(self):
        self.plan['releases']=[self.release('test.company',True,True)];r=self.plan['releases'][0];s=c.load(self.assets/r['binding']['instanceSchema']['path']);s['properties']['snapshot']={'type':'object'};self.replaceasset(r,'instanceSchema',s);self.rejects('NESTED')
    def test_internal_ref_resolves(self):
        self.plan['releases']=[self.release('test.company',True,True)];r=self.plan['releases'][0];s=c.load(self.assets/r['binding']['instanceSchema']['path']);s['$defs']={'name':s['properties']['name']};s['properties']['name']={'$ref':'#/$defs/name'};self.replaceasset(r,'instanceSchema',s);self.assertTrue(self.runplan()['valid'])
    def test_draft_assurance_not_authorized(self):self.plan['authority']['allowReviewableDrafts']=False;self.rejects('ASSURANCE')
    def test_empty_agents(self):self.plan['releases'][0]['agents']=self.asset('test.company/AGENTS.md',b' \n','text/markdown');self.rejects('AGENTS')
    def test_shared_native_path_refused(self):
        self.plan['releases']=[self.release('test.company',True),self.release('test.unit',True)];r=self.plan['releases'][1];self.plan['roots'].append({'modelId':'test.unit','version':'1.0.0'});s=c.load(self.assets/r['binding']['runtime']['path']);s['paths']={'test.company.snapshot':{'valueTypes':['string'],'units':[None]}};self.replaceasset(r,'runtime',s);self.rejects('FACT-PATH')
    def test_kernel_leaf_allowed(self):self.plan['releases'][0]['role']='kernel';self.assertTrue(self.runplan()['valid'])
    def test_policy_change_before_staging_commit(self):
        p,pol,lock=self.files();original=c.tempfile.mkdtemp
        def mutate(*args,**kwargs):
            out=original(*args,**kwargs);pol.write_bytes(b'{}');return out
        with patch.object(c.tempfile,'mkdtemp',side_effect=mutate):
            with self.assertRaisesRegex(c.Invalid,'STALE:'):c.stage(p,self.assets,pol,lock,self.root/'staged')
        self.assertFalse((self.root/'staged').exists())

if __name__=='__main__':
    suite=unittest.defaultTestLoader.loadTestsFromTestCase(CompositionTests)
    result=unittest.TextTestRunner(verbosity=2).run(suite)
    report={'tests':result.testsRun,'failures':len(result.failures),'errors':len(result.errors),'passed':result.wasSuccessful(),'scope':'Offline exact closure, trusted policy, descriptor integrity, readiness, historical correction, idempotency and staged-commit failure. Synthetic assets; native runtime acceptance is a separate test.'}
    (Path(__file__).parent/'test-results.json').write_bytes(c.encode(report))
    raise SystemExit(0 if result.wasSuccessful() else 1)

```

FILE implementation/acceptance.py sha256:1c8a1f6aea2843aea955d6849debfb47ce8bb97c02e5ecc9f3550a6fee84a21e
```
"""Reproduce three synthetic new-Dimension trials against a trusted Vercy skill.

Usage: python acceptance.py --skill /trusted/vercy/skills/vercy --report result.json

Never uses real company data or changes an existing Dimension.

"""

from pathlib import Path

import argparse,copy,importlib.util,json,sys,tempfile,subprocess
from unittest.mock import patch
import bootstrap_dimension as bd
import composition as c

from bootstrap_dimension import bootstrap



def run(skill):

    skill=Path(skill).resolve();examples=Path(__file__).resolve().parent/'examples'

    sys.path.insert(0,str(skill/'scripts'))

    from write_record import append

    from validate_dimension import validate as native_validate

    reports=[];failure_checks=[]
    with tempfile.TemporaryDirectory(prefix='vercy-composition-acceptance-') as tmp:

        root=Path(tmp)

        for name in ['startup','group','ai-team']:

            src=examples/name;plan=c.load(src/'plan.json');stage=root/(name+'-stage');target=root/name

            c.stage(src/'plan.json',examples/'assets',src/'policy.json',src/'current.lock',stage)

            result=bootstrap(stage,src/'policy.json',src/'current.lock',skill,target,'Synthetic '+name,plan['dimensionId'])

            assert c.load(target/'dimension.yaml')['id']==plan['dimensionId']

            obj={'recordType':'object','schemaVersion':'1.0.0','recordId':'urn:synthetic:org:'+name+':r1','objectId':'urn:synthetic:org:'+name,'objectType':'vr.wm-org-001:organization','name':'Synthetic '+name,'description':'Public fictional acceptance fixture','recordedAt':c.now(),'previousRecordId':None,'state':'active','provenance':{'source':'urn:synthetic:reference','synthetic':True},'accessClass':'synthetic-private'}

            # Start from the current runtime fact template, retaining its exact temporal/provenance shape.

            template=c.load(examples/'native-fact.reference.json')

            fact={**template,'factId':'urn:synthetic:org:'+name+':name:r1','subjectId':obj['objectId'],'path':'organization.reference.name','value':obj['name'],'unit':None}

            for kind,value in [('object',obj),('fact',fact)]:

                f=root/(name+'-'+kind+'.json');f.write_bytes(c.encode(value));append(target,kind,f)

            nested=None

            if name=='ai-team':

                vf=examples/'assets/wm-org-017-performance-objective-review/validate_examples.py'

                module_spec=importlib.util.spec_from_file_location('trusted_performance_reference',vf);module=importlib.util.module_from_spec(module_spec);module_spec.loader.exec_module(module)

                good=c.load(examples/'example-founder-draft.json');bad=copy.deepcopy(good);bad['policy']['automatic_employment_decisions']=True

                assert not module.errors(good) and module.errors(bad)

                for kind in ['object','fact']:append(target,kind,examples/('native-'+kind+'.reference.json'))

                nested={'positivePassed':True,'negativeRejected':True,'rule':'No automatic employment decisions','execution':'Explicit trusted acceptance harness only; composer never executes package code.'}

            validation=native_validate(target);assert validation['valid'],validation

            # A second bootstrap must refuse, preserving all bytes.

            before={str(p.relative_to(target)):c.digest(p.read_bytes()) for p in target.rglob('*') if p.is_file()}

            try:bootstrap(stage,src/'policy.json',src/'current.lock',skill,target,'Synthetic '+name,plan['dimensionId'])

            except c.Invalid:pass

            else:raise AssertionError('existing Dimension was not refused')

            assert before=={str(p.relative_to(target)):c.digest(p.read_bytes()) for p in target.rglob('*') if p.is_file()}

            validation.pop('dimension',None)

            reports.append({'profile':name,'passed':True,'nativeModels':result['nativeBoundModels'],'semanticOnlyModels':result['semanticOnlyModels'],'nativeValidation':validation,'nestedValidation':nested,'existingDimensionPreserved':True})
        src=examples/'startup';stage=root/'startup-stage';plan=c.load(src/'plan.json')
        def invoke(target,namespace=plan['dimensionId']):return bootstrap(stage,src/'policy.json',src/'current.lock',skill,target,'Synthetic startup',namespace)
        target=root/'wrong-dimension'
        try:invoke(target,'urn:dimension:other')
        except c.Invalid as e:assert str(e).startswith('OWNER:')
        else:raise AssertionError('namespace mismatch allowed')
        assert not target.exists();failure_checks.append('authorized Dimension identity enforced')
        target=root/'native-invalid';real_run=bd.subprocess.run
        def invalid_native(cmd,**kwargs):
            if str(skill/'scripts/vercy.py') in cmd:return subprocess.CompletedProcess(cmd,1,json.dumps({'valid':False,'errors':['injected acceptance failure']}),'')
            return real_run(cmd,**kwargs)
        with patch.object(bd.subprocess,'run',side_effect=invalid_native):
            try:invoke(target)
            except c.Invalid as e:assert str(e).startswith('NATIVE:')
            else:raise AssertionError('native failure activated')
        assert not target.exists() and not list(root.glob('.native-invalid.*'));failure_checks.append('failed native validation never activates')
        target=root/'rename-invalid'
        with patch.object(c.os,'rename',side_effect=OSError('injected rename failure')):
            try:invoke(target)
            except OSError:pass
            else:raise AssertionError('rename failure ignored')
        assert not target.exists() and not list(root.glob('.rename-invalid.*'));failure_checks.append('failed activation cleans only own temporary state')
    return {'format':'vercy-composition-acceptance','executedAt':c.now(),'passed':len(reports),'failed':0,'scope':'Synthetic limited bindings, not startup/group/AI-enterprise domain completeness; no real company data.','profiles':reports,'bootstrapFailureChecks':failure_checks}
if __name__=='__main__':

    p=argparse.ArgumentParser();p.add_argument('--skill',required=True);p.add_argument('--report',required=True);a=p.parse_args();report=run(a.skill);Path(a.report).write_bytes(c.encode(report));print(json.dumps(report,indent=2))


```

FILE implementation/test-results.json sha256:cff5f128921c99ee0ecd6ae7c369401143243a37043c2b44dd93897086f981c6
```
{
  "errors": 0,
  "failures": 0,
  "passed": true,
  "scope": "Offline exact closure, trusted policy, descriptor integrity, readiness, historical correction, idempotency and staged-commit failure. Synthetic assets; native runtime acceptance is a separate test.",
  "tests": 55
}

```

FILE implementation/acceptance-results.json sha256:b65c714b20c16f751ab342a0cc339e66810801c66442a3b44772125fad714518
```
{
  "bootstrapFailureChecks": [
    "authorized Dimension identity enforced",
    "failed native validation never activates",
    "failed activation cleans only own temporary state"
  ],
  "executedAt": "2026-09-21T15:13:51Z",
  "failed": 0,
  "format": "vercy-composition-acceptance",
  "passed": 3,
  "profiles": [
    {
      "existingDimensionPreserved": true,
      "nativeModels": 1,
      "nativeValidation": {
        "conformanceLevel": "V3",
        "counts": {
          "events": 0,
          "facts": 1,
          "objects": 1,
          "relations": 0
        },
        "errors": [],
        "schemas": "https://ver.cy/schemas/dimension/1.0/",
        "scope": "executable structure and record semantics; does not certify external truth, legal authority, or safety",
        "valid": true,
        "warnings": []
      },
      "nestedValidation": null,
      "passed": true,
      "profile": "startup",
      "semanticOnlyModels": 0
    },
    {
      "existingDimensionPreserved": true,
      "nativeModels": 1,
      "nativeValidation": {
        "conformanceLevel": "V3",
        "counts": {
          "events": 0,
          "facts": 1,
          "objects": 1,
          "relations": 0
        },
        "errors": [],
        "schemas": "https://ver.cy/schemas/dimension/1.0/",
        "scope": "executable structure and record semantics; does not certify external truth, legal authority, or safety",
        "valid": true,
        "warnings": []
      },
      "nestedValidation": null,
      "passed": true,
      "profile": "group",
      "semanticOnlyModels": 1
    },
    {
      "existingDimensionPreserved": true,
      "nativeModels": 2,
      "nativeValidation": {
        "conformanceLevel": "V3",
        "counts": {
          "events": 0,
          "facts": 2,
          "objects": 2,
          "relations": 0
        },
        "errors": [],
        "schemas": "https://ver.cy/schemas/dimension/1.0/",
        "scope": "executable structure and record semantics; does not certify external truth, legal authority, or safety",
        "valid": true,
        "warnings": []
      },
      "nestedValidation": {
        "execution": "Explicit trusted acceptance harness only; composer never executes package code.",
        "negativeRejected": true,
        "positivePassed": true,
        "rule": "No automatic employment decisions"
      },
      "passed": true,
      "profile": "ai-team",
      "semanticOnlyModels": 0
    }
  ],
  "scope": "Synthetic limited bindings, not startup/group/AI-enterprise domain completeness; no real company data."
}

```

FILE implementation/upstream-verification.json sha256:92aae00ff6c3ceb7c2d520d08dc3751a429676eb835471573b13538fac9b6870
```
{

  "checks": [

    {

      "url": "https://ver.cy/models/wm-org-001-organization/spec.yaml",

      "http": 200,

      "sha256": "ce27fcf5453fb390d7aea631ab91748404ca25968a8b3af67311bf4c65a76cf1",

      "exactBytesMatch": true,

      "profile": "Vercy JSON-compatible YAML"

    },

    {

      "url": "https://ver.cy/models/wm-org-002-organizational-unit/spec.yaml",

      "http": 200,

      "sha256": "9e3e80da4db6db6589991102b91af4af1a00080cd348848250b63f70a97b2330",

      "exactBytesMatch": true,

      "profile": "Vercy JSON-compatible YAML"

    },

    {

      "url": "https://ver.cy/models/wm-org-017-performance-objective-review/spec.yaml",

      "http": 200,

      "sha256": "dfd609fcb460b3b8878df6c0e6cde28f324512b053705b007ec71e2d8aea01f7",

      "exactBytesMatch": true,

      "profile": "Vercy JSON-compatible YAML"

    }

  ]

}


```

FILE implementation/README.md sha256:0062f0dfb87a0c83f79446067ce8e49b04d4214df6cad21fffe364c427089209
```
# Композиция моделей для нового Измерения компании



WM-XCT-040 Model Composition Resolution, 0.1.0. Общий контракт и эталонная реализация.



Модель отвечает на вопрос: какие точные версии моделей выбраны для этого Измерения, кто разрешил их использование, какие зависимости обязательны, какие байты проверены и какие данные уже можно записывать. Это один контракт композиции. Он не заменяет ядро Vercy, модели Компании, Юрлица, Подразделения или Сотрудника.



Публикация доступна для использования и дальнейшего рецензирования. Уровень исследования: `reviewable-draft`. Полная корпоративная архитектура и универсальная совместимость не заявляются. Состояние независимых проверок и оставшиеся ограничения находятся в исследовательском досье.



## Состав



- `model-spec.md`: граница, типы, связи, состояния, права, время, мастерство данных, миграции.

- `field-catalog.json`: поля с типами, обязательностью, источниками и владельцами.

- `whole-object-coverage.json`: пять аспектов для каждого из девяти типов контракта.

- `composition-plan.schema.json`, `policy.schema.json`: исполняемые схемы JSON Schema 2020-12.

- `composition.py`: проверка точного состава и создание пакета проверенных файлов.

- `bootstrap_dimension.py`: создание только нового Измерения через доверенную локальную копию Vercy skill.

- `crosswalk.json`, `kernel-boundary-decision.json`: сопоставления с существующими моделями и решение о границе.

- `examples/`: вымышленные сценарии, политики, точные версии и копии опубликованных пакетов.

- `test-results.json`, `acceptance-results.json`: фактические результаты испытаний.



## Быстрый воспроизводимый пример



Распакуйте полный пакет. Нужны Python 3.11+ и `jsonschema >=4,<5`. Путь к Vercy skill задаётся явно: используйте доверенную локальную копию из официального Vercy. Composer сам не скачивает и не исполняет код из пакетов.



```text

python -m pip install "jsonschema>=4,<5"

python test_composition.py

python acceptance.py --skill /trusted/vercy/skills/vercy --report acceptance-local.json

```



`acceptance.py` создаёт временные тестовые Измерения и удаляет только свои временные данные после проверки. В нём явно запускается проверенный пример валидатора вложенных данных. Обычный Composer такой код автоматически не запускает.



Чтобы оставить отдельное учебное Измерение:



```text

python composition.py validate examples/startup/plan.json --assets examples/assets --policy examples/startup/policy.json --lock examples/startup/current.lock

python composition.py stage examples/startup/plan.json --assets examples/assets --policy examples/startup/policy.json --lock examples/startup/current.lock --target /existing-parent/startup-stage

python bootstrap_dimension.py --stage /existing-parent/startup-stage --policy examples/startup/policy.json --lock examples/startup/current.lock --skill /trusted/vercy/skills/vercy --target /existing-parent/startup-dimension --name "Synthetic startup" --namespace urn:dimension:synthetic:startup

```



Замените пути на свои. Родительский каталог должен существовать, конечные каталоги должны быть новыми. `--namespace` должен точно совпадать с `dimensionId` плана и независимой политики. Bootstrap создаёт структуру и реестры; данные организации вы добавляете отдельно. Проверка `acceptance.py` показывает такой пример.



## Использование для своей компании



Вымышленные политики из примеров не дают полномочий работать с вашей компанией. Владелец Измерения отдельно задаёт идентификатор, исполнителей, цель, разрешённые модели, источники и срок действия политики. План ссылается на SHA-256 этой политики и исходного lock-файла. Обновление этих документов требует пересчёта соответствующих контрольных сумм.



Для каждой выбранной модели укажите точную версию, SHA-256 и размер спецификации и AGENTS.md. Разделите обязательные зависимости `requires` и необязательные ссылки `references`. Замкнутый состав включает все обязательные зависимости и исключает лишние пакеты. Циклы, неоднозначные версии и конфликты пространств имён отклоняются.



Режим `semantic-only` позволяет хранить и использовать семантическую спецификацию. Он не объявляет схему фактов готовой. Для `native-binding` отдельно укажите runtime-схему, привязанную к точным байтам спецификации. Для вложенного снимка также нужны закрытая схема данных и отдельный предметный валидатор. Успешная проверка V3 не заменяет проверку содержимого вложенного объекта.



Учебные планы имеют ограниченный срок: до конца 2026 года. После истечения можно проверить исторический состав через `validate --at` с датой действия плана. Для нового создания нужна новая действующая политика и новый план; историческая дата не разрешает запись.



## Что подтверждают сценарии



| Сценарий | Проверено | Граница |

|---|---|---|

| Startup | Новый Dimension, Organization, объект и факт имени, V3 | Только имя; не вся схема организации |

| Group | Organization с данными и Organizational Unit как семантический пакет | Подразделение не получает выдуманную runtime-схему |

| AI team | Organization и опубликованный пример Performance Case, V3 и отдельный вложенный валидатор | Синтетический пример, не модель сотрудников OpenAI или реальная оценка людей |



Во всех сценариях повторное создание поверх существующего Измерения отклоняется с сохранением данных.



## Миграция и восстановление



Реализация создаёт только новые Измерения. Для существующего Измерения нужен отдельный план миграции с резервной копией, анализом потерь и преобразованием данных. Автоматическое обновление и понижение версий не поддерживаются.



Обычная ошибка убирает только временный каталог операции и её блокировку. При аварийном завершении процесса сначала проверьте владельца оставшейся блокировки, отсутствие активного процесса и квитанцию. Не удаляйте блокировки вслепую. Переименование каталога служит точкой активации на проверенной локальной файловой системе; распределённая транзакция и устойчивость к потере питания не заявляются.



Контракт не реализует корпоративную IAM, проверку цифровых подписей издателей, ELMM minimum-version selection, исполнение всех правил предметных моделей или изменение действующих Измерений. Эти ограничения не скрываются за отметкой `published`.



Спецификации принимаются только в формате JSON либо JSON с одной начальной строкой `#`, то есть в используемой Vercy JSON-совместимой форме YAML. Произвольный YAML отклоняется. Три пакета из примеров проверены по байтам с опубликованными версиями ver.cy. Поддерживаемый preset этого адаптера: `commercial-company`.


```