@atmem/architect 0.2.0-alpha.4.1 → 0.2.1

package/server/memory_worker.py

@@ -2,13 +2,70 @@
 import json
 import sys
 import sqlite3
+import base64
+import re
 from importlib.metadata import version
+from pathlib import Path
+EXPECTED_ATMEM_VERSION = re.search(r"^atmem==(\d+\.\d+\.\d+)$", (Path(__file__).parent / "memory-requirements.txt").read_text(), re.M).group(1)
 from atmem import Memory
 
 
+def public_record(record, owner=None, memory=None):
+    episode=memory.store.get_episode(record['subject_id'],record['episode_id'])if memory and record.get('episode_id')else None
+    raw=(episode or {}).get('raw') or record.get('raw') or {}
+    return {**{key:record.get(key)for key in ('id','content','status','fact_key','created_at','updated_at','supersedes_id','source_type')},
+            'governance':{'userId':raw.get('user_id'), 'actor':raw.get('actor'), 'actorType':raw.get('actor_type'),
+                          'source':raw.get('source_url') or raw.get('interpreter'), 'ownerUserId':owner}}
+
+
+def page_records(memory,subject,op):
+    # Pinned SDK adapter: use its policy-aware connection, never reopen the database.
+    from atmem.store.sqlite import _record_from_row
+    db=memory.store._conn
+    limit=max(1,min(int(op.get('limit',50)),100));query=str(op.get('query','')).strip()[:200]
+    status=op.get('status','active')
+    statuses=('active','superseded','quarantined') if status=='all' else (status,)
+    if any(value not in {'active','superseded','quarantined'}for value in statuses):raise ValueError('Invalid memory status')
+    before=None
+    if op.get('cursor'):
+        before=json.loads(base64.urlsafe_b64decode(op['cursor']).decode())
+        if not isinstance(before,list)or len(before)!=2 or any(not isinstance(v,str)or len(v)>100 for v in before):raise ValueError('Invalid page cursor')
+    candidates=[];total=0
+    for selected in statuses:
+        clauses=['subject_id=?','status=?'];args=[subject,selected]
+        if query:
+            if query.startswith('rec_'):
+                clauses.append('id=?');args.append(query)
+            else:
+                terms=re.findall(r'[^\W_]+',query,flags=re.UNICODE)[:12]
+                if not terms:raise ValueError('Enter a search word or record ID')
+                if not memory.store._fts_enabled:raise ValueError('Indexed search is unavailable for this store')
+                expression=' AND '.join('"'+word.replace('"','')+'"'for word in terms)
+                clauses.append('id IN (SELECT record_id FROM records_fts WHERE records_fts MATCH ? AND subject_id=?)')
+                args.extend([expression,subject])
+        where=' AND '.join(clauses)
+        total+=db.execute('SELECT COUNT(*) FROM records WHERE '+where,args).fetchone()[0]
+        if before:where+=' AND (created_at,id)<(?,?)';args.extend(before)
+        rows=db.execute('SELECT * FROM records WHERE '+where+' ORDER BY created_at DESC,id DESC LIMIT ?',(*args,limit+1)).fetchall()
+        candidates.extend(_record_from_row(row)for row in rows)
+    candidates.sort(key=lambda row:(row['created_at'],row['id']),reverse=True)
+    more=len(candidates)>limit;rows=candidates[:limit]
+    cursor=base64.urlsafe_b64encode(json.dumps([rows[-1]['created_at'],rows[-1]['id']]).encode()).decode()if more and rows else None
+    return {'records':[public_record(row,op.get('owner'),memory)for row in rows],'total':total,'hasMore':more,'nextCursor':cursor,'limit':limit}
+
+
+def keyed_records(memory,subject,record_id,limit=10001):
+    record=memory.store.get_record(subject,record_id)
+    if not record or record['status']=='tombstoned':raise ValueError('Memory is unavailable in this scope')
+    if not record.get('fact_key'):return record,[record]
+    from atmem.store.sqlite import _record_from_row
+    rows=memory.store._conn.execute("SELECT * FROM records WHERE subject_id=? AND fact_key IS ? AND status IN ('active','superseded','quarantined') ORDER BY created_at DESC,id DESC LIMIT ?",(subject,record.get('fact_key'),limit)).fetchall()
+    return record,[_record_from_row(row)for row in rows]
+
+
 def run(payload):
