@atmem/architect 0.2.0-alpha.4.1 → 0.2.0

package/server/local_providers.py

@@ -4,6 +4,10 @@ from pathlib import Path
 
 SIGN_IN={'claude-code':('claude','claude auth login'),'codex':('codex','codex login'),'gemini-cli':('gemini','gemini'),'copilot':('copilot','copilot login')}
 
+def cli_command(argv):
+    """Resolve PATHEXT shims explicitly; CreateProcess does not search .cmd names."""
+    return [shutil.which(argv[0]) or argv[0], *argv[1:]]
+
 def account_environment():
     env=dict(os.environ)
     for key in ['ANTHROPIC_API_KEY','ANTHROPIC_AUTH_TOKEN','OPENAI_API_KEY','CODEX_API_KEY','GEMINI_API_KEY','GOOGLE_API_KEY','GITHUB_TOKEN','GH_TOKEN','COPILOT_GITHUB_TOKEN']:
@@ -21,7 +25,7 @@ def signed_in(provider):
     if not argv or not shutil.which(argv[0]):return None
     import subprocess
     try:
-        done=subprocess.run(argv,capture_output=True,text=True,timeout=8,stdin=subprocess.DEVNULL,env=account_environment())
+        done=subprocess.run(cli_command(argv),capture_output=True,text=True,encoding='utf-8',errors='replace',timeout=8,stdin=subprocess.DEVNULL,env=account_environment())
     except Exception:
         return None
     if provider=='claude-code':
@@ -40,7 +44,7 @@ async def start_login(provider):
     if not argv or not shutil.which(argv[0]):raise RuntimeError('This provider has no sign-in AtMem AI Architect can start. Use its API key instead.')
     running=LOGINS.get(provider)
     if running and running.returncode is None:return {'started':True,'url':None}
-    process=await asyncio.create_subprocess_exec(*argv,stdin=asyncio.subprocess.DEVNULL,stdout=asyncio.subprocess.PIPE,stderr=asyncio.subprocess.STDOUT,env=account_environment(),start_new_session=os.name!='nt')
+    process=await asyncio.create_subprocess_exec(*cli_command(argv),stdin=asyncio.subprocess.DEVNULL,stdout=asyncio.subprocess.PIPE,stderr=asyncio.subprocess.STDOUT,env=account_environment(),start_new_session=os.name!='nt')
     LOGINS[provider]=process
     url=None
     try:
@@ -128,7 +132,7 @@ def models(provider):
         return [{'id':i,'name':n,'efforts':CLAUDE_EFFORTS,'defaultEffort':'medium'} for i,n in CLAUDE_MODELS]
     if provider=='codex' and shutil.which('codex'):
         try:
-            done=subprocess.run(['codex','debug','models'],capture_output=True,text=True,timeout=15,stdin=subprocess.DEVNULL,env=account_environment())
+            done=subprocess.run(cli_command(['codex','debug','models']),capture_output=True,text=True,encoding='utf-8',errors='replace',timeout=15,stdin=subprocess.DEVNULL,env=account_environment())
             data=json.loads(done.stdout)
             return [{'id':m['slug'],'name':m.get('display_name',m['slug']),'efforts':[e['effort'] for e in m.get('supported_reasoning_levels',[])],'defaultEffort':m.get('default_reasoning_level')}
                     for m in data.get('models',[]) if m.get('visibility','list')=='list']

package/server/memory_context.py

