@topolo/cli 0.13.17 → 0.13.21

package/agent-packs/src/topolo_agent_pack/work_adoption.py

@@ -0,0 +1,122 @@
+"""Human-authorized diagnostic continuation of one immutable cloud claim.
+
+Never reconstruct authority from a chat, local source path or worker assertion.
+The original failed jobs, source custody and uncertain effects remain held.
+"""
+import hashlib
+import json
+import pathlib
+import tempfile
+import uuid
+from .storage import canonical
+from .work import require, text
+
+FIELDS={'requestId','objective','channel','canonicalClaimId','continuationOwnerTaskId',
+        'role','acceptance','checkpointSHA256','checkpointRef','authorizationRef','continuationRevision','parentCheckpointSHA256'}
+SCOPE='read-only-checkpoint-diagnostic'
+
+def digest(value):
+    return hashlib.sha256(canonical(value)).hexdigest()
+
+def request_digest(request):
+    return digest(request)
+
+def validate(request):
+    require(isinstance(request,dict) and set(request)==FIELDS,'Exact retained adoption fields required')
+    for key in ['requestId','continuationOwnerTaskId']:
+        try:valid=str(uuid.UUID(request[key]))==request[key]
+        except (TypeError,ValueError,AttributeError):valid=False
+        require(valid,'Adoption requires exact task identities')
+    require(type(request['continuationRevision']) is int and request['continuationRevision']>0,'Exact parent revision required')
+    require(isinstance(request['parentCheckpointSHA256'],str) and len(request['parentCheckpointSHA256'])==64 and all(c in '0123456789abcdef' for c in request['parentCheckpointSHA256']),'Exact parent checkpoint heads required')
+    require(request['requestId']!=request['continuationOwnerTaskId'],'Continuation must retain its originating delivery task')
+    require(request['channel']=='engineering','Retained engineering channel required')
+    require(all(text(request[k],12000 if k=='acceptance' else 16000 if k=='objective' else 240)
+                for k in ['objective','canonicalClaimId','role','acceptance']),'Adoption requires objective, claim, registered role and string acceptance')
+    require(isinstance(request['checkpointSHA256'],str) and len(request['checkpointSHA256'])==64
+            and all(c in '0123456789abcdef' for c in request['checkpointSHA256']),'Exact canonical checkpoint digest required')
+    for key in ['checkpointRef','authorizationRef']:
+        ref=request[key]
+        require(isinstance(ref,dict) and set(ref)=={'appId','workspaceId','scope','key','etag','size','sha256'}
+                and ref['appId']=='app_topolo_bytes' and ref['scope']=='org'
+                and all(text(ref[k],1000) for k in ['workspaceId','key','etag','sha256'])
+                and type(ref['size']) is int and 0<ref['size']<=131072,'Exact bounded cloud evidence reference required')
+
+def read_evidence(store,ref):
+    from .topolo import read_artifact
+    require(getattr(store,'cloud',False),'Retained continuation requires activated cloud authority; no local history fallback')
+    authority=json.loads((store.root/'context-authority.json').read_text())
+    require(authority.get('organizationId')==store.binding['organizationId']
+            and authority.get('scope')==ref['scope'] and authority.get('workspaceId')==ref['workspaceId'],
+            'Selected claim evidence belongs to another cloud authority')
+    with tempfile.TemporaryDirectory(prefix='topolo-selected-claim-') as tmp:
+        path=pathlib.Path(tmp)/'selected.json'
+        read_artifact(store.client,{'input':{'bytesScope':ref['scope'],'bytesWorkspaceId':ref['workspaceId']}},ref['key'],ref,path)
+        return json.loads(path.read_text())
+
+def plan(request,retained,claim,roles):
+    validate(request)
+    require(request['role'] in roles,'Exact registered specialist role required')
+    require(retained['claimId']==request['canonicalClaimId']==claim.get('claimId'),'Claim identity differs')
+    require(text(retained.get('ownerThreadId'),200) and retained['ownerThreadId']==claim.get('ownerThreadId'),'Recorded original controller differs')
+    require(digest(claim)==request['checkpointSHA256'],'Canonical checkpoint changed')
+    require(any(word in str(claim.get('state','')).lower() for word in ['failed','blocked','held','paused','unknown']),
+            'Recorded claim is active or unqualified; preserve current custody')
+    require(not any(claim.get(key) for key in ['lease','activeLease','ownerLease','leaseId','ownerLeaseId','leaseExpiresAt','ownerLeaseExpiresAt','activeWorkerId','activeRunId']),
+            'Canonical claim has a live or unresolved owner lease')
+    return {'format':'topolo-retained-continuation-plan-v2','canonicalClaimId':request['canonicalClaimId'],
+            'checkpointSHA256':digest(claim),'retainedSHA256':digest(retained),
+            'fromOwnerThreadId':claim['ownerThreadId'],'toRole':request['role'],
+            'continuationOwnerTaskId':request['continuationOwnerTaskId'],'acceptance':request['acceptance'],
+            'requestSHA256':request_digest(request),'canonicalSource':request['checkpointRef'],
+            'authorizationRef':request['authorizationRef'],'checkpoint':claim,'scope':SCOPE,
+            'preserveUnknownEffects':True,'sourceOwnerRetained':True,'releaseGatesRetained':True}
+
+def verify_authority(request,prepared,authorization,actor,consent,installation):
+    consent=consent or {}
+    required={'format','principalId','organizationId','canonicalClaimId','checkpointSHA256','sourceHead',
+              'continuationOwnerTaskId','continuationRevision','parentCheckpointSHA256','scope','instruction','instructionSHA256'}
+    require(isinstance(authorization,dict) and set(authorization)==required
+            and authorization['format']=='topolo-human-retained-continuation-v1'
+            and authorization['scope']==prepared['scope']==SCOPE,'Exact human diagnostic authorization required')
+    require(actor.get('user',{}).get('role')=='owner' and actor.get('user',{}).get('id')==authorization['principalId']==consent.get('principalId')
+            and actor.get('organization',{}).get('id')==authorization['organizationId']=='org_topolo_platform'
+            and consent.get('approved') is True and consent.get('contextKey')=='org:org_topolo_platform',
+            'Current authenticated owner and installation consent differ')
+    require(all(authorization[k]==request[k] for k in ['canonicalClaimId','checkpointSHA256','continuationOwnerTaskId','continuationRevision','parentCheckpointSHA256'])
+            and text(authorization['instruction']) and hashlib.sha256(authorization['instruction'].encode()).hexdigest()==authorization['instructionSHA256'],
+            'Human instruction does not bind this exact claim continuation')
+    head=prepared['checkpoint'].get('head') or prepared['checkpoint'].get('sourceCommit')
+    require(isinstance(head,str) and len(head)==40 and all(c in '0123456789abcdef' for c in head)
+            and authorization['sourceHead']==head,'Exact source head differs from human authorization')
+    return {'authority':'current-authenticated-human-instruction','principalId':authorization['principalId'],
+            'organizationId':authorization['organizationId'],'installationId':installation,
+            'authorizationSHA256':digest(authorization),'consentSHA256':digest(consent),
+            'planSHA256':digest(prepared),'scope':SCOPE,'originalWorkerAcceptance':False}
+
+def parent_heads(parent,workers):
+    return {'result':parent.get('result',{}).get('checkpoint'),
+            'workers':[{'id':w['id'],'phase':w['phase'],'checkpoint':w.get('checkpoint')} for w in sorted(workers,key=lambda w:w['id'])]}
+
+def verify_parent(parent,workers,request,root,client,installation):
+    """Only closed portable checkpoints permit a foreign installation transfer."""
+    from .work_artifacts import read_checkpoint
+    require(parent['state'] in {'blocked','needs_input'} and parent['revision']==request['continuationRevision'],
+            'Parent is active, uncertain or revision changed; preserve custody')
+    require(workers and digest(parent_heads(parent,workers))==request['parentCheckpointSHA256'],
+            'Parent cloud checkpoint heads differ')
+    for worker in workers:
+        require(worker['state']=='archived' and worker.get('nativeArchived') is True
+                and text(worker.get('nativeId'),200) and text(worker.get('turnId'),200)
+                and isinstance(worker.get('checkpoint',{}).get('artifact'),dict),
+                'Parent native worker has unresolved or nonportable custody')
+        payload=read_checkpoint(root,worker['checkpoint'],parent['id'],worker['id'],client=client)
+        native=payload['nativeReceipt']
+        require(payload['phase']==worker['phase'] and native['threadId']==worker['nativeId']
+                and native['turnId']==worker['turnId'] and native['status'] in {'completed','failed','cancelled'},
+                'Parent terminal checkpoint differs')
+    require(parent.get('result',{}).get('checkpoint') in [w['checkpoint'] for w in workers],
+            'Parent result does not bind a verified terminal checkpoint')
+    return {'fromInstallationId':parent.get('ownerInstallationId'),'toInstallationId':installation,
+            'revision':parent['revision'],'checkpointHeadsSHA256':request['parentCheckpointSHA256'],
+            'scope':SCOPE,'taskStatePreserved':parent['state']}

