rnxsim 0.1.451 → 0.1.453

package/cli/bridge-flow-runner.ts

@@ -6,10 +6,12 @@ import {
   REQUIRED_IDENTICAL_PROOF_FRAMES,
   framesIdentical,
 } from '../detox/proof-frame.cjs'
+import { flowTimeoutScale } from '../src/flow-timeout-scale'
 import { composeFramedScreenshot } from '../src/screenshots/frame-compose'
 import { inspectWaitReady, waitReadyReason } from './commands/inspect/core'
 import { waitForSootsimIdle } from './commands/inspect/settling'
 import { callShellCommandWhenReady, getShellState } from './commands/inspect/shared'
+import { saveCurrentSimId } from './current-sim'
 import { FlowLiveStatusReporter } from './flow-live-status'
 import { MaestroJsContext, scriptConditionIsTruthy } from './maestro-js'
 import { ensureCliRecordingEntitlement } from './recording-access'
@@ -21,16 +23,7 @@ import type {
 } from '@rnx/globals'
 
 const DEFAULT_TIMEOUT = 10000
-// hosted-runner previews reach first-render much slower than local dev: the
-// guest bundle (often 20+ MB) re-evals and re-hydrates on every launchApp hard
-// reload, and it is served over a cloudflared tunnel. SOOTSIM_FLOW_TIMEOUT_SCALE
-// multiplies every flow wait deadline so a slow-but-working app clears its own
-// `.maestro` waits without editing per-app timeouts. off (1x) locally; run.sh
-// sets it for the recording lane. clamped to 1..10.
-const FLOW_TIMEOUT_SCALE = Math.min(
-  10,
-  Math.max(1, Number(process.env.SOOTSIM_FLOW_TIMEOUT_SCALE) || 1),
-)
+const FLOW_TIMEOUT_SCALE = flowTimeoutScale()
 const scaledTimeout = (ms: number) => Math.round(ms * FLOW_TIMEOUT_SCALE)
 const SCREEN_W = 393
 const SCREEN_H = 852
