@topolo/cli 0.13.19 → 0.13.22

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

@@ -275,7 +275,7 @@ def request(lib,operation,params=None):
     record=read_json(lib.root/'live-bridge.json',{})
     if not record: raise PackError('This desktop profile has no live bridge. Open it through topolo-agent-pack first.')
     with socket.socket(socket.AF_UNIX,socket.SOCK_STREAM) as connection:
-        connection.settimeout(3 if operation=='status' else 240 if operation.startswith('lane-') else 60 if operation in {'permissions-configure','owned-roster-read','smoke-start'} else 20)
+        connection.settimeout(3 if operation=='status' else 240 if operation.startswith('lane-') or operation in {'work-submit','work-respond','work-re-review'} else 60 if operation in {'permissions-configure','owned-roster-read','smoke-start'} else 20)
         try: connection.connect(record['socket'])
         except OSError as exc: raise PackError('Managed live bridge is unavailable: '+str(exc)) from exc
         connection.sendall(canonical({'token':record['token'],'operation':operation,**({'params':params} if params is not None else {})})+b'\n')
@@ -310,6 +310,7 @@ class BackendProxy:
         self.token=secrets.token_hex(32);self.path=socket_path(lib)
         self.execution=None;self.catalog_ready=asyncio.Event();self.catalog_id='topolo-catalog-'+uuid.uuid4().hex
         self.catalog_rows=[];self.catalog_cursors=set()
+        self.work=None;self.work_startup_error=None;self.work_initialization=None
         self.approvals=None;self.native_calls={};self.notifications=set()
         self.permission_configuration=False
         self.permission_batch=None
@@ -328,6 +329,15 @@ class BackendProxy:
         if not active.get('runtime'): raise PackError('No selected managed runtime')
         self.runtime=active['runtime'];env=os.environ.copy()
         self.execution=load_gate(self.runtime);self.catalog_ready.clear()
+        self.work=None;self.work_startup_error=None;initialize_work=False
+        if (self.lib.root/'work/config.json').is_file():
+            if (self.lib.root/'work/cutover.json').exists() and not (self.lib.root/'work/cloud.json').exists():
+                # A closed legacy ledger cannot initialize a broker. Native policy
+                # and history reads remain available; model work stays fenced.
+                self.work_startup_error='Legacy task authority is fenced; attach this installation to the existing cloud authority before dispatch'
+            else:
+                initialize_work=True
+                self.work_startup_error='Task dispatcher initialization is pending; native task execution is unavailable'
         self.approvals=ApprovalRouter(pathlib.Path(self.runtime)/'approval-inbox',
             list(self.execution.roles.values()),uuid.uuid4().hex) if self.execution else None
         self.catalog_rows=[];self.catalog_cursors=set()
@@ -335,6 +345,18 @@ class BackendProxy:
         env['CODEX_HOME']=str(pathlib.Path(self.runtime)/'home');env['CODEX_CLI_PATH']=self.real
         self.child=await asyncio.create_subprocess_exec(self.real,*self.args,env=env,stdin=asyncio.subprocess.PIPE,stdout=asyncio.subprocess.PIPE,limit=64*1024*1024)
         self.output_task=asyncio.create_task(self.output())
+        if initialize_work:self.work_initialization=asyncio.create_task(self.initialize_work())
+
+    async def initialize_work(self):
+        # Native organization-policy bootstrap must not depend on cloud latency.
+        # The explicit admission error remains until every broker check passes.
+        try:
+            from .work_native import Broker
+            broker=Broker(self);await broker.initialize()
+            self.work=broker;self.work_startup_error=None
+            if self.initialized:self.work.launch(self.work.resume_ready())
+        except Exception as exc:
+            self.work=None;self.work_startup_error=str(exc) or 'Task dispatcher initialization failed'
 
     async def output(self):
         while line:=await self.child.stdout.readline():
@@ -362,15 +384,24 @@ class BackendProxy:
                                        {**self.execution.status(),'protocol':self.protocol})
             if 'id' in value and ('result' in value or 'error' in value):
                 self.pending.discard(str(value['id']))
-                if 'result' in value and isinstance(value['result'],dict) and 'userAgent' in value['result']: self.initialized=True
+                if 'result' in value and isinstance(value['result'],dict) and 'userAgent' in value['result']:
+                    self.initialized=True
+                    if self.work:self.work.launch(self.work.resume_ready())
             method=value.get('method');params=value.get('params') or {}