@@ -0,0 +1,58 @@
+"""Operator-configured external RAG/memory retrieval; never persists returned context."""
+from concurrent.futures import ThreadPoolExecutor
+import json
+import os
+import re
+from urllib.parse import urlsplit
+import urllib.request
+from .settings import setting
+
+
+def providers():
+    values=json.loads(setting('MEMORY_CONTEXT_PROVIDERS') or '[]')
+    if not isinstance(values,list)or len(values)>4:raise ValueError('Configure at most four context providers')
+    seen=set()
+    for value in values:
+        if not isinstance(value,dict)or set(value)-{'id','label','url','tokenEnv','enabled','kind'}:raise ValueError('Invalid context provider configuration')
+        ident=value.get('id','');url=urlsplit(value.get('url',''))
+        if not re.fullmatch(r'[a-z][a-z0-9-]{0,63}',ident)or ident in seen or url.scheme not in {'http','https'}or not url.hostname or url.username or url.password or url.fragment or url.query:raise ValueError('Context providers need unique IDs and credential-free HTTP endpoints')
+        token=value.get('tokenEnv')
+        if token and not re.fullmatch(r'[A-Z][A-Z0-9_]{0,99}',token):raise ValueError('Use an environment variable for provider credentials')
+        seen.add(ident)
+    return values
+
+
+def describe():
+    return [{'id':value['id'],'label':str(value.get('label')or value['id'])[:80],'kind':value.get('kind','rag'),'enabled':value.get('enabled',True),'configured':True}for value in providers()]
+
+
+class NoRedirect(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self,*args,**kwargs):return None
+
+
+def retrieve(project,owner,query,safe):
+    configured=[value for value in providers()if value.get('enabled',True)]
+    if not configured:return [],[]
+    def fetch(value):
+        ident=value['id'];headers={'Content-Type':'application/json'}
+        if value.get('tokenEnv'):
+            token=os.getenv(value['tokenEnv'])
+            if not token:return [],{'id':ident,'status':'credential_missing'}
+            headers['Authorization']='Bearer '+token
+        request=urllib.request.Request(value['url'],data=json.dumps({'query':query[:4000],'userId':owner,'projectId':project,'limit':6}).encode(),headers=headers,method='POST')
+        try:
+            with urllib.request.build_opener(NoRedirect).open(request,timeout=4)as response:data=response.read(100001)
+            if len(data)>100000:raise ValueError('Context exceeds bound')
+            result=json.loads(data);rows=result.get('records')
+            if not isinstance(rows,list)or len(rows)>6:raise ValueError('Invalid context response')
+            context=[]
+            for row in rows:
+                scope=row.get('scope','project')
+                if scope not in {'project','user'}or row.get('userId')!=owner or(scope=='project'and row.get('projectId')!=project)or(scope=='user'and row.get('projectId')not in {None,''}):raise ValueError('Context scope mismatch')
+                text=row.get('text');source=row.get('source');record_id=row.get('id')
+                if not isinstance(text,str)or not 0<len(text)<=4000 or not safe(text)or not isinstance(source,dict)or not isinstance(record_id,str)or len(record_id)>160 or not safe(source):raise ValueError('Invalid context provenance')
+                context.append({'id':ident+':'+record_id,'scope':scope,'text':text,'sourceDate':row.get('createdAt'),'key':row.get('key'),'provider':ident,'source':source,'external':True,'boundary':'retrieved_context_only'})
+            return context,{'id':ident,'status':'ready','records':len(context)}
+        except Exception:return [],{'id':ident,'status':'unavailable'}
+    with ThreadPoolExecutor(max_workers=4)as pool:results=list(pool.map(fetch,configured))
+    return [row for rows,_ in results for row in rows],[state for _,state in results]

package/server/memory_routes.py

@@ -6,7 +6,7 @@ from typing import Literal
 from .contracts import Strict
 from .memory_service import service
 from . import skills
-from .pricing import aws_s3, storage_quote
+from .pricing import aws_s3, storage_quote, lambda_quote, google_public_quote
 
 router=APIRouter()
 class Target(Strict):
@@ -28,8 +28,8 @@ class Price(Target):
     provider:Literal['aws','azure','gcp','ibm']='aws'
     region:str=Field(max_length=40)
 
-async def invoke(fn,*args):
-    try:return await asyncio.to_thread(fn,*args)
+async def invoke(fn,*args,**kwargs):
+    try:return await asyncio.to_thread(fn,*args,**kwargs)
     except ValueError as exc:raise HTTPException(422,str(exc))
     except Exception:raise HTTPException(503,'AtMem is unavailable; your project still works. Run npm run setup:memory if needed.')
 
@@ -54,11 +54,8 @@ async def profile(payload:Profile):
 
 @router.post('/api/memory/forget-preview')
 async def preview(payload:Forget):
-    report=await invoke(service().inspect,payload.projectId)
-    records=report['profile' if payload.scope=='user' else 'project']
-    record=next((r for r in records if r['id']==payload.recordId),None)
-    if not record:raise HTTPException(404,'Record not available in this scope')
-    return {'records':[r for r in records if r['fact_key']==record['fact_key']], 'notice':'Removes this memory and its earlier values. Project data is kept; edit the project itself to change requirements or decisions.'}
+    result=await invoke(service().record_detail,payload.projectId,payload.scope,payload.recordId,True)
+    return {**result,'notice':'Removes this memory and its history. Project files remain.'}
 
 @router.post('/api/memory/forget')
 async def forget(payload:Forget):
@@ -80,3 +77,65 @@ async def price(payload:Price):
 async def storage(payload:Price):
     try:return await asyncio.to_thread(storage_quote,payload.provider,payload.region)
     except Exception:raise HTTPException(503,'The exact provider/region price could not be verified. No rate was invented.')
