@atmem/architect 0.0.0-stage → 0.2.0-alpha.4.1

package/server/requirements.txt

@@ -0,0 +1,68 @@
+annotated-doc==0.0.5
+annotated-types==0.8.0
+anthropic==0.125.0
+anyio==4.15.1
+attrs==26.1.0
+aws-bedrock-token-generator==1.1.0
+boto3==1.43.123
+botocore==1.43.123
+certifi==2026.10.23
+cffi==2.1.1
+charset-normalizer==3.5.2
+click==8.5.0
+cryptography==50.0.2
+distro==1.9.0
+docstring_parser==0.18.0
+fastapi==0.162.0
+github-copilot-sdk==1.0.28
+google-auth==2.62.0
+google-genai==2.34.0
+h11==0.16.0
+httpcore==1.0.9
+httpcore2==2.16.0
+httpx==0.28.1
+httpx2==2.16.0
+idna==3.20
+jiter==0.18.0
+jmespath==1.1.0
+jsonschema==4.26.0
+jsonschema-specifications==2025.9.1
+mcp==2.3.0
+mcp-types==2.3.0
+openai==3.42.0
+opentelemetry-api==1.45.2
+opentelemetry-instrumentation==0.66b2
+opentelemetry-instrumentation-threading==0.66b2
+opentelemetry-sdk==1.45.2
+opentelemetry-semantic-conventions==0.66b2
+packaging==26.3
+pyasn1==0.6.5
+pyasn1_modules==0.4.2
+pycparser==3.12
+pydantic==2.14.2
+pydantic_core==2.50.2
+PyJWT==2.15.1
+python-dateutil==2.9.0.post0
+python-multipart==0.0.33
+PyYAML==6.0.3
+referencing==0.37.0
+requests==2.34.2
+rpds-py==2026.9.1
+s3transfer==0.19.3
+six==1.17.0
+sniffio==1.3.1
+sse-starlette==3.6.0
+starlette==1.10.0
+strands-agents==1.63.0
+tenacity==9.1.4
+truststore==0.10.5
+typing-inspection==0.4.4
+typing_extensions==4.16.0
+urllib3==2.8.0
+uvicorn==0.54.0
+watchdog==6.0.0
+websockets==17.4
+wrapt==2.5.2
+
+pypdf==7.0.0
+Pillow==13.0.0

package/server/runtime_dependency_locks.py

@@ -0,0 +1,27 @@
+"""Read-only reconciliation of hash-lock declarations and reviewed wheel dependencies."""
+import re
+from packaging.markers import default_environment
+from packaging.requirements import Requirement
+from packaging.utils import canonicalize_name
+from packaging.version import Version
+
+def dependency_gaps(lock):
+    records={canonicalize_name(row['name']):row for row in lock['sources']}
+    env={**default_environment(),'python_version':'3.13','python_full_version':'3.13.0','sys_platform':'linux','platform_system':'Linux','platform_machine':'x86_64','implementation_name':'cpython','platform_python_implementation':'CPython'}
+    extras={key:{''} for key in records}
+    gaps=set();changed=True
+    while changed:
+        changed=False
+        for name,row in records.items():
+            for text in row['requiresDist']:
+                requirement=Requirement(text)
+                if requirement.marker and not any(requirement.marker.evaluate({**env,'extra':extra}) for extra in extras[name]):continue
+                target=canonicalize_name(requirement.name)
+                if target not in records:gaps.add(name+' requires '+target);continue
+                if Version(records[target]['version']) not in requirement.specifier:gaps.add(name+' incompatible '+target)
+                new=requirement.extras-extras[target]
+                if new:extras[target].update(new);changed=True
+    pins={canonicalize_name(name):version for name,version in re.findall(r'^([A-Za-z0-9_.-]+)==([^\s\\]+)',lock['requirements'],re.M)}
+    if pins!={key:row['version'] for key,row in records.items()}:gaps.add('lock pins differ from reviewed wheel metadata')
+    return gaps
+

package/server/runtime_evidence.py