+            if method=='account/updated' and self.execution:
+                self.execution.catalog={};self.catalog_ready.clear()
             if self.approvals:
                 record=self.approvals.capture(value)
                 if record:self.dynamic_permission_event(record)
                 if record and record['sourceThreadId']!=record['intakeThreadId'] and record['notificationState']!='delivered':
                     self.schedule_notification(record)
+            if method in {'turn/started','turn/completed','thread/status/changed'} and getattr(self,'work',None):
+                self.work.launch(self.work.notify())
+            if method=='item/completed' and getattr(self,'work',None):self.work.launch(self.work.progress(params))
             if method=='turn/started': self.active_turns.add(params['threadId'])
             if method=='turn/completed': self.active_turns.discard(params['threadId'])
+            if method=='turn/completed' and getattr(self,'work',None):
+                self.work.completed(params['threadId'],params['turn'])
             if method=='thread/status/changed':
                 if params.get('status',{}).get('type')=='active':self.active_turns.add(params['threadId'])
                 elif params.get('status',{}).get('type') in {'idle','notLoaded','systemError'}:self.active_turns.discard(params['threadId'])
@@ -378,9 +409,20 @@ class BackendProxy:
                     for row in self.approvals.records():
                         if row['nativeConnectionCurrent'] and row['intakeThreadId']==params['threadId'] and row['notificationState']!='delivered':
                             self.schedule_notification(row)
+            if method in {'turn/started','turn/completed','thread/status/changed'} and getattr(self,'work',None):
+                from .coordinator_activity import record as record_activity
+                try:
+                    record_activity(self.lib.root,{'runtime':self.runtime,'activeTurns':sorted(self.active_turns)})
+                    self.activity_error=None
+                except Exception as exc:self.activity_error=str(exc)
             if self.emit_native:sys.stdout.buffer.write(line);sys.stdout.buffer.flush()
 
     async def stop_child(self):
+        if self.work_initialization:
+            self.work_initialization.cancel()
+            try:await self.work_initialization
+            except asyncio.CancelledError:pass
+            self.work_initialization=None
         if self.child and self.child.returncode is None:
             self.child.terminate()
             try: await asyncio.wait_for(self.child.wait(),5)
@@ -390,13 +432,13 @@ class BackendProxy:
         if self.output_task: await self.output_task
 
     async def forward(self,value):
-        if self.smoke_busy and value.get('method') in {'thread/resume','turn/start'}:
+        if self.smoke_busy and value.get('method') in {'thread/resume','turn/start','turn/steer'}:
             sys.stdout.buffer.write(canonical({'id':value.get('id'),'error':{'code':-32000,
                 'message':'Owned native smoke dispatch is being qualified'}})+b'\n');sys.stdout.buffer.flush();return
-        if self.permission_configuration and value.get('method') in {'thread/resume','turn/start'}:
+        if self.permission_configuration and value.get('method') in {'thread/resume','turn/start','turn/steer'}:
             sys.stdout.buffer.write(canonical({'id':value.get('id'),'error':{'code':-32000,'message':'Owned permission configuration in progress'}})+b'\n')
             sys.stdout.buffer.flush();return
-        if value.get('method') in {'thread/resume','turn/start'} and (pathlib.Path(self.runtime)/'permissions-operation.json').exists():
+        if value.get('method') in {'thread/resume','turn/start','turn/steer'} and (pathlib.Path(self.runtime)/'permissions-operation.json').exists():
             sys.stdout.buffer.write(canonical({'id':value.get('id'),'error':{'code':-32000,
                 'message':'Unresolved native permission operation requires reconciliation before execution'}})+b'\n')
             sys.stdout.buffer.flush();return
@@ -404,11 +446,16 @@ class BackendProxy:
             if 'id' in value:
                 sys.stdout.buffer.write(canonical({'id':value['id'],'error':{'code':-32000,'message':'Pack switch in progress; reconnecting backend'}})+b'\n');sys.stdout.buffer.flush()
             return
-        if self.execution and value.get('method') in {'thread/resume','turn/start'} and (value.get('params') or {}).get('threadId') in self.execution.roles:
+        if self.execution and value.get('method') in {'thread/resume','turn/start','turn/steer'} and (value.get('params') or {}).get('threadId') in self.execution.roles:
             try:
+                if value.get('method') in {'turn/start','turn/steer'} and self.work_startup_error:
+                    raise PackError(self.work_startup_error)
                 await self.qualify_organization((value.get('params') or {})['threadId'])
-                await asyncio.wait_for(self.catalog_ready.wait(),10)
+                await self.ensure_catalog()
+                value=await self.qualify_resume_path(value)
                 value=self.execution.prepare(value)
+                if value.get('method') in {'turn/start','turn/steer'} and getattr(self,'work',None):
+                    value=await self.work.frontdoor(value)
             except (PackError,asyncio.TimeoutError) as exc:
                 sys.stdout.buffer.write(canonical({'id':value.get('id'),'error':{'code':-32000,'message':str(exc) or 'Native model catalog unavailable'}})+b'\n');sys.stdout.buffer.flush();return
         if 'id' in value and 'method' in value:self.pending.add(str(value['id']))
@@ -429,6 +476,32 @@ class BackendProxy:
             'params':{'includeHidden':True,**({'cursor':cursor} if cursor else {})}})+b'\n')
         await self.child.stdin.drain()
 
+    async def ensure_catalog(self):
+        # Some desktop clients do not send the optional initialized notification
+        # that primes our private catalog request. Qualify on the owning native
+        # connection before resume instead of waiting for an event never sent.
+        if not self.catalog_ready.is_set():
+            result=await self.read_catalog()
+            self.execution.set_catalog(result)
+            self.catalog_ready.set()
+        # Preserve the native event-loop readiness fence: queued approvals or
+        # work notifications must be observed before a configuration effect.
+        await asyncio.wait_for(self.catalog_ready.wait(),10)
+
+    async def qualify_resume_path(self,value):
+        params=value.get('params') or {}
+        if value.get('method')!='thread/resume' or params.get('path') is None:return value
+        role=self.execution.roles[params['threadId']]
+        result=await self.call_native('thread/read',{'threadId':params['threadId'],'includeTurns':False})
+        thread=result.get('thread',{})
+        if (thread.get('id')!=params['threadId'] or thread.get('cwd')!=role['cwd'] or
+            not isinstance(thread.get('path'),str) or params['path']!=thread['path']):
+            raise PackError('Frontend resume path differs from the native owned thread')
+        # Resume by verified identity. Never allow a caller path to select a
+        # different history or change the reviewed execution settings.
+        value={**value,'params':{k:v for k,v in params.items() if k!='path'}}
+        return value
+
     async def call_native(self,method,params,before_dispatch=None):
         if self.managed_transport:
             return await self.call_managed_native(method,params,before_dispatch)
@@ -438,7 +511,7 @@ class BackendProxy:
             if not self.permission_configuration and (pathlib.Path(self.runtime)/'permissions-operation.json').exists():
                 raise PackError('Unresolved native permission operation requires reconciliation before execution')
             await self.qualify_organization(params['threadId'])
-            await asyncio.wait_for(self.catalog_ready.wait(),10)
+            await self.ensure_catalog()
             if self.permission_configuration:
                 if self._permission_configuration_inputs is None:
                     raise PackError('No owned permission configuration snapshot; native settings were not sent')
@@ -621,7 +694,7 @@ class BackendProxy:
         from . import topolo
         consent=role['installationConsent']
         agents=self.lib.load(consent['pack'])[0]['agents']
-        matches=[a for a in agents if '/'.join([a['pack'],a['set'],a['id']])==role.get('sourceRoleKey',role['key']) and a['threadId']==role.get('sourceRoleNativeId',role['threadId'])]
+        matches=[a for a in agents if '/'.join([a['pack'],a['set'],a['id']])==role.get('sourcePermissionRoleKey',role.get('sourceRoleKey',role['key'])) and a['threadId']==role.get('sourceRoleNativeId',role['threadId'])]
         if len(matches)!=1:
             raise PackError('Current consent has no unique live owned role')
         effective_consent=consent
@@ -663,6 +736,9 @@ class BackendProxy:
         declared={(r['key'],r['threadId']) for r in document['roles']}
         with closing(sqlite3.connect('file:'+str(pathlib.Path(self.runtime)/'home/state_5.sqlite')+'?mode=ro',uri=True)) as db:
             native_ids=[r[0] for r in db.execute('SELECT id FROM threads')]