+
+
+class LambdaPrice(Target):
+    region:str=Field(max_length=40)
+    architecture:Literal['x86_64','arm64']='x86_64'
+
+@router.post('/api/pricing/lambda')
+async def lambda_price(payload:LambdaPrice):
+    try:return await asyncio.to_thread(lambda_quote,payload.region,payload.architecture)
+    except Exception:raise HTTPException(503,'The regional Lambda price is unavailable. Retry pricing; no rate was invented.')
+
+
+class GooglePrice(Target):
+    service:Literal['cloud-run','cloud-sql']
+    region:str=Field(default='',max_length=40)
+    planningReference:StrictBool=False
+
+@router.post('/api/pricing/google')
+async def google_price(payload:GooglePrice):
+    try:return await asyncio.to_thread(google_public_quote,payload.service,payload.region,payload.planningReference)
+    except ValueError as error:raise HTTPException(422,str(error)) from None
+    except Exception:raise HTTPException(503,'Google pricing could not be verified. Retry pricing.') from None
+
+
+class MemoryPage(Target):
+    scope:Literal['user','project','knowledge']='project'
+    status:Literal['active','superseded','quarantined','all']='active'
+    query:str=Field(default='',max_length=200)
+    cursor:str|None=Field(default=None,max_length=500)
+    limit:int=Field(default=50,ge=1,le=100,strict=True)
+
+class ProfileName(Strict):
+    name:str=Field(min_length=1,max_length=80)
+
+@router.post('/api/memory/records')
+async def memory_records(payload:MemoryPage):
+    return await invoke(service().browse,payload.projectId,payload.scope,status=payload.status,query=payload.query,cursor=payload.cursor,limit=payload.limit)
+
+@router.post('/api/memory/record')
+async def memory_record(payload:Forget):
+    return await invoke(service().record_detail,payload.projectId,payload.scope,payload.recordId)
+
+@router.post('/api/memory/user-profile')
+async def user_profile(payload:ProfileName):
+    return await invoke(service().rename_profile,payload.name)
+
+
+class ContextRequest(Target):
+    query:str=Field(min_length=1,max_length=4000)
+
+@router.post('/api/memory/context')
+async def memory_context(payload:ContextRequest):
+    memory=service()
+    records,status=await invoke(memory.recall,payload.projectId,payload.query)
+    return {'records':records,'status':status,'userId':memory.owner,'projectId':payload.projectId,'boundary':'retrieval_only'}
+
+
+@router.post('/api/memory/overview')
+async def memory_overview(payload:Target):
+    memory=service();result=await invoke(memory.overview,payload.projectId)
+    result['skills']=skills.public(skills.catalogue(memory,payload.projectId))
+    return result

package/server/memory_service.py