-    if version('atmem') != '2.3.10':
-        raise RuntimeError('AtMem AI Architect requires the tested AtMem 2.3.10 runtime')
+    if version('atmem') != EXPECTED_ATMEM_VERSION:
+        raise RuntimeError(f'AtMem AI Architect requires the tested AtMem {EXPECTED_ATMEM_VERSION} runtime')
     memory = Memory(payload['database'], auto_vectors=False)
     receipts = sqlite3.connect(payload['database'] + '.receipts.sqlite')
     receipts.execute('CREATE TABLE IF NOT EXISTS receipts (id TEXT PRIMARY KEY, result TEXT)')
@@ -23,32 +80,40 @@ def run(payload):
                     results.append(json.loads(previous[0]))
                     continue
                 value = memory.remember(subject, message=op['text'], source_type='user_message',
-                    interpreted_fact=op['text'], interpreted_fact_key=op['key'], actor='atforma',
-                    raw={'interpreter': 'atforma-project-event-v1', 'event_id': op['eventId'], 'source_url': op.get('source', '')})
+                    interpreted_fact=op['text'], interpreted_fact_key=op['key'], actor=op.get('actor','atforma'),
+                    raw={'interpreter': 'atforma-project-event-v1', 'event_id': op['eventId'], 'source_url': op.get('source', ''), 'user_id':op.get('owner'), 'actor':op.get('actor'), 'actor_type':op.get('actorType')})
                 receipt = {'refused': value.get('refused', []), 'ids': [r['id'] for r in value.get('records', [])] + value.get('duplicate_ids', [])}
                 receipts.execute('INSERT INTO receipts VALUES (?,?)', (op['eventId'], json.dumps(receipt)))
                 receipts.commit()
                 results.append(receipt)
             elif action == 'recall':
                 results.append(memory.recall(subject, op['query'], limit=op.get('limit', 6)))
+            elif action == 'page':
+                results.append(page_records(memory,subject,op))
+            elif action == 'record':
+                record=memory.store.get_record(subject,op['recordId'])
+                if not record or record['status']=='tombstoned':raise ValueError('Record unavailable in this scope')
+                audit=memory.store._conn.execute('SELECT actor,event_type,created_at FROM audit_log WHERE subject_id=? AND record_id=? ORDER BY created_at DESC,sequence DESC LIMIT 50',(subject,op['recordId'])).fetchall()
+                results.append({'record':public_record(record,op.get('owner'),memory),'audit':[dict(row)for row in audit]})
+            elif action == 'forget-preview':
+                record,rows=keyed_records(memory,subject,op['recordId'],101)
+                total=memory.store._conn.execute("SELECT COUNT(*) FROM records WHERE subject_id=? AND fact_key IS ? AND status!='tombstoned'",(subject,record.get('fact_key'))).fetchone()[0]if record.get('fact_key')else 1
+                results.append({'records':[public_record(row,op.get('owner'),memory)for row in rows[:100]],'total':total})
             elif action == 'list':
                 results.append(memory.list(subject, include_inactive=True))
             elif action == 'forget':
                 # Forget the entire keyed preference history so old values cannot resurface.
-                records = memory.list(subject, include_inactive=True)
-                record = next((r for r in records if r['id'] == op['recordId'] and r['status'] != 'tombstoned'), None)
-                if record is None:
-                    raise ValueError('Memory record is not available in this scope')
+                record,records=keyed_records(memory,subject,op['recordId'])
+                if len(records)>10000:raise ValueError('History exceeds the synchronous removal limit; no records were removed')
                 deletion_receipts = []
                 for r in records:
-                    if r.get('fact_key') == record.get('fact_key') and r['status'] != 'tombstoned':
-                        deletion_receipts.append(memory.forget_record(subject, r['id'])['receipt'])
+                    deletion_receipts.append(memory.forget_record(subject,r['id'],actor=op.get('actor','user'))['receipt'])
                 results.append({'deleted': True, 'receipts': deletion_receipts, 'key': record.get('fact_key')})
             elif action == 'audit':
                 report = memory.audit(subject)
                 results.append({'valid': report['audit_chain_valid'], 'events': report['audit_log'][-40:]})
             elif action == 'log':
-                results.append(memory.log_action(subject, op['eventType'], op['payload'], actor='atforma'))
+                results.append(memory.log_action(subject, op['eventType'], op['payload'], actor='atmem-architect:'+op.get('owner','unknown')))
             else:
                 raise ValueError('Unknown memory operation')
         return {'version': version('atmem'), 'results': results}

package/server/orca_handoff.py

@@ -0,0 +1,90 @@
+"""Explicit local editor handoff. Never executes project files or overwrites a workspace."""
+import base64
+import binascii
+import io
+import os
+from pathlib import Path, PurePosixPath
+import re
+import shutil
+import stat
+import subprocess
+import sys
+import tempfile
+import zipfile
+
+MAX_ZIP = 32_000_000
+MAX_EXPANDED = 150_000_000
+
+
+def orca_command():
+    names = ['orca-ide', 'orca'] if sys.platform.startswith('linux') else ['orca']
+    for name in names:
+        found = shutil.which(name)
+        if found:
+            return found
+    candidate = Path.home()/'.local/bin/orca'
+    if candidate.is_file() and os.access(candidate, os.X_OK):
+        return str(candidate)
+    raise ValueError('Install Orca and enable its CLI in Settings → General → Orca CLI.')
+
+
+def unpack_package(encoded, root, project):
+    try:
+        data = base64.b64decode(encoded, validate=True)
+    except (ValueError, binascii.Error):
+        raise ValueError('The project ZIP is invalid.') from None
+    if not data or len(data) > MAX_ZIP:
+        raise ValueError('Orca handoff supports ZIPs up to 32 MB. Download ZIP instead.')
+    try:
+        archive = zipfile.ZipFile(io.BytesIO(data))
+        entries = archive.infolist()
+        if len(entries) > 20000 or sum(e.file_size for e in entries) > MAX_EXPANDED:
+            raise ValueError('The expanded project exceeds the handoff limit.')
+        seen = set()
+        for entry in entries:
+            name = entry.filename
+            parts = PurePosixPath(name).parts
+            mode = entry.external_attr >> 16
+            if (not parts or name.startswith('/') or '\\' in name or '\x00' in name
+                or any(part in {'.', '..'} or ':' in part or part.endswith((' ', '.')) for part in parts)
+                or any(re.match(r'^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)', part, re.I) for part in parts)
+                or mode and stat.S_IFMT(mode) not in {0, stat.S_IFREG, stat.S_IFDIR}):
+                raise ValueError('The ZIP contains an unsupported path or file type.')
+            canonical = name.rstrip('/').casefold()
+            if canonical in seen:
+                raise ValueError('The ZIP contains conflicting paths.')
+            seen.add(canonical)
+        if not entries:
+            raise ValueError('The project ZIP is empty.')
+        root = Path(root)
+        root.mkdir(parents=True, exist_ok=True, mode=0o700)
+        destination = Path(tempfile.mkdtemp(prefix=project+'-', dir=root))
+        try:
+            for entry in entries:
+                path = destination.joinpath(*PurePosixPath(entry.filename).parts)
+                if entry.is_dir():
+                    path.mkdir(parents=True, exist_ok=True)
+                    continue
+                path.parent.mkdir(parents=True, exist_ok=True)
+                with archive.open(entry) as source, path.open('xb') as target:
+                    shutil.copyfileobj(source, target)
+                os.chmod(path, 0o700 if (entry.external_attr >> 16) & 0o111 else 0o600)
+        except Exception:
+            shutil.rmtree(destination)
+            raise
+        return destination
+    except (zipfile.BadZipFile, RuntimeError, OSError):
+        raise ValueError('The project ZIP could not be prepared for Orca.') from None
+
+
+def open_package(encoded, root, project):
+    command = orca_command()
+    destination = unpack_package(encoded, root, project)
+    try:
+        subprocess.run([command, 'open', '--json'], check=True, capture_output=True, timeout=30)
+        subprocess.run([command, 'repo', 'add', '--path', str(destination), '--kind', 'folder', '--json'],
+                       check=True, capture_output=True, timeout=30)
+    except (OSError, subprocess.SubprocessError):
+        # Keep the prepared folder for retry/manual opening. Do not expose command output.
+        return {'opened': False, 'path': str(destination), 'message': 'Orca did not open. Open this folder in Orca.'}
+    return {'opened': True, 'path': str(destination)}