+        if getattr(self,'work',None):
+            task_ids=self.work.native_ids
+            native_ids=[tid for tid in native_ids if tid not in task_ids]
         from .lanes import Registry
         dynamic=[r for r in Registry(self.lib.root,'codex').records() if r['state']!='retired']
         dynamic_ids={r['nativeId'] for r in dynamic}
@@ -1332,7 +1408,11 @@ class BackendProxy:
                 'nativeTransport':'existing-managed-window' if self.managed_transport else 'owned-stdio',
                 'managedTargetId':self.managed_transport.target_id if self.managed_transport else None,
                 'quiesced':self.quiesced,'initialized':self.initialized,
-                'activeTurns':sorted(self.active_turns),'pendingRequests':len(self.pending),
+                'activeTurns':sorted(self.active_turns),'pendingRequests':len(self.pending),'activityError':getattr(self,'activity_error',None),'workStartupError':getattr(self,'work_startup_error',None),
+                'backendHealth':{'childReturnCode':getattr(self.child,'returncode',None),
+                    'responseReaderDone':self.output_task.done() if self.output_task else None,
+                    'catalogReady':self.catalog_ready.is_set(),
+                    'catalogModels':len(self.execution.catalog) if self.execution else 0},
                 'executionPolicy':self.execution.status() if self.execution else {'state':'not-configured'},
                 'executionProtocol':self.protocol if self.execution else None}
 
@@ -1364,8 +1444,10 @@ class BackendProxy:
                     raise PackError('Outgoing agents have active turns. Wait for their current turns; Codex can stay open.')
                 if self.pending:
                     raise PackError('Backend requests are in flight. Retry the switch; Codex can stay open.')
-                self.quiesced=True
-                await self.stop_child()
+                if getattr(self,'work',None):await self.work.quiesce()
+                else:
+                    self.quiesced=True
+                    await self.stop_child()
             elif op=='resume':
                 if self.quiesced:
                     raise PackError('Use the desktop reconnect action to resume a quiesced bridge')
@@ -1386,8 +1468,48 @@ class BackendProxy:
                 self.lane_close_event.set();result={'state':'normal-own-connection-close-requested'}
             elif op in {'lane-plan','lane-adopt','lane-configure','lane-read','lane-settle','lane-retire'}:
                 result=await self.dynamic_lane(op,message.get('params') or {})
+            elif op=='desktop-acceptance':
+                from .desktop_acceptance import run
+                result=await run(self,message.get('params') or {})
             elif op=='owned-roster-read':
                 result=await self.owned_roster_read(message.get('params') or {})
+            elif op.startswith('work-'):
+                if not self.work:
+                    raise PackError(self.work_startup_error or 'Task dispatch is not installed on this owning connection')
+                params=message.get('params') or {}
+                if self.quiesced and op not in {'work-list','work-read','work-retained','work-watch','work-cutover-status'}:
+                    raise PackError('Native task admission is quiesced for cutover')
+                if op=='work-cutover' and not params:
+                    result=await self.work.quiesce(cutover=True)
+                elif op=='work-cutover-status' and not params:
+                    if not self.quiesced:raise PackError('Native cutover is not quiesced')
+                    from .cloud_cutover import closure
+                    if self.work.cutover_closure!=closure():raise PackError('Executing native cutover source changed')
+                    if self.work.cutover_record is None or read_json(self.work.store.root/'cutover.json')!=self.work.cutover_record:raise PackError('Native cutover acknowledgement changed')
+                    result=self.work.cutover_record
+                elif op=='work-submit':
+                    result=await self.work.submit(params)
+                elif op=='work-adoption-plan':
+                    result=await self.work.adoption_plan(params)
+                elif op=='work-adopt':
+                    result=await self.work.adopt_retained(params)
+                elif op=='work-respond':
+                    result=await self.work.respond(params)
+                elif op=='work-re-review':
+                    result=await self.work.re_review(params)
+                elif op=='work-list' and not params:
+                    result=await self.work.snapshot()
+                elif op=='work-read' and set(params)=={'taskId'}:
+                    result=await self.work.read(params['taskId'])
+                elif op=='work-retained':
+                    result=await self.work.state_call('retained_page',params)
+                elif op=='work-reconcile-unstarted':
+                    result=await self.work.reconcile_unstarted(params)
+                elif op=='work-reconcile-route':
+                    result=await self.work.reconcile_route(params)
+                elif op=='work-watch' and not params:
+                    await self.work.watch(reader,writer);return
+                else:raise PackError('Unsupported bounded work operation')
             elif op in {'smoke-start','smoke-read'}:
                 result=await self.owned_smoke(op,message.get('params') or {})
             elif op=='permissions-configure':