@@ -49,6 +49,7 @@ class MemoryService:
         with self.db() as db:
             db.executescript('''
               CREATE TABLE IF NOT EXISTS identity (id TEXT PRIMARY KEY);
+              CREATE TABLE IF NOT EXISTS profiles (id TEXT PRIMARY KEY,name TEXT NOT NULL);
               CREATE TABLE IF NOT EXISTS settings (project TEXT PRIMARY KEY, enabled INTEGER NOT NULL DEFAULT 1);
               CREATE TABLE IF NOT EXISTS snapshots (project TEXT PRIMARY KEY, revision INTEGER, entities TEXT, digest TEXT);
               CREATE TABLE IF NOT EXISTS queue (seq INTEGER PRIMARY KEY AUTOINCREMENT, event_id TEXT UNIQUE, project TEXT, scope TEXT, key TEXT, text TEXT, source TEXT, state TEXT, created TEXT);
@@ -61,6 +62,7 @@ class MemoryService:
             self.owner = row[0] if row else str(uuid.uuid4())
             if not row:
                 db.execute('INSERT INTO identity VALUES (?)', (self.owner,))
+            db.execute("INSERT OR IGNORE INTO profiles VALUES (?,?)",(self.owner,'Default profile'))
 
     @contextmanager
     def db(self):
@@ -94,6 +96,7 @@ class MemoryService:
         return {'enabled': enabled}
 
     def call(self, operations):
+        operations=[{**op,'owner':self.owner,'actor':'user:'+self.owner if (op.get('subject')==self.subject('user','') or op.get('action')=='forget') else 'atmem-project-sync','actorType':'user' if (op.get('subject')==self.subject('user','') or op.get('action')=='forget') else 'project-sync'}for op in operations]
         result = subprocess.run([self.worker, '-I', str(ROOT / 'server/memory_worker.py')],
             input=json.dumps({'database': str(self.home / 'memories.db'), 'operations': operations}),
             text=True, capture_output=True, timeout=25, cwd=str(self.home))
@@ -202,22 +205,49 @@ class MemoryService:
             self.flush()
             return self.status(project)
 
+    def overview(self,project):
+        from .memory_context import describe
+        self.project(project)
+        with self.lock,self.db()as db:
+            activity=[{'id':row[0],'createdAt':row[1],**json.loads(row[2])}for row in db.execute('SELECT id,created,payload FROM activity WHERE project=? ORDER BY created DESC LIMIT 20',(project,))]
+        return {**self.status(project),'activity':activity,'userProfile':self.user_profile(),'contextProviders':describe()}
+
     def inspect(self, project):
+        from .memory_context import describe
         self.project(project)
         with self.lock:
             if self.enabled(project):
                 self.flush()
             subjects = [self.subject('user', project), self.subject('project', project), self.subject('knowledge', project)]
             try:
-                results = self.call([{'action': 'list', 'subject': s} for s in subjects])
-                records = [[{k: r.get(k) for k in ('id','content','status','fact_key','created_at','supersedes_id')} for r in rows[-200:] if r.get('status') != 'tombstoned'] for rows in results]
+                results = self.call([{'action': 'page', 'subject': s,'status':'all','limit':50} for s in subjects])
+                records = [page['records'] for page in results]
             except (OSError, RuntimeError, subprocess.TimeoutExpired):
                 self.error = 'AtMem unavailable — using this project only; eligible changes queued'
                 records = [[], [], []]
             with self.db() as db:
                 activity = [{'id': r[0], 'createdAt': r[1], **json.loads(r[2])} for r in db.execute('SELECT id,created,payload FROM activity WHERE project=? ORDER BY created DESC LIMIT 20', (project,))]
                 events = [{'key':r[0],'status':r[1],'reason':r[2],'createdAt':r[3]} for r in db.execute("SELECT key,state,reason,created FROM queue WHERE project=? AND state IN ('pending','rejected') ORDER BY seq DESC LIMIT 20",(project,))]
-            return {**self.status(project), 'profile': records[0], 'project': records[1], 'knowledge': records[2], 'activity': activity, 'events':events}
+            return {**self.status(project), 'profile': records[0], 'project': records[1], 'knowledge': records[2], 'activity': activity, 'events':events,'userProfile':self.user_profile(),'contextProviders':describe()}
+
+    def user_profile(self):
+        with self.db()as db:name=db.execute('SELECT name FROM profiles WHERE id=?',(self.owner,)).fetchone()[0]
+        return {'id':self.owner,'name':name,'kind':'local','identitySource':'local-installation'}
+
+    def rename_profile(self,name):
+        if not isinstance(name,str)or not name.strip()or len(name)>80:raise ValueError('Enter a profile name up to 80 characters')
+        with self.lock,self.db()as db:db.execute('UPDATE profiles SET name=? WHERE id=?',(name.strip(),self.owner))
+        return self.user_profile()
+
+    def browse(self,project,scope='project',**options):
+        self.project(project)
+        if scope not in {'user','project','knowledge'}:raise ValueError('Invalid memory scope')
+        with self.lock:return self.call([{'action':'page','subject':self.subject(scope,project),**options}])[0]
+
+    def record_detail(self,project,scope,record_id,preview=False):
+        self.project(project)
+        if scope not in {'user','project'}:raise ValueError('Invalid memory scope')
+        with self.lock:return self.call([{'action':'forget-preview'if preview else 'record','subject':self.subject(scope,project),'recordId':record_id}])[0]
 
     def forget(self, project, scope, record_id):
         if scope not in {'user', 'project'}:
@@ -243,12 +273,15 @@ class MemoryService:
             try:
                 rows = self.call([{'action': 'recall', 'subject': self.subject(s, project), 'query': query, 'limit': 6} for s in ('user', 'project')])
                 context = [{'scope': scope, 'id': r['id'], 'text': r['content'], 'sourceDate': r['created_at'], 'key': r.get('fact_key')} for scope, records in zip(('user','project'), rows) for r in records]
-                return context, self.status(project)
+                from .memory_context import retrieve
+                external,provider_status=retrieve(project,self.owner,query,safe)
+                return context+external,{**self.status(project),'contextProviders':provider_status}
             except (OSError, RuntimeError, subprocess.TimeoutExpired):
                 self.error = 'AtMem unavailable — using this project only; eligible changes queued'
                 return [], self.status(project)
 
     def record_turn(self, project, payload):
+        payload={**payload,'userId':self.owner,'actor':'atmem-architect','actorType':'agent'}
         ident = str(uuid.uuid4())
         with self.lock, self.db() as db:
             db.execute('INSERT INTO activity VALUES (?,?,?,?)', (ident, project, timestamp(), json.dumps(payload)))

package/server/memory_worker.py

@@ -2,10 +2,65 @@
 import json
 import sys
 import sqlite3
+import base64
+import re
 from importlib.metadata import version
 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')
@@ -23,32 +78,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

@@ -82,3 +82,109 @@ def storage_quote(provider,region):
             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':'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'}

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.
+"""