@@ -0,0 +1,93 @@
+"""Pinned operator-observed runtime facts, separate from application acceptance."""
+import hashlib,json,os,re
+from datetime import datetime
+from pathlib import Path
+from server.process_control_observation import PYTHON_PROCESS_CONTROLS
+
+
+def runtime_binding(spec):
+    return {'imageId':spec.image,'platform':spec.platform,'executable':spec.command[0],
+        'bootstrapPython':spec.bootstrap_python,'isolationProfile':spec.isolation_profile,
+        'environment':dict(spec.runtime_environment),**({'executableScratch':True}if spec.executable_scratch else {})}
+
+
+def digest(value):return hashlib.sha256(json.dumps(value,sort_keys=True,separators=(',',':')).encode()).hexdigest()
+
+
+class RuntimeEvidence:
+    def __init__(self,encoded,*,worker_identity=None,worker_policy=None,context_bound=False):
+        self._encoded=encoded
+        self._worker_identity,self._worker_policy=worker_identity,worker_policy
+        self.context_bound=context_bound
+
+    def public(self):return json.loads(self._encoded)
+
+    def matches_worker(self,worker):
+        return self._worker_identity==worker.identity_digest and self._worker_policy==worker.policy_digest
+
+    @classmethod
+    def load(cls,reference,spec):
+        if not isinstance(reference,dict) or set(reference)!={'path','sha256'} or not isinstance(reference['path'],str) or not Path(reference['path']).is_absolute() or not isinstance(reference.get('sha256'),str) or not re.fullmatch(r'[a-f0-9]{64}',reference['sha256']):
+            raise ValueError('Register an absolute pinned operator runtime receipt')
+        descriptor=os.open(reference['path'],os.O_RDONLY|os.O_NOFOLLOW|os.O_NONBLOCK)
+        try:
+            import stat
+            info=os.fstat(descriptor)
+            if not stat.S_ISREG(info.st_mode) or info.st_size>64000:raise ValueError('Runtime evidence must be a bounded regular receipt')
+            with os.fdopen(descriptor,'rb',closefd=False)as source:content=source.read(64001)
+        finally:os.close(descriptor)
+        if len(content)>64000 or hashlib.sha256(content).hexdigest()!=reference['sha256']:raise ValueError('Runtime receipt bytes differ from their operator pin')
+        receipt=json.loads(content)
+        binding=runtime_binding(spec)
+        if not isinstance(receipt,dict) or receipt.get('format')!='atmem.runtime-observation' or type(receipt.get('version')) is not int or receipt['version'] not in {1,2} or receipt.get('passed') is not True or receipt.get('runtime')!=binding or receipt.get('runtimeSha256')!=digest(binding):
+            raise ValueError('Runtime observation does not match the registered immutable runtime')
+        if datetime.fromisoformat(receipt.get('observedAt','')).tzinfo is None or any(not isinstance(receipt.get(key),str) or not re.fullmatch(r'[a-f0-9]{64}',receipt[key]) for key in ['observerSha256','workerPolicySha256','workerIdentitySha256']):raise ValueError('Runtime observation requires dated observer/worker provenance')
+        probe=receipt.get('probe')
+        if not isinstance(probe,dict) or probe.get('status')!='passed' or type(probe.get('exitCode')) is not int or probe['exitCode']!=0 or probe.get('outputTruncated') is not False or probe.get('artifactSha256')!=hashlib.sha256(b'PK\x05\x06'+b'\0'*18).hexdigest() or any(probe.get(key)!=expected for key,expected in [('imageId',spec.image),('platform',spec.platform),('isolationProfile',spec.isolation_profile),('runtimeEnvironment',dict(spec.runtime_environment))]) or not isinstance(probe.get('command'),list) or probe['command'][:1]!=[spec.command[0]]:
+            raise ValueError('Runtime evidence needs a successful empty-source probe of the same runtime')
+        observed=receipt.get('observed')
+        if probe.get('executableScratch',False)is not spec.executable_scratch:raise ValueError('Runtime observation does not match executable scratch capability')
+        if not isinstance(probe.get('output'),str) or json.loads(probe['output'])!=observed:raise ValueError('Observed facts differ from the complete probe output')
+        version=receipt['version']
+        extra={'processControls','executionContext'} if version==2 else set()
+        if not isinstance(observed,dict) or set(observed)-({'kind','executableVersion','packages','serviceOperations','browserVersion'}|extra) or observed.get('kind') not in {'python','node'}:
+            raise ValueError('Unrecognized observed runtime shape')
+        def text(value):return isinstance(value,str) and bool(value) and len(value)<=150 and not any(ord(c)<32 for c in value)
+        if not text(observed.get('executableVersion')):raise ValueError('An observed executable version is required')
+        packages=observed.get('packages',{})
+        if not isinstance(packages,dict) or len(packages)>32 or any(not text(key) or (value is not None and not text(value)) for key,value in packages.items()):raise ValueError('Runtime package observations must be bounded versions or explicit unknowns')
+        services=observed.get('serviceOperations',{})
+        if not isinstance(services,dict) or len(services)>16:raise ValueError('Bound service capability observations')
+        for name,operations in services.items():
+            if not text(name) or (operations is not None and (not isinstance(operations,list) or len(operations)>2000 or any(not text(operation) for operation in operations) or len(set(operations))!=len(operations))):raise ValueError('Unrecognized service capability observations')
+        if 'browserVersion' in observed and observed['browserVersion'] is not None and not text(observed['browserVersion']):raise ValueError('Invalid browser version observation')
+        if version==2:validate_process_observation(receipt,observed,probe,text)
+        result={'receiptSha256':reference['sha256'],'runtimeSha256':digest(binding),'observed':observed,
+            'observedAt':receipt['observedAt'],'evidenceLevel':'operator_pinned_local_runtime_observation','scope':'Observed immutable image runtime only; artifact-vendored dependencies can differ. Null package versions mean unobserved distribution metadata, not proof an import is impossible. Null service operations are unknown; an actual operation list describes only the installed SDK model. Not application, account, cloud or requirement acceptance.'}
+        if version==2:
+            result.update(executionContextSha256=receipt['executionContextSha256'],processControlProbeSha256=receipt['processControlProbeSha256'])
+            result['scope']=result['scope'].replace('Observed immutable image runtime only;', 'Observed immutable image metadata and the last recorded execution context;')
+            result['scope']+=' Process controls describe only the last observed execution context, not an image-only capability or current availability guarantee. Reobserve after worker, kernel, boot or policy changes. Null process controls are unobserved, not unsupported. Observation never grants permissions or changes safeguards.'
+        return cls(json.dumps(result,ensure_ascii=False,allow_nan=False),worker_identity=receipt['workerIdentitySha256'],worker_policy=receipt['workerPolicySha256'],context_bound=version==2)
+
+
+def validate_process_observation(receipt,observed,probe,text):
+    """Validate an opt-in context snapshot; do not turn it into authorization."""
+    expected=hashlib.sha256(PYTHON_PROCESS_CONTROLS.encode()).hexdigest()
+    if observed['kind']!='python' or receipt.get('processControlProbeSha256')!=expected or not any(isinstance(argument,str) and PYTHON_PROCESS_CONTROLS in argument for argument in probe['command']):
+        raise ValueError('Process-control evidence requires the reviewed Python probe')
+    controls=observed.get('processControls')
+    if not isinstance(controls,dict) or set(controls)!={'noNewPrivileges','seccompFilter'}:
+        raise ValueError('Unrecognized process-control observation')
+    def outcome(value):
+        if not isinstance(value,dict) or set(value)!={'supported','returnCode','errno'} or type(value['supported']) is not bool or type(value['returnCode']) is not int or type(value['errno']) is not int:
+            raise ValueError('Process controls need explicit typed syscall outcomes')
+        if (value['supported'] and (value['returnCode']!=0 or value['errno']!=0)) or (not value['supported'] and (value['returnCode']!=-1 or not 1<=value['errno']<=4095)):
+            raise ValueError('Inconsistent process-control outcome')
+    outcome(controls['noNewPrivileges'])
+    if controls['noNewPrivileges']['supported']:outcome(controls['seccompFilter'])
+    elif controls['seccompFilter'] is not None:
+        raise ValueError('A dependent control without its prerequisite must remain unknown')
+    context=observed.get('executionContext')
+    if not isinstance(context,dict) or set(context)!={'processMachine','kernelRelease','kernelBootSha256','uid'} or not text(context['processMachine']) or not text(context['kernelRelease']) or type(context['uid']) is not int or not 0<=context['uid']<2**32 or not isinstance(context['kernelBootSha256'],str) or not re.fullmatch(r'[a-f0-9]{64}',context['kernelBootSha256']) or receipt.get('executionContextSha256')!=digest(context):
+        raise ValueError('Process-control evidence requires a bound execution context')