package/agent-packs/src/topolo_agent_pack/work_artifacts.py

@@ -0,0 +1,84 @@
+"""Portable task results and declared evidence; never exports native reasoning/history."""
+import hashlib,json,pathlib,tempfile,mimetypes
+from .storage import atomic_json,read_json,canonical,PackError,safe_id
+from .work import require
+
+def client_default():
+    from .topolo import Client
+    return Client('production','org:org_topolo_platform')
+
+def publish(root,task_id,label,data,content_type='application/json',client=None):
+    safe_id(task_id)
+    root=pathlib.Path(root);authority=read_json(root/'context-authority.json',{})
+    require(authority.get('format')=='topolo-task-context-authority-v1' and authority.get('organizationId')=='org_topolo_platform' and authority.get('scope')=='org' and authority.get('workspaceId'),'Cloud artifact authority is missing')
+    require(isinstance(data,bytes) and 0<len(data)<=100*1024*1024 and all(c.isalnum() or c in '-_.' for c in label),'Invalid declared artifact')
+    digest=hashlib.sha256(data).hexdigest();directory=root/'artifact-uploads'/task_id;directory.mkdir(parents=True,exist_ok=True,mode=0o700)
+    name=label+'-'+digest[:16];file=directory/name;receipt=directory/(name+'.receipt.json');prior=read_json(receipt,{})
+    client=client or client_default()
+    if prior:
+        require(prior.get('sha256')==digest and prior.get('state') in {'uploaded','verified'},'Artifact upload is uncertain; reconcile before retrying')
+        key=prior['key']
+    else:
+        require(not file.exists(),'Artifact source exists without an upload receipt; reconcile first')
+        file.write_bytes(data);file.chmod(0o600);atomic_json(receipt,{'state':'prepared','sha256':digest})
+        result=client.action('app_topolo_bytes.files.upload_url.create',{'key':'task-results/'+task_id+'/'+name,'type':content_type,'size':len(data),'scope':authority['scope']},authority['workspaceId'],write=True,upload=file)
+        key=result.get('key') or result.get('session',{}).get('key');require(isinstance(key,str) and key,'Artifact upload key is unconfirmed; reconcile before retrying')
+        atomic_json(receipt,{'state':'uploaded','sha256':digest,'key':key})
+    from .topolo import read_artifact
+    ref=read_artifact(client,{'input':{'bytesScope':authority['scope'],'bytesWorkspaceId':authority['workspaceId']}},key)
+    require(ref['sha256']==digest,'Cloud artifact differs from declared output')
+    atomic_json(receipt,{'state':'verified','sha256':digest,'key':key,'artifact':ref});return ref
+
+def declared_files(worker,values):
+    require(isinstance(values,list) and len(values)<=16,'Declare at most sixteen evidence files')
+    cwd=pathlib.Path(worker['cwd']).resolve();paths=[]
+    for value in values:
+        require(isinstance(value,str),'Evidence path must be a string')
+        path=pathlib.Path(value)
+        require(path.is_absolute() and '..' not in path.parts and path.is_file() and not path.is_symlink() and path.resolve().is_relative_to(cwd) and not any(p.is_symlink() for p in path.parents if p!=cwd.parent),'Evidence must be a regular file in this worker workspace')
+        require(0<path.stat().st_size<=100*1024*1024,'Declared evidence exceeds upload boundary');paths.append(path)
+    return paths
+
+def checkpoint(root,task,worker,actual,client=None):
+    text='\n'.join(i.get('text','') for i in actual.get('items',[]) if i.get('type')=='agentMessage' and i.get('phase')!='commentary')
+    require(len(text.encode())<=100000,'Worker output exceeds bounded checkpoint')
+    normalized=None;error=None
+    if worker['phase'] in {'execute','review'} and actual['status']=='completed':
+        try:
+            raw=text.strip()
+            if raw.startswith('```'):raw=raw.split('\n',1)[1].rsplit('```',1)[0]
+            output=json.loads(raw)
+            if worker['phase']=='execute':
+                require(set(output)=={'summary','artifacts','references'} and isinstance(output['summary'],str) and isinstance(output['references'],list) and len(output['references'])<=32 and all(isinstance(r,str) and len(r)<=2000 for r in output['references']),'Invalid portable worker result contract')
+                paths=declared_files(worker,output['artifacts'])
+            else:
+                require(set(output)=={'verdict','summary','evidence'} and output['verdict'] in {'completed','needs_input','blocked'} and isinstance(output['summary'],str),'Invalid independent review contract')
+                paths=declared_files(worker,output['evidence']);require(output['verdict']!='completed' or bool(paths),'Completion requires inspected evidence')
+        except (PackError,ValueError,TypeError,KeyError) as exc:error=str(exc)
+        else:
+            refs=[{'title':path.name,'artifact':publish(root,task['id'],worker['id']+'-evidence-'+str(n),path.read_bytes(),mimetypes.guess_type(path.name)[0] or 'application/octet-stream',client)} for n,path in enumerate(paths)]
+            normalized={**output,('artifacts' if worker['phase']=='execute' else 'evidence'):refs}
+    payload={'format':'topolo-task-checkpoint-v1','taskId':task['id'],'workerId':worker['id'],'phase':worker['phase'],'nativeReceipt':{'threadId':worker['nativeId'],'turnId':actual['id'],'status':actual['status'],'toolItems':sum(i.get('type') not in {'agentMessage','userMessage','reasoning','plan'} for i in actual.get('items',[]))},'resolution':worker['resolution'],'roleSource':worker.get('roleSource'),'contextRef':task.get('contextRef'),'output':canonical(normalized).decode() if normalized is not None else text,'outputError':error,'nativeHistoryIncluded':False}
+    if actual.get('nativeProof'):
+        payload['nativeReceipt']['producer']=actual['nativeProof']
+    data=canonical(payload);ref=publish(root,task['id'],worker['id']+'-checkpoint',data,client=client)
+    return {'artifact':ref,'sha256':ref['sha256']},payload,normalized
+
+def read_checkpoint(root,proof,task_id,worker_id=None,client=None):
+    from .topolo import read_artifact
+    ref=proof['artifact'];require(proof['sha256']==ref['sha256'] and 0<ref['size']<=200000,'Checkpoint digest or size binding differs');client=client or client_default()
+    with tempfile.TemporaryDirectory(prefix='topolo-one-checkpoint-') as tmp:
+        file=pathlib.Path(tmp)/'checkpoint.json';read_artifact(client,{'input':{'bytesScope':ref['scope'],'bytesWorkspaceId':ref['workspaceId']}},ref['key'],ref,file);payload=json.loads(file.read_text())
+    require(set(payload)=={'format','taskId','workerId','phase','nativeReceipt','resolution','roleSource','contextRef','output','outputError','nativeHistoryIncluded'} and payload.get('format')=='topolo-task-checkpoint-v1' and payload.get('taskId')==task_id and (worker_id is None or payload.get('workerId')==worker_id) and payload.get('nativeHistoryIncluded') is False,'Cloud checkpoint identity differs')
+    return payload
+
+def materialize_result(root,task,cwd,client=None):
+    from .topolo import read_artifact
+    result=task.get('result',{});payload=read_checkpoint(root,result['checkpoint'],task['id'],result['workerId'],client)
+    require(payload['phase']=='execute' and payload['outputError'] is None,'Worker checkpoint is not a qualified result')
+    output=json.loads(payload['output']);require(output=={k:result[k] for k in ['summary','artifacts','references']},'Task result differs from the immutable worker checkpoint')
+    target=pathlib.Path(cwd)/'context';target.mkdir(exist_ok=True);atomic_json(target/'worker-result.json',payload)
+    evidence=target/'evidence';evidence.mkdir(exist_ok=True);mapping=[];client=client or client_default()
+    for n,row in enumerate(result.get('artifacts',[])):
+        ref=row['artifact'];path=evidence/str(n);read_artifact(client,{'input':{'bytesScope':ref['scope'],'bytesWorkspaceId':ref['workspaceId']}},ref['key'],ref,path);mapping.append({'title':row['title'],'path':str(path),'artifact':ref})
+    atomic_json(target/'result-source.json',{'checkpoint':result['checkpoint'],'evidence':mapping})