@@ -496,11 +489,39 @@ export class SootSimBridgeFlowRunner {
   }
 
   async waitForTree(timeout: number = DEFAULT_TIMEOUT) {
-    const status = await inspectWaitReady(this.bridge, scaledTimeout(timeout))
+    let status = await inspectWaitReady(this.bridge, scaledTimeout(timeout))
     if (status.ready) return
     if (status.externalError) {
       throw new Error(`app failed to load: ${status.externalError}`)
     }
+    if (status.bridgeError) {
+      // the guest re-registers under a new sim id whenever its page reloads,
+      // and every command here pins this.opts.simId, so a reload strands the
+      // whole flow on a disposed render host. re-pin to the same browser
+      // host's successor and read the tree again before calling it dead.
+      // the successor does not appear the instant the old sim is disposed —
+      // the page has to finish reloading and re-register — so give it the same
+      // budget the rest of the flow waits on rather than looking exactly once.
+      const pinned = this.opts.simId
+      let successor: string | null = null
+      if (pinned) {
+        const deadline = Date.now() + scaledTimeout(15000)
+        do {
+          successor = await this.bridge.resolveReloadedSim(pinned)
+          if (successor) break
+          await sleep(500)
+        } while (Date.now() < deadline)
+      }
+      if (successor) {
+        console.error(
+          `  note: sim ${pinned} reloaded and reconnected as ${successor}; following it`,
+        )
+        this.opts.simId = successor
+        saveCurrentSimId(successor)
+        status = await inspectWaitReady(this.bridge, scaledTimeout(timeout))
+        if (status.ready) return
+      }
+    }
     if (status.bridgeError) {
       throw new Error(
         `target sim is not responding to the bridge (${status.bridgeError}). ` +
@@ -1989,7 +2010,9 @@ export class SootSimBridgeFlowRunner {
       strict: true,
     })
     if (!result.settled) {
-      throw new Error(`visual state did not settle within ${result.elapsed}ms`)
+      throw new Error(
+        `visual state did not settle within ${result.elapsed}ms (${result.blockedBy})`,
+      )
     }
   }
 
@@ -2290,7 +2313,12 @@ export class SootSimBridgeFlowRunner {
         step.runFlow ||
         // runScript http calls are synchronous with a 5-minute upstream
         // timeout — the 10s watchdog would kill legitimate setup scripts.
-        step.runScript
+        step.runScript ||
+        // takeScreenshot self-governs: it retries a bounded visual settle that
+        // already fails with its own reason. sharing the watchdog's 10s budget
+        // meant the watchdog always won that race, reporting "bridge probably
+        // hung" for a screen that was merely still animating.
+        step.takeScreenshot
       )
       const STEP_WATCHDOG_MS = 10_000
       const body = this.runStepInner(step)

package/cli/cloud-client.ts

@@ -1001,6 +1001,11 @@ class CloudBridge implements WsBridge {
     return Promise.reject(new Error('remote simulators have no browser window to focus'))
   }
 
+  resolveReloadedSim(): Promise<string | null> {
+    // cloud sims carry no local browser host, so there is no lineage to follow
+    return Promise.resolve(null)
+  }
+
   closeSim(): Promise<never> {
     return Promise.reject(
       new Error('remote simulator close uses the simulator DELETE route'),
@@ -1091,6 +1096,11 @@ class CloudBoxBridge implements WsBridge {
     return Promise.reject(new Error('a box simulator has no browser window to focus'))
   }
 
+  resolveReloadedSim(): Promise<string | null> {
+    // cloud sims carry no local browser host, so there is no lineage to follow
+    return Promise.resolve(null)
+  }
+
   closeSim(): Promise<never> {
     return Promise.reject(new Error('close a box simulator with rnx box stop'))
   }

package/cli/commands/control.ts

@@ -22,6 +22,7 @@ import {
   resolveConnectionInput,
   type ResolvedDevBundle,
 } from '../../src/dev-bundle-resolution'
+import { flowTimeoutScale } from '../../src/flow-timeout-scale'
 import {
   isDaemonLockfileFresh,
   isDevBridgeLockfileFresh,
@@ -844,10 +845,21 @@ async function waitForSimReady(
     minNodeCount?: number
   } = {},
 ) {
-  const attempts = opts.attempts ?? 30
+  // the ceiling here is attempts * intervalMs. a hosted launchApp re-evals the
+  // whole guest bundle over a tunnel, which routinely outlasts the local
+  // default, so scale the poll ceiling by the same factor the flow runner
+  // scales its own waits. this still returns the moment the sim reports enough
+  // nodes; only the deadline moves, and locally the scale is 1.
   const intervalMs = opts.intervalMs ?? 500
+  const attempts = opts.attempts ?? Math.round(30 * flowTimeoutScale())
   const minNodeCount = opts.minNodeCount ?? 10
 
+  // a poll that only ever reports "timed out" cannot say whether the guest was
+  // still booting, never installed the test hook, or was unreachable, so keep
+  // the last observation and hand it to the caller for the failure message.
+  let lastCount: unknown
+  let lastError = ''
+
   for (let i = 0; i < attempts; i++) {
     const bridge = createBridge(wsPort, {
       commandTimeoutMs,
@@ -857,19 +869,21 @@ async function waitForSimReady(
     try {
       const count = await bridge.send({
         type: 'evaluate',
-        code: '(async () => (await window.__sootsimTest?.getNodeCount()) || 0)()',
+        code: '(async () => (await window.__sootsimTest?.getNodeCount()) ?? null)()',
       })
+      lastCount = count
+      lastError = ''
       if (typeof count === 'number' && count > minNodeCount) {
         return { bridge, count }
       }
-    } catch {
-      // still loading or disconnected
+    } catch (err) {
+      lastError = err instanceof Error ? err.message : String(err)
     }
     bridge.close()
     await sleep(intervalMs)
   }
 
-  return null
+  return { bridge: null, attempts, intervalMs, minNodeCount, lastCount, lastError }
 }
 
 export async function waitForSimMatch(
@@ -1511,6 +1525,7 @@ export async function runOpenCommand(
     const bridge = createBridgeFromParsed(parsed)
     const simHint = parsed.simId ? ` --sim ${parsed.simId}` : ''
     let fallBackToNewSim = false
+    let preNavSimIds = new Set<string>()
 
     try {
       let targetSim: BridgeSimInfo | null = null
@@ -1570,6 +1585,11 @@ export async function runOpenCommand(
           }
         }
         if (!fallBackToNewSim && targetSim) {
+          // a navigation that crosses origins tears down the page context, so
+          // the guest reconnects as a NEW sim and the id we are holding stops
+          // existing. record what was connected first, so the wait below can
+          // follow the reload instead of polling an id the browser retired.
+          preNavSimIds = new Set(sims.map((sim) => sim.id))
           const resolvedBaseUrl =
             hasExplicitBaseUrl || looksLikeSootsimUrl(target)
               ? baseUrl
@@ -1603,13 +1623,38 @@ export async function runOpenCommand(
 
       if (!fallBackToNewSim && targetSim) {
         await sleep(1500)
+        const navSim = targetSim
+        const reloadedSim = await waitForSimMatch(
+          parsed.wsPort,
+          parsed.commandTimeoutMs,
+          (sim) =>
+            sim.readyState === 'open' &&
+            simUsesDriver(sim, driverId) &&
+            (sim.id === navSim.id || (!preNavSimIds.has(sim.id) && sim.isPrimary)),
+          { attempts: Math.round(30 * flowTimeoutScale()) },
+        )
+        if (reloadedSim && reloadedSim.id !== navSim.id) {
+          targetSim = reloadedSim
+        }
         const ready = await waitForSimReady(
           parsed.wsPort,
           parsed.commandTimeoutMs,
           targetSim.id,
         )
-        if (!ready) {
-          console.error('  timed out waiting for current sim to load target')
+        if (!ready.bridge) {
+          const observed = ready.lastError
+            ? `last bridge error: ${ready.lastError}`
+            : ready.lastCount === null
+              ? 'guest never installed window.__sootsimTest'
+              : `last node count: ${String(ready.lastCount)} (needs > ${ready.minNodeCount})`
+          console.error(
+            `  timed out waiting for current sim to load target after ${ready.attempts} polls over ${Math.round((ready.attempts * ready.intervalMs) / 1000)}s; ${observed}`,
+          )
+          await printBridgeFailureDiagnostics(bridge, {
+            errorsCommand: `rnx get errors 5${simHint}`,
+            warningsCommand: `rnx get warnings 5${simHint}`,
+            requestsCommand: `rnx get requests 5${simHint}`,
+          })
           rnxExit(1)
         }
         ready.bridge.close()

package/cli/commands/debug.ts

@@ -28,6 +28,7 @@ import {
   type WsBridge,
 } from '../ws-bridge'
 import {
+  callDebugBridge,
   inspectDebugFind,
   inspectDebugFlags,
   inspectDebugRecent,
@@ -63,15 +64,19 @@ rnx debug — drive __sootsimDebug from the terminal
 usage:
   rnx debug <subcommand> [args]
 
+  record, recent, and clear-events target the tenant; --host selects the page buffer.
+  enable/disable/toggle also update the tenant unless --host is passed.
+  shell event buffers are separate; shell console logs are forwarded to the host.
+
 subcommands:
-  enable <channels>       turn on one or more debug channels
+  enable <channels>       turn on host, shell/compositor, and tenant channels
                           channels: ${KNOWN_CHANNELS.slice(0, -1).join(', ')}
                           or 'all' for every channel
   disable <channels>      turn off one or more debug channels (or 'all')
   toggle <channel>        flip a single channel
-  status                  list currently-enabled channels
+  status                  list host channels forwarded to shell/compositor
   channels                list every known channel name
-  flags                   print the full DEBUG flag object
+  flags                   print the host DEBUG flag object
 
   state <kind> ...        dump raw runtime state (diagnostic — not a getter)
                           kinds: shell, worker, keyboard, node <id>,
@@ -393,7 +398,7 @@ function printImageAudit(
 export async function runDebug(args: string[], opts: DebugOptions) {
   const parsed = parseBridgeCliArgs(args, {
     port: opts.port,
-    stripBooleanFlags: ['--pretty', '--json', '--help', '-h'],
+    stripBooleanFlags: ['--pretty', '--json', '--help', '-h', '--host'],
   })
   const positional = parsed.positional
   const subcommand = positional[0]
@@ -441,14 +446,24 @@ export async function runDebug(args: string[], opts: DebugOptions) {
           )
           rnxExit(1)
         }
-        const active = await setDebugChannels(bridge, 'enable', channels)
+        const active = await setDebugChannels(
+          bridge,
+          'enable',
+          channels,
+          args.includes('--host'),
+        )
         console.log(fmt({ active }, pretty))
         break
       }
 
       case 'disable': {
         const channels = parseChannelList(rest[0])
-        const active = await setDebugChannels(bridge, 'disable', channels)
+        const active = await setDebugChannels(
+          bridge,
+          'disable',
+          channels,
+          args.includes('--host'),
+        )
         console.log(fmt({ active }, pretty))
         break
       }
@@ -459,10 +474,17 @@ export async function runDebug(args: string[], opts: DebugOptions) {
           console.error('  usage: rnx debug toggle <channel>')
           rnxExit(1)
         }
-        const result = await call(
+        const result = await callDebugBridge(
           bridge,
-          `window.__sootsimDebug.toggle(${JSON.stringify(channel)})`,
+          `toggle(${JSON.stringify(channel)})`,
+          true,
         )
+        if (!args.includes('--host')) {
+          await callDebugBridge(
+            bridge,
+            `${result ? 'enable' : 'disable'}(${JSON.stringify(channel)})`,
+          )
+        }
         console.log(fmt({ [channel]: result }, pretty))
         break
       }
@@ -681,7 +703,11 @@ export async function runDebug(args: string[], opts: DebugOptions) {
       case 'record': {
         const target = rest[0]
         const on = target === 'on' ? 'true' : target === 'off' ? 'false' : 'undefined'
-        const result = await call(bridge, `window.__sootsimDebug.record(${on})`)
+        const result = await callDebugBridge(
+          bridge,
+          `record(${on})`,
+          args.includes('--host'),
+        )
         console.log(fmt({ recording: result }, pretty))
         break
       }
@@ -689,13 +715,18 @@ export async function runDebug(args: string[], opts: DebugOptions) {
       case 'recent': {
         const channel = rest[0]
         const limit = rest[1] ? Number(rest[1]) : 50
-        const result = await inspectDebugRecent(bridge, channel, limit)
+        const result = await inspectDebugRecent(
+          bridge,
+          channel,
+          limit,
+          args.includes('--host'),
+        )
         console.log(fmt(result, pretty))
         break
       }
 
       case 'clear-events': {
-        await call(bridge, 'window.__sootsimDebug.clearEvents()')
+        await callDebugBridge(bridge, 'clearEvents()', args.includes('--host'))
         console.log(fmt({ cleared: true }, pretty))
         break
       }

package/cli/commands/inspect/core.ts

@@ -1767,26 +1767,46 @@ export async function inspectDebugFind(
   })
 }
 
-// `debug recent` — recent debug events, optionally filtered to one channel.
-// only channels enabled via `setDebugChannels` record events.
+// debug buffers belong to their execution context. tenant calls use the
+// existing test bridge; host calls keep shell/compositor flag forwarding intact.
+export async function callDebugBridge(
+  bridge: InspectBridge,
+  expression: string,
+  host = false,
+): Promise<unknown> {
+  const code = `globalThis.__sootsimDebug.${expression}`
+  if (host) return bridge.send({ type: 'evaluate', code })
+  return bridge.send({
+    type: 'evaluate',
+    code: `(async () => {
+      const result = await window.__sootsimTest.evalInTenant(${JSON.stringify(code)})
+      if (!result.ok) throw new Error(result.error)
+      return result.value
+    })()`,
+  })
+}
+
+// `debug recent` reads tenant events; --host explicitly selects the page buffer.
 export async function inspectDebugRecent(
   bridge: InspectBridge,
   channel?: string,
   limit = 50,
+  host = false,
 ): Promise<unknown> {
-  const code =
-    channel && channel !== 'all'
-      ? `window.__sootsimDebug.recent(${JSON.stringify(channel)}, ${limit})`
-      : `window.__sootsimDebug.recent(undefined, ${limit})`
-  return bridge.send({ type: 'evaluate', code })
+  return callDebugBridge(
+    bridge,
+    `recent(${channel && channel !== 'all' ? JSON.stringify(channel) : 'undefined'}, ${limit})`,
+    host,
+  )
 }
 
-// `debug enable|disable <channels>` — turn debug channels on or off. returns
-// the resulting active-channel set. an empty list with `disable` clears all.
+// channel controls reach the host (and its shell/compositor subscribers) plus
+// the active tenant. await the tenant reply before reporting success.
 export async function setDebugChannels(
   bridge: InspectBridge,
   action: 'enable' | 'disable',
   channels: string[],
+  host = false,
 ): Promise<unknown> {
   const args =
     channels.length > 0
@@ -1794,10 +1814,10 @@ export async function setDebugChannels(
       : action === 'disable'
         ? "'all'"
         : ''
-  return bridge.send({
-    type: 'evaluate',
-    code: `window.__sootsimDebug.${action}(${args})`,
-  })
+  const expression = `${action}(${args})`
+  const active = await callDebugBridge(bridge, expression, true)
+  if (host) return active
+  return callDebugBridge(bridge, expression)
 }
 
 // ─── memory ───

package/cli/commands/inspect/settling.ts

@@ -12,6 +12,10 @@ export type WaitForSootsimIdleOptions = {
 export type WaitForSootsimIdleResult = {
   elapsed: number
   settled: boolean
+  // what the last poll still saw moving. a settle that only reports "did not
+  // settle" cannot tell a slow screen from one that animates forever, and the
+  // two need opposite fixes.
+  blockedBy: string
 }
 
 export async function waitForSootsimIdle({
@@ -117,8 +121,19 @@ export async function waitForSootsimIdle({
       let lastRequestTotal = -1
       let stable = 0
       let visuallyStillSince = 0
+      // counts across the whole budget: a flag that is true on every poll is a
+      // different bug from one that is true intermittently, and the two need
+      // opposite fixes (engine vs budget).
+      let polls = 0
+      let dirtyPolls = 0
+      let animatingPolls = 0
+      let layoutChangedPolls = 0
       while (Date.now() < deadline) {
         const snapshot = await readSnapshot()
+        polls++
+        if (snapshot.layoutDirty) dirtyPolls++
+        if (snapshot.animating) animatingPolls++
+        if (polls > 1 && snapshot.layout !== lastLayout) layoutChangedPolls++
         const strictOk =
           !strict ||
           (snapshot.renderStatsAvailable && !snapshot.animating && !snapshot.layoutDirty)
@@ -139,7 +154,7 @@ export async function waitForSootsimIdle({
             stable >= requiredStablePolls &&
             (networkQuiet || Date.now() - visuallyStillSince >= networkQuietGraceMs)
           ) {
-            return { settled: true, elapsed: Date.now() - start }
+            return { settled: true, elapsed: Date.now() - start, blockedBy: '' }
           }
         } else {
           stable = 0
@@ -149,7 +164,22 @@ export async function waitForSootsimIdle({
         lastRequestTotal = snapshot.requestTotal
         await sleep(pollMs)
       }
-      return { settled: false, elapsed: Date.now() - start }
+      const last = await readSnapshot()
+      const blockers = []
+      if (strict && !last.renderStatsAvailable) blockers.push('render stats unavailable')
+      if (last.animating) blockers.push('animations still running')
+      if (last.layoutDirty) blockers.push('layout still dirty')
+      if (last.pendingFetches > 0) blockers.push(last.pendingFetches + ' image fetches pending')
+      if (last.layout !== lastLayout) blockers.push('layout still changing')
+      if (last.requestInFlight > 0) blockers.push(last.requestInFlight + ' requests in flight')
+      return {
+        settled: false,
+        elapsed: Date.now() - start,
+        blockedBy:
+          (blockers.length ? blockers.join(', ') : 'unknown') +
+          ' over ' + polls + ' polls (layout changed ' + layoutChangedPolls +
+          'x, layoutDirty ' + dirtyPolls + 'x, animating ' + animatingPolls + 'x)',
+      }
     })()`,
     },
     {
@@ -157,9 +187,11 @@ export async function waitForSootsimIdle({
     },
   )
 
-  const { elapsed, settled } = (result ?? {}) as Partial<WaitForSootsimIdleResult>
+  const { elapsed, settled, blockedBy } = (result ??
+    {}) as Partial<WaitForSootsimIdleResult>
   return {
     elapsed: typeof elapsed === 'number' ? elapsed : maxMs,
     settled: settled === true,
+    blockedBy: typeof blockedBy === 'string' ? blockedBy : 'unknown',
   }
 }

package/cli/drivers/playwright.ts

@@ -16,6 +16,7 @@ import { spawn } from 'child_process'
 import { closeSync, mkdtempSync, openSync, readFileSync } from 'fs'
 import { tmpdir } from 'os'
 import { join } from 'path'
+import { playwrightHostLogName } from '../../src/playwright-host-log'
 import { ensureProfile, playwrightProfileUserDataDir } from '../../src/profiles'
 import { RNX_INTERNAL_CHILDREN, RNX_INTERNAL_COMMAND } from '../internal-child'
 import { getProcessComm } from '../parent-pid'
@@ -102,10 +103,7 @@ async function launch(opts: DriverLaunchOptions): Promise<DriverLaunchResult> {
     }
   }
 
-  const errLog = join(
-    tmpdir(),
-    `rnx-playwright-host-${Date.now().toString(36)}-${process.pid}.log`,
-  )
+  const errLog = join(tmpdir(), playwrightHostLogName(Date.now(), process.pid))
   const connectAckFile = `${errLog}.connected`
   const errFd = openSync(errLog, 'a')
   try {

package/cli/ws-bridge.ts

@@ -28,6 +28,7 @@ import {
   getCliIdentity,
   readCurrentSim,
   readCurrentSimId,
+  saveCurrentSimId,
 } from './current-sim'
 
 // --- bridge world resolution ---------------------------------------------
@@ -323,6 +324,10 @@ export interface WsBridge {
     opts?: { timeoutMs?: number },
   ): Promise<any>
   listSims(): Promise<BridgeSimInfo[]>
+  // a guest reload retires the sim id and re-registers the same page under a
+  // new one. a caller that pins an id resolves the successor here; null means
+  // nothing proves what replaced it.
+  resolveReloadedSim(retiredSimId: string): Promise<string | null>
   focusSim(simId?: string): Promise<any>
   closeSim(simId?: string): Promise<any>
   claim(simId?: string, opts?: { force?: boolean }): Promise<BridgeClaimResult>
@@ -611,6 +616,24 @@ export function createBridge(wsPort: number, opts: WsBridgeOptions = {}): WsBrid
 
   let warnedAboutContention = false
   let noticedTarget = false
+  // the browser host behind the current pin, learned while the pinned sim is
+  // still connected. a reload changes the sim id but not the host.
+  let pinnedHostPid: number | null = null
+  let lineageLookupInFlight = false
+
+  // a reload retires the sim id but keeps the browser host, so a successor
+  // sharing that host pid IS the same page lineage rather than a guess. only
+  // an unambiguous match counts; callers fail closed on null.
+  function pickReloadedSuccessor(sims: unknown, retiredSimId: string): string | null {
+    if (pinnedHostPid === null) return null
+    const successors = (Array.isArray(sims) ? (sims as BridgeSimInfo[]) : []).filter(
+      (sim) =>
+        sim.id !== retiredSimId &&
+        sim.readyState === 'open' &&
+        sim.meta?.sootsimHostPid === pinnedHostPid,
+    )
+    return successors.length === 1 ? successors[0].id : null
+  }
 
   // print a one-line notice on first sim-scoped command so agents/users see
   // which sim the command actually hit. suppressed for bridge:*
@@ -682,7 +705,10 @@ export function createBridge(wsPort: number, opts: WsBridgeOptions = {}): WsBrid
       // NOTE: `opts` (the createBridge closure arg) carries simId; do not
       // shadow it with the per-call arg.
       const effectiveTimeoutMs = callOpts?.timeoutMs ?? commandTimeoutMs
-      const sendOnce = async (defaultSimId?: string) => {
+      const sendOnce = async (
+        defaultSimId?: string,
+        cmdOverride?: Record<string, any>,
+      ) => {
         await ready
         const id = nextId++
         return new Promise((resolve, reject) => {
@@ -706,7 +732,7 @@ export function createBridge(wsPort: number, opts: WsBridgeOptions = {}): WsBrid
             },
           })
 
-          const payload = { ...cmd, id } as Record<string, any>
+          const payload = { ...(cmdOverride ?? cmd), id } as Record<string, any>
           if (payload.simId === undefined && defaultSimId) {
             payload.simId = defaultSimId
           }
@@ -725,7 +751,26 @@ export function createBridge(wsPort: number, opts: WsBridgeOptions = {}): WsBrid
       const sentSimId =
         opts.simIdSource === 'flag' ? opts.simId : (readCurrentSimId() ?? opts.simId)
       try {
-        return await sendOnce(sentSimId)
+        const result = await sendOnce(sentSimId)
+        // the guest re-registers under a NEW sim id whenever its page reloads,
+        // so remember which browser host is behind the pin while it still
+        // exists. that lineage is what lets the fail-closed path below follow
+        // the reload without ever guessing at an unrelated sim.
+        if (sentSimId && pinnedHostPid === null && !lineageLookupInFlight) {
+          lineageLookupInFlight = true
+          void sendOnce(undefined, { type: 'bridge:list-sims' })
+            .then((sims) => {
+              if (!Array.isArray(sims)) return
+              const pinned = (sims as BridgeSimInfo[]).find((sim) => sim.id === sentSimId)
+              const hostPid = pinned?.meta?.sootsimHostPid
+              if (typeof hostPid === 'number') pinnedHostPid = hostPid
+            })
+            .catch(() => {})
+            .finally(() => {
+              lineageLookupInFlight = false
+            })
+        }
+        return result
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error)
         const missingSimMessage = `no sim connected with id ${sentSimId}`
@@ -735,9 +780,24 @@ export function createBridge(wsPort: number, opts: WsBridgeOptions = {}): WsBrid
           cmd.simId === undefined &&
           (message === missingSimMessage || message.startsWith(`${missingSimMessage};`))
         ) {
+          // a reload retires the sim id but keeps the browser host, so the
+          // successor with the same host pid IS the same page lineage — not a
+          // guess. adopt only that, and only when it is unambiguous.
+          const successor = pickReloadedSuccessor(
+            await sendOnce(undefined, { type: 'bridge:list-sims' }),
+            sentSimId,
+          )
+          if (successor) {
+            saveCurrentSimId(successor)
+            process.stderr.write(
+              `  note: sim ${sentSimId} reloaded and reconnected as ${successor}; following it\n`,
+            )
+            return sendOnce(successor)
+          }
           clearCurrentSimId()
-          // the saved sim is gone. fail closed instead of driving whichever
-          // sim is primary; that is how agents end up recording the wrong app.
+          // the saved sim is gone and nothing proves what replaced it. fail
+          // closed instead of driving whichever sim is primary; that is how
+          // agents end up recording the wrong app.
           throw new Error(
             `saved sim ${sentSimId} is gone${message.slice(missingSimMessage.length)}; ` +
               'run `rnx list` and ' +
@@ -751,6 +811,13 @@ export function createBridge(wsPort: number, opts: WsBridgeOptions = {}): WsBrid
       const sims = await this.send({ type: 'bridge:list-sims' })
       return Array.isArray(sims) ? (sims as BridgeSimInfo[]) : []
     },
+    // a caller holding its own pinned sim id (a flow runner sets simId on every
+    // command, so it never reaches the pin-following path in send) asks here
+    // after a reload retires that id. null means nothing proves what replaced
+    // it, and the caller must fail rather than guess.
+    async resolveReloadedSim(retiredSimId: string) {
+      return pickReloadedSuccessor(await this.listSims(), retiredSimId)
+    },
     async focusSim(simId?: string) {
       return this.send({ type: 'focus', simId })
     },

package/dist-lib/agent-daemon-client.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.451 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.453 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __create = Object.create;

package/dist-lib/agent-events.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.451 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.453 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __defProp = Object.defineProperty;