@topolo/cli 0.13.10 → 0.13.11

package/README.md

@@ -436,3 +436,15 @@ context start, fixture start, retirement, and positive permission forwarding
 remain closed before native access. A valid private profile reference does not
 lift this boundary. Source fixtures and descriptor reads do not establish
 private MCP adoption or actual task completion.
+
+Dynamic lane plans can explicitly select the `native-cli` continuity transport.
+Its closed `remote-context --continuity-input` operation produces a bounded
+public identity/context receipt with real response request IDs. The native
+thread's own command or Bash result and charter reads must independently match
+that receipt; an external shell result does not establish native context.
+
+Current native startup, credential refresh authority and Bash result producers
+remain unqualified. Native CLI effects therefore refuse with
+`native_cli_startup_unqualified` before client/helper/native access. Private MCP
+startup retains its existing refusal. Version 1 plans stay readable and do not
+silently become version 2 CLI plans.

package/agent-packs/README.md

@@ -669,3 +669,33 @@ context start, fixture start, retirement, and positive permission forwarding
 remain closed before native access. A valid private profile reference does not
 lift this boundary. Source fixtures and descriptor reads do not establish
 private MCP adoption or actual task completion.
+
+### Explicit native CLI continuity
+
+Version 2 dynamic plans may name `continuityTransport: native-cli`; version 1
+plans retain their existing behavior. The original intake relation is logical
+routing. It does not invent native parentage for a peer session.
+
+The existing public `remote-context` command accepts `--continuity-input` with
+one owned, closed input file. The operation uses an absolute pinned Node/CLI,
+selected profile metadata and an isolated child environment. Its receipt projects
+public principal, organization, Agent/version, Agent/Bytes scope, source digests,
+nonce and actual successful response request IDs. Raw stderr, response bodies,
+credentials and environment dumps are excluded. Missing or ambiguous response
+metadata is incomplete evidence.
+
+A receipt itself cannot acknowledge native context. Verification requires the
+same owning native query, its actual model/effort acknowledgement, exact command,
+turn/tool identity, successful completion/exit and matching result within the
+original request history boundary, plus genuine reads of the own charter/context.
+Only the exact bootstrap command may receive bootstrap permission through the
+original intake. Other work also requires verified context, current policy,
+actual tool outcome and separate settlement. Approval forwarding alone is not
+operation completion.
+
+Current startup provenance, profile refresh authority and native Bash completion
+contracts are unavailable. Effects stay closed with
+`native_cli_startup_unqualified`; an unsupported result contract stays
+`native_cli_tool_result_unqualified`. Input references, hashes or JSON flags do
+not grant admission. Private MCP is a separate unsupported transport and is never
+a fallback. Source fixtures do not activate either native harness.

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

@@ -344,6 +344,7 @@ def parser():
             q.add_argument('--ownership',choices=['user','organization'],required=True);q.add_argument('--bytes-scope',choices=['private','org'],required=True);q.add_argument('--instance')
             q.add_argument('--reconcile-local-context',action='store_true',help='Explicitly reconcile a recorded partial context attachment; never replays cloud writes')
             q.add_argument('--private-profile',action='store_true',help='Bind the explicitly selected protected profile metadata for native child helpers')
+        if command=='remote-context':q.add_argument('--continuity-input',help='Closed native-cli continuity input; runtime authority must independently qualify before any client')
         if command=='remember':
             q.add_argument('--content',required=True);q.add_argument('--kind',choices=['instruction','knowledge','durable'],required=True)
             q.add_argument('--provenance',required=True);q.add_argument('--visibility',choices=['private','shared'],default='private')
@@ -385,7 +386,10 @@ def main(argv=None):
         lib=Library(args.store)
         if args.command in {'connect','remote-context','remember','artifact','artifact-get','remote-recover'}:
             from . import topolo
-            with topolo.connection_lock(lib,args):result=topolo.dispatch(lib,args)
+            if args.command=='remote-context' and args.continuity_input:
+                result=topolo.native_cli_continuity_read(lib,args)
+            else:
+                with topolo.connection_lock(lib,args):result=topolo.dispatch(lib,args)
             emit(result)
             return 0
         if args.command=='lane' and args.operation=='serve':

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

@@ -9,6 +9,9 @@ import hashlib
 import os
 import pathlib
 import stat
+import re
+import uuid
+import time
 from contextlib import contextmanager
 
 from .storage import PackError, atomic_json, canonical, read_json, safe_id
@@ -51,7 +54,7 @@ def _role(value, harness):
 
 def plan(request, role, intake, resolution, ceiling):
     if (not isinstance(request, dict) or not {'laneId','logicalOriginThreadId','sourceRoleKey','task'}<=set(request) or
-            set(request)-{'laneId','logicalOriginThreadId','sourceRoleKey','task','verificationProfile'}):
+            set(request)-{'laneId','logicalOriginThreadId','sourceRoleKey','task','verificationProfile','continuityTransport','continuity'}):
         raise PackError('Dynamic lane request has unsupported fields')
     if request.get('verificationProfile') not in {None,'manual'}:
         raise PackError('Only a separately bound narrower manual verification profile is supported')
@@ -68,7 +71,12 @@ def plan(request, role, intake, resolution, ceiling):
         raise PackError('Dynamic lane has no exact current policy ceiling and intake route')
     for key in ['policyRevision', 'policyDigest', 'profile']:
         _identity(ceiling[key], key)