@@ -1419,7 +1541,7 @@ class BackendProxy:
                         result={'state':'native-response-forwarded','operationEffectVerified':False}
             elif op!='status':
                 raise PackError('Unknown live bridge operation')
-            if op not in {'lane-context-start','lane-context-read','lane-fixture-start','lane-fixture-read','lane-create','lane-close','lane-plan','lane-adopt','lane-configure','lane-read','lane-settle','lane-retire','approval-list','approval-details','approval-respond','permissions-configure','owned-roster-read','smoke-start','smoke-read'}:
+            if not op.startswith('work-') and op not in {'lane-context-start','lane-context-read','lane-fixture-start','lane-fixture-read','lane-create','lane-close','lane-plan','lane-adopt','lane-configure','lane-read','lane-settle','lane-retire','approval-list','approval-details','approval-respond','permissions-configure','owned-roster-read','desktop-acceptance','smoke-start','smoke-read'}:
                 result=self.status()
         except Exception as exc: result={'error':str(exc)}
         writer.write(canonical(result)+b'\n');await writer.drain();writer.close();await writer.wait_closed()
@@ -1889,6 +2011,93 @@ def managed_lane_frontend(lib,runtime,planned,native_id=None,app='/Applications/
         return {**result,'targetId':target,'selectedRuntime':str(root),'capability':capability,'proxyGeneration':generation}
     finally:ws.close()
 
+def bind_sidebar(lib,runtime,app='/Applications/ChatGPT.app',presentation_journal=None,reconcile=None,reconnect_atoms=None):
+    """Existing managed manager, genuine account, guarded journaled presentation."""
+    from . import native
+    root=pathlib.Path(runtime);home=root/'home'
+    generation=managed_backend_generation(lib,str(root))
+    homes=[str(home)];layout=lib.root/'desktop-layout.json';stable=lib.root/'desktop-home'
+    layout_hash=None
+    if layout.exists():
+        OwnedSmoke.owned(layout);OwnedSmoke.owned(stable,directory=True)
+        if read_json(layout).get('owner') not in {'topolo-agent-pack','codex-pack'}:
+            raise PackError('Stable sidebar layout owner differs')
+        selected=lib.root/'selected-runtime'
+        if not selected.is_symlink() or selected.resolve()!=root.resolve():
+            raise PackError('Stable sidebar selected runtime differs')
+        for name in ['config.toml','state_5.sqlite','sessions']:
+            target=stable/name
+            if not target.is_symlink() or os.readlink(target)!=str(pathlib.Path('..')/'selected-runtime'/'home'/name):
+                raise PackError('Stable sidebar execution route differs')
+        homes.append(str(stable));layout_hash=hashlib.sha256(layout.read_bytes()).hexdigest()
+    capability=adapter(app);ws,_=renderer(lib)
+    try:
+        params={'adapter':capability,'homes':homes,'configFile':str(home/'config.toml'),'cwd':str(home)}
+        expression="""(async()=>{
+          const p=PARAMS,services=(await import(p.adapter.module))[p.adapter.export];
+          const opened=await services.appServerManagers.open('local');
+          if(opened?.status!=='ready'||!opened.manager)throw new Error('Existing managed backend unavailable');
+          const manager=opened.manager,home=await manager.getCodexHome();
+          if(typeof home!=='string'||!p.homes.includes(home))throw new Error('Selected sidebar home changed');
+          const config=await manager.sendRequest('config/read',{cwd:p.cwd,includeLayers:true});
+          const origins=config?.layers?.filter(layer=>layer.name?.type==='user'&&!layer.disabledReason);
+          if(!Array.isArray(origins)||!origins.length||origins.some(layer=>layer.name.file!==p.configFile||typeof layer.version!=='string'||!layer.version))throw new Error('Selected sidebar config provenance changed');
+          const a=await manager.sendRequest('account/read',{refreshToken:false});
+          if(await manager.getCodexHome()!==home)throw new Error('Selected sidebar home changed');
+          return {requiresOpenaiAuth:a.requiresOpenaiAuth,account:a.account?{type:a.account.type}:null,
+            workspaceRouting:a.workspaceRouting?{chatgptAccountId:a.workspaceRouting.chatgptAccountId}:null,
+            _nativeContext:{home,configOrigins:origins.map(layer=>({name:layer.name,version:layer.version}))}};
+        })()""".replace('PARAMS',json.dumps(params),1)
+        account=ws.evaluate(expression);binding=native.sidebar_binding(root,account)
+        origin=account.get('_nativeContext') if isinstance(account,dict) else None
+        if not isinstance(origin,dict) or origin.get('home') not in homes or not origin.get('configOrigins'):
+            raise PackError('Actual managed sidebar provenance missing')
+        context={'kind':'managed','app':app,'home':origin['home'],'configOrigins':origin['configOrigins'],
+                 'account':{'type':(account.get('account') or {}).get('type'),'accountId':binding['accountId'],
+                 'requiresOpenaiAuth':account['requiresOpenaiAuth']},'generation':generation,'layoutSHA256':layout_hash}
+        def guard():
+            if ws.evaluate(expression)!=account:raise PackError('Selected sidebar account/home/config changed')
+            if managed_backend_generation(lib,str(root))!=generation:raise PackError('Selected sidebar backend changed')
+            if layout_hash is not None:
+                if hashlib.sha256(layout.read_bytes()).hexdigest()!=layout_hash or (lib.root/'selected-runtime').resolve()!=root.resolve():
+                    raise PackError('Stable sidebar route/layout changed')
+                for name in ['config.toml','state_5.sqlite','sessions']:
+                    target=stable/name
+                    if not target.is_symlink() or os.readlink(target)!=str(pathlib.Path('..')/'selected-runtime'/'home'/name):
+                        raise PackError('Stable sidebar route changed')
+            return context
+        guard()
+        current=fetch(ws,'get-global-state',{'key':'electron-persisted-atom-state'}).get('value') or {}
+        if reconcile is not None:
+            path,document=reconcile
+            return native.reconcile_sidebar(lib,path,document,guard(),current,guard)
+        sections=dict(current.get('sidebar-custom-sections-v3',{}));sections.update(binding['sections'])
+        # set-global-state replaces the whole value for its key. Reconnect must
+        # not send a filtered container early: that would erase live account
+        # presentation. Merge ordinary runtime atoms only inside this guarded,
+        # journaled write; destination sections/pins come exclusively from the
+        # fresh managed account, never the captured/offline runtime account.
+        ordinary={k:v for k,v in (reconnect_atoms or {}).items()
+                  if k not in {'sidebar-custom-sections-v3','unified-sidebar-pinned-order-v1'}}
+        value={**current,**ordinary,'sidebar-custom-sections-v3':sections,'unified-sidebar-pinned-order-v1':binding['pins']}
+        report={k:v for k,v in binding.items() if k not in {'sections','pins'}}
+        # There is no qualified identity-bound/CAS setter here. Journal the
+        # unavoidable mid-dispatch uncertainty rather than claiming atomicity.
+        mutation=native.SidebarJournal(lib,root,context,current,value,report,parent=presentation_journal)
+        try:
+            guard()  # AFTER awaited settings read and durable intent, BEFORE setter.
+            mutation.dispatched=True
+            if not fetch(ws,'set-global-state',{'key':'electron-persisted-atom-state','value':value}).get('success'):
+                raise PackError('Desktop refused sidebar binding')
+            actual=fetch(ws,'get-global-state',{'key':'electron-persisted-atom-state'}).get('value')
+            if actual!=value:raise PackError('Desktop sidebar read-back differs')
+            guard();atomic_json(root/'sidebar-binding.json',report)
+            if read_json(root/'sidebar-binding.json')!=report:raise PackError('Sidebar report read-back differs')
+            guard();mutation.complete();return report
+        except BaseException as error:
+            mutation.failed(error);raise
+    finally:ws.close()
+
 def checkpoint_ui(lib,runtime):
     ws,_=renderer(lib)
     try:
@@ -1907,15 +2116,26 @@ def reconcile(ws,capability,incoming,outgoing):
     params=json.dumps({'adapter':capability,'incoming':incoming,'outgoing':outgoing})
     return ws.evaluate('''(async()=>{const p=PARAMS;const c=(await import(p.adapter.module))[p.adapter.export]?.localThreadCatalog;if(!c)throw new Error('Catalog capability unavailable');for(const threadId of p.outgoing)await c.removeMissingEntry({hostId:'local',threadId});for(const threadId of p.incoming)await c.notifyThread({hostId:'local',threadId},'upsert');await c.invalidateSource('local');await c.requestSync(['local'],'immediate');let proof;const deadline=Date.now()+15000;do{const entries=await c.readEntries(p.incoming.map(threadId=>({hostId:'local',threadId})));const missing=await c.readEntries(p.outgoing.map(threadId=>({hostId:'local',threadId})));proof={incoming:entries.map(e=>e.threadId),titles:entries.map(e=>e.displayTitle),outgoing:missing.map(e=>e.threadId),count:await c.readThreadCount('local')};if(proof.incoming.length===p.incoming.length&&!proof.outgoing.length&&proof.count===p.incoming.length)return proof;await new Promise(r=>setTimeout(r,50))}while(Date.now()<deadline);return proof})()'''.replace('PARAMS',params,1))
 
-def reconnect(lib,runtime,previous_runtime=None,app='/Applications/ChatGPT.app'):
+def reconnect(lib,runtime,previous_runtime=None,app='/Applications/ChatGPT.app',presentation_journal=None):
     ws,target_id=renderer(lib)
     try:
+        if presentation_journal is None:
+            raise PackError('Reconnect presentation requires its original transaction journal')
+        jpath,jdocument=presentation_journal
+        targets={jdocument.get('targetRuntime'),jdocument.get('before',{}).get('runtime'),jdocument.get('after',{}).get('runtime')}
+        if pathlib.Path(jpath).parent!=lib.root/'journals' or read_json(jpath)!=jdocument or str(runtime) not in targets or jdocument.get('phase') in {'complete','rolled-back'}:
+            raise PackError('Reconnect presentation transaction changed')
+        if jdocument.get('sidebar',{}).get('state') in {'UNKNOWN','may-have-effects'}:
+            raise PackError('Pending sidebar effects require original owner reconciliation')
         current_bridge=available(lib)
         if current_bridge and not current_bridge['quiesced']:quiesce(lib)
         capability=adapter(app);bind(lib,runtime)
         gs=read_json(pathlib.Path(runtime)/'home'/'.codex-global-state.json')
-        current=fetch(ws,'get-global-state',{'key':'electron-persisted-atom-state'}).get('value') or {}
-        updates={**gs,'electron-persisted-atom-state':{**current,**gs.get('electron-persisted-atom-state',{})}}
+        # Defer the entire atom container. The native API replaces a key's
+        # value; removing nested presentation keys here would still erase them.
+        # Its ordinary atoms join the post-restart guarded binder below.
+        runtime_atoms=gs.get('electron-persisted-atom-state',{})
+        updates={key:value for key,value in gs.items() if key!='electron-persisted-atom-state'}
         for key,value in updates.items():
             result=fetch(ws,'set-global-state',{'key':key,'value':value})
             if not result.get('success'): raise PackError('Desktop refused state update: '+key)
@@ -1927,6 +2147,7 @@ def reconnect(lib,runtime,previous_runtime=None,app='/Applications/ChatGPT.app')
             if bridge and not bridge['quiesced'] and bridge['runtime']==str(runtime) and bridge['initialized']:break
             time.sleep(0.05)
         else:raise PackError('Managed backend did not reconnect; run topolo-agent-pack recover')
+        sidebar_binding=bind_sidebar(lib,runtime,app,presentation_journal=presentation_journal,reconnect_atoms=runtime_atoms)
         proof=reconcile(ws,capability,incoming,outgoing)
         if set(proof['incoming'])!=set(incoming) or proof['outgoing'] or proof['count']!=len(incoming):raise PackError('Sidebar catalog did not match selected runtime; run recover')
         # Soft reload clears thread/composer caches while retaining this exact
@@ -1949,9 +2170,42 @@ def reconnect(lib,runtime,previous_runtime=None,app='/Applications/ChatGPT.app')
                 ws.close();time.sleep(0.05)
             except (OSError,PackError):time.sleep(0.05)
         else:raise PackError('Desktop did not render after reconnect; run recover')
-        return {'state':'same-window-verified','app':str(app),'targetId':target_id,'desktopPid':bridge['desktopPid'],'frontendVerified':True,'windowClosed':False,'catalog':proof,'renderedTitles':sidebar,'renderedThreadIds':sorted(shown),'selectedThreadId':selected}
+        return {'state':'same-window-verified','app':str(app),'targetId':target_id,'desktopPid':bridge['desktopPid'],'frontendVerified':True,'windowClosed':False,'catalog':proof,'renderedTitles':sidebar,'renderedThreadIds':sorted(shown),'selectedThreadId':selected,'sidebarBinding':sidebar_binding,'sectionsRenderedVerified':False}
     finally:ws.close()
 
+def reconcile_desktop_catalog(lib,home,runtime):
+    """Drop obsolete derived local catalog rows before an offline cold launch.
+
+    Native transcripts and the timeline ledger are never changed. A complete
+    SQLite backup makes cache repair recoverable; cloud/remote hosts stay intact.
+    """
+    from . import native
+    path=home/'sqlite/codex-dev.db'
+    if not path.exists():return
+    if path.is_symlink() or path.stat().st_uid!=os.getuid():
+        raise PackError('Unowned desktop catalog')
+    native.assert_idle(home)
+    state=pathlib.Path(runtime)/'home/state_5.sqlite'
+    with closing(sqlite3.connect('file:'+str(state)+'?mode=ro',uri=True)) as db:
+        active={r[0] for r in db.execute('SELECT id FROM threads WHERE archived=0')}
+    with closing(sqlite3.connect(path)) as db:
+        tables={r[0] for r in db.execute("SELECT name FROM sqlite_master WHERE type='table'")}
+        if 'local_thread_catalog' not in tables:
+            return
+        stale=[r[0] for r in db.execute("SELECT thread_id FROM local_thread_catalog WHERE host_id='local'") if r[0] not in active]
+        if not stale:
+            return
+        folder=lib.root/'catalog-recovery';folder.mkdir(exist_ok=True,mode=0o700)
+        backup=folder/(uuid.uuid4().hex+'.sqlite')
+        with closing(sqlite3.connect(backup)) as saved:db.backup(saved)
+        backup.chmod(0o600)
+        with db:
+            db.executemany("DELETE FROM local_thread_catalog WHERE host_id='local' AND thread_id=?",[(v,) for v in stale])
+            for table in ['local_thread_catalog_sync_state','local_thread_catalog_scan_checkpoints','local_thread_catalog_scan_entries']:
+                if table in tables:db.execute('DELETE FROM '+table+" WHERE host_id='local'")
+            if 'local_thread_catalog_metadata' in tables:db.execute('UPDATE local_thread_catalog_metadata SET catalog_revision=catalog_revision+1 WHERE id=1')
+        atomic_json(backup.with_suffix('.json'),{'boundary':'derived desktop catalog only','runtime':str(runtime),'removedIds':stale,'retainedActiveIds':sorted(active),'backup':str(backup),'nativeHistoryChanged':False})
+
 def prepare(lib,real):
     home=lib.root/'desktop-home'
     if home.exists() and not (lib.root/'desktop-layout.json').exists():raise PackError('Existing desktop-home is unowned; choose a separate pack library')
@@ -1962,7 +2216,20 @@ def prepare(lib,real):
     home.mkdir(exist_ok=True,mode=0o700)
     atomic_json(lib.root/'desktop-layout.json',{'owner':'topolo-agent-pack','schemaVersion':1})
     bind(lib,lib.active()['runtime'])
-    if not (home/'.codex-global-state.json').exists():atomic_json(home/'.codex-global-state.json',read_json(pathlib.Path(lib.active()['runtime'])/'home/.codex-global-state.json'))
+    reconcile_desktop_catalog(lib,home,lib.active()['runtime'])
+    # The control home outlives a selected runtime. Its cached sidebar must
+    # follow that runtime on every cold launch, rather than only its first one.
+    state_path=home/'.codex-global-state.json'
+    current=read_json(state_path,{})
+    runtime=str(lib.active()['runtime'])
+    if current.get('topolo-selected-runtime')==runtime:return executable,home
+    selected=read_json(pathlib.Path(lib.active()['runtime'])/'home/.codex-global-state.json')
+    for key in ['pinned-thread-ids','thread-titles','thread-workspace-root-hints']:
+        current[key]=selected.get(key,{} if key!='pinned-thread-ids' else [])
+    current['electron-persisted-atom-state']={**current.get('electron-persisted-atom-state',{}),**selected.get('electron-persisted-atom-state',{})}
+    current.pop('app-server-migrated-pinned-thread-ids-by-host',None)
+    current['topolo-selected-runtime']=runtime
+    atomic_json(state_path,current)
     return executable,home
 
 def bind(lib,runtime):