package/server/settings.py

@@ -0,0 +1,14 @@
+"""Current product settings, with legacy installation compatibility."""
+import os
+from pathlib import Path
+
+def setting(name):
+    return os.getenv('ATMEM_ARCHITECT_' + name) or os.getenv('ATFORMA_' + name)
+
+def home():
+    configured = setting('HOME')
+    if configured:
+        return Path(configured)
+    legacy = Path.home() / '.atforma'
+    # Preserve scoped memory identities and project history in existing installations.
+    return legacy if legacy.exists() else Path.home() / '.atmem-ai-architect'

package/server/skills.py

@@ -0,0 +1,103 @@
+"""Small reviewed specialist registry; pinned upstream assets are references, never scripts."""
+import hashlib
+import json
+import re
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+GUIDANCE = [
+ ('composition','Architecture composition and engineering judgment','all',['discover','design','review','deploy'],'Choose and compose blocks through responsibility, contracts, state, identity, failure modes and trade-offs; verify the complete system.'),
+ ('architecture','AI architecture and discovery','all',['discover','design','review'], 'Clarify outcome, users, existing systems, data ownership and constraints. Evolve the diagram incrementally. Derive functional requirements and propose measurable quality targets as assumptions needing confirmation. Compare clouds against the actual requirements; do not assume an enterprise identity provider or a vendor. Keep proposed and accepted decisions distinct.'),
+ ('security','Security and reliability','all',['design','review','deploy'], 'Check data classification, residency, access boundaries, encryption choices, approval of automated actions, reliability and recovery. A drawn control is not enforcement evidence. Explain missing controls and tests. Propose requirements from the components and paths; mark default targets as suggestions, never existing company policy.'),
+ ('finops','FinOps and progressive estimation','all',['estimate','design'], 'Populate a bill of resources from the diagram. Separate monthly cloud charges from one-off build effort. Use pricing.lookup for supported current list pricing, and project.read for usage. Ask the largest missing usage/model/region question. Input and output tokens, storage, requests, duration, networking and observability can have separate charges. Never invent prices or effort. Options cost scores are qualitative judgements, not price quotes.'),
+ ('devops','Infrastructure and DevOps handoff','all',['deploy','review'], 'Prepare a reviewable plan, IaC sketch, CI/CD checks, secrets handling, observability, acceptance tests, rollback and ownership. Existing systems require integration planning. Every wire needs implementation. Access does not equal permission to deploy; the current broker has no write/deploy tools. Report implementation and validation gaps.'),
+ ('aws','AWS architecture guidance','aws',['design','review','estimate','deploy'], 'Apply AWS Well-Architected concerns to the drawn workload with evidence. Distinguish Bedrock on-demand model access, knowledge-base/vector storage, guardrails and IAM; they are separate concerns. S3 storage, requests and transfer are separate cost dimensions. A diagram is not a complete Well-Architected review. Native generation currently covers only S3 foundations.'),
+ ('azure','Azure architecture guidance','azure',['design','review','estimate','deploy'], 'Check Microsoft 365/Entra integration only when relevant to the user. Match model, retrieval, data and runtime services to requirements. Evaluate redundancy, regional availability, identity and recovery separately. The pinned Azure reliability reference specifically covers Functions and App Service; do not extend its validation claims to other services.'),
+ ('gcp','Google Cloud AI architecture guidance','gcp',['design','review','estimate','deploy'], 'Match model runtime, retrieval, storage, identity and network boundaries to the project. Distinguish architecture guidance from validated commands. Verify regional model availability, quotas and residency before estimating/deploying. The pinned platform architecture reference has additional companion manuals; those commands are not enabled in AtMem AI Architect.'),
+ ('ibm','IBM Cloud architecture guidance','ibm',['design','review','estimate','deploy'], 'Match watsonx, data services, identity, application runtime and observability to the same requirements used for other clouds. Check region, data residency, model access and IBM plan before pricing. Use a sourced IBM quote; do not substitute an AWS/Azure rate or claim an unsupported deployment is ready.'),
+ ('terraform','Terraform delivery guidance','all',['deploy','design'], 'Keep provider versions and configurable inputs explicit, use stable resource addresses, declare references and dependencies, and review state/import and destructive changes. Run validation before claiming a valid sketch. Current generated S3 foundations are partial; application resources and integrations remain engineering work.'),
+ ('pulumi','Pulumi delivery guidance','all',['deploy','design'], 'Declare resources predictably and pass Outputs through dependencies; do not create resources inside apply callbacks. Plan aliases and protection before refactors. Keep secrets in supported secret/config stores. Explain import versus refresh limits. AtMem AI Architect Pulumi output remains a metadata scaffold, not deployed provider resources.'),
+]
+
+
+def generation_guidance():
+    catalogue = json.loads((ROOT / 'agent-skills/generation-capabilities.json').read_text())
+    return ('Compiler capability catalogue v' + str(catalogue['version']) + ': ' +
+            json.dumps(catalogue['contracts'], separators=(',', ':')) + '. ' + catalogue['evidenceBoundary'] +
+            ' Application source assembly contracts: ' + json.dumps(catalogue.get('applicationAssemblies', []), separators=(',', ':')) + '. ' +
+            ' Preserve required unsupported scope and identify missing compiler work; never substitute a different provider or present references as generated infrastructure.')
+
+
+def registry():
+    refs = json.loads((ROOT / 'agent-skills/upstream/manifest.json').read_text())
+    by_id = {r['id']: r for r in refs}
+    result = []
+    for ident, name, provider, stages, content in GUIDANCE:
+        path = ROOT / 'agent-skills/specialists' / ident / 'SKILL.md'
+        expected = json.loads((ROOT / 'agent-skills/specialists/manifest.json').read_text())[ident]
+        data = path.read_bytes()
+        version_match = re.search(r'^version: ([0-9]+\.[0-9]+\.[0-9]+)$', data.decode(), re.MULTILINE)
+        valid = hashlib.sha256(data).hexdigest() == expected and version_match is not None
+        reference = by_id.get(ident)
+        if reference:
+            reference = {**reference, 'integrity': hashlib.sha256((ROOT / reference['file']).read_bytes()).hexdigest() == reference['sha256']}
+            valid = valid and reference['integrity']
+        result.append({'id': ident, 'name': name, 'provider': provider, 'stages': stages, 'version': version_match.group(1) if version_match else 'unknown', 'digest': expected,
+            'instructions': data.decode(), 'summary': content, 'source': reference['url'] if reference else 'AtMem AI Architect reviewed specialist guidance',
+            'reference': reference, 'integrity': valid, 'coverage': 'guidance; no cloud execution', 'tools': ['memory.lookup','project.read','skills.lookup'] + (['pricing.lookup'] if ident in {'aws','finops'} else [])})
+    return result
+
+
+def catalogue(memory, project):
+    skills = registry()
+    with memory.db() as db:
+        settings = dict(db.execute('SELECT id,enabled FROM skill_settings'))
+    for skill in skills:
+        skill['enabled'] = bool(settings.get(skill['id'], 1)) and skill['integrity']
+    return skills
+
+
+def select(memory, project, request, recalled):
+    skills = catalogue(memory, project)
+    text = request.message.lower()
+    providers = {request.project.provider, *(n.data.provider for n in request.project.nodes)}
+    if re.search(r'compar|versus|alternative|\bvs\b', text):
+        providers.update({'aws','azure','gcp','ibm'})
+    for provider, pattern in [('aws',r'\baws\b'),('azure',r'\bazure\b'),('gcp',r'google cloud|\bgcp\b'),('ibm',r'\bibm\b|watsonx')]:
+        if re.search(pattern,text): providers.add(provider)
+    selected = []
+    for skill in skills:
+        choose = skill['id'] in {'architecture','composition'} or ((request.stage in skill['stages'] or request.stage == 'discover') and skill['provider'] in providers)
+        choose |= skill['id'] == 'security' and (bool(request.project.nodes) or bool(re.search(r'authenticat|authoriz|sign.in|tenant|permission|access.boundary|security|private.memory|webhook', text)))
+        choose |= skill['id'] == 'finops' and (request.stage == 'estimate' or bool(re.search(r'cost|pric|estimat|budget', text)))
+        choose |= skill['id'] == 'devops' and (request.stage == 'deploy' or bool(re.search(r'deploy|devops|rollback|pipeline', text)))
+        if skill['id'] in {'terraform','pulumi'}:
+            choose = skill['id'] in text or request.stage == 'deploy' and skill['id'] in ' '.join(r['text'].lower() for r in recalled)
+        if choose and skill['enabled']:
+            selected.append(skill)
+    return selected[:8]
+
+
+def publication_text(skill):
+    """Publish bounded guidance or an explicit index; never silently clip instructions."""
+    text = f'Skill {skill["id"]} v{skill["version"]}: {skill["instructions"]}\nSource: {skill["source"]}; artifact SHA256: {skill["digest"]}'
+    if len(text) > 1900:
+        text = f'Skill {skill["id"]} v{skill["version"]}: {skill["summary"]}\nIndex record only; full reviewed instructions are loaded by the skill registry.\nSource: {skill["source"]}; artifact SHA256: {skill["digest"]}'
+    if len(text) > 1900:
+        raise ValueError(f'Skill {skill["id"]} publication exceeds the AtMem boundary')
+    return text
+
+
+def publish(memory, project):
+    if not memory.enabled(project): return
+    for skill in catalogue(memory, project):
+        if not skill['integrity']: continue
+        text = publication_text(skill)
+        memory.enqueue(project,'knowledge','skill.'+skill['id'],text,event_id='skill-'+skill['digest'],source=skill['source'])
+    from .engineering_knowledge import publish as publish_practices
+    publish_practices(memory,project)
+    memory.flush()
+
+
+def public(skills):
+    return [{k:v for k,v in skill.items() if k != 'instructions'} for skill in skills]

