fix: tighten dogfood snapshot and session UX (#350)

* fix: tighten dogfood snapshot and session UX

* fix: improve iOS simulator network dump recovery

* fix: honor simulator device set in iOS log recovery

Author: thymikee

skills/agent-device/references/debugging.md

@@ -36,8 +36,11 @@ Logging is off by default. Enable it only when you need a debugging window.
 - Default app logs live under `~/.agent-device/sessions/<session>/app.log`.
 - `logs clear --restart` is the fastest clean repro loop.
 - `network dump [limit] [summary|headers|body|all]` parses recent HTTP(s) entries from the same session app log.
+- On iOS simulators, `network dump` can recover recent app log history with `simctl log show` when the live session stream is sparse, so check the returned notes before assuming the repro window was empty.
+- On iOS, `network dump` is still limited to what Unified Logging exposes for the app process. If the app does not emit request metadata there, `network dump` can legitimately return no HTTP entries even during a real repro.
 - Summary output already shows timestamp, status, and duration when the log backend exposes them.
 - Prefer the explicit flag form `network dump 25 --include headers|body|all` when you need more than the default summary view.
+- If iOS simulator notes say app logs were recovered but none looked like HTTP traffic, treat that as an app instrumentation gap rather than a missing repro and inspect `logs path` for the non-network diagnostics that were captured.
 - `logs doctor` checks backend and runtime readiness for the current session and device.
 - `logs mark "before tap"` inserts a timestamped marker into the app log.
 - Android `network dump` surfaces timestamps from logcat-style prefixes and can backfill status and request/response duration from adjacent GIBSDK packet lines, so check it before dumping raw log windows.
@@ -84,6 +87,7 @@ agent-device alert accept
 
 - `alert` is only supported on iOS simulators.
 - `alert accept` and `alert dismiss` retry internally for a short window, so you usually do not need manual sleeps.
+- If a permission sheet is visible in `snapshot` or `screenshot` but `alert accept` says no alert was found, treat it as normal tappable UI for that run: take a scoped `snapshot -i -s "<visible label>"` and `press @ref` instead of looping on `alert`.
 - iOS 16+ "Allow Paste" prompts are suppressed under XCUITest. Use `xcrun simctl pbcopy booted` when you need to seed simulator clipboard content directly.
 
 ## Setup problems worth recognizing early

skills/agent-device/references/exploration.md

@@ -90,6 +90,7 @@ agent-device close
 - On iOS and Android, default snapshot output is visible-first. Off-screen interactive content is surfaced as discovery hints (including inline scroll/list hidden-content hints when known), not shown as directly tappable refs.
 - Treat large text-surface lines in `snapshot -i` as discovery output. If a node shows preview or truncation metadata, use `get text @ref` only after you have already decided that `snapshot -i` is needed for that surface.
 - Use `snapshot -i -s "Camera"` or `snapshot -i -s @e3` when you want a smaller, scoped result.
+- If `snapshot -i -s "<query>"` returns 0 nodes, the scope did not match the current screen. Widen the query or re-check the screen state instead of assuming the command silently fell back to the full tree.
 - If `snapshot -i` returns 0 nodes but the screen is visibly populated, treat `screenshot` as visual truth, wait briefly, then re-run `snapshot -i` once before escalating.
 - If `snapshot -i -d <n>` says the interactive output is empty at that depth, retry without `-d` instead of taking more shallow snapshots.
 

src/daemon/__tests__/app-log.test.ts

@@ -9,6 +9,7 @@ import {
   assertAndroidPackageArgSafe,
   buildAppleLogPredicate,
   buildIosDeviceLogStreamArgs,
+  buildIosSimulatorLogStreamArgs,
   clearAppLogFiles,
   cleanupStaleAppLogProcesses,
   getAppLogPathMetadata,
@@ -22,7 +23,7 @@ test('buildAppleLogPredicate includes bundle-aware filters', () => {
   assert.match(predicate, /subsystem == "com\.example\.app"/);
   assert.match(predicate, /processImagePath ENDSWITH\[c\] "\/com\.example\.app"/);
   assert.match(predicate, /senderImagePath ENDSWITH\[c\] "\/com\.example\.app"/);
-  assert.match(predicate, /eventMessage CONTAINS\[c\] "com\.example\.app"/);
+  assert.doesNotMatch(predicate, /eventMessage CONTAINS\[c\] "com\.example\.app"/);
 });
 
 test('assertAndroidPackageArgSafe rejects unsafe values', () => {
@@ -92,6 +93,50 @@ test('buildIosDeviceLogStreamArgs builds expected devicectl command args', () =>
   ]);
 });
 
+test('buildIosSimulatorLogStreamArgs streams logs inside the simulator at info level', () => {
+  assert.deepEqual(
+    buildIosSimulatorLogStreamArgs({ deviceId: 'sim-1', appBundleId: 'com.example.app' }),
+    [
+      'simctl',
+      'spawn',
+      'sim-1',
+      'log',
+      'stream',
+      '--style',
+      'compact',
+      '--level',
+      'info',
+      '--predicate',
+      buildAppleLogPredicate('com.example.app'),
+    ],
+  );
+});
+
+test('buildIosSimulatorLogStreamArgs respects simulator device set scoping', () => {
+  assert.deepEqual(
+    buildIosSimulatorLogStreamArgs({
+      deviceId: 'sim-1',
+      appBundleId: 'com.example.app',
+      simulatorSetPath: '/tmp/tenant-a/simulators',
+    }),
+    [
+      'simctl',
+      '--set',
+      '/tmp/tenant-a/simulators',
+      'spawn',
+      'sim-1',
+      'log',
+      'stream',
+      '--style',
+      'compact',
+      '--level',
+      'info',
+      '--predicate',
+      buildAppleLogPredicate('com.example.app'),
+    ],
+  );
+});
+
 test('cleanupStaleAppLogProcesses removes legacy plain pid files safely', () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-app-log-clean-legacy-'));
   const sessionDir = path.join(root, 'default');

src/daemon/__tests__/network-log.test.ts

@@ -129,6 +129,26 @@ test('readRecentNetworkTraffic keeps Android packet enrichment disabled for Appl
   assert.equal(dump.entries[0]?.durationMs, undefined);
 });
 
+test('readRecentNetworkTraffic ignores plain documentation URLs in non-network log messages', () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-network-log-'));
+  const logPath = path.join(tempDir, 'app.log');
+  fs.writeFileSync(
+    logPath,
+    '2026-04-02 08:14:44.371 E New Expensify Dev[32193:8c7e18d] Airship config warning. See https://docs.airship.com/platform/mobile/setup/sdk/ios/#url-allow-list for more information.\n',
+    'utf8',
+  );
+
+  const dump = readRecentNetworkTraffic(logPath, {
+    backend: 'ios-simulator',
+    maxEntries: 5,
+    include: 'summary',
+    maxPayloadChars: 2048,
+    maxScanLines: 100,
+  });
+
+  assert.equal(dump.entries.length, 0);
+});
+
 test('readRecentNetworkTraffic returns empty result when log file is missing', () => {
   const logPath = path.join(os.tmpdir(), 'agent-device-network-log-missing', 'app.log');
   const dump = readRecentNetworkTraffic(logPath, {

src/daemon/__tests__/request-lock-policy.test.ts

@@ -52,6 +52,28 @@ test('rejects fresh-session selector conflicts under request lock policy', () =>
   );
 });
 
+test('allows open to choose a fresh-session target under request lock policy', () => {
+  const req = applyRequestLockPolicy({
+    token: 'token',
+    session: 'qa-ios',
+    command: 'open',
+    positionals: ['Settings'],
+    flags: {
+      platform: 'ios',
+      device: 'iPhone 16',
+      udid: 'SIM-001',
+    },
+    meta: {
+      lockPolicy: 'reject',
+      lockPlatform: 'ios',
+    },
+  });
+
+  assert.equal(req.flags?.platform, 'ios');
+  assert.equal(req.flags?.device, 'iPhone 16');
+  assert.equal(req.flags?.udid, 'SIM-001');
+});
+
 test('strips fresh-session selector conflicts and restores lock platform', () => {
   const req = applyRequestLockPolicy({
     token: 'token',

src/daemon/app-log-ios.ts

@@ -1,5 +1,7 @@
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
+import { buildSimctlArgs } from '../platforms/ios/simctl.ts';
+import { runCmd } from '../utils/exec.ts';
 import { clearPidFile, writePidFile, type AppLogResult } from './app-log-process.ts';
 import { attachChildToStream, createLineWriter, waitForChildExit } from './app-log-stream.ts';
 
@@ -8,24 +10,96 @@ export function buildAppleLogPredicate(appBundleId: string): string {
     `subsystem == "${appBundleId}"`,
     `processImagePath ENDSWITH[c] "/${appBundleId}"`,
     `senderImagePath ENDSWITH[c] "/${appBundleId}"`,
-    `eventMessage CONTAINS[c] "${appBundleId}"`,
   ].join(' OR ');
 }
 
+export function buildIosSimulatorLogStreamArgs(params: {
+  deviceId: string;
+  appBundleId: string;
+  simulatorSetPath?: string;
+}): string[] {
+  const { deviceId, appBundleId, simulatorSetPath } = params;
+  return buildSimctlArgs(
+    [
+      'spawn',
+      deviceId,
+      'log',
+      'stream',
+      '--style',
+      'compact',
+      '--level',
+      'info',
+      '--predicate',
+      buildAppleLogPredicate(appBundleId),
+    ],
+    { simulatorSetPath },
+  );
+}
+
 export function buildIosDeviceLogStreamArgs(deviceId: string): string[] {
   return ['devicectl', 'device', 'log', 'stream', '--device', deviceId];
 }
 
+export async function readRecentIosSimulatorLogShowForBundle(params: {
+  deviceId: string;
+  appBundleId: string;
+  startedAt?: number;
+  simulatorSetPath?: string;
+}): Promise<{ text: string; recoveredLineCount: number } | null> {
+  const { deviceId, appBundleId, startedAt, simulatorSetPath } = params;
+  const args = buildSimctlArgs(
+    [
+      'spawn',
+      deviceId,
+      'log',
+      'show',
+      '--style',
+      'compact',
+      '--info',
+      '--predicate',
+      buildAppleLogPredicate(appBundleId),
+    ],
+    { simulatorSetPath },
+  );
+  if (typeof startedAt === 'number' && Number.isFinite(startedAt) && startedAt > 0) {
+    args.push('--start', `@${Math.floor(startedAt / 1000)}`);
+  } else {
+    args.push('--last', '5m');
+  }
+  const result = await runCmd('xcrun', args, { allowFailure: true, timeoutMs: 4_000 });
+  if (result.exitCode !== 0 || result.stdout.trim().length === 0) {
+    return null;
+  }
+  const lines = result.stdout
+    .split('\n')
+    .map((line) => line.trimEnd())
+    .filter((line) => {
+      const trimmed = line.trim();
+      return (
+        trimmed.length > 0 && !trimmed.startsWith('Timestamp               Ty Process[PID:TID]')
+      );
+    });
+  if (lines.length === 0) {
+    return null;
+  }
+  return {
+    text: `${lines.join('\n')}\n`,
+    recoveredLineCount: lines.length,
+  };
+}
+
 export async function startIosSimulatorAppLog(
+  deviceId: string,
   appBundleId: string,
   stream: fs.WriteStream,
   redactionPatterns: RegExp[],
+  simulatorSetPath?: string,
   pidPath?: string,
 ): Promise<AppLogResult> {
   let state: 'active' | 'failed' = 'active';
   const child = spawn(
-    'log',
-    ['stream', '--style', 'compact', '--predicate', buildAppleLogPredicate(appBundleId)],
+    'xcrun',
+    buildIosSimulatorLogStreamArgs({ deviceId, appBundleId, simulatorSetPath }),
     {
       stdio: ['ignore', 'pipe', 'pipe'],
     },