package/agent-packs/src/topolo_agent_pack/work_context.py

@@ -0,0 +1,77 @@
+"""Pinned immutable Docs task context, fetched at assignment time."""
+import hashlib
+import pathlib
+import json,tempfile
+from .storage import read_json,atomic_json,PackError
+from .work import require
+
+def materialize(root,task,cwd,client_factory=None):
+    binding=pathlib.Path(root)/'context-refs'/(task['id']+'.json')
+    if not binding.exists() and not task.get('contextRef'):
+        require((cwd/'context/continuity.md').is_file(),'Task continuity context is missing; bind the existing cloud task packet before dispatch')
+        return
+    require(not binding.is_symlink(),'Task context binding cannot be a symlink')
+    ref=task.get('contextRef') or read_json(binding)
+    if client_factory is None:
+        from .topolo import Client
+        client_factory=lambda:Client('production','org:org_topolo_platform')
+    if set(ref)=={'taskId','artifact'}:
+        require(ref['taskId']==task['id'],'Cloud task context identity differs')
+        from .topolo import read_artifact
+        artifact=ref['artifact']
+        with tempfile.TemporaryDirectory(prefix='topolo-one-task-context-') as tmp:
+            path=pathlib.Path(tmp)/'task.json'
+            read_artifact(client_factory(),{'input':{'bytesScope':artifact['scope'],'bytesWorkspaceId':artifact['workspaceId']}},artifact['key'],artifact,path)
+            packet=json.loads(path.read_text())
+        require(set(packet)=={'format','taskId','markdown'} and packet['format']=='topolo-task-context-v1' and packet['taskId']==task['id'] and isinstance(packet['markdown'],str) and len(packet['markdown'])<=100000,'Unqualified individual task context')
+        target=cwd/'context';target.mkdir(exist_ok=True,mode=0o700)
+        (target/'continuity.md').write_text(packet['markdown'])
+        atomic_json(target/'continuity-source.json',ref)
+        return
+    require(set(ref)=={'taskId','workspaceId','documentId','versionId','bodySHA256'},'Invalid pinned task context')
+    require(ref['taskId']==task['id'],'Cloud task context identity differs')
+    result=client_factory().action('app_topolo_docs.documents.get',{'documentId':ref['documentId']},ref['workspaceId'])
+    doc=result['document'];versions=[v for v in result['versions'] if v['id']==ref['versionId']]
+    require(doc['id']==ref['documentId'] and doc['workspaceId']==ref['workspaceId'] and doc['organizationId']=='org_topolo_platform' and len(versions)==1,'Pinned cloud context is unavailable in the owning organization')
+    body=versions[0]['bodyMarkdown'];require(hashlib.sha256(body.encode()).hexdigest()==ref['bodySHA256'],'Pinned cloud task context changed')
+    start='<!-- topolo-task-context:'+task['id']+' -->';end='<!-- /topolo-task-context -->'
+    require(body.count(start)==1,'Cloud document has no unique context for this task')
+    section=body.split(start,1)[1];require(end in section,'Cloud task context section is incomplete');section=section.split(end,1)[0]
+    target=cwd/'context';target.mkdir(exist_ok=True,mode=0o700)
+    (target/'continuity.md').write_text('# Verified immutable Topolo Docs task context\n\nSource: '+ref['documentId']+' / '+ref['versionId']+'\n\n'+section)
+    atomic_json(target/'continuity-source.json',ref)
+
+def ensure(root,task,client=None):
+    """Publish one new request packet before native work; never replay an uncertain upload."""
+    root=pathlib.Path(root);binding=root/'context-refs'/(task['id']+'.json')
+    if task.get('contextRef'):return task['contextRef']
+    if binding.exists():return read_json(binding)
+    authority=read_json(root/'context-authority.json',{})
+    require(set(authority)=={'format','organizationId','workspaceId','scope'} and authority['format']=='topolo-task-context-authority-v1' and authority['organizationId']=='org_topolo_platform' and authority['scope']=='org' and isinstance(authority['workspaceId'],str) and authority['workspaceId'],'Task cloud context authority is missing; no local-context fallback')
+    if client is None:
+        from .topolo import Client
+        client=Client('production','org:org_topolo_platform')
+    from .topolo import read_artifact
+    directory=root/'context-uploads';directory.mkdir(exist_ok=True,mode=0o700)
+    receipt=directory/(task['id']+'.receipt.json');file=directory/(task['id']+'.context.json')
+    packet={'format':'topolo-task-context-v1','taskId':task['id'],'markdown':'# Current human request\n\nTask: '+task['id']+'\nChannel: '+task['channel']+'\n\n'+task['objective']+'\n\n## Custody and evidence\nThis packet records the human request, not proof that existing work is unowned, resumed, released or complete. Discover only the relevant canonical Topolo Docs/Bytes references before execution. Preserve existing task/claim/intent identities, owners, pauses and UNKNOWN effects. Report missing context or authority without duplicating work. Current task phase and subsequent human responses are in TASK.json. No task history or portfolio export is required for this packet.\n'}
+    source=json.dumps(packet,sort_keys=True,separators=(',',':')).encode();digest=hashlib.sha256(source).hexdigest()
+    prior=read_json(receipt,{})
+    if prior:
+        require(prior.get('sourceSHA256')==digest,'Task context input changed; reconcile the existing upload')
+        require(prior.get('state') in {'uploaded','verified'},'Task context upload is uncertain; reconcile its receipt before retrying')
+        key=prior['key']
+    else:
+        require(not file.exists(),'Task context source exists without a receipt; reconcile before uploading')
+        file.write_bytes(source);file.chmod(0o600)
+        atomic_json(receipt,{'state':'prepared','taskId':task['id'],'sourceSHA256':digest})
+        result=client.action('app_topolo_bytes.files.upload_url.create',{'key':'task-context/'+file.name,'type':'application/json','size':len(source),'scope':authority['scope']},authority['workspaceId'],write=True,upload=file)
+        key=result.get('key') or result.get('session',{}).get('key')
+        require(isinstance(key,str) and key,'Task context upload returned no persisted key; reconcile before retrying')
+        atomic_json(receipt,{'state':'uploaded','taskId':task['id'],'sourceSHA256':digest,'key':key})
+    artifact=read_artifact(client,{'input':{'bytesScope':authority['scope'],'bytesWorkspaceId':authority['workspaceId']}},key)
+    require(artifact['sha256']==digest,'Persisted task context differs; no native work started')
+    ref={'taskId':task['id'],'artifact':artifact}
+    atomic_json(receipt,{'state':'verified','taskId':task['id'],'sourceSHA256':digest,'key':key,'artifact':artifact})
+    atomic_json(binding,ref)
+    return ref