package/server/storage_emulation_worker.py

@@ -0,0 +1,160 @@
+"""Bounded storage data-plane checks. Never calls a cloud control plane.
+
+SDK clients target only a worker-owned loopback service; IBM uses Moto's S3
+protocol model, explicitly not an IBM Cloud emulator. Generated adapters are
+server-owned, never submitted as executable code by the caller.
+"""
+import base64
+from contextlib import contextmanager
+import importlib.util
+import importlib.metadata
+import hashlib
+import json
+import os
+from pathlib import Path
+import socket
+import subprocess
+import sys
+import time
+from unittest.mock import patch
+
+ROOT=Path(__file__).resolve().parents[1]
+
+@contextmanager
+def loopback_only(port):
+    connect=socket.socket.connect
+    connect_ex=socket.socket.connect_ex
+    resolve=socket.getaddrinfo
+    def allowed(address):
+        if not isinstance(address,tuple) or address[0]!='127.0.0.1' or address[1]!=port:
+            raise RuntimeError('Network request outside the isolated emulator is forbidden')
+    def guarded(sock,address):allowed(address);return connect(sock,address)
+    def guarded_ex(sock,address):allowed(address);return connect_ex(sock,address)
+    def dns(host,service,*args,**kwargs):
+        if host!='127.0.0.1' or int(service)!=port:raise RuntimeError('External DNS is forbidden')
+        return resolve(host,service,*args,**kwargs)
+    with patch.object(socket.socket,'connect',guarded),patch.object(socket.socket,'connect_ex',guarded_ex),patch.object(socket,'getaddrinfo',dns):yield
+
+@contextmanager
+def service(provider,folder):
+    with socket.socket() as sock:sock.bind(('127.0.0.1',0));port=sock.getsockname()[1]
+    endpoint=f'http://127.0.0.1:{port}'
+    env=dict(os.environ)
+    if provider=='azure':
+        key=base64.b64encode(b'synthetic-local-only-not-a-cloud-key'*2).decode()
+        env['AZURITE_ACCOUNTS']='atmememulator:'+key
+        command=[str(ROOT/'.local/cloud-emulators/node_modules/.bin/azurite-blob'),'--blobHost','127.0.0.1','--blobPort',str(port),'--inMemoryPersistence','--extentMemoryLimit','32','--disableTelemetry','--silent']
+    else:
+        key=None
+        command=[str(ROOT/'.local/cloud-emulators/fake-gcs/fake-gcs-server'),'-scheme','http','-host','127.0.0.1','-port',str(port),'-backend','memory','-public-host',f'127.0.0.1:{port}','-external-url',endpoint,'-log-level','error']
+    with (folder/'emulator.log').open('w') as log:
+        proc=subprocess.Popen(command,cwd=folder,env=env,stdout=log,stderr=log)
+        try:
+            for _ in range(100):
+                if proc.poll() is not None:raise RuntimeError('Local storage emulator exited during startup')
+                try:
+                    with socket.create_connection(('127.0.0.1',port),timeout=.1):break
+                except OSError:time.sleep(.1)
+            else:raise RuntimeError('Local storage emulator startup timed out')
+            with loopback_only(port):yield endpoint,key
+        finally:
+            proc.terminate()
+            try:proc.wait(timeout=3)
+            except subprocess.TimeoutExpired:proc.kill();proc.wait(timeout=3)
+
+
+def run(folder):
+    folder=Path(folder);plan=json.loads((folder/'resource-schedule.json').read_text());provider=plan.get('provider')
+    checks=[];limitations=['Local API checks do not validate Terraform apply, real IAM, account policy, region availability, networking, billing or production operations.','Synthetic client credentials are not deployment identities.','Only the explicit private object storage contract is exercised; other provider services are not emulated.']
+    def check(name,fn):
+        try:fn();checks.append({'name':name,'passed':True})
+        except Exception as error:checks.append({'name':name,'passed':False,'errorType':type(error).__name__,'message':str(error)[:500]})
+    def equal(actual,expected):
+        if actual!=expected:raise AssertionError(f'Expected {expected!r}, received {actual!r}')
+    spec=importlib.util.spec_from_file_location('generated_storage_client',folder/'storage_client.py');client=importlib.util.module_from_spec(spec);spec.loader.exec_module(client)
+    stores=plan.get('storageContracts',[])
+    if provider not in ('azure','gcp','ibm') or not 1<=len(stores)<=10:raise ValueError('Unsupported storage scope')
+    backend={'azure':'azurite','gcp':'fake-gcs-server','ibm':'moto-s3-compatibility'}[provider]
+    versions={'azure':'3.37.0','gcp':'1.56.1','ibm':'5.2.5'}
+    if provider=='azure':
+        installed=json.loads((ROOT/'.local/cloud-emulators/node_modules/azurite/package.json').read_text())['version']
+        if installed!=versions[provider]:raise RuntimeError('Azurite version differs from the qualified backend')
+    if provider=='gcp':
+        location=ROOT/'.local/cloud-emulators/fake-gcs';receipt=json.loads((location/'receipt.json').read_text())
+        if receipt.get('version')!=versions[provider] or receipt.get('binarySha256')!=hashlib.sha256((location/'fake-gcs-server').read_bytes()).hexdigest():raise RuntimeError('GCS emulator installation integrity mismatch; rerun setup')
+    if provider=='ibm':versions[provider]=importlib.metadata.version('moto')
+    sdk_name={'azure':'azure-storage-blob','gcp':'google-cloud-storage','ibm':'boto3'}[provider]
+
+    data='Synthetic document — café\n'.encode()
+    if provider=='azure':
+        from azure.storage.blob import BlobServiceClient
+        from azure.core.exceptions import ResourceNotFoundError,ResourceExistsError
+        with service(provider,folder) as (endpoint,key):
+            # Pin an API version implemented by the installed emulator, never skip checks.
+            sdk=BlobServiceClient(endpoint+'/atmememulator',credential={'account_name':'atmememulator','account_key':key},api_version='2025-11-05',retry_total=0,connection_timeout=3,read_timeout=3)
+            for i,store in enumerate(stores):
+                container=sdk.create_container(f'documents-{i}')
+                def roundtrip():client.azure_put(container,'report.txt',data);equal(client.azure_get(container,'report.txt'),data)
+                check(f'{store["id"]}: generated upload/read preserves UTF-8 bytes',roundtrip)
+                def overwrite():client.azure_put(container,'report.txt',b'updated');equal(client.azure_get(container,'report.txt'),b'updated');equal([b.name for b in container.list_blobs()],['report.txt'])
+                check(f'{store["id"]}: overwrite and listing',overwrite)
+                def deletion():
+                    client.azure_delete(container,'report.txt')
+                    try:client.azure_get(container,'report.txt')
+                    except ResourceNotFoundError:return
+                    raise AssertionError('Deleted object remained readable')
+                check(f'{store["id"]}: deletion and missing-object error',deletion)
+                container.delete_container()
+            sdk.close()
+        limitations.append('Azure Entra authorization, custom role enforcement, storage-account versioning and soft-delete retention remain unverified; Azurite CRUD does not establish these behaviors.')
+    elif provider=='gcp':
+        from google.cloud import storage
+        from google.auth.credentials import AnonymousCredentials
+        from google.api_core.exceptions import NotFound,PreconditionFailed
+        with service(provider,folder) as (endpoint,_):
+            sdk=storage.Client(project='synthetic-qualification',credentials=AnonymousCredentials(),client_options={'api_endpoint':endpoint})
+            for i,store in enumerate(stores):
+                bucket=storage.Bucket(sdk,f'atmem-documents-{i}');bucket.versioning_enabled=True;bucket=sdk.create_bucket(bucket,timeout=5,retry=None)
+                state={}
+                def roundtrip():state['generation']=client.gcp_put(bucket,'report.txt',data,0);equal(client.gcp_get(bucket,'report.txt'),data)
+                check(f'{store["id"]}: generated upload/read preserves UTF-8 bytes',roundtrip)
+                def conditional():
+                    try:client.gcp_put(bucket,'report.txt',b'bad overwrite',0)
+                    except PreconditionFailed:equal(client.gcp_get(bucket,'report.txt'),data);return
+                    raise AssertionError('Stale generation precondition accepted')
+                check(f'{store["id"]}: stale write rejected without changing data',conditional)
+                def recovery():client.gcp_put(bucket,'report.txt',b'updated',state['generation']);equal(client.gcp_get(bucket,'report.txt',state['generation']),data);equal(client.gcp_get(bucket,'report.txt'),b'updated')
+                check(f'{store["id"]}: overwritten generation remains recoverable',recovery)
+                def deletion():
+                    client.gcp_delete(bucket,'report.txt')
+                    try:client.gcp_get(bucket,'report.txt')
+                    except NotFound:return
+                    raise AssertionError('Deleted object remained current')
+                check(f'{store["id"]}: deletion and missing-object error',deletion)
+                for blob in bucket.list_blobs(versions=True):blob.delete(timeout=5,retry=None)
+                bucket.delete(timeout=5,retry=None)
+            sdk.close()
+        limitations.append('GCP IAM, public-access prevention and signed URL authentication are not enforced by this test backend.')
+    else:
+        from moto import mock_aws
+        import boto3
+        # Moto intercepts S3 requests; deny all real sockets, including loopback.
+        with mock_aws(),loopback_only(0):
+            sdk=boto3.client('s3',region_name='us-east-1',aws_access_key_id='testing',aws_secret_access_key='testing')
+            for i,store in enumerate(stores):
+                bucket=f'atmem-documents-{i}';sdk.create_bucket(Bucket=bucket);sdk.put_bucket_versioning(Bucket=bucket,VersioningConfiguration={'Status':'Enabled'});state={}
+                def roundtrip():state['version']=client.ibm_put(sdk,bucket,'report.txt',data)['VersionId'];equal(client.ibm_get(sdk,bucket,'report.txt'),data)
+                check(f'{store["id"]}: generated S3-compatible upload/read preserves bytes',roundtrip)
+                def recovery():state['new']=client.ibm_put(sdk,bucket,'report.txt',b'updated')['VersionId'];equal(client.ibm_get(sdk,bucket,'report.txt',state['version']),data);equal(client.ibm_get(sdk,bucket,'report.txt'),b'updated')
+                check(f'{store["id"]}: prior object version recovery',recovery)
+                def deletion():
+                    client.ibm_delete(sdk,bucket,'report.txt',state['new']);client.ibm_delete(sdk,bucket,'report.txt',state['version']);equal(sdk.list_object_versions(Bucket=bucket).get('Versions',[]),[])
+                check(f'{store["id"]}: exact-version cleanup',deletion);sdk.delete_bucket(Bucket=bucket)
+            sdk.close()
+        limitations.append('This is S3 protocol compatibility coverage, not IBM COS service emulation: IBM IAM, OAuth/HMAC behavior, endpoints and COS-specific errors require IBM validation.')
+    return {'status':'passed' if checks and all(c['passed'] for c in checks) else 'failed','backend':backend,'backendVersion':versions[provider],'sdk':{'name':sdk_name,'version':importlib.metadata.version(sdk_name)},'checks':checks,'capabilities':[{'service':provider+' object storage','mode':'generated-client data-plane checks'}],'limitations':limitations,'message':'Generated client functions exercised against local storage APIs. Review the unverified boundaries before planning deployment.'}
+
+if __name__=='__main__':
+    try:result=run(sys.argv[1])
+    except Exception as error:result={'status':'failed','checks':[],'message':f'{type(error).__name__}: {str(error)[:500]}'}
+    print(json.dumps(result));sys.exit(0 if result['status']=='passed' else 1)