-    return {'format': 'topolo-dynamic-lane-plan', 'schemaVersion': 1,
+    explicit_cli='continuityTransport' in request or 'continuity' in request
+    if explicit_cli:
+        if request.get('continuityTransport')!='native-cli' or set(request.get('continuity',{}))!={'cli','admissionReferences'}:
+            raise PackError('Explicit closed native-cli continuity transport required; no fallback')
+        native_cli_configuration(request['continuity'])
+    result={'format': 'topolo-dynamic-lane-plan', 'schemaVersion': 2 if explicit_cli else 1,
             'laneId': request['laneId'], 'harness': harness,
             'logicalOriginThreadId': request['logicalOriginThreadId'],
             'role': copy.deepcopy(role), 'intake': copy.deepcopy(intake),
@@ -78,6 +86,10 @@ def plan(request, role, intake, resolution, ceiling):
             'nativeParentId': intake['nativeId'] if harness == 'claude' else None,
             'nativeParentAvailability': 'actual-harness-intake' if harness == 'claude' else 'UNAVAILABLE',
             'state': 'planned', 'executionAuthorized': False}
+    if explicit_cli:
+        result.update(continuityTransport='native-cli',continuity=copy.deepcopy(request['continuity']),
+            nativeParentId=None,nativeParentAvailability='actual-native-peer')
+    return result
 
 
 def adopt(planned, receipt, native, current):
@@ -110,7 +122,7 @@ def adopt(planned, receipt, native, current):
         _identity(native.get('title'),'actual child title')
     if not pathlib.Path(receipt['cwd']).is_absolute():
         raise PackError('Created lane requires its exact absolute owned workspace')
-    return {'format': 'topolo-dynamic-lane', 'schemaVersion': 1,
+    return {'format': 'topolo-dynamic-lane', 'schemaVersion': planned['schemaVersion'],
             'laneId': planned['laneId'], 'harness': planned['harness'], 'nativeId': receipt['nativeId'],
             'plan': copy.deepcopy(planned), 'planDigest': digest(planned),
             'creationReceipt': copy.deepcopy(receipt), 'creationReceiptDigest': digest(receipt),
@@ -139,6 +151,8 @@ def acknowledge_context(record, context_digest):
 
 
 def request_permission(record, request_fingerprint, request_id, generation):
+    if record['plan'].get('continuityTransport')=='native-cli' and record.get('nativeCliContext',{}).get('state')!='native-cli-context-ACK':
+        raise PackError('Native-cli work requires verified same-query public context receipt; bootstrap is separately scoped')
     if record['state'] != 'loaded-context-ACK' or generation != record['nativeConnectionGeneration']:
         raise PackError('Dynamic permission request has no current configured connection')
     _identity(request_fingerprint, 'native request fingerprint'); _identity(request_id, 'native request identity')
@@ -263,7 +277,7 @@ class Registry:
         if path.stat().st_size > 131072:
             raise PackError('Dynamic lane record exceeds its bounded schema')
         record = read_json(path)
-        if (record.get('format') != 'topolo-dynamic-lane' or record.get('schemaVersion') != 1 or
+        if (record.get('format') != 'topolo-dynamic-lane' or record.get('schemaVersion') not in {1,2} or not native_cli_record_version(record) or
                 record.get('laneId') != lane_id or record.get('harness') != self.harness or
                 record.get('state') not in STATES or
                 digest(record.get('plan')) != record.get('planDigest') or
@@ -297,7 +311,7 @@ class Registry:
 
     def write(self, record, before_digest):
         lane_id = record['laneId']
-        if (record.get('format') != 'topolo-dynamic-lane' or record.get('schemaVersion') != 1 or
+        if (record.get('format') != 'topolo-dynamic-lane' or record.get('schemaVersion') not in {1,2} or not native_cli_record_version(record) or
                 record['harness'] != self.harness or record['state'] not in STATES or
                 digest(record['plan']) != record['planDigest'] or
                 digest(record['creationReceipt']) != record['creationReceiptDigest']):
@@ -647,6 +661,14 @@ class ClaudeLifecycle:
     def dispatch(self,action,payload):
         if not isinstance(payload,dict):
             raise PackError('Closed native helper object required')
+        candidates=[payload.get('request'),payload.get('plan'),payload.get('operation',{}).get('record',{}).get('plan') if isinstance(payload.get('operation'),dict) and isinstance(payload.get('operation',{}).get('record',{}),dict) else None]
+        for candidate in candidates:
+            if isinstance(candidate,dict) and (candidate.get('continuityTransport')=='native-cli' or candidate.get('schemaVersion')==2 or 'continuity' in candidate):
+                native_cli_admission(candidate.get('continuity'))
+        if isinstance(payload.get('laneId'),str):
+            existing=self.store.read(payload['laneId'])
+            if existing and existing['plan'].get('continuityTransport')=='native-cli':
+                native_cli_admission(existing['plan']['continuity'])
         base={'models'}
         shapes={
             'peek':{'sourceRoleKey'},'plan':{'request','nativeIds'},'adopt':{'plan','receipt','native'},
@@ -747,3 +769,134 @@ def install_model_configuration(lib,pack,document,before_digest):
         raise PackError('Dynamic configuration readback differs')
     return {'state':'dynamic-task-model-intent-installed','pack':pack,'configurationDigest':digest(document),
         'nativeAvailabilityVerified':False,'existingRoleSettingsChanged':False,'modelTurnsStarted':False}
+
+
+# Explicit native-query CLI continuity. These validators do not grant authority.
+NATIVE_CLI_CONTEXT_FIELDS={'principalId','organizationId','contextKey','installationId','logicalId','agentId',
+    'agentVersionId','agentWorkspaceId','bytesWorkspaceId','environment','bytesScope'}
+NATIVE_CLI_SOURCE_FIELDS={'packRevision','planDigest','bindingDigest','policyDigest','charterDigest','contextDigest'}
+NATIVE_CLI_CLI_FIELDS={'nodeExecutable','nodeDigest','entry','entryDigest','version'}
+NATIVE_CLI_AUTHORITY_FIELDS={'startupEvidencePath','startupEvidenceDigest','profileAuthorityPath','profileAuthorityDigest','expiresAt'}
+NATIVE_CLI_INPUT_FIELDS={'format','schemaVersion','operationId','nonce','transport','harness','laneId','nativeId',
+    'sourceRoleKey','intakeKey','intakeNativeId','nativeConnectionGeneration','context','source','cli','admissionReferences','deadline'}
+NATIVE_CLI_RECEIPT_FIELDS={'format','schemaVersion','operationId','nonce','transport','harness','laneId','nativeId',
+    'nativeConnectionGeneration','context','source','cli','responses','claim'}
+
+
+def native_cli_closed(value,fields,label):
+    if not isinstance(value,dict) or set(value)!=fields:
+        raise PackError('Closed native-cli '+label+' required')
+
+
+def native_cli_hash(value):
+    if not isinstance(value,str) or not re.fullmatch('[a-f0-9]{64}',value):
+        raise PackError('Exact native-cli source digest required')
+
+
+def native_cli_configuration(value):
+    native_cli_closed(value,{'cli','admissionReferences'},'configuration')
+    cli=value['cli'];refs=value['admissionReferences']
+    native_cli_closed(cli,NATIVE_CLI_CLI_FIELDS,'CLI identity')
+    native_cli_closed(refs,NATIVE_CLI_AUTHORITY_FIELDS,'authority references')
+    for path in [cli['nodeExecutable'],cli['entry'],refs['startupEvidencePath'],refs['profileAuthorityPath']]:
+        if not isinstance(path,str) or len(path)>4096 or not pathlib.Path(path).is_absolute() or any(ord(c)<32 for c in path):
+            raise PackError('Exact absolute native-cli path reference required')
+    for value in [cli['nodeDigest'],cli['entryDigest'],refs['startupEvidenceDigest'],refs['profileAuthorityDigest']]:
+        native_cli_hash(value)
+    if not isinstance(cli['version'],str) or not re.fullmatch(r'0\.13\.\d+',cli['version']):
+        raise PackError('Immutable native-cli version required')
+    if type(refs['expiresAt']) is not int or refs['expiresAt']<=time.time():
+        raise PackError('Current native-cli authority reference required; reference alone is not authority')
+
+
+def native_cli_input(value):
+    native_cli_closed(value,NATIVE_CLI_INPUT_FIELDS,'input')
+    if (value['format']!='topolo-native-cli-continuity-input' or type(value['schemaVersion']) is not int or value['schemaVersion']!=1 or
+            value['transport']!='native-cli' or value['harness'] not in {'codex','claude'}):
+        raise PackError('Explicit versioned native-cli input required')
+    try:
+        if str(uuid.UUID(value['operationId']))!=value['operationId']:
+            raise ValueError()
+    except (ValueError,TypeError,AttributeError) as error:
+        raise PackError('Exact native-cli operation UUID required') from error
+    native_cli_hash(value['nonce']);safe_id(value['laneId'])
+    for key in ['nativeId','sourceRoleKey','intakeKey','intakeNativeId','nativeConnectionGeneration']:
+        _identity(value[key],key)
+    if '/intakes/' not in value['intakeKey'] or value['nativeId']==value['intakeNativeId']:
+        raise PackError('Exact independent child and original intake required')
+    context=value['context'];source=value['source']
+    native_cli_closed(context,NATIVE_CLI_CONTEXT_FIELDS,'public context');native_cli_closed(source,NATIVE_CLI_SOURCE_FIELDS,'source')
+    for entry in context.values():
+        _identity(entry,'public context')
+    if (context['environment'] not in {'production','staging','development'} or context['bytesScope'] not in {'private','org'} or
+            context['contextKey']!='org:'+context['organizationId']):
+        raise PackError('Exact native-cli environment, organization and Bytes scope required')
+    _identity(source['packRevision'],'pack revision')
+    for key in NATIVE_CLI_SOURCE_FIELDS-{'packRevision'}:
+        native_cli_hash(source[key])
+    native_cli_configuration({'cli':value['cli'],'admissionReferences':value['admissionReferences']})
+    if type(value['deadline']) is not int or value['deadline']<=time.time() or value['deadline']>value['admissionReferences']['expiresAt']:
+        raise PackError('Current bounded native-cli operation deadline required')
+    return copy.deepcopy(value)
+
+
+def native_cli_admission(_value):
+    # No supported current startup/refresh authority producer is installed.
+    # Never turn hashes, a caller boolean or JSON evidence references into one.
+    raise PackError('native_cli_startup_unqualified: current startup, profile refresh authority and native result contracts are unavailable')
+
+
+def native_cli_receipt(expected,receipt):
+    expected=native_cli_input(expected);native_cli_closed(receipt,NATIVE_CLI_RECEIPT_FIELDS,'receipt')
+    if (receipt['format']!='topolo-native-cli-continuity-receipt' or type(receipt['schemaVersion']) is not int or receipt['schemaVersion']!=1 or
+            receipt['claim']!='PUBLIC_IDENTITY_CONTEXT_RESPONSE_ONLY_NATIVE_ATTRIBUTION_REQUIRED'):
+        raise PackError('Native-cli public receipt format differs')
+    for key in NATIVE_CLI_RECEIPT_FIELDS-{'format','schemaVersion','responses','claim'}:
+        if receipt[key]!=expected[key]:
+            raise PackError('Native-cli receipt identity/source/operation differs')
+    native_cli_closed(receipt['responses'],{'identity','context'},'responses');seen=set()
+    for kind,response in receipt['responses'].items():
+        native_cli_closed(response,{'requestEvents','bodyProjectionDigest','actionId','resourceType','resourceId'},'response evidence')
+        native_cli_hash(response['bodyProjectionDigest']);events=response['requestEvents']
+        if not isinstance(events,list) or not 1<=len(events)<=8:
+            raise PackError('Actual bounded native-cli response request IDs required')
+        services=set()
+        for event in events:
+            native_cli_closed(event,{'requestId','method','service','path','status'},'request event')
+            identity=event['requestId'];path=event['path']
+            if (not isinstance(identity,str) or identity=='unavailable' or not re.fullmatch('[A-Za-z0-9][A-Za-z0-9._:-]{0,127}',identity) or
+                    identity in seen or event['method'] not in {'GET','POST'} or event['service'] not in {'auth','agent'} or
+                    type(event['status']) is not int or not 200<=event['status']<300 or not isinstance(path,str) or
+                    not path.startswith('/') or len(path)>1024 or any(c in path for c in ['?','#','\\','\n','\r'])):
+                raise PackError('Actual canonical successful native-cli response evidence required')
+            seen.add(identity);services.add(event['service'])
+        wanted=(None,None,None) if kind=='identity' else ('app_topolo_agent.agent_packs.context','workspace',expected['context']['agentWorkspaceId'])
+        if (response['actionId'],response['resourceType'],response['resourceId'])!=wanted or ('auth' if kind=='identity' else 'agent') not in services:
+            raise PackError('Native-cli response action/resource attribution differs')
+    return copy.deepcopy(receipt)
+
+
+def native_cli_context_ack(record,input,receipt,proof):
+    receipt=native_cli_receipt(input,receipt)
+    if (record.get('schemaVersion')!=2 or record['plan'].get('continuityTransport')!='native-cli' or
+            record['nativeId']!=input['nativeId'] or record['nativeConnectionGeneration']!=input['nativeConnectionGeneration'] or
+            record['state']!='loaded-context-ACK' or record['planDigest']!=input['source']['planDigest']):
+        raise PackError('Exact configured native-cli lane required before context ACK')
+    native_cli_closed(proof,{'harness','nativeId','generation','turnId','itemId','commandDigest','exitCode','receiptDigest'},'native tool attribution')
+    if (proof['harness']!=input['harness'] or proof['nativeId']!=input['nativeId'] or proof['generation']!=input['nativeConnectionGeneration'] or
+            proof['exitCode']!=0 or type(proof['exitCode'])is not int or proof['receiptDigest']!=digest(receipt)):
+        raise PackError('Actual same-query successful native tool attribution differs')
+    for key in ['turnId','itemId']:
+        _identity(proof[key],key)
+    native_cli_hash(proof['commandDigest'])
+    return {**record,'nativeCliContext':{'state':'native-cli-context-ACK','operationId':input['operationId'],
+        'nonce':input['nonce'],'receiptDigest':digest(receipt),'proof':copy.deepcopy(proof)}}
+
+
+def native_cli_record_version(record):
+    planned=record.get('plan',{})
+    if record.get('schemaVersion')==1:
+        return planned.get('schemaVersion')==1 and 'continuityTransport' not in planned
+    return (planned.get('schemaVersion')==2 and planned.get('continuityTransport')=='native-cli' and
+        planned.get('nativeParentId') is None and isinstance(planned.get('continuity'),dict) and
+        set(planned['continuity'])=={'cli','admissionReferences'})

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

@@ -606,6 +606,12 @@ class BackendProxy:
 
     async def qualify_organization(self,thread_id):
         role=self.execution.roles.get(thread_id) if self.execution else None
+        record=None
+        if role and role.get('dynamicLaneId'):
+            from . import lanes
+            record=lanes.Registry(self.lib.root,'codex').read(role['dynamicLaneId'])
+            if record['plan'].get('continuityTransport')=='native-cli':
+                lanes.native_cli_admission(record['plan']['continuity'])
         if role and not self.permission_configuration and (pathlib.Path(self.runtime)/'permissions-operation.json').exists():
             raise PackError('Unresolved native permission operation requires reconciliation before owned execution or grants')
         if not role or not role.get('installationConsent'):
@@ -635,8 +641,6 @@ class BackendProxy:
             raise PackError('Fresh organization policy prohibits the child-only manual verification profile')
         role['organizationPolicyProof']=proof
         if role.get('dynamicLaneId'):
-            from .lanes import Registry
-            record=Registry(self.lib.root,'codex').read(role['dynamicLaneId'])
             current=await self.dynamic_current(record['plan'])
             configuring=self._lane_configuration_record
             if configuring and configuring['nativeId']==thread_id and self.lane_busy:
@@ -1010,6 +1014,8 @@ class BackendProxy:
         self.lane_idle();store=lanes.Registry(self.lib.root,'codex');record=store.read(params['laneId'])
         if not record or record['state']!='loaded-context-ACK':
             raise PackError('Actual native settings and instruction-source ACK required before bootstrap')
+        if record['plan'].get('continuityTransport')=='native-cli':
+            lanes.native_cli_admission(record['plan']['continuity'])
         current=await self.dynamic_current(record['plan'])
         if current!={k:record['plan'][k] for k in ['role','intake','ceiling']}:
             raise PackError('Current bootstrap source or policy differs')
@@ -1086,6 +1092,8 @@ class BackendProxy:
         self.lane_idle();store=lanes.Registry(self.lib.root,'codex');record=store.read(params['laneId'])
         if not record or record['plan'].get('verificationProfile')!='manual':
             raise PackError('Actual routing proof requires the bound two-child manual verification plan')
+        if record['plan'].get('continuityTransport')=='native-cli':
+            lanes.native_cli_admission(record['plan']['continuity'])
         current=await self.dynamic_current(record['plan'])
         if current!={k:record['plan'][k] for k in ['role','intake','ceiling']}:
             raise PackError('Current source/intake/policy changed before own fixture verification')
@@ -1149,6 +1157,8 @@ class BackendProxy:
         self.lane_idle();store=lanes.Registry(self.lib.root,'codex');planned=store.read_plan(params['laneId'])
         if store.read(params['laneId']) is not None:
             raise PackError('This lane already has an actual native identity')
+        if planned.get('continuityTransport')=='native-cli':
+            lanes.native_cli_admission(planned['continuity'])
         current=await self.dynamic_current(planned)
         if current!={k:planned[k] for k in ['role','intake','ceiling']}:
             raise PackError('Source, intake or policy changed before native creation')
@@ -1202,6 +1212,9 @@ class BackendProxy:
 
     async def dynamic_lane(self, operation, params):
         from . import lanes,task_models,policy
+        requested=params.get('request',params.get('plan',{})) if isinstance(params,dict) else {}
+        if isinstance(requested,dict) and (requested.get('continuityTransport')=='native-cli' or requested.get('schemaVersion')==2 or 'continuity' in requested):
+            lanes.native_cli_admission(requested.get('continuity'))
         self.lane_idle()
         if self.lane_busy:
             raise PackError('An owned dynamic lane operation is already active')
@@ -1254,6 +1267,8 @@ class BackendProxy:
             record=store.read(params['laneId'])
             if not record:
                 raise PackError('No owned dynamic lane registration')
+            if record['plan'].get('continuityTransport')=='native-cli':
+                lanes.native_cli_admission(record['plan']['continuity'])
             current=await self.dynamic_current(record['plan'])
             if current!={k:record['plan'][k] for k in ['role','intake','ceiling']}:
                 raise PackError('Dynamic source, intake or policy drift; no native mutation')
@@ -1973,3 +1988,56 @@ def bind(lib,runtime):
             if backup.exists():raise PackError('Cannot preserve existing desktop-home file: '+name)
             dest.rename(backup)
         dest.symlink_to(expected)
+
+
+def compile_native_cli_command(value,store,pack,input_path,environment):
+    """Compile a fixed native tool command; no shell/model text is accepted."""
+    import shlex
+    from . import lanes
+    value=lanes.native_cli_input(value)
+    allowed={'HOME','USER','LOGNAME','PATH','LANG','LC_ALL','TMPDIR','TOPOLO_CONFIG_PATH','TOPOLO_ENV','TOPOLO_CONTEXT'}
+    if (not isinstance(environment,dict) or not set(environment)<=allowed or
+            any(not isinstance(v,str) or len(v)>4096 or any(ord(c)<32 for c in v) for v in environment.values()) or
+            not environment.get('TOPOLO_CONFIG_PATH') or not pathlib.Path(environment['TOPOLO_CONFIG_PATH']).is_absolute() or
+            environment.get('TOPOLO_ENV')!=value['context']['environment'] or environment.get('TOPOLO_CONTEXT')!=value['context']['contextKey']):
+        raise PackError('Exact child-only native-cli environment required; inherited credentials are forbidden')
+    if any(not pathlib.Path(p).is_absolute() for p in [store,input_path]) or pack!=value['sourceRoleKey'].split('/')[0]:
+        raise PackError('Exact owned store, pack and input references required')
+    argv=['/usr/bin/env','-i',*[k+'='+environment[k] for k in sorted(environment)],value['cli']['nodeExecutable'],value['cli']['entry'],
+        'agent-packs','--store',str(store),'remote-context',pack,'--environment',value['context']['environment'],
+        '--context-key',value['context']['contextKey'],'--role',value['context']['logicalId'],'--continuity-input',str(input_path)]
+    return shlex.join(argv)
+
+
+def native_cli_codex_tool_proof(value,command,result,turn_id,cwd,guide_command,guide_digest):
+    """Verify actual owned Codex tool DTOs; printed/foreign receipts do not ACK."""
+    import shlex
+    from . import lanes
+    value=lanes.native_cli_input(value);lanes.native_cli_hash(guide_digest)
+    if guide_digest!=value['source']['charterDigest']:
+        raise PackError('Native-cli actual charter read differs from the pinned receipt source')
+    thread=result.get('thread',{});turns=[t for t in thread.get('turns',[]) if t.get('id')==turn_id]
+    if (thread.get('id')!=value['nativeId'] or thread.get('cwd')!=str(cwd) or len(turns)!=1 or
+            turns[0].get('status')!='completed' or turns[0].get('error')):
+        raise PackError('Exact same-child native-cli turn/cwd completion required')
+    receipts=[];reads=[]
+    for item in turns[0].get('items',[]):
+        if item.get('type')!='commandExecution' or item.get('status')!='completed' or type(item.get('exitCode'))is not int or item['exitCode']!=0 or not item.get('id'):
+            continue
+        actual=item.get('command');args=shlex.split(actual) if isinstance(actual,str) else []
+        unwrapped=args[2] if len(args)==3 and args[0] in {'/bin/sh','/bin/bash','/bin/zsh'} and args[1]=='-c' else actual
+        if unwrapped==guide_command and hashlib.sha256(item.get('aggregatedOutput','').encode()).hexdigest()==guide_digest:
+            reads.append(item['id'])
+        if unwrapped!=command:
+            continue
+        try:
+            receipt=json.loads(item.get('aggregatedOutput',''))
+        except (ValueError,TypeError):
+            continue
+        receipt=lanes.native_cli_receipt(value,receipt);receipts.append((item['id'],receipt))
+    if len(receipts)!=1 or len(reads)!=1 or receipts[0][0]==reads[0]:
+        raise PackError('Actual native-cli command/receipt and own charter read require unique successful tool results')
+    identity,receipt=receipts[0]
+    proof={'harness':'codex','nativeId':value['nativeId'],'generation':value['nativeConnectionGeneration'],'turnId':turn_id,
+        'itemId':identity,'commandDigest':lanes.digest(command),'exitCode':0,'receiptDigest':lanes.digest(receipt)}
+    return {'receipt':receipt,'proof':proof,'nativeCharterReadItemId':reads[0]}

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

@@ -6,21 +6,23 @@ class ConnectionSourceRefused(PackError):
     pass
 
 class Client:
-    def __init__(self,environment,context,binary=None):
+    def __init__(self,environment,context,binary=None,env=None,node=None):
         if environment not in {'development','staging','production'}:
             raise PackError('Explicit Topolo environment required')
         if not context or any(c in context for c in '\n\r'):
             raise PackError('Explicit Topolo context required')
-        if any(os.environ.get(k) for k in ['TOPOLO_API_KEY','TOPOLO_ACCESS_TOKEN','TOPOLO_'+environment.upper()+'_API_KEY','TOPOLO_'+environment.upper()+'_ACCESS_TOKEN']):
+        selected=os.environ if env is None else env
+        if any(selected.get(k) for k in ['TOPOLO_API_KEY','TOPOLO_ACCESS_TOKEN','TOPOLO_'+environment.upper()+'_API_KEY','TOPOLO_'+environment.upper()+'_ACCESS_TOKEN']):
             raise PackError('Pinned connections require the CLI protected account context, not injected credentials')
         self.environment=environment;self.context=context
         self.binary=binary or shutil.which('topolo')
         if not self.binary:
             raise PackError('Install the public @topolo/cli and authenticate before connecting')
-        self.env={**os.environ,'TOPOLO_CONTEXT':context}
-        self.env['PATH']=str(pathlib.Path(self.binary).parent)+os.pathsep+self.env.get('PATH','')
+        self.env={**selected,'TOPOLO_CONTEXT':context}
+        self.command=[node,self.binary] if node else [self.binary]
+        self.env['PATH']=(str(pathlib.Path(node).parent)+os.pathsep+'/usr/bin:/bin') if node else str(pathlib.Path(self.binary).parent)+os.pathsep+self.env.get('PATH','')
     def run(self,args):
-        p=subprocess.run([self.binary,'--env',self.environment,*args,'--json'],env=self.env,capture_output=True,text=True,timeout=90)
+        p=subprocess.run([*self.command,'--env',self.environment,*args,'--json'],env=self.env,capture_output=True,text=True,timeout=90)
         if p.returncode:
             raise PackError('Topolo command failed (exit '+str(p.returncode)+'); inspect the published action, account permissions and environment. No fallback was used.')
         try:value=json.loads(p.stdout)
@@ -599,6 +601,8 @@ def connection_lock(lib,args):
         yield
 
 def dispatch(lib,args):
+    if args.command=='remote-context' and getattr(args,'continuity_input',None):
+        return native_cli_continuity_read(lib,args)
     client=Client(args.environment,args.context_key)
     if args.command=='connect':return connect(lib,args,client)
     if args.command=='remote-context':return remote_context(lib,args,client)[1]
@@ -610,3 +614,124 @@ def dispatch(lib,args):
         reference=read_json(args.reference)
         return read_artifact(client,binding,reference['key'],reference,args.destination)
     raise PackError('Unsupported Topolo command')
+
+
+
+def native_cli_response(stdout,stderr,service):
+    """Preserve only canonical public response metadata; never echo raw stderr."""
+    from . import lanes
+    if len(stdout.encode())>262144 or len(stderr.encode())>65536:
+        raise PackError('native_cli_request_metadata_unavailable: bounded public response required')
+    try:
+        body=json.loads(stdout)
+    except ValueError as error:
+        raise PackError('native_cli_request_metadata_unavailable: invalid public JSON') from error
+    if not isinstance(body,dict) or body.get('error'):
+        raise PackError('native_cli_request_metadata_unavailable: unsuccessful public response')
+    events=[];seen=set()
+    pattern=r'^\[topolo\] ← (\d{3}) (GET|POST) (auth|agent) (/[^\s?#\\]+) \([0-9.]+ms, req=([A-Za-z0-9][A-Za-z0-9._:-]{0,127})\)$'
+    for line in stderr.splitlines():
+        match=re.fullmatch(pattern,line)
+        if not match:
+            continue
+        status,method,target,path,request_id=match.groups()
+        if request_id=='unavailable' or request_id in seen or not 200<=int(status)<300:
+            raise PackError('native_cli_request_metadata_unavailable: ambiguous or unsuccessful response request IDs')
+        seen.add(request_id);events.append({'requestId':request_id,'method':method,'service':target,'path':path,'status':int(status)})
+    if not 1<=len(events)<=8 or service not in {event['service'] for event in events}:
+        raise PackError('native_cli_request_metadata_unavailable: actual canonical server response IDs required')
+    return body.get('data',body),events
+
+
+def native_cli_command_response(client,args,service):
+    env={**client.env,'TOPOLO_DEBUG':'1'}
+    result=subprocess.run([*client.command,'--env',client.environment,*args,'--json'],env=env,
+        capture_output=True,text=True,timeout=90)
+    if result.returncode:
+        raise PackError('native_cli_request_metadata_unavailable: public command refused; no fallback or retry')
+    return native_cli_response(result.stdout,result.stderr,service)
+
+
+def native_cli_selected_environment(value,binding,host_env):
+    from . import lanes
+    from types import SimpleNamespace
+    context=value['context'];profile=binding.get('privateCredentialProfile')
+    lanes.native_cli_closed(profile,{'format','schemaVersion','configPath','environment','contextKey','identity'},'private profile reference')
+    if (profile['format']!='topolo-private-credential-profile' or profile['schemaVersion']!=1 or
+            profile['environment']!=context['environment'] or profile['contextKey']!=context['contextKey'] or
+            profile['identity']!={'userId':context['principalId'],'organizationId':context['organizationId']}):
+        raise PackError('Exact native-cli approved profile/principal/context reference required')
+    selected=SimpleNamespace(env={'TOPOLO_CONFIG_PATH':profile['configPath']},environment=context['environment'],context=context['contextKey'])
+    args=SimpleNamespace(private_profile=True,environment=context['environment'],context_key=context['contextKey'])
+    private_profile_reference(selected,args)
+    for path,sha in [(value['cli']['nodeExecutable'],value['cli']['nodeDigest']),(value['cli']['entry'],value['cli']['entryDigest'])]:
+        p=pathlib.Path(path);info=p.lstat()
+        if (p.resolve()!=p or not stat.S_ISREG(info.st_mode) or info.st_uid not in {0,os.getuid()} or info.st_mode&0o022 or
+                not info.st_mode&0o111 or hashlib.sha256(p.read_bytes()).hexdigest()!=sha):
+            raise PackError('Native-cli executable source/provenance changed')
+    allowed={'HOME','USER','LOGNAME','PATH','LANG','LC_ALL','TMPDIR'}
+    env={k:v for k,v in host_env.items() if k in allowed and isinstance(v,str)}
+    env['PATH']=str(pathlib.Path(value['cli']['nodeExecutable']).parent)+os.pathsep+'/usr/bin:/bin'
+    env.update(TOPOLO_CONFIG_PATH=profile['configPath'],TOPOLO_ENV=context['environment'],TOPOLO_CONTEXT=context['contextKey'])
+    return env
+
+
+def native_cli_continuity_read(lib,args,*,_admit=None,_client_factory=None,_response=None):
+    """Native command producer. No current runtime authority producer exists.
+
+    Injected callbacks are internal hermetic seams, never CLI/JSON options.
+    Receipt output is public response evidence, not native-query attribution.
+    """
+    from . import lanes
+    path=pathlib.Path(args.continuity_input);info=path.lstat()
+    if (path.is_symlink() or not stat.S_ISREG(info.st_mode) or info.st_uid!=os.getuid() or info.st_nlink!=1 or
+            info.st_mode&0o077 or info.st_size>65536):
+        raise PackError('Exact owned bounded native-cli input required')
+    value=lanes.native_cli_input(read_json(path))
+    (lanes.native_cli_admission if _admit is None else _admit)(value)
+    context=value['context']
+    if (args.environment!=context['environment'] or args.context_key!=context['contextKey'] or args.role!=context['logicalId'] or
+            value['sourceRoleKey']!=args.name+'/'+args.role):
+        raise PackError('Native-cli command differs from the exact source/operation')
+    file=binding_path(lib,args.name,args.environment,args.context_key);info=file.lstat()
+    if (file.is_symlink() or not stat.S_ISREG(info.st_mode) or info.st_uid!=os.getuid() or info.st_nlink!=1 or
+            hashlib.sha256(file.read_bytes()).hexdigest()!=value['source']['bindingDigest']):
+        raise PackError('Native-cli current owned binding source differs')
+    binding=read_json(file);roles=[r for r in binding['input']['roles'] if r['logicalId']==args.role]
+    if (len(roles)!=1 or binding['identity']!={'userId':context['principalId'],'organizationId':context['organizationId']} or
+            binding['packRevision']!=value['source']['packRevision'] or binding['input']['instanceId']!=context['installationId'] or
+            binding['agentWorkspaceId']!=context['agentWorkspaceId'] or binding['input']['bytesWorkspaceId']!=context['bytesWorkspaceId'] or
+            binding['input']['bytesScope']!=context['bytesScope'] or roles[0]['agentId']!=context['agentId'] or roles[0]['agentVersionId']!=context['agentVersionId']):
+        raise PackError('Native-cli source principal/Agent/Bytes binding differs')
+    env=native_cli_selected_environment(value,binding,os.environ)
+    client=(Client if _client_factory is None else _client_factory)(args.environment,args.context_key,
+        binary=value['cli']['entry'],env=env,node=value['cli']['nodeExecutable'])
+    call=native_cli_command_response if _response is None else _response
+    identity,identity_events=call(client,['whoami'],'auth')
+    if (identity.get('user',{}).get('id')!=context['principalId'] or (identity.get('organization')or{}).get('id')!=context['organizationId']):
+        raise PackError('Actual native-cli public identity differs')
+    with tempfile.TemporaryDirectory(prefix='topolo-native-cli-context-') as directory:
+        input_file=pathlib.Path(directory)/'input.json';atomic_json(input_file,{'instanceId':context['installationId'],'logicalId':context['logicalId']})
+        envelope,context_events=call(client,['actions','call','app_topolo_agent.agent_packs.context','--detail','--data','@'+str(input_file),
+            '--resource-type','workspace','--resource-id',context['agentWorkspaceId']],'agent')
+    result=envelope.get('data',envelope)
+    actual=result.get('context',{})
+    expected={'organizationId':context['organizationId'],'workspaceId':context['agentWorkspaceId'],'instanceId':context['installationId'],
+        'logicalId':context['logicalId'],'agentId':context['agentId'],'agentVersionId':context['agentVersionId'],
+        'artifacts':{'appId':'app_topolo_bytes','resourceType':'workspace','resourceId':context['bytesWorkspaceId'],'scope':context['bytesScope']}}
+    if envelope.get('success') is False or any(actual.get(k)!=v for k,v in expected.items()):
+        raise PackError('Actual native-cli public Agent/Bytes context differs')
+    # Recheck mutable public binding, binary and stat-only profile after awaited reads.
+    if hashlib.sha256(file.read_bytes()).hexdigest()!=value['source']['bindingDigest']:
+        raise PackError('Native-cli binding changed during response; no receipt ACK')
+    native_cli_selected_environment(value,binding,os.environ)
+    (lanes.native_cli_admission if _admit is None else _admit)(value)
+    responses={}
+    for kind,body,events in [('identity',{'userId':context['principalId'],'organizationId':context['organizationId']},identity_events),
+                             ('context',expected,context_events)]:
+        responses[kind]={'requestEvents':events,'bodyProjectionDigest':lanes.digest(body),'actionId':None if kind=='identity' else 'app_topolo_agent.agent_packs.context',
+            'resourceType':None if kind=='identity' else 'workspace','resourceId':None if kind=='identity' else context['agentWorkspaceId']}
+    receipt={k:value[k] for k in lanes.NATIVE_CLI_RECEIPT_FIELDS-{'format','schemaVersion','responses','claim'}}
+    receipt.update(format='topolo-native-cli-continuity-receipt',schemaVersion=1,responses=responses,
+        claim='PUBLIC_IDENTITY_CONTEXT_RESPONSE_ONLY_NATIVE_ATTRIBUTION_REQUIRED')
+    return lanes.native_cli_receipt(value,receipt)

package/dist/{claude-pack-backend-RMSOPHVQ.js → claude-pack-backend-YEVPAOID.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/lib/claude-pack-backend.ts
-import { createHash, randomBytes, randomUUID } from "crypto";
+import { createHash as createHash2, randomBytes, randomUUID } from "crypto";
 import { closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, unlinkSync, writeFileSync } from "fs";
 import * as filesystem from "fs";
 import * as cryptography from "crypto";
@@ -13,6 +13,7 @@ import { createConnection } from "net";
 import { WebSocket } from "undici";
 
 // src/lib/claude-native-pack.ts
+import { createHash } from "crypto";
 async function nativeClaudePackOperation(manager, sidebar, plan, apply, checkpoint, verifyContext = () => {
 }) {
   const fenceKey = /* @__PURE__ */ Symbol.for("topolo.agent-pack.native-operation.v1");
@@ -849,7 +850,7 @@ async function nativeClaudeApprovalOperation(manager, routes, operation, fingerp
     const session = await manager.getSession(route.sessionId);
     if (!session || session.sessionId !== route.sessionId || session.cwd !== route.cwd || session.title !== route.title || session.isArchived)
       throw new Error("Native approval session identity differs: " + route.key);
-    if (!descriptor || descriptor.sessionId !== route.sessionId || descriptor.cwd !== route.cwd || descriptor.title !== route.title || descriptor.isArchived || descriptor.backend?.kind !== "local" || descriptor.backend.remoteTarget || descriptor.worktreePath || descriptor.worktreeLazy || (route.dynamic ? descriptor.spawnedFrom?.sessionId !== route.dynamic.nativeParentId || descriptor.spawnedFrom?.sideSession !== true || route.dynamic.nativeParentId !== route.intakeSessionId || !/^[a-f0-9]{64}$/.test(route.dynamic.planDigest) : descriptor.spawnedFrom))
+    if (!descriptor || descriptor.sessionId !== route.sessionId || descriptor.cwd !== route.cwd || descriptor.title !== route.title || descriptor.isArchived || descriptor.backend?.kind !== "local" || descriptor.backend.remoteTarget || descriptor.worktreePath || descriptor.worktreeLazy || (route.dynamic ? (route.dynamic.continuityTransport === "native-cli" ? Boolean(descriptor.spawnedFrom) || route.dynamic.nativeParentId !== null : descriptor.spawnedFrom?.sessionId !== route.dynamic.nativeParentId || descriptor.spawnedFrom?.sideSession !== true || route.dynamic.nativeParentId !== route.intakeSessionId) || !/^[a-f0-9]{64}$/.test(route.dynamic.planDigest) : descriptor.spawnedFrom))
       throw new Error("Native approval session descriptor identity differs: " + route.key);
     return session;
   };
@@ -993,11 +994,30 @@ async function nativeClaudeApprovalOperation(manager, routes, operation, fingerp
   if (operation.kind === "list") return { requests: [...state.entries.values()].map((e) => ({ ...e.record })) };
   const entry = state.entries.get(operation.key);
   if (!entry || entry.record.state !== "pending" || entry.record.intakeSessionId !== operation.intake || entry.record.fingerprint !== operation.fingerprint) throw new Error("Exact pending request and owning intake required.");
-  if (operation.kind === "respond" && operation.decision === "once" && byId.get(entry.record.sourceSessionId)?.dynamic)
-    throw Object.assign(
+  let cliFinalGuard;
+  if (operation.kind === "respond" && operation.decision === "once" && byId.get(entry.record.sourceSessionId)?.dynamic) {
+    const route = byId.get(entry.record.sourceSessionId);
+    if (route.dynamic?.continuityTransport === "native-cli") {
+      const producer = state.dynamicLifecycle?.get(entry.record.sourceSessionId)?.authorizeNativeCLI;
+      if (typeof producer !== "function") throw Object.assign(new Error("native_cli_startup_unqualified: actual native CLI admission producer unavailable."), { code: "native_cli_startup_unqualified" });
+      const admission = await producer(entry.record, entry.request, operation);
+      if (!admission || !["bootstrap", "work"].includes(admission.phase) || admission.nativeId !== entry.record.sourceSessionId || admission.intakeNativeId !== entry.record.intakeSessionId || admission.fingerprint !== entry.record.fingerprint || admission.generation !== route.dynamic.generation || typeof route.dynamic.generation !== "string" || !route.dynamic.generation || !admission.query || typeof admission.verifyCurrent !== "function" || typeof admission.model !== "string" || !admission.model || typeof admission.effort !== "string" || !admission.effort)
+        throw new Error("Exact current native CLI query/intake admission differs.");
+      const raw = await manager.getSessionWhenLoaded(entry.record.sourceSessionId, "topolo-native-cli-permission", { warnOnMiss: false });
+      if (raw?.query !== admission.query || typeof manager.readRunningModel !== "function" || typeof manager.getEffort !== "function" || await manager.readRunningModel(raw, raw.query) !== admission.model || await manager.getEffort(raw.sessionId) !== admission.effort)
+        throw new Error("Actual same-query native model/effort acknowledgement differs.");
+      cliFinalGuard = () => {
+        if (state.dynamicLifecycle?.get(entry.record.sourceSessionId)?.authorizeNativeCLI !== producer || raw.query !== admission.query || admission.verifyCurrent() !== void 0) throw new Error("Current native CLI admission changed before dispatch.");
+      };
+      if (admission.phase === "bootstrap") {
+        if (entry.request.toolName !== "Bash" || entry.request.input?.command !== admission.command || admission.commandDigest !== fingerprint(admission.command))
+          throw new Error("Only the exact native CLI bootstrap command may precede context acknowledgement.");
+      } else if (!/^[a-f0-9]{64}$/.test(admission.contextReceiptDigest ?? "")) throw new Error("Native CLI work requires verified same-query context receipt.");
+    } else throw Object.assign(
       new Error("native_private_query_prestart_contract_unqualified: dynamic private query authorization remains closed."),
       { code: "native_private_query_prestart_contract_unqualified" }
     );
+  }
   const pending = await current(entry);
   if (manager[symbol] !== state || state.entries.get(operation.key) !== entry || entry.record.state !== "pending" || state.auditFailed)
     throw new Error("Exact pending request changed during native identity validation; reconcile without replay.");
@@ -1005,6 +1025,7 @@ async function nativeClaudeApprovalOperation(manager, routes, operation, fingerp
   if (operation.kind !== "respond" || operation.humanDecisionRecorded !== true || !["once", "deny"].includes(operation.decision ?? ""))
     throw new Error("Recorded human one-request decision required; never auto-approve.");
   if (operation.decision !== "deny" && entry.record.cardOnly) throw new Error("Claude requires the original card; intake cannot impersonate its origin.");
+  cliFinalGuard?.();
   entry.record.state = "response-may-have-effects";
   checkpoint({ ...entry.record });
   await manager.respondToToolPermission(pending.requestId, operation.decision, void 0, "elsewhere");
@@ -1019,17 +1040,26 @@ async function nativeClaudeApprovalOperation(manager, routes, operation, fingerp
 }
 async function nativeClaudeAppendDynamicRoute(manager, route, verify, checkpoint, lifecycle) {
   const state = manager[/* @__PURE__ */ Symbol.for("topolo.agent-pack.approvals.v1")];
-  if (!state || state.auditFailed || !state.byId || !state.byKey || !route.dynamic || !/^[a-f0-9]{64}$/.test(route.dynamic.planDigest) || route.dynamic.nativeParentId !== route.intakeSessionId)
+  if (!state || state.auditFailed || !state.byId || !state.byKey || !route.dynamic || !/^[a-f0-9]{64}$/.test(route.dynamic.planDigest) || (route.dynamic.continuityTransport === "native-cli" ? route.dynamic.nativeParentId !== null : route.dynamic.nativeParentId !== route.intakeSessionId))
     throw new Error("Current qualified original approval listener required.");
+  let cliAdmission;
+  if (route.dynamic.continuityTransport === "native-cli") {
+    if (typeof lifecycle?.authorizeNativeCLI !== "function") throw Object.assign(new Error("native_cli_startup_unqualified: actual native CLI admission producer unavailable."), { code: "native_cli_startup_unqualified" });
+    cliAdmission = await lifecycle.authorizeNativeCLI(null, null, { kind: "route-append" });
+  }
   const intake = state.byId.get(route.intakeSessionId);
   if (!intake || intake.key !== route.intakeKey || intake.contextKey !== route.contextKey || !intake.key.includes("/intakes/"))
     throw new Error("Dynamic approval route has no exact same-context original intake.");
   await verify();
   const raw = await manager.getSessionWhenLoaded(route.sessionId, "topolo-dynamic-route", { warnOnMiss: false });
   const dto = await manager.getSession(route.sessionId);
-  if (!raw || !dto || raw.sessionId !== route.sessionId || raw.cwd !== route.cwd || raw.title !== route.title || dto.sessionId !== route.sessionId || dto.cwd !== route.cwd || dto.title !== route.title || raw.isArchived || dto.isArchived || raw.backend?.kind !== "local" || raw.backend.remoteTarget || raw.worktreePath || raw.worktreeLazy || raw.spawnedFrom?.sessionId !== route.intakeSessionId || raw.spawnedFrom?.sideSession !== true)
+  if (!raw || !dto || raw.sessionId !== route.sessionId || raw.cwd !== route.cwd || raw.title !== route.title || dto.sessionId !== route.sessionId || dto.cwd !== route.cwd || dto.title !== route.title || raw.isArchived || dto.isArchived || raw.backend?.kind !== "local" || raw.backend.remoteTarget || raw.worktreePath || raw.worktreeLazy || (route.dynamic.continuityTransport === "native-cli" ? Boolean(raw.spawnedFrom) : raw.spawnedFrom?.sessionId !== route.intakeSessionId || raw.spawnedFrom?.sideSession !== true))
     throw new Error("Actual dynamic child descriptor differs before route append.");
+  if (route.dynamic.continuityTransport === "native-cli" && (!cliAdmission?.query || raw.query !== cliAdmission.query || cliAdmission.nativeId !== route.sessionId || cliAdmission.intakeNativeId !== route.intakeSessionId || cliAdmission.generation !== route.dynamic.generation || typeof route.dynamic.generation !== "string" || !route.dynamic.generation || typeof cliAdmission.verifyCurrent !== "function" || typeof cliAdmission.model !== "string" || !cliAdmission.model || typeof cliAdmission.effort !== "string" || !cliAdmission.effort || typeof manager.readRunningModel !== "function" || typeof manager.getEffort !== "function" || await manager.readRunningModel(raw, raw.query) !== cliAdmission.model || await manager.getEffort(raw.sessionId) !== cliAdmission.effort))
+    throw new Error("Actual native CLI route query/model/effort admission differs.");
   await verify();
+  if (route.dynamic.continuityTransport === "native-cli" && (raw.query !== cliAdmission.query || cliAdmission.verifyCurrent() !== void 0))
+    throw new Error("Current native CLI route admission changed before append.");
   if (manager[/* @__PURE__ */ Symbol.for("topolo.agent-pack.approvals.v1")] !== state || state.auditFailed)
     throw new Error("Original native permission connection changed.");
   const old = state.byId.get(route.sessionId);
@@ -1188,8 +1218,8 @@ function prepareClaudeNativePlan(store, pack, policyPath, mode = "configure") {
     captureMarkdown(cwd);
     const charter = resolve(cwd, "CLAUDE.md");
     const transcript = realpathSync(record.transcript);
-    context[charter] = createHash("sha256").update(readFileSync(charter)).digest("hex");
-    context[transcript] = createHash("sha256").update(readFileSync(transcript)).digest("hex");
+    context[charter] = createHash2("sha256").update(readFileSync(charter)).digest("hex");
+    context[transcript] = createHash2("sha256").update(readFileSync(transcript)).digest("hex");
     roleContextFiles[record.desktopSessionId] = [charter, transcript];
     members.push({
       key: record.key,
@@ -1207,7 +1237,7 @@ function prepareClaudeNativePlan(store, pack, policyPath, mode = "configure") {
     });
   }
   for (const file of [resolve(root, "claude/state.json"), realpathSync(policyPath)])
-    context[file] = createHash("sha256").update(readFileSync(file)).digest("hex");
+    context[file] = createHash2("sha256").update(readFileSync(file)).digest("hex");
   const activePath = resolve(root, "claude/active.json");
   const active = existsSync(activePath) ? JSON.parse(readFileSync(activePath, "utf8")) : null;
   const target = new Set(members.map((m) => m.key));
@@ -1224,7 +1254,7 @@ function prepareClaudeNativePlan(store, pack, policyPath, mode = "configure") {
       if (!cwd.startsWith(resolve(root, "claude/workspaces", record.pack) + sep)) throw new Error("Outgoing workspace is outside the owned pack.");
       captureMarkdown(cwd);
       for (const file of [resolve(cwd, "CLAUDE.md"), realpathSync(record.transcript)])
-        context[file] = createHash("sha256").update(readFileSync(file)).digest("hex");
+        context[file] = createHash2("sha256").update(readFileSync(file)).digest("hex");
       outgoing.push({ key, sessionId: record.desktopSessionId, cwd, title: record.title });
     }
   } else if (mode === "switch") throw new Error("Configure and verify an initial active roster before switching.");
@@ -1528,7 +1558,7 @@ async function configureClaudePack(options, evaluate = evaluateClaudeMain, quali
       if (!journal.startsWith(realpathSync(directory) + sep)) throw new Error("Recovery journal is outside the owned library.");
       const lines = readFileSync(journal, "utf8").split("\n").filter(Boolean);
       const line = lines[0];
-      if (createHash("sha256").update(line).digest("hex") !== marker.planHash) throw new Error("Recovery plan identity changed.");
+      if (createHash2("sha256").update(line).digest("hex") !== marker.planHash) throw new Error("Recovery plan identity changed.");
       const record = JSON.parse(line);
       if (record.pack !== options.pack || record.operationId !== marker.operationId || !record.apply) throw new Error("Recovery pack or operation identity differs.");
       plan = { ...record, approvalRoutes: record.approvalRoutes ?? [], recovery: true, noEffects: marker.format === 2 && marker.dispatchState === "not-dispatched" && !lines.map((line2) => JSON.parse(line2)).some((r) => r.kind === "attempt") };
@@ -1542,7 +1572,7 @@ async function configureClaudePack(options, evaluate = evaluateClaudeMain, quali
             throw new Error("Unowned native approval connection.");
           const connection = JSON.parse(readFileSync(connectionPath, "utf8"));
           if (connection.pid === options.pid && connection.pack === options.pack && JSON.stringify(connection.routes) === JSON.stringify(plan.approvalRoutes) && JSON.stringify(connection.installationConsent) === JSON.stringify(plan.installationConsent)) {
-            if (typeof connection.secretPath !== "string" || typeof connection.socket !== "string" || !resolve(connection.secretPath).startsWith(realpathSync(resolve(root, "claude/private")) + sep) || realpathSync(connection.secretPath) !== resolve(connection.secretPath) || dirname(resolve(connection.socket)) !== resolve("/tmp", "topolo-claude-pack-" + createHash("sha256").update(root).digest("hex").slice(0, 16)))
+            if (typeof connection.secretPath !== "string" || typeof connection.socket !== "string" || !resolve(connection.secretPath).startsWith(realpathSync(resolve(root, "claude/private")) + sep) || realpathSync(connection.secretPath) !== resolve(connection.secretPath) || dirname(resolve(connection.socket)) !== resolve("/tmp", "topolo-claude-pack-" + createHash2("sha256").update(root).digest("hex").slice(0, 16)))
               throw new Error("Native approval connection is outside owned control paths.");
             const secret = lstatSync(connection.secretPath);
             if (!secret.isFile() || secret.isSymbolicLink() || typeof process.getuid !== "function" || secret.uid !== process.getuid() || secret.mode & 63)
@@ -1553,7 +1583,7 @@ async function configureClaudePack(options, evaluate = evaluateClaudeMain, quali
         if (!plan.control) {
           const directory2 = resolve(root, "claude/private");
           mkdirSync(directory2, { recursive: true, mode: 448 });
-          const socketDirectory = resolve("/tmp", "topolo-claude-pack-" + createHash("sha256").update(root).digest("hex").slice(0, 16));
+          const socketDirectory = resolve("/tmp", "topolo-claude-pack-" + createHash2("sha256").update(root).digest("hex").slice(0, 16));
           mkdirSync(socketDirectory, { recursive: true, mode: 448 });
           for (const path of [directory2, socketDirectory]) {
             const stat = lstatSync(path);
@@ -1568,7 +1598,7 @@ async function configureClaudePack(options, evaluate = evaluateClaudeMain, quali
       journal = resolve(directory, operationId + ".jsonl");
       const record = { kind: "plan", pack: options.pack, ...plan, apply: options.apply };
       durableRecord(journal, record, "wx");
-      marker = { format: 2, dispatchState: "not-dispatched", operationId, journal, planHash: createHash("sha256").update(JSON.stringify(record)).digest("hex") };
+      marker = { format: 2, dispatchState: "not-dispatched", operationId, journal, planHash: createHash2("sha256").update(JSON.stringify(record)).digest("hex") };
       if (options.apply) durableRecord(markerPath, marker, "wx");
       syncDirectory(directory);
       syncDirectory(resolve(root, "claude"));
@@ -1837,8 +1867,9 @@ function prepareClaudeDynamicLane(store, pack, policyPath, laneId) {
   if (lstatSync(file).size > 131072) throw new Error("Dynamic lane record exceeds its schema bound.");
   const record = JSON.parse(readFileSync(file, "utf8"));
   const canonical = (value) => JSON.stringify(value, (_key, item) => item && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.keys(item).sort().map((key) => [key, item[key]])) : item);
-  const digest = (value) => createHash("sha256").update(canonical(value)).digest("hex");
-  if (record.format !== "topolo-dynamic-lane" || record.schemaVersion !== 1 || record.harness !== "claude" || record.laneId !== laneId || record.planDigest !== digest(record.plan) || record.creationReceiptDigest !== digest(record.creationReceipt) || typeof record.nativeTitle !== "string" || !record.nativeTitle || record.nativeTitle.length > 256 || record.plan.role.packId !== pack || record.plan.nativeParentId !== record.plan.intake.nativeId)
+  const digest = (value) => createHash2("sha256").update(canonical(value)).digest("hex");
+  const nativeCLI = record.schemaVersion === 2 && record.plan?.schemaVersion === 2 && record.plan.continuityTransport === "native-cli";
+  if (record.format !== "topolo-dynamic-lane" || !(record.schemaVersion === 1 || nativeCLI) || record.harness !== "claude" || record.laneId !== laneId || record.planDigest !== digest(record.plan) || record.creationReceiptDigest !== digest(record.creationReceipt) || typeof record.nativeTitle !== "string" || !record.nativeTitle || record.nativeTitle.length > 256 || record.plan.role.packId !== pack || (nativeCLI ? record.plan.nativeParentId !== null : record.plan.nativeParentId !== record.plan.intake.nativeId))
     throw new Error("Durable dynamic child identity or plan digest differs.");
   const stateFile = owned(resolve(root, "claude/state.json"));
   const state = JSON.parse(readFileSync(stateFile, "utf8"));
@@ -1847,8 +1878,8 @@ function prepareClaudeDynamicLane(store, pack, policyPath, laneId) {
   if (state.harness !== "claude" || policy.format !== "topolo-agent-execution-policy" || policy.pack !== pack || policy.sourceRevision !== record.plan.role.packRevision || !policy.installationConsent)
     throw new Error("Dynamic child source policy or organization-bound installation is stale.");
   const context = {
-    [stateFile]: createHash("sha256").update(readFileSync(stateFile)).digest("hex"),
-    [policyFile]: createHash("sha256").update(readFileSync(policyFile)).digest("hex")
+    [stateFile]: createHash2("sha256").update(readFileSync(stateFile)).digest("hex"),
+    [policyFile]: createHash2("sha256").update(readFileSync(policyFile)).digest("hex")
   };
   const inventories = {};
   const fixed = (descriptor) => {
@@ -1861,7 +1892,7 @@ function prepareClaudeDynamicLane(store, pack, policyPath, laneId) {
       throw new Error("Dynamic source workspace or current fixed settings differ.");
     const files = [resolve(cwd, "CLAUDE.md"), resolve(cwd, "topolo-connection.json"), resolve(cwd, ".mcp.json")];
     const hashes = {};
-    for (const f of files) hashes[owned(f)] = createHash("sha256").update(readFileSync(f)).digest("hex");
+    for (const f of files) hashes[owned(f)] = createHash2("sha256").update(readFileSync(f)).digest("hex");
     const connection = JSON.parse(readFileSync(files[1], "utf8"));
     const expected = {
       environment: descriptor.environment,
@@ -1898,6 +1929,7 @@ function prepareClaudeDynamicLane(store, pack, policyPath, laneId) {
       planDigest: record.planDigest,
       nativeId: record.nativeId,
       cwd: record.creationReceipt.cwd,
+      ...nativeCLI ? { continuityTransport: "native-cli", continuity: record.plan.continuity } : {},
       title: record.nativeTitle,
       source,
       intake,
@@ -1981,7 +2013,7 @@ function prepareClaudePrivateHelperConnection(store, pack, policyPath, sourceRol
   const policyBytes = readFileSync(policyFile), policy = JSON.parse(policyBytes.toString("utf8")), consent = policy.installationConsent;
   if (!consent || !["development", "staging", "production"].includes(consent.environment) || typeof consent.contextKey !== "string")
     throw new Error("Existing approved per-environment private connection required.");
-  const bindingFile = resolve(root, "connections", pack, consent.environment, createHash("sha256").update(consent.contextKey).digest("hex") + ".json");
+  const bindingFile = resolve(root, "connections", pack, consent.environment, createHash2("sha256").update(consent.contextKey).digest("hex") + ".json");
   const bindingBytes = readFileSync(bindingFile), binding = JSON.parse(bindingBytes.toString("utf8"));
   const connection = {
     format: "topolo-private-helper-connection",
@@ -1991,9 +2023,9 @@ function prepareClaudePrivateHelperConnection(store, pack, policyPath, sourceRol
     sourceRoleKey,
     policyFile,
     bindingFile,
-    policyDigest: createHash("sha256").update(policyBytes).digest("hex"),
-    bindingDigest: createHash("sha256").update(bindingBytes).digest("hex"),
-    stateDigest: createHash("sha256").update(readFileSync(resolve(root, "claude/state.json"))).digest("hex"),
+    policyDigest: createHash2("sha256").update(policyBytes).digest("hex"),
+    bindingDigest: createHash2("sha256").update(bindingBytes).digest("hex"),
+    stateDigest: createHash2("sha256").update(readFileSync(resolve(root, "claude/state.json"))).digest("hex"),
     profile: binding.privateCredentialProfile
   };
   privateClaudeHelperEnvironment(connection, filesystem, cryptography, paths, process.env);
@@ -2025,6 +2057,11 @@ function runClaudeLaneHelper(root, pack, policyPath, action, payload, source, co
     return Promise.reject(new Error("Closed typed native lifecycle helper required."));
   const encoded = JSON.stringify(payload);
   if (Buffer.byteLength(encoded) > 2097152) return Promise.reject(new Error("Own-child native transcript exceeds bounded transport; no broad history read."));
+  try {
+    requireClaudePrivateQueryEffectQualified("helper", payload);
+  } catch (error) {
+    return Promise.reject(error);
+  }
   const selectedRole = payload.sourceRoleKey ?? payload.request?.sourceRoleKey ?? payload.plan?.role?.key ?? payload.operation?.record?.plan?.role?.key;
   if (!connection || root !== connection.root || pack !== connection.pack || policyPath !== connection.policyFile || selectedRole !== void 0 && selectedRole !== connection.sourceRoleKey)
     return Promise.reject(new Error("Private helper arguments differ from the exact bound source connection."));
@@ -2072,7 +2109,14 @@ function runClaudeLaneHelper(root, pack, policyPath, action, payload, source, co
     child.stdin.end(encoded);
   });
 }
-function requireClaudePrivateQueryEffectQualified(operation) {
+function requireClaudePrivateQueryEffectQualified(operation, input) {
+  const candidates = [input, input?.request, input?.plan, input?.record?.plan, input?.operation?.record?.plan];
+  const transports = candidates.map((value) => value?.continuityTransport).filter((value) => value !== void 0);
+  if (transports.some((value) => !["native-cli", "private-mcp"].includes(value)) || new Set(transports).size > 1)
+    throw new Error("Closed explicit continuity transport required; no fallback.");
+  const transport = transports[0];
+  if (transport === "native-cli" || candidates.some((value) => value?.schemaVersion === 2))
+    throw Object.assign(new Error("native_cli_startup_unqualified: current startup, profile refresh authority and native result producers are unavailable."), { code: "native_cli_startup_unqualified" });
   if (["create", "configure", "context-start", "fixture-start", "retire", "approval-once"].includes(operation))
     throw Object.assign(
       new Error("native_private_query_prestart_contract_unqualified: private native query startup, exclusion and owned lifecycle are not qualified."),
@@ -2082,12 +2126,12 @@ function requireClaudePrivateQueryEffectQualified(operation) {
 function claudeLaneExpression(options, source, journal, prepared) {
   if (!Number.isSafeInteger(options.pid) || options.pid < 1 || !["plan", "create", "create-read", "adopt", "read", "configure", "context-start", "context-read", "fixture-start", "fixture-read", "retire"].includes(options.operation))
     throw new Error("Closed typed Claude lane operation required.");
-  requireClaudePrivateQueryEffectQualified(options.operation);
+  requireClaudePrivateQueryEffectQualified(options.operation, options.input);
   if (!options.privateConnection) throw new Error("Explicit approved private helper connection required before native access.");
   return `(async()=>{
     const expected=${JSON.stringify({ ...options, qualifier: CLAUDE_NATIVE_QUALIFIER, source, journal })};
     const requireClaudePrivateQueryEffectQualified=(${requireClaudePrivateQueryEffectQualified.toString()});
-    requireClaudePrivateQueryEffectQualified(expected.operation);
+    requireClaudePrivateQueryEffectQualified(expected.operation,expected.input);
     if(process.pid!==expected.pid || typeof process.getBuiltinModule!=='function')throw new Error('Native process identity changed.');
     const load=process.getBuiltinModule('module').createRequire(process.resourcesPath+'/app.asar/package.json');
     const fs=load('node:fs'),crypto=load('node:crypto'),path=load('node:path');
@@ -2203,7 +2247,7 @@ function claudeLaneExpression(options, source, journal, prepared) {
       if(!secretInfo.isFile()||secretInfo.isSymbolicLink()||secretInfo.uid!==process.getuid()||secretInfo.mode&63)throw new Error('Unowned private native control secret.');
       const secret=JSON.parse(fs.readFileSync(control.secretPath,'utf8'));
       const ownedOperation=async op=>{
-        requireClaudePrivateQueryEffectQualified(op.kind==='approval-respond'&&op.decision==='once'?'approval-once':op.kind);
+        requireClaudePrivateQueryEffectQualified(op.kind==='approval-respond'&&op.decision==='once'?'approval-once':op.kind,{continuityTransport:nativePlan.continuityTransport});
         qualify();const current=await helper('read',{laneId:nativePlan.laneId});
         const scopedPlan={...nativePlan,lifecycleState:current.state,deadline:Date.now()+200000};
         if(op.kind.startsWith('approval-')){
@@ -2270,7 +2314,7 @@ function claudeLaneExpression(options, source, journal, prepared) {
   })()`;
 }
 async function operateClaudeLane(options, evaluate = evaluateClaudeMain) {
-  requireClaudePrivateQueryEffectQualified(options.operation);
+  requireClaudePrivateQueryEffectQualified(options.operation, options.input);
   validateInspectorEndpoint(options.endpoint);
   const root = realpathSync(options.store);
   const policy = realpathSync(options.policy);
@@ -2285,6 +2329,7 @@ async function operateClaudeLane(options, evaluate = evaluateClaudeMain) {
     const journal = resolve(directory, randomUUID() + ".jsonl");
     durableRecord(journal, { operation: options.operation, pid: options.pid, at: Date.now() }, "wx");
     const prepared = ["plan", "create", "create-read", "adopt"].includes(options.operation) ? void 0 : prepareClaudeDynamicLane(root, options.pack, policy, options.input.laneId);
+    if (prepared?.record.plan.continuityTransport === "native-cli") requireClaudePrivateQueryEffectQualified(options.operation, prepared.record.plan);
     let sourceRoleKey = prepared?.record.plan.role.key ?? (options.operation === "plan" ? options.input.request?.sourceRoleKey : options.input.plan?.role?.key);
     if (["create", "create-read"].includes(options.operation)) {
       if (typeof options.input.laneId !== "string" || !/^[a-z0-9][a-z0-9-]*$/.test(options.input.laneId)) throw new Error("Exact existing creation lane required.");
@@ -2307,8 +2352,8 @@ async function operateClaudeLane(options, evaluate = evaluateClaudeMain) {
       mkdirSync(directory2, { mode: 448 });
       const secretPath = resolve(directory2, "secret.json");
       durableRecord(secretPath, { token: randomBytes(32).toString("hex") }, "wx");
-      const identity = createHash("sha256").update(JSON.stringify({ pid: options.pid, laneId, planDigest: prepared.record.planDigest, qualifier: CLAUDE_NATIVE_QUALIFIER })).digest("hex");
-      const socketDirectory = resolve("/tmp", "topolo-claude-" + process.getuid?.() + "-" + createHash("sha256").update(root + "\0" + laneId).digest("hex").slice(0, 24));
+      const identity = createHash2("sha256").update(JSON.stringify({ pid: options.pid, laneId, planDigest: prepared.record.planDigest, qualifier: CLAUDE_NATIVE_QUALIFIER })).digest("hex");
+      const socketDirectory = resolve("/tmp", "topolo-claude-" + process.getuid?.() + "-" + createHash2("sha256").update(root + "\0" + laneId).digest("hex").slice(0, 24));
       mkdirSync(socketDirectory, { mode: 448 });
       const socket = resolve(socketDirectory, "control.sock");
       control = { socket, secretPath, identity };
@@ -2335,7 +2380,7 @@ async function operateClaudeLane(options, evaluate = evaluateClaudeMain) {
   }
 }
 function operateClaudeLaneControl(options, request = requestClaudeApprovalControl) {
-  requireClaudePrivateQueryEffectQualified(options.operation.kind === "approval-respond" && options.operation.decision === "once" ? "approval-once" : options.operation.kind);
+  requireClaudePrivateQueryEffectQualified(options.operation.kind === "approval-respond" && options.operation.decision === "once" ? "approval-once" : options.operation.kind, options.operation);
   if (!/^[a-z0-9][a-z0-9-]*$/.test(options.connection)) throw new Error("Exact owned native lane connection ID required.");
   const root = realpathSync(options.store);
   const directory = resolve(root, "claude/dynamic-controls", options.connection);

package/dist/index.js

@@ -14,7 +14,7 @@ function registerAgentPacksCommand(program2) {
       throw new Error("Exact closed smoke operation, role/case and UUID required.");
     const store = packs.opts().store ?? resolve(homedir(), "AgentPacks");
     if (options.harness === "claude") {
-      const { operateClaudeSmoke } = await import("./claude-pack-backend-RMSOPHVQ.js");
+      const { operateClaudeSmoke } = await import("./claude-pack-backend-YEVPAOID.js");
       console.log(JSON.stringify(await operateClaudeSmoke({
         store,
         kind: "smoke-" + operation,
@@ -44,7 +44,7 @@ function registerAgentPacksCommand(program2) {
   });
   packs.command("configure").description("Qualify and configure an adopted Claude roster through its live native backend").argument("<pack>").option("--harness <name>", "Host adapter", "claude").requiredOption("--policy <path>", "Reviewed execution policy JSON").requiredOption("--endpoint <url>", "Explicit loopback main-process inspector endpoint, enabled separately with authorization").requiredOption("--pid <pid>", "Expected Claude main-process PID").option("--apply", "Apply native groups, pins, models, effort and permission modes; otherwise preflight only").action(async (pack, options) => {
     if (options.harness !== "claude") throw new Error("Native configure is currently qualified only for Claude Desktop.");
-    const { configureClaudePack } = await import("./claude-pack-backend-RMSOPHVQ.js");
+    const { configureClaudePack } = await import("./claude-pack-backend-YEVPAOID.js");
     const result = await configureClaudePack({
       store: packs.opts().store ?? resolve(homedir(), "AgentPacks"),
       pack,
@@ -92,7 +92,7 @@ function registerAgentPacksCommand(program2) {
             throw new Error("Closed existing Claude lane control operation required.");
           const input3 = options.input ? JSON.parse(readFileSync(options.input, "utf8")) : {};
           if (!input3 || typeof input3 !== "object" || Array.isArray(input3) || Object.keys(input3).some((k) => k !== "operationId")) throw new Error("Only an exact bootstrap/fixture operation UUID may be supplied.");
-          const { operateClaudeLaneControl } = await import("./claude-pack-backend-RMSOPHVQ.js");
+          const { operateClaudeLaneControl } = await import("./claude-pack-backend-YEVPAOID.js");
           console.log(JSON.stringify(await operateClaudeLaneControl({
             store: packs.opts().store ?? resolve(homedir(), "AgentPacks"),
             connection: options.connection,
@@ -104,7 +104,7 @@ function registerAgentPacksCommand(program2) {
           throw new Error("Closed Claude lane operation requires --input, --pack, --policy, --endpoint and --pid.");
         const input2 = JSON.parse(readFileSync(options.input, "utf8"));
         if (!input2 || typeof input2 !== "object" || Array.isArray(input2)) throw new Error("Closed native lane input object required.");
-        const { operateClaudeLane } = await import("./claude-pack-backend-RMSOPHVQ.js");
+        const { operateClaudeLane } = await import("./claude-pack-backend-YEVPAOID.js");
         console.log(JSON.stringify(await operateClaudeLane({
           store: packs.opts().store ?? resolve(homedir(), "AgentPacks"),
           pack: options.pack,
@@ -130,7 +130,7 @@ function registerAgentPacksCommand(program2) {
           decision = response.decision;
         }
         if (options.connection) {
-          const { operateClaudeLaneControl } = await import("./claude-pack-backend-RMSOPHVQ.js");
+          const { operateClaudeLaneControl } = await import("./claude-pack-backend-YEVPAOID.js");
           console.log(JSON.stringify(await operateClaudeLaneControl({
             store: packs.opts().store ?? resolve(homedir(), "AgentPacks"),
             connection: options.connection,
@@ -142,7 +142,7 @@ function registerAgentPacksCommand(program2) {
           }), null, 2));
           return;
         }
-        const { operateClaudeApprovals } = await import("./claude-pack-backend-RMSOPHVQ.js");
+        const { operateClaudeApprovals } = await import("./claude-pack-backend-YEVPAOID.js");
         console.log(JSON.stringify(await operateClaudeApprovals({
           store: packs.opts().store ?? resolve(homedir(), "AgentPacks"),
           kind: args[0],
@@ -157,7 +157,7 @@ function registerAgentPacksCommand(program2) {
       if (name !== "lane" && (options.policy || options.endpoint || options.pid || options.apply)) {
         if (options.harness !== "claude" || !options.policy || !options.endpoint || !options.pid || args.length !== 1)
           throw new Error("Native switch/recovery requires one Claude pack, --policy, --endpoint and --pid.");
-        const { configureClaudePack } = await import("./claude-pack-backend-RMSOPHVQ.js");
+        const { configureClaudePack } = await import("./claude-pack-backend-YEVPAOID.js");
         const result2 = await configureClaudePack({
           store: packs.opts().store ?? resolve(homedir(), "AgentPacks"),
           pack: args[0],

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@topolo/cli",
   "packageManager": "pnpm@10.17.1",
-  "version": "0.13.10",
-  "topoloPublishedVersion": "0.13.10",
+  "version": "0.13.11",
+  "topoloPublishedVersion": "0.13.11",
   "description": "Public command-line interface for Topolo customer organizations, developers, and agents.",
   "license": "UNLICENSED",
   "author": "Topolo",