package/agent-packs/src/topolo_agent_pack/work_gui.py

@@ -0,0 +1,51 @@
+"""Closed loopback GUI adapter to the token-authenticated owning connection."""
+import json
+import socket
+from .storage import Library,canonical,read_json,PackError
+from . import live
+from .work import Store
+
+class Client:
+    def __init__(self,root):
+        self.lib=Library(root)
+    def snapshot(self):
+        try:
+            result=live.request(self.lib,'work-list',{})
+            if 'events' not in result:result['events']=[event for task in result['tasks'] for event in live.request(self.lib,'work-read',{'taskId':task['id']})['events']]
+            result['coordinatorObservations']=self.observe_coordinators()
+            if read_json(self.lib.root/'work/config.json',{}).get('frontdoorDispatch') is not True:
+                states=read_json(self.lib.root/'work/coordinator-observations.json',{}).get('states',{})
+                active=sorted({event['owner'] for event in result['coordinatorObservations'] if states.get(event['threadId'])=='active'})
+                if active:result['activityNotice']=', '.join(active)+' is executing outside the task ledger. Recorded milestones update here; continuous specialist progress awaits the pending backend activation.'
+            status=live.request(self.lib,'status',{})
+            if status.get('workStartupError'):result['activityNotice']='Automatic task resumption is blocked: '+status['workStartupError']
+            result['connection']='live';return result
+        except (PackError,OSError):
+            from .cloud_work import open_store
+            store=open_store(self.lib.root)
+            result=store.snapshot() if getattr(store,'cloud',False) else {'tasks':store.list(),'workers':store.workers(),'events':store.events(),'retainedCount':len(store.retained())}
+            return {**result,'connection':'offline','notice':'Native execution is disconnected. Recorded checkpoints are shown; no task is being retried.'}
+    def observe_coordinators(self):
+        from .coordinator_activity import record
+        status=live.request(self.lib,'status',{})
+        if status.get('activityError'):
+            raise PackError('Native activity recording failed: '+status['activityError'])
+        return record(self.lib.root,status)
+    def submit(self,request):
+        return live.request(self.lib,'work-submit',request)
+    def respond(self,request):
+        return live.request(self.lib,'work-respond',request)
+    def read(self,task_id):
+        return live.request(self.lib,'work-read',{'taskId':task_id})
+    def events(self):
+        record=read_json(self.lib.root/'live-bridge.json',{})
+        if not record:
+            raise PackError('Native event connection unavailable')
+        with socket.socket(socket.AF_UNIX,socket.SOCK_STREAM) as connection:
+            connection.settimeout(3);connection.connect(record['socket']);connection.sendall(canonical({'token':record['token'],'operation':'work-watch','params':{}})+b'\n');connection.settimeout(None)
+            with connection.makefile('rb') as stream:
+                for line in stream:
+                    value=json.loads(line)
+                    if 'error' in value:
+                        raise PackError(value['error'])
+                    yield value