package/server/structured_emulation_worker.py

@@ -0,0 +1,48 @@
+"""Execute server-generated Azure source acceptance checks without Azure/network.
+
+These are local source/cryptographic/ASGI checks with scripted key/model/policy
+transport. Neither cloud authentication nor real inference is established.
+"""
+import hashlib
+import importlib.util
+import io
+import json
+from pathlib import Path
+import re
+import sys
+import unittest
+
+sys.path.insert(0,str(Path(__file__).resolve().parent))
+from emulation_worker import deny_network
+
+
+def run(folder):
+    root=Path(folder).resolve()
+    plan=json.loads((root/'resource-schedule.json').read_text())
+    entries=[(entry,'azure') for entry in plan.get('azureStructuredPlan',{}).get('entries',[])]+[(entry,'gcp') for entry in plan.get('gcpStructuredPlan',{}).get('entries',[])]+[(entry,'ibm') for entry in plan.get('ibmStructuredPlan',{}).get('entries',[])]
+    checks=[]
+    with deny_network():
+        for entry,provider in entries:
+            address=entry['row']['address']
+            if not re.fullmatch(r'block_[0-9a-f]+',address):raise ValueError('Invalid compiler component address')
+            app=root/'applications'/address
+            script=app/(provider+'_acceptance.py')
+            old=list(sys.path)
+            try:
+                sys.path.insert(0,str(app))
+                for name in ['azure_structured','gcp_structured','ibm_structured','policy_review','structured_output','structured_http','http_acceptance','export_contract_acceptance']:sys.modules.pop(name,None)
+                spec=importlib.util.spec_from_file_location('acceptance_'+address,script)
+                module=importlib.util.module_from_spec(spec);spec.loader.exec_module(module)
+                log=io.StringIO()
+                result=unittest.TextTestRunner(stream=log,verbosity=1).run(unittest.defaultTestLoader.loadTestsFromModule(module))
+                checks.append({'name':'Generated '+provider+' application JWT, HTTP, output and account-policy boundaries','passed':result.wasSuccessful() and result.testsRun>0,'testsRun':result.testsRun,'componentId':entry['row']['id'],'sourceSha256':hashlib.sha256((app/(provider+'_structured.py')).read_bytes()).hexdigest(),'evidence':'host-runtime-cryptographic-jwt-scripted-'+provider+'-transport','output':log.getvalue()[-6000:]})
+            finally:sys.path[:]=old
+    providers=sorted({provider for _,provider in entries})
+    return {'version':1,'kind':'local-structured-application-tests','backend':'host-asgi-scripted-'+('-'.join(providers)),'status':'passed' if checks and all(c['passed'] for c in checks) else 'failed','checks':checks,'modelMode':'scripted-fixture','cloudOperations':False,'terraformApply':'not_run','limitations':['Generated Python source executes on this host, not a provider container image.','Ephemeral RSA/ES256 JWT signatures and local ASGI requests are real; provider key retrieval, policy and model transports are scripted, with network denied.','Cloud sign-in, MFA, group assignment and token revocation, workload-identity exchange, model quality, regional capacity, container startup/scan, account plan and deployment remain unverified.','Token authorization is bounded by expiry/skew; these modules do not implement independent continuous group/user revocation.']}
+
+
+if __name__=='__main__':
+    sys.dont_write_bytecode=True
+    try:report=run(sys.argv[1])
+    except Exception as error:report={'version':1,'status':'failed','checks':[],'message':'Generated source checks failed: '+type(error).__name__,'cloudOperations':False}
+    print(json.dumps(report));raise SystemExit(0 if report['status']=='passed' else 1)