package/server/pricing.py

@@ -61,6 +61,9 @@ def storage_quote(provider,region):
     if provider=='aws':return {**aws_s3(region),'provider':'aws','available':True}
     if provider=='azure':return dict(_azure_storage(region,int(time.time()//3600)))
     if provider=='gcp':
+        if region=='us-central1':
+            try:return dict(_google_storage_public(region,int(time.time()//3600)))
+            except (ValueError,OSError):pass
         import os
         key=os.getenv('GOOGLE_CLOUD_BILLING_API_KEY')
         if key and re.fullmatch(r'[a-z]+-[a-z]+\d',region):
@@ -80,5 +83,162 @@ def storage_quote(provider,region):
                     price=rates[0]['unitPrice'];value=float(price.get('units',0))+float(price.get('nanos',0))/1e9
                     candidates.append({'available':True,'provider':'gcp','price':value,'currency':'USD','unit':'GiB-month','region':region,'service':'Google Cloud Storage Standard / '+sku['skuId'],'source':'Google Cloud Billing Catalog','url':'https://cloud.google.com/skus/?currency=USD','date':datetime.now(timezone.utc).date().isoformat(),'coverage':'Standard storage only; operations, replication and transfer excluded'})
             if len(candidates)==1:return candidates[0]
-        return {'available':False,'provider':'gcp','region':region,'sourceUrl':PROVIDER_PAGES[provider],'reason':'An exact regional storage SKU needs a configured Google Cloud Billing Catalog API key or a sourced quote. A generic/default-region web price will not be substituted.','nextQuestion':'Which Google Cloud region and storage class should we price?'}
+        return {'available':False,'provider':'gcp','region':region,'sourceUrl':PROVIDER_PAGES[provider],'reason':f'Storage pricing for {region or "the selected region"} could not be verified. Recalculate or enter a sourced rate.','nextQuestion':'Which Google Cloud region and storage class should we price?'}
     return {'available':False,'provider':'ibm','region':region,'sourceUrl':PROVIDER_PAGES[provider],'reason':'IBM pricing depends on region, storage class and plan. No verified regional quote is configured; no AWS or invented rate is substituted.','nextQuestion':'Which IBM region and storage class or existing IBM quote should we use?'}
+
+
+def parse_lambda(data,region,url,architecture='x86_64'):
+    """Regional on-demand base meters; never apply account-specific free tiers."""
+    suffix='-ARM' if architecture=='arm64' else ''
+    expected={'requests':('AWS-Lambda-Requests'+suffix,'Request'),
+              'compute':('AWS-Lambda-Duration'+suffix,'Lambda-GB-Second')}
+    meters={}
+    for name,(group,unit)in expected.items():
+        matches=[]
+        for sku,product in data.get('products',{}).items():
+            attrs=product.get('attributes',{})
+            if attrs.get('regionCode')!=region or attrs.get('group')!=group:continue
+            for term in data.get('terms',{}).get('OnDemand',{}).get(sku,{}).values():
+                for rate in term.get('priceDimensions',{}).values():
+                    if rate.get('unit')!=unit or rate.get('beginRange')!='0':continue
+                    value=float(rate.get('pricePerUnit',{}).get('USD','nan'))
+                    if not 0<value<1:continue
+                    end=rate.get('endRange')
+                    matches.append({'price':value,'unit':unit,'service':'AWS Lambda / '+sku,
+                                    'tierLimit':None if end=='Inf'else float(end)})
+        if len(matches)!=1:raise ValueError('Could not uniquely verify the regional Lambda meter')
+        meters[name]=matches[0]
+    return {'available':True,'provider':'aws','region':region,'architecture':architecture,
+            'currency':'USD','source':'AWS public Price List','url':url,
+            'date':datetime.now(timezone.utc).date().isoformat(),'publicationDate':data.get('publicationDate'),
+            'meters':meters,'coverage':'On-demand requests and base compute only. Free tiers, logs, transfer, public gateway charges, provisioned concurrency, taxes and discounts are not included.'}
+
+
+@lru_cache(maxsize=32)
+def _lambda(region,architecture,hour):
+    url=f'https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/AWSLambda/current/{region}/index.json'
+    with urllib.request.urlopen(urllib.request.Request(url,headers={'User-Agent':'AtMem AI Architect/0.2'}),timeout=12)as response:raw=response.read(12_000_001)
+    if len(raw)>12_000_000:raise ValueError('Price list exceeds the supported size')
+    return parse_lambda(json.loads(raw),region,url,architecture)
+
+
+def lambda_quote(region,architecture='x86_64'):
+    if not re.fullmatch(r'[a-z]{2}-(?:gov-)?[a-z]+-\d',region)or architecture not in {'x86_64','arm64'}:
+        raise ValueError('Select an explicit AWS region and Lambda architecture')
+    return dict(_lambda(region,architecture,int(time.time()//3600)))
+
+
+def _public_rows(html):
+    from html.parser import HTMLParser
+    class Rows(HTMLParser):
+        def __init__(self):
+            super().__init__();self.rows=[];self.row=None;self.cell=None
+        def handle_starttag(self,tag,attrs):
+            if tag=='tr':self.row=[]
+            if tag in {'td','th'} and self.row is not None:self.cell=[]
+        def handle_data(self,data):
+            if self.cell is not None:self.cell.append(data)
+        def handle_endtag(self,tag):
+            if tag in {'td','th'} and self.cell is not None:
+                self.row.append(' '.join(' '.join(self.cell).split()));self.cell=None
+            if tag=='tr' and self.row is not None:self.rows.append(self.row);self.row=None
+    parser=Rows();parser.feed(html);return parser.rows
+
+
+def parse_google_public(html,service,url):
+    import hashlib
+    if service=='cloud-run':
+        marker='Services (Requests-based billing)'
+        if marker not in html:raise ValueError('Cloud Run request-based pricing section is missing')
+        html=html[html.index(marker):]
+        expected={'cpu':'CPU (per vCPU-second)','memory':'Memory (per GiB-second)','requests':'Requests (per 1,000,000)'}
+        units={'cpu':'vCPU-seconds','memory':'GiB-seconds','requests':'million requests'}
+    elif service=='cloud-sql':
+        if 'Iowa (us-central1)' not in html or 'Enterprise Edition - N4' not in html:
+            raise ValueError('Cloud SQL reference region or edition is missing')
+        marker='Enterprise Edition - N4';html=html[html.index(marker):]
+        expected={'cpu':'vCPUs','memory':'Memory'};units={'cpu':'vCPU-hours','memory':'GiB-hours'}
+    else:raise ValueError('Unsupported Google pricing service')
+    meters={}
+    for row in _public_rows(html):
+        if not row:continue
+        for key,label in expected.items():
+            if key in meters or row[0]!=label:continue
+            value=next((re.search(r'\$([0-9]+(?:\.[0-9]+)?)',cell)for cell in row[1:]if '$' in cell),None)
+            if value:
+                price=float(value.group(1))
+                if not 0<price<10:raise ValueError('Unexpected Google public price')
+                meters[key]={'price':price,'unit':units[key]}
+        if len(meters)==len(expected):break
+    if len(meters)!=len(expected):raise ValueError('Google public pricing meters could not be verified')
+    return {'available':True,'provider':'gcp','service':service,'region':'us-central1','currency':'USD',
+            'source':'Google Cloud public pricing','url':url,'date':datetime.now(timezone.utc).date().isoformat(),
+            'sourceSha256':hashlib.sha256(html.encode()).hexdigest(),'meters':meters,
+            'coverage':'US reference on-demand rates. Excludes free tiers, commitments, taxes, networking, backups, storage, external APIs and payment fees.'}
+
+
+@lru_cache(maxsize=8)
+def _google_public(service,hour):
+    path={'cloud-run':'run','cloud-sql':'sql'}.get(service)
+    if not path:raise ValueError('Unsupported Google pricing service')
+    url=f'https://cloud.google.com/{path}/pricing'
+    with urllib.request.urlopen(urllib.request.Request(url,headers={'User-Agent':'AtMem Architect pricing'}),timeout=15)as response:raw=response.read(8_000_001)
+    if len(raw)>8_000_000:raise ValueError('Google price page exceeds its size bound')
+    return parse_google_public(raw.decode('utf-8'),service,url)
+
+
+def google_public_quote(service,region,planning_reference=False):
+    if region!='us-central1' and not (planning_reference and (not region or re.search('select|unknown|tbd',region,re.I))):
+        raise ValueError('This public quote supports Iowa only; the selected region is preserved.')
+    return {**_google_public(service,int(time.time()//3600)),'planningReference':region!='us-central1'}
+
+
+def parse_google_storage_public(html, region, url):
+    """Read an explicitly selected single-region public table, never a region list match."""
+    import hashlib
+    from html.parser import HTMLParser
+    if region != 'us-central1':
+        raise ValueError('The public default storage table verifies Iowa only.')
+    marker = 'id="data-storage"'
+    if marker not in html:
+        raise ValueError('Google data storage section is missing.')
+    section = html[html.index(marker):]
+    # Stop before dual-region rates. Region options alone do not verify selected pricing.
+    boundary = re.search(r'<(?:p|h[1-6])[^>]*>\s*(?:<b>)?Dual-region(?:</b>)?\s*</', section)
+    if not boundary:
+        raise ValueError('The single-region storage boundary is missing.')
+    section = section[:boundary.start()]
+    class Selected(HTMLParser):
+        def __init__(self):super().__init__();self.regions=[]
+        def handle_starttag(self,tag,attrs):
+            a=dict(attrs)
+            if a.get('role')=='option' and a.get('aria-selected')=='true':self.regions.append(a.get('data-value'))
+    selected=Selected();selected.feed(section)
+    if selected.regions != ['Iowa (us-central1)']:
+        raise ValueError('The selected public storage region is not Iowa.')
+    table = re.search(r'<table\b[^>]*>.*?</table>', section, re.S)
+    rows = _public_rows(table.group(0)) if table else []
+    if len(rows)!=2 or rows[0].count('Standard storage')!=1:
+        raise ValueError('The Standard storage table could not be verified.')
+    index=rows[0].index('Standard storage')
+    if index>=len(rows[1]):raise ValueError('The storage price is missing.')
+    cell=rows[1][index]
+    rate=re.fullmatch(r'\$([0-9]+(?:\.[0-9]+)?) / 1 gibibyte hour(?:, per 1 month / account)?',cell)
+    if not rate or not 0<float(rate.group(1))<1:raise ValueError('Unexpected Google storage rate or unit.')
+    hourly=float(rate.group(1))
+    return {'available':True,'provider':'gcp','price':hourly*730,'currency':'USD',
+            'unit':'GiB-month','region':region,'service':'Cloud Storage Standard / single-region',
+            'source':'Google Cloud public pricing','url':url,
+            'date':datetime.now(timezone.utc).date().isoformat(),
+            'sourceSha256':hashlib.sha256(section.encode()).hexdigest(),
+            'hourlyPrice':hourly,'hoursPerMonth':730,
+            'coverage':'Single-region Standard storage; 730-hour planning month. Operations, replication, transfer, taxes and discounts excluded.'}
+
+
+@lru_cache(maxsize=32)
+def _google_storage_public(region,hour):
+    url='https://cloud.google.com/storage/pricing'
+    with urllib.request.urlopen(urllib.request.Request(url,headers={'User-Agent':'AtMem Architect pricing'}),timeout=12) as response:
+        raw=response.read(8_000_001)
+    if len(raw)>8_000_000:raise ValueError('Google storage page exceeds its size bound.')
+    return parse_google_storage_public(raw.decode('utf-8'),region,url)

package/server/prompts.py

@@ -121,3 +121,16 @@ new project; preserve an existing client's chosen name. The host constructs a co
 proposal after validation. Do not spend output tokens copying the entire current graph,
 original brief or unchanged configuration just to propose a small correction.
 """
+
+
+SYSTEM_PROMPT += """
+# Owner UX instruction: avoid word vomit
+Keep the visible chat reply quick and concise: normally one or two short sentences,
+at most 20 words total. Longer optional explanation belongs behind a help disclosure or in the specification. Ask one direct question when a decision is needed.
+Do not recap the brief, repeat accepted choices, narrate your process, advertise a
+skill or add examples unless asked. Example: 'Use USD for welcome credit and top-ups?'
+Preserve full requirements, rationale, uncertainty and technical detail in structured
+project/specification fields. Do not shorten or discard source requirements.
+If a material blocker needs explaining, state its cause and next action briefly.
+User requests for detailed specifications still receive complete specifications.
+"""

package/server/request_uploads.py

@@ -0,0 +1,65 @@
+"""Bounded, temporary, ordered request assembly. Uploaded content is never executed."""
+import hashlib
+import secrets
+import tempfile
+import threading
+import time
+
+MAX_BYTES = 64 * 1024 * 1024
+CHUNK_BYTES = 128 * 1024
+
+
+class RequestUploads:
+    def __init__(self):
+        self.rows = {}
+        self.lock = threading.Lock()
+
+    def _expire(self):
+        for key, row in list(self.rows.items()):
+            if time.monotonic() - row['updated'] > 1800:
+                self.rows.pop(key)['file'].close()
+
+    def start(self, size, digest):
+        with self.lock:
+            self._expire()
+            if not 0 < size <= MAX_BYTES:
+                raise ValueError('Request exceeds the 64 MiB upload limit.')
+            if len(self.rows) >= 8 or sum(r['size'] for r in self.rows.values()) + size > 2 * MAX_BYTES:
+                raise ValueError('Upload capacity is busy. Retry after current uploads finish.')
+            key = secrets.token_hex(24)
+            self.rows[key] = dict(file=tempfile.TemporaryFile(), size=size, digest=digest,
+                                  received=0, index=0, updated=time.monotonic())
+            return {'uploadId': key, 'chunkBytes': CHUNK_BYTES}
+
+    def append(self, key, index, content):
+        with self.lock:
+            self._expire()
+            row = self.rows.get(key)
+            if row is None:
+                raise ValueError('Upload expired. Start validation again.')
+            if index != row['index'] or not 0 < len(content) <= CHUNK_BYTES or row['received'] + len(content) > row['size']:
+                raise ValueError('Upload chunk is out of order or exceeds its declared size.')
+            row['file'].write(content)
+            row.update(received=row['received'] + len(content), index=index + 1, updated=time.monotonic())
+            return {'receivedBytes': row['received']}
+
+    def take(self, key):
+        with self.lock:
+            self._expire()
+            row = self.rows.pop(key, None)
+            if row is None:
+                raise ValueError('Upload expired. Start validation again.')
+            try:
+                row['file'].seek(0)
+                data = row['file'].read()
+                if len(data) != row['size'] or hashlib.sha256(data).hexdigest() != row['digest']:
+                    raise ValueError('Upload is incomplete or its checksum changed. Retry validation.')
+                return data
+            finally:
+                row['file'].close()
+
+    def cancel(self, key):
+        with self.lock:
+            row = self.rows.pop(key, None)
+            if row:
+                row['file'].close()

package/server/terraform_routes.py

@@ -11,13 +11,49 @@ from pathlib import Path
 import shutil
 import subprocess
 import tempfile
+import base64
+import binascii
 from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field, ValidationError
+from .request_uploads import RequestUploads, MAX_BYTES
 from typing import Literal
 
 router = APIRouter()
 LOCK = asyncio.Lock()
 ROOT = Path(__file__).resolve().parent.parent
+UPLOADS = RequestUploads()
+
+class UploadStart(BaseModel):
+    model_config = ConfigDict(extra='forbid')
+    bytes: int = Field(gt=0, le=MAX_BYTES, strict=True)
+    sha256: str = Field(pattern=r'^[a-f0-9]{64}$')
+
+class UploadId(BaseModel):
+    model_config = ConfigDict(extra='forbid')
+    uploadId: str = Field(pattern=r'^[a-f0-9]{48}$')
+
+class UploadChunk(UploadId):
+    index: int = Field(ge=0, strict=True)
+    data: str = Field(min_length=1, max_length=174764)
+
+@router.post('/api/terraform/uploads/start')
+async def upload_start(payload: UploadStart):
+    try:
+        return UPLOADS.start(payload.bytes, payload.sha256)
+    except ValueError as error:
+        raise HTTPException(409, str(error))
+
+@router.post('/api/terraform/uploads/chunk')
+async def upload_chunk(payload: UploadChunk):
+    try:
+        return UPLOADS.append(payload.uploadId, payload.index, base64.b64decode(payload.data, validate=True))
+    except (ValueError, binascii.Error) as error:
+        raise HTTPException(422, str(error))
+
+@router.post('/api/terraform/uploads/cancel')
+async def upload_cancel(payload: UploadId):
+    UPLOADS.cancel(payload.uploadId)
+    return {'cancelled': True}
 
 class ValidationRequest(BaseModel):
     model_config = ConfigDict(extra='forbid')
@@ -116,3 +152,13 @@ async def validate_route(payload: ValidationRequest):
             raise HTTPException(504, 'Terraform validation timed out. No deployment was attempted.')
         except (ValueError, OSError):
             raise HTTPException(422, 'Could not validate the generated Terraform draft. Check the project and local Terraform installation.')
+
+@router.post('/api/terraform/validate-upload')
+async def validate_upload(payload: UploadId):
+    if LOCK.locked():
+        raise HTTPException(409, 'A Terraform validation is already running.')
+    try:
+        request = ValidationRequest.model_validate_json(UPLOADS.take(payload.uploadId))
+    except (ValueError, ValidationError):
+        raise HTTPException(422, 'The upload is incomplete, changed, or is not a valid project validation request.')
+    return await validate_route(request)